@ycodium-ai/agent-codex 0.2.3272 → 0.2.3306

package/dist/index.js

@@ -440,7 +440,7 @@ import * as NodeProcess from "node:process";
 import {
   describeExecutorSpawnFailure,
   ExecutorSpawnRefusedError as ExecutorSpawnRefusedError2,
-  raceAbort
+  raceAbort as raceAbort2
 } from "@ycodium-ai/plugin-api/executor";
 
 // src/appServerLaunch.ts
@@ -563,6 +563,9 @@ function tokenizeLaunchArgs(value) {
   if (current || quoted) tokens.push(current);
   return tokens;
 }
+function encodeQuotedArgs(args) {
+  return args.map((arg) => `"${arg.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`).join(" ");
+}
 function codexExecLaunchArgs(launchArgs) {
   const args = tokenizeLaunchArgs(launchArgs ?? "");
   const execArgs = [];
@@ -646,6 +649,9 @@ function codexSpawnArgs(recipe, layout) {
   if (!needsOverrides) return tokenizeLaunchArgs(recipe.launchArgs);
   return connectionArgv(recipe, layout);
 }
+function encodeCodexConnectionArgs(recipe, layout) {
+  return encodeQuotedArgs(connectionArgv(recipe, layout));
+}
 var CRUSHED_API_KEYS = {
   OPENAI_API_KEY: void 0,
   CODEX_API_KEY: void 0
@@ -1161,28 +1167,25 @@ async function createCodexRpcClient(handle, handlers) {
     const settled = new Promise((resolve2, reject) => {
       pending.set(id, { resolve: resolve2, reject, method });
     });
+    const limit = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    let timer;
+    const timedOut = new Promise((_, reject) => {
+      if (limit > 0)
+        timer = setTimeout(
+          () => reject(new Error(`codex app-server ${method} timed out after ${String(limit)}ms`)),
+          limit
+        );
+    });
     try {
       await Promise.race([
         writeLine({ id, method, ...params === void 0 ? {} : { params } }),
-        settled
+        settled,
+        timedOut
       ]);
+      return await Promise.race([settled, timedOut]);
     } catch (error) {
       pending.delete(id);
       throw error;
-    }
-    const limit = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    if (limit <= 0) return await settled;
-    let timer;
-    try {
-      return await Promise.race([
-        settled,
-        new Promise((_, reject) => {
-          timer = setTimeout(() => {
-            pending.delete(id);
-            reject(new Error(`codex app-server ${method} timed out after ${String(limit)}ms`));
-          }, limit);
-        })
-      ]);
     } finally {
       if (timer !== void 0) clearTimeout(timer);
     }
@@ -4707,11 +4710,50 @@ var codexWorkspaceInventory = async (rpc, cwd) => {
   return { skills, watchPaths: codexWorkspaceWatchPaths(cwd, skills) };
 };
 
+// src/signIn.ts
+import { raceAbort } from "@ycodium-ai/plugin-api/executor";
+
+// src/signInLifecycle.ts
+function signInLifetime(signal) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) abort();
+  const timer = setTimeout(
+    () => controller.abort(new Error("Codex sign-in timed out")),
+    10 * 6e4
+  );
+  timer.unref?.();
+  return {
+    signal: controller.signal,
+    close: () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      controller.abort(new Error("Codex sign-in cancelled"));
+    }
+  };
+}
+
 // src/signIn.ts
 var DEVICE_CODE_URL = /https?:\/\/\S+/;
 var DEVICE_CODE_VALUE = /\b([A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+)\b/;
 var deviceCodeUrl = (output) => DEVICE_CODE_URL.exec(output)?.[0];
 var deviceCodeValue = (output) => DEVICE_CODE_VALUE.exec(output)?.[1];
+async function closeSignInRpc(rpc, host, handle) {
+  await Promise.all([
+    rpc.close({
+      drainTimeoutMs: 5e3,
+      onDrainTimeout: () => host.log.warn("Codex sign-in output did not close after termination")
+    }),
+    handle.exited
+  ]);
+}
+function closeOperation(operations, operation) {
+  return operation.closing ??= Promise.resolve().then(operation.close).finally(() => {
+    if (operations.get(operation.operationId) === operation)
+      operations.delete(operation.operationId);
+  });
+}
 async function collectText(stream, into) {
   const decoder = new TextDecoder();
   for await (const chunk of stream) {
@@ -4738,96 +4780,158 @@ async function startCodexSignIn(input) {
   }
   const isolatedHome = accountHomeFromLayout(input.layout);
   const env = nativeLoginSpawnEnv(input.processEnv, isolatedHome);
+  const loginRecipe = { ...input.recipe, authMode: "chatgpt" };
   const owner = { bindingId: input.host.bindingId };
-  const tryAppServer = async () => {
-    const { handle: handle2 } = await spawnCodexAppServer({
-      host: input.host,
-      recipe: input.recipe,
-      layout: input.layout,
-      args: tokenizeLaunchArgs(input.recipe.launchArgs),
-      env
-    });
-    let completed;
-    const rpc = await createCodexRpcClient(handle2, {
-      onNotification: (notification) => {
-        if (notification.method !== "account/login/completed") return;
-        const params = isRecord3(notification.params) ? notification.params : {};
-        const loginId = asString(params["loginId"]);
-        completed = loginId ? { loginId } : {};
-      },
-      onServerRequest: () => void 0,
-      onStderrLine: () => void 0
-    });
-    try {
-      await rpc.request("initialize", CODEX_INITIALIZE_PARAMS);
-      await rpc.notify("initialized");
-      const started = await rpc.request("account/login/start", { type: "chatgptDeviceCode" });
-      if (!isRecord3(started) || asString(started["type"]) !== "chatgptDeviceCode") {
-        await rpc.close();
-        return void 0;
-      }
-      const userCode2 = asString(started["userCode"]) ?? asString(started["user_code"]) ?? void 0;
-      const verificationUrl2 = asString(started["verificationUrl"]) ?? asString(started["verification_uri"]) ?? asString(started["url"]) ?? void 0;
-      const operationId2 = `codex-login-${Date.now()}`;
-      return {
-        operation: {
-          operationId: operationId2,
-          handle: handle2,
-          close: async () => {
-            void completed;
-            await rpc.close();
-          }
+  const lifetime = signInLifetime(input.signal);
+  try {
+    const tryAppServer = async () => {
+      const { handle: handle2 } = await spawnCodexAppServer({
+        host: input.host,
+        recipe: loginRecipe,
+        layout: input.layout,
+        env,
+        signal: lifetime.signal
+      });
+      const completion = Promise.withResolvers();
+      let expectedLoginId;
+      const earlyCompletions = [];
+      const receiveCompletion = (result) => {
+        if (expectedLoginId === void 0) earlyCompletions.push(result);
+        else if (expectedLoginId === null || result.loginId === expectedLoginId)
+          completion.resolve(result);
+      };
+      const rpc = await createCodexRpcClient(handle2, {
+        onNotification: (notification) => {
+          if (notification.method !== "account/login/completed") return;
+          const params = isRecord3(notification.params) ? notification.params : {};
+          const loginId = asString(params["loginId"]);
+          receiveCompletion({
+            loginId,
+            success: params["success"] === true,
+            error: asString(params["error"])
+          });
         },
-        ...userCode2 ? { userCode: userCode2 } : {},
-        ...verificationUrl2 ? { verificationUrl: verificationUrl2 } : {}
+        onServerRequest: () => void 0,
+        onStderrLine: () => void 0
+      });
+      const close = async () => {
+        lifetime.close();
+        await closeSignInRpc(rpc, input.host, handle2);
       };
-    } catch {
-      await rpc.close().catch(() => void 0);
-      return void 0;
-    }
-  };
-  const appServer = await tryAppServer();
-  if (appServer) return appServer;
-  const handle = await input.host.process.spawn({
-    program: input.recipe.binaryPath,
-    args: [...codexExecLaunchArgs(input.recipe.launchArgs), ...CODEX_CARD.deviceCodeSignInArgs],
-    owner,
-    env
-  });
-  const stdout = { text: "" };
-  const stderr = { text: "" };
-  void collectText(handle.stdout, stdout);
-  void collectText(handle.stderr, stderr);
-  const deadline = Date.now() + 3e3;
-  while (Date.now() < deadline) {
-    const combined2 = `${stdout.text}
+      const abort = () => {
+        void closeSignInRpc(rpc, input.host, handle2).catch(() => void 0);
+      };
+      lifetime.signal.addEventListener("abort", abort, { once: true });
+      if (lifetime.signal.aborted) abort();
+      try {
+        await raceAbort(rpc.request("initialize", CODEX_INITIALIZE_PARAMS), lifetime.signal);
+        await raceAbort(rpc.notify("initialized"), lifetime.signal);
+        const started = await raceAbort(
+          rpc.request("account/login/start", { type: "chatgptDeviceCode" }),
+          lifetime.signal
+        );
+        if (!isRecord3(started) || asString(started["type"]) !== "chatgptDeviceCode") {
+          await closeSignInRpc(rpc, input.host, handle2);
+          return void 0;
+        }
+        const userCode2 = asString(started["userCode"]) ?? asString(started["user_code"]) ?? void 0;
+        const verificationUrl2 = asString(started["verificationUrl"]) ?? asString(started["verification_uri"]) ?? asString(started["url"]) ?? void 0;
+        const operationId2 = `codex-login-${Date.now()}`;
+        expectedLoginId = asString(started["loginId"]);
+        for (const result of earlyCompletions) receiveCompletion(result);
+        earlyCompletions.length = 0;
+        const completed2 = raceAbort(
+          Promise.race([
+            completion.promise.then((result) => {
+              if (!result.success) throw new Error(result.error ?? "Codex sign-in failed");
+            }),
+            handle2.exited.then(() => {
+              throw new Error("Codex exited before sign-in completed");
+            })
+          ]),
+          lifetime.signal
+        );
+        void completed2.catch(() => void 0);
+        return {
+          operation: {
+            operationId: operationId2,
+            handle: handle2,
+            completed: completed2,
+            close: async () => {
+              lifetime.signal.removeEventListener("abort", abort);
+              await close();
+            }
+          },
+          ...userCode2 ? { userCode: userCode2 } : {},
+          ...verificationUrl2 ? { verificationUrl: verificationUrl2 } : {}
+        };
+      } catch (error) {
+        await closeSignInRpc(rpc, input.host, handle2).catch(() => void 0);
+        if (lifetime.signal.aborted) throw error;
+        return void 0;
+      }
+    };
+    const appServer = await tryAppServer();
+    if (appServer) return appServer;
+    const handle = await input.host.process.spawn({
+      program: input.recipe.binaryPath,
+      args: [
+        ...codexExecLaunchArgs(encodeCodexConnectionArgs(loginRecipe, input.layout)),
+        ...CODEX_CARD.deviceCodeSignInArgs
+      ],
+      owner,
+      env,
+      signal: lifetime.signal
+    });
+    const stdout = { text: "" };
+    const stderr = { text: "" };
+    void collectText(handle.stdout, stdout);
+    void collectText(handle.stderr, stderr);
+    const deadline = Date.now() + 3e3;
+    while (Date.now() < deadline) {
+      const combined2 = `${stdout.text}
 ${stderr.text}`;
-    if (deviceCodeUrl(combined2) && deviceCodeValue(combined2)) break;
-    await new Promise((resolve2) => setTimeout(resolve2, 50));
-  }
-  const combined = `${stdout.text}
+      if (deviceCodeUrl(combined2) && deviceCodeValue(combined2)) break;
+      await new Promise((resolve2) => setTimeout(resolve2, 50));
+    }
+    const combined = `${stdout.text}
 ${stderr.text}`;
-  const operationId = `codex-login-${Date.now()}`;
-  const userCode = deviceCodeValue(combined);
-  const verificationUrl = deviceCodeUrl(combined);
-  return {
-    operation: {
-      operationId,
-      handle,
-      close: async () => {
-        try {
-          await handle.closeStdin();
-        } catch {
-        }
-        try {
-          await handle.kill("SIGTERM");
-        } catch {
+    const operationId = `codex-login-${Date.now()}`;
+    const userCode = deviceCodeValue(combined);
+    const verificationUrl = deviceCodeUrl(combined);
+    const completed = raceAbort(
+      handle.exited.then((code) => {
+        if (code !== 0)
+          throw new Error(stderr.text.trim() || `Codex sign-in exited with code ${String(code)}`);
+      }),
+      lifetime.signal
+    );
+    void completed.catch(() => void 0);
+    return {
+      operation: {
+        operationId,
+        handle,
+        completed,
+        close: async () => {
+          lifetime.close();
+          try {
+            await handle.closeStdin();
+          } catch {
+          }
+          try {
+            await handle.kill("SIGTERM");
+            await handle.exited;
+          } catch {
+          }
         }
-      }
-    },
-    ...userCode ? { userCode } : {},
-    ...verificationUrl ? { verificationUrl } : {}
-  };
+      },
+      ...userCode ? { userCode } : {},
+      ...verificationUrl ? { verificationUrl } : {}
+    };
+  } catch (error) {
+    lifetime.close();
+    throw error;
+  }
 }
 async function verifyCodexSignIn(input) {
   const home = accountHomeFromLayout(input.layout);
@@ -4844,16 +4948,21 @@ async function verifyCodexSignIn(input) {
   const env = nativeLoginSpawnEnv(input.processEnv, home);
   const { handle } = await spawnCodexAppServer({
     host: input.host,
-    recipe: input.recipe,
+    recipe: { ...input.recipe, authMode: "chatgpt" },
     layout: input.layout,
-    args: tokenizeLaunchArgs(input.recipe.launchArgs),
-    env
+    env,
+    ...input.signal === void 0 ? {} : { signal: input.signal }
   });
   const rpc = await createCodexRpcClient(handle, {
     onNotification: () => void 0,
     onServerRequest: () => void 0,
     onStderrLine: () => void 0
   });
+  const abort = () => {
+    void closeSignInRpc(rpc, input.host, handle).catch(() => void 0);
+  };
+  input.signal?.addEventListener("abort", abort, { once: true });
+  if (input.signal?.aborted) abort();
   let version = null;
   try {
     version = codexVersionFromInitialize(
@@ -4861,7 +4970,8 @@ async function verifyCodexSignIn(input) {
     );
     await rpc.notify("initialized");
     const account = await rpc.request("account/read", { refreshToken: true }, 15e3);
-    const type = isRecord3(account) ? asString(account["type"]) : null;
+    const details = isRecord3(account) && isRecord3(account["account"]) ? account["account"] : account;
+    const type = isRecord3(details) ? asString(details["type"]) : null;
     if (type !== "chatgpt") {
       return {
         installed: true,
@@ -4876,7 +4986,11 @@ async function verifyCodexSignIn(input) {
       installed: true,
       version,
       readiness: "ready",
-      auth,
+      auth: {
+        ...auth,
+        status: "authenticated",
+        ...isRecord3(details) && asString(details["email"]) ? { email: asString(details["email"]) } : {}
+      },
       ...models === void 0 ? {} : { models },
       ...CODEX_NATIVE_MODE_REPORT
     };
@@ -4889,9 +5003,52 @@ async function verifyCodexSignIn(input) {
       ...CODEX_NATIVE_MODE_REPORT
     };
   } finally {
-    await rpc.close().catch(() => void 0);
+    input.signal?.removeEventListener("abort", abort);
+    await closeSignInRpc(rpc, input.host, handle).catch(() => void 0);
+  }
+}
+async function verifyCodexSignInOperation(input) {
+  const operation = input.operations.values().next().value;
+  try {
+    if (operation) await raceAbort(operation.completed, input.signal);
+    return await verifyCodexSignIn(input);
+  } finally {
+    if (operation) {
+      await closeOperation(input.operations, operation);
+    }
   }
 }
+function makeCodexSignIn(input) {
+  const current = (signal) => ({
+    host: input.host,
+    recipe: input.recipe(),
+    layout: input.layout(),
+    processEnv: process.env,
+    ...signal === void 0 ? {} : { signal }
+  });
+  return {
+    start: async (signal) => {
+      const started = await startCodexSignIn(current(signal));
+      if (signal?.aborted || input.isDisposed()) {
+        await started.operation.close();
+        throw new Error("Codex sign-in cancelled");
+      }
+      input.operations.set(started.operation.operationId, started.operation);
+      input.onStarted(started.operation);
+      return {
+        operationId: started.operation.operationId,
+        ...started.userCode === void 0 ? {} : { userCode: started.userCode },
+        ...started.verificationUrl === void 0 ? {} : { verificationUrl: started.verificationUrl }
+      };
+    },
+    cancel: async (operationId) => {
+      const operation = input.operations.get(operationId);
+      if (operation === void 0) return;
+      await closeOperation(input.operations, operation);
+    },
+    verify: (signal) => verifyCodexSignInOperation({ ...current(signal), operations: input.operations })
+  };
+}
 
 // src/turnSummaryPrompt.ts
 function buildTurnSummaryPrompt(raw) {
@@ -6037,7 +6194,7 @@ var createCodexInstance = (config, host, attachments, cache) => {
       }
       trackHandle(handle, `${recipe.binaryPath} (probe)`);
       const spawned = handle;
-      return await raceAbort(
+      return await raceAbort2(
         (async () => {
           rpc = await createCodexRpcClient(spawned, {
             onNotification: () => void 0,
@@ -6309,9 +6466,8 @@ var createCodexInstance = (config, host, attachments, cache) => {
       );
       disposeTask = (async () => {
         const operations = [...signInOperations.values()];
-        signInOperations.clear();
         for (const operation of operations) {
-          await operation.close().catch(() => void 0);
+          await instance.signIn.cancel(operation.operationId).catch(() => void 0);
         }
         for (const result of await closing) {
           if (result.status === "rejected") throw result.reason;
@@ -6398,35 +6554,14 @@ var createCodexInstance = (config, host, attachments, cache) => {
         }
       }
     },
-    signIn: {
-      start: async () => {
-        const started = await startCodexSignIn({
-          host,
-          recipe,
-          layout: layoutFor(recipe),
-          processEnv: process.env
-        });
-        signInOperations.set(started.operation.operationId, started.operation);
-        trackHandle(started.operation.handle, "codex login --device-auth");
-        return {
-          operationId: started.operation.operationId,
-          ...started.userCode === void 0 ? {} : { userCode: started.userCode },
-          ...started.verificationUrl === void 0 ? {} : { verificationUrl: started.verificationUrl }
-        };
-      },
-      cancel: async (operationId) => {
-        const operation = signInOperations.get(operationId);
-        if (operation === void 0) return;
-        signInOperations.delete(operationId);
-        await operation.close().catch(() => void 0);
-      },
-      verify: async () => verifyCodexSignIn({
-        host,
-        recipe,
-        layout: layoutFor(recipe),
-        processEnv: process.env
-      })
-    },
+    signIn: makeCodexSignIn({
+      host,
+      recipe: () => recipe,
+      layout: () => layoutFor(recipe),
+      operations: signInOperations,
+      isDisposed: () => disposed,
+      onStarted: (operation) => trackHandle(operation.handle, "codex login --device-auth")
+    }),
     mcpOAuth: {
       start: async (input) => {
         const started = await startCodexMcpOAuth({
@@ -6497,7 +6632,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-codex",
-  apiVersion: 32,
+  apiVersion: 34,
   executors,
   activate(ctx) {
     capturedAttachments = ctx.attachments;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-codex",
-  "version": "0.2.3272",
+  "version": "0.2.3306",
   "description": "Codex executor: Codex CLI over the app-server JSON-RPC protocol.",
   "keywords": [
     "ycodium",
@@ -29,7 +29,7 @@
     "tailwindcss": "^4.0.0",
     "typescript": "~6.0.3",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3272",
+    "@ycodium-ai/plugin-api": "0.2.3306",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {