@chorus-aidlc/chorus 0.17.2 → 0.18.0

package/cli/codex-spawner.mjs

@@ -27,6 +27,8 @@
 // stream parse) and the PATH-walk shape of resolveClaudePath.
 
 import { spawn } from "node:child_process";
+import { safeSpawnError } from "./launch-diagnostics.mjs";
+import { validateAgentCliConfig, overlayAgentEnv, getAgentEnv, assertConfiguredShimArgs } from "./agent-cli-config.mjs";
 import { readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, win32 as pathWin32, posix as pathPosix } from "node:path";
@@ -49,8 +51,9 @@ const NOOP_LOGGER = { info() {}, warn() {}, error() {} };
 export function hasChorusMcpServer(deps = {}) {
   const env = deps.env ?? process.env;
   const readFile = deps.readFile ?? readFileSync;
-  const home = deps.home ?? homedir();
-  const configPath = join(env.CODEX_HOME || join(home, ".codex"), "config.toml");
+  const platform = deps.platform ?? process.platform;
+  const home = deps.home ?? getAgentEnv(env, "HOME", platform) ?? getAgentEnv(env, "USERPROFILE", platform) ?? homedir();
+  const configPath = join(getAgentEnv(env, "CODEX_HOME", platform) || join(home, ".codex"), "config.toml");
   try {
     const config = readFile(configPath, "utf8");
     return /^\s*\[mcp_servers\.chorus\]\s*(?:#.*)?$/m.test(config);
@@ -148,14 +151,15 @@ export function resolveCodexPath(deps = {}) {
       }
     });
 
-  if (env.CHORUS_CODEX_PATH && isFile(env.CHORUS_CODEX_PATH)) {
-    return env.CHORUS_CODEX_PATH;
+  const override = getAgentEnv(env, "CHORUS_CODEX_PATH", platform);
+  if (override && isFile(override)) {
+    return override;
   }
 
   const isWin = platform === "win32";
   const p = isWin ? pathWin32 : pathPosix;
   const names = isWin ? ["codex.cmd", "codex.exe", "codex"] : ["codex"];
-  const pathVar = env.PATH || env.Path || "";
+  const pathVar = getAgentEnv(env, "PATH", platform) || env.Path || "";
   const dirs = pathVar.split(p.delimiter).filter(Boolean);
   for (const dir of dirs) {
     for (const name of names) {
@@ -178,7 +182,7 @@ export function resolveSpawnCommand(codexPath, args, platform = process.platform
   const isWin = platform === "win32";
   const lower = codexPath.toLowerCase();
   if (isWin && (lower.endsWith(".cmd") || lower.endsWith(".bat"))) {
-    const comspec = env.ComSpec || env.COMSPEC || "cmd.exe";
+    const comspec = getAgentEnv(env, "COMSPEC", platform) || "cmd.exe";
     return { command: comspec, argv: ["/d", "/s", "/c", codexPath, ...args] };
   }
   return { command: codexPath, argv: args };
@@ -210,6 +214,8 @@ export class CodexSpawner {
     this.permissionMode = opts.permissionMode ?? "chorus";
     this.creds = opts.creds ?? null;
     this.platform = opts.platform ?? process.platform;
+    this.cliConfig = validateAgentCliConfig(opts.cliConfig, "codex", opts.label);
+    this.env = overlayAgentEnv(opts.env ?? process.env, this.cliConfig.env, this.platform);
     this.getThreadIdFn = opts.getThreadIdFn ?? defaultGetThreadId;
     this.setThreadIdFn = opts.setThreadIdFn ?? defaultSetThreadId;
     this.getUsageSnapshotFn = opts.getUsageSnapshotFn ?? defaultGetUsageSnapshot;
@@ -246,7 +252,7 @@ export class CodexSpawner {
     // instead of publishing the entire historical cumulative total.
     let needsUsageSeed = Boolean(knownThreadId && !previousUsage);
 
-    const codexPath = this.codexPath ?? this.resolveCodexPathFn();
+    const codexPath = this.codexPath ?? this.resolveCodexPathFn({ env: this.env, platform: this.platform });
     if (!codexPath) {
       // No crash — surface visibly and resolve with a failure result.
       this.logger.error("[Chorus] cannot locate the `codex` executable on PATH; skipping wake");
@@ -255,15 +261,17 @@ export class CodexSpawner {
 
     if (!this.mcpConfigChecked) {
       this.mcpConfigChecked = true;
-      if (!this.hasChorusMcpServerFn()) {
+      if (!this.hasChorusMcpServerFn({ env: this.env, platform: this.platform })) {
         this.logger.warn(
           "[Chorus] Codex config has no [mcp_servers.chorus] entry; wake will continue without Chorus MCP tools",
         );
       }
     }
 
-    const args = buildCodexArgs({ isNew, threadId: knownThreadId, permissionMode: this.permissionMode });
-    const { command, argv } = resolveSpawnCommand(codexPath, args, this.platform);
+    assertConfiguredShimArgs(codexPath, this.cliConfig.args, this.platform);
+    const args = [...buildCodexArgs({ isNew, threadId: knownThreadId, permissionMode: this.permissionMode }), ...this.cliConfig.args,
+      ...(this.cliConfig.args.length ? ["-"] : [])];
+    const { command, argv } = resolveSpawnCommand(codexPath, args, this.platform, this.env);
 
     // POSIX: detached process group so the interrupt path can group-kill the tree
     // (codex exec forks child shells for tools). Windows uses taskkill /T. stdio
@@ -273,7 +281,7 @@ export class CodexSpawner {
     // Export the daemon's resolved connection pair for both Codex MCP auth and
     // SessionStart hooks. Explicitly overwrite inherited values so the hook and
     // daemon cannot disagree about which Chorus instance this wake belongs to.
-    const childEnv = { ...process.env, CHORUS_DAEMON_HEADLESS: "1" };
+    const childEnv = { ...this.env, CHORUS_DAEMON_HEADLESS: "1" };
     if (this.creds) {
       if (this.creds.url) childEnv.CHORUS_URL = this.creds.url;
       if (this.creds.apiKey) childEnv.CHORUS_API_KEY = this.creds.apiKey;
@@ -294,8 +302,8 @@ export class CodexSpawner {
           detached,
           windowsHide: true,
         });
-      } catch (err) {
-        this.logger.error(`[Chorus] failed to spawn codex: ${err}`);
+      } catch (error) {
+        this.logger.error(`[Chorus] failed to spawn codex: ${safeSpawnError(error)}`);
         resolve({ sessionId: anchor, backendSessionId: knownThreadId, exitCode: null, isNew });
         return;
       }
@@ -357,8 +365,8 @@ export class CodexSpawner {
         if (text) this.logger.warn(`[Chorus] codex stderr: ${text}`);
       });
 
-      child.on("error", (err) => {
-        this.logger.error(`[Chorus] codex process error: ${err}`);
+      child.on("error", (error) => {
+        this.logger.error(`[Chorus] codex process error: ${safeSpawnError(error)}`);
         resolve({ sessionId: anchor, backendSessionId: observedThreadId, exitCode: null, isNew });
       });
 

package/cli/credentials.mjs

@@ -19,6 +19,7 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+import { rejectSharedCliConfig } from "./agent-cli-config.mjs";
 
 /** Absolute path to the login file written by `chorus login`. */
 export function loginFilePath() {
@@ -425,6 +426,7 @@ export function resolveLaunchAgent(flags = {}, deps = {}) {
   const wanted = nonEmpty(flags.name) ?? nonEmpty(flags.agent) ?? nonEmpty(env.CHORUS_AGENT_PROFILE);
 
   const file = readJson(loginPath);
+  rejectSharedCliConfig(file);
   const agentEntries =
     file && Array.isArray(file.agents)
       ? file.agents.filter((a) => a && typeof a === "object")
@@ -448,6 +450,8 @@ export function resolveLaunchAgent(flags = {}, deps = {}) {
     agentUuid: nonEmpty(entry.agentUuid),
     agentName: nonEmpty(entry.agentName) ?? nonEmpty(entry.name),
     agentType: nonEmpty(entry.agentType),
+    args: entry.args,
+    env: entry.env,
   }));
   const labels = resolved.map((a) => a.label).join(", ");
 
@@ -479,6 +483,9 @@ export function resolveLaunchAgent(flags = {}, deps = {}) {
     agentUuid: selected.agentUuid,
     agentName: selected.agentName,
     agentType: selected.agentType,
+    // Validation uses the launcher's effective --type, not the stored classification.
+    args: selected.args,
+    env: selected.env,
     label: selected.label,
   };
 }

package/cli/daemon-agent.mjs

@@ -44,7 +44,7 @@ export const DEFAULT_AGENT = "claude-code";
 export function backendCli(agentType) {
   if (agentType === "codex") return { name: "codex", envVar: "CHORUS_CODEX_PATH" };
   if (agentType === "kiro") return { name: "kiro-cli", envVar: "CHORUS_KIRO_PATH" };
-  if (agentType === "dsh") return { name: "dsh-jsonrpc-agent", envVar: "CHORUS_DSH_PATH" };
+  if (agentType === "dsh") return { name: "dsh", envVar: "CHORUS_DSH_PATH" };
   if (agentType === "pi") return { name: "pi", envVar: "CHORUS_PI_PATH" };
   // `offline` has no CLI to resolve — it is never woken (see backendClientType).
   // The daemon does not probe a binary for it; this explicit descriptor keeps the

package/cli/daemon-config.mjs

@@ -18,6 +18,14 @@ import { isAbsolute, resolve as resolvePath } from "node:path";
 import { loginFilePath, resolveCredentials, resolveCredentialDefaults } from "./credentials.mjs";
 import { resolveAgentType, KNOWN_AGENTS } from "./daemon-agent.mjs";
 import { resolvePermissionMode } from "./daemon-permission-mode.mjs";
+import { rejectSharedCliConfig, validateAgentCliConfig } from "./agent-cli-config.mjs";
+
+/** Read only the flat profile customization; also used by the legacy startup path. */
+export function resolveFlatAgentCliConfig(type, deps = {}) {
+  const file = (deps.readJson ?? readJsonSafe)(deps.loginPath ?? loginFilePath());
+  rejectSharedCliConfig(file);
+  return validateAgentCliConfig(file ?? {}, type, "agent");
+}
 
 /** Built-in default escalation window (ms) — matches the spec's 10 seconds. */
 export const DEFAULT_SIGINT_TIMEOUT_MS = 10_000;
@@ -307,6 +315,8 @@ function positiveInt(value) {
  * @property {string} url                       Chorus server URL for this agent.
  * @property {string} apiKey                    This agent's `cho_` API key.
  * @property {string} agentType                 Backend: claude-code | codex | kiro | dsh | offline.
+ * @property {string[]} args                   Literal extra backend arguments (per-agent only).
+ * @property {Record<string,string>} env       Literal child environment overrides (per-agent only).
  * @property {boolean} [daemonWake]             Wake opt-in for a wakeable backend; only
  *                                              `false` disables (absent/true ⇒ woken).
  * @property {Array<string|undefined>} cwds     Served paths (`undefined` ⇒ process cwd).
@@ -344,6 +354,8 @@ export function resolveAgentConfigs(flags = {}, deps = {}) {
   const home = deps.home ?? homedir();
   const file = readJson(loginPath);
 
+  rejectSharedCliConfig(file);
+
   // Global default permission posture; a per-agent `permissionMode` overrides it.
   // needConfirm/hasAck is vestigial, so isTTY/hasAck do not affect the resolved mode.
   const defaultPermissionMode =
@@ -365,6 +377,7 @@ export function resolveAgentConfigs(flags = {}, deps = {}) {
         url: creds.url,
         apiKey: creds.apiKey,
         agentType: at.agent,
+        ...validateAgentCliConfig(file ?? {}, at.agent, "agent"),
         cwds: resolveDaemonCwds(flags, deps),
         permissionMode: defaultPermissionMode,
         maxConcurrency: positiveInt(file?.maxConcurrency) ?? DEFAULT_MAX_CONCURRENCY,
@@ -449,6 +462,7 @@ export function resolveAgentConfigs(flags = {}, deps = {}) {
       url,
       apiKey,
       agentType,
+      ...validateAgentCliConfig(entry, agentType, label),
       cwds,
       permissionMode,
       maxConcurrency,

package/cli/daemon.mjs

@@ -40,12 +40,13 @@ import { EventRouter } from "./event-router.mjs";
 import { WakeQueue } from "./wake-queue.mjs";
 import { Waker } from "./waker.mjs";
 import { LineageResolver } from "./lineage.mjs";
-import { resolveClaudePath } from "./claude-spawner.mjs";
+import { resolveClaudePath, isNewSession } from "./claude-spawner.mjs";
 import { resolveCodexPath } from "./codex-spawner.mjs";
 import { resolveDshPath } from "./dsh-spawner.mjs";
 import { prepareManagedDshConfig } from "./dsh-managed-config.mjs";
 import { resolveKiroPath } from "./kiro-spawner.mjs";
 import { selectSpawner } from "./spawner-select.mjs";
+import { overlayAgentEnv } from "./agent-cli-config.mjs";
 import {
   createExecutionUploadHooks,
   createTranscriptUploadHooks,
@@ -61,6 +62,7 @@ import {
   resolveDaemonCwds,
   resolveBrowseRoots,
   resolveAgentConfigs,
+  resolveFlatAgentCliConfig,
   hasConfiguredAgents,
 } from "./daemon-config.mjs";
 import { discoverDirectories, validateDirectory } from "./directory-discovery.mjs";
@@ -157,6 +159,10 @@ export function buildDaemon(creds, deps = {}) {
   // passed through so the Codex backend can export the daemon key into the woken
   // process env (the Claude backend ignores creds — it gets its key via --mcp-config).
   const spawner = deps.spawner ?? selectSpawner(agentType, {
+    ...deps.spawnerOptions,
+    cliConfig: deps.cliConfig,
+    env: deps.env,
+    label: deps.label,
     logger,
     permissionMode,
     creds,
@@ -306,6 +312,7 @@ export function buildDaemon(creds, deps = {}) {
         creds,
         lineage,
         spawner,
+        isNewSessionFn: (sessionId, runCwd) => isNewSession(sessionId, runCwd, { env: spawner.env, platform: spawner.platform }),
         cwd: boundCwd,
         hooks,
         logger,
@@ -664,6 +671,8 @@ export function buildMultiAgentDaemon(agentConfigs, deps = {}) {
         logger,
         permissionMode: cfg.permissionMode,
         agentType: cfg.agentType,
+        cliConfig: { args: cfg.args, env: cfg.env },
+        label: cfg.label,
         cwds: cfg.cwds,
         cwd: undefined,
         maxConcurrency: cfg.maxConcurrency,
@@ -862,6 +871,19 @@ export async function runDaemon(flags = {}, deps = {}) {
     return handleLifecycleAction(action, { log, errLog, lifecycle, service, pfDeps });
   }
 
+  // Validate flat customization before credential/network preflight, including
+  // the detach path. Lifecycle-only actions above do not launch an agent.
+  const multiAgent = hasConfiguredAgents({ readJson: deps.readJson, loginPath: deps.loginPath });
+  let cliConfig;
+  if (!multiAgent) {
+    try {
+      cliConfig = resolveFlatAgentCliConfig(agentType, { readJson: deps.readJson, loginPath: deps.loginPath });
+    } catch (error) {
+      errLog(`[Chorus] ${error.message}`);
+      return 1;
+    }
+  }
+
   // `-d` / --detach: complete any interactive preflight in THIS foreground process
   // (which holds the TTY), then spawn the daemon detached and return. The detached
   // child re-enters runDaemon with the DETACHED_ENV marker set, so it skips the
@@ -889,7 +911,7 @@ export async function runDaemon(flags = {}, deps = {}) {
   // credential preflight (interactive credential completion is a single-agent
   // affordance). Each agent authenticates on its own key; a failure is isolated
   // (logged + that agent skipped) so the rest still serve.
-  if (hasConfiguredAgents({ readJson: deps.readJson, loginPath: deps.loginPath })) {
+  if (multiAgent) {
     const buildMulti = deps.buildMulti ?? buildMultiAgentDaemon;
     let agentConfigs;
     try {
@@ -950,6 +972,7 @@ export async function runDaemon(flags = {}, deps = {}) {
     const multiDaemon = buildMulti(okConfigs, {
       logger: { info: log, warn: errLog, error: errLog },
       verbose,
+      env,
       fetchImpl: deps.fetchImpl,
       killer: deps.killer,
       sseListener: deps.sseListener,
@@ -1000,16 +1023,17 @@ export async function runDaemon(flags = {}, deps = {}) {
   // Detect the SELECTED backend's executable (non-fatal): the daemon still
   // subscribes when it's missing; a wake surfaces the error visibly when one
   // arrives. The resolved path (or absence) is shown in the banner below. Each
-  // backend probes its own binary, including dsh-jsonrpc-agent for dsh, so the
+  // backend probes its own binary, including the `dsh` CLI for dsh, so the
   // startup banner and warning report the selected runtime rather than Claude.
+  const discoveryEnv = overlayAgentEnv(env, cliConfig.env);
   const cliPath =
     agentType === "codex"
-      ? findCodex()
+      ? findCodex({ env: discoveryEnv })
       : agentType === "kiro"
-        ? findKiro()
+        ? findKiro({ env: discoveryEnv })
         : agentType === "dsh"
-          ? findDsh()
-          : findClaude();
+          ? findDsh({ env: discoveryEnv })
+          : findClaude({ env: discoveryEnv });
 
   // The daemon.json the layered config readers (credentials, sigint timeout, cwds)
   // consult. Surfacing its absolute path + presence in the banner makes it obvious
@@ -1068,6 +1092,8 @@ export async function runDaemon(flags = {}, deps = {}) {
     logger: { info: log, warn: errLog, error: errLog },
     permissionMode,
     agentType,
+    cliConfig,
+    env,
     verbose,
     sigintTimeoutMs,
     cwds,
@@ -1272,8 +1298,7 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
     });
     if (
       installAgent.agent === "dsh" &&
-      !String(env.CHORUS_DSH_CONFIG ?? "").trim() &&
-      !String(env.DSH_CORDIS_CONFIG ?? "").trim()
+      !String(env.CHORUS_DSH_HOME ?? "").trim()
     ) {
       try {
         await (pfDeps?.prepareManagedDshConfig ?? prepareManagedDshConfig)({