@zgeoff/atc 3.1.0 → 3.1.1

package/package.json

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

package/src/daemon/restore-fleet.ts

@@ -80,13 +80,26 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<RestoreF
   // 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);
+  // A row that cannot be registered is logged and skipped, so one bad row
+  // never keeps the rest of the fleet down.
+  const registered: { session: Session; revive: boolean }[] = [];
 
-    return listed === undefined
-      ? { session: mgr.restore(entry), revive: false }
-      : { session: listed, revive: true };
-  });
+  for (const entry of entries) {
+    try {
+      const listed = mgr.sessions.find((s) => s.id === entry.sessionID);
+
+      const row =
+        listed === undefined
+          ? { session: mgr.restore(entry), revive: false }
+          : { session: listed, revive: true };
+
+      registered.push(row);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+
+      mgr.log(`atc could not restore session ${entry.sessionID} (${reason})`);
+    }
+  }
 
   const queued = registered
     .filter((r) => r.revive || r.session.state !== 'exited')

package/src/daemon/sessions.ts

@@ -535,6 +535,17 @@ export class SessionManager {
     }
   }
 
+  // An exited row never runs again until revived, and a row on a remote
+  // target holds a path from another machine, so neither resolves a
+  // repository on this one: the directory is its own root.
+  private pickRestoredRepoRoot(cwd: string, exited: boolean, target: string): string {
+    if (exited || this.targets.get(target)?.provider?.remote === true) {
+      return cwd;
+    }
+
+    return resolveRepoRoot(cwd);
+  }
+
   // Registers a fleet entry as a session with no terminal yet, under the
   // atc session id its row holds, so a fleet-wide restore can show every
   // incoming session at once; adopting it later attaches the terminal.
@@ -584,7 +595,7 @@ export class SessionManager {
       agent: entry.agent,
       pinned: entry.pinned ?? false,
       lastAttachedAt: entry.lastAttachedAt ?? Date.now(),
-      repoRoot: resolveRepoRoot(entry.cwd),
+      repoRoot: this.pickRestoredRepoRoot(entry.cwd, exited, target),
       namedBy: 'auto',
       createdAt: Date.now(),
       parent: parent !== null && this.sessions.some((s) => s.id === parent) ? parent : null,
@@ -757,6 +768,7 @@ export class SessionManager {
     s.kind = 'pty';
     s.state = 'running';
     s.lastMsg = 'revived';
+    s.repoRoot = provider.remote ? s.cwd : resolveRepoRoot(s.cwd);
     s.desired = 'run';
     s.suspended = false;
 
@@ -959,9 +971,8 @@ export class SessionManager {
       overrides.trustClonedWorkspace ??
       this.targets.get(target)?.options['trustClonedWorkspace'] === true;
 
-    // The repository root resolves before the process starts: resolving it
-    // can throw, and a spawn that throws must leave nothing running. A
-    // remote directory is not on the daemon's machine, so it is its own root.
+    // A remote directory is not on the daemon's machine, so it is its own
+    // root.
     const repoRoot = provider.remote ? cwd : resolveRepoRoot(cwd);
     const hostKey = this.pickHostKey(id, parent, target, execution.identity);
     const auth = this.resolveHarnessAuth(adapter, provider, target);

package/src/shared/resolve-repo-root.ts

@@ -1,3 +1,4 @@
+import type { Stats } from 'node:fs';
 import { readFileSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 
@@ -6,17 +7,33 @@ import { dirname, join } from 'node:path';
  * overlay. Walks toward the filesystem root looking for a `.git` entry: a
  * directory holding HEAD marks the repository root itself, and a linked
  * worktree's `.git` file points back at the main repository, so worktrees
- * cluster with it. A directory outside any repository resolves to itself.
+ * cluster with it. A directory outside any repository resolves to itself, and
+ * so does one whose path cannot be read: a filesystem error other than a
+ * missing entry ends the walk instead of throwing.
  */
 export function resolveRepoRoot(cwd: string): string {
   let dir = cwd;
 
   while (true) {
     const marker = join(dir, '.git');
-    const stat = statSync(marker, { throwIfNoEntry: false });
+    const stat = tryStat(marker);
 
-    if (stat !== undefined && stat.isDirectory() && hasGitHead(marker)) {
-      return dir;
+    if (stat === null) {
+      return cwd;
+    }
+
+    if (stat !== undefined && stat.isDirectory()) {
+      // git needs HEAD in a repository, and an empty `.git` directory in a shared
+      // temporary directory would otherwise cluster every session under it.
+      const head = tryStat(join(marker, 'HEAD'));
+
+      if (head === null) {
+        return cwd;
+      }
+
+      if (head !== undefined) {
+        return dir;
+      }
     }
 
     if (stat !== undefined && stat.isFile()) {
@@ -33,13 +50,14 @@ export function resolveRepoRoot(cwd: string): string {
   }
 }
 
-/**
- * Whether a `.git` directory is a repository rather than an empty directory
- * that happens to carry the name. git needs HEAD in one, and a stray `.git` in
- * a shared temporary directory would otherwise cluster every session under it.
- */
-function hasGitHead(marker: string): boolean {
-  return statSync(join(marker, 'HEAD'), { throwIfNoEntry: false }) !== undefined;
+// The stat of a path: undefined when nothing is there, null when the path
+// cannot be read at all.
+function tryStat(path: string): Stats | undefined | null {
+  try {
+    return statSync(path, { throwIfNoEntry: false });
+  } catch {
+    return null;
+  }
 }
 
 // A linked worktree's `.git` file reads `gitdir: <main>/.git/worktrees/<name>`.