@zgeoff/atc 0.1.12 → 1.0.0

package/src/{hooks.ts → daemon/hooks.ts}

@@ -1,9 +1,11 @@
 import { unlinkSync } from 'node:fs';
-import { socketPath } from './config';
-import { isRecord } from './report';
+import { socketPath } from '../shared/config';
+import { isRecord } from '../shared/report';
+import type { SessionID } from '../shared/session-id';
+import { toSessionID } from '../shared/to-session-id';
 
 export interface HookEvent {
-  atcId: string;
+  atcId: SessionID;
   event: string;
   payload: Record<string, unknown>;
 }
@@ -37,7 +39,7 @@ export function startHookServer(onEvent: (e: HookEvent) => void, path: string =
               isRecord(parsed['payload'])
             ) {
               onEvent({
-                atcId: parsed['atcId'],
+                atcId: toSessionID(parsed['atcId']),
                 event: parsed['event'],
                 payload: parsed['payload'],
               });

package/src/daemon/mint-session-id.ts

@@ -0,0 +1,12 @@
+import type { SessionID } from '../shared/session-id';
+
+let counter = 0;
+
+/**
+ * A fresh atc session id: an incrementing counter joined to the current time
+ * in base36. Every session the session manager spawns or restores gets one.
+ */
+export function mintSessionID(): SessionID {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- this is where atc mints a session id
+  return `s${++counter}-${Date.now().toString(36)}` as SessionID;
+}

package/src/{permission-registry.ts → daemon/permission-registry.ts}

@@ -1,6 +1,8 @@
+import type { SessionID } from '../shared/session-id';
+
 export interface PermissionRequest {
   readonly id: string;
-  readonly sessionID: string;
+  readonly sessionID: SessionID;
   readonly message: string;
   readonly respondable: boolean;
 }
@@ -36,7 +38,7 @@ export class PermissionRegistry {
     this.timeoutMs = timeoutMs;
   }
 
-  open(sessionID: string, message: string, respondable: boolean): PermissionRequest {
+  open(sessionID: SessionID, message: string, respondable: boolean): PermissionRequest {
     const id = `p${++this.counter}`;
     const req: PermissionRequest = { id, sessionID, message, respondable };
 
@@ -70,7 +72,7 @@ export class PermissionRegistry {
     return 'ok';
   }
 
-  answerAll(sessionID: string, decision: string): void {
+  answerAll(sessionID: SessionID, decision: string): void {
     for (const [id, entry] of this.pending) {
       if (entry.req.sessionID === sessionID) {
         this.removeRequest(id, decision);

package/src/daemon/restore-fleet.ts

@@ -0,0 +1,141 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { SessionID } from '../shared/session-id';
+import type { StateStore } from '../store/state-store';
+import { ScreenModel } from './screen-model';
+import type { SessionRuntime } from './session-runtime';
+import type { Session, SessionManager } from './sessions';
+
+export interface RestoreFleetParams {
+  readonly mgr: SessionManager;
+  readonly store: StateStore;
+  readonly findRuntime: (sessionID: SessionID) => SessionRuntime | undefined;
+  readonly cols: number;
+  readonly rows: number;
+
+  // Caps how long a staggered restore waits for a revived session to report
+  // it has booted before moving on regardless; zero waits on the signal
+  // alone.
+  readonly capMs: number;
+}
+
+/**
+ * Restores the fleet: dedupes stored entries against live sessions, orders
+ * the rest by recency, registers every one as a terminal-less session so
+ * the whole fleet lists at once, then adopts terminals one at a time,
+ * waiting for each session to report it has booted before starting the
+ * next.
+ */
+export async function restoreFleet(params: RestoreFleetParams): Promise<number> {
+  const mgr = params.mgr;
+  const store = params.store;
+  const findRuntime = params.findRuntime;
+  const cols = params.cols;
+  const rows = params.rows;
+  const capMs = params.capMs;
+
+  const hasLiveSession = (agentSessionID: AgentSessionID) =>
+    mgr.sessions.some(
+      (s) =>
+        s.agentSessionID === agentSessionID &&
+        (s.pty !== null || (s.kind === 'headless' && s.state !== 'exited')),
+    );
+
+  const hasAnySession = (agentSessionID: AgentSessionID) =>
+    mgr.sessions.some((s) => s.agentSessionID === agentSessionID);
+
+  const recency = await store.collectFleetRecency();
+  const stored = await store.loadFleet();
+
+  // Most recently active sessions revive first, so the ones the user was
+  // just working in come back before long-idle ones; entries that never
+  // reported an event keep their stored order at the end. Exited entries
+  // dedupe against every listed session, so repeated restores never double
+  // up the killed archive.
+  const entries = stored
+    .filter((entry) =>
+      entry.exited === true
+        ? !hasAnySession(entry.agentSessionID)
+        : !hasLiveSession(entry.agentSessionID),
+    )
+    .toSorted((a, b) =>
+      (recency.get(b.agentSessionID) ?? '').localeCompare(recency.get(a.agentSessionID) ?? ''),
+    );
+
+  // The whole fleet registers as terminal-less sessions up front, so the
+  // list shows every incoming session immediately instead of revealing them
+  // one boot at a time. Exited entries only register — they stay killed
+  // until revived by hand, so no terminal is adopted for them.
+  const registered = entries.map((entry) => mgr.restore(entry));
+  const queued = registered.filter((s) => s.state !== 'exited');
+
+  const adoptQueued = (s: Session): boolean => {
+    if (mgr.adoptTerminal(s.id, cols, rows) === null) {
+      return false;
+    }
+
+    const runtime = findRuntime(s.id);
+
+    if (runtime !== undefined) {
+      runtime.dims = { cols, rows };
+
+      runtime.screen ??= new ScreenModel(cols, rows);
+    }
+
+    return true;
+  };
+
+  const waitForBoot = (sessionID: SessionID): Promise<void> => {
+    const runtime = findRuntime(sessionID);
+
+    if (runtime === undefined) {
+      return Promise.resolve();
+    }
+
+    const settled = Promise.withResolvers<void>();
+    const timer = capMs > 0 ? setTimeout(settled.resolve, capMs) : undefined;
+
+    runtime.bootWaiter = settled.resolve;
+    runtime.bootTimer = timer;
+
+    return (async () => {
+      await settled.promise;
+
+      runtime.bootWaiter = null;
+
+      if (timer !== undefined) {
+        clearTimeout(timer);
+
+        runtime.bootTimer = undefined;
+      }
+    })();
+  };
+
+  const [first, ...rest] = queued;
+
+  if (first === undefined) {
+    return registered.length;
+  }
+
+  // The first terminal attaches synchronously so a caller can attach at
+  // once; each later one waits for the previous session to report it has
+  // booted, so a heavy fleet comes up one process at a time instead of all
+  // at once. A per-session cap keeps a session that never reports from
+  // stalling the rest.
+  const adoptRest = async (previous: Session | null) => {
+    let prev = previous;
+
+    for (const s of rest) {
+      if (prev !== null) {
+        await waitForBoot(prev.id);
+      }
+
+      prev = adoptQueued(s) ? s : null;
+    }
+  };
+
+  const firstBooted = adoptQueued(first) ? first : null;
+
+  void adoptRest(firstBooted);
+
+  return registered.length;
+}

package/src/daemon/run-eject-handoff.ts

@@ -0,0 +1,33 @@
+import type { SessionID } from '../shared/session-id';
+import type { SessionRuntime } from './session-runtime';
+
+export interface EjectHandoffParams {
+  readonly sessionID: SessionID;
+  readonly prompt: string;
+  readonly settleMs: number;
+  readonly runtime: SessionRuntime;
+  readonly startHeadlessTurn: (sessionID: SessionID, prompt: string) => boolean;
+}
+
+/**
+ * Waits for the ejected terminal's final report (or a settle timeout,
+ * whichever comes first) before starting the headless turn — resuming an
+ * agent session while its old process is still shutting down corrupts the
+ * handoff.
+ */
+export function runEjectHandoff(params: EjectHandoffParams): void {
+  const settled = Promise.withResolvers<void>();
+  const timer = setTimeout(settled.resolve, params.settleMs);
+
+  params.runtime.pendingEject = settled.resolve;
+
+  void (async () => {
+    await settled.promise;
+
+    clearTimeout(timer);
+
+    params.runtime.pendingEject = null;
+
+    params.startHeadlessTurn(params.sessionID, params.prompt);
+  })();
+}

package/src/{screen-model.ts → daemon/screen-model.ts}

@@ -1,6 +1,6 @@
 import { SerializeAddon } from '@xterm/addon-serialize';
 import { Terminal } from '@xterm/headless';
-import { RESET_INPUT_MODES } from './reset-input-modes';
+import { RESET_INPUT_MODES } from '../shared/reset-input-modes';
 
 // The serializer already re-emits the modes the vt engine models (mouse
 // tracking, bracketed paste, focus events); these are the ones it drops.

package/src/daemon/session-runtime.ts

@@ -0,0 +1,64 @@
+import type { Dims } from './attach-registry';
+import type { ScreenModel } from './screen-model';
+
+// The daemon's own bookkeeping for one live headless run: enough to stop it
+// on eject, kill, or session removal.
+interface HeadlessRunHandle {
+  readonly stop: () => void;
+}
+
+/**
+ * Everything the daemon tracks for one session: its screen model, output
+ * sequence counter, PTY dims, its resize/detect/boot timers, its live
+ * headless run, and its pending eject and boot waiters. `dispose` releases
+ * all of it in one call, and is safe to call more than once.
+ */
+export class SessionRuntime {
+  screen: ScreenModel | null = null;
+
+  seq = 0;
+
+  dims: Dims | null = null;
+
+  resizeTimer: ReturnType<typeof setTimeout> | undefined;
+
+  detectTimer: ReturnType<typeof setTimeout> | undefined;
+
+  bootTimer: ReturnType<typeof setTimeout> | undefined;
+
+  headlessRun: HeadlessRunHandle | null = null;
+
+  pendingEject: (() => void) | null = null;
+
+  bootWaiter: (() => void) | null = null;
+
+  // Whether a SessionStart hook is still owed for this session before its
+  // agent can be recorded as the last one used; a spawn sets it, the hook
+  // clears it, and a spawn that never reports leaves it stranded harmlessly.
+  pendingLastUsed = false;
+
+  dispose(): void {
+    clearTimeout(this.resizeTimer);
+    clearTimeout(this.detectTimer);
+    clearTimeout(this.bootTimer);
+
+    this.resizeTimer = undefined;
+    this.detectTimer = undefined;
+    this.bootTimer = undefined;
+    this.screen?.stop();
+    this.screen = null;
+
+    this.stopHeadlessRun();
+    this.pendingEject?.();
+    this.pendingEject = null;
+    this.bootWaiter?.();
+    this.bootWaiter = null;
+  }
+
+  // Ends the live headless run, if there is one, and forgets its handle so
+  // the session is free to start another.
+  stopHeadlessRun(): void {
+    this.headlessRun?.stop();
+    this.headlessRun = null;
+  }
+}