@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/core/tools/bash-core.js

@@ -0,0 +1,169 @@
+import { bashOutputSchema, bashSchema, bashToolConfig, } from "./bash-schema.js";
+import { createMachineOutputSpill } from "./machine-output-spill.js";
+import { OutputAccumulator } from "./output-accumulator-core.js";
+import { createShellOutput } from "./shell-output.js";
+import { createShellOperations, machineShellExecHost } from "./shell-operations.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "./truncate.js";
+/** Output limit of `structuredContent.output`, which programmatic callers such as codemode scripts receive. */
+const STRUCTURED_OUTPUT_MAX_BYTES = 1024 * 1024;
+function resolveSpawnContext(command, cwd, baseEnv, spawnHook, exposeSessionEnvironment, ctx) {
+    const env = { ...baseEnv };
+    delete env.PI_SESSION_ID;
+    delete env.PI_SESSION_FILE;
+    delete env.PI_SESSION_CWD;
+    delete env.PI_GOAL_STORE_FILE;
+    delete env.PI_PROVIDER;
+    delete env.PI_MODEL;
+    delete env.PI_REASONING_LEVEL;
+    delete env.OMO_BROWSER_ENGINE;
+    if (exposeSessionEnvironment && ctx) {
+        const model = ctx.model;
+        env.PI_SESSION_ID = ctx.sessionManager.getSessionId();
+        env.PI_SESSION_CWD = ctx.cwd;
+        if (ctx.goalStoreFile)
+            env.PI_GOAL_STORE_FILE = ctx.goalStoreFile;
+        const sessionFile = ctx.sessionManager.getSessionFile();
+        if (sessionFile)
+            env.PI_SESSION_FILE = sessionFile;
+        if (model) {
+            env.PI_PROVIDER = model.provider;
+            env.PI_MODEL = model.id;
+        }
+        if (ctx.thinkingLevel)
+            env.PI_REASONING_LEVEL = ctx.thinkingLevel;
+        if (ctx.browserEngine)
+            env.OMO_BROWSER_ENGINE = ctx.browserEngine;
+        Object.assign(env, ctx.sessionEnv);
+    }
+    const baseContext = { command, cwd, env };
+    return spawnHook ? spawnHook(baseContext) : baseContext;
+}
+const appendStatus = (text, status) => `${text ? `${text}\n\n` : ""}${status}`;
+/** A shell tool's model-facing definition and execution, without renderers: the shared core of bash and powershell. */
+export function createShellToolCore(cwd, config, options) {
+    const { machine, operations: ops, commandPrefix, spawnHook, annotateTrust } = options;
+    const exposeSessionEnvironment = options.exposeSessionEnvironment ?? true;
+    const redactSecretsInOutput = options.redactSecretsInOutput === true;
+    return {
+        name: config.name,
+        label: config.label,
+        description: `Execute a ${config.shellName} command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        promptSnippet: config.promptSnippet,
+        promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
+        fullPromptGuidelines: exposeSessionEnvironment && config.fullPromptGuidelines ? [...config.fullPromptGuidelines] : undefined,
+        parameters: bashSchema,
+        outputSchema: bashOutputSchema,
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
+        async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
+            const admitted = machine.begin("process.exec", { command, timeout }, signal);
+            if (admitted !== undefined)
+                await admitted;
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            const spawnContext = resolveSpawnContext(resolvedCommand, ctx?.cwd || cwd, options.shellEnv?.() ?? {}, spawnHook, exposeSessionEnvironment, ctx);
+            const output = new OutputAccumulator({ tempFilePrefix: config.tempFilePrefix, spill: options.outputSpill });
+            const shellOutput = createShellOutput(output, onUpdate, redactSecretsInOutput);
+            if (onUpdate) {
+                onUpdate({ content: [], details: undefined });
+            }
+            const startedAt = performance.now();
+            try {
+                let exitCode;
+                try {
+                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
+                        onData: shellOutput.handleData,
+                        redactSecretsInOutput,
+                        signal,
+                        timeout,
+                        env: spawnContext.env,
+                    });
+                    exitCode = result.exitCode;
+                }
+                catch (err) {
+                    let snapshot;
+                    try {
+                        snapshot = await shellOutput.finishOutput();
+                    }
+                    catch (cleanupError) {
+                        throw new AggregateError([err, cleanupError], "Bash command and output cleanup failed");
+                    }
+                    const { text } = shellOutput.formatOutput(snapshot, "");
+                    if (err instanceof Error && err.message === "aborted") {
+                        throw new Error(appendStatus(text, "Command aborted"));
+                    }
+                    if (err instanceof Error && err.message.startsWith("timeout:")) {
+                        const timeoutSecs = err.message.split(":")[1];
+                        throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
+                    }
+                    try {
+                        await output.removeTempFile();
+                    }
+                    catch (unlinkError) {
+                        throw new AggregateError([err, unlinkError], "Bash command and output cleanup failed");
+                    }
+                    throw err;
+                }
+                const snapshot = await shellOutput.finishOutput();
+                const { text: outputText, content, details } = shellOutput.formatOutput(snapshot);
+                if (exitCode === null) {
+                    throw new Error(appendStatus(outputText, "Command terminated without an exit code"));
+                }
+                const wallTimeSeconds = Math.round((performance.now() - startedAt) / 100) / 10;
+                const fullOutput = await output.readFullOutput(STRUCTURED_OUTPUT_MAX_BYTES);
+                const structuredContent = {
+                    output: fullOutput.content,
+                    truncated: fullOutput.truncated,
+                    ...(fullOutput.truncated && snapshot.fullOutputPath
+                        ? { full_output_path: snapshot.fullOutputPath }
+                        : {}),
+                    exit_code: exitCode,
+                    wall_time_seconds: wallTimeSeconds,
+                };
+                if (exitCode !== 0) {
+                    const text = appendStatus(outputText, `Command exited with code ${exitCode}`);
+                    // The engine trust annotation (omo#10762) rides only on error results, so the success
+                    // `outputSchema` (and the prompt bytes it costs) stays unchanged.
+                    const annotation = annotateTrust?.({ exitCode, output: fullOutput.content });
+                    if (annotation === undefined) {
+                        return { content: [{ type: "text", text }], details, structuredContent, isError: true };
+                    }
+                    return {
+                        content: [
+                            { type: "text", text: annotation.text === undefined ? text : `${text}\n\n${annotation.text}` },
+                        ],
+                        details: { ...details, trust: annotation.trust },
+                        structuredContent: { ...structuredContent, trust: annotation.trust },
+                        isError: true,
+                    };
+                }
+                // Success keeps the fork's model-only truncation notice; the error text above carries it inline.
+                return { content, details, structuredContent };
+            }
+            finally {
+                shellOutput.clearUpdateTimer();
+            }
+        },
+    };
+}
+/** The bash tool for a host whose only effect channel is `machine`. */
+export function createCoreBashToolDefinition(cwd, options) {
+    const { machine } = options;
+    return {
+        ...createShellToolCore(cwd, bashToolConfig, {
+            ...options,
+            operations: options.operations ?? createShellOperations("bash", machine, machineShellExecHost(machine, options.shell)),
+            outputSpill: options.outputSpill ?? createMachineOutputSpill(machine),
+        }),
+        exposure: "eval",
+    };
+}
+export function createCoreBashTool(cwd, options) {
+    const definition = createCoreBashToolDefinition(cwd, options);
+    const tool = wrapToolDefinition(definition);
+    Object.assign(tool, {
+        promptSnippet: definition.promptSnippet,
+        promptGuidelines: definition.promptGuidelines,
+    });
+    return tool;
+}
+//# sourceMappingURL=bash-core.js.map

package/dist/core/tools/bash-schema.d.ts

@@ -0,0 +1,48 @@
+import { type Static, Type } from "typebox";
+import type { ShellTrust } from "../../engine-trust/shell-trust.ts";
+import type { TruncationResult } from "./truncate.ts";
+export declare const bashSchema: Type.TObject<{
+    command: Type.TString;
+    timeout: Type.TOptional<Type.TNumber>;
+}>;
+export declare const bashToolSystemPromptContribution: {
+    readonly snippet: "Execute bash commands (ls, rg, find, etc.)";
+    readonly guidelines: readonly ["PI_* env vars = current model + session details."];
+    readonly fullGuidelines: readonly ["You can inspect PI_* environment variables for current model and session details."];
+};
+export type BashToolInput = Static<typeof bashSchema>;
+/**
+ * Result for programmatic callers such as codemode scripts. A non-zero exit code is an error result for the model, but scripts still resolve to this value.
+ * `output` is not limited like the model-facing output: callers decide how much of it reaches the model.
+ */
+export declare const bashOutputSchema: Type.TObject<{
+    output: Type.TString;
+    truncated: Type.TBoolean;
+    full_output_path: Type.TOptional<Type.TString>;
+    exit_code: Type.TNumber;
+    wall_time_seconds: Type.TNumber;
+}>;
+export type BashToolOutput = Static<typeof bashOutputSchema>;
+export interface BashToolDetails {
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+    trust?: ShellTrust;
+}
+export interface BashSpawnContext {
+    command: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type BashSpawnHook = (context: BashSpawnContext) => BashSpawnContext;
+export interface ShellToolConfig {
+    name: string;
+    label: string;
+    shellName: string;
+    prompt: string;
+    promptSnippet: string;
+    promptGuidelines?: readonly string[];
+    fullPromptGuidelines?: readonly string[];
+    tempFilePrefix: string;
+}
+export declare const bashToolConfig: ShellToolConfig;
+//# sourceMappingURL=bash-schema.d.ts.map

package/dist/core/tools/bash-schema.js

@@ -0,0 +1,34 @@
+import { Type } from "typebox";
+export const bashSchema = Type.Object({
+    command: Type.String({ description: "Shell command to execute" }),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+export const bashToolSystemPromptContribution = {
+    snippet: "Execute bash commands (ls, rg, find, etc.)",
+    guidelines: ["PI_* env vars = current model + session details."],
+    fullGuidelines: ["You can inspect PI_* environment variables for current model and session details."],
+};
+/**
+ * Result for programmatic callers such as codemode scripts. A non-zero exit code is an error result for the model, but scripts still resolve to this value.
+ * `output` is not limited like the model-facing output: callers decide how much of it reaches the model.
+ */
+export const bashOutputSchema = Type.Object({
+    output: Type.String({
+        description: "Combined stdout and stderr, up to 1 MiB. Longer output keeps its first and last 512 KiB around an omission marker.",
+    }),
+    truncated: Type.Boolean({ description: "Whether `output` omits part of the command output" }),
+    full_output_path: Type.Optional(Type.String({ description: "Temp file with the full output, when truncated" })),
+    exit_code: Type.Number(),
+    wall_time_seconds: Type.Number(),
+});
+export const bashToolConfig = {
+    name: "bash",
+    label: "bash",
+    shellName: "bash",
+    prompt: "$",
+    promptSnippet: bashToolSystemPromptContribution.snippet,
+    promptGuidelines: bashToolSystemPromptContribution.guidelines,
+    fullPromptGuidelines: bashToolSystemPromptContribution.fullGuidelines,
+    tempFilePrefix: "pi-bash",
+};
+//# sourceMappingURL=bash-schema.js.map

package/dist/core/tools/bash.d.ts

@@ -1,60 +1,11 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { type Static, Type } from "typebox";
-import { type ShellTrust } from "../../engine-trust/shell-trust.ts";
 import { type ShellConfig } from "../../utils/shell.ts";
 import type { ToolDefinition } from "../extensions/types.ts";
+import { type BashSpawnHook, type BashToolDetails, type bashSchema, type ShellToolConfig } from "./bash-schema.ts";
 import { type ToolMachine } from "./machine.ts";
-import { type TruncationResult } from "./truncate.ts";
-declare const bashSchema: Type.TObject<{
-    command: Type.TString;
-    timeout: Type.TOptional<Type.TNumber>;
-}>;
-export declare const bashToolSystemPromptContribution: {
-    readonly snippet: "Execute bash commands (ls, rg, find, etc.)";
-    readonly guidelines: readonly ["PI_* env vars = current model + session details."];
-    readonly fullGuidelines: readonly ["You can inspect PI_* environment variables for current model and session details."];
-};
-export type BashToolInput = Static<typeof bashSchema>;
-/**
- * Result for programmatic callers such as codemode scripts. A non-zero exit code is an error result for the model, but scripts still resolve to this value.
- * `output` is not limited like the model-facing output: callers decide how much of it reaches the model.
- */
-declare const bashOutputSchema: Type.TObject<{
-    output: Type.TString;
-    truncated: Type.TBoolean;
-    full_output_path: Type.TOptional<Type.TString>;
-    exit_code: Type.TNumber;
-    wall_time_seconds: Type.TNumber;
-}>;
-export type BashToolOutput = Static<typeof bashOutputSchema>;
-export interface BashToolDetails {
-    truncation?: TruncationResult;
-    fullOutputPath?: string;
-    trust?: ShellTrust;
-}
-/**
- * Pluggable operations for the bash tool.
- * Override these to delegate command execution to remote systems (for example SSH).
- */
-export interface BashOperations {
-    /**
-     * Execute a command and stream output.
-     * @param command The command to execute
-     * @param cwd Working directory
-     * @param options Execution options
-     * @returns Promise resolving to the exit code. Report signal terminations as 128 + signal number;
-     * a null exit code is treated as a failed command.
-     */
-    exec: (command: string, cwd: string, options: {
-        onData: (data: Buffer, stream?: "stdout" | "stderr") => void;
-        signal?: AbortSignal;
-        timeout?: number;
-        env?: NodeJS.ProcessEnv;
-        redactSecretsInOutput?: boolean;
-    }) => Promise<{
-        exitCode: number | null;
-    }>;
-}
+import { type BashOperations } from "./shell-operations.ts";
+export { type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOutput, bashToolSystemPromptContribution, type ShellToolConfig, } from "./bash-schema.ts";
+export type { BashOperations } from "./shell-operations.ts";
 /**
  * Shared process execution used by the built-in shell tools: one `process.exec` of the operation layer (own
  * process group, scope token, abort/timeout kill the group). The tool keeps its own output handling.
@@ -76,12 +27,6 @@ export declare class DeviceUnavailableError extends Error {
     readonly tool: string;
     constructor(tool: string);
 }
-export interface BashSpawnContext {
-    command: string;
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-}
-export type BashSpawnHook = (context: BashSpawnContext) => BashSpawnContext;
 export interface BashToolOptions {
     /** Redact credential-shaped output before streaming or spilling. Default: false. */
     redactSecretsInOutput?: boolean;
@@ -109,18 +54,7 @@ export type BashRenderState = {
     endedAt: number | undefined;
     interval: NodeJS.Timeout | undefined;
 };
-export interface ShellToolConfig {
-    name: string;
-    label: string;
-    shellName: string;
-    prompt: string;
-    promptSnippet: string;
-    promptGuidelines?: readonly string[];
-    fullPromptGuidelines?: readonly string[];
-    tempFilePrefix: string;
-}
 export declare function createShellToolDefinition(cwd: string, config: ShellToolConfig, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
 export declare function createBashToolDefinition(cwd: string, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
 export declare function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
-export {};
 //# sourceMappingURL=bash.d.ts.map