@zgeoff/atc 2.11.0 → 2.13.0

package/src/client/index.ts

@@ -2,6 +2,7 @@ import { match } from 'ts-pattern';
 import { createActor } from 'xstate';
 import type { AgentID } from '../agents/agent-adapter';
 import { countSessionStates, sortGroupedSessionViews, sortSessionViews } from '../daemon/sessions';
+import { DaemonError } from '../protocol/daemon-error';
 import type { EventMsg } from '../protocol/protocol';
 import { loadConfig } from '../shared/config';
 import { makeSingleFlight } from '../shared/make-single-flight';
@@ -20,6 +21,10 @@ import { ansi, cols, drawHelp, drawHome, drawOverlay, drawPicker, drawStatusBar,
 let overlaySelected = 0;
 let confirmKill = false;
 
+// The session whose forget waits on a confirm because it destroys the
+// session's host, or null.
+let confirmDestroyID: string | null = null;
+
 // The client's mirror of the daemon's fleet, kept fresh by events.
 let fleet: MirrorSession[] = [];
 
@@ -95,6 +100,36 @@ async function sendQuiet(m: string, p?: Readonly<Record<string, unknown>>) {
   } catch {}
 }
 
+// A kill the daemon refuses because forgetting the session destroys its
+// host asks once more before the forget.
+async function sendKill(sessionID: string) {
+  try {
+    await client.sendRequest('session.kill', { session: sessionID });
+  } catch (error) {
+    if (error instanceof DaemonError && error.code === 'confirmation_required') {
+      confirmDestroyID = sessionID;
+
+      if (service.getSnapshot().value === 'overlay') {
+        renderOverlay();
+      }
+    }
+  }
+}
+
+// Takes the confirm token the daemon offers and hands it straight back:
+// the operator already confirmed in the overlay.
+async function sendForget(sessionID: string) {
+  try {
+    const offered = await client.sendRequest('session.forget', { session: sessionID });
+
+    const confirmToken = offered['confirmToken'];
+
+    if (typeof confirmToken === 'string') {
+      await client.sendRequest('session.forget', { session: sessionID, confirmToken });
+    }
+  } catch {}
+}
+
 async function attach(sessionID: string) {
   service.send({ type: 'ATTACH', sessionID });
 
@@ -215,6 +250,7 @@ function renderOverlay() {
     agentMarks,
     selected: overlaySelected,
     confirmKill,
+    confirmDestroy: confirmDestroyID !== null,
     filter: overlayFilter,
     stale: daemonStale && !daemonRestarting,
     grouped: overlayGrouped,
@@ -225,6 +261,7 @@ function renderOverlay() {
 
 function openOverlay() {
   confirmKill = false;
+  confirmDestroyID = null;
   overlayFilter = null;
 
   const focusedIndex = pickOverlaySessions().findIndex((s) => s.id === focusedID);
@@ -510,7 +547,7 @@ function applyOverlayKey(buf: Buffer) {
 
   if (confirmKill) {
     if (buf[0] === 0x79 /* y */ && sel !== undefined) {
-      void sendQuiet('session.kill', { session: sel.id });
+      void sendKill(sel.id);
     }
 
     confirmKill = false;
@@ -520,6 +557,18 @@ function applyOverlayKey(buf: Buffer) {
     return;
   }
 
+  if (confirmDestroyID !== null) {
+    if (buf[0] === 0x79 /* y */) {
+      void sendForget(confirmDestroyID);
+    }
+
+    confirmDestroyID = null;
+
+    renderOverlay();
+
+    return;
+  }
+
   if (applyOverlayFilterKey(buf)) {
     return;
   }

package/src/client/spawn-picker.ts

@@ -1,5 +1,6 @@
 import { homedir } from 'node:os';
 import type { AgentID } from '../agents/agent-adapter';
+import { DaemonError } from '../protocol/daemon-error';
 import { loadConfig } from '../shared/config';
 import { collectAgentPicks } from './collect-agent-picks';
 import type { AgentPick } from './collect-agent-picks';
@@ -32,7 +33,8 @@ export interface SpawnPickerDeps<TMirror> {
 /**
  * The modal flow behind n and r: agent, then directory, then name, then an
  * optional first prompt. Every path out of it either attaches the new
- * session or returns the client to the screen it came from.
+ * session or returns the client to the screen it came from. A spawn the
+ * daemon refuses is no path out: the flow stays open and shows why.
  */
 export class SpawnPicker<TMirror extends { readonly id: string }> {
   private readonly deps: SpawnPickerDeps<TMirror>;
@@ -60,6 +62,10 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
   private agent: AgentID = 'claude';
 
+  // The daemon's refusal of the last spawn, shown in place of the hint until
+  // the next key.
+  private refusal: string | null = null;
+
   constructor(deps: SpawnPickerDeps<TMirror>) {
     this.deps = deps;
   }
@@ -82,12 +88,15 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
     this.agent = this.picks[this.selected]?.agent ?? this.deps.getLastUsedAgent();
     this.step = 'agent';
+    this.refusal = null;
 
     process.stdout.write(ansi.clear);
     this.render();
   }
 
   applyKey(buf: Buffer) {
+    this.refusal = null;
+
     const edit = planTextEdit(buf, this.input, {
       isLeaderKey: this.deps.isLeaderKey,
       moves: this.step === 'agent' || this.step === 'dir',
@@ -168,7 +177,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
         selected: -1,
         input: this.input,
         placeholder: formatDirName(this.dir),
-        hint: `session name for ${formatDir(this.dir)} · ⏎ accept · esc back`,
+        hint: this.refusal ?? `session name for ${formatDir(this.dir)} · ⏎ accept · esc back`,
       });
     } else {
       drawPicker({
@@ -177,7 +186,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
         selected: -1,
         input: this.input,
         placeholder: 'optional — ⏎ to start interactive',
-        hint: 'first message for the session · ⏎ spawn · esc back',
+        hint: this.refusal ?? 'first message for the session · ⏎ spawn · esc back',
       });
     }
 
@@ -320,7 +329,21 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
         return;
       }
-    } catch {}
+    } catch (error) {
+      // A refused spawn keeps the picker on the step that sent it, with the
+      // entered text back in the input, so the user can fix the cause and
+      // retry or back out.
+      const reason =
+        error instanceof DaemonError ? `${error.code}: ${error.message}` : String(error);
+
+      this.refusal = `${reason} · ⏎ retry · esc back`;
+      this.input = this.resume ? this.name : prompt;
+
+      process.stdout.write(ansi.clear);
+      this.render();
+
+      return;
+    }
 
     this.deps.toBase();
   }

package/src/client/ui.ts

@@ -196,6 +196,10 @@ export interface OverlayView {
   agentMarks: Readonly<Record<AgentID, string>>;
   selected: number;
   confirmKill: boolean;
+
+  // A kill the daemon refused because forgetting the session destroys its
+  // host waits on a second confirm.
+  confirmDestroy: boolean;
   filter: string | null;
   stale: boolean;
   grouped: boolean;
@@ -271,6 +275,10 @@ export function drawOverlay(view: OverlayView) {
     hint = formatKillConfirm(selected, view.sessions);
   }
 
+  if (view.confirmDestroy) {
+    hint = 'forget destroys its host and everything on it? y / n';
+  }
+
   rowsList.push(dimRow(width, hint), boxBottom(width));
 
   drawBox(rowsList);

package/src/daemon/build-agent-list.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter } from '../agents/agent-adapter';
+import type { AgentAdapter, SpawnOptionSpec } from '../agents/agent-adapter';
 
 interface AgentCapabilities {
   // Only an installed agent can start a session.
@@ -21,6 +21,19 @@ export interface AgentEntry {
   readonly installed: boolean;
   readonly capabilities: AgentCapabilities;
   readonly models: Readonly<Record<string, string>> | null;
+  readonly spawnOptions: SpawnOptionEntries;
+}
+
+// A spawn option as `agents.list` shows it: the agent's own spec, plus
+// whether a spawn on this host can pass it now. Only an installed agent's
+// supported option is available.
+export interface SpawnOptionEntry extends SpawnOptionSpec {
+  readonly available: boolean;
+}
+
+interface SpawnOptionEntries {
+  readonly model: SpawnOptionEntry;
+  readonly effort: SpawnOptionEntry;
 }
 
 /**
@@ -53,6 +66,29 @@ export function buildAgentList(
         input: true,
       },
       models: profile?.models ?? null,
+      spawnOptions: {
+        model: buildSpawnOptionEntry(profile?.spawnOptions.model, installed),
+        effort: buildSpawnOptionEntry(profile?.spawnOptions.effort, installed),
+      },
     };
   });
 }
+
+// A stand-in adapter declares no spawn options, so it takes none.
+const NO_SPAWN_OPTION: SpawnOptionSpec = {
+  supported: false,
+  values: null,
+  examples: [],
+  default: null,
+  backendEffect: null,
+  note: null,
+};
+
+function buildSpawnOptionEntry(
+  spec: SpawnOptionSpec | undefined,
+  installed: boolean,
+): SpawnOptionEntry {
+  const resolved = spec ?? NO_SPAWN_OPTION;
+
+  return { ...resolved, available: installed && resolved.supported };
+}

package/src/daemon/build-config-revision.ts

@@ -0,0 +1,27 @@
+import { createHash } from 'node:crypto';
+import type { TargetConfigError } from '../shared/collect-targets';
+import type { ExecutionTarget } from './build-execution-targets';
+
+/**
+ * A short digest of the target config a daemon runs with: each target's id
+ * and identity, the default target, and the config errors. Two daemons with
+ * the same targets return the same revision, and any change to them
+ * changes it.
+ */
+export function buildConfigRevision(
+  targets: readonly ExecutionTarget[],
+  defaultTarget: string | null,
+  errors: readonly TargetConfigError[],
+): string {
+  const canonical = JSON.stringify({
+    targets: targets.map((target) => [target.id, target.identity]),
+    defaultTarget,
+    errors: errors.map((error) =>
+      error.scope === 'config'
+        ? [error.scope, error.path, error.problem, error.detail]
+        : [error.scope, error.target ?? null, error.problem],
+    ),
+  });
+
+  return createHash('sha256').update(canonical).digest('hex').slice(0, 16);
+}

package/src/daemon/build-execution-targets.ts

@@ -0,0 +1,73 @@
+import type { TargetConfig, TargetConfigError } from '../shared/collect-targets';
+import { buildImpProvider } from './build-imp-provider';
+import { buildTargetIdentity } from './build-target-identity';
+import type { ExecutionProvider } from './execution-provider';
+import { LocalPTYProvider } from './local-pty-provider';
+
+/**
+ * A configured place sessions run, with the provider that serves it. The
+ * provider is null when this daemon has no provider of the configured kind:
+ * the target still lists, and a spawn to it fails rather than running
+ * anywhere else.
+ */
+export interface ExecutionTarget {
+  readonly id: string;
+  readonly kind: string;
+  readonly options: Readonly<Record<string, unknown>>;
+
+  // The identity a session spawned here binds to.
+  readonly identity: string;
+  readonly provider: ExecutionProvider | null;
+}
+
+/**
+ * The targets the daemon serves, and the problems with their entries that
+ * only the daemon's environment shows.
+ */
+export interface ExecutionTargetsBuild {
+  readonly targets: ExecutionTarget[];
+  readonly errors: TargetConfigError[];
+}
+
+/**
+ * Builds one target per configured entry, in config order, each with a
+ * provider of its kind when this daemon has one. An entry whose provider
+ * cannot start from `env` keeps no provider and adds a target error.
+ */
+export function buildExecutionTargets(
+  configs: readonly TargetConfig[],
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): ExecutionTargetsBuild {
+  const errors: TargetConfigError[] = [];
+
+  const targets = configs.map((config) => {
+    const built = buildProvider(config, env);
+
+    if (built.problem !== null) {
+      errors.push({ scope: 'target', target: config.id, problem: built.problem });
+    }
+
+    return {
+      id: config.id,
+      kind: config.provider,
+      options: config.options,
+      identity: buildTargetIdentity(config.provider, config.options),
+      provider: built.provider,
+    };
+  });
+
+  return { targets, errors };
+}
+
+function buildProvider(
+  config: TargetConfig,
+  env: Readonly<Record<string, string | undefined>>,
+): Readonly<{ provider: ExecutionProvider | null; problem: string | null }> {
+  if (config.provider === 'local-pty') {
+    return { provider: new LocalPTYProvider(), problem: null };
+  }
+
+  return config.provider === 'imp'
+    ? buildImpProvider(config.id, config.options, env)
+    : { provider: null, problem: null };
+}

package/src/daemon/build-fleet-events.ts

@@ -23,7 +23,8 @@ export function buildFleetEvents(
   sessions: readonly SessionDescriptor[],
 ): FleetEvent[] {
   return rows.map((row) => {
-    // A restore re-mints atc ids, so the agent session id is the stable link.
+    // Rows written before atc session ids stayed stable across restores
+    // carry an earlier atc id, so the agent session id links them.
     const live =
       (row.agentSessionID === null
         ? undefined

package/src/daemon/build-imp-provider.ts

@@ -0,0 +1,68 @@
+import { ImpClientPort } from './imp-client-port';
+import { ImpProvider } from './imp-provider';
+
+/**
+ * The provider of an `imp` target, or the problem that keeps it from one.
+ * A problem never includes the token or any other environment value.
+ */
+export interface ImpProviderBuild {
+  readonly provider: ImpProvider | null;
+  readonly problem: string | null;
+}
+
+/**
+ * The provider of target `id` from its `imp` options: `url` is where impd
+ * listens, and `tokenEnv` holds the name of the daemon's environment
+ * variable that carries the token, so no credential sits in the config.
+ * `image`, `memoryMib`, `guestDir`, and `guestATC` pass through. No
+ * provider when `url` is missing, so the target lists and refuses every
+ * spawn. A `tokenEnv` that is not a non-empty string, or whose variable is
+ * unset or empty in `env`, is a problem and leaves no provider; a target
+ * without `tokenEnv` calls impd with no token.
+ */
+export function buildImpProvider(
+  id: string,
+  options: Readonly<Record<string, unknown>>,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): ImpProviderBuild {
+  const url = options['url'];
+  const tokenEnv = options['tokenEnv'];
+
+  if (typeof url !== 'string' || url === '') {
+    return { provider: null, problem: null };
+  }
+
+  if (tokenEnv !== undefined && (typeof tokenEnv !== 'string' || tokenEnv === '')) {
+    return {
+      provider: null,
+      problem: `target ${JSON.stringify(id)} must give tokenEnv as a non-empty string`,
+    };
+  }
+
+  const token = tokenEnv === undefined ? null : env[tokenEnv];
+
+  if (token === undefined || token === '') {
+    return {
+      provider: null,
+      problem: `target ${JSON.stringify(id)} reads its impd token from ${String(tokenEnv)}, which is unset or empty in the daemon's environment`,
+    };
+  }
+
+  const provider = new ImpProvider(new ImpClientPort({ url, token }), {
+    ...pickString(options, 'image'),
+    ...pickString(options, 'guestDir'),
+    ...pickString(options, 'guestATC'),
+    ...(typeof options['memoryMib'] === 'number' ? { memoryMib: options['memoryMib'] } : {}),
+  });
+
+  return { provider, problem: null };
+}
+
+function pickString(
+  options: Readonly<Record<string, unknown>>,
+  key: 'image' | 'guestDir' | 'guestATC',
+): Partial<Record<typeof key, string>> {
+  const value = options[key];
+
+  return typeof value === 'string' && value !== '' ? { [key]: value } : {};
+}

package/src/daemon/build-payload-hash.ts

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto';
+import { isRecord } from '../shared/report';
+
+/**
+ * The SHA-256 of a request's params as canonical JSON: object keys sorted
+ * at every depth, with the idempotency key itself left out. Two requests
+ * that differ only in key order or in their idempotency key hash the same.
+ */
+export function buildPayloadHash(params: Readonly<Record<string, unknown>>): string {
+  const { idempotencyKey: _ignored, ...payload } = params;
+
+  return createHash('sha256')
+    .update(JSON.stringify(sortKeys(payload)))
+    .digest('hex');
+}
+
+function sortKeys(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortKeys(item));
+  }
+
+  if (!isRecord(value)) {
+    return value;
+  }
+
+  return Object.fromEntries(
+    Object.keys(value)
+      .toSorted()
+      .map((key) => [key, sortKeys(value[key])]),
+  );
+}

package/src/daemon/build-report-trail-entry.ts

@@ -5,14 +5,15 @@ import type { TrailEntry } from '../store/trail-entry';
 import type { NoteReport } from './parse-report';
 
 /**
- * The trail entry for one note a session reported, carrying its label and a
- * preview of its text.
+ * The trail entry for one note a session reported, carrying its label, a
+ * preview of its text, and the id its reporter gave it, when it gave one.
  */
 export function buildReportTrailEntry(
   sessionID: SessionID,
   agentSessionID: AgentSessionID | undefined,
   report: Readonly<NoteReport>,
   reportedAt: number,
+  reportID?: string,
 ): TrailEntry {
   return {
     at: reportedAt,
@@ -21,5 +22,6 @@ export function buildReportTrailEntry(
     kind: 'report',
     label: report.label,
     detail: truncateDetail(report.text),
+    ...(reportID === undefined ? {} : { reportID }),
   };
 }