codex-plus-patcher 0.2.1 → 0.4.0

package/src/patches/lib/host-hooks.js

@@ -0,0 +1,24 @@
+const { replaceAllOnce } = require("./replace");
+
+function exactReplacement(oldText, newText, label) {
+  return [oldText, newText, label];
+}
+
+function prependAtAnchor(anchor, helper, label) {
+  return exactReplacement(anchor, `${helper}${anchor}`, label);
+}
+
+function appendImport(anchorImport, newImport, label) {
+  return exactReplacement(anchorImport, `${anchorImport}${newImport}`, label);
+}
+
+function applyExactReplacements(text, descriptors) {
+  return replaceAllOnce(text, descriptors);
+}
+
+module.exports = {
+  appendImport,
+  applyExactReplacements,
+  exactReplacement,
+  prependAtAnchor,
+};

package/src/patches/lib/make-patch-set.js

@@ -0,0 +1,14 @@
+function makePatchSet({ id, codexVersion, bundleVersion, asarSha256, assetFiles, patches }) {
+  return {
+    id,
+    codexVersion,
+    bundleVersion,
+    asarSha256,
+    assetFiles,
+    patches,
+  };
+}
+
+module.exports = {
+  makePatchSet,
+};

package/src/patches/lib/replace.js

@@ -0,0 +1,17 @@
+function replaceOnce(text, oldText, newText, label) {
+  const matches = text.split(oldText).length - 1;
+  if (matches !== 1) throw new Error(`Expected one ${label}, found ${matches}`);
+  return text.replace(oldText, newText);
+}
+
+function replaceAllOnce(text, replacements) {
+  return replacements.reduce((current, replacement) => {
+    const [oldText, newText, label] = replacement;
+    return replaceOnce(current, oldText, newText, label);
+  }, text);
+}
+
+module.exports = {
+  replaceAllOnce,
+  replaceOnce,
+};

package/src/runtime/assets.js

@@ -0,0 +1,27 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const runtimeRoot = __dirname;
+const runtimeFiles = [
+  [".vite/build/codex-plus-aboutMetadata.js", "plugins/aboutMetadata.js"],
+  [".vite/build/codex-plus-worker.js", "worker.js"],
+  ["webview/assets/codex-plus/runtime.js", "runtime.js"],
+  ["webview/assets/codex-plus/plugins/aboutMetadata.js", "plugins/aboutMetadata.js"],
+  ["webview/assets/codex-plus/plugins/nestedRepositories.js", "plugins/nestedRepositories.js"],
+  ["webview/assets/codex-plus/plugins/diagnosticErrors.js", "plugins/diagnosticErrors.js"],
+  ["webview/assets/codex-plus/plugins/userBubbleColors.js", "plugins/userBubbleColors.js"],
+  ["webview/assets/codex-plus/plugins/projectColors.js", "plugins/projectColors.js"],
+  ["webview/assets/codex-plus/plugins/sidebarNameBlur.js", "plugins/sidebarNameBlur.js"],
+];
+
+function codexPlusRuntimeAssets() {
+  return runtimeFiles.map(([asarPath, localPath]) => [
+    asarPath,
+    fs.readFileSync(path.join(runtimeRoot, localPath), "utf8"),
+  ]);
+}
+
+module.exports = {
+  codexPlusRuntimeAssets,
+  runtimeFiles,
+};

package/src/runtime/plugins/aboutMetadata.js

@@ -0,0 +1,93 @@
+(function (globalObject) {
+  const DEFAULT_REPO_URL = "https://github.com/michaelw/codex-plus-patcher";
+  const DISCLAIMER_HEADING = "Disclaimer of Warranty and Limitation of Liability";
+  const DISCLAIMER_BODY = [
+    'THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. This is a modified, binary-patched demonstrator provided strictly for experimental or demonstration purposes.',
+    "The upstream developers, contributors, and maintainers assume NO responsibility or liability for any errors, malfunctions, data loss, or damages—including consequential or incidental damages—arising from the installation or use of this patched version. You use, test, or distribute this patched app at your sole and absolute risk.",
+    "The original authors and upstream suppliers are under no obligation to provide support, updates, fixes, or assistance with any issues, mess, or conflicts caused by this modified build.",
+  ].join("\n\n");
+
+  function buildInfoLines(context = {}) {
+    const appliedPatches = Array.isArray(context.appliedPatches) ? context.appliedPatches : [];
+    return [
+      `Patcher: ${context.patcherRepoUrl || DEFAULT_REPO_URL}`,
+      `Patcher commit: ${context.patcherGitSha || "unknown"}`,
+      `Source app.asar: ${context.sourceAsarSha256 || "unknown"}`,
+      "",
+      "Applied patches:",
+      ...appliedPatches.map((patchId) => `- ${patchId}`),
+    ];
+  }
+
+  function aboutPayload(context = {}) {
+    return {
+      appDisplayName: "Codex Plus",
+      buildInfoLines: buildInfoLines(context),
+      disclaimerBody: DISCLAIMER_BODY,
+      disclaimerHeading: DISCLAIMER_HEADING,
+    };
+  }
+
+  function disclaimerStyles() {
+    return [
+      "    .codex-plus-disclaimer {",
+      "      width: 100%;",
+      "      margin: 0 0 12px;",
+      "      color: var(--muted-text);",
+      "      text-align: left;",
+      "      font-size: 9px;",
+      "      line-height: 1.25;",
+      "      white-space: pre-wrap;",
+      "      overflow-wrap: anywhere;",
+      "    }",
+      "",
+      "    .codex-plus-disclaimer-heading {",
+      "      margin-bottom: 4px;",
+      "      font-weight: 700;",
+      "    }",
+    ].join("\n");
+  }
+
+  function disclaimerMarkup({ escape, heading, body }) {
+    if (heading == null || body == null || typeof escape !== "function") return "";
+    return `<section class="codex-plus-disclaimer" aria-label="${escape(heading)}"><div class="codex-plus-disclaimer-heading">${escape(heading)}</div><div class="codex-plus-disclaimer-body">${escape(body)}</div></section>`;
+  }
+
+  function browserBuildInfo() {
+    return {
+      heading: DISCLAIMER_HEADING,
+      lines: ["Codex Plus runtime plugin layer active", "Plugin: aboutMetadata"],
+    };
+  }
+
+  const exportsObject = {
+    aboutPayload,
+    browserBuildInfo,
+    buildInfoLines,
+    defaultRepoUrl: DEFAULT_REPO_URL,
+    disclaimerBody: DISCLAIMER_BODY,
+    disclaimerHeading: DISCLAIMER_HEADING,
+    disclaimerMarkup,
+    disclaimerStyles,
+  };
+
+  if (typeof module !== "undefined" && module.exports) {
+    module.exports = exportsObject;
+  }
+
+  const CodexPlus = globalObject?.CodexPlus;
+  if (!CodexPlus) return;
+
+  CodexPlus.registerPlugin(
+    CodexPlus.definePlugin({
+      id: "aboutMetadata",
+      name: "About Metadata",
+      description: "Adds Codex Plus provenance and disclaimer metadata to the About dialog host surface.",
+      required: true,
+      exports: exportsObject,
+      start(api) {
+        api.ui.about.addBuildInfo(browserBuildInfo);
+      },
+    }),
+  );
+})(typeof window !== "undefined" ? window : globalThis);

package/src/runtime/plugins/diagnosticErrors.js

@@ -0,0 +1,43 @@
+(function (globalObject) {
+  const DETAIL_CLASS =
+    "max-h-80 max-w-full overflow-auto whitespace-pre-wrap rounded-md border border-token-border bg-token-main-surface-secondary p-2 text-left font-vscode-editor text-[11px] leading-4 text-token-text-primary";
+
+  function diagnosticText(error, componentStack) {
+    const base = error?.stack ?? error?.message ?? String(error ?? "");
+    if (!base && !componentStack) return "";
+    return [base, componentStack].filter(Boolean).join("\n\n");
+  }
+
+  function renderDetails({ jsx, error, componentStack }) {
+    if (typeof jsx !== "function") return null;
+    const text = diagnosticText(error, componentStack);
+    if (!text) return null;
+    return jsx("pre", { className: DETAIL_CLASS, children: text });
+  }
+
+  const exportsObject = {
+    detailClassName: DETAIL_CLASS,
+    diagnosticText,
+    renderDetails,
+  };
+
+  if (typeof module !== "undefined" && module.exports) {
+    module.exports = exportsObject;
+  }
+
+  const CodexPlus = globalObject?.CodexPlus;
+  if (!CodexPlus) return;
+
+  CodexPlus.registerPlugin(
+    CodexPlus.definePlugin({
+      id: "diagnosticErrors",
+      name: "Diagnostic Errors",
+      description: "Adds richer diagnostic context to selected Codex app-shell errors.",
+      required: true,
+      exports: exportsObject,
+      start(api) {
+        api.ui.errors.decorateBoundary(renderDetails);
+      },
+    }),
+  );
+})(typeof window !== "undefined" ? window : globalThis);

package/src/runtime/plugins/nestedRepositories.js

@@ -0,0 +1,448 @@
+(function () {
+  const CodexPlus = window.CodexPlus;
+
+  function repoKey(repo) {
+    return repo?.id ?? repo?.cwd ?? repo?.path ?? "unknown";
+  }
+
+  function label(repo) {
+    return repo?.kind === "main" ? "Main" : repo?.label ?? repo?.path ?? "Repository";
+  }
+
+  function sessionKey(hostId, conversationId, cwd) {
+    return JSON.stringify([hostId, conversationId, cwd]);
+  }
+
+  function debugText(value) {
+    try {
+      return JSON.stringify(value, (_key, item) => (typeof item === "bigint" ? String(item) : item), 2) ?? "";
+    } catch (error) {
+      return `Unable to render debug object: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+
+  function Warnings({ warnings }, deps) {
+    const { jsx } = deps;
+    if (!warnings || warnings.length === 0) return null;
+    return jsx("div", {
+      className: "px-3 py-2 text-xs text-token-description-foreground",
+      children: warnings.map((warning, index) =>
+        jsx("div", { children: warning.message ?? warning.type ?? String(warning) }, `${warning.type ?? "warning"}:${warning.path ?? index}`),
+      ),
+    });
+  }
+
+  function Debug({ debug }, deps) {
+    const { jsx, jsxs } = deps;
+    if (debug == null) return null;
+    const plusToml = debug.plusToml ?? {};
+    const readState = plusToml.readOk === true ? "read ok" : "not read";
+    const parsedCount = String(plusToml.parsedRepositories ?? 0);
+    return jsxs("details", {
+      className: "mx-3 mb-2 rounded-md border border-token-border bg-token-main-surface-secondary px-2 py-1 text-xs text-token-description-foreground",
+      children: [
+        jsxs("summary", { className: "cursor-pointer select-none", children: ["plus.toml debug: ", readState, ", parsed ", parsedCount] }),
+        jsx("pre", {
+          className: "mt-2 max-h-72 overflow-auto whitespace-pre-wrap font-vscode-editor text-[11px] leading-4 text-token-foreground",
+          children: debugText(debug),
+        }),
+      ],
+    });
+  }
+
+  function MainGroup({ children, repo, collapsed, onToggle }, deps) {
+    const { jsx, jsxs } = deps;
+    return jsxs("section", {
+      className: "border-b border-token-border-default",
+      children: [
+        jsxs("button", {
+          type: "button",
+          className: "flex w-full items-center justify-between gap-2 px-3 py-2 text-left text-sm text-token-foreground hover:bg-token-list-hover-background",
+          onClick: onToggle,
+          "aria-expanded": !collapsed,
+          children: [
+            jsxs("span", {
+              className: "min-w-0",
+              children: [
+                jsx("span", { className: "font-medium", children: label(repo) }),
+                jsx("span", { className: "ml-2 text-xs text-token-description-foreground", children: repo?.path ?? "." }),
+              ],
+            }),
+            jsx("span", { className: "shrink-0 text-xs text-token-description-foreground", children: collapsed ? "Show" : "Hide" }),
+          ],
+        }),
+        collapsed ? null : children,
+      ],
+    });
+  }
+
+  function PlainDiff({ text }, deps) {
+    return deps.jsx("pre", {
+      className: "mx-3 mb-3 max-h-[520px] overflow-auto whitespace-pre-wrap rounded-md border border-token-border bg-token-main-surface-secondary p-3 font-vscode-editor text-xs leading-5 text-token-foreground",
+      children: text,
+    });
+  }
+
+  function RepoDiffBody({ cwd, hostConfig, conversationId, diffMode, diffText, statusText, error, isLoading }, deps) {
+    const { jsx, createElement, parseDiff, DiffCard, pathValue } = deps;
+    if (error != null || isLoading || diffText == null) return PlainDiff({ text: statusText }, deps);
+    let parsed;
+    try {
+      parsed = parseDiff(diffText);
+    } catch (parseError) {
+      const message = parseError instanceof Error ? parseError.message : String(parseError);
+      return PlainDiff({ text: `Unable to parse diff: ${message}\n\n${diffText}` }, deps);
+    }
+    if (parsed == null || parsed.length === 0) return PlainDiff({ text: statusText }, deps);
+    return jsx("div", {
+      className: "mx-3 mb-3 flex min-w-0 max-w-none flex-col gap-2",
+      children: parsed.map((diff, index) =>
+        createElement(DiffCard, {
+          key: `${diff.metadata?.newPath ?? diff.metadata?.oldPath ?? index}:${index}`,
+          containerClassName: "codex-review-diff-card extension:rounded-lg w-full max-w-none",
+          conversationId: conversationId ?? undefined,
+          cwd: pathValue(cwd),
+          defaultOpen: true,
+          diff,
+          diffViewWrap: true,
+          expandScope: "review",
+          fullContentNextFallbackToDisk: true,
+          headerVariant: "full-review",
+          hostConfig,
+          hunkActionsVariant: "unstaged",
+          hunkSeparators: diff.metadata?.additionLines ? "line-info" : "metadata",
+          roundedCorners: false,
+          showFileActions: false,
+          showHunkActions: false,
+          stickyHeader: false,
+          viewType: diffMode ?? "unified",
+        }),
+      ),
+    });
+  }
+
+  function BranchPicker({ repo, hostConfig, baseBranch, setBaseBranch, deps }) {
+    const { jsx, jsxs, React, Button, Tooltip, Icon, Dropdown, DropdownMenu, BranchPickerDropdownContent, gitRequest } = deps;
+    const [open, setOpen] = React.useState(false);
+    const [branches, setBranches] = React.useState([]);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [query, setQuery] = React.useState("");
+    const [searchedBranches, setSearchedBranches] = React.useState([]);
+    const [searchLoading, setSearchLoading] = React.useState(false);
+    const [searchError, setSearchError] = React.useState(null);
+    const selected = (baseBranch ?? "").trim();
+
+    const loadBranches = () => {
+      const controller = new AbortController();
+      setLoading(true);
+      setError(null);
+      gitRequest("git")
+        .request({
+          method: "recent-branches",
+          params: { root: repo.root, limit: 100, hostConfig, operationSource: "codex_plus_review" },
+          signal: controller.signal,
+        })
+        .then((result) => setBranches(result?.branches ?? []))
+        .catch((loadError) => {
+          if (!controller.signal.aborted) setError(loadError instanceof Error ? loadError.message : String(loadError));
+        })
+        .finally(() => {
+          if (!controller.signal.aborted) setLoading(false);
+        });
+      return controller;
+    };
+
+    React.useEffect(() => {
+      if (!open) return undefined;
+      const controller = loadBranches();
+      return () => controller.abort();
+    }, [open, repo.root, hostConfig.id]);
+
+    React.useEffect(() => {
+      if (!open) return undefined;
+      const trimmed = query.trim();
+      if (!trimmed) {
+        setSearchedBranches([]);
+        setSearchError(null);
+        setSearchLoading(false);
+        return undefined;
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => {
+        setSearchLoading(true);
+        setSearchError(null);
+        gitRequest("git")
+          .request({
+            method: "search-branches",
+            params: { root: repo.root, query: trimmed, limit: 50, hostConfig, operationSource: "codex_plus_review" },
+            signal: controller.signal,
+          })
+          .then((result) => setSearchedBranches(result?.branches ?? []))
+          .catch((searchLoadError) => {
+            if (!controller.signal.aborted) setSearchError(searchLoadError instanceof Error ? searchLoadError.message : String(searchLoadError));
+          })
+          .finally(() => {
+            if (!controller.signal.aborted) setSearchLoading(false);
+          });
+      }, 250);
+      return () => {
+        clearTimeout(timer);
+        controller.abort();
+      };
+    }, [open, query, repo.root, hostConfig.id]);
+
+    const title = selected || "Unstaged";
+    const button = jsxs(Button, {
+      type: "button",
+      color: selected ? "ghostActive" : "ghost",
+      size: "toolbar",
+      className: "max-w-44 min-w-0 shrink-0 border-token-border px-1.5",
+      children: [jsx("span", { className: "min-w-0 truncate", children: title }), jsx(Icon, { className: "icon-2xs text-token-input-placeholder-foreground" })],
+    });
+    const triggerButton = jsx(Tooltip, { tooltipContent: selected ? `Base branch: ${title}` : "Working tree changes", children: button });
+    const dropdownContent = jsx(BranchPickerDropdownContent, {
+      branches,
+      selectedBranch: selected,
+      disabled: false,
+      isError: error != null,
+      isLoading: loading,
+      isSearchError: searchError != null,
+      isSearchLoading: searchLoading,
+      onClose: () => setOpen(false),
+      onRetry: loadBranches,
+      onRetrySearch: () => setQuery(query),
+      onSearchQueryChange: setQuery,
+      onSelectBranch: (branch) => {
+        setBaseBranch(branch);
+        setOpen(false);
+      },
+      searchedBranches,
+      searchQuery: query,
+    });
+    const unstaged = selected
+      ? jsxs(deps.Fragment, {
+          children: [
+            jsx(DropdownMenu.Separator, {}),
+            jsx(DropdownMenu.Item, {
+              onSelect: () => {
+                setBaseBranch("");
+                setOpen(false);
+              },
+              children: "Show unstaged changes",
+            }),
+          ],
+        })
+      : null;
+    return jsx(Dropdown, {
+      align: "end",
+      contentWidth: "menu",
+      open,
+      onOpenChange: setOpen,
+      triggerButton,
+      children: jsxs(deps.Fragment, { children: [dropdownContent, unstaged] }),
+    });
+  }
+
+  function RepoPatchGroup({ repo, hostConfig, hostId, conversationId, diffMode, baseBranch, setBaseBranch, collapsed, setCollapsed, deps }) {
+    const { jsx, jsxs, React, ReviewToolbar, gitRequest, pathValue } = deps;
+    const [diffText, setDiffText] = React.useState(null);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [currentBranch, setCurrentBranch] = React.useState(null);
+
+    React.useEffect(() => {
+      let cancelled = false;
+      const controller = new AbortController();
+      setDiffText(null);
+      setError(null);
+      setLoading(true);
+      gitRequest("git")
+        .request({ method: "current-branch", params: { root: repo.root, hostConfig, operationSource: "codex_plus_review" }, signal: controller.signal })
+        .then((result) => {
+          if (!cancelled) setCurrentBranch(result?.branch ?? null);
+        })
+        .catch(() => {
+          if (!cancelled) setCurrentBranch(null);
+        });
+
+      const selected = (baseBranch ?? "").trim();
+      gitRequest("git")
+        .request({
+          method: "review-patch",
+          params: {
+            cwd: pathValue(repo.cwd),
+            source: selected ? "branch" : "unstaged",
+            operationSource: "codex_plus_review",
+            hostConfig,
+            ...(selected ? { baseBranch: selected } : {}),
+          },
+          signal: controller.signal,
+        })
+        .then((result) => {
+          if (cancelled) return;
+          const text = result?.diff?.type === "success" ? result.diff.unifiedDiff ?? result.diff.diff ?? "" : "";
+          setDiffText(text.trim().length > 0 ? text : null);
+        })
+        .catch((loadError) => {
+          if (!cancelled) setError(loadError instanceof Error ? loadError.message : String(loadError));
+        })
+        .finally(() => {
+          if (!cancelled) setLoading(false);
+        });
+      return () => {
+        cancelled = true;
+        controller.abort();
+      };
+    }, [repo.cwd, repo.root, hostConfig.id, baseBranch]);
+
+    const statusText = error ?? (loading ? "Loading diff..." : diffText == null ? "No changes" : diffText);
+    return jsxs("section", {
+      className: "border-b border-token-border-default",
+      children: [
+        jsxs("div", {
+          className: "flex min-w-0 items-center gap-2 px-3 py-2",
+          children: [
+            jsxs("button", {
+              type: "button",
+              className: "min-w-0 flex-1 text-left hover:bg-token-list-hover-background",
+              onClick: () => setCollapsed(!collapsed),
+              "aria-expanded": !collapsed,
+              children: [
+                jsx("div", { className: "truncate text-sm font-medium text-token-foreground", children: label(repo) }),
+                jsx("div", {
+                  className: "truncate text-xs text-token-description-foreground",
+                  children: [repo.kind, repo.path ?? "", currentBranch ? ` - ${currentBranch}` : ""].filter(Boolean).join(" / "),
+                }),
+              ],
+            }),
+            jsx(BranchPicker, { repo, hostConfig, baseBranch, setBaseBranch, deps }),
+            jsx(ReviewToolbar, {
+              conversationId,
+              cwd: repo.cwd,
+              hostId,
+              codexWorktree: false,
+              surface: "review-toolbar",
+              reviewToolbarCompact: true,
+            }, repo.id),
+          ],
+        }),
+        collapsed ? null : RepoDiffBody({ cwd: repo.cwd, hostConfig, conversationId, diffMode, diffText, statusText, error, isLoading: loading }, deps),
+      ],
+    });
+  }
+
+  function ReviewMux(props, deps) {
+    const { jsx, jsxs, React, useStore, useAtom, routeAtom, cwdAtom, hostIdAtom, hostConfigAtom, conversationIdAtom, gitRequest, pathValue, DefaultReview } = deps;
+    const routeStore = useStore(routeAtom);
+    const cwd = useAtom(cwdAtom);
+    const hostId = useAtom(hostIdAtom);
+    const hostConfig = useAtom(hostConfigAtom);
+    const conversationAtomValue = useAtom(conversationIdAtom);
+    const conversationId = routeStore.value.routeKind === "local-thread" ? routeStore.value.conversationId : null;
+    const [targets, setTargets] = React.useState(null);
+    const [collapsed, setCollapsedState] = React.useState(() => new Map());
+    const [baseBranches, setBaseBranches] = React.useState(() => new Map());
+    const mainReviewContent = props.mainReviewContent;
+    const upstreamReview = React.useMemo(
+      () => mainReviewContent ?? jsx(DefaultReview, props),
+      [mainReviewContent, props.diffRefs, props.diffMode, props.isCappedMode, props.reviewDiffMetrics, props.showReviewGitActions],
+    );
+
+    React.useEffect(() => {
+      if (cwd == null || hostConfig == null) {
+        setTargets(null);
+        return undefined;
+      }
+      let cancelled = false;
+      const controller = new AbortController();
+      gitRequest("git")
+        .request({
+          method: "repository-targets",
+          params: { cwd: pathValue(cwd), hostId, hostConfig, operationSource: "codex_plus_review" },
+          signal: controller.signal,
+        })
+        .then((result) => {
+          if (!cancelled) setTargets(result);
+        })
+        .catch((error) => {
+          if (!cancelled) setTargets({ main: null, repositories: [], warnings: [{ type: "load-error", message: error instanceof Error ? error.message : String(error) }] });
+        });
+      return () => {
+        cancelled = true;
+        controller.abort();
+      };
+    }, [cwd, hostId, hostConfig?.id]);
+
+    const main = targets?.main ?? (cwd == null ? null : { id: `main:${cwd}`, kind: "main", path: ".", label: "Main", cwd });
+    const repositories = targets?.repositories ?? [];
+    const all = [main, ...repositories].filter(Boolean);
+    if (main == null || (all.length <= 1 && (!targets?.warnings || targets.warnings.length === 0) && targets?.debug == null)) return upstreamReview;
+
+    const session = sessionKey(hostId, conversationId ?? conversationAtomValue, cwd);
+    const keyFor = (repo) => `${session}:${repoKey(repo)}`;
+    const isCollapsed = (repo) => collapsed.get(keyFor(repo)) === true;
+    const setCollapsed = (repo, next) =>
+      setCollapsedState((current) => {
+        const copy = new Map(current);
+        if (next) copy.set(keyFor(repo), true);
+        else copy.delete(keyFor(repo));
+        return copy;
+      });
+    const setBaseBranch = (repo, branch) =>
+      setBaseBranches((current) => {
+        const copy = new Map(current);
+        copy.set(keyFor(repo), branch);
+        return copy;
+      });
+
+    return jsxs("div", {
+      className: "flex h-full min-h-0 w-full min-w-0 flex-1 flex-col overflow-x-hidden overflow-y-auto",
+      children: [
+        jsx("div", { className: "px-3 py-1 text-[11px] font-medium uppercase tracking-wide text-token-description-foreground", children: "Codex Plus repositories" }),
+        Warnings({ warnings: targets?.warnings ?? [] }, deps),
+        Debug({ debug: targets?.debug }, deps),
+        main ? MainGroup({ repo: main, collapsed: isCollapsed(main), onToggle: () => setCollapsed(main, !isCollapsed(main)), children: upstreamReview }, deps) : upstreamReview,
+        repositories.map((repo) =>
+          jsx(
+            RepoPatchGroup,
+            {
+              repo,
+              hostConfig,
+              hostId,
+              conversationId,
+              diffMode: props.diffMode,
+              baseBranch: baseBranches.get(keyFor(repo)) ?? "",
+              setBaseBranch: (branch) => setBaseBranch(repo, branch),
+              collapsed: isCollapsed(repo),
+              setCollapsed: (next) => setCollapsed(repo, next),
+              deps,
+            },
+            repoKey(repo),
+          ),
+        ),
+      ],
+    });
+  }
+
+  CodexPlus.registerPlugin(
+    CodexPlus.definePlugin({
+      id: "nestedRepositories",
+      name: "Nested Repositories",
+      description: "Hosts nested repository review panel behavior and worker bridge requests.",
+      required: true,
+      exports: {
+        ReviewMux,
+        repoKey,
+      },
+      start(api) {
+        api.ui.review.wrapBody((props, deps) => ReviewMux(props, deps));
+        api.modules.registerHostModule("codex-plus:native:repository-targets", {
+          request(params) {
+            return api.native.request("repository-targets", params);
+          },
+        });
+      },
+    }),
+  );
+})();