tinker-agent 2.9.0 → 2.10.0

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/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;
   }
 }
 

package/src/tools/bash.ts

@@ -13,6 +13,7 @@ import type { TaskOutputSnapshot } from "./task-output";
 import type { BashRawResult, ToolExecutionContext, ToolExecutor } from "./types";
 import { DEFAULT_PUBLIC_TOOLING_CONFIG } from "../cli/public-config-contract";
 import { classifyBashRisk } from "./bash-guard";
+import { MAX_TERMINAL_DIMENSION, MIN_TERMINAL_COLUMNS } from "./terminal-screen";
 
 type BashArgs = {
   command: string;
@@ -20,6 +21,8 @@ type BashArgs = {
   description?: string;
   run_in_background?: boolean;
   tty?: boolean;
+  cols?: number;
+  rows?: number;
 };
 
 export type BashToolOptions = {
@@ -44,7 +47,8 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
   return defineToolExecutor("bash", {
     definition: {
       name: "Bash",
-      description: "Run a shell command locally.",
+      description:
+        "Run a shell command locally. If the foreground timeout expires while the command is still running, it continues as a background task and returns a task ID; it is not killed. Use TaskOutput to inspect progress, then decide whether to keep waiting or stop it with TaskStop.",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -57,7 +61,8 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
             type: "integer",
             minimum: 1,
             maximum: maxTimeoutMs,
-            description: "Optional foreground timeout in milliseconds.",
+            description:
+              "Optional foreground wait duration in milliseconds. On timeout, a still-running command continues in the background instead of being killed.",
           },
           description: {
             type: "string",
@@ -72,6 +77,20 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
             description:
               "Run the command in a pseudo-terminal so it can receive interactive input.",
           },
+          cols: {
+            type: "integer",
+            minimum: MIN_TERMINAL_COLUMNS,
+            maximum: MAX_TERMINAL_DIMENSION,
+            description:
+              "Initial PTY width in columns. Defaults to 80. Ignored unless tty=true.",
+          },
+          rows: {
+            type: "integer",
+            minimum: 1,
+            maximum: MAX_TERMINAL_DIMENSION,
+            description:
+              "Initial PTY height in rows. Defaults to 24. Ignored unless tty=true.",
+          },
         },
         required: ["command"],
       },
@@ -137,6 +156,8 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
         description: input.description ?? input.command,
         origin: call,
         tty: input.tty === true,
+        cols: input.cols,
+        rows: input.rows,
       });
 
       if (input.run_in_background === true) {
@@ -232,6 +253,25 @@ export function parseBashArgs(
     return { ok: false, error: "Bash.tty must be a boolean." };
   }
 
+  if (args.tty === true) {
+    for (const name of ["cols", "rows"] as const) {
+      const value = args[name];
+      const minimum = name === "cols" ? MIN_TERMINAL_COLUMNS : 1;
+      if (
+        value !== undefined &&
+        (typeof value !== "number" ||
+          !Number.isInteger(value) ||
+          value < minimum ||
+          value > MAX_TERMINAL_DIMENSION)
+      ) {
+        return {
+          ok: false,
+          error: `Bash.${name} must be an integer between ${minimum} and ${MAX_TERMINAL_DIMENSION}.`,
+        };
+      }
+    }
+  }
+
   return {
     ok: true,
     value: {
@@ -243,6 +283,8 @@ export function parseBashArgs(
           : args.description,
       run_in_background: args.run_in_background,
       tty: args.tty,
+      cols: args.tty === true ? (args.cols as number | undefined) : undefined,
+      rows: args.tty === true ? (args.rows as number | undefined) : undefined,
     },
   };
 }

package/src/tools/glob.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { stat } from "node:fs/promises";
-import { glob } from "glob";
+import { realpath, stat } from "node:fs/promises";
+import { glob, type Path } from "glob";
 import { cancellationError, throwIfTurnCancelled } from "../agent/turn-cancellation";
 import { resolveWorkspacePath, toDisplayPath } from "./path-safety";
 import { defineToolExecutor } from "./types";
@@ -9,6 +9,8 @@ import type { GlobRawResult, ToolExecutionContext, ToolExecutor } from "./types"
 type GlobArgs = {
   pattern: string;
   path?: string;
+  head_limit: number;
+  offset: number;
 };
 
 export type GlobToolOptions = {
@@ -16,12 +18,15 @@ export type GlobToolOptions = {
 };
 
 const ignoredDirectories = ["node_modules", ".git"];
+const defaultHeadLimit = 200;
+const maxHeadLimit = 500;
 
 export function createGlobToolExecutor(options: GlobToolOptions): ToolExecutor {
   return defineToolExecutor("glob", {
     definition: {
       name: "Glob",
-      description: "Find files by glob pattern. node_modules and .git are ignored.",
+      description:
+        "Find regular files by glob pattern, including symbolic links to regular files. Case sensitivity follows platform defaults. Directory links and broken links are excluded. node_modules and .git are skipped during traversal; to search inside either, set path directly to that directory.",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -33,7 +38,21 @@ export function createGlobToolExecutor(options: GlobToolOptions): ToolExecutor {
           path: {
             type: "string",
             description:
-              "Optional workspace-relative or absolute search directory. Defaults to the workspace root.",
+              "Optional workspace-relative or absolute search directory. Defaults to the workspace root. A directory symbolic link is allowed as the search root.",
+          },
+          head_limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: maxHeadLimit,
+            description:
+              "Maximum paths to return. Defaults to 200; must be between 1 and 500.",
+          },
+          offset: {
+            type: "integer",
+            minimum: 0,
+            maximum: Number.MAX_SAFE_INTEGER,
+            description:
+              "Skip the first N sorted matches. Defaults to 0. To continue, pass nextOffset from the previous result with the same pattern and path.",
           },
         },
         required: ["pattern"],
@@ -46,8 +65,16 @@ export function createGlobToolExecutor(options: GlobToolOptions): ToolExecutor {
       if (!parsed.ok) {
         return {
           ok: false,
-          pattern: "",
-          searchPath: ".",
+          pattern:
+            isRecord(args) && typeof args.pattern === "string"
+              ? args.pattern
+              : undefined,
+          searchPath:
+            isRecord(args) && args.path !== undefined
+              ? typeof args.path === "string"
+                ? args.path
+                : "(invalid path)"
+              : ".",
           ignored: ignoredDirectories,
           error: parsed.error,
         };
@@ -87,27 +114,43 @@ export function createGlobToolExecutor(options: GlobToolOptions): ToolExecutor {
       }
 
       try {
+        // Resolve the root only; keep the traversal policy for links below it.
+        const realSearchPath = await realpath(absoluteSearchPath);
+        throwIfTurnCancelled(context.signal);
         const matches = await glob(input.pattern, {
-          cwd: absoluteSearchPath,
+          cwd: realSearchPath,
           nodir: true,
           dot: true,
           follow: false,
+          withFileTypes: true,
           signal: context.signal,
           ignore: ["**/node_modules/**", "**/.git/**"],
         });
-        const displayMatches = toDisplayMatches({
+        const displayMatches = await toDisplayMatches({
           workspaceRoot: options.workspaceRoot,
           absoluteSearchPath,
+          realSearchPath,
           matches,
+          signal: context.signal,
         });
+        const page = displayMatches.slice(
+          input.offset,
+          input.offset + input.head_limit,
+        );
+        const hasMore = input.offset + page.length < displayMatches.length;
 
         return {
           ok: true,
           pattern: input.pattern,
           searchPath,
           absoluteSearchPath,
-          matches: displayMatches,
-          matchCount: displayMatches.length,
+          matches: page,
+          matchCount: page.length,
+          totalMatches: displayMatches.length,
+          returnedCount: page.length,
+          appliedOffset: input.offset,
+          hasMore,
+          ...(hasMore ? { nextOffset: input.offset + page.length } : {}),
           ignored: ignoredDirectories,
         };
       } catch (error) {
@@ -151,11 +194,35 @@ function parseGlobArgs(
     return { ok: false, error: "Glob.path must be a string." };
   }
 
+  if (
+    args.head_limit !== undefined &&
+    (typeof args.head_limit !== "number" ||
+      !Number.isSafeInteger(args.head_limit) ||
+      args.head_limit < 1 ||
+      args.head_limit > maxHeadLimit)
+  ) {
+    return {
+      ok: false,
+      error: "Glob.head_limit must be an integer between 1 and 500.",
+    };
+  }
+
+  if (
+    args.offset !== undefined &&
+    (typeof args.offset !== "number" ||
+      !Number.isSafeInteger(args.offset) ||
+      args.offset < 0)
+  ) {
+    return { ok: false, error: "Glob.offset must be a non-negative safe integer." };
+  }
+
   return {
     ok: true,
     value: {
       pattern: args.pattern,
       path: args.path,
+      head_limit: args.head_limit ?? defaultHeadLimit,
+      offset: args.offset ?? 0,
     },
   };
 }
@@ -177,22 +244,43 @@ async function ensureDirectory(
   }
 }
 
-function toDisplayMatches(input: {
+async function toDisplayMatches(input: {
   workspaceRoot: string;
   absoluteSearchPath: string;
-  matches: string[];
-}): string[] {
-  const normalized = input.matches.map((match) => {
-    const absolutePath = resolveWorkspacePath(
-      input.workspaceRoot,
-      path.resolve(input.absoluteSearchPath, match),
+  realSearchPath: string;
+  matches: Path[];
+  signal: AbortSignal;
+}): Promise<string[]> {
+  const normalized: string[] = [];
+  for (const match of input.matches) {
+    throwIfTurnCancelled(input.signal);
+    if (!(await isRegularFileMatch(match))) continue;
+    // Preserve the caller's root spelling, including directory links and aliases.
+    const absolutePath = path.resolve(
+      input.absoluteSearchPath,
+      path.relative(input.realSearchPath, match.fullpath()),
     );
-    return toDisplayPath(input.workspaceRoot, absolutePath);
-  });
+    normalized.push(toDisplayPath(input.workspaceRoot, absolutePath));
+  }
+  throwIfTurnCancelled(input.signal);
 
   return [...new Set(normalized)].sort((left, right) => left.localeCompare(right));
 }
 
+async function isRegularFileMatch(match: Path): Promise<boolean> {
+  if (!match.isSymbolicLink()) return match.isFile();
+
+  try {
+    // Resolve only the type; keep the link's path in the returned matches.
+    return (await stat(match.fullpath())).isFile();
+  } catch (error) {
+    if (isRecord(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return false;
+    }
+    throw error;
+  }
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }