minecodex 0.1.5 → 0.1.7

package/README.md

@@ -19,9 +19,11 @@ mcx install
 
 `mcx install` 不会关闭或启动 Codex，也不会改变当前窗口。安装完成后，终端会提示
 MineCodex 将在下次重启 Codex 时启用，并询问是否现在重启；默认答案是 **No**。
-只有用户明确确认，或之后主动运行 `mcx restart`，MineCodex 才会关闭并重新打开
-Codex。安装后，macOS 的“登录项与扩展”中会显示名为 **MineCodex** 的后台项目；
-这个后台项目负责插件与本地控制台，不会在用户退出 Codex 后自动将它重新打开。
+安装过程只有在用户明确确认，或之后主动运行 `mcx restart` 时，才会关闭并重新打开
+Codex。安装后，macOS 的“登录项与扩展”中会显示名为 **MineCodex** 的后台项目。
+这个后台项目负责插件与本地控制台：用户退出 Codex 后，它会保持停止；用户后来从
+Dock 主动打开 Codex 时，这次新启动会被视为明确的启动意图，并切换为可注入的托管
+实例。由于普通 Dock 启动本身没有 CDP，首次切换时 Codex 可能会短暂重开一次。
 
 安装后三个插件默认开启。打开本地控制台：
 

package/features/images/codex-feature.json

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

package/features/images/web/app.js

@@ -303,9 +303,9 @@ function layoutMasonry() {
   const cards = [...grid.children];
   if (!cards.length) return;
 
-  // Keep DOM writes and geometry reads in separate batches so the browser only
-  // needs to resolve layout once, even for a full page of boards.
-  for (const card of cards) card.style.gridRowEnd = "auto";
+  // Existing spans do not affect the intrinsic card boxes because the grid
+  // aligns items to the start. Clearing them here would collapse the 1px row
+  // grid and clamp the user's scroll position before the new spans are applied.
   const blockGap = Number.parseFloat(getComputedStyle(cards[0]).marginBottom);
   const spans = cards.map((card) => (
     Math.ceil((card.getBoundingClientRect().height + blockGap) / rowHeight)

package/features/images/web/styles.css

@@ -617,6 +617,7 @@ h1,
 
 .thread-board-preview img {
   width: 100%;
+  height: auto;
   min-height: 76px;
   aspect-ratio: 16 / 6;
   display: block;

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

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

package/features/notes/codex-feature.json

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

package/features/notes/web/app.js

@@ -1,4 +1,4 @@
-const params = new URLSearchParams(location.search);
+const params = new URL(document.baseURI).searchParams;
 const SUPPORTED_LOCALES = new Set(["en", "zh-CN"]);
 
 function normalizeLocale(value) {

package/package.json

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

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

@@ -19,6 +19,19 @@ function hasExited(child) {
   return Boolean(child && (child.exitCode != null || child.signalCode != null));
 }
 
+function hasExactCommandArgument(command, argument) {
+  const value = String(command);
+  let offset = value.indexOf(argument);
+  while (offset >= 0) {
+    const before = offset === 0 || /\s/.test(value[offset - 1]);
+    const end = offset + argument.length;
+    const after = end === value.length || /\s/.test(value[end]);
+    if (before && after) return true;
+    offset = value.indexOf(argument, offset + 1);
+  }
+  return false;
+}
+
 function normalizedFailure(failure) {
   if (!failure || typeof failure !== "object") return failure ?? null;
   return {
@@ -119,6 +132,8 @@ export class RuntimeManager {
     waitForReady: readyWaiter = waitForReady,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     stopTimeoutMs = 5_000,
+    manualLaunchPollMs = 1_000,
+    cdpPort = Number(process.env.CODEX_RUNTIME_CDP_PORT ?? 9231),
   }) {
     this.paths = paths;
     this.platform = platform;
@@ -127,6 +142,8 @@ export class RuntimeManager {
     this.waitForReady = readyWaiter;
     this.sleep = sleep;
     this.stopTimeoutMs = stopTimeoutMs;
+    this.manualLaunchPollMs = manualLaunchPollMs;
+    this.cdpPort = cdpPort;
     this.child = null;
     this.appliedFeatures = [];
     this.plugins = [];
@@ -134,6 +151,12 @@ export class RuntimeManager {
     this.stopping = false;
     this.lifecycleQueue = Promise.resolve();
     this.restartInFlight = null;
+    this.manualLaunchMonitorPromise = null;
+    this.manualLaunchMonitorStopped = true;
+    this.manualLaunchTimer = null;
+    this.manualLaunchWake = null;
+    this.manualLaunchBaselinePids = new Set();
+    this.manualLaunchArmed = false;
   }
 
   enqueue(operation) {
@@ -163,7 +186,7 @@ export class RuntimeManager {
         ...process.env,
         CODEX_FEATURES_ROOT: this.paths.featuresRoot,
         CODEX_RUNTIME_PROFILE_DIR: this.paths.profileDir,
-        CODEX_RUNTIME_CDP_PORT: process.env.CODEX_RUNTIME_CDP_PORT ?? "9231",
+        CODEX_RUNTIME_CDP_PORT: String(this.cdpPort),
         CODEX_IMAGE_HOST_DATA_DIR: this.paths.imagesDataDir,
         CODEX_NOTES_DATA_DIR: this.paths.notesDataDir,
         MINECODEX_ENABLED_FEATURES: features.join(","),
@@ -228,7 +251,155 @@ export class RuntimeManager {
   }
 
   start() {
-    return this.enqueue(() => this.startInternal());
+    return this.enqueue(async () => {
+      const status = await this.startInternal();
+      await this.startManualLaunchMonitor();
+      return status;
+    });
+  }
+
+  async nativeCodexSnapshot() {
+    if (typeof this.platform?.snapshotNativeCodexState !== "function") return null;
+    const snapshot = await this.platform.snapshotNativeCodexState();
+    const cdpArgument = `--remote-debugging-port=${this.cdpPort}`;
+    const processes = (Array.isArray(snapshot?.processes) ? snapshot.processes : [])
+      .filter(({ command }) => !hasExactCommandArgument(command, cdpArgument));
+    return {
+      count: processes.length,
+      processes,
+      pids: new Set(processes.flatMap(({ pid }) => Number.isInteger(pid) ? [pid] : [])),
+    };
+  }
+
+  async startManualLaunchMonitor() {
+    if (this.manualLaunchMonitorPromise || typeof this.platform?.snapshotNativeCodexState !== "function") return;
+    const snapshot = await this.nativeCodexSnapshot();
+    this.manualLaunchBaselinePids = new Set(snapshot?.pids ?? []);
+    this.manualLaunchArmed = this.manualLaunchBaselinePids.size === 0;
+    this.manualLaunchMonitorStopped = false;
+    const monitor = this.monitorManualCodexLaunches().catch((error) => {
+      if (!this.manualLaunchMonitorStopped) {
+        this.logger.warn?.("MineCodex manual Codex launch monitor failed", error.message);
+      }
+    }).finally(() => {
+      if (this.manualLaunchMonitorPromise === monitor) this.manualLaunchMonitorPromise = null;
+    });
+    this.manualLaunchMonitorPromise = monitor;
+  }
+
+  waitForManualLaunchPoll() {
+    if (this.manualLaunchMonitorStopped) return Promise.resolve();
+    return new Promise((resolve) => {
+      const finish = () => {
+        if (this.manualLaunchTimer) clearTimeout(this.manualLaunchTimer);
+        this.manualLaunchTimer = null;
+        this.manualLaunchWake = null;
+        resolve();
+      };
+      this.manualLaunchWake = finish;
+      this.manualLaunchTimer = setTimeout(finish, this.manualLaunchPollMs);
+    });
+  }
+
+  async monitorManualCodexLaunches() {
+    while (!this.manualLaunchMonitorStopped) {
+      await this.waitForManualLaunchPoll();
+      if (this.manualLaunchMonitorStopped) break;
+      try {
+        await this.reconcileManualCodexLaunch();
+      } catch (error) {
+        this.logger.warn?.("MineCodex could not adopt the Codex launch", error.message);
+      }
+    }
+  }
+
+  async stopManualLaunchMonitor() {
+    this.manualLaunchMonitorStopped = true;
+    this.manualLaunchWake?.();
+    await this.manualLaunchMonitorPromise;
+    this.manualLaunchMonitorPromise = null;
+    this.manualLaunchBaselinePids.clear();
+    this.manualLaunchArmed = false;
+  }
+
+  async reconcileManualCodexLaunch() {
+    if (this.manualLaunchMonitorStopped) return false;
+    const snapshot = await this.nativeCodexSnapshot();
+    if (!snapshot) return false;
+
+    if (this.manualLaunchBaselinePids.size > 0) {
+      const baselineStillRunning = [...this.manualLaunchBaselinePids]
+        .some((pid) => snapshot.pids.has(pid));
+      if (baselineStillRunning) return false;
+      this.manualLaunchBaselinePids.clear();
+      if (snapshot.count === 0) {
+        this.manualLaunchArmed = true;
+        return false;
+      }
+      this.manualLaunchArmed = true;
+    }
+
+    if (snapshot.count === 0) {
+      this.manualLaunchArmed = true;
+      return false;
+    }
+    if (!this.manualLaunchArmed) return false;
+
+    const observedPids = new Set(snapshot.pids);
+    this.manualLaunchArmed = false;
+    this.manualLaunchBaselinePids = observedPids;
+    return this.enqueue(async () => {
+      if (this.manualLaunchMonitorStopped) return false;
+      const latest = await this.nativeCodexSnapshot();
+      const observedProcessStillRunning = latest
+        && [...observedPids].some((pid) => latest.pids.has(pid));
+      if (!observedProcessStillRunning) {
+        if (!latest?.count) {
+          this.manualLaunchBaselinePids.clear();
+          this.manualLaunchArmed = true;
+        }
+        return false;
+      }
+
+      await this.stopInternal();
+      let terminated;
+      try {
+        terminated = await this.platform.terminateNativeCodex();
+      } catch (error) {
+        await this.restoreIdleRuntimeAfterAdoptionFailure(error);
+        throw error;
+      }
+
+      if (!(terminated > 0)) {
+        await this.startInternal();
+        this.manualLaunchBaselinePids.clear();
+        this.manualLaunchArmed = true;
+        return false;
+      }
+
+      try {
+        const status = await this.startInternal({ launchCodex: true });
+        this.manualLaunchBaselinePids.clear();
+        this.manualLaunchArmed = true;
+        return status;
+      } catch (error) {
+        this.manualLaunchBaselinePids.clear();
+        this.manualLaunchArmed = true;
+        await this.restoreIdleRuntimeAfterAdoptionFailure(error);
+        throw error;
+      }
+    });
+  }
+
+  async restoreIdleRuntimeAfterAdoptionFailure(failure) {
+    try {
+      await this.startInternal();
+    } catch (recoveryError) {
+      throw new Error(
+        `${failure.message}; idle RuntimeHost recovery failed: ${recoveryError.message}`,
+        { cause: failure },
+      );
+    }
   }
 
   async stopInternal() {
@@ -274,7 +445,8 @@ export class RuntimeManager {
     }
   }
 
-  stop() {
+  async stop() {
+    await this.stopManualLaunchMonitor();
     return this.enqueue(() => this.stopInternal());
   }
 

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

@@ -51,12 +51,25 @@ function declaredSurfaceUrls(feature) {
 }
 
 function requireDeclaredLoopbackSurface(feature, value) {
-  if (typeof value !== "string" || !declaredSurfaceUrls(feature).has(value)) {
+  if (typeof value !== "string") {
     throw Object.assign(new Error("Surface URL is not declared by this feature"), {
       code: "SURFACE_URL_NOT_ALLOWED",
     });
   }
   const url = new URL(value);
+  const matchesDeclaredDocument = Array.from(declaredSurfaceUrls(feature), (declared) => new URL(declared))
+    .some((declared) => (
+      declared.origin === url.origin
+      && declared.username === url.username
+      && declared.password === url.password
+      && declared.pathname === url.pathname
+      && declared.hash === url.hash
+    ));
+  if (!matchesDeclaredDocument) {
+    throw Object.assign(new Error("Surface URL is not declared by this feature"), {
+      code: "SURFACE_URL_NOT_ALLOWED",
+    });
+  }
   if (url.protocol !== "http:" || !LOOPBACK_SURFACE_HOSTS.has(url.hostname)) {
     throw Object.assign(new Error("Surface URL must use an exact loopback HTTP origin"), {
       code: "SURFACE_URL_NOT_ALLOWED",
@@ -2541,7 +2554,7 @@ export function createInjectionSource(features, {
 
       closePromptPreview({ immediate: true });
       closeModalSurface();
-      const editorUrl = new URL(sourceRecord.frame.src);
+      const editorUrl = new URL(sourceRecord.surfaceUrl);
       editorUrl.searchParams.set("surface", "editor");
       editorUrl.searchParams.set("kind", kind);
       if (typeof payload.id === "string" && payload.id) editorUrl.searchParams.set("id", payload.id);