@dxos/plugin-github 0.7.4 → 0.13.0

package/src/extensions/references.test.ts

@@ -0,0 +1,83 @@
+//
+// Copyright 2026 DXOS.org
+//
+// @vitest-environment happy-dom
+
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { describe, test } from 'vitest';
+
+import { Repo } from '@dxos/types';
+import { createMarkdownExtensions } from '@dxos/ui-editor';
+
+import { type GitHubReferenceResolver, githubReferences, referenceUrl } from './references.ts';
+
+const REPO = 'dxos/dxos';
+
+const createView = (doc: string, resolve: GitHubReferenceResolver = (number) => referenceUrl(REPO, number)) => {
+  const parent = document.createElement('div');
+  return new EditorView({
+    state: EditorState.create({
+      doc,
+      extensions: [createMarkdownExtensions(), githubReferences({ resolve }), EditorView.editable.of(false)],
+    }),
+    parent,
+  });
+};
+
+const links = (view: EditorView): { text: string; href: string }[] =>
+  Array.from(view.dom.querySelectorAll('a.cm-link')).map((anchor) => ({
+    text: anchor.textContent ?? '',
+    href: anchor.getAttribute('href') ?? '',
+  }));
+
+describe('github references', () => {
+  test('decorates a reference as a link to the repository', ({ expect }) => {
+    const view = createView('Blocked on #12752 until Friday.');
+    expect(links(view)).toEqual([{ text: '#12752', href: 'https://github.com/dxos/dxos/issues/12752' }]);
+    view.destroy();
+  });
+
+  test('decorates every reference in the document', ({ expect }) => {
+    const view = createView('Supersedes #1 and #22; see #333.');
+    expect(links(view).map(({ text }) => text)).toEqual(['#1', '#22', '#333']);
+    view.destroy();
+  });
+
+  test('leaves a reference alone when the repository is unknown', ({ expect }) => {
+    const view = createView('Blocked on #12752.', () => undefined);
+    expect(links(view)).toEqual([]);
+    view.destroy();
+  });
+
+  test('ignores a `#` that is not a reference', ({ expect }) => {
+    const view = createView('# Heading\n\nColour #ff0000, anchor page#42, and a hash#tag.');
+    expect(links(view)).toEqual([]);
+    view.destroy();
+  });
+
+  test('ignores references inside code', ({ expect }) => {
+    const view = createView('Inline `#12752` and\n\n```\nconst id = #99;\n```\n');
+    expect(links(view)).toEqual([]);
+    view.destroy();
+  });
+
+  test('ignores a reference inside a link target', ({ expect }) => {
+    const view = createView('[the PR](https://github.com/dxos/dxos/pull/12752#issuecomment-1)');
+    expect(links(view).map(({ href }) => href)).not.toContain('https://github.com/dxos/dxos/issues/1');
+    view.destroy();
+  });
+
+  test('a repo object supplies the target', ({ expect }) => {
+    const repo = Repo.make({ name: 'dxos', owner: 'dxos', url: 'https://github.com/dxos/dxos' });
+    const view = createView('Blocked on #12752.', (number) => referenceUrl(Repo.fullName(repo), number));
+    expect(links(view)).toEqual([{ text: '#12752', href: 'https://github.com/dxos/dxos/issues/12752' }]);
+    view.destroy();
+  });
+
+  test('a heading still carries references in its prose', ({ expect }) => {
+    const view = createView('## Notes on #7');
+    expect(links(view)).toEqual([{ text: '#7', href: 'https://github.com/dxos/dxos/issues/7' }]);
+    view.destroy();
+  });
+});

package/src/extensions/references.ts

@@ -0,0 +1,100 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { syntaxTree } from '@codemirror/language';
+import { type Extension, type Range } from '@codemirror/state';
+import { Decoration, type DecorationSet, type EditorView, ViewPlugin, type ViewUpdate } from '@codemirror/view';
+
+/** `#123` — a GitHub issue or pull-request reference. GitHub itself caps numbers well below this. */
+const REFERENCE = /(^|[^\w#/])#(\d{1,9})\b/g;
+
+/**
+ * Nodes whose text is not prose: a `#` inside them is a fragment, a colour, or code — never a
+ * reference. A heading is deliberately absent: `## Notes on #123` is prose after the marker.
+ */
+const OPAQUE_NODES = new Set(['InlineCode', 'CodeText', 'FencedCode', 'CodeBlock', 'URL', 'Link', 'Autolink']);
+
+export type GitHubReferenceResolver = (number: number) => string | undefined;
+
+export type GitHubReferencesOptions = {
+  /**
+   * Target for a reference, or `undefined` to leave it undecorated — which is the answer whenever
+   * the repository is unknown, since `#123` means nothing without one.
+   */
+  resolve: GitHubReferenceResolver;
+};
+
+/**
+ * Decorates `#123` as a link to the issue or pull request.
+ *
+ * Contributed by this plugin rather than built into the editor: the number resolves against the
+ * repository the space is bound to, which is GitHub-specific knowledge, and a document with no
+ * GitHub binding must render the text unchanged.
+ */
+export const githubReferences = ({ resolve }: GitHubReferencesOptions): Extension =>
+  ViewPlugin.fromClass(
+    class {
+      decorations: DecorationSet;
+
+      constructor(view: EditorView) {
+        this.decorations = build(view, resolve);
+      }
+
+      update(update: ViewUpdate) {
+        if (update.docChanged || update.viewportChanged) {
+          this.decorations = build(update.view, resolve);
+        }
+      }
+    },
+    {
+      decorations: (instance) => instance.decorations,
+    },
+  );
+
+/** Only the visible ranges: a long document would otherwise re-scan in full on every keystroke. */
+const build = (view: EditorView, resolve: GitHubReferenceResolver): DecorationSet => {
+  const ranges: Range<Decoration>[] = [];
+  const tree = syntaxTree(view.state);
+  for (const { from, to } of view.visibleRanges) {
+    const text = view.state.sliceDoc(from, to);
+    REFERENCE.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = REFERENCE.exec(text))) {
+      const start = from + match.index + match[1].length;
+      const end = start + match[2].length + 1;
+      if (isOpaque(tree, start)) {
+        continue;
+      }
+      const url = resolve(Number(match[2]));
+      if (!url) {
+        continue;
+      }
+      ranges.push(
+        Decoration.mark({
+          tagName: 'a',
+          attributes: { class: 'cm-link', href: url, rel: 'noreferrer', target: '_blank' },
+        }).range(start, end),
+      );
+    }
+  }
+
+  return Decoration.set(ranges, true);
+};
+
+const isOpaque = (tree: ReturnType<typeof syntaxTree>, position: number): boolean => {
+  let node = tree.resolveInner(position, 1);
+  while (node.parent) {
+    if (OPAQUE_NODES.has(node.name)) {
+      return true;
+    }
+    node = node.parent;
+  }
+  return OPAQUE_NODES.has(node.name);
+};
+
+/**
+ * The canonical target for a reference. `issues/<n>` is deliberate: GitHub redirects it to the pull
+ * request when the number is one, so a single URL serves both without asking which it is.
+ */
+export const referenceUrl = (repo: string, number: number): string => `https://github.com/${repo}/issues/${number}`;

package/src/github-link.ts

@@ -0,0 +1,70 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// The shapes a GitHub reference takes, and nothing else: the operations that read one run in node
+// and workerd, where importing the editor's link widget would drag React into the plugin's entry
+// (`plugin-github:check-module-structure` fails on exactly that).
+
+/**
+ * `https://github.com/owner/repo`, `/pull/123` or `/issues/123`, with an optional trailing slash,
+ * fragment or query. A path below the repository (`/blob/…`, `/actions`) is a page, not an object.
+ */
+export const GITHUB_LINK =
+  /^https:\/\/github\.com\/([^/\s?#]+)\/([^/\s?#]+)(?:\/(pull|issues)\/(\d+)(?:[/?#]\S*)?|\/?(?:[?#]\S*)?)$/;
+
+export type GitHubLink = {
+  owner: string;
+  repo: string;
+  kind: 'repo' | 'pull' | 'issue';
+  /** Absent for a repository. */
+  number?: number;
+  url: string;
+};
+
+/** The parts of a pull request or issue URL, or undefined for any other URL. */
+export const parseGitHubLink = (url: string): GitHubLink | undefined => {
+  const match = GITHUB_LINK.exec(url);
+  if (!match) {
+    return undefined;
+  }
+  const [, owner, repo, kind, number] = match;
+  if (!kind) {
+    return { owner, repo, kind: 'repo', url };
+  }
+  return { owner, repo, kind: kind === 'pull' ? 'pull' : 'issue', number: Number(number), url };
+};
+
+/**
+ * `owner/repo#123` — how a pull request is written where a URL would be noise, and the one form a
+ * reviewer can type from memory.
+ */
+const PULL_REQUEST_SHORTHAND = /^([\w.-]+)\/([\w.-]+)#(\d+)$/;
+
+/** A pull request named by its coordinates, however the user wrote it. */
+export type PullRequestReference = {
+  owner: string;
+  repo: string;
+  number: number;
+};
+
+/**
+ * The pull request a user's text names: a github.com URL or `owner/repo#123`.
+ *
+ * An `/issues/123` URL is accepted alongside `/pull/123` because GitHub itself serves a pull
+ * request under both, and a reader who copied the wrong one still means the same change.
+ */
+export const parsePullRequestReference = (value: string): PullRequestReference | undefined => {
+  const text = value.trim();
+  const shorthand = PULL_REQUEST_SHORTHAND.exec(text);
+  if (shorthand) {
+    const [, owner, repo, number] = shorthand;
+    return { owner, repo, number: Number(number) };
+  }
+
+  const link = parseGitHubLink(text);
+  if (!link || link.number === undefined) {
+    return undefined;
+  }
+  return { owner: link.owner, repo: link.repo, number: link.number };
+};

package/src/hooks/index.ts

@@ -1,6 +1,9 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
-export * from './useDocGhId';
-export * from './useGhIdFromUrl';
+export * from './useOpenObject.ts';
+export * from './usePullRequestFiles.ts';
+export * from './usePullRequestDiff.ts';
+export * from './useSyncPullRequest.ts';
+export * from './usePullRequestChecks.ts';

package/src/hooks/useOpenObject.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { useCallback } from 'react';
+
+import * as Hooks from '@dxos/app-framework/Hooks';
+import * as AppGraph from '@dxos/app-graph/AppGraph';
+import * as GraphPath from '@dxos/app-toolkit/GraphPath';
+import * as ToolkitHooks from '@dxos/app-toolkit/Hooks';
+import * as LayoutOperation from '@dxos/app-toolkit/LayoutOperation';
+import * as NavigationOperation from '@dxos/app-toolkit/NavigationOperation';
+import { Obj } from '@dxos/echo';
+import * as EffectEx from '@dxos/effect/EffectEx';
+import { EID } from '@dxos/keys';
+
+/** How long to wait for a just-stored object to appear in the app graph before opening anyway. */
+const GRAPH_NODE_TIMEOUT = '10 seconds';
+
+/**
+ * Opens a stored object as a plank.
+ *
+ * An object stored moments ago has no graph node yet, and the deck cannot open a node it cannot
+ * find; expanding only asks the connectors, so wait for the node to land.
+ */
+export const useOpenObject = (): ((object: Obj.Any) => Promise<void>) => {
+  const { invokePromise } = Hooks.useOperationInvoker();
+  const { graph } = ToolkitHooks.useAppGraph();
+
+  return useCallback(
+    async (object: Obj.Any) => {
+      const db = Obj.getDatabase(object);
+      if (!db) {
+        return;
+      }
+
+      const { data } = await invokePromise(NavigationOperation.ResolveNavigationTargets, {
+        query: { uri: EID.make({ spaceId: db.spaceId, entityId: object.id }) },
+      });
+      const path = data?.targets[0]?.path ?? GraphPath.getObjectPathFromObject(object);
+      AppGraph.expandPath(graph, path);
+      await EffectEx.runPromise(AppGraph.waitFor(graph, path).pipe(Effect.timeout(GRAPH_NODE_TIMEOUT), Effect.ignore));
+      await invokePromise(LayoutOperation.Open, { subject: [path], disposition: 'add' });
+    },
+    [invokePromise, graph],
+  );
+};

package/src/hooks/usePullRequestChecks.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import * as Hooks from '@dxos/app-framework/Hooks';
+import { Ref } from '@dxos/echo';
+import { type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type PullRequest } from '@dxos/types';
+
+import { GitHubOperation } from '#types';
+
+import { type PullRequestChecks } from '../containers/PullRequestsArticle/arrange.ts';
+
+/** How long a pull request's checks stand before they are read from GitHub again. */
+const CHECKS_INTERVAL = 5 * 60_000;
+
+/** Status reads in flight at once: each costs three GitHub requests, and a list can hold hundreds. */
+const CONCURRENCY = 4;
+
+// Keyed by object id and shared across mounts, so reopening the list within the interval costs nothing.
+const cache = new Map<string, { at: number; checks: PullRequestChecks }>();
+
+/** Whether a pull request's checks still change; a merged or closed one's head is settled. */
+const isLive = (pullRequest: PullRequest.PullRequest) => pullRequest.state === 'open' || pullRequest.state === 'draft';
+
+/**
+ * The CI and review standing of every live pull request in `pullRequests`, keyed by object id and
+ * filled in as each read lands. Finished pull requests are not read: their checks no longer ask
+ * anything of the reader.
+ */
+export const usePullRequestChecks = (
+  pullRequests: readonly PullRequest.PullRequest[],
+  spaceId: SpaceId | undefined,
+): ReadonlyMap<string, PullRequestChecks> => {
+  const { invokePromise } = Hooks.useOperationInvoker();
+  const [checks, setChecks] = useState<ReadonlyMap<string, PullRequestChecks>>(
+    () => new Map([...cache].map(([id, { checks }]) => [id, checks])),
+  );
+
+  useEffect(() => {
+    if (!spaceId) {
+      return;
+    }
+
+    let cancelled = false;
+    const now = Date.now();
+    const queue = pullRequests.filter(
+      (pullRequest) => isLive(pullRequest) && now - (cache.get(pullRequest.id)?.at ?? 0) >= CHECKS_INTERVAL,
+    );
+
+    const worker = async () => {
+      for (let pullRequest = queue.shift(); pullRequest && !cancelled; pullRequest = queue.shift()) {
+        const { data, error } = await invokePromise(
+          GitHubOperation.GetPullRequestStatus,
+          { pullRequest: Ref.make(pullRequest) },
+          { spaceId },
+        );
+        if (error || !data) {
+          log.warn('pull request checks failed', { pullRequest: pullRequest.id, error });
+          continue;
+        }
+        const next = { ci: data.ci, checks: data.checks, review: data.review, approvals: data.approvals };
+        cache.set(pullRequest.id, { at: Date.now(), checks: next });
+        // Set even once cancelled: the next run skips this pull request as freshly cached, so a read
+        // that lands across a re-run would otherwise never reach the list.
+        const id = pullRequest.id;
+        setChecks((previous) => new Map(previous).set(id, next));
+      }
+    };
+
+    void Promise.all(Array.from({ length: Math.min(CONCURRENCY, queue.length) }, worker));
+    return () => {
+      cancelled = true;
+    };
+  }, [invokePromise, pullRequests, spaceId]);
+
+  return checks;
+};

package/src/hooks/usePullRequestDiff.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import * as Hooks from '@dxos/app-framework/Hooks';
+import { type Ref } from '@dxos/echo';
+import { type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type PullRequest } from '@dxos/types';
+
+import { GitHubOperation } from '#types';
+
+export type PullRequestDiff = {
+  diff?: string;
+  /** Head commit the diff was read at, which a line comment on it must name. */
+  commit?: string;
+  error?: Error;
+};
+
+/** Reads a pull request's diff through the space's GitHub connection, once `enabled` first turns true. */
+export const usePullRequestDiff = (
+  pullRequest: Ref.Ref<PullRequest.PullRequest>,
+  spaceId: SpaceId | undefined,
+  enabled: boolean,
+): PullRequestDiff => {
+  const { invokePromise } = Hooks.useOperationInvoker();
+  const [result, setResult] = useState<PullRequestDiff>({});
+  const [requested, setRequested] = useState(false);
+  useEffect(() => {
+    if (enabled) {
+      setRequested(true);
+    }
+  }, [enabled]);
+
+  useEffect(() => {
+    if (!requested) {
+      return;
+    }
+    let cancelled = false;
+    void invokePromise(GitHubOperation.GetPullRequestDiff, { pullRequest }, { spaceId }).then(({ data, error }) => {
+      if (cancelled) {
+        return;
+      }
+      if (error) {
+        log.warn('pull request diff failed', { error });
+      }
+      setResult({ diff: data?.diff, commit: data?.commit, error });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [requested, invokePromise, pullRequest, spaceId]);
+
+  return result;
+};

package/src/hooks/usePullRequestFiles.ts

@@ -0,0 +1,98 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { log } from '@dxos/log';
+
+import { type FileNode, buildFileTree, fileSignature, flattenFiles } from '../components/PullRequestFiles/files.ts';
+import { type PatchFile, parsePatch } from '../walkthrough/patch.ts';
+
+export type PullRequestFiles = {
+  tree?: FileNode;
+  files: PatchFile[];
+  /** The file on screen. */
+  file?: PatchFile;
+  reviewed: ReadonlySet<string>;
+  select: (path: string) => void;
+  /** Moves to the file `delta` places away in tree order; a no-op past either end. */
+  step: (delta: number) => void;
+  setReviewed: (path: string, reviewed: boolean) => void;
+};
+
+/** Paths the reader checked off, each at the signature of the change they reviewed. */
+type ReviewedRecord = Record<string, string>;
+
+const readRecord = (key: string): ReviewedRecord => {
+  try {
+    const value = localStorage.getItem(key);
+    return value ? JSON.parse(value) : {};
+  } catch (error) {
+    // Blocked or cleared storage leaves the reader with nothing checked, which is recoverable.
+    log.warn('reviewed files unreadable', { error });
+    return {};
+  }
+};
+
+const writeRecord = (key: string, record: ReviewedRecord): void => {
+  try {
+    localStorage.setItem(key, JSON.stringify(record));
+  } catch (error) {
+    log.warn('reviewed files not saved', { error });
+  }
+};
+
+/**
+ * A pull request's changed files, the one on screen, and which the reader has reviewed.
+ *
+ * Reviewed state is the reader's own, so it lives in their browser under `storageKey` rather than in
+ * the space. A file is reviewed at the change it had when checked: a push that changes it unchecks
+ * it, as GitHub's "Viewed" does.
+ */
+export const usePullRequestFiles = (diff: string | undefined, storageKey: string): PullRequestFiles => {
+  const files = useMemo(() => (diff === undefined ? [] : parsePatch(diff)), [diff]);
+  const tree = useMemo(() => (diff === undefined ? undefined : buildFileTree(files)), [diff, files]);
+  const order = useMemo(() => (tree ? flattenFiles(tree) : []), [tree]);
+  const signatures = useMemo(() => new Map(files.map((file) => [file.path, fileSignature(file)])), [files]);
+
+  const [record, setRecord] = useState<ReviewedRecord>(() => readRecord(storageKey));
+  useEffect(() => setRecord(readRecord(storageKey)), [storageKey]);
+
+  const reviewed = useMemo(
+    () => new Set(Object.keys(record).filter((path) => signatures.get(path) === record[path])),
+    [record, signatures],
+  );
+
+  const setReviewed = useCallback(
+    (path: string, value: boolean) => {
+      setRecord((previous) => {
+        const next = { ...previous };
+        const signature = signatures.get(path);
+        if (value && signature) {
+          next[path] = signature;
+        } else {
+          delete next[path];
+        }
+        writeRecord(storageKey, next);
+        return next;
+      });
+    },
+    [signatures, storageKey],
+  );
+
+  const [selected, setSelected] = useState<string>();
+  const file = order.find((candidate) => candidate.path === selected) ?? order[0];
+  const step = useCallback(
+    (delta: number) => {
+      const index = order.findIndex((candidate) => candidate.path === file?.path);
+      const next = order[index + delta];
+      if (next) {
+        setSelected(next.path);
+      }
+    },
+    [order, file],
+  );
+
+  return { tree, files, file, reviewed, select: setSelected, step, setReviewed };
+};

package/src/hooks/useSyncPullRequest.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect } from 'react';
+
+import * as Hooks from '@dxos/app-framework/Hooks';
+import { Obj, Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { type PullRequest } from '@dxos/types';
+
+import { GitHubOperation } from '#types';
+
+/** How long a re-sync stands before the pull request is read from GitHub again. */
+const SYNC_INTERVAL = 5 * 60_000;
+
+// Keyed by object id: a board of pull request cards would otherwise spend one GitHub request per
+// card each time it mounts, and an anonymous caller has only 60 an hour. Entries past the interval
+// are pruned on every write, so the map holds only pull requests synced within it.
+const lastSynced = new Map<string, number>();
+
+const markSynced = (id: string, now: number) => {
+  for (const [key, syncedAt] of lastSynced) {
+    if (now - syncedAt >= SYNC_INTERVAL) {
+      lastSynced.delete(key);
+    }
+  }
+  lastSynced.set(id, now);
+};
+
+/**
+ * Refreshes a stored pull request from GitHub when it is shown, since whatever shows it is the moment
+ * its fields are worth trusting: a repository sync may be days old, and an import is never re-synced.
+ *
+ * A pull request held by no database (a link preview) is skipped, as there is nothing to write back to,
+ * and one synced within {@link SYNC_INTERVAL} is skipped too.
+ */
+export const useSyncPullRequest = (pullRequest: PullRequest.PullRequest): void => {
+  const { invokePromise } = Hooks.useOperationInvoker();
+  const spaceId = Obj.getDatabase(pullRequest)?.spaceId;
+  useEffect(() => {
+    const now = Date.now();
+    if (!spaceId || now - (lastSynced.get(pullRequest.id) ?? 0) < SYNC_INTERVAL) {
+      return;
+    }
+    markSynced(pullRequest.id, now);
+    void invokePromise(GitHubOperation.SyncPullRequest, { pullRequest: Ref.make(pullRequest) }, { spaceId }).then(
+      ({ error }) => error && log.warn('pull request sync failed', { error }),
+    );
+  }, [invokePromise, pullRequest, spaceId]);
+};

package/src/index.ts

@@ -1,9 +1,7 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
-import { GithubPlugin } from './GithubPlugin';
-
-export default GithubPlugin;
-
-export * from './GithubPlugin';
+export * as GitHubPlugin from './GitHubPlugin.ts';
+export * from '#types';
+export * as Extensions from './Extensions.ts';

package/src/meta.ts

@@ -1,18 +1,13 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import * as Plugin from '@dxos/app-framework/Plugin';
+import { DXN } from '@dxos/keys';
 
-export const GITHUB_PLUGIN = 'dxos.org/plugin/github';
-export const GITHUB_PLUGIN_SHORT_ID = 'github';
+import config from '../dx.config.ts';
 
-export default {
-  id: GITHUB_PLUGIN,
-  shortId: GITHUB_PLUGIN_SHORT_ID,
-  name: 'GitHub',
-  description: 'GitHub integration.',
-  icon: 'ph--github-logo--regular',
-  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-github',
-  tags: ['experimental'],
-} satisfies PluginMeta;
+export const meta = Plugin.getMetaFromConfig(config);
+
+/** The dialog behind the "Import pull request" command. */
+export const IMPORT_PULL_REQUEST_DIALOG = DXN.make(`${meta.profile.key}.importPullRequestDialog`);

package/src/operations/add-pull-request-comment.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as FetchHttpClient from 'effect/http/FetchHttpClient';
+
+import * as Operation from '@dxos/compute/Operation';
+
+import { GitHubOperation } from '#types';
+
+import { GitHubApi } from '../services/index.ts';
+import { resolvePullRequest } from './pull-request.ts';
+
+const handler: Operation.WithHandler<typeof GitHubOperation.AddPullRequestComment> =
+  GitHubOperation.AddPullRequestComment.pipe(
+    Operation.withHandler(
+      Effect.fn(function* ({ pullRequest: ref, body }) {
+        const { pullRequest, credentials } = yield* resolvePullRequest(ref);
+        const comment = yield* GitHubApi.createIssueComment(
+          pullRequest.owner,
+          pullRequest.repo,
+          pullRequest.number,
+          body,
+        ).pipe(Effect.provide(credentials));
+        return { commentId: comment.id, url: comment.html_url ?? undefined };
+      }, Effect.provide(FetchHttpClient.layer)),
+    ),
+  );
+
+export default handler;