codex-plus-patcher 0.5.0 → 0.7.0

package/src/patches/lib/project-selector-shortcut-patch.js

@@ -0,0 +1,55 @@
+const { replaceOnce } = require("./replace");
+const { projectSelectorSearchHook, projectSelectorTriggerHook } = require("./hooks/project-selector");
+
+function patchLocalActiveWorkspaceRootDropdownProjectSelectorShortcut(text) {
+  let patched = replaceOnce(
+    text,
+    "Ne=r();function Pe(e){let t=(0,Ne.c)(42),",
+    `Ne=r();${projectSelectorSearchHook()}function Pe(e){let t=(0,Ne.c)(42),`,
+    "project selector fuzzy search adapter insertion anchor",
+  );
+  patched = replaceOnce(
+    patched,
+    "let e=h.trim().toLowerCase();v=n.filter(t=>{if(!e)return!0;let n=t.repositoryData?.rootFolder??``;return[t.label,n,t.path??``,t.hostDisplayName??``].some(t=>t.toLowerCase().includes(e))});",
+    "v=CPXP.fuzzyFilter(n,h);",
+    "project selector fuzzy search filter anchor",
+  );
+  patched = replaceOnce(
+    patched,
+    "S=(0,H.jsx)(ve,{value:h,onChange:o,placeholder:s,className:`mb-1`})",
+    "S=(0,H.jsx)(ve,{value:h,onChange:o,onKeyDown:e=>CPXP.acceptFirst(e,v,i,h),placeholder:s,className:`mb-1`})",
+    "project selector accept first match keydown anchor",
+  );
+  patched = replaceOnce(
+    patched,
+    "(0,H.jsx)(`span`,{className:`truncate`,children:e.label})",
+    "(0,H.jsx)(`span`,{className:`truncate`,children:CPXP.fuzzyHighlight(e.label,h,H.jsx)})",
+    "project selector fuzzy search highlight anchor",
+  );
+  patched = replaceOnce(
+    patched,
+    "function Ie(e){let t=(0,Ne.c)(81),",
+    `${projectSelectorTriggerHook()}function Ie(e){let t=(0,Ne.c)(81),`,
+    "project selector shortcut helper insertion anchor",
+  );
+  return replaceOnce(
+    patched,
+    "at=(0,H.jsx)(ye,{open:f,onOpenChange:g,onCloseAutoFocus:Y,align:tt,disabled:O,triggerButton:X,contentWidth:`workspace`,contentMaxHeight:`tall`,children:$})",
+    "at=(0,H.jsx)(ye,{open:f,onOpenChange:g,onCloseAutoFocus:Y,align:tt,disabled:O,triggerButton:CPXPST(X,k),contentWidth:`workspace`,contentMaxHeight:`tall`,children:$})",
+    "project selector shortcut final dropdown trigger anchor",
+  );
+}
+
+function patchRunCommandProjectSelectorShortcut(text) {
+  return replaceOnce(
+    text,
+    "],[`openFolder`,()=>{r()}],[`toggleSidebar`,",
+    "],[`codexPlus.focusProjectSelector`,()=>{window.CodexPlus?.commands?.run?.(`codexPlus.focusProjectSelector`)}],[`openFolder`,()=>{r()}],[`toggleSidebar`,",
+    "project selector shortcut command dispatch anchor",
+  );
+}
+
+module.exports = {
+  patchLocalActiveWorkspaceRootDropdownProjectSelectorShortcut,
+  patchRunCommandProjectSelectorShortcut,
+};

package/src/runtime/api/about.js

@@ -0,0 +1,16 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { ui } = globalObject.CodexPlus;
+
+  const buildInfo = [];
+
+  function addBuildInfo(fn) {
+    buildInfo.push(fn);
+    return fn;
+  }
+
+  ui.about = {
+    addBuildInfo,
+    buildInfo,
+  };
+})();

package/src/runtime/api/commands.js

@@ -0,0 +1,85 @@
+(function () {
+  const globalObject = typeof window !== "undefined" ? window : globalThis;
+  const { core, safeId } = globalObject.__CodexPlusRuntime;
+
+  function register(command) {
+    core.commands.set(safeId(command.id), command);
+    return command;
+  }
+
+  function run(id, ...args) {
+    const command = core.commands.get(id);
+    if (!command) throw new Error(`Unknown Codex Plus command: ${id}`);
+    return command.run?.(...args);
+  }
+
+  function commandGroups(command) {
+    return command.menu?.groups || [];
+  }
+
+  function commandKeybindings(command) {
+    return command.shortcut?.defaultKeybindings || [];
+  }
+
+  function commandMetadata() {
+    return Array.from(core.commands.values())
+      .filter((command) => command.palette?.enabled !== false)
+      .map((command) => {
+        const groups = commandGroups(command);
+        return {
+          id: command.id,
+          title: command.title,
+          description: command.description,
+          menuGroups: groups,
+          defaultKeybindings: commandKeybindings(command),
+          commandMenuGroupKey: groups.includes("panels") ? "panels" : groups[0],
+          commandMenu: true,
+          electron: {
+            menuTitle: command.title,
+            defaultKeybindings: commandKeybindings(command),
+          },
+        };
+      });
+  }
+
+  function CommandMenuItemHost({ command, deps, group, close }) {
+    const jsx = deps?.jsx;
+    const MenuItem = deps?.MenuItem;
+    if (typeof jsx !== "function" || MenuItem == null) return null;
+    const render = (closeMenu) =>
+      jsx(
+        MenuItem,
+        {
+          value: command.title,
+          title: command.title,
+          description: command.description,
+          onSelect() {
+            run(command.id);
+            closeMenu?.();
+            close?.();
+          },
+        },
+        command.id,
+      );
+    deps?.register?.(command.id, () => run(command.id), {
+      menuItem: { id: command.id, groupKey: group, render },
+    });
+    return null;
+  }
+
+  function renderMenuItems({ group, deps, close } = {}) {
+    const jsx = deps?.jsx;
+    if (typeof jsx !== "function") return [];
+    return Array.from(core.commands.values())
+      .filter((command) => commandGroups(command).includes(group))
+      .map((command) => jsx(CommandMenuItemHost, { command, deps, group, close }, command.id));
+  }
+
+  globalObject.CodexPlus.commands = {
+    register,
+    run,
+    all: () => Array.from(core.commands.values()),
+    menuItems: (group) => Array.from(core.commands.values()).filter((command) => commandGroups(command).includes(group)),
+  };
+  globalObject.CodexPlus.ui.commands = { renderMenuItems, commandMetadata };
+})();

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,
+  };
+})();