mesurer-solid 0.2.1-beta.0 → 0.2.1-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mesurer-solid",
-  "version": "0.2.1-beta.0",
+  "version": "0.2.1-beta.2",
   "description": "Framework-agnostic UI measurement and inspection tools for browser apps and coding agents.",
   "license": "MIT",
   "type": "module",
@@ -32,6 +32,11 @@
     "./plugins/codex/bridge": {
       "types": "./plugins/codex/bridge.d.ts",
       "default": "./plugins/codex/bridge.mjs"
+    },
+    "./plugins/codex/preload": {
+      "types": "./plugins/codex/preload.d.ts",
+      "import": "./plugins/codex/preload.mjs",
+      "require": "./plugins/codex/preload.cjs"
     }
   },
   "files": [

package/plugins/codex/bridge.d.ts

@@ -1,4 +1,6 @@
 export type CodexBridgeAction =
+  | "activate"
+  | "deactivate"
   | "runtime"
   | "health"
   | "threads"
@@ -9,6 +11,7 @@ export type CodexBridgeAction =
 
 export type CodexBridgeRequest = {
   action: CodexBridgeAction;
+  leaseId?: string;
   thread?: string;
   limit?: number;
   message?: string;
@@ -21,6 +24,8 @@ export type CodexBridgeOptions = {
   codex?: string;
   /** Codex state directory. Defaults to CODEX_HOME, then ~/.codex. */
   codexHome?: string;
+  /** Native host client identity. Electron hosts should derive this from the invoking WebContents. */
+  clientId?: string;
 };
 
 export type CodexBridgeRuntime = {
@@ -39,6 +44,8 @@ export type CodexBridgeThread = {
 
 export type CodexBridgeResponse = {
   ok: true;
+  leaseId?: string;
+  released?: boolean;
   runtime?: CodexBridgeRuntime;
   thread?: string | null;
   threads?: string[];
@@ -61,3 +68,30 @@ export function codexBridge(
   request: CodexBridgeRequest,
   options?: CodexBridgeOptions,
 ): Promise<CodexBridgeResponse>;
+
+export type MesurerCodexHostEvent = {
+  sender: {
+    id: number;
+    on?(event: "did-navigate" | "render-process-gone" | "destroyed", listener: () => void): void;
+    removeListener?(event: "did-navigate" | "render-process-gone" | "destroyed", listener: () => void): void;
+  };
+  senderFrame?: { parent?: object | null } | null;
+};
+
+export type MesurerCodexHostOptions = Omit<CodexBridgeOptions, "clientId"> & {
+  ipcMain: {
+    handle(channel: string, listener: (event: MesurerCodexHostEvent, request: CodexBridgeRequest) => CodexBridgeResponse | Promise<CodexBridgeResponse>): void;
+    removeHandler(channel: string): void;
+  };
+  channel?: string;
+  validateSender(event: MesurerCodexHostEvent): boolean | Promise<boolean>;
+};
+
+export type MesurerCodexHost = {
+  channel: string;
+  dispose(): void;
+};
+
+export const MESURER_CODEX_BRIDGE_CHANNEL: "mesurer:codex-bridge";
+
+export function installMesurerCodexHost(options: MesurerCodexHostOptions): MesurerCodexHost;

package/plugins/codex/bridge.mjs

@@ -29,6 +29,8 @@ const MAX_DELIVERIES = 100;
 
 const deliveries = new Map();
 
+const leases = new Map();
+
 let deliveryStateLoadPromise = null;
 
 let loadedDeliveryStatePath = null;
@@ -51,6 +53,37 @@ const normalizeTitle = (value) => {
 
 const normalizeTimestamp = (value) => Number.isFinite(value) ? Number(value) : null;
 
+const bridgeClientId = (options) => normalizeString(options.clientId) ?? "direct";
+
+const requireLease = (request, options) => {
+  const leaseId = normalizeString(request.leaseId);
+
+  if (!leaseId) throw new Error("Codex Bridge request requires an active lease.");
+
+  const lease = leases.get(leaseId);
+
+  if (!lease || lease.clientId !== bridgeClientId(options)) {
+    throw new Error("Codex Bridge lease is not active for this host client.");
+  }
+
+  return lease;
+};
+
+const releaseCodexBridgeClient = (clientId) => {
+  const normalized = normalizeString(clientId);
+
+  if (!normalized) return 0;
+  let released = 0;
+
+  for (const [leaseId, lease] of leases) {
+    if (lease.clientId !== normalized) continue;
+    leases.delete(leaseId);
+    released += 1;
+  }
+
+  return released;
+};
+
 const shortThread = (thread) => thread.length > 16
   ? `${thread.slice(0, 8)}…${thread.slice(-4)}`
   : thread;
@@ -1233,6 +1266,125 @@ const restoreDelivery = async (request, options, desktop = null) => {
   };
 };
 
+const activateBridge = async (request, options) => {
+  const desktop = await desktopTransport(options);
+
+  await ensureDeliveriesLoaded(options);
+
+  const ready = desktop
+    ? desktopHealth(desktop)
+    : await health(normalizeString(request.thread), options);
+
+  const leaseId = randomUUID();
+
+  leases.set(leaseId, {
+    clientId: bridgeClientId(options),
+    createdAt: Date.now(),
+  });
+
+  return {
+    ...ready,
+    leaseId,
+  };
+};
+
+const deactivateBridge = (request, options) => {
+  requireLease(request, options);
+  const leaseId = normalizeString(request.leaseId);
+
+  leases.delete(leaseId);
+
+  return {
+    ok: true,
+    leaseId,
+    released: true,
+  };
+};
+
+export const MESURER_CODEX_BRIDGE_CHANNEL = "mesurer:codex-bridge";
+
+/**
+ * Install Mesurer's Codex IPC handler in an Electron main process.
+ *
+ * The adapter binds native leases to the invoking WebContents, rejects subframe
+ * callers, supports an application-owned sender validator, and releases every
+ * lease when that renderer navigates, exits, or is destroyed.
+ */
+export function installMesurerCodexHost(options = {}) {
+  const ipcMain = options.ipcMain;
+
+  if (!ipcMain?.handle || !ipcMain?.removeHandler) {
+    throw new Error("installMesurerCodexHost requires Electron ipcMain.");
+  }
+
+  if (!(options.validateSender instanceof Function)) {
+    throw new Error("installMesurerCodexHost requires validateSender(event).");
+  }
+
+  const channel = normalizeString(options.channel) ?? MESURER_CODEX_BRIDGE_CHANNEL;
+  const clients = new Map();
+
+  const releaseSender = (clientId) => {
+    const record = clients.get(clientId);
+
+    if (!record) return;
+    clients.delete(clientId);
+    releaseCodexBridgeClient(clientId);
+
+    record.sender.removeListener?.("did-navigate", record.release);
+    record.sender.removeListener?.("render-process-gone", record.release);
+    record.sender.removeListener?.("destroyed", record.release);
+  };
+
+  const bindSender = (sender) => {
+    const clientId = String(sender.id);
+
+    if (clients.has(clientId)) return clientId;
+
+    const release = () => releaseSender(clientId);
+
+    clients.set(clientId, { sender, release });
+    sender.on?.("did-navigate", release);
+    sender.on?.("render-process-gone", release);
+    sender.on?.("destroyed", release);
+
+    return clientId;
+  };
+
+  ipcMain.handle(channel, async (event, request) => {
+    if (event?.senderFrame?.parent) {
+      throw new Error("Mesurer Codex host requests are only accepted from the main frame.");
+    }
+
+    if (!await options.validateSender(event)) {
+      throw new Error("Mesurer Codex host rejected the invoking renderer.");
+    }
+
+    const sender = event?.sender;
+
+    if (!sender || !Number.isFinite(sender.id)) {
+      throw new Error("Mesurer Codex host could not identify the invoking renderer.");
+    }
+
+    const clientId = bindSender(sender);
+
+    return codexBridge(request, {
+      codex: options.codex,
+      codexHome: options.codexHome,
+      clientId,
+    });
+  });
+
+  return {
+    channel,
+    dispose() {
+      ipcMain.removeHandler(channel);
+
+      for (const clientId of clients.keys()) releaseSender(clientId);
+    },
+  };
+}
+
 /**
  * Native Codex transport for Mesurer's Codex plugin.
  *
@@ -1256,6 +1408,12 @@ export async function codexBridge(request, options = {}) {
     };
   }
 
+  if (action === "activate") return activateBridge(request, options);
+
+  if (action === "deactivate") return deactivateBridge(request, options);
+
+  requireLease(request, options);
+
   const desktop = await desktopTransport(options);
 
   await ensureDeliveriesLoaded(options);

package/plugins/codex/preload.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+const MESURER_CODEX_BRIDGE_CHANNEL = "mesurer:codex-bridge";
+
+const createMesurerCodexPreloadBridge = (
+  ipcRenderer,
+  options = {},
+) => {
+  if (!ipcRenderer?.invoke) {
+    throw new Error("createMesurerCodexPreloadBridge requires Electron ipcRenderer.");
+  }
+
+  const configuredChannel = options.channel?.constructor === String
+    ? options.channel.trim()
+    : "";
+
+  const channel = configuredChannel || MESURER_CODEX_BRIDGE_CHANNEL;
+
+  return (request) => ipcRenderer.invoke(channel, request);
+};
+
+module.exports = {
+  MESURER_CODEX_BRIDGE_CHANNEL,
+  createMesurerCodexPreloadBridge,
+};

package/plugins/codex/preload.d.ts

@@ -0,0 +1,22 @@
+import type {
+  CodexBridgeRequest,
+  CodexBridgeResponse,
+} from "./bridge";
+
+export type MesurerCodexPreloadOptions = {
+  channel?: string;
+};
+
+export type MesurerCodexIpcRenderer = {
+  invoke(
+    channel: string,
+    request: CodexBridgeRequest,
+  ): Promise<CodexBridgeResponse>;
+};
+
+export const MESURER_CODEX_BRIDGE_CHANNEL: "mesurer:codex-bridge";
+
+export function createMesurerCodexPreloadBridge(
+  ipcRenderer: MesurerCodexIpcRenderer,
+  options?: MesurerCodexPreloadOptions,
+): (request: CodexBridgeRequest) => Promise<CodexBridgeResponse>;

package/plugins/codex/preload.mjs

@@ -0,0 +1,18 @@
+export const MESURER_CODEX_BRIDGE_CHANNEL = "mesurer:codex-bridge";
+
+export function createMesurerCodexPreloadBridge(
+  ipcRenderer,
+  options = {},
+) {
+  if (!ipcRenderer?.invoke) {
+    throw new Error("createMesurerCodexPreloadBridge requires Electron ipcRenderer.");
+  }
+
+  const configuredChannel = options.channel?.constructor === String
+    ? options.channel.trim()
+    : "";
+
+  const channel = configuredChannel || MESURER_CODEX_BRIDGE_CHANNEL;
+
+  return (request) => ipcRenderer.invoke(channel, request);
+}

package/skills/mesurer-ui/SKILL.md

@@ -9,7 +9,7 @@ Mesurer is shared visual state between the person reviewing a page and the codin
 
 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.
 
-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.
+Do not add a second Mesurer process for Codex delivery. Native applications expose the narrow `window.__MESURER_HOST__.codexBridge(request)` capability. The enabled plugin owns a renderer-scoped native lease; disabling it releases that lease without stopping Codex's shared daemon. 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 start the shared daemon.
 
 A meaningful Mesurer step must return evidence the agent actually uses.
 
@@ -133,7 +133,7 @@ If review is still numerically wrong, continue editing. If target status is stal
 
 The human-facing inspection tool is **Typography**. The internal compatibility id remains `text-inspector`; do not automate normal application work by guessing toolbar labels.
 
-Direct editing starts by double-click or double-tap while Edit is active. Typography in Select is inspection-only. Edit also owns the existing Arrange movement intent.
+Direct editing starts by double-click or double-tap while Edit is active. Typography in Select is inspection-only. Edit also owns movement intent stored under the existing Arrange compatibility names.
 
 The editor exposes direct B/I/U, Font, Size, Weight, rendered-page colors, custom color, and a separate Text/H1/H2/H3 semantic preset popup. Missing heading levels are not invented.