@zgeoff/atc 2.33.0 → 2.35.0

package/src/client/spawn-picker.ts

@@ -1,6 +1,8 @@
 import { homedir } from 'node:os';
 import { DaemonError } from '../protocol/daemon-error';
+import type { DaemonFeature } from '../protocol/daemon-features';
 import type { AgentID } from '../shared/agent-id';
+import { buildWorkspaceDestination } from '../shared/build-workspace-destination';
 import type { WorkspacesConfig } from '../shared/collect-workspaces-config';
 import { collectZoxideDirs } from '../shared/collect-zoxide-dirs';
 import { loadConfig } from '../shared/config';
@@ -8,7 +10,6 @@ import { DEFAULT_GIT_TRANSPORTS } from '../shared/default-git-transports';
 import { isGitURL } from '../shared/is-git-url';
 import { isRecord } from '../shared/report';
 import { resolveHomeDir } from '../shared/resolve-home-dir';
-import { buildWorkspaceDestination } from './build-workspace-destination';
 import { collectAgentPicks } from './collect-agent-picks';
 import type { AgentPick } from './collect-agent-picks';
 import { collectPathCompletions } from './collect-path-completions';
@@ -48,6 +49,7 @@ export interface SpawnPickerDeps<TMirror> {
   readonly attach: (sessionID: string) => Promise<void>;
   readonly toMirrorSession: (value: unknown) => TMirror | null;
   readonly upsertMirror: (session: Readonly<TMirror>) => void;
+  readonly hasDaemonFeature: (feature: DaemonFeature) => boolean;
 }
 
 // One source `agents.list` returned, in the order the daemon offers them.
@@ -100,6 +102,9 @@ interface ChosenRef {
   readonly sha: string;
 }
 
+// The root the daemon picks a destination under on a remote target without
+// a configured one, as the confirm screen shows it.
+const AUTO_ROOT = '~/.local/share/atc/workspaces';
 const FULL_SHA_PATTERN = /^(?:[\da-f]{40}|[\da-f]{64})$/u;
 const SHORT_SHA_PATTERN = /^[\da-f]{7,63}$/u;
 
@@ -236,6 +241,11 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
   // The repository the destination was built or typed for.
   private destinationRepoURL: string | null = null;
 
+  // The directory the daemon picks on the target when the confirm screen
+  // has no destination it can build, under the target user's home as the
+  // screen shows it, or null when the spawn gives its own.
+  private autoDestination: string | null = null;
+
   private name = '';
 
   private resume = false;
@@ -291,6 +301,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.destination = '';
     this.destinationEdited = false;
     this.destinationRepoURL = null;
+    this.autoDestination = null;
 
     // A last-used agent that is no longer installed is not in the menu, so
     // the selection falls to the first one that is.
@@ -462,7 +473,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
         items: [],
         selected: -1,
         input: this.input,
-        placeholder: formatDirName(this.dir),
+        placeholder: formatDirName(this.autoDestination ?? this.dir),
         hint: this.refusal ?? `session name for ${where} · ⏎ accept · esc back`,
       });
     } else {
@@ -607,7 +618,10 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       ],
       selected: -1,
       input: this.input,
-      placeholder: 'destination on the target',
+      placeholder:
+        this.autoDestination === null
+          ? 'destination on the target'
+          : 'picked on the target · or type an absolute path',
       hint: this.refusal ?? 'destination on the target · ⏎ continue · esc back',
     });
   }
@@ -1584,6 +1598,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
   private openConfirmStep() {
     this.step = 'confirm';
     this.destinationAttempt = 1;
+    this.autoDestination = null;
 
     if (this.destination === '' && this.repo !== null && this.ref !== null) {
       const target = this.findEffectiveTarget();
@@ -1602,6 +1617,13 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
           ref: this.ref.ref,
           sha: this.ref.sha,
         });
+      } else if (target !== null && !target.inPlace && this.canPickOnTarget(target.id)) {
+        this.autoDestination = buildWorkspaceDestination({
+          root: this.workspaces.targetRoots.get(target.id) ?? this.workspaces.root ?? AUTO_ROOT,
+          url: this.repo.url,
+          ref: this.ref.ref,
+          sha: this.ref.sha,
+        });
       } else {
         this.refusal = root.message;
       }
@@ -1610,10 +1632,30 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.input = this.buildDestination();
   }
 
+  // Whether the daemon picks the destination on a remote target: it must
+  // take a git workspace without a directory, and the target's configured
+  // root, if any, must be one it resolves there, under the home.
+  private canPickOnTarget(target: string): boolean {
+    const configured = this.workspaces.targetRoots.get(target) ?? this.workspaces.root;
+
+    return (
+      this.deps.hasDaemonFeature('spawn.workspace.autoDir') &&
+      (configured === null || configured === '~' || configured.startsWith('~/'))
+    );
+  }
+
   // Takes the confirm screen's destination: absolute on its target, with a
   // leading `~` expanded only on the daemon's own machine. False, with the
   // reason shown, when the target cannot take it.
   private applyDestination(typed: string): boolean {
+    // An empty destination takes the one the daemon picks on the target.
+    if (typed === '' && this.autoDestination !== null) {
+      this.destinationRepoURL = this.repo?.url ?? null;
+      this.dir = '';
+
+      return true;
+    }
+
     const inPlace = this.findEffectiveTarget()?.inPlace ?? true;
 
     const dir =
@@ -1635,6 +1677,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       this.destinationEdited = true;
     }
 
+    this.autoDestination = null;
     this.destinationRepoURL = this.repo?.url ?? null;
     this.dir = this.buildDestination();
 
@@ -1649,7 +1692,11 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
   }
 
   private formatDestination(): string {
-    return `${this.findEffectiveTarget()?.id ?? 'local'}:${this.buildDestination()}`;
+    const target = this.findEffectiveTarget()?.id ?? 'local';
+
+    return this.autoDestination === null
+      ? `${target}:${this.buildDestination()}`
+      : `${target}:${this.autoDestination}`;
   }
 
   // The target the spawn runs on: the chosen one, else the daemon's
@@ -1792,7 +1839,7 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
   private async spawn(prompt: string) {
     const params = {
-      cwd: this.dir,
+      ...(this.isGitFlow() && this.autoDestination !== null ? {} : { cwd: this.dir }),
       name: this.name,
       prompt,
       cols: cols(),
@@ -1885,7 +1932,12 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       return;
     }
 
-    if (step === 'destination') {
+    if (step === 'destination' && this.autoDestination !== null) {
+      // The daemon already tried the numbered directories beside its pick.
+      this.step = 'confirm';
+      this.input = '';
+      this.refusal = `${reason} · esc back`;
+    } else if (step === 'destination') {
       this.destinationAttempt += 1;
       this.step = 'confirm';
       this.input = this.buildDestination();

package/src/daemon/build-default-workspace-dir.ts

@@ -0,0 +1,70 @@
+import { posix } from 'node:path';
+import { DaemonError } from '../protocol/daemon-error';
+import type { SpawnWorkspaceSource } from '../protocol/request-param-schemas';
+import { buildWorkspaceDestination } from '../shared/build-workspace-destination';
+
+type GitWorkspaceSource = Extract<SpawnWorkspaceSource, { kind: 'git' }>;
+
+interface DefaultDirTarget {
+  // The workspaces root the config sets for the target, else the global
+  // one, else null for the default.
+  readonly root: string | null;
+
+  // Whether the target runs on another machine, whose home only that
+  // machine knows.
+  readonly remote: boolean;
+
+  // The home directory of the daemon's own user.
+  readonly home: string;
+}
+
+// Where checkouts land without a configured root, under the target user's
+// home.
+const DEFAULT_ROOT = '~/.local/share/atc/workspaces';
+
+/**
+ * The directory a git workspace lands in when the spawn gives none:
+ * `<root>/<repo>-<ref>-<short sha>`, with the root the config sets, else
+ * `~/.local/share/atc/workspaces`. A root under `~` resolves on the
+ * target: against the daemon user's home on the daemon's own machine, and
+ * on a remote target as a path relative to the target user's home, which
+ * the host resolves, since only that host knows its home. Any other root
+ * must be absolute.
+ */
+export function buildDefaultWorkspaceDir(
+  source: GitWorkspaceSource,
+  target: DefaultDirTarget,
+): string {
+  const configured = target.root ?? DEFAULT_ROOT;
+
+  const parts = {
+    url: source.url,
+    ref: source.ref ?? null,
+    sha: source.sha ?? null,
+  };
+
+  if (configured.startsWith('/')) {
+    return buildWorkspaceDestination({ root: posix.normalize(configured), ...parts });
+  }
+
+  if (configured !== '~' && !configured.startsWith('~/')) {
+    throw new DaemonError(
+      'bad_args',
+      `workspaces root '${configured}' must be an absolute path or start with ~/`,
+    );
+  }
+
+  const normalized = posix.normalize(`./${configured.slice(1)}`);
+  const underHome = normalized === './' || normalized === '.' ? '' : normalized;
+
+  if (underHome === '..' || underHome.startsWith('../')) {
+    throw new DaemonError(
+      'bad_args',
+      `workspaces root '${configured}' must stay under the home directory`,
+    );
+  }
+
+  return target.remote
+    ? buildWorkspaceDestination({ root: underHome, ...parts })
+    : buildWorkspaceDestination({ root: posix.join(target.home, underHome), ...parts });
+}

package/src/daemon/build-tar-archive.ts

@@ -12,8 +12,9 @@ const BLOCK = 512;
 
 /**
  * Packs files into a POSIX ustar archive that `tar -x` unpacks, each with
- * its parent directories created on the way. A path longer than ustar
- * holds is refused.
+ * its parent directories created on the way. A path longer than 100 bytes
+ * splits at a slash into ustar's prefix and name fields, and a path that
+ * fits no such split is refused.
  */
 // oxlint-disable-next-line prefer-readonly-parameter-types -- file bytes have no readonly form
 export function buildTarArchive(files: readonly ArchiveFile[]): Uint8Array {
@@ -50,15 +51,11 @@ export function buildTarArchive(files: readonly ArchiveFile[]): Uint8Array {
 function buildHeader(path: string, size: number, mode: number): Uint8Array {
   const encoder = new TextEncoder();
 
-  const name = encoder.encode(path);
-
-  if (name.length > 100) {
-    throw new Error(`archive path is longer than 100 bytes: ${path}`);
-  }
+  const split = splitArchivePath(path);
 
   const header = new Uint8Array(BLOCK);
 
-  header.set(name, 0);
+  header.set(encoder.encode(split.name), 0);
   header.set(encoder.encode(formatOctal(mode, 8)), 100);
   header.set(encoder.encode(formatOctal(0, 8)), 108);
   header.set(encoder.encode(formatOctal(0, 8)), 116);
@@ -71,6 +68,7 @@ function buildHeader(path: string, size: number, mode: number): Uint8Array {
   header[156] = '0'.codePointAt(0) ?? 0;
 
   header.set(encoder.encode('ustar\u000000'), 257);
+  header.set(encoder.encode(split.prefix), 345);
 
   const checksum = header.reduce((total, byte) => total + byte, 0);
 
@@ -79,6 +77,33 @@ function buildHeader(path: string, size: number, mode: number): Uint8Array {
   return header;
 }
 
+const NAME_BYTES = 100;
+const PREFIX_BYTES = 155;
+
+// The ustar fields a path fills: the whole path as the name when it fits,
+// otherwise the part before the last slash that leaves a name short enough,
+// with that slash dropped, as the prefix.
+function splitArchivePath(path: string): { readonly prefix: string; readonly name: string } {
+  if (countBytes(path) <= NAME_BYTES) {
+    return { prefix: '', name: path };
+  }
+
+  for (let at = path.indexOf('/'); at !== -1; at = path.indexOf('/', at + 1)) {
+    const prefix = path.slice(0, at);
+    const name = path.slice(at + 1);
+
+    if (countBytes(prefix) <= PREFIX_BYTES && countBytes(name) <= NAME_BYTES && name !== '') {
+      return { prefix, name };
+    }
+  }
+
+  throw new Error(`archive path does not fit a ustar header: ${path}`);
+}
+
+function countBytes(text: string): number {
+  return new TextEncoder().encode(text).length;
+}
+
 // An octal number padded to fill its field, ending in a NUL.
 function formatOctal(value: number, width: number): string {
   return `${value.toString(8).padStart(width - 1, '0')}\u0000`;

package/src/daemon/daemon-connection.ts

@@ -926,6 +926,13 @@ export class DaemonConnection {
     }
 
     const data = parsed.data;
+    const cwd = data.cwd;
+
+    if (cwd === undefined && data.workspace?.kind !== 'git') {
+      this.sendErr(req.id, 'bad_args', 'session.spawn requires a cwd');
+
+      return;
+    }
 
     // Every refusal is thrown from the plan, which runs only once a key is
     // claimed: a retry of a held key answers from the key without checking
@@ -972,16 +979,28 @@ export class DaemonConnection {
         ctx.requireWorkspaceTarget(target);
       }
 
+      // A git workspace without a cwd lands where the daemon picks on the
+      // target.
+      const dir =
+        cwd === undefined && data.workspace?.kind === 'git'
+          ? ctx.buildDefaultWorkspaceDir(target, data.workspace)
+          : cwd;
+
+      if (dir === undefined) {
+        throw new DaemonError('bad_args', 'session.spawn requires a cwd');
+      }
+
       // A workspace is materialized at cwd on the target, which only an
-      // absolute path names.
-      if (data.workspace !== undefined && !isAbsolute(data.cwd)) {
+      // absolute path names; a directory the daemon picks on a remote
+      // target is relative to the home there, which the host resolves.
+      if (data.workspace !== undefined && cwd !== undefined && !isAbsolute(cwd)) {
         throw new DaemonError('bad_args', 'a spawn with a workspace requires an absolute cwd');
       }
 
       // A workspace is created, filled, and removed at the one directory
       // the host resolves cwd to, which a dot segment or a control
       // character would make differ from the path as written.
-      if (data.workspace !== undefined && !isPlainWorkspaceDir(data.cwd)) {
+      if (data.workspace !== undefined && !isPlainWorkspaceDir(dir)) {
         throw new DaemonError(
           'bad_args',
           'a spawn with a workspace requires a cwd without . or .. segments or control characters',
@@ -1001,8 +1020,8 @@ export class DaemonConnection {
       }
 
       return {
-        cwd: data.cwd,
-        name: data.name === '' ? basename(data.cwd) : data.name,
+        cwd: dir,
+        name: data.name === '' ? basename(dir) : data.name,
         prompt: data.prompt,
         cols: data.cols,
         rows: data.rows,
@@ -1015,9 +1034,13 @@ export class DaemonConnection {
           ...(data.trustClonedWorkspace === undefined
             ? {}
             : { trustClonedWorkspace: data.trustClonedWorkspace }),
+          ...(data.resumeInterruptedTurns === undefined
+            ? {}
+            : { resumeInterruptedTurns: data.resumeInterruptedTurns }),
         },
         target,
         workspace: data.workspace ?? null,
+        autoDir: cwd === undefined,
       };
     };
 

package/src/daemon/daemon-context.ts

@@ -39,6 +39,11 @@ export interface SpawnParams {
   // Where the session's working directory comes from; null runs the
   // session in cwd as it stands.
   readonly workspace: SpawnWorkspaceSource | null;
+
+  // Whether the daemon picked cwd for a git workspace the spawn gave no
+  // directory for, so a held directory moves the spawn to a numbered one
+  // beside it.
+  readonly autoDir: boolean;
 }
 
 interface SessionRecord {
@@ -180,6 +185,14 @@ export interface DaemonContext {
   // one whose provider cannot both transfer an archive and run a command.
   readonly requireWorkspaceTarget: (target: string) => void;
 
+  // The directory a git workspace lands in on a target when the spawn
+  // gives none: absolute on the daemon's own machine, and relative to the
+  // target user's home on a remote target.
+  readonly buildDefaultWorkspaceDir: (
+    target: string,
+    source: Extract<SpawnWorkspaceSource, { kind: 'git' }>,
+  ) => string;
+
   // Throws the refusal for an agent that takes its credential from impd's
   // broker on a target whose provider reaches no broker.
   readonly requireAgentTarget: (agent: AgentID, target: string) => void;

package/src/daemon/daemon.ts

@@ -18,6 +18,7 @@ import { DEFAULT_GIT_TRANSPORTS } from '../shared/default-git-transports';
 import { findDaemonRecord } from '../shared/find-daemon-record';
 import type { MessageID } from '../shared/message-id';
 import { isRecord } from '../shared/report';
+import { resolveHomeDir } from '../shared/resolve-home-dir';
 import type { SessionID } from '../shared/session-id';
 import { toMessageID } from '../shared/to-message-id';
 import { truncateToBytes } from '../shared/truncate-to-bytes';
@@ -34,6 +35,7 @@ import { ANSWER_BYTE_CAP } from './answer-byte-cap';
 import { AttachRegistry } from './attach-registry';
 import { buildAgentList } from './build-agent-list';
 import { buildConfigRevision } from './build-config-revision';
+import { buildDefaultWorkspaceDir } from './build-default-workspace-dir';
 import { buildExecutionTargets } from './build-execution-targets';
 import type { ExecutionTarget } from './build-execution-targets';
 import { buildFleetEvents } from './build-fleet-events';
@@ -155,6 +157,11 @@ export interface DaemonOptions {
   readonly restoreBootTimeoutMs?: number;
   readonly tapGraceMs?: number;
 
+  // Whether a fleet restore sends a session that was mid-turn when the
+  // previous daemon stopped one message to carry on, for a session spawned
+  // without its own choice; off when unset.
+  readonly resumeInterruptedTurns?: boolean;
+
   // How long a confirm token from `session.forget` stays usable.
   readonly forgetConfirmMs?: number;
 
@@ -178,6 +185,14 @@ export interface DaemonOptions {
   // or the invalid list the config holds, which refuses every git
   // operation; https and ssh when unset.
   readonly gitTransports?: readonly string[] | InvalidGitTransports;
+
+  // The root a git workspace without a directory lands under on any target
+  // without its own, and each target's own root, by target id; the default
+  // root under the target user's home when unset.
+  readonly workspaceRoots?: Readonly<{
+    root: string | null;
+    targetRoots: ReadonlyMap<string, string>;
+  }>;
 }
 
 // The TCP listener's address and the file holding the tokens a handshake
@@ -271,6 +286,11 @@ const LOCK_WAIT_MS = 2000;
  * because transports guarantee byte integrity and such a line means a buggy
  * or hostile peer.
  */
+// The sender and opening of the message a restore sends a session whose
+// turn the previous daemon's stop cut off.
+const RESUME_SENDER = 'atc';
+const RESUME_LEAD = 'atc restarted the daemon';
+
 export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
   let stopDaemon: (() => Promise<void>) | null = null;
 
@@ -962,7 +982,9 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
         ? null
         : async (
             host: Readonly<{
-              readyHost: () => Promise<{ readonly host: SessionID; readonly dir: string }>;
+              readyHost: (
+                attempt: number,
+              ) => Promise<{ readonly host: SessionID; readonly dir: string }>;
               removeClaim: (dir: string) => Promise<boolean>;
             }>,
             targetIdentity: string,
@@ -1013,7 +1035,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     id: SessionID,
     source: SpawnWorkspaceSource,
     host: Readonly<{
-      readyHost: () => Promise<{ readonly host: SessionID; readonly dir: string }>;
+      readyHost: (attempt: number) => Promise<{ readonly host: SessionID; readonly dir: string }>;
       removeClaim: (dir: string) => Promise<boolean>;
     }>,
     targetIdentity: string,
@@ -1028,6 +1050,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
         dir: p.cwd,
         source,
         inPlace: bound.provider.kind === 'local-pty',
+        autoDir: p.autoDir,
       },
       {
         requireProvider: (capability) => mgr.requireExecution(binding, capability).provider,
@@ -1049,7 +1072,9 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     materialize:
       | ((
           host: Readonly<{
-            readyHost: () => Promise<{ readonly host: SessionID; readonly dir: string }>;
+            readyHost: (
+              attempt: number,
+            ) => Promise<{ readonly host: SessionID; readonly dir: string }>;
             removeClaim: (dir: string) => Promise<boolean>;
           }>,
           targetIdentity: string,
@@ -1075,6 +1100,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       p.target,
       materialize,
       requireInReach,
+      p.autoDir,
     );
 
     const runtime = runtimes.get(s.id);
@@ -1083,7 +1109,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       runtime.pendingLastUsed = true;
     }
 
-    void store.recordSpawnDir(p.cwd, { target: s.target, targetIdentity: s.targetIdentity });
+    void store.recordSpawnDir(s.cwd, { target: s.target, targetIdentity: s.targetIdentity });
 
     return getDescriptor(mgr, s.id);
   };
@@ -1292,6 +1318,37 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     return record;
   };
 
+  const startedAt = new Date().toISOString();
+
+  // Sends a restored session the message that carries on a turn the
+  // previous daemon's stop cut off. A resume message still pending from an
+  // earlier restart covers this one, so a session never holds two.
+  const sendResumeMessage = async (s: Session): Promise<void> => {
+    const pending = await store.collectPendingMessages(buildMessageOwner(s));
+
+    if (
+      pending.some((record) => record.from === RESUME_SENDER && record.text.startsWith(RESUME_LEAD))
+    ) {
+      return;
+    }
+
+    const refusal = findMessageRefusal(s.id);
+
+    if (refusal !== null) {
+      mgr.log(`atc sent session ${s.id} no resume message (${refusal})`);
+
+      return;
+    }
+
+    await writeAcceptedMessage(
+      s.id,
+      RESUME_SENDER,
+      `${RESUME_LEAD} at ${startedAt}; your last turn was interrupted. Check the state of anything you had in flight, then continue.`,
+      mintMessageID(),
+      () => {},
+    );
+  };
+
   // A retried send answers with the message's current status, so a caller
   // that lost the first answer learns where its message stands now.
   const loadMessageReplay = async (
@@ -1405,6 +1462,12 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       mgr.requireExecution({ target, targetIdentity: null }, 'transfer');
       mgr.requireExecution({ target, targetIdentity: null }, 'run');
     },
+    buildDefaultWorkspaceDir: (target, source) =>
+      buildDefaultWorkspaceDir(source, {
+        root: opts.workspaceRoots?.targetRoots.get(target) ?? opts.workspaceRoots?.root ?? null,
+        remote: mgr.requireExecution({ target, targetIdentity: null }, 'run').provider.remote,
+        home: resolveHomeDir(),
+      }),
     requireAgentTarget: (agent, target) => {
       mgr.requireAgentTarget(agent, target);
     },
@@ -1754,7 +1817,16 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       attachments.findEffectiveDims(sessionID) ??
       runtimes.get(sessionID)?.dims ?? { cols: 80, rows: 24 },
     restoreFleet: (cols, rows) =>
-      restoreFleet({ mgr, store, findRuntime, cols, rows, capMs: opts.restoreBootTimeoutMs ?? 0 }),
+      restoreFleet({
+        mgr,
+        store,
+        findRuntime,
+        cols,
+        rows,
+        capMs: opts.restoreBootTimeoutMs ?? 0,
+        resumeInterruptedTurns: opts.resumeInterruptedTurns ?? false,
+        sendResumeMessage,
+      }),
     readSessionRecord: async (id, access) => {
       const s = mgr.sessions.find((x) => x.id === id);