tinker-agent 1.5.1 → 1.7.0

package/src/tools/edit.ts

@@ -1,10 +1,12 @@
 import { Buffer } from "node:buffer";
 import { readFile, stat, writeFile } from "node:fs/promises";
+import type { ToolCall } from "../agent/types";
 import { throwIfTurnCancelled } from "../agent/turn-cancellation";
 import { computeFilePatch } from "./file-diff";
 import { ensureParentDirectory } from "./ensure-parent-directory";
 import { sha256Bytes, sha256Text } from "./hash";
 import { resolveWorkspacePath } from "./path-safety";
+import type { TurnUndoManager } from "./turn-undo-manager";
 import { defineToolExecutor } from "./types";
 import type {
   EditFileRawResult,
@@ -23,6 +25,7 @@ type EditArgs = {
 export type EditToolOptions = {
   workspaceRoot: string;
   snapshots: FileSnapshotStore;
+  undoManager?: TurnUndoManager;
 };
 
 export function createEditToolExecutor(options: EditToolOptions): ToolExecutor {
@@ -58,7 +61,7 @@ export function createEditToolExecutor(options: EditToolOptions): ToolExecutor {
     },
     async execute(
       args,
-      _call,
+      call,
       context: ToolExecutionContext,
     ): Promise<EditFileRawResult> {
       throwIfTurnCancelled(context.signal);
@@ -102,6 +105,8 @@ export function createEditToolExecutor(options: EditToolOptions): ToolExecutor {
           target,
           newContent: input.new_string,
           snapshots: options.snapshots,
+          undoManager: options.undoManager,
+          call,
           signal: context.signal,
         });
       }
@@ -173,6 +178,9 @@ export function createEditToolExecutor(options: EditToolOptions): ToolExecutor {
         expectedSha256: target.sha256,
         readRequiredOnChange: true,
         snapshots: options.snapshots,
+        undoManager: options.undoManager,
+        call,
+        initialBefore: target,
         signal: context.signal,
       });
     },
@@ -219,6 +227,8 @@ async function writeEmptyTarget(input: {
   target: TargetFileState;
   newContent: string;
   snapshots: FileSnapshotStore;
+  undoManager?: TurnUndoManager;
+  call: ToolCall;
   signal: AbortSignal;
 }): Promise<EditFileRawResult> {
   if (input.target.exists && input.target.content.length > 0) {
@@ -242,6 +252,9 @@ async function writeEmptyTarget(input: {
     expectedSha256: input.target.exists ? input.target.sha256 : undefined,
     readRequiredOnChange: false,
     snapshots: input.snapshots,
+    undoManager: input.undoManager,
+    call: input.call,
+    initialBefore: input.target,
     signal: input.signal,
   });
 }
@@ -258,10 +271,14 @@ async function writeEditedContent(input: {
   expectedSha256?: string;
   readRequiredOnChange: boolean;
   snapshots: FileSnapshotStore;
+  undoManager?: TurnUndoManager;
+  call: ToolCall;
+  initialBefore: TargetFileState;
   signal: AbortSignal;
 }): Promise<EditFileRawResult> {
   throwIfTurnCancelled(input.signal);
 
+  let verifiedBefore = input.initialBefore;
   if (input.expectedSha256 !== undefined) {
     const currentState = await targetFileState(input.absolutePath);
     throwIfTurnCancelled(input.signal);
@@ -296,12 +313,27 @@ async function writeEditedContent(input: {
           : "File changed while Edit was being prepared. Retry Edit with the current file state.",
       };
     }
+    verifiedBefore = currentState;
   }
 
+  const undoCapture = await input.undoManager?.captureBeforeMutation({
+    turnId: input.call.turnId,
+    turnNumber: input.call.turnNumber,
+    absolutePath: input.absolutePath,
+    displayPath: input.filePath,
+    loadBefore: async () =>
+      verifiedBefore.exists
+        ? { state: "present", bytes: verifiedBefore.bytes }
+        : { state: "absent" },
+  });
+
   if (input.created) {
     try {
       await ensureParentDirectory(input.absolutePath);
     } catch (error) {
+      if (undoCapture !== undefined) {
+        await input.undoManager?.recordMutationFailure(undoCapture);
+      }
       return {
         ok: false,
         filePath: input.filePath,
@@ -312,14 +344,39 @@ async function writeEditedContent(input: {
     throwIfTurnCancelled(input.signal);
   }
 
-  await writeFile(input.absolutePath, input.newContent, "utf8");
-  const newSha256 = sha256Text(input.newContent);
-  const writtenInfo = await stat(input.absolutePath);
-  input.snapshots.set(input.absolutePath, {
-    sha256: newSha256,
-    mtimeMs: writtenInfo.mtimeMs,
-    source: "edit",
-  });
+  let newSha256: string;
+  try {
+    throwIfTurnCancelled(input.signal);
+    await writeFile(input.absolutePath, input.newContent, "utf8");
+    const expectedSha256 = sha256Text(input.newContent);
+    const written = await targetFileState(input.absolutePath);
+    if (!written.ok) {
+      throw new Error(`Failed to verify edited file: ${written.error}`);
+    }
+    if (!written.exists) {
+      throw new Error("Failed to verify edited file: File does not exist.");
+    }
+    if (written.sha256 !== expectedSha256) {
+      throw new Error("File changed while Edit was being verified.");
+    }
+    newSha256 = written.sha256;
+    if (undoCapture !== undefined) {
+      input.undoManager?.recordMutationResult(undoCapture, {
+        state: "present",
+        sha256: newSha256,
+      });
+    }
+    input.snapshots.set(input.absolutePath, {
+      sha256: newSha256,
+      mtimeMs: written.mtimeMs,
+      source: "edit",
+    });
+  } catch (error) {
+    if (undoCapture !== undefined) {
+      await input.undoManager?.recordMutationFailure(undoCapture);
+    }
+    throw error;
+  }
 
   const patch = computeFilePatch({
     filePath: input.filePath,
@@ -348,6 +405,7 @@ type TargetFileState =
       ok: true;
       exists: true;
       content: string;
+      bytes: Buffer;
       sha256: string;
       mtimeMs: number;
     };
@@ -371,6 +429,7 @@ async function targetFileState(
       ok: true,
       exists: true,
       content: bytes.toString("utf8"),
+      bytes,
       sha256: sha256Bytes(bytes),
       mtimeMs: currentInfo.mtimeMs,
     };

package/src/tools/registry.ts

@@ -1,18 +1,21 @@
 import { createBashToolExecutor } from "./bash";
 import { ShellTaskManager } from "./bash-task";
 import { createCwdState } from "./cwd-state";
+import { createDeleteToolExecutor } from "./delete";
 import { createEditToolExecutor } from "./edit";
 import { createGlobToolExecutor } from "./glob";
 import { createGrepToolExecutor } from "./grep";
 import { createReadToolExecutor } from "./read";
 import { createRecallToolExecutor } from "./recall";
 import { createTaskListToolExecutor } from "./task-list";
+import { createTaskInputToolExecutor } from "./task-input";
 import { createTaskOutputToolExecutor } from "./task-output-tool";
 import { createTaskStopToolExecutor } from "./task-stop";
 import { createWebFetchToolExecutor } from "./web-fetch";
 import type { Refiner } from "./web-fetch/refiner";
 import { createWebSearchToolExecutor } from "./web-search";
 import { createWriteToolExecutor } from "./write";
+import { TurnUndoManager } from "./turn-undo-manager";
 import { cancellationError, throwIfTurnCancelled } from "../agent/turn-cancellation";
 import type {
   RuntimeSessionContext,
@@ -62,7 +65,17 @@ export class ToolRegistry {
 }
 
 export class ToolRuntime {
-  constructor(private readonly registry: ToolRegistry) {}
+  constructor(
+    private readonly registry: ToolRegistry,
+    private readonly bashGuard?: {
+      readonly surface: "tui" | "one-shot";
+      confirm(
+        call: ToolCall,
+        request: { command: string; reason: string },
+        signal: AbortSignal,
+      ): Promise<"allow" | "deny">;
+    },
+  ) {}
 
   async execute(call: ToolCall, context: ToolExecutionContext): Promise<ToolRawResult> {
     throwIfTurnCancelled(context.signal);
@@ -88,7 +101,16 @@ export class ToolRuntime {
     }
 
     try {
-      return await tool.execute(call.args, call, context);
+      return await tool.execute(call.args, call, {
+        ...context,
+        ...(this.bashGuard === undefined
+          ? {}
+          : {
+              bashGuardSurface: this.bashGuard.surface,
+              confirmBashCommand: (request: { command: string; reason: string }) =>
+                this.bashGuard!.confirm(call, request, context.signal),
+            }),
+      });
     } catch (error) {
       if (context.signal.aborted) {
         throw cancellationError(context.signal, error);
@@ -113,6 +135,7 @@ export type DefaultTooling = {
   snapshots: FileSnapshotStore;
   bashState: BashToolingState;
   taskManager: ShellTaskManager;
+  turnUndoManager?: TurnUndoManager;
   dispose(reason?: SessionDisposeReason["type"]): Promise<void>;
 };
 
@@ -134,8 +157,20 @@ export function createDefaultTooling(options: {
   skillCoordinator?: SkillActivationCoordinator;
   toolingConfig?: PublicToolingConfig;
   memorySearch?: ToolExecutor;
+  enableTurnUndo?: boolean;
+  bashGuard?: {
+    readonly surface: "tui" | "one-shot";
+    confirm(
+      call: ToolCall,
+      request: { command: string; reason: string },
+      signal: AbortSignal,
+    ): Promise<"allow" | "deny">;
+  };
 }): DefaultTooling {
   const snapshots: FileSnapshotStore = new Map();
+  const turnUndoManager = options.enableTurnUndo
+    ? new TurnUndoManager({ snapshots })
+    : undefined;
   const registry = new ToolRegistry();
   const runtimeSession = options.runtimeSession;
   const toolingConfig = options.toolingConfig ?? DEFAULT_PUBLIC_TOOLING_CONFIG;
@@ -194,12 +229,21 @@ export function createDefaultTooling(options: {
     createWriteToolExecutor({
       workspaceRoot: options.workspaceRoot,
       snapshots,
+      ...(turnUndoManager === undefined ? {} : { undoManager: turnUndoManager }),
     }),
   );
   registry.register(
     createEditToolExecutor({
       workspaceRoot: options.workspaceRoot,
       snapshots,
+      ...(turnUndoManager === undefined ? {} : { undoManager: turnUndoManager }),
+    }),
+  );
+  registry.register(
+    createDeleteToolExecutor({
+      workspaceRoot: options.workspaceRoot,
+      snapshots,
+      ...(turnUndoManager === undefined ? {} : { undoManager: turnUndoManager }),
     }),
   );
   registry.register(
@@ -213,6 +257,7 @@ export function createDefaultTooling(options: {
   );
   registry.register(createTaskListToolExecutor({ taskManager }));
   registry.register(createTaskOutputToolExecutor({ taskManager }));
+  registry.register(createTaskInputToolExecutor({ taskManager }));
   registry.register(createTaskStopToolExecutor({ taskManager }));
 
   const exaApiKey = options.exaApiKey ?? toolingConfig.exaApiKey;
@@ -232,9 +277,10 @@ export function createDefaultTooling(options: {
 
   return {
     registry,
-    runtime: new ToolRuntime(registry),
+    runtime: new ToolRuntime(registry, options.bashGuard),
     snapshots,
     taskManager,
+    ...(turnUndoManager === undefined ? {} : { turnUndoManager }),
     bashState: {
       get cwd() {
         return cwdState.cwd;

package/src/tools/shell-process.ts

@@ -0,0 +1,296 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { TERMINAL_SCREEN_COLUMNS, TERMINAL_SCREEN_ROWS } from "./terminal-screen";
+
+export type ShellProcessMode = "pipe" | "pty";
+
+export type ProcessExitResult = {
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  error?: string;
+};
+
+export type ShellProcessHandle = {
+  readonly pid: number;
+  readonly mode: ShellProcessMode;
+  readonly exitCode: number | null;
+  readonly signalCode: NodeJS.Signals | null;
+  wait(): Promise<ProcessExitResult>;
+  waitForOutputClose(): Promise<void>;
+  write?(chars: string): Promise<number>;
+  close(): void;
+};
+
+export class ShellProcessWriteError extends Error {
+  constructor(
+    message: string,
+    readonly writtenBytes: number,
+  ) {
+    super(message);
+    this.name = "ShellProcessWriteError";
+  }
+}
+
+export async function spawnShellProcess(input: {
+  mode: ShellProcessMode;
+  command: string;
+  cwd: string;
+  cwdFilePath: string;
+  onOutput(bytes: Uint8Array): void;
+}): Promise<ShellProcessHandle> {
+  const env = {
+    ...process.env,
+    NO_COLOR: "1",
+    TINKER_BASH_COMMAND: input.command,
+    TINKER_BASH_CWD_FILE: input.cwdFilePath,
+  };
+
+  if (input.mode === "pty") {
+    return spawnPtyShellProcess({ ...input, env });
+  }
+
+  return spawnPipeShellProcess({ ...input, env });
+}
+
+async function spawnPipeShellProcess(input: {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  onOutput(bytes: Uint8Array): void;
+}): Promise<ShellProcessHandle> {
+  const child = spawn("bash", ["-lc", bashWrapperScript], {
+    cwd: input.cwd,
+    detached: true,
+    env: input.env,
+  });
+  pipeOutput(child.stdout, (bytes) => input.onOutput(bytes));
+  pipeOutput(child.stderr, (bytes) => input.onOutput(bytes));
+
+  const exit = waitForNodeProcessExit(child);
+  const close = waitForNodeProcessClose(child);
+  if (child.pid === undefined) {
+    const result = await exit;
+    throw new Error(result.error ?? "Bash process failed to start.");
+  }
+
+  return {
+    pid: child.pid,
+    mode: "pipe",
+    get exitCode() {
+      return child.exitCode;
+    },
+    get signalCode() {
+      return child.signalCode;
+    },
+    wait: () => exit,
+    waitForOutputClose: () => close,
+    close() {},
+  };
+}
+
+function spawnPtyShellProcess(input: {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  onOutput(bytes: Uint8Array): void;
+}): ShellProcessHandle {
+  let terminalEnded = false;
+  let resolveTerminalExit: (() => void) | undefined;
+  let drainGeneration = 0;
+  const drainWaiters = new Set<() => void>();
+  const terminalExit = new Promise<void>((resolve) => {
+    resolveTerminalExit = resolve;
+  });
+  const notifyDrain = () => {
+    drainGeneration += 1;
+    for (const resolve of drainWaiters) {
+      resolve();
+    }
+    drainWaiters.clear();
+  };
+  const settleTerminalExit = () => {
+    if (terminalEnded) {
+      return;
+    }
+    terminalEnded = true;
+    notifyDrain();
+    resolveTerminalExit?.();
+  };
+
+  const subprocess = Bun.spawn(["bash", "-lc", bashWrapperScript], {
+    cwd: input.cwd,
+    detached: true,
+    env: {
+      ...input.env,
+      TERM: "xterm-256color",
+      NO_COLOR: "1",
+      PAGER: "cat",
+      GIT_PAGER: "cat",
+    },
+    terminal: {
+      cols: TERMINAL_SCREEN_COLUMNS,
+      rows: TERMINAL_SCREEN_ROWS,
+      name: "xterm-256color",
+      data(_terminal, bytes) {
+        input.onOutput(new Uint8Array(bytes));
+      },
+      exit() {
+        // Linux reports slave closure as EIO; subprocess.exited owns task status.
+        settleTerminalExit();
+      },
+      drain() {
+        notifyDrain();
+      },
+    },
+  });
+  const terminal = subprocess.terminal!;
+
+  let writeQueue = Promise.resolve();
+  const write = (chars: string): Promise<number> => {
+    const bytes = new TextEncoder().encode(chars);
+    const operation = writeQueue.then(async () => {
+      let writtenBytes = 0;
+      try {
+        while (writtenBytes < bytes.byteLength) {
+          if (terminalEnded || terminal.closed) {
+            throw new Error("PTY is closed.");
+          }
+
+          const generationBeforeWrite = drainGeneration;
+          const accepted = terminal.write(bytes.subarray(writtenBytes));
+          if (accepted < 0 || accepted > bytes.byteLength - writtenBytes) {
+            throw new Error(`PTY accepted an invalid byte count: ${accepted}.`);
+          }
+          writtenBytes += accepted;
+
+          if (writtenBytes < bytes.byteLength) {
+            await waitForDrainOrExit({
+              generationBeforeWrite,
+              currentGeneration: () => drainGeneration,
+              terminalEnded: () => terminalEnded || terminal.closed,
+              drainWaiters,
+            });
+          }
+        }
+        return writtenBytes;
+      } catch (error) {
+        throw new ShellProcessWriteError(
+          error instanceof Error ? error.message : String(error),
+          writtenBytes,
+        );
+      }
+    });
+    writeQueue = operation.then(
+      () => undefined,
+      () => undefined,
+    );
+    return operation;
+  };
+
+  const exit = subprocess.exited.then(
+    (code): ProcessExitResult => ({
+      code: subprocess.signalCode === null ? code : null,
+      signal: subprocess.signalCode,
+    }),
+    (error): ProcessExitResult => ({
+      code: null,
+      signal: null,
+      error: error instanceof Error ? error.message : String(error),
+    }),
+  );
+
+  return {
+    pid: subprocess.pid,
+    mode: "pty",
+    get exitCode() {
+      return subprocess.exitCode;
+    },
+    get signalCode() {
+      return subprocess.signalCode;
+    },
+    wait: () => exit,
+    waitForOutputClose: () => terminalExit,
+    write,
+    close() {
+      if (!terminal.closed) {
+        terminal.close();
+      }
+    },
+  };
+}
+
+async function waitForDrainOrExit(input: {
+  generationBeforeWrite: number;
+  currentGeneration(): number;
+  terminalEnded(): boolean;
+  drainWaiters: Set<() => void>;
+}): Promise<void> {
+  if (
+    input.currentGeneration() !== input.generationBeforeWrite ||
+    input.terminalEnded()
+  ) {
+    return;
+  }
+
+  await new Promise<void>((resolve) => {
+    input.drainWaiters.add(resolve);
+    if (
+      input.currentGeneration() !== input.generationBeforeWrite ||
+      input.terminalEnded()
+    ) {
+      input.drainWaiters.delete(resolve);
+      resolve();
+    }
+  });
+}
+
+function waitForNodeProcessExit(
+  process: ChildProcessWithoutNullStreams,
+): Promise<ProcessExitResult> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result: ProcessExitResult) => {
+      if (!settled) {
+        settled = true;
+        resolve(result);
+      }
+    };
+
+    process.once("error", (error) => {
+      finish({ code: null, signal: null, error: error.message });
+    });
+    process.once("exit", (code, signal) => {
+      finish({ code, signal });
+    });
+  });
+}
+
+function waitForNodeProcessClose(
+  process: ChildProcessWithoutNullStreams,
+): Promise<void> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (!settled) {
+        settled = true;
+        resolve();
+      }
+    };
+
+    process.once("error", finish);
+    process.once("close", finish);
+  });
+}
+
+function pipeOutput(
+  stream: NodeJS.ReadableStream,
+  onOutput: (bytes: Uint8Array) => void,
+): void {
+  stream.on("data", (chunk: Buffer | string) => {
+    onOutput(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  });
+}
+
+const bashWrapperScript = `
+eval "$TINKER_BASH_COMMAND"
+exit_code=$?
+pwd -P > "$TINKER_BASH_CWD_FILE"
+exit "$exit_code"
+`;