@arnilo/prism-coding-agent 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -5,7 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.0.6] - 2026-07-19
+
+### Added
+
+- Finite validated defaults/hard caps for text scans, image/file/input/edit counts, shell wall time, display output, and total shell output.
+- Exported coding limit constants plus bounded `ReadOperations.readText` page contracts.
+
+### Changed
+
+- Text reads stream one bounded page instead of loading the entire file; edit/image reads use a shared bounded file reader after stat checks.
+- Shell defaults to a 600-second timeout, kills the operation at 64 MiB combined output, and creates exclusive Unix `0600` spill files.
+- Failed/aborted/timed-out/output-limited shell calls delete unpublished spill files; successful truncated output remains host-owned at `metadata.fullOutputPath`.
+- Custom `ReadOperations` now require `readText` and `statFile`; custom `EditOperations` require `statFile` and receive byte/signal options.
+- Removed non-exported filesystem edit-preview helpers that duplicated the edit tool's file read path.
+
+## [0.0.5] - 2026-07-16
+
+- Pinned the required `@arnilo/prism` peer and package metadata to 0.0.5; runtime behavior is unchanged.
+
 
 ## [0.0.4] - 2026-07-14
 

package/README.md

@@ -33,6 +33,8 @@ import { createReadOnlyTools } from "@arnilo/prism-coding-agent";
 const tools = createToolRegistry(createReadOnlyTools(process.cwd()));
 ```
 
+Shared `ToolsOptions.executionPolicy` applies to every tool returned by full, all, and read-only aggregators unless a per-tool policy overrides it.
+
 Individual tools with options:
 
 ```ts
@@ -42,6 +44,8 @@ const shell = createShellTool(process.cwd(), {
   shellPath: "/bin/bash",        // force bash; default: SHELL env → /bin/bash → sh
   commandPrefix: "set -euo pipefail",
   maxLines: 500,
+  timeout: 600,
+  maxTotalOutputBytes: 64 * 1024 * 1024,
 });
 
 const remoteWrite = createWriteTool(process.cwd(), {
@@ -56,10 +60,10 @@ const remoteWrite = createWriteTool(process.cwd(), {
 
 | Tool | Input | Result |
 | --- | --- | --- |
-| `shell` | `{ command, timeout? }` | Combined output + `metadata.exitCode`. Non-zero exit is **not** an error. |
-| `read` | `{ path, offset?, limit? }` | `TextContent` (text) or `[note, ImageContent]` (image). |
-| `write` | `{ path, content }` | `Successfully wrote N bytes (M lines) to <abs>`. |
-| `edit` | `{ path, edits: [{oldText,newText}] }` | `Successfully replaced N block(s)` + `metadata.{diff,patch,firstChangedLine}`. |
+| `shell` | `{ command, timeout? }` | Combined output + `metadata.exitCode`; 600-second default timeout and 64 MiB total-output cap. Non-zero exit is **not** an error. |
+| `read` | `{ path, offset?, limit? }` | Streamed bounded text page or bounded `[note, ImageContent]`. |
+| `write` | `{ path, content }` | Bounded UTF-8 input; `Successfully wrote N bytes (M lines) to <abs>`. |
+| `edit` | `{ path, edits: [{oldText,newText}] }` | Bounded target/input/count; `Successfully replaced N block(s)` + diff metadata. |
 
 ### pi name mapping
 
@@ -72,9 +76,11 @@ const remoteWrite = createWriteTool(process.cwd(), {
 
 Factories: `createShellTool`, `createReadTool`, `createWriteTool`, `createEditTool`, `createCodingTools`, `createReadOnlyTools`, `createAllTools`, `createLocalBashOperations`.
 
-Helpers: `detectSupportedImageMimeType`, `detectSupportedImageMimeTypeFromFile`, `getShellConfig`, `killProcessTree`, `waitForChildProcess`, `withFileMutationQueue`.
+Helpers: `detectSupportedImageMimeType`, `detectSupportedImageMimeTypeFromFile`, `getShellConfig`, `killProcessTree`, `waitForChildProcess`, `withFileMutationQueue`. Default/hard coding limit constants are exported for host configuration.
+
+Option/operation types: `ToolsOptions`, `ShellToolOptions`/`BashOperations`, `ReadToolOptions`/`ReadOperations`/`ReadTextOptions`/`ReadTextResult`, `WriteToolOptions`/`WriteOperations`, `EditToolOptions`/`EditOperations`/`EditToolDetails`.
 
-Option/operation types: `ToolsOptions`, `ShellToolOptions`/`BashOperations`, `ReadToolOptions`/`ReadOperations`, `WriteToolOptions`/`WriteOperations`, `EditToolOptions`/`EditOperations`/`EditToolDetails`.
+Text reads stop after one page or `maxScanBytes` instead of loading the file. Custom `ReadOperations` must implement bounded `readText` and `statFile`; custom `EditOperations` must implement `statFile` and honor the supplied read cap/signal. Successful truncated shell output is retained in an exclusive Unix `0600` temp file owned by the host; timeout, abort, output-limit, and spill failures remove unpublished spill files. Hosts should delete published `metadata.fullOutputPath` files after use.
 
 ## License
 

package/dist/bounded-file.d.ts

@@ -0,0 +1,2 @@
+/** Read one regular-file snapshot no larger than `maxBytes`; always closes its handle. */
+export declare function readFileBounded(path: string, maxBytes: number, signal?: AbortSignal): Promise<Buffer>;

package/dist/bounded-file.js

@@ -0,0 +1,25 @@
+import { open } from "node:fs/promises";
+/** Read one regular-file snapshot no larger than `maxBytes`; always closes its handle. */
+export async function readFileBounded(path, maxBytes, signal) {
+    const handle = await open(path, "r");
+    try {
+        const size = (await handle.stat()).size;
+        if (size > maxBytes)
+            throw new Error(`File exceeds ${maxBytes} byte limit`);
+        const buffer = Buffer.allocUnsafe(size);
+        let offset = 0;
+        while (offset < size) {
+            if (signal?.aborted)
+                throw new Error("Operation aborted");
+            const { bytesRead } = await handle.read(buffer, offset, size - offset, offset);
+            if (bytesRead === 0)
+                break;
+            offset += bytesRead;
+        }
+        return buffer.subarray(0, offset);
+    }
+    finally {
+        await handle.close();
+    }
+}
+//# sourceMappingURL=bounded-file.js.map

package/dist/edit-diff.d.ts

@@ -75,19 +75,9 @@ export interface EditDiffResult {
     diff: string;
     firstChangedLine: number | undefined;
 }
-export interface EditDiffError {
-    error: string;
-}
 /**
  * Generate a display-oriented diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
 export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): EditDiffResult;
-/**
- * Compute the diff for one or more edit operations without applying them.
- * Used for preview before the edit tool executes.
- */
-export declare function computeEditsDiff(path: string, edits: Edit[], cwd: string): Promise<EditDiffResult | EditDiffError>;
-/** Compute the diff for a single edit operation without applying it. */
-export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string): Promise<EditDiffResult | EditDiffError>;
 export {};

package/dist/edit-diff.js

@@ -2,14 +2,11 @@
  * Shared diff computation utilities for the edit and similar tools.
  *
  * Behavioral port of pi's core/tools/edit-diff for @arnilo/prism-coding-agent.
- * stdlib (node:fs/promises, node:fs constants) plus the `diff` package for
+ * The `diff` package provides unified-patch / display-diff generation;
  * unified-patch / display-diff generation. Fuzzy matching, replacement
  * preservation, BOM/line-ending handling are dep-free.
  */
 import * as Diff from "diff";
-import { constants } from "node:fs";
-import { access, readFile } from "node:fs/promises";
-import { resolveToCwd } from "./path-utils.js";
 export function detectLineEnding(content) {
     const crlfIdx = content.indexOf("\r\n");
     const lfIdx = content.indexOf("\n");
@@ -387,33 +384,4 @@ export function generateDiffString(oldContent, newContent, contextLines = 4) {
     }
     return { diff: output.join("\n"), firstChangedLine };
 }
-/**
- * Compute the diff for one or more edit operations without applying them.
- * Used for preview before the edit tool executes.
- */
-export async function computeEditsDiff(path, edits, cwd) {
-    const absolutePath = resolveToCwd(path, cwd);
-    try {
-        try {
-            await access(absolutePath, constants.R_OK);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error && "code" in error ? `Error code: ${String(error.code)}` : String(error);
-            return { error: `Could not edit file: ${path}. ${errorMessage}.` };
-        }
-        const rawContent = await readFile(absolutePath, "utf-8");
-        // Strip BOM before matching (LLM won't include invisible BOM in oldText).
-        const { text: content } = stripBom(rawContent);
-        const normalizedContent = normalizeToLF(content);
-        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
-        return generateDiffString(baseContent, newContent);
-    }
-    catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
-}
-/** Compute the diff for a single edit operation without applying it. */
-export async function computeEditDiff(path, oldText, newText, cwd) {
-    return computeEditsDiff(path, [{ oldText, newText }], cwd);
-}
 //# sourceMappingURL=edit-diff.js.map

package/dist/edit.d.ts

@@ -39,17 +39,36 @@ export interface EditToolDetails {
  * (e.g. SSH) while keeping the tool's matching + per-path serialization behavior.
  */
 export interface EditOperations {
-    /** Read file contents as a Buffer. */
-    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Read bounded file contents as a Buffer. */
+    readFile: (absolutePath: string, options: {
+        maxBytes: number;
+        signal?: AbortSignal;
+    }) => Promise<Buffer>;
     /** Write content to a file. */
-    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    writeFile: (absolutePath: string, content: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
     /** Check the file is readable and writable (throw if not). */
-    access: (absolutePath: string) => Promise<void>;
+    access: (absolutePath: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    /** Return target size before the bounded read. */
+    statFile: (absolutePath: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        size: number;
+    }>;
 }
 export interface EditToolOptions {
     /** Structured pre-execution policy checked before filesystem writes. */
     executionPolicy?: ExecutionPolicy;
     /** Custom operations backend (default: local filesystem). */
     operations?: EditOperations;
+    /** Maximum target file bytes read for matching (default 8 MiB). */
+    maxFileBytes?: number;
+    /** Maximum aggregate UTF-8 bytes across old/new edit text (default 2 MiB). */
+    maxInputBytes?: number;
+    /** Maximum replacements per call (default 100). */
+    maxEdits?: number;
 }
 export declare function createEditTool(cwd: string, options?: EditToolOptions): ToolDefinition;

package/dist/edit.js

@@ -1,13 +1,38 @@
-import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "node:fs/promises";
+/**
+ * Edit tool: precise text replacement in an existing file via exact-then-fuzzy matching.
+ *
+ * Behavioral port of pi's core/tools/edit for @arnilo/prism-coding-agent, adapted to Prism's
+ * `ToolDefinition` contract. Faithfully ports the access → read → stripBom → line-ending-normalize →
+ * `applyEditsToNormalizedContent` (exact then fuzzy, with duplicate/overlap/empty/no-change guards) →
+ * write flow, serialized per-path via `withFileMutationQueue`. Also ports `prepareEditArguments`
+ * (tolerates models that send `edits` as a JSON string or as legacy top-level `oldText`/`newText`).
+ *
+ * Drops pi's TUI (`renderCall`/`renderResult`, live preview cache, theme/syntax-highlight).
+ *
+ * Deviations from pi (documented):
+ *  - Abort + every failure (missing/unreadable file, no-match, duplicate, overlap, empty oldText,
+ *    no-change) return a Prism `error` result (pi throws/rejects). On no-match the file is untouched
+ *    because `applyEditsToNormalizedContent` throws before `writeFile`.
+ *  - pi's per-tool `details: { diff, patch, firstChangedLine }` (TUI-facing) is surfaced as
+ *    `ToolResult.metadata` (host-readable, keeps model context small — the model only sees the short
+ *    `Successfully replaced N block(s)` confirmation).
+ *  - The post-`writeFile` abort check is dropped (consistent with the write tool): if the write
+ *    completed, the edit is real and is reported as success rather than a misleading "aborted".
+ */
+import { Buffer } from "node:buffer";
+import { access as fsAccess, stat as fsStat, writeFile as fsWriteFile, } from "node:fs/promises";
 import { constants } from "node:fs";
+import { readFileBounded } from "./bounded-file.js";
 import { enforceExecutionPolicy } from "./execution-policy.js";
 import { resolveToCwd } from "./path-utils.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { DEFAULT_MAX_EDIT_FILE_BYTES, DEFAULT_MAX_EDIT_INPUT_BYTES, DEFAULT_MAX_EDITS, HARD_MAX_EDIT_FILE_BYTES, HARD_MAX_EDIT_INPUT_BYTES, HARD_MAX_EDITS, validateCodingLimit, } from "./limits.js";
 import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
 const defaultEditOperations = {
-    readFile: (path) => fsReadFile(path),
-    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    readFile: (path, options) => readFileBounded(path, options.maxBytes, options.signal),
+    writeFile: (path, content, options) => fsWriteFile(path, content, { encoding: "utf-8", signal: options?.signal }),
     access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+    statFile: async (path) => ({ size: (await fsStat(path)).size }),
 };
 function errorResult(toolCallId, message) {
     return {
@@ -40,22 +65,32 @@ function prepareEditArguments(input) {
     }
     return { path, edits };
 }
-function validateEdits(edits) {
+function validateEdits(edits, maxEdits, maxInputBytes) {
     if (!Array.isArray(edits) || edits.length === 0) {
         return "edits must contain at least one replacement.";
     }
+    if (edits.length > maxEdits)
+        return `edits contains ${edits.length} replacements, exceeds ${maxEdits} limit.`;
     const out = [];
+    let inputBytes = 0;
     for (let i = 0; i < edits.length; i++) {
         const e = edits[i];
         if (typeof e?.oldText !== "string" || typeof e?.newText !== "string") {
             return `edits[${i}] must have string oldText and newText.`;
         }
+        inputBytes += Buffer.byteLength(e.oldText, "utf-8") + Buffer.byteLength(e.newText, "utf-8");
+        if (inputBytes > maxInputBytes) {
+            return `edit input is ${inputBytes} bytes, exceeds ${maxInputBytes} byte limit.`;
+        }
         out.push({ oldText: e.oldText, newText: e.newText });
     }
     return out;
 }
 export function createEditTool(cwd, options) {
     const ops = options?.operations ?? defaultEditOperations;
+    const maxFileBytes = validateCodingLimit("maxFileBytes", options?.maxFileBytes ?? DEFAULT_MAX_EDIT_FILE_BYTES, HARD_MAX_EDIT_FILE_BYTES);
+    const maxInputBytes = validateCodingLimit("maxInputBytes", options?.maxInputBytes ?? DEFAULT_MAX_EDIT_INPUT_BYTES, HARD_MAX_EDIT_INPUT_BYTES);
+    const maxEdits = validateCodingLimit("maxEdits", options?.maxEdits ?? DEFAULT_MAX_EDITS, HARD_MAX_EDITS);
     return {
         name: "edit",
         description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
@@ -85,11 +120,14 @@ export function createEditTool(cwd, options) {
         },
         async execute(args, context) {
             const toolCallId = context.toolCallId;
+            if (typeof args.edits === "string" && Buffer.byteLength(args.edits, "utf-8") > maxInputBytes) {
+                return errorResult(toolCallId, `edit input exceeds ${maxInputBytes} byte limit.`);
+            }
             const prepared = prepareEditArguments(args);
             if (prepared.path.length === 0) {
                 return errorResult(toolCallId, "path is required and must be a non-empty string.");
             }
-            const editsOrError = validateEdits(prepared.edits);
+            const editsOrError = validateEdits(prepared.edits, maxEdits, maxInputBytes);
             if (typeof editsOrError === "string") {
                 return errorResult(toolCallId, editsOrError);
             }
@@ -101,7 +139,7 @@ export function createEditTool(cwd, options) {
                     operation: "edit",
                     paths: [absolutePath],
                     risk: "medium",
-                    metadata: { editCount: edits.length, signal: context.signal },
+                    metadata: { editCount: edits.length, sessionId: context.sessionId, runId: context.runId, signal: context.signal },
                 }, toolCallId, "edit");
                 if (!policyCheck.allowed)
                     return policyCheck.result;
@@ -111,7 +149,7 @@ export function createEditTool(cwd, options) {
                         return errorResult(toolCallId, "Operation aborted");
                     // Check the file is readable + writable.
                     try {
-                        await ops.access(allowedPath);
+                        await ops.access(allowedPath, { signal: context.signal });
                     }
                     catch (error) {
                         if (context.signal?.aborted)
@@ -122,7 +160,16 @@ export function createEditTool(cwd, options) {
                     }
                     if (context.signal?.aborted)
                         return errorResult(toolCallId, "Operation aborted");
-                    const buffer = await ops.readFile(allowedPath);
+                    const { size } = await ops.statFile(allowedPath, { signal: context.signal });
+                    if (size > maxFileBytes) {
+                        return errorResult(toolCallId, `Edit target is ${size} bytes, exceeds ${maxFileBytes} byte limit.`);
+                    }
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    const buffer = await ops.readFile(allowedPath, { maxBytes: maxFileBytes, signal: context.signal });
+                    if (buffer.length > maxFileBytes) {
+                        return errorResult(toolCallId, `Edit target is ${buffer.length} bytes, exceeds ${maxFileBytes} byte limit.`);
+                    }
                     if (context.signal?.aborted)
                         return errorResult(toolCallId, "Operation aborted");
                     const rawContent = buffer.toString("utf-8");
@@ -143,7 +190,7 @@ export function createEditTool(cwd, options) {
                     if (context.signal?.aborted)
                         return errorResult(toolCallId, "Operation aborted");
                     const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-                    await ops.writeFile(allowedPath, finalContent);
+                    await ops.writeFile(allowedPath, finalContent, { signal: context.signal });
                     const diffResult = generateDiffString(baseContent, newContent);
                     const patch = generateUnifiedPatch(prepared.path, baseContent, newContent);
                     return {

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 export { createShellTool, createLocalBashOperations, getShellConfig, killProcessTree, waitForChildProcess, } from "./shell.js";
 export type { ShellToolOptions, ShellConfig, BashOperations, BashExecOptions, BashSpawnContext, BashSpawnHook, } from "./shell.js";
 export { createReadTool, detectSupportedImageMimeType, detectSupportedImageMimeTypeFromFile, DEFAULT_MAX_IMAGE_BYTES, } from "./read.js";
-export type { ReadToolOptions, ReadOperations, TransformImage, TransformImageInput, } from "./read.js";
+export type { ReadToolOptions, ReadOperations, ReadTextOptions, ReadTextResult, TransformImage, TransformImageInput, } from "./read.js";
 export { createWriteTool } from "./write.js";
 export type { WriteToolOptions, WriteOperations } from "./write.js";
 export { createEditTool } from "./edit.js";
 export type { EditToolOptions, EditOperations, EditToolDetails, Edit } from "./edit.js";
 export { withFileMutationQueue } from "./file-mutation-queue.js";
 export { enforceExecutionPolicy } from "./execution-policy.js";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_MAX_TEXT_SCAN_BYTES, DEFAULT_MAX_WRITE_BYTES, DEFAULT_MAX_EDIT_FILE_BYTES, DEFAULT_MAX_EDIT_INPUT_BYTES, DEFAULT_MAX_EDITS, DEFAULT_SHELL_TIMEOUT_SECONDS, DEFAULT_MAX_TOTAL_OUTPUT_BYTES, HARD_MAX_BYTES, HARD_MAX_LINES, HARD_MAX_TEXT_SCAN_BYTES, HARD_MAX_IMAGE_BYTES, HARD_MAX_WRITE_BYTES, HARD_MAX_EDIT_FILE_BYTES, HARD_MAX_EDIT_INPUT_BYTES, HARD_MAX_EDITS, HARD_SHELL_TIMEOUT_SECONDS, HARD_MAX_TOTAL_OUTPUT_BYTES, } from "./limits.js";
 import type { ExecutionPolicy, ToolDefinition } from "@arnilo/prism";
 import type { ShellToolOptions } from "./shell.js";
 import type { ReadToolOptions } from "./read.js";

package/dist/index.js

@@ -11,6 +11,7 @@ export { createEditTool } from "./edit.js";
 // --- generic primitives (re-exported for hosts that want them) ---
 export { withFileMutationQueue } from "./file-mutation-queue.js";
 export { enforceExecutionPolicy } from "./execution-policy.js";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_MAX_TEXT_SCAN_BYTES, DEFAULT_MAX_WRITE_BYTES, DEFAULT_MAX_EDIT_FILE_BYTES, DEFAULT_MAX_EDIT_INPUT_BYTES, DEFAULT_MAX_EDITS, DEFAULT_SHELL_TIMEOUT_SECONDS, DEFAULT_MAX_TOTAL_OUTPUT_BYTES, HARD_MAX_BYTES, HARD_MAX_LINES, HARD_MAX_TEXT_SCAN_BYTES, HARD_MAX_IMAGE_BYTES, HARD_MAX_WRITE_BYTES, HARD_MAX_EDIT_FILE_BYTES, HARD_MAX_EDIT_INPUT_BYTES, HARD_MAX_EDITS, HARD_SHELL_TIMEOUT_SECONDS, HARD_MAX_TOTAL_OUTPUT_BYTES, } from "./limits.js";
 import { createShellTool } from "./shell.js";
 import { createReadTool } from "./read.js";
 import { createWriteTool } from "./write.js";
@@ -34,7 +35,7 @@ export function createCodingTools(cwd, options) {
 }
 /** Read-only subset: `read` only (this package ships no grep/find/ls). */
 export function createReadOnlyTools(cwd, options) {
-    return [createReadTool(cwd, options?.read)];
+    return [createReadTool(cwd, withSharedExecutionPolicy(options?.read, options?.executionPolicy))];
 }
 /** Every tool this package provides — identical to {@link createCodingTools} for now. */
 export function createAllTools(cwd, options) {

package/dist/limits.d.ts

@@ -0,0 +1,22 @@
+export declare const DEFAULT_MAX_LINES = 2000;
+export declare const HARD_MAX_LINES = 100000;
+export declare const DEFAULT_MAX_BYTES: number;
+export declare const HARD_MAX_BYTES: number;
+export declare const DEFAULT_MAX_TEXT_SCAN_BYTES: number;
+export declare const HARD_MAX_TEXT_SCAN_BYTES: number;
+export declare const DEFAULT_MAX_IMAGE_BYTES = 10000000;
+export declare const HARD_MAX_IMAGE_BYTES: number;
+export declare const DEFAULT_MAX_WRITE_BYTES: number;
+export declare const HARD_MAX_WRITE_BYTES: number;
+export declare const DEFAULT_MAX_EDIT_FILE_BYTES: number;
+export declare const HARD_MAX_EDIT_FILE_BYTES: number;
+export declare const DEFAULT_MAX_EDIT_INPUT_BYTES: number;
+export declare const HARD_MAX_EDIT_INPUT_BYTES: number;
+export declare const DEFAULT_MAX_EDITS = 100;
+export declare const HARD_MAX_EDITS = 1000;
+export declare const DEFAULT_SHELL_TIMEOUT_SECONDS = 600;
+export declare const HARD_SHELL_TIMEOUT_SECONDS = 3600;
+export declare const DEFAULT_MAX_TOTAL_OUTPUT_BYTES: number;
+export declare const HARD_MAX_TOTAL_OUTPUT_BYTES: number;
+/** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
+export declare function validateCodingLimit(name: string, value: number, hardCap: number): number;

package/dist/limits.js

@@ -0,0 +1,28 @@
+export const DEFAULT_MAX_LINES = 2_000;
+export const HARD_MAX_LINES = 100_000;
+export const DEFAULT_MAX_BYTES = 50 * 1024;
+export const HARD_MAX_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_TEXT_SCAN_BYTES = 64 * 1024 * 1024;
+export const HARD_MAX_TEXT_SCAN_BYTES = 1024 * 1024 * 1024;
+export const DEFAULT_MAX_IMAGE_BYTES = 10_000_000;
+export const HARD_MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_MAX_WRITE_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_WRITE_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_EDIT_FILE_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_EDIT_FILE_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_EDIT_INPUT_BYTES = 2 * 1024 * 1024;
+export const HARD_MAX_EDIT_INPUT_BYTES = 16 * 1024 * 1024;
+export const DEFAULT_MAX_EDITS = 100;
+export const HARD_MAX_EDITS = 1_000;
+export const DEFAULT_SHELL_TIMEOUT_SECONDS = 600;
+export const HARD_SHELL_TIMEOUT_SECONDS = 3_600;
+export const DEFAULT_MAX_TOTAL_OUTPUT_BYTES = 64 * 1024 * 1024;
+export const HARD_MAX_TOTAL_OUTPUT_BYTES = 1024 * 1024 * 1024;
+/** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
+export function validateCodingLimit(name, value, hardCap) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > hardCap) {
+        throw new Error(`${name} must be a positive safe integer at most ${hardCap}`);
+    }
+    return value;
+}
+//# sourceMappingURL=limits.js.map

package/dist/output-accumulator.d.ts

@@ -1,26 +1,25 @@
-import type { TruncationResult } from "./truncate.js";
+import { type TruncationResult } from "./truncate.js";
 export interface OutputAccumulatorOptions {
     maxLines?: number;
     maxBytes?: number;
+    maxTotalOutputBytes?: number;
     tempFilePrefix?: string;
+    onLimit?: () => void;
+    onStorageError?: () => void;
 }
 export interface OutputSnapshot {
     content: string;
     truncation: TruncationResult;
     fullOutputPath?: string;
 }
-/**
- * Incrementally tracks streaming output with bounded memory.
- *
- * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded
- * tail for display snapshots, and opens a temp file when the full output needs
- * to be preserved.
- */
 export declare class OutputAccumulator {
     private readonly maxLines;
     private readonly maxBytes;
+    private readonly maxTotalOutputBytes;
     private readonly maxRollingBytes;
     private readonly tempFilePrefix;
+    private readonly onLimit?;
+    private readonly onStorageError?;
     private readonly decoder;
     private rawChunks;
     private tailText;
@@ -33,19 +32,27 @@ export declare class OutputAccumulator {
     private currentLineBytes;
     private hasOpenLine;
     private finished;
+    private exceeded;
     private tempFilePath?;
-    private tempFileStream?;
+    private tempFileFd?;
+    private tempFileError?;
     constructor(options?: OutputAccumulatorOptions);
-    append(data: Buffer): void;
+    append(data: Buffer): boolean;
     finish(): void;
     snapshot(options?: {
         persistIfTruncated?: boolean;
     }): OutputSnapshot;
     closeTempFile(): Promise<void>;
+    cleanupTempFile(): Promise<void>;
     getLastLineBytes(): number;
+    getTotalRawBytes(): number;
+    isOutputLimitExceeded(): boolean;
+    hasStorageError(): boolean;
     private appendDecodedText;
     private trimTail;
     private getSnapshotText;
     private shouldUseTempFile;
     private ensureTempFile;
+    private writeTemp;
+    private recordTempError;
 }