@linzumi/cli 0.0.60-beta → 0.0.61-beta

package/README.md

@@ -62,7 +62,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.60-beta --version
+npx -y @linzumi/cli@0.0.61-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -28294,7 +28294,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.60-beta";
+var linzumiCliVersion = "0.0.61-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -28779,6 +28779,333 @@ function normalizeLocalRunnerCache(value) {
   );
 }
 
+// src/threadCodexWorkerIpc.ts
+function bindThreadCodexWorkerIpc(codex) {
+  const pendingServerRequests = /* @__PURE__ */ new Map();
+  const state = { nextServerRequestId: 1 };
+  const send = (message) => {
+    if (process.send === void 0) {
+      throw new Error("thread Codex worker IPC channel closed");
+    }
+    process.send(message);
+  };
+  process.on("message", (message) => {
+    const parsed = threadCodexWorkerParentMessage(message);
+    if (parsed === void 0) {
+      return;
+    }
+    switch (parsed.type) {
+      case "linzumi_thread_codex_worker_request":
+        void codex.request(parsed.method, parsed.params).then(
+          (response) => send({
+            type: "linzumi_thread_codex_worker_response",
+            id: parsed.id,
+            response
+          })
+        ).catch(
+          (error51) => send({
+            type: "linzumi_thread_codex_worker_response",
+            id: parsed.id,
+            error: error51 instanceof Error ? error51.message : String(error51)
+          })
+        );
+        return;
+      case "linzumi_thread_codex_worker_notify":
+        codex.notify(parsed.method, parsed.params);
+        return;
+      case "linzumi_thread_codex_worker_server_request_response": {
+        const pending = pendingServerRequests.get(parsed.id);
+        if (pending === void 0) {
+          return;
+        }
+        pendingServerRequests.delete(parsed.id);
+        if (parsed.error !== void 0) {
+          pending.reject(new Error(parsed.error));
+          return;
+        }
+        pending.resolve(parsed.result);
+        return;
+      }
+    }
+  });
+  codex.onNotification((notification) => {
+    send({
+      type: "linzumi_thread_codex_worker_notification",
+      notification
+    });
+  });
+  codex.onRequest(
+    (request) => new Promise((resolve11, reject) => {
+      const id = state.nextServerRequestId;
+      state.nextServerRequestId += 1;
+      pendingServerRequests.set(id, { resolve: resolve11, reject });
+      send({
+        type: "linzumi_thread_codex_worker_server_request",
+        id,
+        request
+      });
+    })
+  );
+  process.once("disconnect", () => {
+    for (const pending of pendingServerRequests.values()) {
+      pending.reject(new Error("thread Codex worker IPC channel closed"));
+    }
+    pendingServerRequests.clear();
+  });
+}
+function connectThreadCodexWorkerIpc(child) {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const notificationCallbacks = /* @__PURE__ */ new Set();
+  const requestCallbacks = /* @__PURE__ */ new Set();
+  const pendingNotifications = [];
+  const state = { nextRequestId: 1, closed: false };
+  const rejectPendingRequests = (message) => {
+    const error51 = new Error(message);
+    for (const pending of pendingRequests.values()) {
+      pending.reject(error51);
+    }
+    pendingRequests.clear();
+  };
+  const send = (message) => {
+    if (state.closed) {
+      throw new Error("thread Codex worker IPC client is closed");
+    }
+    if (child.send === void 0 || child.connected === false) {
+      throw new Error("thread Codex worker IPC channel closed");
+    }
+    child.send(message);
+  };
+  const onMessage = (message) => {
+    const parsed = threadCodexWorkerChildMessage(message);
+    if (parsed === void 0) {
+      return;
+    }
+    switch (parsed.type) {
+      case "linzumi_thread_codex_worker_response": {
+        const pending = pendingRequests.get(parsed.id);
+        if (pending === void 0) {
+          return;
+        }
+        pendingRequests.delete(parsed.id);
+        if (parsed.error !== void 0) {
+          pending.reject(new Error(parsed.error));
+          return;
+        }
+        if (parsed.response === void 0) {
+          pending.reject(
+            new Error("thread Codex worker response missing body")
+          );
+          return;
+        }
+        pending.resolve(parsed.response);
+        return;
+      }
+      case "linzumi_thread_codex_worker_notification":
+        if (notificationCallbacks.size === 0) {
+          pendingNotifications.push(parsed.notification);
+        } else {
+          for (const callback of notificationCallbacks) {
+            callback(parsed.notification);
+          }
+        }
+        return;
+      case "linzumi_thread_codex_worker_server_request":
+        void respondToThreadCodexWorkerServerRequest(
+          send,
+          parsed.id,
+          parsed.request,
+          requestCallbacks
+        );
+        return;
+    }
+  };
+  const onClosed = () => {
+    state.closed = true;
+    rejectPendingRequests("thread Codex worker IPC channel closed");
+  };
+  child.on("message", onMessage);
+  child.once("exit", onClosed);
+  child.once("disconnect", onClosed);
+  return {
+    request: (method, params) => new Promise((resolve11, reject) => {
+      const id = state.nextRequestId;
+      state.nextRequestId += 1;
+      pendingRequests.set(id, { resolve: resolve11, reject });
+      try {
+        send({
+          type: "linzumi_thread_codex_worker_request",
+          id,
+          method,
+          params
+        });
+      } catch (error51) {
+        pendingRequests.delete(id);
+        reject(error51 instanceof Error ? error51 : new Error(String(error51)));
+      }
+    }),
+    notify: (method, params) => {
+      send({
+        type: "linzumi_thread_codex_worker_notify",
+        method,
+        params
+      });
+    },
+    onNotification: (callback) => {
+      notificationCallbacks.add(callback);
+      pendingNotifications.splice(0).forEach((notification) => {
+        callback(notification);
+      });
+    },
+    onRequest: (callback) => {
+      requestCallbacks.add(callback);
+    },
+    close: () => {
+      state.closed = true;
+      child.off("message", onMessage);
+      child.off("exit", onClosed);
+      child.off("disconnect", onClosed);
+      rejectPendingRequests("thread Codex worker IPC client closed");
+    }
+  };
+}
+async function respondToThreadCodexWorkerServerRequest(send, id, request, callbacks) {
+  try {
+    for (const callback of callbacks) {
+      const result = await callback(request);
+      if (result !== void 0) {
+        send({
+          type: "linzumi_thread_codex_worker_server_request_response",
+          id,
+          result
+        });
+        return;
+      }
+    }
+    send({
+      type: "linzumi_thread_codex_worker_server_request_response",
+      id,
+      error: `unhandled Codex app-server request: ${request.method}`
+    });
+  } catch (error51) {
+    send({
+      type: "linzumi_thread_codex_worker_server_request_response",
+      id,
+      error: error51 instanceof Error ? error51.message : String(error51)
+    });
+  }
+}
+function threadCodexWorkerParentMessage(message) {
+  if (!isJsonObject(message)) {
+    return void 0;
+  }
+  switch (message.type) {
+    case "linzumi_thread_codex_worker_request": {
+      const id = integerValue(message.id);
+      const method = stringValue(message.method);
+      if (id === void 0 || method === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_request",
+        id,
+        method,
+        params: objectValue(message.params)
+      };
+    }
+    case "linzumi_thread_codex_worker_notify": {
+      const method = stringValue(message.method);
+      if (method === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_notify",
+        method,
+        params: objectValue(message.params)
+      };
+    }
+    case "linzumi_thread_codex_worker_server_request_response": {
+      const id = integerValue(message.id);
+      if (id === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_server_request_response",
+        id,
+        result: message.result,
+        error: stringValue(message.error)
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function threadCodexWorkerChildMessage(message) {
+  if (!isJsonObject(message)) {
+    return void 0;
+  }
+  switch (message.type) {
+    case "linzumi_thread_codex_worker_response": {
+      const id = integerValue(message.id);
+      if (id === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_response",
+        id,
+        response: jsonRpcResponseValue(message.response),
+        error: stringValue(message.error)
+      };
+    }
+    case "linzumi_thread_codex_worker_notification": {
+      const notification = jsonRpcNotificationValue(message.notification);
+      if (notification === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_notification",
+        notification
+      };
+    }
+    case "linzumi_thread_codex_worker_server_request": {
+      const id = integerValue(message.id);
+      const request = jsonRpcRequestValue(message.request);
+      if (id === void 0 || request === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_server_request",
+        id,
+        request
+      };
+    }
+    case "linzumi_thread_codex_worker_ready":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function jsonRpcResponseValue(value) {
+  if (!isJsonObject(value) || !("id" in value)) {
+    return void 0;
+  }
+  if ("result" in value || "error" in value) {
+    return value;
+  }
+  return void 0;
+}
+function jsonRpcNotificationValue(value) {
+  if (!isJsonObject(value) || "id" in value || typeof value.method !== "string") {
+    return void 0;
+  }
+  return value;
+}
+function jsonRpcRequestValue(value) {
+  if (!isJsonObject(value) || !("id" in value) || typeof value.method !== "string") {
+    return void 0;
+  }
+  return value;
+}
+
 // src/runner.ts
 var THREAD_RUNNER_READY_TIMEOUT_MS = 3e4;
 async function runLocalCodexRunner(options) {
@@ -28829,14 +29156,16 @@ async function runThreadCodexWorker(options) {
   const started = await startOwnedCodexAppServer(options, {
     linzumiMcp: false
   });
+  const codex = await connectCodexAppServer(started.url);
   const stop = once(() => {
+    codex.close();
     started.stop();
     log.close();
   });
+  bindThreadCodexWorkerIpc(codex);
   process.send({
     type: "linzumi_thread_codex_worker_ready",
-    kandanThreadId: options.threadProcess.kandanThreadId,
-    codexUrl: started.url
+    kandanThreadId: options.threadProcess.kandanThreadId
   });
   await waitForThreadCodexWorkerStop(started.process);
   stop();
@@ -29870,6 +30199,18 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       log
     });
     dynamicChannelSessions.set(kandanThreadId, session);
+    if (sessionCodex !== codex) {
+      sessionCodex.onNotification((notification) => {
+        seq.value += 1;
+        const params = notification.params ?? {};
+        const metadata = extractCodexIds(params);
+        log("codex.notification", {
+          method: notification.method,
+          metadata
+        });
+        session.handleCodexNotification(notification.method, params);
+      });
+    }
     return session;
   };
   const attachThreadSession = async (control, cwd, codexThreadId) => {
@@ -29939,7 +30280,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       throw error51;
     }
     try {
-      const threadCodex = await connectCodexAppServer(handle.codexUrl);
+      const threadCodex = handle.codex;
       const closeThreadCodex = once(() => threadCodex.close());
       handle.onExit?.(closeThreadCodex);
       const runtimeHandle = {
@@ -32813,7 +33154,7 @@ async function spawnLocalThreadRunnerProcess(options) {
   });
   return {
     kandanThreadId: ready2.kandanThreadId,
-    codexUrl: ready2.codexUrl,
+    codex: connectThreadCodexWorkerIpc(child),
     processPid: child.pid,
     onExit: (listener) => {
       if (exitState.exited) {
@@ -32840,11 +33181,10 @@ function threadRunnerReadyMessage(message, expectedKandanThreadId) {
     return void 0;
   }
   const kandanThreadId = stringValue(message.kandanThreadId);
-  const codexUrl = stringValue(message.codexUrl);
-  if (kandanThreadId !== expectedKandanThreadId || codexUrl === void 0) {
+  if (kandanThreadId !== expectedKandanThreadId) {
     throw new Error("thread Codex worker reported invalid ready payload");
   }
-  return { kandanThreadId, codexUrl };
+  return { kandanThreadId };
 }
 function waitForThreadCodexWorkerStop(codexProcess) {
   return new Promise((resolve11) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.60-beta",
+  "version": "0.0.61-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {