minecodex 0.1.1 → 0.1.3

package/README.md

@@ -17,9 +17,11 @@ npm install -g minecodex
 mcx install
 ```
 
-`mcx install` 会关闭当前正在运行的 Codex 窗口，再以 MineCodex 托管方式重新打开；
-请先保存正在编辑的内容，并让安装命令完整运行到成功提示。安装后，macOS 的
-“登录项与扩展”中会显示名为 **MineCodex** 的后台项目，用于在登录后恢复插件。
+`mcx install` 不会关闭或启动 Codex，也不会改变当前窗口。安装完成后，终端会提示
+MineCodex 将在下次重启 Codex 时启用，并询问是否现在重启；默认答案是 **No**。
+只有用户明确确认，或之后主动运行 `mcx restart`，MineCodex 才会关闭并重新打开
+Codex。安装后，macOS 的“登录项与扩展”中会显示名为 **MineCodex** 的后台项目；
+这个后台项目负责插件与本地控制台，不会在用户退出 Codex 后自动将它重新打开。
 
 安装后三个插件默认开启。打开本地控制台：
 

package/features/images/README.md

@@ -87,7 +87,7 @@ HTTP + Images UI
 - Images 服务需要保持运行，才会持续监听新图片；侧边栏注册由 `CodexRuntimeHost` 统一维持。
 - 每次服务启动都会先开放 health，再在后台补扫停机期间新增的图片并刷新来源名称；初始补扫完成后，运行期间的新图片由文件监听自动加入。手动 Refresh 会再次补扫来源和 Archive 状态，但不会重置筛选、图板模式、详情、滚动位置或列数。刷新 ring 至少显示 1 秒。
 - 侧边栏使用 Codex 当前未公开的 CDP / DOM 能力，Codex UI 更新后只需调整统一宿主；独立 Web UI 和路径索引不受影响。
-- 当前 Codex 的 CSP 会屏蔽普通本地 iframe。统一宿主会先等待原生侧栏完成渲染，再启用 CSP bypass、注册 document-start 脚本，并替换当前 document 中旧的 MineCodex runtime 后显式完成注入；当前实现不会调用会让用户看到页面刷新的 `Page.reload`（Issue #1）。
+- 当前 Codex 的 CSP 会屏蔽普通本地 iframe。统一宿主会先启用 CSP bypass 并注册 document-start 脚本；尚未完成该初始化的首次或旧版 document 会受控 reload 一次。完成初始化后会留下 document 标记，后续 RuntimeHost 重启只替换旧的 MineCodex runtime，不再刷新 Codex 页面（Issue #1）。
 - 详情打开时会从本机 Session JSONL 按需读取该 ImageGen item 的真实 `revised_prompt` 并缓存到索引；历史记录缺少该事件时明确显示 Prompt 不可用，不从附近文本猜测。
 - 当前没有发现 Codex 会因运行时间增长而自动清理 `generated_images` 的证据。如果未来观察到真实清理，再决定是否增加可选备份。
 

package/features/images/codex-feature.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "images",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "label": {
     "en": "Images",
     "zh-CN": "图片"

package/features/model-slider/codex-feature.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "model-slider",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "label": {
     "en": "Model Slider",
     "zh-CN": "模型滑条"

package/features/notes/codex-feature.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "notes",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "label": {
     "en": "Notes",
     "zh-CN": "笔记"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecodex",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Lightweight, local-first plugins for the Codex desktop app.",
   "license": "MIT",
   "type": "module",

package/packages/cli/src/commands.mjs

@@ -1,5 +1,6 @@
 import { access, readFile, rm } from "node:fs/promises";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { assertNodeSupported, MacPlatformAdapter } from "./platform.mjs";
 import { ensureConfig, ensureControlToken, readConfig } from "./config.mjs";
 import { createControlServer } from "./control-server.mjs";
@@ -98,37 +99,32 @@ async function restoreService(platform, snapshot, { cliPath, paths }) {
   return platform.restoreServiceState(snapshot, { cliPath, paths });
 }
 
-async function nativeSnapshot(platform) {
-  if (platform.snapshotNativeCodexState) return platform.snapshotNativeCodexState();
-  return { count: 0 };
-}
-
-async function restoreNative(platform, snapshot) {
-  if (!snapshot?.count) return;
-  if (platform.restoreNativeCodexState) {
-    await platform.restoreNativeCodexState(snapshot);
-    return;
-  }
-  await platform.openNativeCodex?.();
-}
-
 function appendRollbackError(error, rollbackError) {
   if (!rollbackError) return error;
   return new Error(`${error.message} Automatic rollback also failed: ${rollbackError.message}`, { cause: error });
 }
 
-async function installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, nodeVersion = process.versions.node }) {
+export async function confirmRestartNow({ input = process.stdin, terminalOutput = process.stdout } = {}) {
+  if (!input.isTTY || !terminalOutput.isTTY) return false;
+  const prompt = createInterface({ input, output: terminalOutput });
+  try {
+    const answer = await prompt.question("Restart Codex now? [y/N] ");
+    return /^(y|yes)$/i.test(answer.trim());
+  } catch {
+    return false;
+  } finally {
+    prompt.close();
+  }
+}
+
+async function installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, confirmRestart, nodeVersion = process.versions.node }) {
   assertNodeSupported(nodeVersion);
   platform.assertInstallSupported();
   await platform.assertCodexInstalled();
   const previousService = await serviceSnapshot(platform, paths);
-  const previousNative = await nativeSnapshot(platform);
   await ensureConfig(paths.configPath);
   await ensureControlToken(paths.tokenPath);
-  let nativeCount = 0;
   try {
-    nativeCount = await platform.terminateNativeCodex();
-    if (nativeCount) output(`Restarting ${nativeCount} running Codex instance${nativeCount === 1 ? "" : "s"} with MineCodex enabled…`);
     await platform.installService({ cliPath, paths, start: true });
     const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
     const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
@@ -143,15 +139,14 @@ async function installCommand({ paths, platform, cliPath, output, serviceProbe,
     } catch (failure) {
       rollbackError = failure;
     }
-    try {
-      await restoreNative(platform, previousNative?.count ? previousNative : { count: nativeCount });
-    } catch (failure) {
-      rollbackError = rollbackError ?? failure;
-    }
     throw appendRollbackError(error, rollbackError);
   }
-  output("MineCodex installed. Model Slider, Notes, and Images are enabled by default.");
-  output("Run `mcx open` to manage plugins.");
+  output("MineCodex installed. It will be enabled the next time Codex restarts.");
+  if (await confirmRestart()) {
+    await restartCommand({ paths, output, fetchImpl });
+  } else {
+    output("Run `mcx restart` when you are ready.");
+  }
 }
 
 async function openCommand({ paths, platform, serviceProbe, fetchImpl }) {
@@ -377,12 +372,13 @@ export async function runCli(argv, {
   npm = createNpmAdapter(),
   serviceProbe,
   fetchImpl = fetch,
+  confirmRestart = confirmRestartNow,
   nodeVersion = process.versions.node,
 } = {}) {
   const [command = "--help", ...args] = argv;
   if (["--help", "-h", "help"].includes(command)) return printHelp(output);
   if (["--version", "-v"].includes(command)) return output(packageMetadata.version);
-  if (command === "install") return installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, nodeVersion });
+  if (command === "install") return installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, confirmRestart, nodeVersion });
   if (command === "open" || command === "gui") return openCommand({ paths, platform, serviceProbe, fetchImpl });
   if (command === "status") return statusCommand({ paths, platform, jsonOutput: args.includes("--json"), output, fetchImpl });
   if (command === "restart") return restartCommand({ paths, output, fetchImpl });

package/packages/cli/src/runtime-manager.mjs

@@ -142,7 +142,7 @@ export class RuntimeManager {
     return next;
   }
 
-  async startInternal() {
+  async startInternal({ launchCodex = false } = {}) {
     if (this.child && !hasExited(this.child)) return this.status();
     this.clearChildState();
     this.stopping = false;
@@ -169,6 +169,7 @@ export class RuntimeManager {
         MINECODEX_ENABLED_FEATURES: features.join(","),
         MINECODEX_CODEX_PID_FILE: this.paths.codexPidPath,
         MINECODEX_RUNTIME_READY_FILE: this.paths.runtimeReadyPath,
+        MINECODEX_LAUNCH_CODEX: launchCodex ? "1" : "0",
         ...(codexExecutable ? { MINECODEX_CODEX_EXECUTABLE: codexExecutable } : {}),
       },
       stdio: "inherit",
@@ -307,7 +308,8 @@ export class RuntimeManager {
     const operation = this.enqueue(async () => {
       await this.stopInternal();
       await this.platform.terminateOwnedCodex(this.paths);
-      return this.startInternal();
+      await this.platform.terminateNativeCodex?.();
+      return this.startInternal({ launchCodex: true });
     });
     this.restartInFlight = operation;
     const shared = this.restartInFlight.finally(() => {

package/packages/runtime-host/README.md

@@ -141,6 +141,9 @@ Host 会再次发送当前状态。功能页面可据此暂停隐藏状态下的
 
 - 只在 top frame 安装 Runtime，绝不向业务 iframe 注入 binding token。
 - Watch / refresh 串行；已连接 Renderer 不重复连接，关闭 target 会清理状态。
+- 本地 Surface 注入前先启用 CSP bypass 并注册 document-start 脚本；缺少初始化标记的
+  首次或旧版 document 只受控 reload 一次。标记存在时，新的 RuntimeHost 会话直接
+  替换旧 Runtime，不刷新当前 Codex 页面。
 - 入口由 Renderer 内的 MutationObserver 幂等挂载，React 重绘不会产生重复入口。
 - Summary 根据对话主区域宽度连续派生 `overlay / shift / gutter`：小于 1096px
   使用临时 Popover；1096–1535px 预留 316px 并把对话内容左移 158px；更宽时

package/packages/runtime-host/src/codex-runtime.mjs

@@ -5,6 +5,8 @@ import path from "node:path";
 
 const RUNTIME_VERSION = 99;
 const HOST_BINDING_NAME = "__codexPersonalHostAction";
+const CSP_BOOTSTRAP_VERSION = 1;
+const CSP_BOOTSTRAP_KEY = "__mineCodexCspBootstrapVersion";
 
 export const RESPONSIVE_SUMMARY_LAYOUT = Object.freeze({
   contentBaseWidth: 736,
@@ -3564,6 +3566,14 @@ export function createRuntimeReadyContract({
   };
 }
 
+function createDocumentBootstrapSource(source) {
+  return `window[${JSON.stringify(CSP_BOOTSTRAP_KEY)}] = ${CSP_BOOTSTRAP_VERSION};\n${source}`;
+}
+
+function documentBootstrapExpression() {
+  return `window[${JSON.stringify(CSP_BOOTSTRAP_KEY)}] === ${CSP_BOOTSTRAP_VERSION}`;
+}
+
 async function connect(url) {
   const socket = new WebSocket(url);
   const pending = new Map();
@@ -3728,8 +3738,6 @@ export class CodexRuntime {
     sleep = (timeoutMs) => new Promise((resolve) => setTimeout(resolve, timeoutMs)),
     availabilityTimeoutMs = 20_000,
     availabilityPollMs = 500,
-    relaunchBaseDelayMs = 250,
-    relaunchMaxDelayMs = 2_000,
     monitorIntervalMs = 2_000,
     runtimeSessionId = randomBytes(16).toString("hex"),
     onStatusChange = null,
@@ -3746,8 +3754,6 @@ export class CodexRuntime {
     this.sleep = sleep;
     this.availabilityTimeoutMs = availabilityTimeoutMs;
     this.availabilityPollMs = availabilityPollMs;
-    this.relaunchBaseDelayMs = relaunchBaseDelayMs;
-    this.relaunchMaxDelayMs = relaunchMaxDelayMs;
     this.monitorIntervalMs = monitorIntervalMs;
     this.runtimeSessionId = runtimeSessionId;
     this.onStatusChange = onStatusChange;
@@ -3764,7 +3770,6 @@ export class CodexRuntime {
     this.targetRefreshQueued = false;
     this.appPid = null;
     this.managedCodexChild = null;
-    this.recoveryPromise = null;
     this.monitorTimer = null;
     this.monitorWake = null;
     this.stopPromise = null;
@@ -3772,20 +3777,35 @@ export class CodexRuntime {
     this.pidChangeQueue = null;
     this.rendererDiscovered = false;
     this.lastRendererStatus = null;
-    this.codexLifecycleManaged = false;
   }
 
-  async start() {
+  async start({ launchCodex = false } = {}) {
     this.stopping = false;
     await mkdir(this.profileDir, { recursive: true });
-    this.codexLifecycleManaged = true;
-    if (!(await this.isAvailable())) {
-      this.launchManagedCodex();
-      await this.waitUntilAvailable();
+    const available = await this.isAvailable();
+    if (!available && launchCodex) {
+      const child = this.launchManagedCodex();
+      try {
+        await this.waitUntilAvailable();
+      } catch (error) {
+        if (this.managedCodexChild === child && !processChildHasExited(child)) {
+          child.kill?.("SIGTERM");
+          const exited = await waitForProcessChildExit(child, 500);
+          if (!exited && !processChildHasExited(child)) {
+            child.kill?.("SIGKILL");
+            await waitForProcessChildExit(child, 500);
+          }
+        }
+        throw error;
+      }
     }
 
-    await this.startTargetDiscovery();
-    await this.refresh();
+    if (available || launchCodex) {
+      await this.startTargetDiscovery();
+      await this.refresh();
+    } else {
+      this.notifyStatusChange();
+    }
     await this.flushManagedCodexPidChange();
     this.monitorPromise = this.monitor();
   }
@@ -3859,14 +3879,10 @@ export class CodexRuntime {
 
   markCodexUnavailable(error) {
     this.clearRendererState();
-    if (this.codexLifecycleManaged && !this.stopping) {
-      this.scheduleCodexRecovery();
-    }
     return error;
   }
 
   launchManagedCodex() {
-    this.codexLifecycleManaged = true;
     const child = this.spawnProcess(
       this.appPath,
       [
@@ -3891,7 +3907,6 @@ export class CodexRuntime {
       this.notifyManagedCodexPidChange(null);
       if (this.stopping) return;
       this.clearRendererState();
-      this.scheduleCodexRecovery();
     };
     child.once?.("exit", onExit);
     child.once?.("error", (error) => {
@@ -3902,73 +3917,6 @@ export class CodexRuntime {
     return child;
   }
 
-  scheduleCodexRecovery() {
-    if (this.stopping || this.recoveryPromise) return this.recoveryPromise;
-    const recovery = this.recoverManagedCodex();
-    let trackedRecovery;
-    trackedRecovery = recovery.finally(() => {
-      if (this.recoveryPromise === trackedRecovery) this.recoveryPromise = null;
-    });
-    this.recoveryPromise = trackedRecovery;
-    return trackedRecovery;
-  }
-
-  async recoverManagedCodex() {
-    let attempt = 0;
-    while (!this.stopping) {
-      if (this.managedCodexChild && !processChildHasExited(this.managedCodexChild)) {
-        await this.sleep(Math.max(1, Math.min(this.relaunchMaxDelayMs, this.relaunchBaseDelayMs || 1)));
-        continue;
-      }
-      if (await this.isAvailable()) {
-        try {
-          await this.startTargetDiscovery();
-          await this.refresh();
-          await this.flushManagedCodexPidChange();
-          return;
-        } catch (error) {
-          if (this.stopping) return;
-          if (await this.isAvailable()) {
-            this.logger.warn?.("Managed Codex CDP is still available; retrying discovery", error.message);
-            await this.sleep(Math.max(1, Math.min(this.relaunchMaxDelayMs, this.relaunchBaseDelayMs || 1)));
-            continue;
-          }
-        }
-      }
-      const delay = Math.min(
-        this.relaunchBaseDelayMs * (2 ** attempt),
-        this.relaunchMaxDelayMs,
-      );
-      if (delay > 0) await this.sleep(delay);
-      if (this.stopping) return;
-      let child;
-      try {
-        child = this.launchManagedCodex();
-        await this.waitUntilAvailable();
-        await this.startTargetDiscovery();
-        await this.refresh();
-        await this.flushManagedCodexPidChange();
-        return;
-      } catch (error) {
-        this.logger.warn?.("Managed Codex recovery retry failed", error.message);
-        if (
-          child
-          && this.managedCodexChild === child
-          && child.exitCode === null
-          && child.signalCode === null
-        ) {
-          child.kill?.("SIGTERM");
-          const exited = await waitForProcessChildExit(child, 500);
-          if (!exited && !processChildHasExited(child)) {
-            child.kill?.("SIGKILL");
-            await waitForProcessChildExit(child, 500);
-          }
-        }
-        attempt += 1;
-      }
-    }
-  }
-
   queueTargetRefresh() {
     if (this.targetRefreshQueued || this.stopping) return;
     this.targetRefreshQueued = true;
@@ -4250,7 +4198,20 @@ export class CodexRuntime {
           bindingToken,
           runtimeSessionId: this.runtimeSessionId,
         });
-        const script = await client.send("Page.addScriptToEvaluateOnNewDocument", { source });
+        const bootstrapExpression = documentBootstrapExpression();
+        const script = await client.send("Page.addScriptToEvaluateOnNewDocument", {
+          source: createDocumentBootstrapSource(source),
+        });
+        const documentWasBootstrapped = Boolean(evaluationValue(await client.send("Runtime.evaluate", {
+          expression: bootstrapExpression,
+          returnByValue: true,
+        })));
+        if (!documentWasBootstrapped) {
+          const pageLoaded = client.waitFor("Page.loadEventFired", 20_000);
+          await client.send("Page.reload");
+          await pageLoaded;
+          await waitForExpression(client, bootstrapExpression);
+        }
         await waitForExpression(
           client,
           `document.readyState === "interactive" || document.readyState === "complete"`,
@@ -4280,7 +4241,6 @@ export class CodexRuntime {
       this.stopping = true;
       this.targetRefreshQueued = false;
       this.monitorWake?.();
-      await this.recoveryPromise?.catch(() => {});
       await this.monitorPromise?.catch(() => {});
       await Promise.all(Array.from(this.clients, async ([targetId, client]) => {
         const identifier = this.scriptIds.get(targetId);

package/packages/runtime-host/src/main.mjs

@@ -17,6 +17,7 @@ const featuresRoot = process.env.CODEX_FEATURES_ROOT ?? path.dirname(runtimeRoot
 const legacyDataDir = process.env.CODEX_IMAGE_HOST_DATA_DIR ?? path.join(os.homedir(), ".codex-image-host");
 const profileDir = process.env.CODEX_RUNTIME_PROFILE_DIR ?? path.join(legacyDataDir, "codex-profile");
 const cdpPort = Number(process.env.CODEX_RUNTIME_CDP_PORT ?? 9231);
+const launchCodex = process.env.MINECODEX_LAUNCH_CODEX === "1";
 
 const discoveredFeatures = await discoverFeatures(featuresRoot);
 if (!discoveredFeatures.length) throw new Error(`No codex-feature.json files found under ${featuresRoot}`);
@@ -70,7 +71,7 @@ runtime = new CodexRuntime({
 });
 
 try {
-  await runtime.start();
+  await runtime.start({ launchCodex });
   runtimeReady = true;
   await writeReadyFile();
 } catch (error) {