@zgeoff/atc 2.16.0 → 2.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.16.0",
+  "version": "2.19.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/cli.ts

@@ -161,6 +161,10 @@ const main = defineCommand({
           const gateway = await import('./agents/gateway-adapter');
           const headless = await import('./agents/start-claude-headless-run');
           const targets = await import('./daemon/build-execution-targets');
+          const sourceOrder = await import('./sources/build-sources');
+          const builtinSources = await import('./sources/collect-builtin-sources');
+          const zoxide = await import('./shared/collect-zoxide-dirs');
+          const home = await import('./shared/resolve-home-dir');
 
           // Test harnesses shrink the outbound queue to force overflow
           // deterministically; unset means the production default.
@@ -178,10 +182,27 @@ const main = defineCommand({
             console.error(`atc daemon: config: ${line}`);
           }
 
-          for (const problem of cfg.principalErrors) {
+          for (const problem of [...cfg.principalErrors, ...cfg.workspaceErrors]) {
             console.error(`atc daemon: config: ${problem}`);
           }
 
+          const sources = sourceOrder.buildSources(
+            builtinSources.collectBuiltinSources({
+              roots: cfg.dirs.roots,
+              githubOwner: cfg.workspaces.githubOwner,
+              ghBin: 'gh',
+              homeDir: home.resolveHomeDir(),
+              collectZoxideDirs: zoxide.collectZoxideDirs,
+            }),
+            cfg.workspaces.sources,
+          );
+
+          for (const id of sources.missing) {
+            console.error(
+              `atc daemon: config: workspaces.sources holds '${id}', which this daemon cannot offer; the picker leaves it out`,
+            );
+          }
+
           // 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
           // keep timing deterministic; unset means the production default.
@@ -220,6 +241,8 @@ const main = defineCommand({
               defaultTarget: cfg.defaultTarget,
               targetErrors,
               principals: cfg.principals,
+              sources: sources.sources,
+              gitTransports: cfg.workspaces.gitTransports,
               restoreBootTimeoutMs,
               ...(Number.isFinite(graceOverride) && graceOverride >= 0
                 ? { tapGraceMs: graceOverride }

package/src/client/build-workspace-destination.ts

@@ -0,0 +1,38 @@
+interface DestinationParts {
+  // The root the checkout lands under, absolute on its target.
+  readonly root: string;
+
+  // The repository URL the checkout comes from, as the daemon resolved it.
+  readonly url: string;
+
+  // The branch or tag the commit was chosen by, or null for a bare commit.
+  readonly ref: string | null;
+  readonly sha: string;
+}
+
+/**
+ * The default directory a git workspace lands in: `<repo>-<ref>-<short
+ * sha>` under the root, with the ref left out for a bare commit. The repo
+ * is the URL's last path segment without `.git`, and each part keeps only
+ * `[A-Za-z0-9._-]`, with `/` turned into `-`, so the name is one path
+ * segment on any target.
+ */
+export function buildWorkspaceDestination(parts: DestinationParts): string {
+  const repo =
+    parts.url
+      .replace(/\/+$/u, '')
+      .split(/[/:]/u)
+      .at(-1)
+      ?.replace(/\.git$/u, '') ?? '';
+
+  const name = [repo, ...(parts.ref === null ? [] : [parts.ref]), parts.sha.slice(0, 7)]
+    .map((part) => toSafeSegment(part))
+    .filter((part) => part !== '')
+    .join('-');
+
+  return `${parts.root.replace(/\/+$/u, '')}/${name}`;
+}
+
+function toSafeSegment(part: string): string {
+  return part.replaceAll('/', '-').replaceAll(/[^\w.-]/gu, '');
+}

package/src/client/collect-target-picks.ts

@@ -0,0 +1,53 @@
+import { isRecord } from '../shared/report';
+
+export interface TargetPick {
+  readonly id: string;
+  readonly provider: string;
+  readonly available: boolean;
+  readonly isDefault: boolean;
+
+  // Whether a workspace can be materialized there: the daemon has the
+  // provider, and it can both transfer an archive and run a command.
+  readonly takesWorkspace: boolean;
+
+  // Whether a session there runs on the daemon's own machine, where a
+  // local directory runs in place.
+  readonly inPlace: boolean;
+}
+
+/**
+ * The execution targets an `agents.list` answer holds, in config order. An
+ * answer from a daemon without targets, or a malformed entry, yields none.
+ */
+export function collectTargetPicks(answer: Readonly<Record<string, unknown>>): TargetPick[] {
+  const targets = answer['targets'];
+
+  if (!Array.isArray(targets)) {
+    return [];
+  }
+
+  return targets.flatMap((entry: unknown): TargetPick[] => {
+    if (
+      !isRecord(entry) ||
+      typeof entry['id'] !== 'string' ||
+      typeof entry['provider'] !== 'string'
+    ) {
+      return [];
+    }
+
+    const capabilities = isRecord(entry['capabilities']) ? entry['capabilities'] : {};
+    const available = entry['available'] === true;
+
+    return [
+      {
+        id: entry['id'],
+        provider: entry['provider'],
+        available,
+        isDefault: entry['default'] === true,
+        takesWorkspace:
+          available && capabilities['transfer'] === true && capabilities['run'] === true,
+        inPlace: entry['provider'] === 'local-pty',
+      },
+    ];
+  });
+}

package/src/client/dirs.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename } from 'node:path';
-import { collectRootDirs } from './collect-root-dirs';
+import { collectRootDirs } from '../shared/collect-root-dirs';
 
 /**
  * Every source the picker lists, merged in the order the reader expects

package/src/client/pick-refusal-step.ts

@@ -0,0 +1,29 @@
+// The steps of the git spawn flow a refused spawn can return to.
+type RefusalStep = 'confirm' | 'destination' | 'ref' | 'source';
+
+const REFUSAL_STEPS: ReadonlyMap<string, RefusalStep> = new Map<string, RefusalStep>([
+  ['workspace_exists', 'destination'],
+  ['ref_not_found', 'ref'],
+  ['invalid_git_url', 'source'],
+  ['credential_in_url', 'source'],
+  ['credential_missing', 'source'],
+  ['clone_failed', 'source'],
+  ['has_submodules', 'confirm'],
+  ['lfs_unsupported', 'confirm'],
+  ['unreadable_tree', 'confirm'],
+  ['sanitize_failed', 'confirm'],
+  ['tar_failed', 'confirm'],
+  ['transfer_failed', 'confirm'],
+  ['workspace_mismatch', 'confirm'],
+]);
+
+/**
+ * The step of the git spawn flow that can fix a workspace spawn's
+ * refusal: the destination for one that already exists, the ref for one
+ * the upstream lacks, the source step for a URL or clone failure, and the
+ * confirm screen for a refusal of the commit or the target's copy of it.
+ * Null for any other refusal, which stays on the step that sent the spawn.
+ */
+export function pickRefusalStep(code: string): RefusalStep | null {
+  return REFUSAL_STEPS.get(code) ?? null;
+}

package/src/client/resolve-workspace-root.ts

@@ -0,0 +1,49 @@
+import type { WorkspacesConfig } from '../shared/collect-workspaces-config';
+import { resolveHomeDir } from '../shared/resolve-home-dir';
+
+type WorkspaceRoot =
+  | { readonly ok: true; readonly root: string }
+  | { readonly ok: false; readonly message: string };
+
+interface RootTarget {
+  readonly id: string;
+
+  // Whether the target is the daemon's own machine, where `~` is this
+  // user's home.
+  readonly inPlace: boolean;
+}
+
+// Where checkouts land on the daemon's own machine without a configured root.
+const DEFAULT_ROOT = '~/.local/share/atc/workspaces';
+
+/**
+ * The directory git workspaces land under on a target: the target's own
+ * root, else the global root, else the default. On the daemon's own
+ * machine a leading `~` expands to the home directory. On any other target
+ * the root must be absolute, since `~` there is a home this client cannot
+ * see, so a root that is not is refused with the config key to set.
+ */
+export function resolveWorkspaceRoot(config: WorkspacesConfig, target: RootTarget): WorkspaceRoot {
+  const configured = config.targetRoots.get(target.id) ?? config.root;
+
+  if (target.inPlace) {
+    const root = expandHome(configured ?? DEFAULT_ROOT);
+
+    return root.startsWith('/')
+      ? { ok: true, root }
+      : { ok: false, message: `workspaces root '${root}' must be an absolute path` };
+  }
+
+  if (configured === null || !configured.startsWith('/')) {
+    return {
+      ok: false,
+      message: `set workspaces.targets.${target.id} in config.json to an absolute path on that target`,
+    };
+  }
+
+  return { ok: true, root: configured };
+}
+
+function expandHome(dir: string): string {
+  return dir === '~' || dir.startsWith('~/') ? `${resolveHomeDir()}${dir.slice(1)}` : dir;
+}