@leoustc/ai-runner-codex 0.1.1 → 0.1.3

package/AGENTS.md

@@ -97,10 +97,12 @@ Optional variables may also be added for the Codex app-server command,
 socket mode; this runner is intended to keep Codex hot through app-server
 WebSocket.
 
-If Codex app-server returns an auth/login error, start `CODEX_LOGIN_COMMAND`
-(`codex login --device-auth` by default), relay the device login URL/code back
-to the Hub as an agent message, wait for login completion, and retry the Codex
-request once.
+If Codex app-server returns an auth/login error or generic app-server error,
+start `CODEX_LOGIN_COMMAND` (`codex login --device-auth` by default), relay a
+normal agent message with `codexLogin: true`, `status`, and any parsed device
+login `url`, `code`, and `deviceId` back to the Hub, wait for login completion,
+and retry the Codex request once. Spawn the login command as a local child
+process and watch stdout/stderr for device login values.
 
 
 Do not commit real `.env` secrets. If examples are needed, use `.env.example`.
@@ -141,6 +143,11 @@ For each valid payload, reply to the Hub as:
 { "requestId": "...", "type": "end", "name": "agent-name" }
 ```
 
+Large Codex reply text must be split into multiple `message` frames before the
+matching `end`. Each `message.text` chunk should be at most 8 KiB encoded as
+UTF-8. Include `message.chunk` metadata with `index`, `total`, and `maxBytes`
+when a reply has more than one chunk.
+
 Errors use:
 
 ```json

package/README.md

@@ -84,9 +84,12 @@ WebSocket text frame.
 On startup, the runner checks that the `codex` CLI is installed and available
 on `PATH` before starting app-server.
 
-If Codex returns an auth/login error, the runner starts `CODEX_LOGIN_COMMAND`,
-posts the device login URL/code back to the Hub as an agent message, waits for
-login completion, then retries the Codex request once.
+If Codex returns an auth/login error or a generic app-server error, the runner
+starts `CODEX_LOGIN_COMMAND`, posts a normal agent message with
+`codexLogin: true`, `status`, and any parsed device login `url`, `code`, and
+`deviceId` back to the Hub, waits for login completion, then retries the Codex
+request once. The login command is spawned as a local child process and the
+runner watches stdout/stderr for the device login values.
 
 Hub WebSocket behavior:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leoustc/ai-runner-codex",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "Codex app-server backed Agent Runner Hub CLI connector",
   "license": "MIT",

package/src/codex.js

@@ -194,7 +194,7 @@ class CodexWsClient {
       this.pending.delete(String(message.id));
 
       if (message.error) {
-        pending.reject(new Error(message.error.message || JSON.stringify(message.error)));
+        pending.reject(codexError(message.error, "Codex app-server request failed"));
       } else {
         pending.resolve(message.result);
       }
@@ -235,7 +235,7 @@ class CodexWsClient {
       this.turns.delete(threadId);
 
       if (message.params?.turn?.status === "failed") {
-        state.reject?.(new Error(message.params.turn.error?.message || "Codex turn failed"));
+        state.reject?.(codexError(message.params.turn.error, "Codex turn failed"));
       } else {
         state.resolve?.(state.text || textFromTurn(message.params?.turn));
       }
@@ -243,7 +243,7 @@ class CodexWsClient {
     }
 
     if (message.method === "error") {
-      const error = new Error(message.params?.message || "Codex app-server error");
+      const error = codexError(message.params, "Codex app-server error");
 
       for (const state of this.turns.values()) {
         state.reject?.(error);
@@ -379,6 +379,34 @@ function textFromTurn(turn) {
     .trim();
 }
 
+function codexError(value, fallback) {
+  if (!value || typeof value !== "object") {
+    return new Error(fallback);
+  }
+
+  const fields = [];
+
+  for (const key of ["message", "code", "reason", "type", "status"]) {
+    if (typeof value[key] === "string" && value[key]) {
+      fields.push(`${key}: ${value[key]}`);
+    }
+  }
+
+  if (value.error && typeof value.error === "object") {
+    for (const key of ["message", "code", "type"]) {
+      if (typeof value.error[key] === "string" && value.error[key]) {
+        fields.push(`error.${key}: ${value.error[key]}`);
+      }
+    }
+  }
+
+  if (fields.length === 0) {
+    fields.push(JSON.stringify(value));
+  }
+
+  return new Error(`${fallback}: ${fields.join("; ")}`);
+}
+
 function sandboxPolicy(mode, cwd) {
   if (mode === "danger-full-access") {
     return { type: "dangerFullAccess" };

package/src/hub.js

@@ -1,4 +1,4 @@
-import { codexRequest, codexText, heartbeat, isRoomPayload, registration, reply } from "./protocol.js";
+import { codexRequest, codexText, heartbeat, isRoomPayload, messageReplies, registration, reply } from "./protocol.js";
 import { requestCodex } from "./codex.js";
 import { ensureCodexLogin, isCodexAuthError } from "./login.js";
 
@@ -94,10 +94,10 @@ export class HubClient {
     try {
       const response = await this.requestCodexWithLogin(value);
       const text = codexText(response) || "Codex returned no text.";
-      this.send(reply(value, this.config, "message", {
+      this.sendMessages(value, {
         model: this.config.model,
         text,
-      }));
+      });
     } catch (error) {
       this.send(reply(value, this.config, "error", {
         error: error instanceof Error ? error.message : String(error),
@@ -117,11 +117,8 @@ export class HubClient {
         throw error;
       }
 
-      await ensureCodexLogin(this.config, this.log, async (text) => {
-        this.send(reply(value, this.config, "message", {
-          codexLogin: true,
-          text,
-        }));
+      await ensureCodexLogin(this.config, this.log, async (notice) => {
+        this.sendMessages(value, loginNoticeMessage(notice));
       });
 
       return await requestCodex(this.config, request);
@@ -210,6 +207,12 @@ export class HubClient {
     }
   }
 
+  sendMessages(payload, message) {
+    for (const value of messageReplies(payload, this.config, message)) {
+      this.send(value);
+    }
+  }
+
   sendNow(value) {
     if (this.socket?.readyState !== WebSocket.OPEN) {
       return false;
@@ -251,3 +254,19 @@ function parseJson(data) {
     return null;
   }
 }
+
+function loginNoticeMessage(notice) {
+  if (notice && typeof notice === "object") {
+    return {
+      ...notice,
+      codexLogin: true,
+      text: typeof notice.text === "string" ? notice.text : JSON.stringify(notice, null, 2),
+    };
+  }
+
+  return {
+    codexLogin: true,
+    status: "notice",
+    text: String(notice),
+  };
+}

package/src/login.js

@@ -5,12 +5,12 @@ let activeLogin = null;
 export function isCodexAuthError(error) {
   const message = error instanceof Error ? error.message : String(error);
 
-  return /auth|login|sign[ -]?in|unauthori[sz]ed|forbidden|invalid_grant|refresh token|access token/i.test(message);
+  return /auth|login|sign[ -]?in|unauthori[sz]ed|forbidden|invalid_grant|refresh token|access token|codex app-server error/i.test(message);
 }
 
 export async function ensureCodexLogin(config, log, notify) {
   if (activeLogin) {
-    await notify("Codex login is already in progress. Waiting for it to complete.");
+    await notify(loginStatusMessage("waiting", "Codex login is already in progress. Waiting for it to complete."));
     return await activeLogin;
   }
 
@@ -24,7 +24,7 @@ export async function ensureCodexLogin(config, log, notify) {
 async function runCodexLogin(config, log, notify) {
   const [program, ...args] = splitCommand(config.codexLoginCommand);
 
-  await notify("Codex login is required. Starting device login.");
+  await notify(loginStatusMessage("starting", "Codex login is required. Starting device login process."));
   log.info(`starting codex login: ${config.codexLoginCommand}`);
 
   return await new Promise((resolve, reject) => {
@@ -62,7 +62,7 @@ async function runCodexLogin(config, log, notify) {
       clearTimeout(timer);
 
       if (code === 0) {
-        void notify("Codex login completed. Retrying the request.");
+        void notify(loginStatusMessage("complete", "Codex login completed. Retrying the request."));
         resolve();
       } else {
         reject(new Error(`Codex login exited code=${code ?? "null"} signal=${signal ?? "null"}`));
@@ -78,27 +78,45 @@ async function sendLoginInfo(state, notify) {
 
   const info = parseLoginInfo(state.buffer);
 
-  if (!info.url && !info.code) {
+  if (!info.url && !info.deviceId) {
     return;
   }
 
   state.sentLoginInfo = true;
-  await notify([
-    "Codex login required.",
-    info.url ? `Open: ${info.url}` : "",
-    info.code ? `Code: ${info.code}` : "",
-    "After login completes, the runner will retry automatically.",
-  ].filter(Boolean).join("\n"));
+  await notify({
+    codexLogin: true,
+    status: "login_required",
+    ...(info.url ? { url: info.url } : {}),
+    ...(info.deviceId ? { code: info.deviceId, deviceId: info.deviceId } : {}),
+    text: [
+      "Codex login required.",
+      info.url ? `Open: ${info.url}` : "",
+      info.deviceId ? `Code: ${info.deviceId}` : "",
+      "After login completes, the runner will retry automatically.",
+    ].filter(Boolean).join("\n"),
+  });
+}
+
+function loginStatusMessage(status, text) {
+  return {
+    codexLogin: true,
+    status,
+    text,
+  };
 }
 
 function parseLoginInfo(text) {
   const url = text.match(/https?:\/\/[^\s"'<>]+/)?.[0]?.replace(/[),.;]+$/, "") ?? "";
+  const labelledDeviceId =
+    text.match(/(?:device|user|login|verification)?\s*(?:id|code)(?:\s+is)?\s*[:=]?\s*([A-Z0-9][A-Z0-9-]{4,})/i)?.[1] ?? "";
   const labelledCode =
     text.match(/(?:user|device|login|verification)?\s*code(?:\s+is)?\s*[:=]?\s*([A-Z0-9][A-Z0-9-]{4,})/i)?.[1] ?? "";
   const fallbackCode = text.match(/\b[A-Z0-9]{4}-[A-Z0-9]{4}\b/i)?.[0] ?? "";
+  const deviceId = labelledDeviceId || labelledCode || fallbackCode;
 
   return {
-    code: labelledCode || fallbackCode,
+    code: deviceId,
+    deviceId,
     url,
   };
 }

package/src/protocol.js

@@ -36,6 +36,30 @@ export function reply(payload, config, type, message) {
   };
 }
 
+export function messageReplies(payload, config, message, maxBytes = 8 * 1024) {
+  if (typeof message?.text !== "string") {
+    return [reply(payload, config, "message", message)];
+  }
+
+  const chunks = splitUtf8Chunks(message.text, maxBytes);
+
+  return chunks.map((chunk, index) =>
+    reply(payload, config, "message", {
+      ...message,
+      text: chunk,
+      ...(chunks.length > 1
+        ? {
+            chunk: {
+              index,
+              total: chunks.length,
+              maxBytes,
+            },
+          }
+        : {}),
+    }),
+  );
+}
+
 export function codexRequest(payload, config) {
   return {
     requestId: payload.requestId,
@@ -80,3 +104,28 @@ function parseMessage(message) {
   }
 }
 
+function splitUtf8Chunks(text, maxBytes) {
+  const encoder = new TextEncoder();
+  const chunks = [];
+  let current = "";
+  let currentBytes = 0;
+
+  for (const character of text) {
+    const characterBytes = encoder.encode(character).byteLength;
+
+    if (current && currentBytes + characterBytes > maxBytes) {
+      chunks.push(current);
+      current = "";
+      currentBytes = 0;
+    }
+
+    current += character;
+    currentBytes += characterBytes;
+  }
+
+  if (current || chunks.length === 0) {
+    chunks.push(current);
+  }
+
+  return chunks;
+}