mesurer-solid 0.2.1 → 0.2.2-beta.0

package/codex/codex-connect.mjs

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+const DEFAULT_BRIDGE = "http://127.0.0.1:47365";
+
+const BRIDGE_NAME = "mesurer-codex";
+
+const BRIDGE_PROTOCOL_VERSION = 2;
+
+const REQUIRED_BRIDGE_CAPABILITIES = [
+  "thread-discovery-v1",
+  "durable-queue-v1",
+  "history-recovery-v2",
+  "client-message-correlation-v1",
+  "idle-safe-shutdown-v1",
+  "nonterminal-retention-v1",
+  "instance-binding-v1",
+];
+
+const IDLE_SAFE_SHUTDOWN_CAPABILITY = "idle-safe-shutdown-v1";
+
+const START_TIMEOUT_MS = 10_000;
+
+const POLL_INTERVAL_MS = 100;
+
+const usage = `Usage:
+  mesurer-codex-connect [options]
+
+Ensures the Mesurer Codex bridge is running, then registers one Codex session
+and makes that session the active Mesurer destination.
+
+Options:
+  --thread <value>   Codex session UUID or exact session name
+  --session-start    Read a Codex SessionStart hook event from stdin
+  --session-end      Read a Codex SessionEnd hook event from stdin
+  --bridge <url>     Bridge URL (default: ${DEFAULT_BRIDGE})
+  --codex <path>     Codex executable passed to a newly-started bridge
+  --once             Start a new bridge with --once (primarily useful for tests)
+  --quiet            Suppress success output
+  --help             Show this help
+
+Without --thread or --session-start, CODEX_THREAD_ID is used when available.
+`;
+
+const { values } = parseArgs({
+  options: {
+    thread: { type: "string" },
+    "session-start": { type: "boolean", default: false },
+    "session-end": { type: "boolean", default: false },
+    bridge: { type: "string", default: DEFAULT_BRIDGE },
+    codex: { type: "string" },
+    once: { type: "boolean", default: false },
+    quiet: { type: "boolean", default: false },
+    help: { type: "boolean", default: false },
+  },
+  allowPositionals: false,
+  strict: true,
+});
+
+if (values.help) {
+  process.stdout.write(usage);
+  process.exit(0);
+}
+
+const fail = (message, code = 1) => {
+  process.stderr.write(`${message}\n`);
+  process.exit(code);
+};
+
+const readStdin = async () => {
+  process.stdin.setEncoding("utf8");
+  let input = "";
+
+  for await (const chunk of process.stdin) input += chunk;
+
+  return input;
+};
+
+const explicitThread = values.thread?.trim() || null;
+
+const fromSessionStart = values["session-start"];
+
+const fromSessionEnd = values["session-end"];
+
+const routingModes = [Boolean(explicitThread), fromSessionStart, fromSessionEnd].filter(Boolean).length;
+
+if (routingModes > 1) {
+  fail("Use only one of --thread, --session-start, or --session-end.", 2);
+}
+
+let thread = explicitThread ?? process.env.CODEX_THREAD_ID?.trim() ?? null;
+
+let cwd = process.cwd();
+
+if (fromSessionStart || fromSessionEnd) {
+  const input = await readStdin();
+  let event;
+
+  try {
+    event = JSON.parse(input);
+  } catch {
+    fail(
+      fromSessionStart
+        ? "--session-start requires one Codex SessionStart JSON event on stdin."
+        : "--session-end requires one Codex SessionEnd JSON event on stdin.",
+      2,
+    );
+  }
+
+  const expectedEvent = fromSessionStart ? "SessionStart" : "SessionEnd";
+
+  if (event?.hook_event_name !== expectedEvent) {
+    fail(`Expected hook_event_name ${expectedEvent}, got ${event?.hook_event_name ?? "<missing>"}.`, 2);
+  }
+
+  thread = event?.session_id?.trim?.() || null;
+  cwd = event?.cwd?.trim?.() || cwd;
+}
+
+if (!thread) {
+  fail(
+    fromSessionStart
+      ? "Codex SessionStart input did not include a session_id."
+      : fromSessionEnd
+        ? "Codex SessionEnd input did not include a session_id."
+        : "mesurer-codex-connect requires --thread, CODEX_THREAD_ID, --session-start, or --session-end.",
+    2,
+  );
+}
+
+const quiet = values.quiet || fromSessionStart || fromSessionEnd;
+
+const bridge = values.bridge?.trim() || DEFAULT_BRIDGE;
+
+const bridgeUrl = new URL(bridge.endsWith("/") ? bridge : `${bridge}/`);
+
+const isLoopbackHost = (hostname) =>
+  hostname === "127.0.0.1"
+  || hostname === "localhost"
+  || hostname === "::1"
+  || hostname === "[::1]";
+
+if (bridgeUrl.protocol !== "http:" || !isLoopbackHost(bridgeUrl.hostname)) {
+  fail(`Automatic bridge startup requires a loopback HTTP URL, got ${bridge}.`, 2);
+}
+
+if (bridgeUrl.pathname !== "/" || bridgeUrl.search || bridgeUrl.hash) {
+  fail(`Automatic bridge startup requires a root bridge URL, got ${bridge}.`, 2);
+}
+
+const port = bridgeUrl.port ? Number(bridgeUrl.port) : 80;
+
+if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+  fail(`Invalid bridge port in ${bridge}.`, 2);
+}
+
+const bridgeScript = fileURLToPath(new URL("./codex-bridge.mjs", import.meta.url));
+
+const expectedSourceHash = createHash("sha256")
+  .update(await readFile(bridgeScript))
+  .digest("hex");
+
+const readPayload = async (response) => {
+  const text = await response.text();
+
+  if (!text) return {};
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { error: text };
+  }
+};
+
+const health = async () => {
+  let response;
+
+  try {
+    response = await fetch(new URL("health", bridgeUrl));
+  } catch {
+    return null;
+  }
+
+  const payload = await readPayload(response);
+
+  if (!response.ok || payload.ok !== true) {
+    throw new Error(
+      payload.error || `Unexpected service at ${bridgeUrl.origin}: HTTP ${response.status}.`,
+    );
+  }
+
+  return payload;
+};
+
+const waitForBridge = async () => {
+  const deadline = Date.now() + START_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    const payload = await health();
+
+    if (payload) return payload;
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+
+  throw new Error(`Mesurer Codex bridge did not become ready at ${bridgeUrl.origin}.`);
+};
+
+const bridgeCapabilities = (payload) =>
+  Array.isArray(payload?.bridge?.capabilities) ? payload.bridge.capabilities : [];
+
+const isCompatibleBridge = (payload) => {
+  if (payload?.bridge?.name !== BRIDGE_NAME) return false;
+
+  if (payload.bridge.protocol !== BRIDGE_PROTOCOL_VERSION) return false;
+
+  const capabilities = new Set(bridgeCapabilities(payload));
+
+  return REQUIRED_BRIDGE_CAPABILITIES.every((capability) => capabilities.has(capability));
+};
+
+const isMesurerBridge = (payload) => payload?.bridge?.name === BRIDGE_NAME;
+
+const isExactBridge = (payload) =>
+  isCompatibleBridge(payload)
+  && payload.bridge.sourceHash === expectedSourceHash;
+
+if (fromSessionEnd) {
+  let current;
+
+  try {
+    current = await health();
+  } catch {
+    process.exit(0);
+  }
+
+  if (!current || !isMesurerBridge(current)) process.exit(0);
+
+  let response;
+
+  try {
+    response = await fetch(new URL("threads/unregister", bridgeUrl), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ thread }),
+      signal: AbortSignal.timeout(750),
+    });
+  } catch {
+    process.exit(0);
+  }
+
+  const payload = await readPayload(response);
+
+  if (!response.ok || payload.ok === false) process.exit(0);
+
+  process.exit(0);
+}
+
+const waitForBridgeToStop = async () => {
+  const deadline = Date.now() + START_TIMEOUT_MS;
+  let unavailableChecks = 0;
+
+  while (Date.now() < deadline) {
+    if (await health()) {
+      unavailableChecks = 0;
+    } else {
+      unavailableChecks += 1;
+
+      if (unavailableChecks >= 3) return;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+
+  throw new Error(`Stale Mesurer Codex bridge did not stop at ${bridgeUrl.origin}.`);
+};
+
+const bridgeUsage = (payload) => ({
+  registeredThreads: Number(payload?.bridgeState?.registeredThreads) || 0,
+  nonTerminalDeliveries: Number(payload?.bridgeState?.nonTerminalDeliveries) || 0,
+  idle: payload?.bridgeState?.idle === true,
+});
+
+const replaceStaleBridge = async (payload) => {
+  if (payload?.bridge?.name !== BRIDGE_NAME || payload.bridge.canShutdown !== true) return false;
+
+  if (!bridgeCapabilities(payload).includes(IDLE_SAFE_SHUTDOWN_CAPABILITY)) return false;
+
+  if (!bridgeUsage(payload).idle) return false;
+
+  let response;
+
+  try {
+    response = await fetch(new URL("shutdown", bridgeUrl), { method: "POST" });
+  } catch (cause) {
+    const error = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(`Could not stop stale Mesurer Codex bridge at ${bridgeUrl.origin}: ${error}`);
+  }
+
+  const body = await readPayload(response);
+
+  if (!response.ok || body.ok === false) {
+    throw new Error(body.error || `Stale Mesurer Codex bridge returned HTTP ${response.status} while stopping.`);
+  }
+
+  await waitForBridgeToStop();
+
+  return true;
+};
+
+let current;
+
+try {
+  current = await health();
+} catch (cause) {
+  fail(cause instanceof Error ? cause.message : String(cause));
+}
+
+if (current && !isCompatibleBridge(current)) {
+  let replaced = false;
+
+  try {
+    replaced = await replaceStaleBridge(current);
+  } catch (cause) {
+    fail(cause instanceof Error ? cause.message : String(cause));
+  }
+
+  if (replaced) {
+    current = null;
+  } else if (current?.bridge?.name === BRIDGE_NAME) {
+    const usage = bridgeUsage(current);
+    const source = current.bridge.sourceHash?.slice?.(0, 12) ?? "unknown";
+    const protocol = current.bridge.protocol ?? "unknown";
+
+    if (!bridgeCapabilities(current).includes(IDLE_SAFE_SHUTDOWN_CAPABILITY)) {
+      fail(
+        `An incompatible Mesurer Codex Bridge is already running at ${bridgeUrl.origin} (protocol ${protocol}, source ${source}). It cannot prove idle-safe replacement, so Mesurer will not stop it automatically. Close the Codex sessions using that bridge, let it exit, then retry.`,
+      );
+    }
+
+    fail(
+      `An incompatible Mesurer Codex Bridge is still in use at ${bridgeUrl.origin} (protocol ${protocol}, source ${source}; ${usage.registeredThreads} registered thread(s), ${usage.nonTerminalDeliveries} queued/working delivery(s)). Mesurer will not interrupt it. Close those Codex sessions or wait for their deliveries to finish, then retry.`,
+    );
+  } else if (!current.bridge && Array.isArray(current.threads)) {
+    fail(
+      `An older Mesurer Codex bridge is already running at ${bridgeUrl.origin}. Stop that legacy bridge once, then rerun mesurer-codex-connect. Refusing to reuse it because its source identity cannot be verified.`,
+    );
+  } else {
+    fail(
+      `Another local service is already using ${bridgeUrl.origin}. Mesurer will not replace or send data to an unverified service.`,
+    );
+  }
+}
+
+if (!current) {
+  const args = [bridgeScript, "--port", String(port), "--thread", thread, "--cwd", cwd];
+
+  if (values.codex?.trim()) args.push("--codex", values.codex.trim());
+
+  if (values.once) args.push("--once");
+
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    env: process.env,
+    shell: false,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+
+  child.unref();
+
+  try {
+    current = await waitForBridge();
+  } catch (cause) {
+    fail(cause instanceof Error ? cause.message : String(cause));
+  }
+
+  if (!isExactBridge(current)) {
+    fail(`Mesurer Codex bridge at ${bridgeUrl.origin} started with an unexpected source identity.`);
+  }
+}
+
+const registration = { thread, cwd };
+
+const appToolsPipe = process.env.CODEX_APP_TOOLS_PIPE_PATH?.trim();
+
+if (appToolsPipe) registration.appToolsPipe = appToolsPipe;
+
+const codexHome = process.env.CODEX_HOME?.trim();
+
+if (codexHome) registration.codexHome = codexHome;
+
+let response;
+
+try {
+  response = await fetch(new URL("threads/register", bridgeUrl), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(registration),
+  });
+} catch (cause) {
+  const error = cause instanceof Error ? cause.message : String(cause);
+  fail(`Could not register Codex thread with ${bridgeUrl.origin}: ${error}`);
+}
+
+const payload = await readPayload(response);
+
+if (!response.ok || payload.ok === false) {
+  fail(payload.error || `Mesurer Codex bridge returned HTTP ${response.status}.`);
+}
+
+if (!quiet) {
+  console.log(`Mesurer Codex bridge ready: ${bridgeUrl.origin}`);
+  console.log(`Registered Codex thread: ${thread}`);
+  console.log(`BRIDGE_URL=${bridgeUrl.origin}`);
+  console.log(`BRIDGE_THREAD=${thread}`);
+}

package/codex/codex-lifecycle.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+
+const DEFAULT_BRIDGE = "http://127.0.0.1:47365";
+
+const { values } = parseArgs({
+  options: {
+    bridge: { type: "string", default: DEFAULT_BRIDGE },
+  },
+  allowPositionals: false,
+  strict: true,
+});
+
+const readStdin = async () => {
+  process.stdin.setEncoding("utf8");
+  let input = "";
+
+  for await (const chunk of process.stdin) input += chunk;
+
+  return input;
+};
+
+try {
+  const input = await readStdin();
+  const event = JSON.parse(input);
+  const eventName = event?.hook_event_name;
+
+  if (!["UserPromptSubmit", "Stop", "Interrupt"].includes(eventName)) process.exit(0);
+
+  const sessionId = event?.session_id?.trim?.() || null;
+  const turnId = event?.turn_id?.trim?.() || null;
+
+  if (!sessionId || !turnId) process.exit(0);
+
+  const bridge = values.bridge?.trim() || DEFAULT_BRIDGE;
+  const base = bridge.endsWith("/") ? bridge : `${bridge}/`;
+  await fetch(new URL("lifecycle", base), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      event: eventName,
+      sessionId,
+      turnId,
+      prompt: eventName === "UserPromptSubmit" ? event?.prompt ?? "" : undefined,
+      stopHookActive: eventName === "Stop" ? event?.stop_hook_active === true : undefined,
+    }),
+  }).catch(() => undefined);
+} catch {
+  // Lifecycle telemetry is best-effort and must never block or inject output into Codex.
+}

package/dist/context.d.ts

@@ -314,6 +314,7 @@ export type MesurerWorkspaceContextSource = {
             position: number;
         }>;
     } | null;
+    elementRect?(element: Element): MesurerContextRect;
     currentSelection(): {
         elements: Element[];
         region: MesurerContextRect | null;