@zgeoff/atc 2.27.0 → 2.29.0

package/README.md

@@ -50,7 +50,7 @@ bun add -g @zgeoff/atc
 ```
 
 atc needs at least one of the `claude`, `grok`, or `codex` CLIs on your PATH. The agent picker lists
-the ones it finds.
+the ones it finds, and opens only when it finds more than one.
 
 ## Use
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.27.0",
+  "version": "2.29.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/index.ts

@@ -11,11 +11,13 @@ import { makeSingleFlight } from '../shared/make-single-flight';
 import { bootDaemonClient } from './boot-daemon';
 import { buildClientMachine } from './build-client-machine';
 import { buildLeaderChords } from './build-leader-chords';
+import { collectTargetPicks } from './collect-target-picks';
 import { findFuzzyScore, formatDir } from './dirs';
 import type { ProtocolMismatch } from './format-protocol-mismatch';
 import { KEY, isDown, isUp, planTextEdit } from './keys';
 import { parseDaemonEvent } from './parse-daemon-event';
 import { pickTabTarget } from './pick-tab-target';
+import { resolveAgentMetadata } from './resolve-agent-metadata';
 import { SpawnPicker } from './spawn-picker';
 import { toMirrorSession } from './to-mirror-session';
 import type { MirrorSession } from './to-mirror-session';
@@ -40,12 +42,17 @@ let focusedID: string | null = null;
 let fleetCount = 0;
 let lastUsedAgent: AgentID = 'claude';
 
-// Read once at start, like the leader key: a newly configured backend gets
-// its overlay letter on the next client run.
-const agentMarks: Readonly<Record<AgentID, string>> = Object.fromEntries(
-  loadConfig().gateways.map((g) => [g.id, g.mark]),
-);
-
+// The readable harness label and tier-alias map per agent: the config alone
+// until the daemon's `agents.list` answer arrives and re-resolves them
+// whenever the overlay opens, so a backend configured after this client
+// started still lists under its name.
+const bootMetadata = resolveAgentMetadata(loadConfig(), {});
+let agentLabels: Readonly<Record<AgentID, string>> = bootMetadata.labels;
+let agentModels: Readonly<Record<AgentID, Readonly<Record<string, string>>>> = bootMetadata.models;
+
+// How many execution targets the daemon could spawn on right now; the
+// target column appears once more than one is available.
+let availableTargets = 0;
 const stdout = process.stdout;
 
 // Full height: the atc status bar only exists on home/overlay screens;
@@ -250,7 +257,9 @@ function renderOverlay() {
 
   drawOverlay({
     sessions,
-    agentMarks,
+    agentLabels,
+    agentModels,
+    showTarget: availableTargets >= 2,
     selected: overlaySelected,
     confirmKill,
     confirmDestroy: confirmDestroyID !== null,
@@ -262,11 +271,33 @@ function renderOverlay() {
   scheduleStatus();
 }
 
+// Rereads what the overlay labels rows with: each agent's readable name and
+// tier aliases, and which execution targets can take a spawn. Target
+// availability moves as remote hosts wake and sleep, so the overlay refresh
+// keeps the column honest rather than trusting the boot-time answer.
+async function refreshAgents() {
+  try {
+    const answer = await client.sendRequest('agents.list');
+
+    const meta = resolveAgentMetadata(loadConfig(), answer);
+
+    agentLabels = meta.labels;
+    agentModels = meta.models;
+    availableTargets = collectTargetPicks(answer).filter((t) => t.available).length;
+  } catch {
+    return;
+  }
+
+  if (service.getSnapshot().value === 'overlay') {
+    renderOverlay();
+  }
+}
+
 function openOverlay() {
   confirmKill = false;
   confirmDestroyID = null;
   overlayFilter = null;
-
+  void refreshAgents();
   const focusedIndex = pickOverlaySessions().findIndex((s) => s.id === focusedID);
 
   overlaySelected = Math.max(0, focusedIndex);
@@ -367,6 +398,9 @@ function upsertMirror(d: Readonly<MirrorSession>) {
     existing.resumable = d.resumable;
     existing.canEject = d.canEject;
     existing.agent = d.agent;
+    existing.target = d.target;
+    existing.model = d.model;
+    existing.harness = d.harness;
   }
 }
 
@@ -808,6 +842,7 @@ if (restartedOnBoot) {
 }
 
 await refreshMirror();
+await refreshAgents();
 
 /**
  * Asks on the terminal whether to restart a daemon that speaks another
@@ -918,8 +953,19 @@ async function restartDaemon() {
   lastUsedAgent = next.lastUsedAgent;
   client.onEvent = applyDaemonEvent;
 
+  // A new daemon may map aliases differently, so rows fall back to the
+  // config baseline until its own answer arrives; the target count goes
+  // back to none for the same reason, hiding the column until the new
+  // daemon reports what it can spawn on.
+  const baseline = resolveAgentMetadata(loadConfig(), {});
+
+  agentLabels = baseline.labels;
+  agentModels = baseline.models;
+  availableTargets = 0;
+
   await sendQuiet('fleet.restore', { cols: cols(), rows: ptyRows() });
   await refreshMirror().catch(() => {});
+  await refreshAgents();
 
   service.send({ type: 'OVERLAY' });
 }

package/src/client/plan-overlay-columns.ts

@@ -0,0 +1,155 @@
+// The glyph, unread, and pin cells that lead every row, plus the one space
+// before the first body column.
+const PREFIX_WIDTH = 4;
+
+// The last-event column's soft width once the rest has claimed its share;
+// whatever width remains after shrinking goes back to it.
+const EVENT_BASE_WIDTH = 4;
+
+export interface OverlayColumnPlan {
+  readonly nameWidth: number;
+
+  // The directory column of the flat view; 0 in the grouped view and
+  // whenever width pressure crowds it out.
+  readonly dirWidth: number;
+
+  // 0 while only one target is available, so the column stays hidden.
+  readonly targetWidth: number;
+  readonly harnessWidth: number;
+
+  // 0 when no visible session runs an explicit model.
+  readonly modelWidth: number;
+  readonly lifecycleWidth: number;
+  readonly eventWidth: number;
+}
+
+export interface OverlayColumnInput {
+  // The width inside the overlay box: the box width less its borders and
+  // padding.
+  readonly innerWidth: number;
+
+  readonly grouped: boolean;
+
+  // Whether more than one execution target is available to spawn on.
+  readonly showTarget: boolean;
+
+  // The longest label each column would draw over the visible sessions;
+  // 0 for a column with nothing to show.
+  readonly targetMax: number;
+  readonly harnessMax: number;
+  readonly modelMax: number;
+}
+
+type ColumnKey = 'dir' | 'model' | 'event' | 'harness' | 'target' | 'name' | 'lifecycle';
+
+// How much pressure it takes to crowd a column out, from first to go to
+// last: the flat view's directory, then the model and the last event, then
+// the harness, the target, and the name, with the lifecycle text held
+// longest.
+const SHRINK_ORDER: readonly ColumnKey[] = [
+  'dir',
+  'model',
+  'event',
+  'harness',
+  'target',
+  'name',
+  'lifecycle',
+];
+
+const PREFERRED: Readonly<Record<ColumnKey, number>> = {
+  dir: 18,
+  model: 14,
+  event: EVENT_BASE_WIDTH,
+  harness: 14,
+  target: 14,
+  name: 16,
+  lifecycle: 9,
+};
+
+// The least each column keeps while any width remains to take: the name,
+// target, and harness stay legible after the directory, model, and last
+// event have given way.
+const FLOOR: Readonly<Record<ColumnKey, number>> = {
+  dir: 0,
+  model: 0,
+  event: 0,
+  harness: 3,
+  target: 3,
+  name: 6,
+  lifecycle: 9,
+};
+
+/**
+ * The column widths a session row draws with. Each column starts at the
+ * shorter of its preferred width and the longest value it would draw; while
+ * the row outgrows the box, the column under the least pressure that still
+ * holds its floor gives up a cell at a time in the order above, so the
+ * model and the last event shrink first and the name, target, and harness
+ * last. Whatever width is left over after the row fits goes to the last
+ * event.
+ */
+export function planOverlayColumns(input: Readonly<OverlayColumnInput>): OverlayColumnPlan {
+  const widths: Record<ColumnKey, number> = {
+    dir: input.grouped ? 0 : PREFERRED.dir,
+    model: pickWidth(input.modelMax, PREFERRED.model),
+    event: PREFERRED.event,
+    harness: pickWidth(input.harnessMax, PREFERRED.harness),
+    target: input.showTarget ? pickWidth(input.targetMax, PREFERRED.target) : 0,
+    name: PREFERRED.name,
+    lifecycle: PREFERRED.lifecycle,
+  };
+
+  truncateWidthsToFit(widths, input.innerWidth, (key) => FLOOR[key]);
+  truncateWidthsToFit(widths, input.innerWidth, () => 0);
+
+  // Whatever width the other columns leave, less the event column's own
+  // gap, becomes the last event's width; a single spare cell is not enough
+  // to bring the column back for.
+  const spare = input.innerWidth - getTotalWidth({ ...widths, event: 0 });
+
+  widths.event = spare >= 2 ? spare - 1 : 0;
+
+  return {
+    nameWidth: widths.name,
+    dirWidth: widths.dir,
+    targetWidth: widths.target,
+    harnessWidth: widths.harness,
+    modelWidth: widths.model,
+    lifecycleWidth: widths.lifecycle,
+    eventWidth: widths.event,
+  };
+}
+
+// A column with nothing to draw keeps no width; otherwise it takes the
+// shorter of its preferred width and its longest value.
+function pickWidth(contentMax: number, preferred: number): number {
+  return contentMax <= 0 ? 0 : Math.min(contentMax, preferred);
+}
+
+function truncateWidthsToFit(
+  widths: Record<ColumnKey, number>,
+  innerWidth: number,
+  floorOf: (key: ColumnKey) => number,
+): void {
+  while (getTotalWidth(widths) > innerWidth) {
+    const giver = SHRINK_ORDER.find((key) => widths[key] > floorOf(key));
+
+    if (giver === undefined) {
+      return;
+    }
+
+    widths[giver] -= 1;
+  }
+}
+
+// The prefix plus every column and one space between the columns that still
+// draw, so a column crowded to nothing takes its gap with it.
+function getTotalWidth(widths: Readonly<Record<ColumnKey, number>>): number {
+  const visible = SHRINK_ORDER.filter((key) => widths[key] > 0);
+
+  return (
+    PREFIX_WIDTH +
+    visible.reduce((sum, key) => sum + widths[key], 0) +
+    Math.max(0, visible.length - 1)
+  );
+}

package/src/client/resolve-agent-metadata.ts

@@ -0,0 +1,75 @@
+import type { AgentID } from '../shared/agent-id';
+import type { Config } from '../shared/config';
+import { isRecord } from '../shared/report';
+
+// What the overlay needs to know per agent to label a row: the readable
+// name, and the tier-alias map a gateway's env configures.
+export interface AgentMetadata {
+  readonly labels: Readonly<Record<AgentID, string>>;
+
+  // Per agent id, the alias-to-model mapping an `agents.list` entry
+  // carries; absent for agents that take models by name only.
+  readonly models: Readonly<Record<AgentID, Readonly<Record<string, string>>>>;
+}
+
+const BUILT_IN_LABELS: Readonly<Record<AgentID, string>> = {
+  claude: 'Claude',
+  grok: 'Grok',
+  codex: 'Codex',
+};
+
+/**
+ * The labels and model aliases the overlay draws with, resolved from the
+ * config a client reads at start and the daemon's `agents.list` answer once
+ * it arrives. The answer wins, so a backend the daemon registers under a
+ * stand-in adapter still lists under its own name; the config alone covers
+ * the window before the answer lands.
+ */
+export function resolveAgentMetadata(config: Config, listed: unknown): AgentMetadata {
+  const labels: Record<AgentID, string> = { ...BUILT_IN_LABELS };
+  const models: Record<AgentID, Readonly<Record<string, string>>> = {};
+
+  for (const gateway of config.gateways) {
+    if (isSafeKey(gateway.id)) {
+      labels[gateway.id] = gateway.label;
+    }
+  }
+
+  if (isRecord(listed) && Array.isArray(listed['agents'])) {
+    for (const entry of listed['agents']) {
+      if (!isRecord(entry) || typeof entry['id'] !== 'string' || !isSafeKey(entry['id'])) {
+        continue;
+      }
+
+      if (typeof entry['label'] === 'string' && entry['label'] !== '') {
+        labels[entry['id']] = entry['label'];
+      }
+
+      if (isRecord(entry['models'])) {
+        models[entry['id']] = pickModelAliases(entry['models']);
+      }
+    }
+  }
+
+  return { labels, models };
+}
+
+// The alias-to-model entries of an `agents.list` model map, keeping the
+// string values a row can resolve and dropping anything else.
+function pickModelAliases(values: Readonly<Record<string, unknown>>): Record<string, string> {
+  const aliases: Record<string, string> = {};
+
+  for (const [alias, model] of Object.entries(values)) {
+    if (typeof model === 'string' && isSafeKey(alias)) {
+      aliases[alias] = model;
+    }
+  }
+
+  return aliases;
+}
+
+// A daemon-supplied id or alias can name `__proto__`, which would change a
+// map's prototype instead of adding an entry, so such keys stay out.
+function isSafeKey(key: string): boolean {
+  return key !== '__proto__';
+}