@episoda/cli 0.2.215 → 0.2.216

package/dist/daemon/daemon-process.js

@@ -3051,7 +3051,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.215",
+      version: "0.2.216",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4804,6 +4804,93 @@ async function ensureCodexBinary() {
 
 // src/agent/providers/codex-config.ts
 var DEFAULT_CODEX_MODEL = "gpt-5.4";
+var SUPPORTED_CODEX_PTY_MODELS = ["gpt-5.4", "gpt-5.3-codex"];
+function stripUnsupportedCodexFlags(args) {
+  const sanitized = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const current = args[index];
+    if (current === "--effort") {
+      index += 1;
+      continue;
+    }
+    if (current.startsWith("--effort=")) {
+      continue;
+    }
+    sanitized.push(current);
+  }
+  return sanitized;
+}
+function extractRequestedModel(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--model") {
+      const candidate = args[index + 1];
+      return typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : null;
+    }
+  }
+  return null;
+}
+function resolveSupportedCodexModel(model) {
+  const normalized = (model || "").trim();
+  if (SUPPORTED_CODEX_PTY_MODELS.includes(normalized)) {
+    return normalized;
+  }
+  if (normalized.toLowerCase().endsWith("-high")) {
+    return DEFAULT_CODEX_MODEL;
+  }
+  return DEFAULT_CODEX_MODEL;
+}
+function upsertModelArg(args, model) {
+  const nextArgs = [...args];
+  for (let index = 0; index < nextArgs.length; index += 1) {
+    if (nextArgs[index] === "--model") {
+      if (index + 1 < nextArgs.length) {
+        nextArgs[index + 1] = model;
+        return nextArgs;
+      }
+      nextArgs.push(model);
+      return nextArgs;
+    }
+  }
+  if (nextArgs[0] === "exec") {
+    return ["exec", "--model", model, ...nextArgs.slice(1)];
+  }
+  return ["--model", model, ...nextArgs];
+}
+function resolveCodexExecutionConfig(options) {
+  const requestedModel = options.preferredModel || extractRequestedModel(options.args || []);
+  const model = resolveSupportedCodexModel(requestedModel);
+  const env = { ...options.env || {} };
+  if (Array.isArray(options.args) && options.args.length > 0) {
+    return {
+      model,
+      args: upsertModelArg(stripUnsupportedCodexFlags(options.args), model),
+      env
+    };
+  }
+  const runType = options.runType || "persistent";
+  const prompt = options.prompt || "";
+  const useYolo = options.useYolo !== false;
+  const effortArgs = options.effort ? ["-c", `reasoning_effort="${options.effort}"`] : [];
+  if (runType === "persistent") {
+    return {
+      model,
+      args: ["--model", model, "--yolo", "--sandbox", "danger-full-access"],
+      env
+    };
+  }
+  if (useYolo) {
+    return {
+      model,
+      args: ["--model", model, ...effortArgs, "--yolo", "--sandbox", "danger-full-access", prompt],
+      env
+    };
+  }
+  return {
+    model,
+    args: ["exec", "--json", "--model", model, ...effortArgs, "--sandbox", "danger-full-access", "--skip-git-repo-check", prompt],
+    env
+  };
+}
 function generateCodexAuthJson(credentials) {
   const tokens = {
     id_token: credentials.idToken || credentials.accessToken,
@@ -12991,8 +13078,10 @@ var fs31 = __toESM(require("fs"));
 var os14 = __toESM(require("os"));
 var path31 = __toESM(require("path"));
 var INACTIVITY_TIMEOUT_MS3 = 30 * 60 * 1e3;
-var CODEX_READINESS_SIGNAL = /(?:\d+% left ·|\bmodel:\s+gpt-)/i;
 var ANSI_ESCAPE_CODE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+var CODEX_BANNER_SIGNAL = /(openai codex|\bmodel:)/i;
+var CODEX_PROMPT_SIGNAL = /(?:^|\n)\s*(?:>|❯)\s*$/m;
+var MAX_CODEX_STARTUP_READY_TIMEOUT_MS = 3e4;
 var sessions = /* @__PURE__ */ new Map();
 function killPtySessionsForModule(moduleUid) {
   const killedRunIds = [];
@@ -13031,16 +13120,30 @@ async function handlePtySpawn(payload, client) {
   console.log(`[PTY] Spawning PTY for ${moduleUid} / ${agent_run_id}: ${command} ${args.join(" ")}`);
   let bootstrap = null;
   let proc;
+  let modelUsed;
+  let launchConfig;
+  let spawnArgs = args;
   try {
     bootstrap = createCredentialBootstrap(payload, agent_run_id);
-    proc = pty.spawn(command, args, {
+    const executionConfig = command === "codex" ? resolveCodexExecutionConfig({ args, env }) : null;
+    spawnArgs = executionConfig?.args ?? args;
+    const spawnEnv = executionConfig?.env ?? (env || {});
+    modelUsed = executionConfig?.model;
+    launchConfig = buildPtyLaunchConfig({
+      command,
+      args: spawnArgs,
+      env: spawnEnv,
+      cwd: cwd || process.cwd(),
+      bootstrap
+    });
+    proc = pty.spawn(command, spawnArgs, {
       name: "xterm-256color",
       cols,
       rows,
       cwd: cwd || process.cwd(),
       env: {
         ...process.env,
-        ...env || {},
+        ...spawnEnv,
         ...bootstrap.env
       }
     });
@@ -13058,7 +13161,10 @@ async function handlePtySpawn(payload, client) {
     });
     return {
       success: false,
-      error: err?.message || `Failed to spawn PTY command '${command}'`
+      error: err?.message || `Failed to spawn PTY command '${command}'`,
+      modelUsed,
+      launchConfig,
+      authPath: bootstrap?.authPath
     };
   }
   const session = {
@@ -13070,7 +13176,7 @@ async function handlePtySpawn(payload, client) {
     lastOutputAt: Date.now(),
     watchdogTimer: null,
     credentialDirs: bootstrap.cleanupDirs,
-    startup: createStartupState(payload)
+    startup: createStartupState(payload, spawnArgs)
   };
   sessions.set(agent_run_id, session);
   const resetWatchdog = () => {
@@ -13087,7 +13193,7 @@ async function handlePtySpawn(payload, client) {
   resetWatchdog();
   proc.onData((data) => {
     resetWatchdog();
-    maybeSeedBufferedInitialPrompt(session, data);
+    handleStartupData(session, data);
     client.send({
       type: "pty_data",
       moduleUid,
@@ -13103,7 +13209,8 @@ async function handlePtySpawn(payload, client) {
   proc.onExit(({ exitCode }) => {
     if (session.startup && !session.startup.readinessObserved) {
       session.startup.markFailed(
-        `Codex PTY exited before startup readiness for ${agent_run_id} (exit code ${exitCode}).`
+        `Codex PTY exited before startup readiness for ${agent_run_id} (exit code ${exitCode}).`,
+        session.startup.failureClass || "EXIT_BEFORE_READY"
       );
     }
     const durationMs = Date.now() - session.startedAt;
@@ -13128,11 +13235,22 @@ async function handlePtySpawn(payload, client) {
     } catch (error) {
       return {
         success: false,
-        error: error?.message || "Codex PTY failed before startup readiness"
+        error: error?.message || "Codex PTY failed before startup readiness",
+        startupFailureClass: session.startup.failureClass,
+        startupConfirmedAt: session.startup.startupConfirmedAt,
+        modelUsed,
+        launchConfig,
+        authPath: bootstrap.authPath
       };
     }
   }
-  return { success: true };
+  return {
+    success: true,
+    startupConfirmedAt: session.startup?.startupConfirmedAt,
+    modelUsed,
+    launchConfig,
+    authPath: bootstrap.authPath
+  };
 }
 function handlePtyResize(payload) {
   const { agent_run_id, cols, rows } = payload;
@@ -13207,29 +13325,40 @@ function createCredentialBootstrap(payload, agentRunId) {
     fs31.writeFileSync(credentialsPath, JSON.stringify({ claudeAiOauth }, null, 2), { mode: 384 });
     return {
       env: { CLAUDE_CONFIG_DIR: claudeConfigDir },
-      cleanupDirs
+      cleanupDirs,
+      authPath: credentialsPath
     };
   }
   const codexHome = path31.join(baseDir, ".codex");
   fs31.mkdirSync(codexHome, { recursive: true });
+  const trustedProjectRoot = resolveCodexTrustedProjectRoot(payload);
   const configFiles = generateCodexConfig({
     accessToken: bootstrap.oauth.access_token,
     idToken: bootstrap.oauth.id_token,
     accountId: bootstrap.oauth.account_id
-  }, payload.cwd);
-  fs31.writeFileSync(path31.join(codexHome, "auth.json"), configFiles["auth.json"], { mode: 384 });
+  }, trustedProjectRoot);
+  const authPath = path31.join(codexHome, "auth.json");
+  const configPath = path31.join(codexHome, "config.toml");
+  fs31.writeFileSync(authPath, configFiles["auth.json"], { mode: 384 });
   if (configFiles["config.toml"]) {
-    fs31.writeFileSync(path31.join(codexHome, "config.toml"), configFiles["config.toml"], { mode: 384 });
+    fs31.writeFileSync(configPath, configFiles["config.toml"], { mode: 384 });
   }
   return {
     env: { CODEX_HOME: codexHome },
-    cleanupDirs
+    cleanupDirs,
+    authPath,
+    configPath,
+    codexHome,
+    trustedProjectRoot
   };
 }
-function createStartupState(payload) {
-  if (payload.run_type !== "persistent" || payload.command !== "codex" || typeof payload.stdin !== "string" || payload.stdin.trim().length === 0) {
+function createStartupState(payload, resolvedArgs) {
+  if (payload.command !== "codex") {
     return void 0;
   }
+  const trimmedStdin = typeof payload.stdin === "string" ? payload.stdin.trim() : "";
+  const trimmedArgvPrompt = payload.run_type === "persistent" ? "" : resolveCodexArgvPrompt(resolvedArgs);
+  const mode = payload.run_type === "persistent" ? trimmedStdin.length > 0 ? "seed_after_prompt" : "prompt_ready" : "first_output";
   let resolveReady;
   let rejectReady;
   const waitForReady = new Promise((resolve9, reject) => {
@@ -13237,10 +13366,14 @@ function createStartupState(payload) {
     rejectReady = reject;
   });
   const startup = {
-    pendingInitialStdin: payload.stdin,
+    mode,
+    pendingInitialStdin: typeof payload.stdin === "string" ? payload.stdin : "",
+    pendingInitialArgvPrompt: trimmedArgvPrompt,
     earlyOutput: "",
+    postSeedOutput: "",
+    bannerObserved: false,
     readinessObserved: false,
-    initialPromptSeeded: false,
+    initialPromptSeeded: mode !== "seed_after_prompt",
     readinessTimer: null,
     settled: false,
     waitForReady,
@@ -13250,9 +13383,10 @@ function createStartupState(payload) {
       if (startup.readinessTimer) clearTimeout(startup.readinessTimer);
       resolveReady();
     },
-    markFailed: (error) => {
+    markFailed: (error, failureClass) => {
       if (startup.settled) return;
       startup.settled = true;
+      startup.failureClass = failureClass;
       if (startup.readinessTimer) clearTimeout(startup.readinessTimer);
       rejectReady(new Error(error));
     }
@@ -13266,9 +13400,9 @@ function armStartupTimeout(session, proc) {
   }
   const timeoutMs = getCodexStartupReadyTimeoutMs();
   startup.readinessTimer = setTimeout(() => {
-    const error = `Codex PTY readiness timeout after ${timeoutMs}ms for ${session.agent_run_id}.`;
+    const error = startup.mode === "seed_after_prompt" ? startup.initialPromptSeeded ? `STARTUP_TIMEOUT: Codex PTY startup acceptance was not observed within ${timeoutMs}ms for ${session.agent_run_id}.` : `STARTUP_TIMEOUT: Codex PTY prompt was not observed within ${timeoutMs}ms for ${session.agent_run_id}.` : startup.mode === "prompt_ready" ? `STARTUP_TIMEOUT: Codex PTY prompt was not observed within ${timeoutMs}ms for ${session.agent_run_id}.` : `STARTUP_TIMEOUT: Codex PTY startup output was not observed within ${timeoutMs}ms for ${session.agent_run_id}.`;
     console.error(`[PTY] EP1498: ${error}`);
-    startup.markFailed(error);
+    startup.markFailed(error, "STARTUP_TIMEOUT");
     try {
       proc.kill();
     } catch (killError) {
@@ -13276,29 +13410,162 @@ function armStartupTimeout(session, proc) {
     }
   }, timeoutMs);
 }
-function maybeSeedBufferedInitialPrompt(session, data) {
+function handleStartupData(session, data) {
   const startup = session.startup;
-  if (!startup || startup.initialPromptSeeded) {
+  if (!startup) {
     return;
   }
-  if (!startup.readinessObserved) {
-    startup.earlyOutput += data;
+  startup.earlyOutput += data;
+  const normalizedEarlyOutput = normalizeCodexStartupOutput(startup.earlyOutput);
+  const detectedFailure = detectCodexStartupFailure(normalizedEarlyOutput);
+  if (detectedFailure) {
+    const error = `${detectedFailure.failureClass}: ${detectedFailure.message}`;
+    console.error(`[PTY] EP1514: ${error}`);
+    startup.markFailed(error, detectedFailure.failureClass);
+    try {
+      session.pty.kill();
+    } catch (killError) {
+      console.warn(`[PTY] EP1514: Failed to kill failed startup PTY for ${session.agent_run_id}:`, killError);
+    }
+    return;
   }
-  const normalizedEarlyOutput = startup.earlyOutput.replace(ANSI_ESCAPE_CODE_REGEX, "");
-  if (!startup.readinessObserved && CODEX_READINESS_SIGNAL.test(normalizedEarlyOutput)) {
-    startup.readinessObserved = true;
-    startup.earlyOutput = "";
+  if (!startup.bannerObserved && CODEX_BANNER_SIGNAL.test(normalizedEarlyOutput)) {
+    startup.bannerObserved = true;
   }
-  if (!startup.readinessObserved) {
+  if (startup.mode === "seed_after_prompt" && !startup.initialPromptSeeded) {
+    if (!startup.bannerObserved || !CODEX_PROMPT_SIGNAL.test(normalizedEarlyOutput)) {
+      return;
+    }
+    session.pty.write(`${startup.pendingInitialStdin}\r`);
+    startup.initialPromptSeeded = true;
+    startup.postSeedOutput = "";
     return;
   }
-  session.pty.write(`${startup.pendingInitialStdin}\r`);
-  startup.initialPromptSeeded = true;
+  if (startup.mode === "prompt_ready") {
+    if (!startup.bannerObserved || !CODEX_PROMPT_SIGNAL.test(normalizedEarlyOutput)) {
+      return;
+    }
+  } else {
+    startup.postSeedOutput += data;
+    const normalizedPostSeedOutput = normalizeCodexStartupOutput(
+      startup.mode === "seed_after_prompt" ? startup.postSeedOutput : startup.earlyOutput
+    );
+    const readinessOutput = startup.mode === "first_output" ? stripEchoedCodexStartupInput(normalizedPostSeedOutput, startup.pendingInitialArgvPrompt) : normalizedPostSeedOutput;
+    if (!hasMeaningfulCodexStartupAcceptance(readinessOutput, [startup.pendingInitialStdin])) {
+      return;
+    }
+  }
+  if (startup.readinessObserved) {
+    return;
+  }
+  startup.readinessObserved = true;
+  startup.startupConfirmedAt = (/* @__PURE__ */ new Date()).toISOString();
   startup.markReady();
 }
 function getCodexStartupReadyTimeoutMs() {
-  const parsed = Number(process.env.EPISODA_CODEX_READY_TIMEOUT_MS || "8000");
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 8e3;
+  const parsed = Number(process.env.EPISODA_CODEX_READY_TIMEOUT_MS || String(MAX_CODEX_STARTUP_READY_TIMEOUT_MS));
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return MAX_CODEX_STARTUP_READY_TIMEOUT_MS;
+  }
+  return Math.min(parsed, MAX_CODEX_STARTUP_READY_TIMEOUT_MS);
+}
+function detectCodexStartupFailure(normalizedOutput) {
+  const loweredOutput = normalizedOutput.toLowerCase();
+  if (loweredOutput.includes("do you trust the contents of this directory?")) {
+    return {
+      failureClass: "TRUST_PROMPT_STALL",
+      message: "Codex prompted for directory trust during non-interactive startup."
+    };
+  }
+  if (loweredOutput.includes("access token could not be refreshed")) {
+    return {
+      failureClass: "OAUTH_REFRESH_ROTATION_CONFLICT",
+      message: "Codex attempted refresh-token rotation against externally managed auth."
+    };
+  }
+  if (loweredOutput.includes("--effort") && (loweredOutput.includes("unknown option") || loweredOutput.includes("unexpected argument") || loweredOutput.includes("unrecognized option") || loweredOutput.includes("unexpected value"))) {
+    return {
+      failureClass: "UNSUPPORTED_FLAG",
+      message: "Codex rejected the unsupported --effort launch flag."
+    };
+  }
+  if (/\b(?:unknown|invalid|unsupported)\b[^\n]*\bmodel\b/i.test(normalizedOutput) || /\bmodel\b[^\n]*(?:not supported|unsupported|unknown|invalid)\b/i.test(normalizedOutput) || /\b(?:400|bad request)\b[^\n]*\bmodel\b/i.test(normalizedOutput)) {
+    return {
+      failureClass: "MODEL_UNSUPPORTED",
+      message: "Codex rejected an unsupported model during startup."
+    };
+  }
+  return null;
+}
+function normalizeCodexStartupOutput(output) {
+  return output.replace(ANSI_ESCAPE_CODE_REGEX, "").replace(/\r/g, "");
+}
+function hasMeaningfulCodexStartupAcceptance(output, echoedInputs) {
+  const withoutEchoes = echoedInputs.reduce((currentOutput, echoedInput) => {
+    return stripEchoedCodexStartupInput(currentOutput, echoedInput);
+  }, output);
+  const sanitized = withoutEchoes.replace(/(?:^|\n)\s*openai codex\s*(?=\n|$)/gi, "\n").replace(/(?:^|\n)\s*model:[^\n]*/gi, "\n").replace(CODEX_PROMPT_SIGNAL, "").replace(/\s+/g, "");
+  return sanitized.length > 0;
+}
+function stripEchoedCodexStartupInput(output, echoedInput) {
+  const normalizedEcho = echoedInput.trim();
+  if (normalizedEcho.length === 0) {
+    return output;
+  }
+  let strippedOutput = output.replace(new RegExp(escapeRegExp(normalizedEcho), "g"), "");
+  const whitespaceFlexiblePattern = buildWhitespaceFlexiblePattern(normalizedEcho);
+  if (whitespaceFlexiblePattern) {
+    strippedOutput = strippedOutput.replace(whitespaceFlexiblePattern, "");
+  }
+  return strippedOutput;
+}
+function buildWhitespaceFlexiblePattern(value) {
+  const normalizedValue = value.trim().replace(/\s+/g, " ");
+  if (normalizedValue.length === 0) {
+    return null;
+  }
+  return new RegExp(normalizedValue.split(" ").map(escapeRegExp).join("\\s+"), "g");
+}
+function resolveCodexArgvPrompt(args) {
+  const positionalArgs = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const current = args[index];
+    if (!current) {
+      continue;
+    }
+    if (current === "--model" || current === "--sandbox" || current === "-c") {
+      index += 1;
+      continue;
+    }
+    if (current.startsWith("--model=") || current.startsWith("--sandbox=") || current.startsWith("-c=") || current.startsWith("--")) {
+      continue;
+    }
+    positionalArgs.push(current);
+  }
+  return positionalArgs.length === 0 ? "" : positionalArgs[positionalArgs.length - 1].trim();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildPtyLaunchConfig(params) {
+  const { command, args, env, cwd, bootstrap } = params;
+  const launchConfig = {
+    command,
+    args,
+    env,
+    cwd
+  };
+  if (bootstrap?.authPath) {
+    launchConfig.auth_path = bootstrap.authPath;
+  }
+  if (bootstrap?.configPath) {
+    launchConfig.config_path = bootstrap.configPath;
+  }
+  if (bootstrap?.codexHome) {
+    launchConfig.codex_home = bootstrap.codexHome;
+    launchConfig.trusted_project_root = bootstrap.trustedProjectRoot || null;
+  }
+  return launchConfig;
 }
 function cleanupCredentialDirs(dirs) {
   for (const dirPath of dirs) {
@@ -13311,6 +13578,17 @@ function cleanupCredentialDirs(dirs) {
     }
   }
 }
+function resolveCodexTrustedProjectRoot(payload) {
+  const cwd = typeof payload.cwd === "string" ? payload.cwd.trim() : "";
+  const envWorktreeDir = typeof payload.env?.EPISODA_WORKTREE_DIR === "string" ? payload.env.EPISODA_WORKTREE_DIR.trim() : "";
+  if (cwd.length > 0) {
+    return cwd;
+  }
+  if (envWorktreeDir.length > 0) {
+    return envWorktreeDir;
+  }
+  return process.cwd();
+}
 
 // src/utils/dev-server.ts
 var import_child_process16 = require("child_process");
@@ -15102,7 +15380,12 @@ var ProjectMessageRouter = class {
           moduleUid: resolvedPayload.moduleUid,
           agent_run_id: resolvedPayload.agent_run_id,
           success: result.success,
-          error: result.error
+          error: result.error,
+          startupFailureClass: result.startupFailureClass,
+          startupConfirmedAt: result.startupConfirmedAt,
+          modelUsed: result.modelUsed,
+          launchConfig: result.launchConfig,
+          authPath: result.authPath
         });
       }
     });