codex-plus-patcher 0.6.0 → 0.7.0

package/src/runtime/host/nativeMain.js

@@ -0,0 +1,159 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { randomUUID } = require("node:crypto");
+const { pathToFileURL } = require("node:url");
+
+function create({ electron }) {
+  let nativeMenuItems = [];
+  let refreshApplicationMenu = null;
+
+  function menuSnapshot(menu) {
+    return menu?.items?.map((item) => ({
+      id: item.id,
+      label: item.label,
+      enabled: item.enabled,
+      visible: item.visible,
+      accelerator: item.accelerator,
+      submenu: menuSnapshot(item.submenu),
+    }));
+  }
+
+  function logMenuDiagnostics() {
+    try {
+      const menu = menuSnapshot(electron.Menu.getApplicationMenu()) ?? [];
+      const text = JSON.stringify(menu);
+      const hasOpenDeveloperTools = text.includes("codexPlusOpenDevTools") || text.includes("Open Developer Tools");
+      if (process.env.CODEX_PLUS_MENU_DIAGNOSTICS === "1" || !hasOpenDeveloperTools) {
+        console.log(`[Codex Plus menu diagnostics] ${JSON.stringify({ hasOpenDeveloperTools, menu })}`);
+      }
+    } catch (error) {
+      console.log(`[Codex Plus menu diagnostics] ${JSON.stringify({ error: String(error?.message ?? error) })}`);
+    }
+  }
+
+  function openDevTools(event) {
+    try {
+      const webContents = event?.sender;
+      if (typeof webContents?.openDevTools !== "function") return { ok: false };
+      webContents.openDevTools();
+      return { ok: true };
+    } catch {
+      return { ok: false };
+    }
+  }
+
+  function focusedEvent() {
+    const window = electron.BrowserWindow.getFocusedWindow();
+    return window && !window.isDestroyed() ? { sender: window.webContents } : null;
+  }
+
+  function runNativeMenuRequest(request) {
+    switch (request?.method) {
+      case "devtools/open":
+        return openDevTools(focusedEvent());
+      default:
+        return { ok: false };
+    }
+  }
+
+  function templateItems(menuId) {
+    return nativeMenuItems
+      .filter((item) => item.menuId === menuId)
+      .map((item) => ({
+        id: item.id,
+        label: item.label,
+        click: () => {
+          runNativeMenuRequest(item.nativeRequest);
+        },
+      }));
+  }
+
+  function registerNativeMenuItem(item) {
+    if (item?.id == null || item?.menuId == null || item?.label == null || item?.nativeRequest?.method == null) {
+      return { ok: false };
+    }
+    const nextItem = {
+      id: String(item.id),
+      menuId: String(item.menuId),
+      label: String(item.label),
+      nativeRequest: {
+        method: String(item.nativeRequest.method),
+        params: item.nativeRequest.params,
+      },
+      afterId: item.afterId == null ? null : String(item.afterId),
+      afterLabel: item.afterLabel == null ? null : String(item.afterLabel),
+    };
+    nativeMenuItems = nativeMenuItems.filter((existing) => existing.id !== nextItem.id);
+    nativeMenuItems.push(nextItem);
+    try {
+      refreshApplicationMenu?.();
+    } catch {}
+    logMenuDiagnostics();
+    return { ok: true };
+  }
+
+  function openMermaidViewer(params) {
+    const html = params?.html;
+    if (typeof html !== "string" || html.length === 0) return { ok: false };
+    const filePath = path.join(os.tmpdir(), `codex-plus-mermaid-${randomUUID()}.html`);
+    fs.writeFileSync(filePath, html, "utf8");
+    const window = new electron.BrowserWindow({
+      height: 900,
+      resizable: true,
+      show: true,
+      title: "Mermaid diagram viewer",
+      webPreferences: {
+        contextIsolation: true,
+        nodeIntegration: false,
+        sandbox: true,
+      },
+      width: 1400,
+    });
+    window.webContents.setWindowOpenHandler((event) => {
+      try {
+        const url = new URL(event.url);
+        if (url.protocol === "https:" && url.hostname === "mermaid.live") electron.shell.openExternal(event.url);
+      } catch {}
+      return { action: "deny" };
+    });
+    window.on("closed", () => {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {}
+    });
+    window.loadURL(pathToFileURL(filePath).toString()).catch(() => {});
+    return { ok: true };
+  }
+
+  function registerNativeRequest({ isTrustedIpcEvent }) {
+    return electron.ipcMain.handle("codex_plus:native-request", async (event, request) => {
+      if (!isTrustedIpcEvent(event)) return { ok: false };
+      switch (request?.method) {
+        case "native-menu/register-item":
+          return registerNativeMenuItem(request.params);
+        case "devtools/open":
+          return openDevTools(event);
+        case "mermaid/openViewer":
+          return openMermaidViewer(request.params);
+        default:
+          return { ok: false };
+      }
+    });
+  }
+
+  function setRefreshApplicationMenu(refresh) {
+    refreshApplicationMenu = refresh;
+  }
+
+  return {
+    logMenuDiagnostics,
+    registerNativeRequest,
+    setRefreshApplicationMenu,
+    templateItems,
+  };
+}
+
+module.exports = {
+  create,
+};

package/src/runtime/host/projectSelector.js

@@ -0,0 +1,58 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function fuzzyFilter(projects, query) {
+    const needle = String(query ?? "").trim().toLowerCase();
+    return globalObject.CodexPlus?.ui?.projectSelector?.fuzzyFilter?.(projects, query) ??
+      (needle
+        ? projects.filter((project) =>
+            [project.label, project.repositoryData?.rootFolder ?? "", project.path ?? "", project.hostDisplayName ?? ""].some((value) =>
+              String(value ?? "").toLowerCase().includes(needle),
+            ),
+          )
+        : projects);
+  }
+
+  function fuzzyHighlight(text, query, jsx) {
+    return globalObject.CodexPlus?.ui?.projectSelector?.fuzzyHighlight?.({ text, query, jsx }) ?? text;
+  }
+
+  function closeDropdown(event) {
+    const KeyboardEventConstructor = globalObject.KeyboardEvent;
+    if (typeof KeyboardEventConstructor !== "function") return;
+
+    const target = event?.target;
+    const dispatchTarget = typeof target?.dispatchEvent === "function" ? target : globalObject.document;
+    dispatchTarget?.dispatchEvent?.(new KeyboardEventConstructor("keydown", {
+      bubbles: true,
+      cancelable: true,
+      key: "Escape",
+    }));
+  }
+
+  function acceptFirst(event, projects, selectProjectId, query) {
+    const project = projects?.[0];
+    if (event?.key !== "Enter" || String(query ?? "").trim().length === 0 || project == null) return;
+    event.preventDefault?.();
+    event.stopPropagation?.();
+    selectProjectId(project.projectId);
+    closeDropdown(event);
+  }
+
+  function trigger(element, variant, React) {
+    return React.isValidElement(element)
+      ? React.cloneElement(element, {
+          ...element.props,
+          "data-codex-plus-project-selector-trigger": true,
+          "data-codex-plus-project-selector-variant": variant,
+        })
+      : element;
+  }
+
+  globalObject.CodexPlusHost.adapters.projectSelector = {
+    acceptFirst,
+    fuzzyFilter,
+    fuzzyHighlight,
+    trigger,
+  };
+})();

package/src/runtime/host/review.js

@@ -0,0 +1,62 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function renderBodyFromHost(props, hostDeps) {
+    const [
+      jsxRuntime,
+      React,
+      useStore,
+      useAtom,
+      routeAtom,
+      cwdAtom,
+      hostIdAtom,
+      hostConfigAtom,
+      conversationIdAtom,
+      gitRequest,
+      pathValue,
+      DefaultReview,
+      Button,
+      Tooltip,
+      Icon,
+      Dropdown,
+      DropdownMenu,
+      BranchPickerDropdownContent,
+      ReviewToolbar,
+      parseDiff,
+      DiffCard,
+    ] = hostDeps;
+    const deps = {
+      jsx: jsxRuntime.jsx,
+      jsxs: jsxRuntime.jsxs,
+      Fragment: jsxRuntime.Fragment,
+      createElement: React.createElement,
+      React,
+      useStore,
+      useAtom,
+      routeAtom,
+      cwdAtom,
+      hostIdAtom,
+      hostConfigAtom,
+      conversationIdAtom,
+      gitRequest,
+      pathValue,
+      DefaultReview,
+      Button,
+      Tooltip,
+      Icon,
+      Dropdown,
+      DropdownMenu,
+      BranchPickerDropdownContent,
+      ReviewToolbar,
+      parseDiff,
+      DiffCard,
+    };
+    return globalObject.CodexPlus.ui.review.renderBody({
+      props,
+      deps,
+      defaultBody: props.mainReviewContent ?? deps.jsx(DefaultReview, props),
+    });
+  }
+
+  globalObject.CodexPlusHost.adapters.review = { renderBodyFromHost };
+})();

package/src/runtime/host/sidebar.js

@@ -0,0 +1,21 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function projectRowProps(project) {
+    return globalObject.CodexPlus?.ui?.sidebar?.projectRowProps?.({ project });
+  }
+
+  function threadRowProps(project) {
+    return globalObject.CodexPlus?.ui?.sidebar?.threadRowProps?.({ project });
+  }
+
+  function mergeThreadRowAttributes(base, extra) {
+    return globalObject.CodexPlus?.ui?.sidebar?.mergeDataAttributes?.(base, extra);
+  }
+
+  globalObject.CodexPlusHost.adapters.sidebar = {
+    mergeThreadRowAttributes,
+    projectRowProps,
+    threadRowProps,
+  };
+})();

package/src/runtime/host/threadHeader.js

@@ -0,0 +1,9 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function accessories(context, deps) {
+    return globalObject.CodexPlus?.ui?.threadHeader?.renderAccessories?.({ context, deps }) ?? null;
+  }
+
+  globalObject.CodexPlusHost.adapters.threadHeader = { accessories };
+})();

package/src/runtime/{worker.js → host/worker.js}

@@ -221,8 +221,15 @@ function isReadOnlyBranchRequest(requestKind, source) {
   return source === "codex_plus_review" && (requestKind === "recent-branches" || requestKind === "search-branches");
 }
 
+function repositoryTargetsFromHost(gitManager, params, platform, signal, getSubmodulePaths) {
+  return repositoryTargets(gitManager, params, platform, signal, (root, submoduleSignal) =>
+    getSubmodulePaths(gitManager.getWorktreeRepositoryForRoot(root, platform), submoduleSignal),
+  );
+}
+
 module.exports = {
   isReadOnlyBranchRequest,
+  repositoryTargetsFromHost,
   repositoryTargets,
   traceRequest,
 };