tinker-agent 2.9.0 → 2.11.0

package/src/remote/service.ts

@@ -0,0 +1,219 @@
+import { randomUUID } from "node:crypto";
+import { createUuidV7 } from "../ids/uuid-v7";
+import { parseSessionId } from "../ids/runtime-id";
+import { SessionCatalog } from "../session/session-catalog";
+import {
+  HostedSession,
+  type HostedRuntimeFactory,
+} from "../agent/runtime-hosted-session";
+import type { RemoteWorkspaceConfig } from "./config";
+import { RemoteServiceStore, type ManagedSessionRecord } from "./service-store";
+import {
+  RemoteError,
+  type RemoteOperationInput,
+  type OperationReceipt,
+  type RemoteSessionInfo,
+} from "./protocol";
+
+export class RemoteService {
+  readonly epoch = randomUUID();
+  private readonly hosted = new Map<string, HostedSession>();
+  private submitting: Promise<void> = Promise.resolve();
+  private stopping = false;
+  constructor(
+    readonly store: RemoteServiceStore,
+    readonly workspaces: readonly RemoteWorkspaceConfig[],
+    private readonly factory: HostedRuntimeFactory,
+    private readonly homeRoot?: string,
+  ) {}
+
+  async initialize(): Promise<void> {
+    // Reacquire every managed canonical lease; no prompt is resubmitted on boot.
+    for (const record of this.store.sessions()) {
+      if (!record.initialized) continue;
+      try {
+        await this.session(record.id).open();
+      } catch {
+        /* A failed workspace/session remains visible with its error. */
+      }
+    }
+  }
+  workspace(id: string): RemoteWorkspaceConfig {
+    const workspace = this.workspaces.find((workspace) => workspace.id === id);
+    if (!workspace)
+      throw new RemoteError(
+        404,
+        "WORKSPACE_NOT_FOUND",
+        "This workspace is not configured on the Mac.",
+      );
+    return workspace;
+  }
+  session(id: string): HostedSession {
+    const existing = this.hosted.get(id);
+    if (existing) return existing;
+    const record = this.store.session(id);
+    if (!record)
+      throw new RemoteError(
+        404,
+        "SESSION_NOT_MANAGED",
+        "Attach this local session before connecting to it.",
+      );
+    const workspace = this.workspace(record.workspaceId);
+    if (record.workspacePath !== workspace.path)
+      throw new RemoteError(
+        409,
+        "WORKSPACE_CHANGED",
+        "The managed session belongs to a different workspace path.",
+      );
+    const hosted = new HostedSession(record, this.store, this.epoch, this.factory);
+    this.hosted.set(id, hosted);
+    return hosted;
+  }
+  async listSessions(workspaceId: string): Promise<RemoteSessionInfo[]> {
+    const workspace = this.workspace(workspaceId);
+    const local = await new SessionCatalog({
+      workspaceRoot: workspace.path,
+      homeRoot: this.homeRoot,
+    }).listAll();
+    const managed = this.store
+      .sessions()
+      .filter((record) => record.workspaceId === workspaceId);
+    return [
+      ...managed.map((record) => {
+        const view = this.hosted.get(record.id)?.view();
+        return (
+          view?.session ?? {
+            id: record.id,
+            workspaceId,
+            title: record.title,
+            modelName: record.modelName,
+            owner: "service" as const,
+            status: record.initialized ? "idle" : "interrupted",
+            updatedAt: record.updatedAt,
+          }
+        );
+      }),
+      ...local
+        .filter((summary) => !managed.some((record) => record.id === summary.sessionId))
+        .map((summary) => ({
+          id: summary.sessionId,
+          workspaceId,
+          title: summary.firstUserPromptPreview ?? "Empty session",
+          modelName: summary.modelName,
+          owner: "local" as const,
+          status: summary.status,
+          updatedAt: summary.updatedAt,
+        })),
+    ].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+
+  submit(input: RemoteOperationInput, device: string): Promise<OperationReceipt> {
+    // Serializes acceptance and any async catalog lookup, never task execution.
+    const result = this.submitting.then(() => this.accept(input, device));
+    this.submitting = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    return result;
+  }
+  private async accept(
+    input: RemoteOperationInput,
+    device: string,
+  ): Promise<OperationReceipt> {
+    const existing = this.store.existing(input, device);
+    if (existing) return existing;
+    if (this.stopping)
+      throw new RemoteError(503, "SERVICE_STOPPING", "The local service is stopping.");
+    if (input.kind === "create" || input.kind === "adopt") {
+      const workspace = this.workspace(input.workspaceId);
+      const id = input.kind === "create" ? createUuidV7() : input.sessionId;
+      if (this.store.sessions().length >= 128)
+        throw new RemoteError(
+          409,
+          "SESSION_LIMIT",
+          "The service has reached its 128 managed session limit.",
+        );
+      let record: ManagedSessionRecord;
+      if (input.kind === "adopt") {
+        if (this.store.session(id))
+          throw new RemoteError(
+            409,
+            "ALREADY_MANAGED",
+            "This session is already owned by the service.",
+          );
+        const summary = await new SessionCatalog({
+          workspaceRoot: workspace.path,
+          homeRoot: this.homeRoot,
+        }).get(parseSessionId(id));
+        if (summary.status !== "resumable" && summary.status !== "interrupted")
+          throw new RemoteError(
+            409,
+            "SESSION_UNAVAILABLE",
+            "Exit its local TUI before attaching this session; it must be resumable.",
+          );
+        record = {
+          id,
+          workspaceId: workspace.id,
+          workspacePath: workspace.path,
+          title: summary.firstUserPromptPreview ?? "Empty session",
+          modelName: summary.modelName,
+          owner: "service",
+          status: "accepted",
+          updatedAt: new Date().toISOString(),
+          initialized: true,
+        };
+      } else {
+        record = {
+          id,
+          workspaceId: workspace.id,
+          workspacePath: workspace.path,
+          title: input.title ?? "New session",
+          modelName: "",
+          owner: "service",
+          status: "accepted",
+          updatedAt: new Date().toISOString(),
+          initialized: false,
+        };
+      }
+      const receipt = this.store.accept(input, device, id, record);
+      const hosted = this.session(id);
+      void hosted.open().then(
+        () => {
+          this.store.update({ ...receipt, status: "completed" });
+          hosted.receiptChanged();
+        },
+        (error: unknown) => {
+          this.store.update({
+            ...receipt,
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error),
+          });
+        },
+      );
+      return receipt;
+    }
+    const session = this.session(input.sessionId);
+    // Attach/initialization must be complete before a new mutation can be accepted.
+    await session.open();
+    session.validate(input);
+    const receipt = this.store.accept(input, device, input.sessionId);
+    if (input.kind === "prompt") session.enqueue(receipt);
+    else session.control(input, receipt);
+    return receipt;
+  }
+
+  async close(): Promise<void> {
+    this.stopping = true;
+    await this.submitting;
+    const results = await Promise.allSettled(
+      [...this.hosted.values()].map((session) => session.close()),
+    );
+    await this.store.close();
+    const errors = results.filter((result) => result.status === "rejected");
+    if (errors.length)
+      throw new AggregateError(
+        errors.map((result) => result.reason as unknown),
+        "Remote service shutdown failed.",
+      );
+  }
+}

package/src/remote/sync-hub.ts

@@ -0,0 +1,95 @@
+import type { RemoteChange, RemoteCursor, RemoteFrame, RemoteView } from "./protocol";
+
+/** Synchronous cursor allocation; transport delivery is always outside the runtime. */
+export class RemoteSyncHub {
+  private sequence = 0;
+  private readonly ring: { frame: RemoteFrame; bytes: number }[] = [];
+  private ringBytes = 0;
+  private readonly listeners = new Set<(frame: RemoteFrame) => void>();
+  private pending: RemoteFrame[] = [];
+  private scheduled = false;
+  constructor(
+    readonly epoch: string,
+    private readonly readView: () => RemoteView,
+    private readonly capacity = 256,
+  ) {}
+
+  snapshot(): RemoteFrame {
+    return {
+      version: 1,
+      type: "snapshot",
+      epoch: this.epoch,
+      sequence: this.sequence,
+      view: this.readView(),
+    };
+  }
+  publish(change: RemoteChange): void {
+    const frame: RemoteFrame = {
+      version: 1,
+      type: "event",
+      epoch: this.epoch,
+      sequence: ++this.sequence,
+      change,
+    };
+    const bytes = Buffer.byteLength(JSON.stringify(frame));
+    this.ring.push({ frame, bytes });
+    this.ringBytes += bytes;
+    while (this.ring.length > this.capacity || this.ringBytes > 8 * 1024 * 1024)
+      this.ringBytes -= this.ring.shift()!.bytes;
+    // A single scheduled delivery per tick; no subscriber can hold up append().
+    this.pending.push(frame);
+    if (this.pending.length > this.capacity) this.pending = [this.snapshot()];
+    if (!this.scheduled) {
+      this.scheduled = true;
+      setTimeout(() => this.deliver(), 0);
+    }
+  }
+  subscribe(
+    cursor: RemoteCursor | undefined,
+    listener: (frame: RemoteFrame) => void,
+  ): () => void {
+    // No await between reading the cursor/view and installing the subscription.
+    let last = this.sequence;
+    const oldest = this.ring[0]?.frame.sequence ?? this.sequence + 1;
+    const replay =
+      cursor?.epoch === this.epoch &&
+      cursor.sequence >= oldest - 1 &&
+      cursor.sequence <= this.sequence
+        ? this.ring
+            .filter(({ frame }) => frame.sequence > cursor.sequence)
+            .map(({ frame }) => frame)
+        : [this.snapshot()];
+    // Same-cursor reconnect still needs a handshake to mark the link synchronized.
+    if (replay.length === 0) replay.push(this.snapshot());
+    const guarded = (frame: RemoteFrame) => {
+      if (frame.sequence <= last) return;
+      last = frame.sequence;
+      listener(frame);
+    };
+    this.listeners.add(guarded);
+    try {
+      for (const frame of replay) listener(frame);
+    } catch {
+      this.listeners.delete(guarded);
+    }
+    return () => this.listeners.delete(guarded);
+  }
+  private deliver(): void {
+    this.scheduled = false;
+    const pending = this.pending;
+    this.pending = [];
+    for (const frame of pending) {
+      for (const listener of this.listeners) {
+        try {
+          listener(frame);
+        } catch {
+          this.listeners.delete(listener);
+        }
+      }
+    }
+  }
+  close(): void {
+    this.listeners.clear();
+    this.pending = [];
+  }
+}

package/src/session/remote-history-reader.ts

@@ -0,0 +1,143 @@
+import { Database } from "bun:sqlite";
+import type { SessionId } from "../ids/runtime-id";
+import { verifyReadableSessionSchema } from "./session-schema";
+import { decodeStoredToolCalls } from "./session-store-record-codecs";
+
+export type RemoteMessage = {
+  id: string;
+  ordinal: number;
+  role: "user" | "assistant" | "tool";
+  text: string;
+  turnId: string;
+  turnStatus: string;
+  createdAt: string;
+  name?: string;
+  toolCallId?: string;
+  toolCalls?: { id: string; name: string; arguments: string }[];
+};
+
+export type RemoteHistoryPage = {
+  messages: RemoteMessage[];
+  hasMore: boolean;
+  beforeOrdinal?: number;
+};
+
+/** A read-only canonical projection; open tails are legal and never synthesized. */
+export class RemoteHistoryReader {
+  private readonly database: Database;
+  constructor(databasePath: string, sessionId: SessionId, workspaceRoot: string) {
+    this.database = new Database(databasePath, { readonly: true, strict: true });
+    try {
+      verifyReadableSessionSchema(this.database, sessionId);
+      const identity = this.database
+        .query("SELECT session_id, workspace_root FROM session_meta")
+        .get() as { session_id: string; workspace_root: string } | null;
+      if (
+        identity?.session_id !== sessionId ||
+        identity.workspace_root !== workspaceRoot
+      ) {
+        throw new Error(
+          "Remote history identity does not match its workspace/session.",
+        );
+      }
+    } catch (error) {
+      this.database.close();
+      throw error;
+    }
+  }
+
+  page(before = Number.MAX_SAFE_INTEGER, limit = 80): RemoteHistoryPage {
+    const rows = this.database
+      .query(
+        `${MESSAGE_SELECT} WHERE m.role <> 'system' AND m.ordinal < ? ORDER BY m.ordinal DESC LIMIT ?`,
+      )
+      .all(before, limit + 1) as MessageRow[];
+    const hasMore = rows.length > limit;
+    const messages = rows.slice(0, limit).reverse().map(projectMessage);
+    return {
+      messages,
+      hasMore,
+      ...(messages[0] ? { beforeOrdinal: messages[0].ordinal } : {}),
+    };
+  }
+
+  after(ordinal: number): RemoteMessage[] {
+    return (
+      this.database
+        .query(
+          `${MESSAGE_SELECT} WHERE m.role <> 'system' AND m.ordinal > ? ORDER BY m.ordinal`,
+        )
+        .all(ordinal) as MessageRow[]
+    ).map(projectMessage);
+  }
+
+  latestTurn(): { id: string; status: string; error?: string } | undefined {
+    const row = this.database
+      .query(
+        "SELECT turn_id, status, terminal_detail_json FROM turns ORDER BY turn_number DESC LIMIT 1",
+      )
+      .get() as {
+      turn_id: string;
+      status: string;
+      terminal_detail_json: string | null;
+    } | null;
+    if (!row) return undefined;
+    const detail = row.terminal_detail_json
+      ? (JSON.parse(row.terminal_detail_json) as { error?: string })
+      : undefined;
+    return {
+      id: row.turn_id,
+      status: row.status,
+      ...(detail?.error ? { error: detail.error } : {}),
+    };
+  }
+
+  turnStatus(turnId: string): string | undefined {
+    return (
+      this.database.query("SELECT status FROM turns WHERE turn_id = ?").get(turnId) as {
+        status: string;
+      } | null
+    )?.status;
+  }
+
+  close(): void {
+    this.database.close();
+  }
+}
+
+const MESSAGE_SELECT =
+  "SELECT m.*, t.status AS turn_status FROM messages m JOIN turns t ON t.turn_id = m.turn_id";
+type MessageRow = {
+  message_id: string;
+  ordinal: number;
+  role: RemoteMessage["role"];
+  content: string | null;
+  turn_id: string;
+  turn_status: string;
+  created_at: string;
+  name: string | null;
+  tool_call_id: string | null;
+  tool_calls_json: string | null;
+};
+function projectMessage(row: MessageRow): RemoteMessage {
+  return {
+    id: row.message_id,
+    ordinal: row.ordinal,
+    role: row.role,
+    text: row.content ?? "",
+    turnId: row.turn_id,
+    turnStatus: row.turn_status,
+    createdAt: row.created_at,
+    ...(row.name ? { name: row.name } : {}),
+    ...(row.tool_call_id ? { toolCallId: row.tool_call_id } : {}),
+    ...(row.tool_calls_json
+      ? {
+          toolCalls: decodeStoredToolCalls(row.tool_calls_json).map((call) => ({
+            id: call.toolCallId,
+            name: call.name,
+            arguments: JSON.stringify(call.args),
+          })),
+        }
+      : {}),
+  };
+}

package/src/session/scoped-query-database.ts

@@ -0,0 +1,27 @@
+import { Database, type SQLQueryBindings } from "bun:sqlite";
+
+/**
+ * Own every query statement until a short-lived connection closes. Bun only
+ * caches its first 20 queries; later statements otherwise survive close() until
+ * GC, leaving a zombie SQLite connection behind. Do not use this for resident
+ * stores: retaining every query is intentionally bounded by the operation.
+ */
+export class ScopedQueryDatabase extends Database {
+  private readonly queries = new Set<{ finalize(): void }>();
+
+  override query<Result, Params extends SQLQueryBindings | SQLQueryBindings[]>(
+    sql: string,
+  ) {
+    const statement = super.query<Result, Params>(sql);
+    this.queries.add(statement);
+    return statement;
+  }
+
+  override close(): void {
+    for (const statement of this.queries) statement.finalize();
+    this.queries.clear();
+    // Also finalizes Bun's transaction statements and rejects any other live
+    // resources instead of silently deferring the underlying connection close.
+    super.close(true);
+  }
+}

package/src/session/session-history-access.ts

@@ -1,4 +1,5 @@
-import { Database } from "bun:sqlite";
+import type { Database } from "bun:sqlite";
+import { ScopedQueryDatabase } from "./scoped-query-database";
 import { lstat, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
 import { throwIfTurnCancelled } from "../agent/turn-cancellation";
@@ -67,7 +68,7 @@ export function createSessionHistoryAccess(input: {
         throwIfTurnCancelled(signal);
         await validateHistoryFiles(location.databasePath, sessionId);
         throwIfTurnCancelled(signal);
-        const database = new Database(location.databasePath, {
+        const database = new ScopedQueryDatabase(location.databasePath, {
           readonly: true,
           strict: true,
           safeIntegers: true,
@@ -100,7 +101,7 @@ export function createSessionHistoryAccess(input: {
           throwIfTurnCancelled(signal);
           return result;
         } finally {
-          database.close(true);
+          database.close();
         }
       } catch (error) {
         throwIfTurnCancelled(signal);

package/src/session/session-store.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { ScopedQueryDatabase } from "./scoped-query-database";
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, open, readdir, rename, rmdir } from "node:fs/promises";
 import path from "node:path";
@@ -1327,7 +1328,7 @@ export class SessionStore implements SessionLedgerCommitter {
       await chmod(stagingDatabasePath, 0o600);
       input.faultInjector?.("after_snapshot");
 
-      stagingDatabase = openWritableDatabase(stagingDatabasePath);
+      stagingDatabase = openWritableDatabase(stagingDatabasePath, ScopedQueryDatabase);
       verifySessionSchema(stagingDatabase, this.sessionId);
       dropSessionCloneTriggers(stagingDatabase);
       input.faultInjector?.("after_trigger_drop");
@@ -1542,8 +1543,11 @@ export async function resolveSessionDatabasePath(
   );
 }
 
-function openWritableDatabase(databasePath: string): Database {
-  const database = new Database(databasePath, {
+function openWritableDatabase(
+  databasePath: string,
+  DatabaseType: typeof Database = Database,
+): Database {
+  const database = new DatabaseType(databasePath, {
     create: false,
     readwrite: true,
     strict: true,

package/src/tools/bash-task.ts

@@ -15,12 +15,7 @@ import {
 } from "./shell-process";
 import { TaskOutput, type TaskOutputSnapshot } from "./task-output";
 import type { TaskOutputRangeRequest } from "./task-output-range";
-import {
-  createTerminalScreen,
-  TERMINAL_SCREEN_COLUMNS,
-  TERMINAL_SCREEN_ROWS,
-  type TerminalScreen,
-} from "./terminal-screen";
+import { createTerminalScreen, type TerminalScreen } from "./terminal-screen";
 import { resolveWorkspaceStorageRoot } from "../session/workspace-storage";
 
 export type ShellTaskStatus =
@@ -146,6 +141,8 @@ export class ShellTaskManager {
     description: string;
     origin: ShellTaskOrigin;
     tty: boolean;
+    cols?: number;
+    rows?: number;
   }): Promise<ShellTaskHandle> {
     if (!this.acceptingTasks) {
       throw new Error("Cannot start a Bash task after task manager shutdown.");
@@ -164,7 +161,7 @@ export class ShellTaskManager {
       throw new Error("Cannot start a Bash task after task manager shutdown.");
     }
 
-    const terminalScreen = input.tty ? createTerminalScreen() : undefined;
+    const terminalScreen = input.tty ? createTerminalScreen(input) : undefined;
     let shellProcess: ShellProcessHandle;
     try {
       shellProcess = await spawnShellProcess({
@@ -172,6 +169,8 @@ export class ShellTaskManager {
         command: input.command,
         cwd: this.options.cwdState.cwd,
         cwdFilePath,
+        cols: terminalScreen?.columns,
+        rows: terminalScreen?.rows,
         onOutput(bytes) {
           output.write(Buffer.from(bytes));
           if (terminalScreen !== undefined) {
@@ -417,8 +416,15 @@ export class ShellTaskManager {
     if (!(await completesWithin(task.completion, this.stopGraceMs))) {
       this.synchronizeTerminalState(task);
       if (!isTerminalStatus(task.status)) {
-        signalProcessGroup(task, "SIGKILL");
-        escalated = true;
+        escalated = signalProcessGroup(task, "SIGKILL");
+        if (
+          !(await completesWithin(task.completion, this.stopGraceMs)) &&
+          !task.process.outputClosed
+        ) {
+          task.error =
+            "Task output remained open after forced termination; closed local output streams. Descendant processes may still be running.";
+          task.process.close();
+        }
       }
     }
 
@@ -474,8 +480,8 @@ export class ShellTaskManager {
   private async monitorTask(task: ManagedShellTask): Promise<ShellTaskSnapshot> {
     const result = await task.process.wait();
 
-    this.applyTermination(task, result);
     await task.process.waitForOutputClose();
+    this.applyTermination(task, result);
     await task.output.end();
     if (task.terminalScreen !== undefined) {
       await task.terminalScreen.flush();
@@ -505,9 +511,9 @@ export class ShellTaskManager {
     }
 
     task.endedAt ??= new Date().toISOString();
-    if (result.error !== undefined) {
+    if (result.error !== undefined || task.error !== undefined) {
       task.status = "failed";
-      task.error = result.error;
+      task.error ??= result.error;
       return;
     }
 
@@ -522,7 +528,9 @@ export class ShellTaskManager {
   }
 
   private synchronizeTerminalState(task: ManagedShellTask): void {
-    if (isTerminalStatus(task.status)) {
+    // An exited wrapper can leave children holding its output descriptors open.
+    // Keep the task stoppable until both process exit and output closure occur.
+    if (isTerminalStatus(task.status) || !task.process.outputClosed) {
       return;
     }
 
@@ -576,8 +584,8 @@ export class ShellTaskManager {
       ...(screen === undefined
         ? {}
         : {
-            screenRows: TERMINAL_SCREEN_ROWS,
-            screenColumns: TERMINAL_SCREEN_COLUMNS,
+            screenRows: task.terminalScreen?.rows,
+            screenColumns: task.terminalScreen?.columns,
             screen,
           }),
     };
@@ -607,13 +615,15 @@ export class ShellTaskManager {
 function signalProcessGroup(
   task: ManagedShellTask,
   signal: "SIGTERM" | "SIGKILL",
-): void {
+): boolean {
   try {
     process.kill(-task.processGroupId, signal);
+    return true;
   } catch (error) {
     if (!isNoSuchProcess(error)) {
       throw error;
     }
+    return false;
   }
 }