tinker-agent 1.5.1 → 1.7.0

package/src/tools/bash-task.ts

@@ -1,4 +1,3 @@
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { mkdir, open, readFile, unlink } from "node:fs/promises";
 import path from "node:path";
 import type {
@@ -8,7 +7,19 @@ import type {
 import type { ToolCallIdentity } from "../agent/types";
 import { createUuidV7 } from "../ids/uuid-v7";
 import { isWorkspaceLocalCwd, type CwdState } from "./cwd-state";
+import {
+  type ProcessExitResult,
+  type ShellProcessHandle,
+  type ShellProcessMode,
+  spawnShellProcess,
+} from "./shell-process";
 import { TaskOutput, type TaskOutputSnapshot } from "./task-output";
+import {
+  createTerminalScreen,
+  TERMINAL_SCREEN_COLUMNS,
+  TERMINAL_SCREEN_ROWS,
+  type TerminalScreen,
+} from "./terminal-screen";
 
 export type ShellTaskStatus =
   | "running"
@@ -38,11 +49,15 @@ export type ShellTaskSnapshot = {
   outputBytes: number;
   outputLines: number;
   cwd: string;
+  tty: boolean;
 };
 
 export type ShellTaskInspection = {
   task: ShellTaskSnapshot;
   output: TaskOutputSnapshot;
+  screenRows?: number;
+  screenColumns?: number;
+  screen?: string;
 };
 
 export type ShellTaskHandle = {
@@ -81,9 +96,12 @@ type ManagedShellTask = {
   outputFilePath: string;
   cwdFilePath: string;
   cwd: string;
-  process: ChildProcessWithoutNullStreams;
+  mode: ShellProcessMode;
+  process: ShellProcessHandle;
   processGroupId: number;
   output: TaskOutput;
+  terminalScreen?: TerminalScreen;
+  finalScreen?: string;
   completion: Promise<ShellTaskSnapshot>;
   stopPromise?: Promise<StopTaskResult>;
   terminalEventEmitted: boolean;
@@ -115,6 +133,7 @@ export class ShellTaskManager {
     command: string;
     description: string;
     origin: ShellTaskOrigin;
+    tty: boolean;
   }): Promise<ShellTaskHandle> {
     if (!this.acceptingTasks) {
       throw new Error("Cannot start a Bash task after task manager shutdown.");
@@ -142,22 +161,26 @@ export class ShellTaskManager {
       throw new Error("Cannot start a Bash task after task manager shutdown.");
     }
 
-    const child = spawn("bash", ["-lc", bashWrapperScript], {
-      cwd: this.options.cwdState.cwd,
-      detached: true,
-      env: {
-        ...process.env,
-        NO_COLOR: "1",
-        TINKER_BASH_COMMAND: input.command,
-        TINKER_BASH_CWD_FILE: cwdFilePath,
-      },
-    });
-
-    if (child.pid === undefined) {
-      const spawnError = await waitForProcessError(child);
+    const terminalScreen = input.tty ? createTerminalScreen() : undefined;
+    let shellProcess: ShellProcessHandle;
+    try {
+      shellProcess = await spawnShellProcess({
+        mode: input.tty ? "pty" : "pipe",
+        command: input.command,
+        cwd: this.options.cwdState.cwd,
+        cwdFilePath,
+        onOutput(bytes) {
+          output.write(Buffer.from(bytes));
+          if (terminalScreen !== undefined) {
+            void terminalScreen.write(bytes).catch(() => undefined);
+          }
+        },
+      });
+    } catch (error) {
+      terminalScreen?.dispose();
       await output.end();
       await unlinkIfExists(cwdFilePath);
-      throw spawnError;
+      throw error;
     }
 
     const task: ManagedShellTask = {
@@ -170,15 +193,15 @@ export class ShellTaskManager {
       outputFilePath,
       cwdFilePath,
       cwd: this.options.cwdState.cwd,
-      process: child,
-      processGroupId: child.pid,
+      mode: shellProcess.mode,
+      process: shellProcess,
+      processGroupId: shellProcess.pid,
       output,
+      terminalScreen,
       completion: Promise.resolve(undefined as never),
       terminalEventEmitted: false,
     };
 
-    pipeTaskOutput(task.process.stdout, task.output);
-    pipeTaskOutput(task.process.stderr, task.output);
     task.completion = this.monitorTaskSafely(task);
     this.tasks.set(id, task);
 
@@ -231,10 +254,45 @@ export class ShellTaskManager {
     }
 
     this.synchronizeTerminalState(task);
-    return {
-      task: this.snapshot(task),
-      output: task.output.snapshot(),
-    };
+    return this.inspection(task);
+  }
+
+  async inspectTaskOutput(taskId: string): Promise<ShellTaskInspection | undefined> {
+    const task = this.tasks.get(taskId);
+    if (task === undefined) {
+      return undefined;
+    }
+
+    this.synchronizeTerminalState(task);
+    if (
+      task.mode === "pty" &&
+      isTerminalStatus(task.status) &&
+      task.finalScreen === undefined
+    ) {
+      await task.completion;
+    } else {
+      await task.terminalScreen?.flush();
+    }
+    return this.inspection(task);
+  }
+
+  taskCompletion(taskId: string): Promise<ShellTaskSnapshot> {
+    return this.requireTask(taskId).completion;
+  }
+
+  async writeTaskInput(taskId: string, chars: string): Promise<number> {
+    const task = this.requireTask(taskId);
+    this.synchronizeTerminalState(task);
+    if (task.mode !== "pty" || task.process.write === undefined) {
+      throw new Error(
+        `Task ${taskId} does not accept terminal input; start it with Bash tty=true.`,
+      );
+    }
+    if (task.status !== "running") {
+      throw new Error(`Task ${taskId} is not running (status=${task.status}).`);
+    }
+
+    return task.process.write(chars);
   }
 
   async stopTask(taskId: string, reason: StopTaskReason): Promise<StopTaskResult> {
@@ -372,20 +430,43 @@ export class ShellTaskManager {
           outputError instanceof Error ? outputError.message : String(outputError)
         }`;
       }
+      if (task.terminalScreen !== undefined) {
+        try {
+          await task.terminalScreen.flush();
+          task.finalScreen = task.terminalScreen.text();
+        } catch {
+          // The original monitor error remains the primary task failure.
+        }
+        task.terminalScreen.dispose();
+      }
+      task.process.close();
       await unlinkIfExists(task.cwdFilePath);
 
-      return this.snapshot(task);
+      const snapshot = this.snapshot(task);
+      if (task.backgroundedAt !== undefined && !task.terminalEventEmitted) {
+        task.terminalEventEmitted = true;
+        await this.options.runtimeSession.append({
+          type: "bash.task.finished",
+          ...task.origin,
+          data: { task: snapshot },
+        });
+      }
+      return snapshot;
     }
   }
 
   private async monitorTask(task: ManagedShellTask): Promise<ShellTaskSnapshot> {
-    const exit = waitForProcessExit(task.process);
-    const close = waitForProcessClose(task.process);
-    const result = await exit;
+    const result = await task.process.wait();
 
     this.applyTermination(task, result);
-    await close;
+    await task.process.waitForOutputClose();
     await task.output.end();
+    if (task.terminalScreen !== undefined) {
+      await task.terminalScreen.flush();
+      task.finalScreen = task.terminalScreen.text();
+      task.terminalScreen.dispose();
+    }
+    task.process.close();
     await this.updateCwdFromFile(task);
     await unlinkIfExists(task.cwdFilePath);
 
@@ -464,6 +545,25 @@ export class ShellTaskManager {
       outputBytes: output.outputBytes,
       outputLines: output.outputLines,
       cwd: task.cwd,
+      tty: task.mode === "pty",
+    };
+  }
+
+  private inspection(task: ManagedShellTask): ShellTaskInspection {
+    const screen =
+      task.mode === "pty"
+        ? (task.finalScreen ?? task.terminalScreen?.text() ?? "")
+        : undefined;
+    return {
+      task: this.snapshot(task),
+      output: task.output.snapshot(),
+      ...(screen === undefined
+        ? {}
+        : {
+            screenRows: TERMINAL_SCREEN_ROWS,
+            screenColumns: TERMINAL_SCREEN_COLUMNS,
+            screen,
+          }),
     };
   }
 
@@ -488,54 +588,6 @@ export class ShellTaskManager {
   }
 }
 
-type ProcessExitResult = {
-  code: number | null;
-  signal: NodeJS.Signals | null;
-  error?: string;
-};
-
-function waitForProcessExit(
-  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 waitForProcessError(process: ChildProcessWithoutNullStreams): Promise<Error> {
-  return new Promise((resolve) => {
-    process.once("error", resolve);
-  });
-}
-
-function waitForProcessClose(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 signalProcessGroup(
   task: ManagedShellTask,
   signal: "SIGTERM" | "SIGKILL",
@@ -573,12 +625,6 @@ function isTerminalStatus(status: ShellTaskStatus): boolean {
   return status === "completed" || status === "failed" || status === "killed";
 }
 
-function pipeTaskOutput(stream: NodeJS.ReadableStream, output: TaskOutput): void {
-  stream.on("data", (chunk: Buffer | string) => {
-    output.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  });
-}
-
 async function ensureEmptyFile(filePath: string): Promise<void> {
   await mkdir(path.dirname(filePath), { recursive: true });
   const file = await open(filePath, "w");
@@ -608,10 +654,3 @@ function errorCode(error: unknown): unknown {
     ? error.code
     : undefined;
 }
-
-const bashWrapperScript = `
-eval "$TINKER_BASH_COMMAND"
-exit_code=$?
-pwd -P > "$TINKER_BASH_CWD_FILE"
-exit "$exit_code"
-`;

package/src/tools/bash.ts

@@ -12,12 +12,14 @@ import { defineToolExecutor } from "./types";
 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";
 
 type BashArgs = {
   command: string;
   timeout?: number;
   description?: string;
   run_in_background?: boolean;
+  tty?: boolean;
 };
 
 export type BashToolOptions = {
@@ -65,6 +67,11 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
             type: "boolean",
             description: "Run the command in the background and return immediately.",
           },
+          tty: {
+            type: "boolean",
+            description:
+              "Run the command in a pseudo-terminal so it can receive interactive input.",
+          },
         },
         required: ["command"],
       },
@@ -86,26 +93,62 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
           outputLines: 0,
           preview: "",
           truncated: false,
+          tty: false,
           error: parsed.error,
         };
       }
 
       const input = parsed.value;
+      const risk = classifyBashRisk(input.command, {
+        workspaceRoot: options.workspaceRoot,
+      });
+      if (risk.dangerous && context.confirmBashCommand !== undefined) {
+        const decision = await context.confirmBashCommand({
+          command: input.command,
+          reason: risk.reason,
+        });
+        throwIfTurnCancelled(context.signal);
+        if (decision === "deny") {
+          const suffix =
+            context.bashGuardSurface === "one-shot"
+              ? "Non-interactive mode cannot confirm; rerun with --yolo."
+              : "The user declined this command.";
+          return {
+            ok: false,
+            command: input.command,
+            taskId: "",
+            sessionId: call.sessionId,
+            status: "failed",
+            cwd: options.cwdState.cwd,
+            outputFilePath: "",
+            outputBytes: 0,
+            outputLines: 0,
+            preview: "",
+            truncated: false,
+            tty: input.tty === true,
+            error: `Command denied: ${risk.reason}. ${suffix}`,
+          };
+        }
+      }
       const foregroundTimeoutMs = input.timeout ?? defaultTimeoutMs;
       throwIfTurnCancelled(context.signal);
       const task = await options.taskManager.start({
         command: input.command,
         description: input.description ?? input.command,
         origin: call,
+        tty: input.tty === true,
       });
 
       if (input.run_in_background === true) {
         // Starting and publishing an explicit background task is one commit
         // boundary. Cancellation is observed after its result is recorded.
         await options.taskManager.markBackgrounded(task.taskId, "requested");
-        const inspection = requireTaskInspection(options.taskManager, task.taskId);
+        const inspection = await requireTaskOutputInspection(
+          options.taskManager,
+          task.taskId,
+        );
         if (inspection.task.status !== "running") {
-          return buildCompletedResult(inspection.task, inspection.output);
+          return buildCompletedResult(inspection);
         }
 
         return buildRunningResult({
@@ -124,9 +167,12 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
         // Timeout wins ownership. Marking the task backgrounded and returning
         // its task ID is an uninterrupted commit boundary.
         await options.taskManager.markBackgrounded(task.taskId, "foreground_timeout");
-        const inspection = requireTaskInspection(options.taskManager, task.taskId);
+        const inspection = await requireTaskOutputInspection(
+          options.taskManager,
+          task.taskId,
+        );
         if (inspection.task.status !== "running") {
-          return buildCompletedResult(inspection.task, inspection.output);
+          return buildCompletedResult(inspection);
         }
 
         return buildRunningResult({
@@ -138,11 +184,14 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
         });
       }
 
-      const inspection = requireTaskInspection(options.taskManager, task.taskId);
-      const raw = await buildCompletedResult(waitResult.task, inspection.output);
+      const inspection = await requireTaskOutputInspection(
+        options.taskManager,
+        task.taskId,
+      );
+      const raw = await buildCompletedResult(inspection);
       updateCwdStateAfterForegroundCommand({
         raw,
-        task: waitResult.task,
+        task: inspection.task,
         cwdState: options.cwdState,
         workspaceRoot: options.workspaceRoot,
       });
@@ -179,6 +228,10 @@ export function parseBashArgs(
     return { ok: false, error: "Bash.run_in_background must be a boolean." };
   }
 
+  if (args.tty !== undefined && typeof args.tty !== "boolean") {
+    return { ok: false, error: "Bash.tty must be a boolean." };
+  }
+
   return {
     ok: true,
     value: {
@@ -189,6 +242,7 @@ export function parseBashArgs(
           ? undefined
           : args.description,
       run_in_background: args.run_in_background,
+      tty: args.tty,
     },
   };
 }
@@ -294,18 +348,22 @@ function buildRunningResult(input: {
     timeoutMs: input.timeoutMs,
     backgrounded: input.backgrounded,
     backgroundedDueToTimeout: input.backgroundedDueToTimeout,
+    tty: task.tty,
+    screenRows: input.inspection.screenRows,
+    screenColumns: input.inspection.screenColumns,
+    screen: input.inspection.screen,
   };
 }
 
 async function buildCompletedResult(
-  task: ShellTaskSnapshot,
-  fallbackOutput: TaskOutputSnapshot,
+  inspection: ShellTaskInspection,
 ): Promise<BashRawResult> {
+  const { task } = inspection;
   if (task.status === "running" || task.status === "stopping") {
     throw new Error(`Bash task ${task.taskId} completed with status=${task.status}.`);
   }
 
-  const snapshot = await snapshotCompletedOutput(task, fallbackOutput);
+  const snapshot = await snapshotCompletedOutput(task, inspection.output);
   const interpretation = interpretCommandResult({
     command: task.command,
     exitCode: task.exitCode,
@@ -328,6 +386,10 @@ async function buildCompletedResult(
     truncated: snapshot.truncated,
     omittedLines: snapshot.omittedLines,
     returnCodeInterpretation: interpretation.interpretation,
+    tty: task.tty,
+    screenRows: inspection.screenRows,
+    screenColumns: inspection.screenColumns,
+    screen: inspection.screen,
     error: task.error,
   };
 }
@@ -359,11 +421,11 @@ function updateCwdStateAfterForegroundCommand(input: {
   }
 }
 
-function requireTaskInspection(
+async function requireTaskOutputInspection(
   taskManager: ShellTaskManager,
   taskId: string,
-): ShellTaskInspection {
-  const inspection = taskManager.inspectTask(taskId);
+): Promise<ShellTaskInspection> {
+  const inspection = await taskManager.inspectTaskOutput(taskId);
   if (inspection === undefined) {
     throw new Error(`Bash task disappeared from task manager: ${taskId}`);
   }

package/src/tools/delete.ts

@@ -0,0 +1,182 @@
+import { lstat, readFile, rm } from "node:fs/promises";
+import { throwIfTurnCancelled } from "../agent/turn-cancellation";
+import { resolveWorkspacePath } from "./path-safety";
+import type { TurnUndoManager } from "./turn-undo-manager";
+import { defineToolExecutor } from "./types";
+import type {
+  DeleteFileRawResult,
+  FileSnapshotStore,
+  ToolExecutionContext,
+  ToolExecutor,
+} from "./types";
+
+type DeleteArgs = {
+  file_path: string;
+};
+
+export type DeleteToolOptions = {
+  workspaceRoot: string;
+  snapshots: FileSnapshotStore;
+  undoManager?: TurnUndoManager;
+};
+
+export function createDeleteToolExecutor(options: DeleteToolOptions): ToolExecutor {
+  return defineToolExecutor("delete", {
+    definition: {
+      name: "Delete",
+      description:
+        "Delete one existing regular file. Directories and symbolic links are not supported.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Workspace-relative path or absolute path.",
+          },
+        },
+        required: ["file_path"],
+      },
+    },
+    async execute(
+      args,
+      call,
+      context: ToolExecutionContext,
+    ): Promise<DeleteFileRawResult> {
+      throwIfTurnCancelled(context.signal);
+      const parsed = parseDeleteArgs(args);
+
+      if (!parsed.ok) {
+        return {
+          ok: false,
+          filePath: "",
+          error: parsed.error,
+        };
+      }
+
+      const input = parsed.value;
+      let absolutePath: string;
+
+      try {
+        absolutePath = resolveWorkspacePath(options.workspaceRoot, input.file_path);
+      } catch (error) {
+        return {
+          ok: false,
+          filePath: input.file_path,
+          error: errorMessage(error),
+        };
+      }
+
+      let info: Awaited<ReturnType<typeof lstat>>;
+      try {
+        info = await lstat(absolutePath);
+      } catch (error) {
+        return {
+          ok: false,
+          filePath: input.file_path,
+          absolutePath,
+          error: deleteErrorMessage(error),
+        };
+      }
+
+      if (info.isSymbolicLink()) {
+        return {
+          ok: false,
+          filePath: input.file_path,
+          absolutePath,
+          error: "Symbolic links are not supported.",
+        };
+      }
+
+      if (!info.isFile()) {
+        return {
+          ok: false,
+          filePath: input.file_path,
+          absolutePath,
+          error: "Path is not a regular file.",
+        };
+      }
+
+      const undoCapture = await options.undoManager?.captureBeforeMutation({
+        turnId: call.turnId,
+        turnNumber: call.turnNumber,
+        absolutePath,
+        displayPath: input.file_path,
+        knownByteLength: info.size,
+        loadBefore: async () => ({
+          state: "present",
+          bytes: await readFile(absolutePath),
+        }),
+      });
+
+      try {
+        throwIfTurnCancelled(context.signal);
+        await rm(absolutePath);
+      } catch (error) {
+        if (undoCapture !== undefined) {
+          await options.undoManager?.recordMutationFailure(undoCapture);
+        }
+        if (context.signal.aborted) {
+          throw error;
+        }
+        return {
+          ok: false,
+          filePath: input.file_path,
+          absolutePath,
+          error: deleteErrorMessage(error),
+        };
+      }
+
+      if (undoCapture !== undefined) {
+        options.undoManager?.recordMutationResult(undoCapture, { state: "absent" });
+      }
+      options.snapshots.delete(absolutePath);
+
+      return {
+        ok: true,
+        filePath: input.file_path,
+        absolutePath,
+      };
+    },
+  });
+}
+
+function parseDeleteArgs(
+  args: unknown,
+): { ok: true; value: DeleteArgs } | { ok: false; error: string } {
+  if (!isRecord(args)) {
+    return { ok: false, error: "Delete arguments must be an object." };
+  }
+
+  if (typeof args.file_path !== "string") {
+    return { ok: false, error: "Delete.file_path must be a string." };
+  }
+
+  return {
+    ok: true,
+    value: {
+      file_path: args.file_path,
+    },
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function deleteErrorMessage(error: unknown): string {
+  return isNotFound(error) ? "File does not exist." : errorMessage(error);
+}
+
+function isNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}