@zgeoff/atc 2.10.4 → 2.12.0

package/src/daemon/restore-fleet.ts

@@ -1,5 +1,6 @@
-import type { AgentSessionID } from '../shared/agent-session-id';
+import { DaemonError } from '../protocol/daemon-error';
 import type { SessionID } from '../shared/session-id';
+import type { FleetEntry } from '../store/fleet-entry';
 import type { StateStore } from '../store/state-store';
 import { ScreenModel } from './screen-model';
 import type { SessionRuntime } from './session-runtime';
@@ -33,15 +34,17 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   const rows = params.rows;
   const capMs = params.capMs;
 
-  const hasLiveSession = (agentSessionID: AgentSessionID) =>
+  const hasLiveSession = (entry: FleetEntry) =>
     mgr.sessions.some(
       (s) =>
-        s.agentSessionID === agentSessionID &&
+        isSameSession(s, entry) &&
         (s.pty !== null || (s.kind === 'headless' && s.state !== 'exited')),
     );
 
-  const hasAnySession = (agentSessionID: AgentSessionID) =>
-    mgr.sessions.some((s) => s.agentSessionID === agentSessionID);
+  const hasAnySession = (entry: FleetEntry) => mgr.sessions.some((s) => isSameSession(s, entry));
+
+  const findRecency = (entry: FleetEntry) =>
+    entry.agentSessionID === undefined ? '' : (recency.get(entry.agentSessionID) ?? '');
 
   const recency = await store.collectFleetRecency();
   const stored = await store.loadFleet();
@@ -52,14 +55,8 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   // dedupe against every listed session, so repeated restores never double
   // up the killed archive.
   const kept = stored
-    .filter((entry) =>
-      entry.exited === true
-        ? !hasAnySession(entry.agentSessionID)
-        : !hasLiveSession(entry.agentSessionID),
-    )
-    .toSorted((a, b) =>
-      (recency.get(b.agentSessionID) ?? '').localeCompare(recency.get(a.agentSessionID) ?? ''),
-    );
+    .filter((entry) => (entry.exited === true ? !hasAnySession(entry) : !hasLiveSession(entry)))
+    .toSorted((a, b) => findRecency(b).localeCompare(findRecency(a)));
 
   // Sub-sessions register after every top-level entry, so each one links
   // to a parent that is already listed; the wrangling session also boots
@@ -72,19 +69,32 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   // 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');
-
+  // until revived by hand, so no terminal is adopted for them. An entry
+  // whose session is still listed, dead, revives that session in place
+  // rather than listing a second session under the same id.
+  const registered = entries.map((entry) => {
+    const listed = mgr.sessions.find((s) => s.id === entry.sessionID);
+
+    return listed === undefined
+      ? { session: mgr.restore(entry), revive: false }
+      : { session: listed, revive: true };
+  });
+
+  const queued = registered
+    .filter((r) => r.revive || r.session.state !== 'exited')
+    .map((r) => r.session);
+
+  // A session whose target refuses to start a terminal stays listed without
+  // one, and the restore moves on to the next.
   const adoptQueued = (s: Session): boolean => {
-    if (mgr.adoptTerminal(s.id, cols, rows) === null) {
+    if (tryAdoptTerminal(mgr, s.id, cols, rows) === null) {
       return false;
     }
 
     const runtime = findRuntime(s.id);
 
     if (runtime !== undefined) {
-      runtime.dims = { cols, rows };
+      runtime.resetBoot({ cols, rows });
 
       runtime.screen ??= new ScreenModel(cols, rows);
     }
@@ -147,3 +157,40 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
 
   return registered.length;
 }
+
+// A stored entry matches a listed session by its atc session id, or by its
+// agent session id when a listed session resumed the same agent session.
+function isSameSession(s: Session, entry: FleetEntry): boolean {
+  return (
+    s.id === entry.sessionID ||
+    (entry.agentSessionID !== undefined && s.agentSessionID === entry.agentSessionID)
+  );
+}
+
+// The refusals that leave one session without a terminal: its target is
+// misconfigured, gone from the config, changed, has no provider here, or
+// cannot start a terminal.
+const REFUSED_ADOPT_CODES: ReadonlySet<string> = new Set([
+  'unsupported_operation',
+  'unknown_target',
+  'target_unavailable',
+  'target_changed',
+  'target_config_invalid',
+]);
+
+function tryAdoptTerminal(
+  mgr: SessionManager,
+  id: SessionID,
+  cols: number,
+  rows: number,
+): Session | null {
+  try {
+    return mgr.adoptTerminal(id, cols, rows);
+  } catch (error) {
+    if (error instanceof DaemonError && REFUSED_ADOPT_CODES.has(error.code)) {
+      return null;
+    }
+
+    throw error;
+  }
+}

package/src/daemon/session-runtime.ts

@@ -46,6 +46,16 @@ export class SessionRuntime {
   // later dropped may be restarting, so it keeps the inbox open.
   tapAttached = false;
 
+  // Returns the boot-scoped state to how a fresh terminal starts, at the
+  // dims it boots with: no SessionStart yet and no tap since. Every path
+  // that boots a new terminal for an existing session runs it, so a revived
+  // session never inherits its previous process's message gate.
+  resetBoot(dims: Dims): void {
+    this.dims = dims;
+    this.startedAt = null;
+    this.tapAttached = false;
+  }
+
   dispose(): void {
     clearTimeout(this.resizeTimer);
     clearTimeout(this.detectTimer);