@zgeoff/atc 2.27.0 → 2.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.27.0",
+  "version": "2.28.0",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",

package/src/client/spawn-picker.ts

@@ -19,9 +19,19 @@ import { KEY, planTextEdit } from './keys';
 import { pickRefusalStep } from './pick-refusal-step';
 import { resolvePathInput } from './resolve-path-input';
 import { resolveWorkspaceRoot } from './resolve-workspace-root';
-import { ansi, cols, drawPicker } from './ui';
-
-type PickerStep = 'agent' | 'dir' | 'source' | 'ref' | 'target' | 'confirm' | 'name' | 'prompt';
+import { splitToWidth } from './split-to-width';
+import { ansi, cols, drawPicker, getPickerWidth } from './ui';
+
+type PickerStep =
+  | 'agent'
+  | 'dir'
+  | 'source'
+  | 'ref'
+  | 'target'
+  | 'confirm'
+  | 'name'
+  | 'prompt'
+  | 'spawned';
 
 // What the flow borrows from the client that owns the screen, the daemon
 // connection and the fleet mirror.
@@ -226,6 +236,12 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
   private pending: PendingRequest | null = null;
 
+  // A session the daemon started with warnings, and those warnings, shown
+  // before the flow attaches it.
+  private spawned: TMirror | null = null;
+
+  private spawnWarnings: readonly string[] = [];
+
   private requestSeq = 0;
 
   // The flow's generation. Opening the flow and every way out of it moves
@@ -281,6 +297,12 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
   applyKey(buf: Buffer) {
     this.refusal = null;
 
+    if (this.step === 'spawned') {
+      this.applySpawnedKey(buf);
+
+      return;
+    }
+
     const edit = planTextEdit(buf, this.input, {
       isLeaderKey: this.deps.isLeaderKey,
       moves:
@@ -387,6 +409,14 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       this.renderTargetStep(verb);
     } else if (this.step === 'confirm') {
       this.renderConfirmStep();
+    } else if (this.step === 'spawned') {
+      drawPicker({
+        title: `${verb}: started`,
+        items: this.spawnWarnings.flatMap((w) => splitToWidth(w, getPickerWidth() - 4)),
+        selected: -1,
+        input: '',
+        hint: '⏎ attach · esc back',
+      });
     } else if (this.step === 'name') {
       const where = this.isGitFlow() ? this.formatDestination() : formatDir(this.dir);
 
@@ -1714,9 +1744,49 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.stopFlow();
     this.deps.upsertMirror(session);
 
+    const warnings = spawned.answer['warnings'];
+
+    // A workspace that left changes behind says so before the session's
+    // screen takes over.
+    if (Array.isArray(warnings) && warnings.length > 0) {
+      this.spawned = session;
+      this.spawnWarnings = warnings.filter((w): w is string => typeof w === 'string');
+      this.step = 'spawned';
+
+      process.stdout.write(ansi.clear);
+      this.render();
+
+      return;
+    }
+
     await this.deps.attach(session.id);
   }
 
+  // The started step takes Enter to attach the session and Esc or the
+  // leader to return to the screen the flow came from; the session runs
+  // either way.
+  private applySpawnedKey(buf: Buffer) {
+    const edit = planTextEdit(buf, '', { isLeaderKey: this.deps.isLeaderKey, moves: false });
+
+    if (edit.kind !== 'submit' && edit.kind !== 'cancel' && edit.kind !== 'leader') {
+      return;
+    }
+
+    const session = this.spawned;
+
+    this.spawned = null;
+    this.spawnWarnings = [];
+    this.step = 'agent';
+
+    if (edit.kind === 'submit' && session !== null) {
+      void this.deps.attach(session.id);
+
+      return;
+    }
+
+    this.deps.toBase();
+  }
+
   // A refused git workspace spawn returns to the step that can fix it. Any
   // other refusal 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

package/src/client/split-to-width.ts

@@ -0,0 +1,47 @@
+/**
+ * Splits text into rows of at most `width` characters, breaking at spaces
+ * and counting a grapheme cluster as one character. A word wider than a
+ * row breaks at the row's edge, never inside a character.
+ */
+export function splitToWidth(text: string, width: number): string[] {
+  if (width <= 0) {
+    return [text];
+  }
+
+  const segmenter = new Intl.Segmenter();
+
+  const rows: string[] = [];
+  let row: string[] = [];
+
+  for (const word of text.split(' ')) {
+    let rest = Array.from(segmenter.segment(word), (part) => part.segment);
+
+    while (rest.length > width) {
+      if (row.length > 0) {
+        rows.push(row.join(''));
+
+        row = [];
+      }
+
+      rows.push(rest.slice(0, width).join(''));
+
+      rest = rest.slice(width);
+    }
+
+    if (row.length === 0) {
+      row = rest;
+    } else if (row.length + 1 + rest.length <= width) {
+      row = [...row, ' ', ...rest];
+    } else {
+      rows.push(row.join(''));
+
+      row = rest;
+    }
+  }
+
+  if (row.length > 0) {
+    rows.push(row.join(''));
+  }
+
+  return rows;
+}

package/src/client/ui.ts

@@ -65,6 +65,14 @@ export function cols(): number {
   return process.stdout.columns || 80;
 }
 
+/**
+ * The width of the picker box, borders included. An item row holds 4
+ * columns fewer.
+ */
+export function getPickerWidth(): number {
+  return Math.min(cols() - 4, 90);
+}
+
 export function rows(): number {
   return process.stdout.rows || 24;
 }
@@ -393,7 +401,7 @@ export interface PickerView {
 }
 
 export function drawPicker(view: PickerView) {
-  const width = Math.min(cols() - 4, 90);
+  const width = getPickerWidth();
   const rowsList: Row[] = [boxTop(width, view.title)];
   const shown = view.items.slice(0, 10);
 

package/src/daemon/materialize-workspace.ts

@@ -326,7 +326,7 @@ async function resolveSource(
     await requireNoOriginRewriteCredentials(source.path);
 
     const resolved = await resolvePathSource(source.path, {
-      allowDirty: source.allowDirty ?? 'refuse',
+      ...(source.allowDirty === undefined ? {} : { allowDirty: source.allowDirty }),
       transports,
     });
 

package/src/mcp/mcp-tools.ts

@@ -58,7 +58,7 @@ const SPAWN_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
       'Execution target for the new session, one of the target ids in atc_agents_list. Omit it to run on the default target (spawnDefaults.target). An unknown or unavailable target is refused; atc never runs the session on another target instead.',
     ),
     workspace: SPAWN_SCHEMA.shape.workspace.describe(
-      "Where the session's working directory comes from. Omit it to run the session in cwd as it stands. With it, atc materializes a clean checkout into cwd on the target, which must not exist yet: {kind:'path', path, allowDirty?} checks out the pushed HEAD of a git checkout on the atc host, refusing uncommitted changes unless allowDirty is 'warn'; {kind:'git', url, ref or sha, credentialRef?} checks out a branch, tag, or full commit of a repository, with credentialRef {kind:'env', name} naming the atc daemon's environment variable that holds its token. A directory outside git runs in place only on a target on the atc host itself (provider local-pty), with cwd equal to its path. Submodules and Git LFS are refused, and so is a URL that carries a credential.",
+      "Where the session's working directory comes from. Omit it to run the session in cwd as it stands. With it, atc materializes a clean checkout into cwd on the target, which must not exist yet: {kind:'path', path, allowDirty?} checks out the pushed HEAD of a git checkout on the atc host, leaving its uncommitted and untracked changes behind with a warning, or refusing them when allowDirty is 'refuse'; {kind:'git', url, ref or sha, credentialRef?} checks out a branch, tag, or full commit of a repository, with credentialRef {kind:'env', name} naming the atc daemon's environment variable that holds its token. A directory outside git runs in place only on a target on the atc host itself (provider local-pty), with cwd equal to its path. Submodules and Git LFS are refused, and so is a URL that carries a credential.",
     ),
     trustClonedWorkspace: SPAWN_SCHEMA.shape.trustClonedWorkspace.describe(
       'Trust the exact verified clone for this launch. An explicit true or false overrides the configured target trustClonedWorkspace default; omitting both keeps trust off. Requires a workspace source, an imp target, and a brokered Claude gateway with isolated guest config; other launches are refused. Accepts repository configuration and helpers without changing tool permission mode. Existing guest config is preserved.',

package/src/protocol/request-param-schemas.ts

@@ -54,8 +54,9 @@ const GIT_SHA = z.string().regex(COMMIT_ID, 'a git workspace sha is a full commi
  * Where a spawn's working directory comes from, materialized as a clean
  * checkout into the spawn's `cwd` on its execution target. A `path` source
  * is a directory on the daemon's host, resolved to its origin URL and
- * pushed HEAD; `allowDirty: 'warn'` resolves a tree with uncommitted
- * changes to HEAD and leaves the changes behind with a warning. A `git`
+ * pushed HEAD. A tree with uncommitted or untracked changes resolves to
+ * HEAD and leaves the changes behind with a warning, unless `allowDirty`
+ * is `'refuse'`, which refuses it. A `git`
  * source is a repository URL with a branch or tag `ref`, a full commit
  * `sha`, or both, and an optional `credentialRef` naming the daemon
  * environment variable that holds its token. With both, the sha is the

package/src/workspace/resolve-path-source.ts

@@ -39,8 +39,9 @@ interface PathSourceRefusal {
  * can clone, so a workspace never carries files that exist only here. The
  * commit is HEAD, and it must already be on origin: a remote-tracking ref
  * under origin contains it, or origin advertises it as a ref tip. A tree
- * with uncommitted or untracked changes is refused, or with `allowDirty:
- * 'warn'` resolves to HEAD and leaves those changes behind with a warning.
+ * with uncommitted or untracked changes resolves to HEAD and leaves those
+ * changes behind, with a warning that counts them; `allowDirty: 'refuse'`
+ * refuses it instead. The changes are never copied.
  * Submodules are refused. The URL is origin's, with any credential stripped.
  */
 export async function resolvePathSource(
@@ -81,7 +82,9 @@ export async function resolvePathSource(
     return { ok: false, code: 'has_submodules', message: `${root} uses submodules` };
   }
 
-  const status = await runGit(['status', '--porcelain', '--untracked-files=normal'], { cwd: root });
+  // Every untracked file is listed on its own, so an untracked directory
+  // counts each file inside it.
+  const status = await runGit(['status', '--porcelain', '--untracked-files=all'], { cwd: root });
 
   if (status.exitCode !== 0) {
     return {
@@ -91,10 +94,11 @@ export async function resolvePathSource(
     };
   }
 
-  const dirty = status.stdout.trim() !== '';
+  const changed = countChangedPaths(status.stdout);
+  const dirty = changed > 0;
   const warnings: string[] = [];
 
-  if (dirty && options.allowDirty !== 'warn') {
+  if (dirty && options.allowDirty === 'refuse') {
     return {
       ok: false,
       code: 'workspace_dirty',
@@ -103,7 +107,10 @@ export async function resolvePathSource(
   }
 
   if (dirty) {
-    warnings.push(`uncommitted and untracked changes in ${root} stay behind; using ${sha}`);
+    // The commit leads, so a display that cuts the note short keeps it.
+    warnings.push(
+      `cloned commit ${sha.slice(0, 12)}; left ${changed} uncommitted or untracked ${changed === 1 ? 'path' : 'paths'} behind in ${root}`,
+    );
   }
 
   const origin = await runGit(['ls-remote', '--get-url', 'origin'], { cwd: root });
@@ -150,6 +157,14 @@ function hasSubmodules(listing: string): boolean {
     .some((line) => line.startsWith('160000 ') || line.endsWith('\t.gitmodules'));
 }
 
+/**
+ * How many paths a porcelain status listing holds. Only the count leaves
+ * this module: a path's name can itself be sensitive.
+ */
+function countChangedPaths(porcelain: string): number {
+  return porcelain.split('\n').filter((line) => line.trim() !== '').length;
+}
+
 /**
  * Whether origin already has the commit. A local remote-tracking ref proves
  * it without network access; failing that, origin's advertised ref tips are