codex-plus-patcher 0.6.0 → 0.7.0

package/src/runtime/api/composer.js

@@ -0,0 +1,14 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { applyDecorators } = globalObject.__CodexPlusRuntime;
+  globalObject.CodexPlus.ui.composer = {
+    surfaceDecorators: [],
+    decorateSurface(fn) {
+      this.surfaceDecorators.push(fn);
+      return fn;
+    },
+    surfaceProps(props) {
+      return applyDecorators(props, this.surfaceDecorators);
+    },
+  };
+})();

package/src/runtime/api/diagnostics.js

@@ -0,0 +1,38 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { core } = globalObject.__CodexPlusRuntime;
+
+  function diagnosticsEnabled() {
+    try {
+      return globalObject.localStorage?.getItem("codex-plus:diagnostics") === "1";
+    } catch {
+      return false;
+    }
+  }
+
+  function log(event, details = {}) {
+    const entry = { event, details, time: new Date().toISOString() };
+    core.diagnosticEvents.push(entry);
+    if (core.diagnosticEvents.length > 200) core.diagnosticEvents.shift();
+    if (diagnosticsEnabled()) {
+      try {
+        console.info("[Codex Plus]", event, details);
+      } catch {}
+    }
+    return entry;
+  }
+
+  const diagnostics = {
+    log,
+    snapshot() {
+      return core.diagnosticEvents.slice();
+    },
+    clear() {
+      core.diagnosticEvents.splice(0, core.diagnosticEvents.length);
+    },
+    enabled: diagnosticsEnabled,
+  };
+
+  globalObject.CodexPlus.diagnostics = diagnostics;
+  globalObject.CodexPlusDiagnostics = diagnostics;
+})();

package/src/runtime/api/errors.js

@@ -0,0 +1,20 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function renderDetails({ jsx, error, componentStack } = {}) {
+    for (const decorator of globalObject.CodexPlus.ui.errors.boundaryDecorators) {
+      const detail = decorator({ jsx, error, componentStack });
+      if (detail != null) return detail;
+    }
+    return null;
+  }
+
+  globalObject.CodexPlus.ui.errors = {
+    boundaryDecorators: [],
+    decorateBoundary(fn) {
+      this.boundaryDecorators.push(fn);
+      return fn;
+    },
+    renderDetails,
+  };
+})();

package/src/runtime/api/index.js

@@ -0,0 +1,79 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const core = {
+    commands: new Map(),
+    diagnosticEvents: [],
+    hostModules: new Map(),
+    patchDescriptors: [],
+    plugins: new Map(),
+    settingsListeners: new Map(),
+    startedPlugins: new Set(),
+    storagePrefix: "codex-plus:plugin:",
+    styleElements: new Map(),
+    waiters: [],
+  };
+
+  function safeId(id) {
+    if (typeof id !== "string" || id.trim() === "") throw new Error("Codex Plus plugin ids must be non-empty strings");
+    return id.trim();
+  }
+
+  function definePlugin(definition) {
+    const id = safeId(definition.id || definition.name);
+    return { ...definition, id };
+  }
+
+  function registerPlugin(definition) {
+    const plugin = definePlugin(definition);
+    core.plugins.set(plugin.id, plugin);
+    if (plugin.settings) plugin.settingsStore = CodexPlus.settings.define(plugin.id, plugin.settings);
+    for (const descriptor of plugin.patches || []) CodexPlus.patches.register({ ...descriptor, plugin: plugin.id });
+    for (const command of plugin.commands || []) CodexPlus.commands.register({ ...command, plugin: plugin.id });
+    if (plugin.styles) CodexPlus.styles.register(plugin.id, plugin.styles);
+    if (plugin.required || plugin.enabledByDefault) startPlugin(plugin.id);
+    CodexPlus.diagnostics.log("plugin.register", { id: plugin.id, started: core.startedPlugins.has(plugin.id) });
+    return plugin;
+  }
+
+  function startPlugin(id) {
+    const plugin = core.plugins.get(id);
+    if (!plugin || core.startedPlugins.has(id)) return;
+    plugin.start?.(CodexPlus);
+    core.startedPlugins.add(id);
+    CodexPlus.diagnostics.log("plugin.start", { id });
+  }
+
+  function stopPlugin(id) {
+    const plugin = core.plugins.get(id);
+    if (!plugin || !core.startedPlugins.has(id)) return;
+    plugin.stop?.(CodexPlus);
+    core.startedPlugins.delete(id);
+  }
+
+  function mergeDataAttributes(base, extra) {
+    if (extra == null) return base;
+    if (base == null) return extra;
+    return { ...base, ...extra, style: { ...base.style, ...extra.style } };
+  }
+
+  function applyDecorators(props, decorators) {
+    let result;
+    for (const decorator of decorators) result = mergeDataAttributes(result, decorator(props));
+    return result;
+  }
+
+  const CodexPlus = {
+    definePlugin,
+    registerPlugin,
+    startPlugin,
+    stopPlugin,
+    plugins: core.plugins,
+    ui: {},
+  };
+
+  globalObject.CodexPlus = CodexPlus;
+  globalObject.CodexPlusDiagnostics = null;
+  globalObject.CodexPlusHost ||= {};
+  globalObject.CodexPlusHost.adapters ||= {};
+  globalObject.__CodexPlusRuntime = { core, safeId, mergeDataAttributes, applyDecorators };
+})();

package/src/runtime/api/mermaid.js

@@ -0,0 +1,14 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { applyDecorators } = globalObject.__CodexPlusRuntime;
+  globalObject.CodexPlus.ui.mermaid = {
+    diagramDecorators: [],
+    decorateDiagram(fn) {
+      this.diagramDecorators.push(fn);
+      return fn;
+    },
+    diagramProps(props) {
+      return applyDecorators(props, this.diagramDecorators);
+    },
+  };
+})();

package/src/runtime/api/message.js

@@ -0,0 +1,14 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { applyDecorators } = globalObject.__CodexPlusRuntime;
+  globalObject.CodexPlus.ui.message = {
+    userBubbleDecorators: [],
+    decorateUserBubble(fn) {
+      this.userBubbleDecorators.push(fn);
+      return fn;
+    },
+    userBubbleProps(props) {
+      return applyDecorators(props, this.userBubbleDecorators);
+    },
+  };
+})();

package/src/runtime/api/modules.js

@@ -0,0 +1,57 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { core } = globalObject.__CodexPlusRuntime;
+
+  function notifyWaiters(name, value) {
+    for (let index = core.waiters.length - 1; index >= 0; index -= 1) {
+      const waiter = core.waiters[index];
+      if (!waiter.filter(value, name)) continue;
+      core.waiters.splice(index, 1);
+      waiter.resolve(value);
+    }
+  }
+
+  function registerHostModule(name, value) {
+    core.hostModules.set(name, value);
+    notifyWaiters(name, value);
+    return value;
+  }
+
+  function moduleValues() {
+    return Array.from(core.hostModules.values());
+  }
+
+  function findByProps(...props) {
+    return moduleValues().find((value) => value && props.every((prop) => prop in value));
+  }
+
+  function findByCode(text) {
+    return moduleValues().find((value) => {
+      try {
+        return String(value).includes(text);
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  function findComponentByCode(text) {
+    return moduleValues().find((value) => {
+      try {
+        return typeof value === "function" && String(value).includes(text);
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  function waitFor(filter) {
+    for (const [name, value] of core.hostModules) {
+      if (filter(value, name)) return Promise.resolve(value);
+    }
+    return new Promise((resolve) => core.waiters.push({ filter, resolve }));
+  }
+
+  globalObject.CodexPlus.modules = { registerHostModule, findByCode, findByProps, findComponentByCode, waitFor };
+  globalObject.CodexPlusHost.register = registerHostModule;
+})();

package/src/runtime/api/native.js

@@ -0,0 +1,14 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  async function request(method, params) {
+    return globalObject.codexPlusNative?.request?.(method, params) ?? globalObject.CodexPlusHost?.nativeRequest?.(method, params);
+  }
+
+  function registerNativeMenuItem(item) {
+    return globalObject.CodexPlus.native.request("native-menu/register-item", item).catch(() => ({ ok: false }));
+  }
+
+  globalObject.CodexPlus.native = { request };
+  globalObject.CodexPlus.nativeMenus = { registerItem: registerNativeMenuItem };
+})();

package/src/runtime/api/patches.js

@@ -0,0 +1,31 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { core } = globalObject.__CodexPlusRuntime;
+
+  function register(descriptor) {
+    core.patchDescriptors.push(descriptor);
+    return descriptor;
+  }
+
+  function apply(source, descriptors = core.patchDescriptors) {
+    let output = source;
+    for (const descriptor of descriptors) {
+      const moduleMatches =
+        typeof descriptor.find === "string" ? output.includes(descriptor.find) : descriptor.find.test(output);
+      if (!moduleMatches) continue;
+      const replacements = Array.isArray(descriptor.replacement) ? descriptor.replacement : [descriptor.replacement];
+      const beforeGroup = output;
+      let appliedGroup = true;
+      for (const replacement of replacements) {
+        const before = output;
+        output = output.replace(replacement.match, replacement.replace);
+        if (before === output) appliedGroup = false;
+      }
+      if (descriptor.group && !appliedGroup) output = beforeGroup;
+      if (!descriptor.all) break;
+    }
+    return output;
+  }
+
+  globalObject.CodexPlus.patches = { register, apply, all: core.patchDescriptors };
+})();

package/src/runtime/api/review.js

@@ -0,0 +1,20 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function renderBody({ props, deps, defaultBody } = {}) {
+    let body = defaultBody;
+    for (const wrapper of globalObject.CodexPlus.ui.review.wrappers) {
+      body = wrapper({ ...props, mainReviewContent: body }, deps);
+    }
+    return body;
+  }
+
+  globalObject.CodexPlus.ui.review = {
+    wrappers: [],
+    wrapBody(wrapper) {
+      this.wrappers.push(wrapper);
+      return wrapper;
+    },
+    renderBody,
+  };
+})();

package/src/runtime/api/settings.js

@@ -0,0 +1,76 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { core, safeId } = globalObject.__CodexPlusRuntime;
+
+  function getPluginStore(pluginId) {
+    const key = `${core.storagePrefix}${pluginId}`;
+    try {
+      return JSON.parse(globalObject.localStorage?.getItem(key) || "{}") || {};
+    } catch {
+      return {};
+    }
+  }
+
+  function writePluginStore(pluginId, store) {
+    const key = `${core.storagePrefix}${pluginId}`;
+    globalObject.localStorage?.setItem(key, JSON.stringify(store));
+  }
+
+  function emitSetting(pluginId, key, value) {
+    const listenerKey = `${pluginId}:${key}`;
+    for (const listener of core.settingsListeners.get(listenerKey) || []) listener(value);
+  }
+
+  function define(pluginId, definitions) {
+    const id = safeId(pluginId);
+    const store = getPluginStore(id);
+    for (const [key, definition] of Object.entries(definitions || {})) {
+      if (!(key in store) && "default" in definition) store[key] = definition.default;
+    }
+    writePluginStore(id, store);
+    return {
+      definitions,
+      get(key) {
+        return getPluginStore(id)[key];
+      },
+      set(key, value) {
+        const next = getPluginStore(id);
+        next[key] = value;
+        writePluginStore(id, next);
+        emitSetting(id, key, value);
+      },
+      use(key, listener) {
+        const listenerKey = `${id}:${key}`;
+        const listeners = core.settingsListeners.get(listenerKey) || new Set();
+        listeners.add(listener);
+        core.settingsListeners.set(listenerKey, listeners);
+        listener(getPluginStore(id)[key]);
+        return () => listeners.delete(listener);
+      },
+    };
+  }
+
+  function AppearanceRowHost({ row, deps, variant }) {
+    return row.render?.({ ...deps, variant, row }) ?? null;
+  }
+
+  const appearance = {
+    rows: [],
+    addRow(row) {
+      this.rows.push(row);
+      return row;
+    },
+    renderRows({ deps, variant, section = "appearance" } = {}) {
+      const jsx = deps?.jsx;
+      if (typeof jsx !== "function") return [];
+      return this.rows
+        .filter((row) => (row.section || "appearance") === section)
+        .slice()
+        .sort((left, right) => (left.order || 0) - (right.order || 0))
+        .map((row) => jsx(AppearanceRowHost, { row, deps, variant }, row.id));
+    },
+  };
+
+  globalObject.CodexPlus.ui.settings = { appearance };
+  globalObject.CodexPlus.settings = { define };
+})();

package/src/runtime/api/sidebar.js

@@ -0,0 +1,24 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { applyDecorators, mergeDataAttributes } = globalObject.__CodexPlusRuntime;
+  const sidebar = {
+    projectDecorators: [],
+    threadDecorators: [],
+    decorateProjectRow(fn) {
+      this.projectDecorators.push(fn);
+      return fn;
+    },
+    decorateThreadRow(fn) {
+      this.threadDecorators.push(fn);
+      return fn;
+    },
+    mergeDataAttributes,
+    projectRowProps(props) {
+      return applyDecorators(props, this.projectDecorators);
+    },
+    threadRowProps(props) {
+      return applyDecorators(props, this.threadDecorators);
+    },
+  };
+  globalObject.CodexPlus.ui.sidebar = sidebar;
+})();

package/src/runtime/api/styles.js

@@ -0,0 +1,28 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { core, safeId } = globalObject.__CodexPlusRuntime;
+
+  function register(pluginId, cssText) {
+    if (typeof document === "undefined") return null;
+    const id = `codex-plus-style-${safeId(pluginId)}`;
+    let element = core.styleElements.get(id) || document.getElementById(id);
+    if (!element) {
+      element = document.createElement("style");
+      element.id = id;
+      document.head?.appendChild(element);
+    }
+    element.textContent = cssText;
+    core.styleElements.set(id, element);
+    return element;
+  }
+
+  function setRootVars(vars) {
+    if (typeof document === "undefined") return;
+    for (const [key, value] of Object.entries(vars || {})) {
+      if (value == null) document.documentElement.style.removeProperty(key);
+      else document.documentElement.style.setProperty(key, value);
+    }
+  }
+
+  globalObject.CodexPlus.styles = { register, setRootVars };
+})();

package/src/runtime/api/threadHeader.js

@@ -0,0 +1,41 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function ThreadHeaderAccessoryHost({ accessory, context, deps }) {
+    const rendered = accessory?.({ context, ...deps }) ?? null;
+    globalObject.CodexPlus.diagnostics.log("threadHeader.accessoryHost.render", {
+      accessoryName: accessory?.name || null,
+      cwd: typeof context?.cwd === "string" ? context.cwd : null,
+      rendered: rendered != null,
+    });
+    return rendered;
+  }
+
+  function renderAccessories({ context, deps } = {}) {
+    const jsx = deps?.jsx;
+    if (typeof jsx !== "function") {
+      globalObject.CodexPlus.diagnostics.log("threadHeader.render.skip", { reason: "missing-jsx" });
+      return null;
+    }
+    globalObject.CodexPlus.diagnostics.log("threadHeader.render", {
+      accessoryCount: globalObject.CodexPlus.ui.threadHeader.accessories.length,
+      cwd: typeof context?.cwd === "string" ? context.cwd : null,
+      hostId: context?.hostId ?? null,
+      header: context?.header ?? null,
+    });
+    const rendered = globalObject.CodexPlus.ui.threadHeader.accessories.map((accessory, index) =>
+      jsx(ThreadHeaderAccessoryHost, { accessory, context, deps }, `thread-header-accessory:${index}`),
+    );
+    return rendered.length === 0 ? null : rendered;
+  }
+
+  globalObject.CodexPlus.ui.threadHeader = {
+    accessories: [],
+    addAccessory(fn) {
+      this.accessories.push(fn);
+      globalObject.CodexPlus.diagnostics.log("threadHeader.addAccessory", { accessoryName: fn?.name || null, accessoryCount: this.accessories.length });
+      return fn;
+    },
+    renderAccessories,
+  };
+})();

package/src/runtime/assets.js

@@ -2,31 +2,72 @@ const fs = require("node:fs");
 const path = require("node:path");
 
 const runtimeRoot = __dirname;
-const runtimeFiles = [
+const browserRuntimeFiles = [
+  "api/index.js",
+  "api/diagnostics.js",
+  "api/modules.js",
+  "api/settings.js",
+  "api/patches.js",
+  "api/commands.js",
+  "api/styles.js",
+  "api/sidebar.js",
+  "api/message.js",
+  "api/composer.js",
+  "api/about.js",
+  "api/review.js",
+  "api/native.js",
+  "api/errors.js",
+  "api/threadHeader.js",
+  "api/mermaid.js",
+  "host/review.js",
+  "host/sidebar.js",
+  "host/messageComposer.js",
+  "host/projectSelector.js",
+  "host/threadHeader.js",
+  "vendor/fzf.umd.js",
+  "plugins/aboutMetadata.js",
+  "plugins/nestedRepositories.js",
+  "plugins/diagnosticErrors.js",
+  "plugins/userBubbleColors.js",
+  "plugins/projectColors.js",
+  "plugins/projectPathHeader.js",
+  "plugins/sidebarNameBlur.js",
+  "plugins/devTools.js",
+  "plugins/projectSelectorShortcut.js",
+  "plugins/mermaidFullscreen.js",
+];
+
+const nodeRuntimeFiles = [
   [".vite/build/codex-plus-aboutMetadata.js", "plugins/aboutMetadata.js"],
-  [".vite/build/codex-plus-worker.js", "worker.js"],
+  [".vite/build/codex-plus-native-main.js", "host/nativeMain.js"],
+  [".vite/build/codex-plus-worker.js", "host/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/projectPathHeader.js", "plugins/projectPathHeader.js"],
-  ["webview/assets/codex-plus/plugins/sidebarNameBlur.js", "plugins/sidebarNameBlur.js"],
-  ["webview/assets/codex-plus/plugins/devTools.js", "plugins/devTools.js"],
-  ["webview/assets/codex-plus/vendor/fzf.umd.js", "../../node_modules/fzf/dist/fzf.umd.js"],
-  ["webview/assets/codex-plus/plugins/projectSelectorShortcut.js", "plugins/projectSelectorShortcut.js"],
-  ["webview/assets/codex-plus/plugins/mermaidFullscreen.js", "plugins/mermaidFullscreen.js"],
 ];
 
+const browserRuntimeAssets = browserRuntimeFiles.map((filePath) => [
+  `webview/assets/codex-plus/${filePath}`,
+  filePath.startsWith("vendor/") ? "../../node_modules/fzf/dist/fzf.umd.js" : filePath,
+]);
+
+const runtimeFiles = [
+  ...nodeRuntimeFiles,
+  ["webview/assets/codex-plus/runtime-manifest.js", null],
+  ...browserRuntimeAssets,
+];
+
+function browserRuntimeManifest() {
+  return `window.__CodexPlusRuntimeFiles=${JSON.stringify(browserRuntimeFiles)};window.__CodexPlusLoadRuntimeFiles?.(window.__CodexPlusRuntimeFiles);\n`;
+}
+
 function codexPlusRuntimeAssets() {
-  return runtimeFiles.map(([asarPath, localPath]) => [
-    asarPath,
-    fs.readFileSync(path.join(runtimeRoot, localPath), "utf8"),
-  ]);
+  return runtimeFiles.map(([asarPath, localPath]) => {
+    const content = localPath == null ? browserRuntimeManifest() : fs.readFileSync(path.join(runtimeRoot, localPath), "utf8");
+    return [asarPath, content];
+  });
 }
 
 module.exports = {
+  browserRuntimeFiles,
   codexPlusRuntimeAssets,
   runtimeFiles,
 };

package/src/runtime/host/messageComposer.js

@@ -0,0 +1,16 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+
+  function userBubbleProps(props) {
+    return globalObject.CodexPlus?.ui?.message?.userBubbleProps?.(props);
+  }
+
+  function composerSurfaceProps(props) {
+    return globalObject.CodexPlus?.ui?.composer?.surfaceProps?.(props);
+  }
+
+  globalObject.CodexPlusHost.adapters.messageComposer = {
+    composerSurfaceProps,
+    userBubbleProps,
+  };
+})();