@zgeoff/atc 2.12.0 → 2.13.0

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

@@ -0,0 +1,85 @@
+/**
+ * One file in an archive: its path relative to the directory it unpacks
+ * into, its bytes, and its permission bits.
+ */
+export interface ArchiveFile {
+  readonly path: string;
+  readonly content: string | Uint8Array;
+  readonly mode?: number;
+}
+
+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.
+ */
+// oxlint-disable-next-line prefer-readonly-parameter-types -- file bytes have no readonly form
+export function buildTarArchive(files: readonly ArchiveFile[]): Uint8Array {
+  const encoder = new TextEncoder();
+
+  const blocks: Uint8Array[] = [];
+
+  for (const file of files) {
+    const content = typeof file.content === 'string' ? encoder.encode(file.content) : file.content;
+
+    blocks.push(
+      buildHeader(file.path, content.length, file.mode ?? 0o644),
+      content,
+      new Uint8Array((BLOCK - (content.length % BLOCK)) % BLOCK),
+    );
+  }
+
+  // Two empty blocks end the archive.
+  blocks.push(new Uint8Array(BLOCK * 2));
+
+  const archive = new Uint8Array(blocks.reduce((total, block) => total + block.length, 0));
+
+  let at = 0;
+
+  for (const block of blocks) {
+    archive.set(block, at);
+
+    at += block.length;
+  }
+
+  return archive;
+}
+
+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 header = new Uint8Array(BLOCK);
+
+  header.set(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);
+  header.set(encoder.encode(formatOctal(size, 12)), 124);
+  header.set(encoder.encode(formatOctal(0, 12)), 136);
+
+  // The checksum counts its own field as spaces.
+  header.set(encoder.encode('        '), 148);
+
+  header[156] = '0'.codePointAt(0) ?? 0;
+
+  header.set(encoder.encode('ustar\u000000'), 257);
+
+  const checksum = header.reduce((total, byte) => total + byte, 0);
+
+  header.set(encoder.encode(`${checksum.toString(8).padStart(6, '0')}\u0000 `), 148);
+
+  return header;
+}
+
+// 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

@@ -1,4 +1,4 @@
-import { basename } from 'node:path';
+import { basename, isAbsolute } from 'node:path';
 import type { AgentAdapter, AgentID, SpawnOptions, SpawnOverrides } from '../agents/agent-adapter';
 import { DaemonError } from '../protocol/daemon-error';
 import { DAEMON_FEATURES } from '../protocol/daemon-features';
@@ -15,6 +15,7 @@ import {
   encodeMessage,
 } from '../protocol/protocol';
 import type { ErrorCode, EventMsg, RequestMsg } from '../protocol/protocol';
+import type { SpawnWorkspaceSource } from '../protocol/request-param-schemas';
 import type { TargetConfigError } from '../shared/collect-targets';
 import type { DaemonID } from '../shared/daemon-id';
 import type { MessageID } from '../shared/message-id';
@@ -49,6 +50,10 @@ export interface SpawnParams {
   readonly parent: SessionID | null;
   readonly overrides: SpawnOverrides;
   readonly target: string;
+
+  // Where the session's working directory comes from; null runs the
+  // session in cwd as it stands.
+  readonly workspace: SpawnWorkspaceSource | null;
 }
 
 interface SessionRecord {
@@ -61,6 +66,15 @@ interface SessionRecord {
 
 // A transcript page with the file it came from, so a cursor into a replaced
 // transcript is distinguishable from one into a grown transcript.
+/**
+ * What `session.forget` answers: the token a forget that destroys a host
+ * must carry, with the time it stops being taken; or the forgotten session,
+ * with whether its host was destroyed.
+ */
+type ForgetResult =
+  | { readonly confirmToken: string; readonly expiresAt: number }
+  | { readonly forgotten: true; readonly destroyed: boolean };
+
 interface SessionTranscriptRead {
   readonly path: string;
   readonly page: TranscriptPage;
@@ -99,6 +113,10 @@ export interface DaemonContext {
   // without a target when the config gives no default.
   readonly resolveSpawnTarget: (requested: string | undefined) => string;
 
+  // Throws the refusal for a target that cannot materialize a workspace:
+  // one whose provider cannot both transfer an archive and run a command.
+  readonly requireWorkspaceTarget: (target: string) => void;
+
   // Runs the plan, which throws the refusal for a spawn it refuses, then
   // spawns. Answers with the `session.spawn` ok payload, which a keyed
   // retry replays as the first spawn answered it while the access, when
@@ -109,6 +127,13 @@ export interface DaemonContext {
     access: TargetAccess | null,
   ) => Promise<Readonly<Record<string, unknown>>>;
   readonly killSession: (id: SessionID) => Promise<boolean>;
+
+  // Forgets a session, or answers with the token a forget that destroys a
+  // host must carry. Throws the refusal for a token it does not take.
+  readonly forgetSession: (
+    id: SessionID,
+    confirmToken: string | undefined,
+  ) => Promise<ForgetResult | 'missing'>;
   readonly updateSession: (id: SessionID, name?: string, pinned?: boolean) => boolean | 'child_pin';
   readonly quitDaemon: () => void;
   readonly ackSession: (id: SessionID) => boolean;
@@ -127,6 +152,13 @@ export interface DaemonContext {
     sessionID: SessionID,
     data: string,
   ) => 'busy' | 'ok' | 'missing' | 'dead';
+
+  // Types a line into the session and submits it the way the session's
+  // agent accepts a line, as opposed to the raw bytes the input write takes.
+  readonly writeSessionLine: (
+    sessionID: SessionID,
+    text: string,
+  ) => 'busy' | 'ok' | 'missing' | 'dead';
   readonly ejectSession: (
     id: SessionID,
     prompt: string,
@@ -135,7 +167,7 @@ export interface DaemonContext {
     id: SessionID,
     cols: number,
     rows: number,
-  ) => 'ok' | 'missing' | 'no_transcript';
+  ) => Promise<'ok' | 'missing' | 'no_transcript'>;
   readonly resizeSession: (client: OutputClient, sessionID: SessionID, dims: Dims) => boolean;
   readonly resyncClient: (sessionID: SessionID, client: OutputClient) => Promise<void>;
   readonly queueBytes?: number;
@@ -551,6 +583,27 @@ export class DaemonConnection {
 
         return;
       }
+      case 'session.forget': {
+        const parsed = parseRequestParams('session.forget', req.p);
+
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
+
+          return;
+        }
+
+        const id = parsed.data.session;
+
+        const forgotten = await this.ctx.forgetSession(id, parsed.data.confirmToken);
+
+        if (forgotten === 'missing') {
+          this.sendErr(req.id, 'no_such_session', `no session '${id}'`);
+        } else {
+          this.sendOk(req.id, { ...forgotten });
+        }
+
+        return;
+      }
       case 'session.resumeCommand': {
         const parsed = parseRequestParams('session.resumeCommand', req.p);
 
@@ -636,7 +689,8 @@ export class DaemonConnection {
         }
 
         const sessionID = parsed.data.session;
-        const adoptResult = ctx.adoptSession(sessionID, parsed.data.cols, parsed.data.rows);
+
+        const adoptResult = await ctx.adoptSession(sessionID, parsed.data.cols, parsed.data.rows);
 
         if (adoptResult === 'ok') {
           this.sendOk(req.id, {});
@@ -680,6 +734,11 @@ export class DaemonConnection {
 
         return;
       }
+      case 'session.submit': {
+        this.applySubmit(req, ctx);
+
+        return;
+      }
       case 'session.resize': {
         this.applyResize(req, ctx);
 
@@ -787,6 +846,18 @@ export class DaemonConnection {
         throw new DaemonError(overrides.code, overrides.message);
       }
 
+      // Checked before the spawn starts, so a target that cannot take a
+      // workspace refuses it before any git command runs.
+      if (data.workspace !== undefined) {
+        this.ctx.requireWorkspaceTarget(target);
+      }
+
+      // A workspace is materialized at cwd on the target, which only an
+      // absolute path names.
+      if (data.workspace !== undefined && !isAbsolute(data.cwd)) {
+        throw new DaemonError('bad_args', 'a spawn with a workspace requires an absolute cwd');
+      }
+
       let parent: SessionID | null = null;
 
       if (data.parent !== undefined) {
@@ -813,6 +884,7 @@ export class DaemonConnection {
         parent,
         overrides: overrides.overrides,
         target,
+        workspace: data.workspace ?? null,
       };
     };
 
@@ -869,8 +941,29 @@ export class DaemonConnection {
     }
 
     const sessionID = parsed.data.session;
-    const result = ctx.writeSessionInput(sessionID, parsed.data.d);
 
+    this.sendInputResult(req, sessionID, ctx.writeSessionInput(sessionID, parsed.data.d));
+  }
+
+  private applySubmit(req: RequestMsg, ctx: DaemonContext): void {
+    const parsed = parseRequestParams('session.submit', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const sessionID = parsed.data.session;
+
+    this.sendInputResult(req, sessionID, ctx.writeSessionLine(sessionID, parsed.data.text));
+  }
+
+  private sendInputResult(
+    req: RequestMsg,
+    sessionID: SessionID,
+    result: 'busy' | 'ok' | 'missing' | 'dead',
+  ): void {
     if (result === 'missing') {
       this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);