Write the forge's name as OxygenHub in everything people read 092b8bf9f2ac

# Changelog

## 0.6.0

- A **Releases** view: each repository's releases with their assets and source archives, to open or download.

- A bell in the status bar with your unread notifications across every hub you are signed in to, and a message when new ones arrive (`oxygenhub.announceNotifications`).

- **Open Inbox**: your notifications, unread first; pick one to mark it read and open it, in the editor for proposals and issues of your workspace's repositories. Mark all as read from the top of the list.

## 0.2.0

- Proposals expand to their changed files. Click one to open it in VS Code's diff editor: the target's state against the projected state, straight from the hub, no checkout needed.

- **View Changes** on a proposal (inline button, or in the detail) opens every file in one multi-file diff editor.

- Review threads appear in those diff editors on the projected side, and new comments there are anchored to the line's atom on the hub.

## 0.1.2

the editor, built on the Oxygen extension the way the

GitHub Pull Requests extension builds on the built-in Git extension. The

specification is docs/spec.md in the repository.

| | |

|---|---|

| **Status** | Draft 0.1 |

| **Date** | 2026-09-27 |

## 1. Goals

## 2. How it compares

|---|---|

| Sign in with GitHub (OAuth) | Sign in with a personal access token; an authentication provider `oxygenhub` other extensions can request |

| Pull Requests view: waiting for my review, created by me, all | Proposals view: **Assigned to me** (review requested or approval needed), **Mine**, **Open**, per repository |

## 5. Proposals

**Detail** is a webview: description, blockers, approvals (sealed or pending), checks, the changes list with signatures, and buttons for the actions. **Check out** fetches from the hub remote and sets a local bookmark `proposal/N` to the projected heads, then switches to it, so the files in the editor are the projected state; review threads then appear in place.

## 8. Issues

### 8.1 Issues from the editor

{

  "name": "oxygenhub-vscode",

  "publisher": "andymccall",

  "license": "MIT OR Apache-2.0",

  "icon": "assets/images/oxygenhub.png",

    "authentication": [

      {

        "id": "oxygenhub",

      }

    ],

    "configuration": {

      "properties": {

        "oxygenhub.hubs": {

          "type": "array",

      "activitybar": [

        {

          "id": "oxygenhub",

          "icon": "assets/images/oxygenhub-activity.svg"

        }

      ]

    "viewsWelcome": [

      {

        "view": "oxygenhub.proposals",

      }

    ],

    "commands": [

      {

        "command": "oxygenhub.signIn",

        "title": "Sign in",

      },

      {

        "command": "oxygenhub.signOut",

        "title": "Sign out",

      },

      {

        "command": "oxygenhub.refresh",

        "title": "Refresh",

        "icon": "$(refresh)"

      },

      {

        "command": "oxygenhub.inbox",

        "title": "Open Inbox",

        "icon": "$(bell)"

      },

      {

        "command": "oxygenhub.openProposal",

        "title": "Open Proposal",

      },

      {

        "command": "oxygenhub.openOnHub",

        "title": "Open on Hub",

        "icon": "$(link-external)"

      },

      {

        "command": "oxygenhub.openProposalFile",

        "title": "Open Proposal File Diff",

      },

      {

        "command": "oxygenhub.openProposalChanges",

        "title": "View Changes",

        "icon": "$(diff-multiple)"

      },

      {

        "command": "oxygenhub.checkoutProposal",

        "title": "Check Out Proposal",

        "icon": "$(git-branch)"

      },

      {

        "command": "oxygenhub.review",

        "title": "Review\u2026",

        "icon": "$(comment-discussion)"

      },

      {

        "command": "oxygenhub.sealApproval",

        "title": "Seal My Approval (oxy seal --proposal)",

      },

      {

        "command": "oxygenhub.land",

        "title": "Land Proposal",

      },

      {

        "command": "oxygenhub.closeProposal",

        "title": "Close Proposal",

      },

      {

        "command": "oxygenhub.createProposal",

        "title": "Propose Current Bookmark\u2026",

      },

      {

        "command": "oxygenhub.newIssue",

        "title": "New Issue\u2026",

        "icon": "$(add)"

      },

      {

        "command": "oxygenhub.draftRelease",

        "title": "Draft Release\u2026",

        "icon": "$(tag)"

      },

      {

        "command": "oxygenhub.issueFromSelection",

        "title": "New Issue from Selection\u2026",

      },

      {

        "command": "oxygenhub.openIssue",

        "title": "Open Issue",

      },

      {

        "command": "oxygenhub.commentIssue",

        "title": "Comment on Issue\u2026",

      },

      {

        "command": "oxygenhub.closeIssue",

        "title": "Close Issue",

      },

      {

        "command": "oxygenhub.reopenIssue",

        "title": "Reopen Issue",

      },

      {

        "command": "oxygenhub.assignMe",

        "title": "Assign to Me",

      },

      {

        "command": "oxygenhub.newThread",

        "title": "Start Review Thread",

      },

      {

        "command": "oxygenhub.reply",

        "title": "Reply",

      },

      {

        "command": "oxygenhub.resolveThread",

        "title": "Resolve",

      }

    ],

    "menus": {

  private readonly disposables: vscode.Disposable[] = [];

  constructor(private readonly secrets: vscode.SecretStorage) {

  }

  async load(): Promise<void> {

    try {

      username = (await client.me()).username;

    } catch (e) {

      if (pick !== "Keep") {

        return undefined;

      }

    try {

      return (await this.auth.clientFor(r.base).proposalContent(r.owner, r.name, r.number, r.side, r.path)) ?? "";

    } catch (e) {

      return "";

    }

  }

/** Every file of a proposal in one multi-file diff editor. */

export async function openAllChanges(repo: RepoRef, p: api.Proposal, files: api.ProposalFile[]): Promise<void> {

  if (!files.length) {

    return;

  }

  const resources = files.map((f) => {

  const ext = vscode.extensions.getExtension<OxygenAPI>("oxygen.oxygen-vscode");

  oxygen = ext ? ((await ext.activate()) as OxygenAPI | undefined) : undefined;

  if (!oxygen) {

  } else {

    context.subscriptions.push(oxygen.registerRemoteProvider(makeProvider({ bases: () => auth.bases() })));

    context.subscriptions.push(oxygen.onDidChangeRepositories(() => refreshAll()));

        const r = await draftRelease(auth, repo);

        if (r) {

          releases.refresh();

          if (open) {

            void vscode.env.openExternal(vscode.Uri.parse(r.url));

          }

        }

      } catch (e) {

      }

    }),

    vscode.commands.registerCommand("oxygenhub.openProposal", async (node?: ProposalNode) => {

          await openAllChanges(repo, p, files);

          await review.loadDiff(repo, number);

        } catch (e) {

        }

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.reopenIssue", (...args: unknown[]) => withIssue(args, async (repo, number) => (await auth.clientFor(repo.base).setIssueState(repo.owner, repo.name, number, "open"), issues.refresh()))),

    vscode.commands.registerCommand("oxygenhub.assignMe", (...args: unknown[]) =>

      withIssue(args, async (repo, number) => {

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.reply", (reply: vscode.CommentReply) => review.reply(reply)),

}

function runInTerminal(repo: HubRepo, command: string): Promise<void> {

  t.show();

  t.sendText(command);

  return Promise.resolve();

    await repo.handle.json(["bookmark", "switch", bookmark, "--json"]);

    await repo.handle.refresh();

    await review.load(repo, number);

  } catch (e) {

  }

}

  try {

    await auth.clientFor(repo.base).review(repo.owner, repo.name, number, verdict.value, body);

  } catch (e) {

    return;

  }

  proposals.refresh();

  }

  const source = repo.handle.currentBookmark;

  if (!source) {

    return;

  }

  const remoteBookmarks = await auth.clientFor(repo.base).bookmarks(repo.owner, repo.name).catch(() => []);

    proposals.refresh();

    void vscode.env.openExternal(vscode.Uri.parse(p.url));

  } catch (e) {

  }

}

  try {

    const i = await auth.clientFor(repo.base).createIssue(repo.owner, repo.name, title, body);

    issues.refresh();

  } catch (e) {

  }

}

async function issueFromSelection(): Promise<void> {

  const editor = vscode.window.activeTextEditor;

  if (!editor || editor.document.uri.scheme !== "file") {

    return;

  }

  const doc = editor.document;

  const file = doc.uri.fsPath;

  const repo = (await proposals.repos()).filter((r) => file.startsWith(r.handle.root + "/") || file.startsWith(r.handle.root + "\\")).sort((a, b) => b.handle.root.length - a.handle.root.length)[0];

  if (!repo) {

    return;

  }

  const sel = editor.selection;

      const line = doc.lineAt(todoLine);

      const annotated = annotateTodo(line.text, issue.number);

      if (annotated !== line.text) {

        if (pick) {

          await editor.edit((e) => e.replace(line.range, annotated));

        }

    }

    await showIssue(auth, repo, issue);

  } catch (e) {

  }

}

// Generated by `cargo run -p hub-api --bin hub-api-typescript`; do not edit.

export type Visibility = "public" | "internal" | "private";

    private readonly open: Opener,

  ) {

    this.item.command = "oxygenhub.inbox";

  }

  /** Every hub's inbox; hubs that fail (offline, token without user:read) are skipped. */

    if (announce && this.lastUnread !== undefined && unread > this.lastUnread) {

      const newest = entries.find((e) => !e.n.read);

      const more = unread - this.lastUnread;

      void vscode.window.showInformationMessage(text, "Open Inbox").then((pick) => pick && vscode.commands.executeCommand("oxygenhub.inbox"));

    }

    this.lastUnread = unread;

      items.unshift({ label: "$(check-all) Mark all as read", all: true, alwaysShow: true });

    }

    if (!entries.length) {

      return;

    }

    if (!pick) {

      return;

    }

        list.sort((a, b) => Number(b.assignees.includes(me ?? "")) - Number(a.assignees.includes(me ?? "")) || b.updated_ms - a.updated_ms);

        return list.map((i) => ({ kind: "issue", repo: node.repo, i }));

      } catch (e) {

        return [];

      }

    }

      try {

        list = await this.proposalsOf(node.repo);

      } catch (e) {

        return [];

      }

      const me = this.auth.sessionFor(node.repo.base)?.username;

        const files = await this.filesOf(node.repo, node.p);

        return files.map((f) => ({ kind: "file", repo: node.repo, p: node.p, f }));

      } catch (e) {

      }

    }

    return [];

export function makeProvider(hubs: KnownHubs) {

  return {

    id: "oxygenhub",

    matches(remoteUrl: string): boolean {

      const p = parseRepoUrl(remoteUrl);

      return !!p && hubs.bases().some((b) => b.replace(/\/$/, "") === p.base);

        const list = await this.auth.clientFor(node.repo.base).releases(node.repo.owner, node.repo.name);

        return list.map((r) => ({ kind: "release", repo: node.repo, r }));

      } catch (e) {

        return [];

      }

    }

  const released = new Set(releases.map((r) => r.tag));

  const open = tags.filter((t) => !released.has(t.name));

  if (!open.length) {

    return undefined;

  }

  const pick = await vscode.window.showQuickPick(

/** The hub's comments as threads on files under the repository root. */

export class ReviewController implements vscode.Disposable {

  private threads: vscode.CommentThread[] = [];

  private active: { repo: HubRepo; number: number } | undefined;

  /** Threads in diff editors, per proposal (`base/owner/name#n`). */

      try {

        await postLineComment(this.auth, repo, r.number, r.path, line, reply.text);

      } catch (e) {

        return;

      }

      // A new thread from the gutter is replaced by the hub's copy.