mesurer-solid 0.2.0-beta.8 → 0.2.0

package/plugins/codex/desktop.mjs

@@ -0,0 +1,155 @@
+import { spawn } from "node:child_process";
+
+const DESKTOP_COMMAND_TIMEOUT_MS = 10_000;
+
+const normalizeString = (value) => {
+  if (value?.constructor !== String) return null;
+
+  const text = value.trim();
+
+  return text || null;
+};
+
+export const desktopSessionFromEnvironment = (env = process.env) => {
+  const thread = normalizeString(env.CODEX_THREAD_ID);
+  const appToolsPipe = normalizeString(env.CODEX_APP_TOOLS_PIPE_PATH);
+
+  if (!thread || !appToolsPipe) return null;
+
+  return {
+    thread,
+    appToolsPipe,
+  };
+};
+
+const run = (
+  command,
+  args,
+  env,
+  timeoutMs,
+  label,
+) => new Promise((resolve, reject) => {
+  const child = spawn(command, args, {
+    env,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+
+  const finish = (error, output) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeout);
+
+    if (error) reject(error);
+    else resolve(output);
+  };
+
+  const timeout = setTimeout(() => {
+    if (child.exitCode === null) child.kill("SIGTERM");
+
+    finish(new Error(`${label} timed out after ${timeoutMs}ms.`));
+  }, timeoutMs);
+
+  child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+  child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (code === 0) {
+      finish(null, stdout.trim());
+
+      return;
+    }
+
+    const detail = stderr.trim()
+      || stdout.trim()
+      || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+
+    finish(new Error(`${label} failed: ${detail}`));
+  });
+});
+
+const queuedSubmissionId = (output, thread) => {
+  const escapedThread = thread.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+  const exact = output.match(new RegExp(
+    `Queued message\\s+(\\S+)\\s+for thread\\s+${escapedThread}\\.?`,
+  ));
+
+  if (exact?.[1]) return exact[1];
+
+  const generic = output.match(/Queued message\s+(\S+)\s+for thread\s+\S+\.?/);
+
+  return generic?.[1] ?? null;
+};
+
+export const queueDesktopThread = async ({
+  command,
+  thread,
+  message,
+  env = process.env,
+}) => {
+  const output = await run(
+    command,
+    ["queue", "--thread", thread, "--message", message],
+    env,
+    DESKTOP_COMMAND_TIMEOUT_MS,
+    "Codex Desktop queue",
+  );
+
+  const submissionId = queuedSubmissionId(output, thread);
+
+  if (!submissionId) {
+    throw new Error("Codex queued the Desktop message without a recognizable submission id.");
+  }
+
+  return {
+    output,
+    queuedSubmissionId: submissionId,
+  };
+};
+
+export const openDesktopThread = async ({
+  thread,
+  env = process.env,
+  platform = process.platform,
+}) => {
+  const url = `codex://threads/${thread}`;
+  const override = normalizeString(env.MESURER_CODEX_DESKTOP_OPEN_BIN);
+
+  let command;
+  let args;
+
+  if (override) {
+    command = override;
+    args = [url];
+  } else if (platform === "darwin") {
+    command = "/usr/bin/open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "powershell.exe";
+    const quotedUrl = url.replaceAll("'", "''");
+
+    args = [
+      "-NoProfile",
+      "-Command",
+      `Start-Process -FilePath '${quotedUrl}'`,
+    ];
+  } else {
+    throw new Error(`Codex Desktop thread wake is unsupported on platform ${platform}.`);
+  }
+
+  await run(
+    command,
+    args,
+    env,
+    DESKTOP_COMMAND_TIMEOUT_MS,
+    "Codex Desktop thread wake",
+  );
+
+  return url;
+};

package/scripts/install-skill.mjs

@@ -14,9 +14,6 @@ if (command !== "install") {
 } else {
   const source = new URL("../skills/mesurer-ui/", import.meta.url);
   const injector = new URL("../dist/inject-script.js", import.meta.url);
-  const codexBridge = new URL("../codex/codex-bridge.mjs", import.meta.url);
-  const codexConnect = new URL("../codex/codex-connect.mjs", import.meta.url);
-  const codexLifecycle = new URL("../codex/codex-lifecycle.mjs", import.meta.url);
   const destination = resolve(process.cwd(), ".agents/skills/mesurer-ui");
   const assets = resolve(destination, "assets");
 
@@ -26,18 +23,12 @@ if (command !== "install") {
   } else if (!existsSync(injector)) {
     console.error("Mesurer inject-script asset is missing. Reinstall mesurer-solid and retry.");
     process.exitCode = 1;
-  } else if (!existsSync(codexBridge) || !existsSync(codexConnect) || !existsSync(codexLifecycle)) {
-    console.error("Mesurer Codex companion assets are missing. Reinstall mesurer-solid and retry.");
-    process.exitCode = 1;
   } else {
     if (force) rmSync(destination, { recursive: true, force: true });
     mkdirSync(resolve(destination, ".."), { recursive: true });
     cpSync(source, destination, { recursive: true });
     mkdirSync(assets, { recursive: true });
     cpSync(injector, resolve(assets, "inject-script.js"));
-    cpSync(codexBridge, resolve(assets, "codex-bridge.mjs"));
-    cpSync(codexConnect, resolve(assets, "codex-connect.mjs"));
-    cpSync(codexLifecycle, resolve(assets, "codex-lifecycle.mjs"));
-    console.log(`Installed Mesurer Agent Skill and assets at ${destination}`);
+    console.log(`Installed Mesurer Agent Skill and injector at ${destination}`);
   }
 }

package/skills/mesurer-ui/SKILL.md

@@ -7,9 +7,9 @@ description: Use Mesurer for frontend UI implementation, review, debugging, layo
 
 Mesurer is shared visual state between the person reviewing a page and the coding agent editing it. The rendered page is the integration boundary.
 
-The normal coding-agent workflow requires no Mesurer MCP server, chat-delivery daemon, or Send-to-agent callback. Use the browser/evaluation channel the browser controller already provides and read `window.__MESURER__` directly. The optional `codex()` plugin and local Codex companion are a separate human-initiated convenience for routing Context feedback to explicitly registered Codex threads.
+The normal coding-agent workflow requires no Mesurer MCP server, chat-delivery daemon, or Send-to-agent callback. Use the browser/evaluation channel the browser controller already provides and read `window.__MESURER__` directly. The first-party `codex()` plugin is a separate human-initiated convenience for routing Context feedback through the application's native Codex host capability.
 
-When the current agent is Codex and the user has explicitly asked for Codex delivery, or the live Mesurer instance already has `mesurer.codex` enabled, ensure the packaged local companion is ready from the Codex process. Do not expect browser JavaScript to spawn a local executable.
+Do not add a second Mesurer process for Codex delivery. Native applications expose the narrow `window.__MESURER_HOST__.codexBridge(request)` capability. Shared sessions use Codex's local app-server. When the native host inherited both `CODEX_THREAD_ID` and `CODEX_APP_TOOLS_PIPE_PATH` from Codex Desktop, Mesurer may queue only to that exact thread and wake it through `codex://threads/<id>`. Treat the app-tools pipe as an ownership signal only; never connect to, proxy, or invoke it. A Desktop-bundled Codex executable must never be used to bootstrap the shared daemon.
 
 A meaningful Mesurer step must return evidence the agent actually uses.
 
@@ -290,39 +290,22 @@ The optional Screenshot plugin is a separate human camera workflow. Native host
 
 ## Optional Codex thread handoff
 
-Use this only when the user asked for Mesurer-to-Codex delivery or the live Mesurer instance already has `mesurer.codex` enabled. Normal agent work still uses `window.__MESURER__` and browser verification.
+Use this only when the user asked for Mesurer-to-Codex delivery or the live Mesurer instance has `mesurer.codex` enabled. Normal agent work still uses `window.__MESURER__` and browser verification.
 
-When this task is running inside Codex, check whether the live page already has the plugin:
-
-```js
-const codexEnabled = Boolean(
-  window.__MESURER_INSTANCE__?.pluginHost?.has("mesurer.codex")
-)
-```
-
-If delivery was requested or `codexEnabled` is true, start or reuse the packaged companion from the Codex shell or tool environment:
-
-```bash
-node .agents/skills/mesurer-ui/assets/codex-connect.mjs
-```
-
-Inside the Mesurer Solid repository, use:
-
-```bash
-bun run mesurer-codex-connect
-```
+Codex delivery uses the native host's in-process Codex Bridge. There is no Mesurer Codex server, bridge port, marketplace plugin, SessionStart hook, or thread-registration command.
 
 Keep these delivery rules:
 
 - Mesurer uses Queue, never `turn/steer`.
-- Codex's native durable queue is the message source of truth.
-- Desktop delivery queues once, keeps the queued-submission id, and opens the existing `codex://threads/<threadId>` destination. Do not use the Desktop app-tools pipe as a second delivery path.
-- Do not delete and resend a queued item after a bridge restart. The bridge persistence file tracks lifecycle; it is not another message queue.
-- The browser plugin connects lazily when the human first queues feedback or opens the thread picker. Do not add mount-time loopback polling.
-- Each page keeps its originating or explicitly chosen thread in per-tab state. If routing is ambiguous, require a human choice.
+- Codex's shared app-server and durable queue are the message source of truth.
+- Only threads reported as loaded by Codex are sendable.
+- The host-side bridge uses `thread/queue/add` directly. Do not shell through `codex queue` or start a parallel app-server.
+- Mesurer's persistence file tracks correlation and lifecycle; it is not another message queue.
+- Each page keeps its explicitly chosen thread in per-tab state. If routing is ambiguous, require a human choice.
 - Queue submission is single-flight. Do not bypass duplicate suppression with a second request.
-- A completed matched turn may remove only the annotation ids included in that delivery. Interrupted, failed, or uncertain work keeps them.
-- Mesurer does not create Codex threads. Create or open the thread in Codex and let the trusted `SessionStart` connector register it.
+- A completed matched turn may remove only the annotation ids included in that delivery. Interrupted, failed, ambiguous, or unreadable work keeps them.
+- Mesurer does not create Codex threads. Create or open the thread in Codex first, then use it once Codex reports it as loaded.
+- Do not stop Codex's shared app-server daemon when Mesurer closes.
 
 The typed `codex:v1` service supports `health()`, `listThreads()`, `useThread(thread)`, `delivery(deliveryId)`, and `queue({ thread })`. `send()` is retained only as a compatibility alias. Generic automation uses `codex.queue`; `codex.send` remains its compatibility alias.