@zgeoff/atc 2.11.0 → 2.13.0

package/src/agents/codex-adapter.ts

@@ -14,9 +14,13 @@ import type {
   AgentProfile,
   NameUpdate,
   ResumeCheck,
+  SpawnOptionSpecs,
   SpawnOptions,
   SpawnPlan,
 } from './agent-adapter';
+import { buildArgsWithoutFlags } from './build-args-without-flags';
+import { findFlagValue } from './find-flag-value';
+import { planPastedLineInput } from './plan-pasted-line-input';
 import { resolveAgentHome } from './resolve-agent-home';
 import { truncateDetail } from './truncate-detail';
 
@@ -33,6 +37,9 @@ const CODEX_HOOK_PAYLOAD_SCHEMA = z.object({
 
 type CodexHookPayload = z.infer<typeof CODEX_HOOK_PAYLOAD_SCHEMA>;
 
+// The spellings of the Codex CLI's model flag.
+const CODEX_MODEL_FLAGS = ['-m', '--model'];
+
 /**
  * The Codex CLI adapter: spawn arguments, hook payload mapping, resume
  * semantics, and session_index.jsonl name-pulling. Hooks are a user-installed
@@ -52,18 +59,33 @@ export class CodexAdapter implements AgentAdapter {
 
   readonly takesMessages = false;
 
+  // Codex's TUI keeps a newline that arrives inside a burst of input, so a
+  // line is pasted and then submitted.
+  readonly planLineInput = planPastedLineInput;
+
   private readonly config: Config;
 
   constructor(config: Config) {
     this.config = config;
-    this.profile = { label: 'Codex', kind: 'codex', bin: config.codexBin, models: null };
+
+    this.profile = {
+      label: 'Codex',
+      kind: 'codex',
+      bin: config.codexBin,
+      models: null,
+      spawnOptions: buildCodexSpawnOptions(config.codexArgs),
+    };
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
     return {
       bin: this.config.codexBin,
       args: [
-        ...this.config.codexArgs,
+        // A model override replaces any model flag the configured arguments
+        // carry, and travels as its own argument.
+        ...(opts.model === undefined
+          ? this.config.codexArgs
+          : [...buildArgsWithoutFlags(this.config.codexArgs, CODEX_MODEL_FLAGS), '-m', opts.model]),
 
         // Bare resume opens Codex's own session picker; an id resumes that
         // session directly. Both accept a prompt afterwards.
@@ -193,3 +215,27 @@ export class CodexAdapter implements AgentAdapter {
     return `cd ${toShellArg(cwd)} && ${resume}`;
   }
 }
+
+// What a Codex spawn can override. Codex documents its reasoning effort as
+// whatever the selected model advertises, with no closed list of levels, so
+// atc takes no effort for it.
+function buildCodexSpawnOptions(codexArgs: readonly string[]): SpawnOptionSpecs {
+  return {
+    model: {
+      supported: true,
+      values: null,
+      examples: [],
+      default: findFlagValue(codexArgs, CODEX_MODEL_FLAGS),
+      backendEffect: 'applied',
+      note: 'A model name, passed as -m.',
+    },
+    effort: {
+      supported: false,
+      values: null,
+      examples: [],
+      default: null,
+      backendEffect: null,
+      note: 'Codex documents its reasoning effort levels as depending on the model, with no closed list, so atc does not pass one.',
+    },
+  };
+}

package/src/agents/find-claude-permission-mode.ts

@@ -0,0 +1,24 @@
+import { isRecord } from '../shared/report';
+import { findFlagValue } from './find-flag-value';
+
+/**
+ * The permission mode a Claude CLI agent's configuration sets: an explicit
+ * `--permission-mode` in its arguments, else the `permissions.defaultMode`
+ * its settings hold, or null when neither sets one. The argument wins, as it
+ * does for the CLI itself.
+ */
+export function findClaudePermissionMode(
+  args: readonly string[],
+  settings: Readonly<Record<string, unknown>> | undefined,
+): string | null {
+  const flag = findFlagValue(args, ['--permission-mode']);
+
+  if (flag !== null) {
+    return flag;
+  }
+
+  const permissions = settings?.['permissions'];
+  const defaultMode = isRecord(permissions) ? permissions['defaultMode'] : undefined;
+
+  return typeof defaultMode === 'string' && defaultMode !== '' ? defaultMode : null;
+}

package/src/agents/find-flag-value.ts

@@ -0,0 +1,27 @@
+/**
+ * The value a CLI flag takes in an argument list, written either as the flag
+ * followed by its value or as `--flag=value`. The last occurrence wins, as it
+ * does for the CLIs atc runs; null when the list never sets the flag.
+ */
+export function findFlagValue(args: readonly string[], names: readonly string[]): string | null {
+  let value: string | null = null;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index] ?? '';
+    const next = args[index + 1];
+
+    if (names.includes(arg) && next !== undefined) {
+      value = next;
+      index += 1;
+      continue;
+    }
+
+    const inline = names.find((name) => name.startsWith('--') && arg.startsWith(`${name}=`));
+
+    if (inline !== undefined) {
+      value = arg.slice(inline.length + 1);
+    }
+  }
+
+  return value;
+}

package/src/agents/gateway-adapter.ts

@@ -11,11 +11,20 @@ import type {
   HeadlessRunner,
   NameUpdate,
   ResumeCheck,
+  SpawnOptionSpecs,
   SpawnOptions,
   SpawnPlan,
 } from './agent-adapter';
+import { buildClaudeOverrideArgs } from './build-claude-override-args';
+import { buildRestoreModeArgs } from './build-restore-mode-args';
 import { ClaudeAdapter } from './claude-adapter';
+import { CLAUDE_EFFORT_LEVELS } from './claude-effort-levels';
+import { findFlagValue } from './find-flag-value';
+import { makeClaudeHeadlessRunner } from './make-claude-headless-runner';
+import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
 import { parseClaudeTranscriptLine } from './parse-claude-transcript-line';
+import { planTypedLineInput } from './plan-typed-line-input';
+import { resolveClaudePermissionMode } from './resolve-claude-permission-mode';
 import { writeATCBridge } from './write-atc-bridge';
 import { writeHookSettings } from './write-hook-settings';
 
@@ -39,6 +48,9 @@ export class GatewayAdapter implements AgentAdapter {
   // The gateway runs the Claude CLI, which writes the same transcript.
   readonly parseTranscriptLine = parseClaudeTranscriptLine;
 
+  // The gateway runs the Claude CLI, whose TUI takes a line the same way.
+  readonly planLineInput = planTypedLineInput;
+
   readonly takesMessages = true;
 
   readonly profile: AgentProfile;
@@ -58,37 +70,44 @@ export class GatewayAdapter implements AgentAdapter {
   constructor(
     gateway: GatewayConfig,
     config: Config,
-    headlessRunner: HeadlessRunner | null = null,
+    headlessRun: ClaudeHeadlessRun | null = null,
     bridgeTarget?: string,
   ) {
     this.bridgeTarget = bridgeTarget;
     this.gateway = gateway;
     this.id = gateway.id;
 
+    const models = pickModels(gateway.env);
+
     this.profile = {
       label: gateway.label,
       kind: 'gateway',
       bin: gateway.bin,
-      models: pickModels(gateway.env),
+      models,
+      spawnOptions: buildGatewaySpawnOptions(gateway.args, models),
     };
 
     this.claude = new ClaudeAdapter(config);
 
     this.headlessRunner =
-      headlessRunner === null
+      headlessRun === null
         ? null
-        : (opts, hooks) =>
-            headlessRunner(
-              { ...opts, settings: this.writeSettings(), pluginDir: this.writeBridge() },
-              hooks,
-            );
+        : makeClaudeHeadlessRunner(headlessRun, {
+            claudeBin: gateway.bin,
+            permissionMode: resolveClaudePermissionMode(gateway.args, gateway.settings),
+            pluginDir: () => this.writeBridge(),
+            settings: () => this.writeSettings(),
+          });
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
     return {
       bin: this.gateway.bin,
       args: [
-        ...this.gateway.args,
+        ...buildClaudeOverrideArgs(this.gateway.args, opts),
+        ...(opts.resume === false
+          ? []
+          : buildRestoreModeArgs(this.gateway.args, this.gateway.settings)),
         '--settings',
         this.writeSettings(),
         '--plugin-dir',
@@ -100,6 +119,12 @@ export class GatewayAdapter implements AgentAdapter {
     };
   }
 
+  // The credential helper runs on the daemon's machine, so a gateway
+  // session never runs on a remote host.
+  planGuestSpawn(): null {
+    return null;
+  }
+
   normalizeHook(e: HookEvent): AdapterEvent {
     return this.claude.normalizeHook(e);
   }
@@ -112,14 +137,23 @@ export class GatewayAdapter implements AgentAdapter {
     return this.claude.canResume(session);
   }
 
-  // Shell command that re-opens this session outside atc. It names the
-  // generated settings file, because without it the CLI would resume the
-  // session against the default backend.
+  // Shell command that re-opens this session outside atc. It carries the
+  // gateway's configured arguments and its configured permission mode as an
+  // explicit flag, so that mode overrides the one the CLI would restore, and
+  // the generated settings file, because
+  // without it the CLI would resume the session against the default backend.
   buildResumeCommand(cwd: string, agentSessionID: AgentSessionID | undefined): string | null {
+    const args = [
+      ...this.gateway.args,
+      ...buildRestoreModeArgs(this.gateway.args, this.gateway.settings),
+    ]
+      .map((arg) => ` ${toShellArg(arg)}`)
+      .join('');
+
     const settings = toShellArg(this.writeSettings());
     const resume = agentSessionID === undefined ? '' : ` ${agentSessionID}`;
 
-    return `cd ${toShellArg(cwd)} && ${this.gateway.bin} --settings ${settings} --resume${resume}`;
+    return `cd ${toShellArg(cwd)} && ${this.gateway.bin}${args} --settings ${settings} --resume${resume}`;
   }
 
   private writeSettings(): string {
@@ -162,3 +196,39 @@ function pickModels(
 
   return Object.keys(models).length === 0 ? null : models;
 }
+
+// The Claude tiers a gateway's env can map to a provider model.
+const GATEWAY_TIERS = ['opus', 'sonnet', 'haiku'];
+
+// What a gateway spawn can override. The model examples are the tier aliases
+// the gateway's env maps, each with the provider model it reaches. Effort
+// goes to the CLI unchanged, and whether the provider acts on it is unknown.
+function buildGatewaySpawnOptions(
+  args: readonly string[],
+  models: Readonly<Record<string, string>> | null,
+): SpawnOptionSpecs {
+  const examples = GATEWAY_TIERS.flatMap((tier) => {
+    const mapped = models?.[tier];
+
+    return mapped === undefined ? [] : [{ value: tier, resolvesTo: mapped }];
+  });
+
+  return {
+    model: {
+      supported: true,
+      values: null,
+      examples,
+      default: findFlagValue(args, ['--model']) ?? models?.['default'] ?? null,
+      backendEffect: 'applied',
+      note: "A tier alias the gateway's env maps, or a model name the provider accepts, passed as --model.",
+    },
+    effort: {
+      supported: true,
+      values: CLAUDE_EFFORT_LEVELS,
+      examples: [],
+      default: findFlagValue(args, ['--effort']),
+      backendEffect: 'unverified',
+      note: "Passed as --effort; the gateway's provider may ignore it.",
+    },
+  };
+}

package/src/agents/grok-adapter.ts

@@ -15,10 +15,12 @@ import type {
   AgentProfile,
   NameUpdate,
   ResumeCheck,
+  SpawnOptionSpec,
   SpawnOptions,
   SpawnPlan,
 } from './agent-adapter';
 import { normalizeHookEventName } from './normalize-hook-event';
+import { planPastedLineInput } from './plan-pasted-line-input';
 import { resolveAgentHome } from './resolve-agent-home';
 import { truncateDetail } from './truncate-detail';
 
@@ -48,6 +50,16 @@ const GROK_HOOK_PAYLOAD_SCHEMA = z.object({
 
 type GrokHookPayload = z.infer<typeof GROK_HOOK_PAYLOAD_SCHEMA>;
 
+// atc passes Grok neither a model nor an effort; the CLI's own config picks both.
+const GROK_UNSUPPORTED_OPTION: SpawnOptionSpec = {
+  supported: false,
+  values: null,
+  examples: [],
+  default: null,
+  backendEffect: null,
+  note: 'atc does not pass this option to Grok.',
+};
+
 /**
  * The Grok Build adapter: spawn arguments, hook payload mapping,
  * resume semantics, and summary.json name-pulling.
@@ -65,13 +77,24 @@ export class GrokAdapter implements AgentAdapter {
 
   readonly takesMessages = false;
 
+  // Grok's TUI keeps a newline that arrives inside a burst of input, so a
+  // line is pasted and then submitted.
+  readonly planLineInput = planPastedLineInput;
+
   private readonly config: Config;
 
   private readonly hookState = new Map<SessionID, GrokSessionHookState>();
 
   constructor(config: Config) {
     this.config = config;
-    this.profile = { label: 'Grok', kind: 'grok', bin: config.grokBin, models: null };
+
+    this.profile = {
+      label: 'Grok',
+      kind: 'grok',
+      bin: config.grokBin,
+      models: null,
+      spawnOptions: { model: GROK_UNSUPPORTED_OPTION, effort: GROK_UNSUPPORTED_OPTION },
+    };
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {

package/src/agents/make-claude-headless-runner.ts

@@ -0,0 +1,46 @@
+import type { HeadlessRunEvents, HeadlessRunner } from './agent-adapter';
+import type { ClaudeHeadlessRunRequest } from './build-claude-query-options';
+
+/**
+ * Runs one headless turn through the Claude CLI; the daemon command supplies
+ * the Agent SDK implementation, and tests supply a recorder.
+ */
+export type ClaudeHeadlessRun = (
+  opts: ClaudeHeadlessRunRequest,
+  hooks: HeadlessRunEvents,
+) => { readonly stop: () => void };
+
+/**
+ * Where and how a Claude CLI headless turn runs: the binary, the permission
+ * mode its adapter resolved, the mod folder, and, for a gateway, the
+ * settings file that carries its backend. The folder and file are written
+ * on first use.
+ */
+interface ClaudeHeadlessTarget {
+  readonly claudeBin: string;
+  readonly permissionMode: string;
+  readonly pluginDir: () => string;
+  readonly settings?: () => string;
+}
+
+/**
+ * Turns the Claude CLI's headless run into the neutral runner the daemon
+ * calls. Every headless turn runs under the permission mode its adapter
+ * resolved for the agent's sessions.
+ */
+export function makeClaudeHeadlessRunner(
+  run: ClaudeHeadlessRun,
+  target: ClaudeHeadlessTarget,
+): HeadlessRunner {
+  return (opts, hooks) =>
+    run(
+      {
+        ...opts,
+        claudeBin: target.claudeBin,
+        permissionMode: target.permissionMode,
+        pluginDir: target.pluginDir(),
+        ...(target.settings === undefined ? {} : { settings: target.settings() }),
+      },
+      hooks,
+    );
+}

package/src/agents/plan-pasted-line-input.ts

@@ -0,0 +1,22 @@
+import type { TerminalInputModes } from './agent-adapter';
+
+const PASTE_START = '\u001B[200~';
+const PASTE_END = '\u001B[201~';
+
+/**
+ * Pastes a line into a TUI that tells a paste from typing, then submits it
+ * with a carriage return as its own write. Such a TUI takes a newline inside
+ * a burst of input as part of the text, so a line typed with its newline
+ * stays unsent in the composer. Between bracketed paste markers the whole
+ * text is one paste event, newlines included, and the carriage return after
+ * the closing marker is a separate Enter key event however the two writes
+ * arrive. Paste markers inside the text are dropped, so the text can neither
+ * end the paste early nor start one of its own. A TUI that has not turned
+ * bracketed paste on gets the text unmarked, and may still read both writes
+ * as one burst.
+ */
+export function planPastedLineInput(text: string, modes: TerminalInputModes): readonly string[] {
+  const unmarked = text.replaceAll(PASTE_START, '').replaceAll(PASTE_END, '');
+
+  return modes.bracketedPaste ? [`${PASTE_START}${unmarked}${PASTE_END}`, '\r'] : [unmarked, '\r'];
+}

package/src/agents/plan-typed-line-input.ts

@@ -0,0 +1,8 @@
+/**
+ * Types a line the way a terminal user does: the text and a newline in one
+ * write. A TUI that reads input a line at a time takes the newline as the
+ * submit key.
+ */
+export function planTypedLineInput(text: string): readonly string[] {
+  return [`${text}\n`];
+}

package/src/agents/resolve-claude-permission-mode.ts

@@ -0,0 +1,13 @@
+import { findClaudePermissionMode } from './find-claude-permission-mode';
+
+/**
+ * The permission mode a Claude CLI agent's headless turns run in: the mode
+ * its configuration sets, else auto, since no human is at a terminal to
+ * answer a prompt.
+ */
+export function resolveClaudePermissionMode(
+  args: readonly string[],
+  settings: Readonly<Record<string, unknown>> | undefined,
+): string {
+  return findClaudePermissionMode(args, settings) ?? 'auto';
+}

package/src/{daemon/start-headless-run.ts → agents/start-claude-headless-run.ts}

@@ -1,31 +1,8 @@
-import type { AgentSessionID } from '../shared/agent-session-id';
-import { socketPath } from '../shared/config';
+import { truncateSummary } from '../daemon/truncate-summary';
 import { isCompiledBinary } from '../shared/is-compiled-binary';
 import { isRecord } from '../shared/report';
-import type { SessionID } from '../shared/session-id';
-import { buildHeadlessEnv } from './build-headless-env';
-import { resolveHeadlessExecutable } from './resolve-headless-executable';
-import { truncateSummary } from './truncate-summary';
-
-const PERMISSION_MODES = [
-  'default',
-  'acceptEdits',
-  'bypassPermissions',
-  'plan',
-  'auto',
-  'dontAsk',
-] as const;
-
-interface HeadlessRunOptions {
-  readonly claudeBin: string;
-  readonly cwd: string;
-  readonly prompt: string;
-  readonly resume?: AgentSessionID;
-  readonly permissionMode?: string;
-  readonly settings?: string;
-  readonly sessionID?: SessionID;
-  readonly pluginDir?: string;
-}
+import { buildClaudeQueryOptions } from './build-claude-query-options';
+import type { ClaudeHeadlessRunRequest } from './build-claude-query-options';
 
 interface HeadlessRunHooks {
   readonly onOutput: (text: string) => void;
@@ -43,15 +20,14 @@ interface HeadlessRunHandle {
  * done (with the turn's whole result) or needs_you (errors, turn limits,
  * anything a human must look at).
  */
-export function startHeadlessRun(
-  opts: HeadlessRunOptions,
+export function startClaudeHeadlessRun(
+  opts: ClaudeHeadlessRunRequest,
   hooks: HeadlessRunHooks,
 ): HeadlessRunHandle {
   const controller = new AbortController();
 
   void (async () => {
     try {
-      const mode = PERMISSION_MODES.find((m) => m === opts.permissionMode);
       let stderrTail = '';
 
       // The SDK is the heaviest module in the daemon's graph, and only a
@@ -62,23 +38,11 @@ export function startHeadlessRun(
       const stream = sdk.query({
         prompt: opts.prompt,
         options: {
-          cwd: opts.cwd,
-          env: buildHeadlessEnv({
-            socketPath,
-            ...(opts.pluginDir === undefined ? {} : { pluginDir: opts.pluginDir }),
-            ...(opts.sessionID === undefined ? {} : { sessionID: opts.sessionID }),
-          }),
+          ...buildClaudeQueryOptions(opts, isCompiledBinary()),
           abortController: controller,
           stderr: (data: string) => {
             stderrTail = `${stderrTail}${data}`.slice(-2000);
           },
-          ...(opts.resume === undefined ? {} : { resume: opts.resume }),
-          ...(mode === undefined ? {} : { permissionMode: mode }),
-
-          // The same generated file the terminal spawn passes, so the turn
-          // runs against the session's own backend and instrumentation.
-          ...(opts.settings === undefined ? {} : { extraArgs: { settings: opts.settings } }),
-          ...resolveHeadlessExecutable(opts.claudeBin, isCompiledBinary()),
         },
       });
 

package/src/agents/write-atc-bridge.ts

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { stateDir } from '../shared/config';
-import { ATC_BRIDGE_FILES } from './atc-bridge-files';
+import { buildATCBridgeFiles } from './build-atc-bridge-files';
 import { buildCLIArgv } from './build-cli-argv';
 
 /**
@@ -13,7 +13,7 @@ import { buildCLIArgv } from './build-cli-argv';
  * there.
  */
 export function writeATCBridge(dir: string = join(stateDir, 'atc-bridge')): string {
-  const files = { ...ATC_BRIDGE_FILES, 'hooks/atc-cli.ts': renderATCCLIModule(buildCLIArgv()) };
+  const files = buildATCBridgeFiles(buildCLIArgv());
 
   for (const [path, content] of Object.entries(files)) {
     const file = join(dir, path);
@@ -29,10 +29,6 @@ export function writeATCBridge(dir: string = join(stateDir, 'atc-bridge')): stri
   return dir;
 }
 
-function renderATCCLIModule(argv: readonly string[]): string {
-  return `export const ATC_CLI: readonly string[] = ${JSON.stringify(argv)};\n`;
-}
-
 function tryReadFileText(file: string): string | null {
   try {
     return readFileSync(file, 'utf8');

package/src/cli.ts

@@ -159,12 +159,28 @@ const main = defineCommand({
           const grok = await import('./agents/grok-adapter');
           const codex = await import('./agents/codex-adapter');
           const gateway = await import('./agents/gateway-adapter');
-          const headless = await import('./daemon/start-headless-run');
+          const headless = await import('./agents/start-claude-headless-run');
+          const targets = await import('./daemon/build-execution-targets');
 
           // Test harnesses shrink the outbound queue to force overflow
           // deterministically; unset means the production default.
           const queueBytes = Number(process.env['ATC_QUEUE_BYTES']);
           const cfg = config.loadConfig();
+          const built = targets.buildExecutionTargets(cfg.targets);
+          const targetErrors = [...cfg.targetErrors, ...built.errors];
+
+          for (const error of targetErrors) {
+            const line =
+              error.scope === 'config'
+                ? `${error.path} cannot be used (${error.problem}: ${error.detail}); every spawn is refused, local ones included, until it is fixed`
+                : error.problem;
+
+            console.error(`atc daemon: config: ${line}`);
+          }
+
+          for (const problem of cfg.principalErrors) {
+            console.error(`atc daemon: config: ${problem}`);
+          }
 
           // Cap on how long a fleet restore waits for one revived session to
           // report it has booted before moving to the next. Tests pin it to
@@ -178,18 +194,12 @@ const main = defineCommand({
           // to it is refused. Tests pin it to 0 to reach the refusal at once.
           const graceOverride = Number(process.env['ATC_TAP_GRACE_MS']);
 
-          const claudeAdapter = new claude.ClaudeAdapter(cfg, (runOpts, hooks) =>
-            headless.startHeadlessRun({ ...runOpts, claudeBin: cfg.claudeBin }, hooks),
-          );
-
+          const claudeAdapter = new claude.ClaudeAdapter(cfg, headless.startClaudeHeadlessRun);
           const grokAdapter = new grok.GrokAdapter(cfg);
           const codexAdapter = new codex.CodexAdapter(cfg);
 
           const gatewayAdapters = cfg.gateways.map(
-            (entry) =>
-              new gateway.GatewayAdapter(entry, cfg, (runOpts, hooks) =>
-                headless.startHeadlessRun({ ...runOpts, claudeBin: entry.bin }, hooks),
-              ),
+            (entry) => new gateway.GatewayAdapter(entry, cfg, headless.startClaudeHeadlessRun),
           );
 
           let handle: Awaited<ReturnType<typeof daemon.startDaemon>>;
@@ -206,6 +216,10 @@ const main = defineCommand({
               legacyFleetPath: config.legacyFleetFile,
               pidPath: config.daemonPidFile,
               hooks: cfg.hooks,
+              targets: built.targets,
+              defaultTarget: cfg.defaultTarget,
+              targetErrors,
+              principals: cfg.principals,
               restoreBootTimeoutMs,
               ...(Number.isFinite(graceOverride) && graceOverride >= 0
                 ? { tapGraceMs: graceOverride }

package/src/client/daemon-client.ts

@@ -65,9 +65,12 @@ export class DaemonClient {
     return this.sendRequest('daemon.hello', { client: build, auth: { scheme: 'none' } });
   }
 
+  // A request with a principal acts as that principal, within what the
+  // connection may reach.
   sendRequest(
     m: string,
     p?: Readonly<Record<string, unknown>>,
+    as?: string,
   ): Promise<Readonly<Record<string, unknown>>> {
     if (this.closedReason !== null) {
       return Promise.reject(new DaemonError('internal', this.closedReason));
@@ -77,7 +80,16 @@ export class DaemonClient {
     const resolvers = Promise.withResolvers<Readonly<Record<string, unknown>>>();
 
     this.pending.set(id, { resolve: resolvers.resolve, reject: resolvers.reject });
-    this.queue?.send(encodeMessage({ v: PROTOCOL_V, id, m, ...(p === undefined ? {} : { p }) }));
+
+    this.queue?.send(
+      encodeMessage({
+        v: PROTOCOL_V,
+        id,
+        m,
+        ...(p === undefined ? {} : { p }),
+        ...(as === undefined ? {} : { as }),
+      }),
+    );
 
     return resolvers.promise;
   }
@@ -138,7 +150,7 @@ export class DaemonClient {
     if (msg.err === undefined) {
       waiter.resolve(msg.ok ?? {});
     } else {
-      waiter.reject(new DaemonError(msg.err.code, msg.err.msg));
+      waiter.reject(new DaemonError(msg.err.code, msg.err.msg, msg.err.data));
     }
   }