tinker-agent 2.9.0 → 2.10.0

package/src/tools/shell-process.ts

@@ -14,6 +14,7 @@ export type ShellProcessHandle = {
   readonly mode: ShellProcessMode;
   readonly exitCode: number | null;
   readonly signalCode: NodeJS.Signals | null;
+  readonly outputClosed: boolean;
   wait(): Promise<ProcessExitResult>;
   waitForOutputClose(): Promise<void>;
   write?(chars: string): Promise<number>;
@@ -35,6 +36,8 @@ export async function spawnShellProcess(input: {
   command: string;
   cwd: string;
   cwdFilePath: string;
+  cols?: number;
+  rows?: number;
   onOutput(bytes: Uint8Array): void;
 }): Promise<ShellProcessHandle> {
   const env = {
@@ -65,7 +68,16 @@ async function spawnPipeShellProcess(input: {
   pipeOutput(child.stderr, (bytes) => input.onOutput(bytes));
 
   const exit = waitForNodeProcessExit(child);
-  const close = waitForNodeProcessClose(child);
+  let outputClosed = false;
+  let resolveOutputClose: () => void;
+  const close = new Promise<void>((resolve) => {
+    resolveOutputClose = resolve;
+  });
+  const settleOutputClose = () => {
+    outputClosed = true;
+    resolveOutputClose();
+  };
+  void waitForNodeProcessClose(child).then(settleOutputClose);
   if (child.pid === undefined) {
     const result = await exit;
     throw new Error(result.error ?? "Bash process failed to start.");
@@ -80,15 +92,25 @@ async function spawnPipeShellProcess(input: {
     get signalCode() {
       return child.signalCode;
     },
+    get outputClosed() {
+      return outputClosed;
+    },
     wait: () => exit,
     waitForOutputClose: () => close,
-    close() {},
+    close() {
+      child.stdin.destroy();
+      child.stdout.destroy();
+      child.stderr.destroy();
+      settleOutputClose();
+    },
   };
 }
 
 function spawnPtyShellProcess(input: {
   cwd: string;
   env: NodeJS.ProcessEnv;
+  cols?: number;
+  rows?: number;
   onOutput(bytes: Uint8Array): void;
 }): ShellProcessHandle {
   let terminalEnded = false;
@@ -125,8 +147,8 @@ function spawnPtyShellProcess(input: {
       GIT_PAGER: "cat",
     },
     terminal: {
-      cols: TERMINAL_SCREEN_COLUMNS,
-      rows: TERMINAL_SCREEN_ROWS,
+      cols: input.cols ?? TERMINAL_SCREEN_COLUMNS,
+      rows: input.rows ?? TERMINAL_SCREEN_ROWS,
       name: "xterm-256color",
       data(_terminal, bytes) {
         input.onOutput(new Uint8Array(bytes));
@@ -205,6 +227,9 @@ function spawnPtyShellProcess(input: {
     get signalCode() {
       return subprocess.signalCode;
     },
+    get outputClosed() {
+      return terminalEnded;
+    },
     wait: () => exit,
     waitForOutputClose: () => terminalExit,
     write,
@@ -212,6 +237,7 @@ function spawnPtyShellProcess(input: {
       if (!terminal.closed) {
         terminal.close();
       }
+      settleTerminalExit();
     },
   };
 }

package/src/tools/task-stop.ts

@@ -37,12 +37,13 @@ export function createTaskStopToolExecutor(options: {
       try {
         const result = await options.taskManager.stopTask(parsed.taskId, "tool");
         return {
-          ok: true,
+          ok: result.task.error === undefined,
           taskId: parsed.taskId,
           task: result.task,
           status: result.task.status,
           requestedSignal: result.requestedSignal,
           escalated: result.escalated,
+          ...(result.task.error === undefined ? {} : { error: result.task.error }),
         };
       } catch (error) {
         const inspection = options.taskManager.inspectTask(parsed.taskId);

package/src/tools/terminal-screen.ts

@@ -3,16 +3,25 @@ import { Terminal } from "@xterm/headless";
 
 export const TERMINAL_SCREEN_ROWS = 24;
 export const TERMINAL_SCREEN_COLUMNS = 80;
+export const MIN_TERMINAL_COLUMNS = 2;
+export const MAX_TERMINAL_DIMENSION = 1_000;
 
 export type TerminalScreen = {
+  readonly rows: number;
+  readonly columns: number;
   write(bytes: Uint8Array): Promise<void>;
   flush(): Promise<void>;
   text(): string;
   dispose(): void;
 };
 
-export function createTerminalScreen(): TerminalScreen {
-  return new HeadlessTerminalScreen(TERMINAL_SCREEN_ROWS, TERMINAL_SCREEN_COLUMNS);
+export function createTerminalScreen(
+  options: { cols?: number; rows?: number } = {},
+): TerminalScreen {
+  return new HeadlessTerminalScreen(
+    options.rows ?? TERMINAL_SCREEN_ROWS,
+    options.cols ?? TERMINAL_SCREEN_COLUMNS,
+  );
 }
 
 export class HeadlessTerminalScreen implements TerminalScreen {

package/src/tools/types.ts

@@ -92,16 +92,27 @@ export type DeleteFileRawResult = {
 
 export type GlobRawResult = {
   ok: boolean;
-  pattern: string;
+  pattern?: string;
   searchPath: string;
   absoluteSearchPath?: string;
   matches?: string[];
+  /** Number of paths returned, including in legacy unpaginated results. */
   matchCount?: number;
+  /** Exact total before pagination; absent in legacy results. */
+  totalMatches?: number;
+  returnedCount?: number;
+  appliedOffset?: number;
+  hasMore?: boolean;
+  nextOffset?: number;
   ignored?: string[];
   error?: string;
 };
 
-export type GrepOutputMode = "content" | "files_with_matches" | "count";
+export type GrepOutputMode =
+  | "content"
+  | "files_with_matches"
+  | "count"
+  | "count-matches";
 
 export type GrepRawResult = {
   ok: boolean;
@@ -113,10 +124,27 @@ export type GrepRawResult = {
   numFiles: number;
   content?: string;
   numLines?: number;
+  /** Structured count records; paths are unescaped and never parsed from display text. */
+  counts?: { filePath: string; count: number }[];
+  /** Sum on this page: matching lines for count, individual matches for count-matches. */
   numMatches?: number;
+  /** Collected pagination units; legacy content results counted all output lines. Not a global total if searchIncomplete. */
+  totalResults?: number;
+  /** Selected pagination units, excluding context and nearby matches shown as context. */
+  returnedResults?: number;
+  paginationUnit?: "matching_lines" | "match_events" | "files";
+  /** More collected pagination units are available, independently of search completeness. */
+  hasMore?: boolean;
+  nextOffset?: number;
   appliedLimit?: number;
   appliedOffset?: number;
+  /** True for interrupted searches (e.g. timeout or output buffer limit), not pagination. */
+  searchIncomplete?: boolean;
+  /** The search stopped early, so requested context cannot be guaranteed complete. */
+  contextMayBeIncomplete?: boolean;
+  /** Legacy default exclusions, not observed skips. New Grep results omit this field. */
   ignored?: string[];
+  /** Compatibility flag combining pagination and interrupted search; prefer explicit fields above. */
   truncated?: boolean;
   error?: string;
 };

package/src/tui/event-store.ts

@@ -873,6 +873,9 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         ? base
         : `${base} -> ${raw.asset.mimeType}, ${raw.asset.width}x${raw.asset.height}, ${raw.asset.byteLength} bytes`;
     case "glob":
+      if (raw.ok && raw.totalMatches !== undefined) {
+        return `${base} -> ${raw.returnedCount ?? raw.matches?.length ?? 0} of ${raw.totalMatches} matches`;
+      }
       return raw.ok && raw.matchCount !== undefined
         ? `${base} -> ${raw.matchCount} match${raw.matchCount === 1 ? "" : "es"}`
         : base;
@@ -881,11 +884,21 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         return `${base} -> ${raw.numLines} line${raw.numLines === 1 ? "" : "s"}`;
       }
       if (
-        raw.mode === "count" &&
+        (raw.mode === "count" || raw.mode === "count-matches") &&
         raw.numMatches !== undefined &&
         raw.numFiles !== undefined
       ) {
-        return `${base} -> ${raw.numMatches} match${raw.numMatches === 1 ? "" : "es"} across ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}`;
+        const unit =
+          raw.mode === "count"
+            ? `matching line${raw.numMatches === 1 ? "" : "s"}`
+            : `match${raw.numMatches === 1 ? "" : "es"}`;
+        const scope =
+          raw.appliedLimit !== undefined || (raw.appliedOffset ?? 0) > 0
+            ? " (this page)"
+            : raw.truncated
+              ? " (partial results)"
+              : "";
+        return `${base} -> ${raw.numMatches} ${unit} across ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}${scope}`;
       }
       return `${base} -> ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}`;
     case "read":

package/src/tui/remote-app.tsx

@@ -0,0 +1,210 @@
+import { Box, Text, useApp, useInput } from "ink";
+import { TextInput } from "@inkjs/ui";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { RemoteClient } from "../remote/client";
+import type { RemoteSessionInfo } from "../remote/protocol";
+
+/** An explicit network client mode; the normal App/controller path is untouched. */
+export function RemoteApp({ client }: { client: RemoteClient }) {
+  const state = useSyncExternalStore(client.subscribe, client.getSnapshot);
+  const { exit } = useApp();
+  const [workspaces, setWorkspaces] = useState<{ id: string; name: string }[]>([]);
+  const [sessions, setSessions] = useState<RemoteSessionInfo[]>([]);
+  const [workspace, setWorkspace] = useState<string | undefined>(client.workspaceId);
+  const [notice, setNotice] = useState(
+    "Select a workspace number. /workspaces returns here; /quit detaches.",
+  );
+  const [inputKey, setInputKey] = useState(0);
+  const [visibleCount, setVisibleCount] = useState(30);
+  const [browsing, setBrowsing] = useState(!client.sessionId);
+  const report = (error: unknown) =>
+    setNotice(error instanceof Error ? error.message : String(error));
+  useEffect(() => {
+    void client
+      .workspaces()
+      .then((result) => setWorkspaces(result.workspaces))
+      .catch(report);
+  }, [client]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") exit();
+  });
+  const submit = async (text: string) => {
+    setInputKey((value) => value + 1);
+    if (!text.trim()) return;
+    if (text === "/quit") {
+      exit();
+      return;
+    }
+    if (text === "/workspaces") {
+      setWorkspace(undefined);
+      setBrowsing(true);
+      setSessions([]);
+      setWorkspaces((await client.workspaces()).workspaces);
+      return;
+    }
+    if (browsing) {
+      if (!workspace) {
+        const chosen = workspaces[Number(text) - 1];
+        if (!chosen) throw new Error("Enter a workspace number.");
+        setWorkspace(chosen.id);
+        setSessions((await client.sessions(chosen.id)).sessions);
+        setNotice(
+          "Enter a session number, or /new. A local session is explicitly attached when selected.",
+        );
+      } else if (text === "/new") {
+        await client.submit({ kind: "create", workspaceId: workspace });
+        setBrowsing(false);
+      } else {
+        const chosen = sessions[Number(text) - 1];
+        if (!chosen) throw new Error("Enter a session number or /new.");
+        if (chosen.owner === "local")
+          await client.submit({
+            kind: "adopt",
+            workspaceId: workspace,
+            sessionId: chosen.id,
+          });
+        else await client.select(chosen.id, workspace);
+        setBrowsing(false);
+      }
+      return;
+    }
+    const sessionId = client.sessionId;
+    if (!sessionId) throw new Error("Waiting for the service to accept the session.");
+    const pending = state.view?.interaction;
+    if (text === "/stop") {
+      if (!state.view?.activeRequestId) throw new Error("No active task is shown.");
+      await client.submit({
+        kind: "stop",
+        sessionId,
+        targetRequestId: state.view.activeRequestId,
+      });
+    } else if (text === "/allow" || text === "/deny") {
+      if (pending?.kind !== "confirmation")
+        throw new Error("No confirmation is pending.");
+      await client.submit({
+        kind: "confirm",
+        sessionId,
+        interactionId: pending.id,
+        decision: text === "/allow" ? "allow" : "deny",
+      });
+    } else if (text.startsWith("/answer ") || text === "/dismiss") {
+      if (pending?.kind !== "question") throw new Error("No question is pending.");
+      await client.submit({
+        kind: "answer",
+        sessionId,
+        interactionId: pending.id,
+        selectedIndex: text === "/dismiss" ? null : Number(text.slice(8)) - 1,
+      });
+    } else if (text === "/history") {
+      await client.loadOlderHistory();
+      setVisibleCount((count) => count + 80);
+      setNotice(
+        "Older history loaded; use your terminal scrollback to read previous renders.",
+      );
+    } else if (text.startsWith("/")) {
+      throw new Error(
+        "Commands: /stop /allow /deny /answer N /dismiss /history /workspaces /quit",
+      );
+    } else {
+      await client.submit({ kind: "prompt", sessionId, prompt: text });
+    }
+  };
+  const view = state.view;
+  return (
+    <Box flexDirection="column">
+      <Text bold color="cyan">
+        Tinker · Service connection
+      </Text>
+      <Text>
+        {state.connection} · {view?.status ?? "select session"} · {state.pending}{" "}
+        unsubmitted
+      </Text>
+      <Text dimColor>{notice}</Text>
+      {state.error && <Text color="red">{safe(state.error)}</Text>}
+      {browsing ? (
+        <Box flexDirection="column">
+          {!workspace
+            ? workspaces.map((w, i) => (
+                <Text key={w.id}>
+                  {i + 1}. {safe(w.name)}
+                </Text>
+              ))
+            : sessions.map((s, i) => (
+                <Text key={s.id}>
+                  {i + 1}. {safe(s.title)} · {s.status} · {s.owner}
+                </Text>
+              ))}
+        </Box>
+      ) : (
+        <Box flexDirection="column">
+          <Text bold>{safe(view?.session.title ?? "Connecting…")}</Text>
+          {view?.history.messages.slice(-visibleCount).map((message) => (
+            <Box key={message.id} flexDirection="column" marginTop={1}>
+              <Text bold color={message.role === "user" ? "green" : "cyan"}>
+                {message.name ?? message.role}
+              </Text>
+              <Text>{safe(message.text)}</Text>
+              {message.toolCalls?.map((call) => (
+                <Text key={call.id} dimColor>
+                  {call.name} {safe(call.arguments)}
+                </Text>
+              ))}
+            </Box>
+          ))}
+          {view?.streaming && (
+            <Box flexDirection="column">
+              <Text dimColor>Generating…</Text>
+              <Text>{safe(view.streaming.text)}</Text>
+            </Box>
+          )}
+          {view?.tools
+            .filter((tool) => tool.status === "running")
+            .map((tool) => (
+              <Text key={tool.id} color="yellow">
+                {tool.name}: {safe(tool.arguments)}
+              </Text>
+            ))}
+          {view?.interaction?.kind === "question" && (
+            <Box flexDirection="column">
+              <Text color="yellow">{safe(view.interaction.question)}</Text>
+              {view.interaction.options.map((option, i) => (
+                <Text key={i}>
+                  {i + 1}. {safe(option.description)}
+                </Text>
+              ))}
+              <Text>/answer N or /dismiss</Text>
+            </Box>
+          )}
+          {view?.interaction?.kind === "confirmation" && (
+            <Box flexDirection="column">
+              <Text color="yellow">{safe(view.interaction.command)}</Text>
+              <Text>{safe(view.interaction.reason)} · /allow or /deny</Text>
+            </Box>
+          )}
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Text color="cyan">› </Text>
+        <TextInput
+          key={inputKey}
+          placeholder={
+            browsing
+              ? "Choose a workspace/session"
+              : "Send task; /stop cancels; /quit detaches"
+          }
+          onSubmit={(value) => {
+            void submit(value).catch(report);
+          }}
+        />
+      </Box>
+    </Box>
+  );
+}
+function safe(value: string): string {
+  return [...value]
+    .filter((character) => {
+      const code = character.codePointAt(0)!;
+      return code === 10 || code === 9 || (code >= 32 && (code < 127 || code > 159));
+    })
+    .join("");
+}