@jskit-ai/assistant-core 0.2.6 → 0.2.8

package/src/server/conversation/codexAccountReader.js

@@ -0,0 +1,168 @@
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import path from "node:path";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeNullableText } from "./normalize.js";
+
+const CODEX_APP_SERVER_SELECTED_AUTH_MAX_BYTES = 1024 * 1024;
+const CODEX_APP_SERVER_CHATGPT_ACCESS_TOKEN_MAX_LENGTH = 256 * 1024;
+export const CODEX_APP_SERVER_ACCOUNT_ID_MAX_LENGTH = 512;
+const CODEX_APP_SERVER_PLAN_TYPE_MAX_LENGTH = 128;
+const CODEX_APP_SERVER_API_KEY_MAX_LENGTH = 16 * 1024;
+
+/** Native account records and secret-change detection. Hosts select the credential home. */
+export function createCodexAccountReader({
+  errorPrefix = "",
+  identityNamespace = "codex-account-v1",
+  secretNamespace = "codex-auth-secret-v1"
+} = {}) {
+  function codexAppServerHelperAuthError(code = "", message = "") {
+    const error = new Error(
+      normalizeNullableText(message) || "Codex helper authentication is unavailable. Reconnect Codex and retry."
+    );
+    error.code = normalizeNullableText(code) || `${errorPrefix}codex_helper_auth_unavailable`;
+    return error;
+  }
+
+  function boundedCodexAuthText(value, {
+    label = "Codex authentication value",
+    maxLength = 0
+  } = {}) {
+    if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
+      throw codexAppServerHelperAuthError(
+        `${errorPrefix}codex_helper_auth_invalid`,
+        `${label} is missing or invalid. Reconnect Codex and retry.`
+      );
+    }
+    return value;
+  }
+
+  function codexAccountIdentitySignature(authMode = "", identity = "") {
+    return `sha256:${createHash("sha256")
+      .update(`${identityNamespace}\0`, "utf8")
+      .update(normalizeNullableText(authMode), "utf8")
+      .update("\0", "utf8")
+      .update(String(identity || ""), "utf8")
+      .digest("hex")}`;
+  }
+
+  function codexAuthSecretSignature(secret = "") {
+    return createHash("sha256")
+      .update(`${secretNamespace}\0`, "utf8")
+      .update(String(secret || ""), "utf8")
+      .digest("hex");
+  }
+
+  async function readBoundedCodexAuthJson(filePath = "") {
+    let handle = null;
+    try {
+      handle = await open(filePath, "r");
+      const fileStat = await handle.stat();
+      if (!fileStat.isFile() || fileStat.size > CODEX_APP_SERVER_SELECTED_AUTH_MAX_BYTES) {
+        throw codexAppServerHelperAuthError(
+          `${errorPrefix}codex_helper_auth_invalid`,
+          "The selected Codex authentication record is invalid. Reconnect Codex and retry."
+        );
+      }
+      const buffer = Buffer.alloc(CODEX_APP_SERVER_SELECTED_AUTH_MAX_BYTES + 1);
+      let offset = 0;
+      while (offset < buffer.length) {
+        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, null);
+        if (bytesRead === 0) {
+          break;
+        }
+        offset += bytesRead;
+      }
+      if (offset > CODEX_APP_SERVER_SELECTED_AUTH_MAX_BYTES) {
+        throw codexAppServerHelperAuthError(
+          `${errorPrefix}codex_helper_auth_invalid`,
+          "The selected Codex authentication record is too large. Reconnect Codex and retry."
+        );
+      }
+      const parsed = JSON.parse(buffer.subarray(0, offset).toString("utf8"));
+      if (!isRecord(parsed)) {
+        throw new Error("invalid authentication record");
+      }
+      return parsed;
+    } catch (error) {
+      // readable-check: allow optional-call - data: a caught value whose code may be absent or not a string
+      if (error?.code?.startsWith?.(`${errorPrefix}codex_helper_auth_`)) {
+        throw error;
+      }
+      throw codexAppServerHelperAuthError(
+        `${errorPrefix}codex_helper_auth_unavailable`,
+        "The selected Codex authentication record could not be read. Reconnect Codex and retry."
+      );
+    } finally {
+      await handle?.close().catch(() => null);
+    }
+  }
+
+  async function readCodexSelectedAccountAuth(options = {}) {
+    const toolHomeSource = normalizeNullableText(options.toolHomeSource);
+    if (!toolHomeSource || !path.isAbsolute(toolHomeSource)) {
+      throw codexAppServerHelperAuthError(
+        `${errorPrefix}codex_helper_auth_unavailable`,
+        "The selected Codex account is unavailable. Reconnect Codex and retry."
+      );
+    }
+    const auth = await readBoundedCodexAuthJson(path.join(toolHomeSource, ".codex", "auth.json"));
+    const storedMode = normalizeNullableText(auth.auth_mode).toLowerCase();
+    if (storedMode === "chatgpt") {
+      const tokens = isRecord(auth.tokens) ? auth.tokens : {};
+      const accountId = boundedCodexAuthText(tokens.account_id, {
+        label: "Codex account identity",
+        maxLength: CODEX_APP_SERVER_ACCOUNT_ID_MAX_LENGTH
+      });
+      const accessToken = boundedCodexAuthText(tokens.access_token, {
+        label: "Codex access token",
+        maxLength: CODEX_APP_SERVER_CHATGPT_ACCESS_TOKEN_MAX_LENGTH
+      });
+      const planTypeValue = tokens.chatgpt_plan_type ?? tokens.plan_type;
+      const planType = planTypeValue === undefined || planTypeValue === null || planTypeValue === ""
+        ? ""
+        : boundedCodexAuthText(planTypeValue, {
+            label: "Codex plan type",
+            maxLength: CODEX_APP_SERVER_PLAN_TYPE_MAX_LENGTH
+          });
+      return Object.freeze({
+        accessToken,
+        accountId,
+        authMode: "chatgpt",
+        identitySignature: codexAccountIdentitySignature("chatgpt", accountId),
+        planType,
+        secretSignature: codexAuthSecretSignature(accessToken)
+      });
+    }
+    if (["apikey", "api_key"].includes(storedMode)) {
+      const apiKey = boundedCodexAuthText(auth.OPENAI_API_KEY, {
+        label: "Codex API key",
+        maxLength: CODEX_APP_SERVER_API_KEY_MAX_LENGTH
+      });
+      return Object.freeze({
+        apiKey,
+        authMode: "apiKey",
+        identitySignature: codexAccountIdentitySignature("apiKey", apiKey),
+        secretSignature: codexAuthSecretSignature(apiKey)
+      });
+    }
+    throw codexAppServerHelperAuthError(
+      `${errorPrefix}codex_helper_auth_invalid`,
+      "The selected Codex authentication mode is unsupported. Reconnect Codex and retry."
+    );
+  }
+
+  return Object.freeze({
+    error: codexAppServerHelperAuthError,
+    identitySignature: codexAccountIdentitySignature,
+    readRecord: readBoundedCodexAuthJson,
+    readSelected: readCodexSelectedAccountAuth
+  });
+}
+
+const CODEX_AUTH_INVALIDATED_PATTERN =
+  /\b(?:token_invalidated|refresh_token_invalidated)\b|authentication token has been invalidated|HTTP error:\s*401 Unauthorized|401 Unauthorized/iu;
+
+export function codexAuthOutputRequiresReconnect(output = "") {
+  return CODEX_AUTH_INVALIDATED_PATTERN.test(String(output || ""));
+}

package/src/server/conversation/codexAuthPreflight.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { codexAuthOutputRequiresReconnect } from "./codexConfiguration.js";
+import { codexAuthOutputRequiresReconnect } from "./codexAccountReader.js";
 import {
   assertExistingDirectory, codexAppServerCommandBaseEnv, codexAppServerCredentialHome,
   codexAppServerProcessCwd, ensureWritablePrivateDirectory
@@ -30,7 +30,7 @@ function codexAuthPreflightArgs() {
 
 async function runCodexAuthPreflight({
   codexCommand = "codex",
-  env = process.env,
+  env,
   executionRoot = "",
   runtimeDir = "",
   terminalEnv = {},
@@ -86,9 +86,10 @@ async function runCodexAuthPreflight({
   }
 }
 
-export async function assertCodexAuthPreflightReady(options = {}, {
+export async function assertCodexAuthPreflightReady(options, {
   reason = "codex-auth-preflight", execution, credentials
-} = {}) {
+}) {
+  if (!options?.env) throw new TypeError("assertCodexAuthPreflightReady requires the application's environment, such as process.env.");
   const result = await runCodexAuthPreflight(options, execution);
   if (result.ok && !codexAuthOutputRequiresReconnect(result.output)) {
     return result;

package/src/server/conversation/codexClient.js

@@ -27,18 +27,23 @@ function codexAppServerRequestAbortedError(method = "") {
 }
 
 function addSocketListener(socket, eventName, handler) {
+  // readable-check: allow method-probe - platform object: a WebSocket is an EventTarget in some implementations and an EventEmitter in others
   if (typeof socket.addEventListener === "function") {
     socket.addEventListener(eventName, handler);
+    // readable-check: allow optional-call - platform object: a WebSocket is an EventTarget in some implementations and an EventEmitter in others
     return () => socket.removeEventListener?.(eventName, handler);
   }
+  // readable-check: allow method-probe - platform object: a WebSocket is an EventTarget in some implementations and an EventEmitter in others
   if (typeof socket.on === "function") {
     socket.on(eventName, handler);
+    // readable-check: allow optional-call - platform object: a WebSocket is an EventTarget in some implementations and an EventEmitter in others
     return () => socket.off?.(eventName, handler) || socket.removeListener?.(eventName, handler);
   }
   throw new Error("Unsupported WebSocket implementation.");
 }
 
 function socketMessageText(event, maxBytes = Number.POSITIVE_INFINITY) {
+  // readable-check: allow no-dual-shape - platform object: an EventTarget socket delivers a message event, an EventEmitter socket the data itself
   const data = event?.data ?? event;
   if (typeof data === "string") {
     return Buffer.byteLength(data, "utf8") <= maxBytes ? data : null;
@@ -50,11 +55,14 @@ function socketMessageText(event, maxBytes = Number.POSITIVE_INFINITY) {
   return Buffer.byteLength(text, "utf8") <= maxBytes ? text : null;
 }
 
+/** A client without a disconnect listener reports nothing. */
+function ignoreDisconnect() {}
+
 class CodexAppServerJsonRpcClient {
   constructor({
     endpoint = "",
     maxMessageBytes = Number.POSITIVE_INFINITY,
-    onDisconnect = null,
+    onDisconnect = ignoreDisconnect,
     requestTimeoutMs = CODEX_APP_SERVER_REQUEST_TIMEOUT_MS,
     WebSocketImpl = WebSocket
   } = {}) {
@@ -79,6 +87,7 @@ class CodexAppServerJsonRpcClient {
     if (!this.endpoint) {
       throw new Error("Codex app-server endpoint is required.");
     }
+    // readable-check: allow method-probe - input validation: an application may supply its own WebSocket implementation
     if (typeof this.WebSocketImpl !== "function") {
       throw new Error("A WebSocket implementation is required for Codex app-server.");
     }
@@ -123,6 +132,7 @@ class CodexAppServerJsonRpcClient {
           this.connected = false;
           this.socket = null;
         }
+        // readable-check: allow no-dual-shape - platform object: an EventTarget socket reports an ErrorEvent wrapping the error, an EventEmitter socket the error itself
         settle(reject, error?.error || error);
       }));
     });
@@ -189,7 +199,7 @@ class CodexAppServerJsonRpcClient {
         return;
       }
       const removeAbortListener = () => {
-        signal?.removeEventListener?.("abort", abort);
+        signal?.removeEventListener("abort", abort);
       };
       const abort = () => {
         const pending = this.pendingRequests.get(id);
@@ -213,7 +223,7 @@ class CodexAppServerJsonRpcClient {
         resolve,
         timeout
       });
-      signal?.addEventListener?.("abort", abort, { once: true });
+      signal?.addEventListener("abort", abort, { once: true });
       try {
         this.send({
           id,
@@ -230,6 +240,7 @@ class CodexAppServerJsonRpcClient {
   }
 
   send(payload) {
+    // readable-check: allow method-probe - platform object: a WebSocket implementation's socket
     if (!this.isOpen() || typeof this.socket.send !== "function") {
       throw new Error("Codex app-server connection is not open.");
     }
@@ -264,7 +275,7 @@ class CodexAppServerJsonRpcClient {
         return;
       }
       clearTimeout(pending.timeout);
-      pending.removeAbortListener?.();
+      pending.removeAbortListener();
       this.pendingRequests.delete(message.id);
       if (message.error) {
         const error = new Error(message.error.message || `Codex app-server request failed: ${pending.method}`);
@@ -316,7 +327,7 @@ class CodexAppServerJsonRpcClient {
   rejectPendingRequests(error) {
     for (const pending of this.pendingRequests.values()) {
       clearTimeout(pending.timeout);
-      pending.removeAbortListener?.();
+      pending.removeAbortListener();
       pending.reject(error);
     }
     this.pendingRequests.clear();
@@ -325,7 +336,7 @@ class CodexAppServerJsonRpcClient {
   disconnect(error) {
     this.rejectPendingRequests(error);
     this.close();
-    this.onDisconnect?.(error);
+    this.onDisconnect(error);
   }
 
   close() {
@@ -333,6 +344,7 @@ class CodexAppServerJsonRpcClient {
     const socket = this.socket;
     this.connected = false;
     this.socket = null;
+    // readable-check: allow optional-call - platform object: a WebSocket implementation's socket
     socket?.close?.();
   }
 }