@papercraneai/sandbox-agent 0.1.12 → 0.1.14-beta.1

package/dist/dashboard-fs/edit.d.ts

@@ -0,0 +1,24 @@
+import type { FileIndex } from "./file-index.js";
+interface EditFileArgs {
+    fileId: unknown;
+    oldString: unknown;
+    newString: unknown;
+    replaceAll?: unknown;
+}
+interface ToolResult {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Edits a file by handle using a string-replace cascade. The fileId must reference
+ * a writable entry. Tries replacers in order (exact, line-trimmed, block-anchor)
+ * and returns a unified diff of the change.
+ *
+ * Not in shared-view's `allowedTools` for v1 — registered for future authoring use.
+ */
+export declare function executeEditFile(index: FileIndex, args: EditFileArgs): Promise<ToolResult>;
+export {};

package/dist/dashboard-fs/edit.js

@@ -0,0 +1,218 @@
+import { readFile, writeFile, stat } from "fs/promises";
+import { createTwoFilesPatch } from "diff";
+import { lookup } from "./file-index.js";
+/**
+ * Returns the input unchanged. The first and most common case: exact match.
+ * Ported from opencode edit.ts (MIT).
+ */
+const SimpleReplacer = function* (_content, find) {
+    yield find;
+};
+/**
+ * Yields candidate substrings whose lines match the search term modulo
+ * leading/trailing whitespace per line. Useful when the model's `oldString`
+ * has slightly different indentation than the file. Ported from opencode (MIT).
+ */
+const LineTrimmedReplacer = function* (content, find) {
+    const originalLines = content.split("\n");
+    const searchLines = find.split("\n");
+    if (searchLines[searchLines.length - 1] === "") {
+        searchLines.pop();
+    }
+    for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+        let matches = true;
+        for (let j = 0; j < searchLines.length; j++) {
+            if (originalLines[i + j].trim() !== searchLines[j].trim()) {
+                matches = false;
+                break;
+            }
+        }
+        if (!matches)
+            continue;
+        let matchStartIndex = 0;
+        for (let k = 0; k < i; k++)
+            matchStartIndex += originalLines[k].length + 1;
+        let matchEndIndex = matchStartIndex;
+        for (let k = 0; k < searchLines.length; k++) {
+            matchEndIndex += originalLines[i + k].length;
+            if (k < searchLines.length - 1)
+                matchEndIndex += 1;
+        }
+        yield content.substring(matchStartIndex, matchEndIndex);
+    }
+};
+/**
+ * For multi-line blocks (>=3 lines), yields candidates anchored on the first
+ * and last lines (trimmed match). Useful when the middle of the block has drift
+ * but the boundaries are stable. Ported from opencode (MIT).
+ */
+const BlockAnchorReplacer = function* (content, find) {
+    const originalLines = content.split("\n");
+    const searchLines = find.split("\n");
+    if (searchLines.length < 3)
+        return;
+    if (searchLines[searchLines.length - 1] === "")
+        searchLines.pop();
+    const firstLineSearch = searchLines[0].trim();
+    const lastLineSearch = searchLines[searchLines.length - 1].trim();
+    for (let i = 0; i < originalLines.length; i++) {
+        if (originalLines[i].trim() !== firstLineSearch)
+            continue;
+        for (let j = i + 2; j < originalLines.length; j++) {
+            if (originalLines[j].trim() !== lastLineSearch)
+                continue;
+            let matchStartIndex = 0;
+            for (let k = 0; k < i; k++)
+                matchStartIndex += originalLines[k].length + 1;
+            let matchEndIndex = matchStartIndex;
+            for (let k = i; k <= j; k++) {
+                matchEndIndex += originalLines[k].length;
+                if (k < j)
+                    matchEndIndex += 1;
+            }
+            yield content.substring(matchStartIndex, matchEndIndex);
+            break; // only first match for this anchor pair
+        }
+    }
+};
+/**
+ * Avoids `$` sequence issues in the replacement string. JavaScript's
+ * `String.prototype.replaceAll` interprets `$&`, `$1`, etc., in the
+ * replacement; this routes through a function replacement which is treated
+ * as a literal. Ported from gemini-cli edit.ts (Apache 2.0).
+ */
+function safeLiteralReplace(content, search, replacement) {
+    // For non-pattern (string) inputs, replaceAll's first-arg-as-string mode
+    // does NOT interpret `$&` — only the replacement string does. Use the
+    // function form to bypass.
+    return content.split(search).join(replacement);
+}
+function replace(content, oldString, newString, replaceAll = false) {
+    if (oldString === newString) {
+        return { error: "No changes to apply: oldString and newString are identical." };
+    }
+    const replacers = [
+        { name: "SimpleReplacer", fn: SimpleReplacer },
+        { name: "LineTrimmedReplacer", fn: LineTrimmedReplacer },
+        { name: "BlockAnchorReplacer", fn: BlockAnchorReplacer }
+    ];
+    let foundButAmbiguous = false;
+    for (const { name, fn } of replacers) {
+        for (const candidate of fn(content, oldString)) {
+            const index = content.indexOf(candidate);
+            if (index === -1)
+                continue;
+            if (replaceAll) {
+                return {
+                    content: safeLiteralReplace(content, candidate, newString),
+                    replacer: name
+                };
+            }
+            const lastIndex = content.lastIndexOf(candidate);
+            if (index !== lastIndex) {
+                // Multiple matches; this replacer can't make a unique replacement.
+                // Try the next replacer in case it yields a more specific candidate.
+                foundButAmbiguous = true;
+                continue;
+            }
+            return {
+                content: content.substring(0, index) + newString + content.substring(index + candidate.length),
+                replacer: name
+            };
+        }
+    }
+    if (foundButAmbiguous) {
+        return { error: "Found multiple matches for oldString. Provide more surrounding context to make the match unique, or set replaceAll: true." };
+    }
+    return { error: "Could not find oldString in the file. It must match exactly, including whitespace and indentation. Try replacing a smaller, more distinctive snippet." };
+}
+// Per-file lock so concurrent EditFile calls on the same file serialize.
+// Ported in spirit from opencode's Semaphore-based locks (MIT).
+const locks = new Map();
+async function withFileLock(absolutePath, fn) {
+    const previous = locks.get(absolutePath) ?? Promise.resolve();
+    let release = () => { };
+    const next = new Promise((resolve) => { release = resolve; });
+    locks.set(absolutePath, previous.then(() => next));
+    await previous;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (locks.get(absolutePath) === previous.then(() => next)) {
+            locks.delete(absolutePath);
+        }
+    }
+}
+/**
+ * Edits a file by handle using a string-replace cascade. The fileId must reference
+ * a writable entry. Tries replacers in order (exact, line-trimmed, block-anchor)
+ * and returns a unified diff of the change.
+ *
+ * Not in shared-view's `allowedTools` for v1 — registered for future authoring use.
+ */
+export async function executeEditFile(index, args) {
+    const entry = lookup(index, args.fileId);
+    if (!entry) {
+        return {
+            content: [{ type: "text", text: `Error: unknown fileId. Use ListFiles to discover available files.` }],
+            isError: true
+        };
+    }
+    if (!entry.writable) {
+        return {
+            content: [{ type: "text", text: `Error: file ${entry.relativePath} is not writable in this session.` }],
+            isError: true
+        };
+    }
+    if (typeof args.oldString !== "string" || typeof args.newString !== "string") {
+        return {
+            content: [{ type: "text", text: `Error: oldString and newString must be strings` }],
+            isError: true
+        };
+    }
+    const replaceAll = args.replaceAll === true;
+    return withFileLock(entry.absolutePath, async () => {
+        let original;
+        try {
+            original = await readFile(entry.absolutePath, "utf-8");
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error reading file: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true
+            };
+        }
+        const result = replace(original, args.oldString, args.newString, replaceAll);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error: ${result.error}` }],
+                isError: true
+            };
+        }
+        try {
+            await writeFile(entry.absolutePath, result.content, "utf-8");
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error writing file: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true
+            };
+        }
+        try {
+            const s = await stat(entry.absolutePath);
+            entry.size = s.size;
+        }
+        catch { /* non-fatal */ }
+        const diff = createTwoFilesPatch(entry.relativePath, entry.relativePath, original, result.content, "before", "after");
+        const trimmedDiff = diff.replace(/^Index: .*\n=+\n/m, "");
+        const matchedSuffix = result.replacer === "SimpleReplacer" ? "" : ` (matched via ${result.replacer})`;
+        return {
+            content: [{
+                    type: "text",
+                    text: `Edited ${entry.relativePath}${matchedSuffix}\n\n${trimmedDiff}`
+                }]
+        };
+    });
+}

package/dist/dashboard-fs/file-index.d.ts

@@ -0,0 +1,33 @@
+export interface FileIndexEntry {
+    absolutePath: string;
+    relativePath: string;
+    writable: boolean;
+    size: number;
+}
+export type FileIndex = Map<string, FileIndexEntry>;
+interface BuildOptions {
+    dashboardRoot: string;
+    queryFiles?: string[];
+    skip?: Set<string>;
+}
+/**
+ * Builds the read/write index for a shared-view chat session.
+ *
+ * The index is the *only* way handle-based tools can address files. The agent
+ * never receives or constructs a path string. There is no `..`, no symlink
+ * resolution, no case-folding to get wrong — handles either resolve to an
+ * absolute path the index already chose, or they don't.
+ *
+ * @param options.dashboardRoot Absolute path to the dashboard folder. Walked recursively.
+ * @param options.queryFiles    Optional list of absolute paths to additional files
+ *                              (e.g., shared query files referenced from the dashboard).
+ *                              Their relative path is resolved against dashboardRoot when
+ *                              they live underneath it; otherwise the absolute path is used.
+ */
+export declare function buildFileIndex(options: BuildOptions): Promise<FileIndex>;
+/**
+ * Looks up a file id in the index. Returns the entry or undefined.
+ * Tools call this rather than ever taking a path argument from the caller.
+ */
+export declare function lookup(index: FileIndex, fileId: unknown): FileIndexEntry | undefined;
+export {};

package/dist/dashboard-fs/file-index.js

@@ -0,0 +1,102 @@
+import { readdir, stat } from "fs/promises";
+import { join, relative, isAbsolute } from "path";
+import { randomBytes } from "crypto";
+const DEFAULT_SKIP = new Set([
+    "node_modules",
+    ".next",
+    ".turbo",
+    ".git",
+    ".cache",
+    "dist",
+    "build",
+    ".DS_Store"
+]);
+function newFileId() {
+    return `f_${randomBytes(8).toString("hex")}`;
+}
+async function walk(rootAbs, current, skip, out) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+        if (skip.has(entry.name) || entry.name.startsWith("."))
+            continue;
+        const entryAbs = join(current, entry.name);
+        if (entry.isSymbolicLink()) {
+            // Symlinks are not followed. Anything we want in scope must be explicitly
+            // present as a regular file or directory under the dashboard root.
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await walk(rootAbs, entryAbs, skip, out);
+        }
+        else if (entry.isFile()) {
+            const s = await stat(entryAbs);
+            out.set(newFileId(), {
+                absolutePath: entryAbs,
+                relativePath: relative(rootAbs, entryAbs),
+                writable: true,
+                size: s.size
+            });
+        }
+    }
+}
+/**
+ * Builds the read/write index for a shared-view chat session.
+ *
+ * The index is the *only* way handle-based tools can address files. The agent
+ * never receives or constructs a path string. There is no `..`, no symlink
+ * resolution, no case-folding to get wrong — handles either resolve to an
+ * absolute path the index already chose, or they don't.
+ *
+ * @param options.dashboardRoot Absolute path to the dashboard folder. Walked recursively.
+ * @param options.queryFiles    Optional list of absolute paths to additional files
+ *                              (e.g., shared query files referenced from the dashboard).
+ *                              Their relative path is resolved against dashboardRoot when
+ *                              they live underneath it; otherwise the absolute path is used.
+ */
+export async function buildFileIndex(options) {
+    const { dashboardRoot, queryFiles = [], skip = DEFAULT_SKIP } = options;
+    if (!isAbsolute(dashboardRoot)) {
+        throw new Error(`buildFileIndex: dashboardRoot must be absolute, got: ${dashboardRoot}`);
+    }
+    const rootStat = await stat(dashboardRoot);
+    if (!rootStat.isDirectory()) {
+        throw new Error(`buildFileIndex: dashboardRoot is not a directory: ${dashboardRoot}`);
+    }
+    const index = new Map();
+    await walk(dashboardRoot, dashboardRoot, skip, index);
+    for (const qf of queryFiles) {
+        if (!isAbsolute(qf)) {
+            throw new Error(`buildFileIndex: queryFiles entries must be absolute, got: ${qf}`);
+        }
+        // Skip if this query file is already inside the dashboard root (already walked).
+        const indexed = [...index.values()].some((e) => e.absolutePath === qf);
+        if (indexed)
+            continue;
+        let s;
+        try {
+            s = await stat(qf);
+        }
+        catch {
+            continue;
+        }
+        if (!s.isFile())
+            continue;
+        const rel = qf.startsWith(dashboardRoot) ? relative(dashboardRoot, qf) : qf;
+        index.set(newFileId(), {
+            absolutePath: qf,
+            relativePath: rel,
+            writable: true,
+            size: s.size
+        });
+    }
+    return index;
+}
+/**
+ * Looks up a file id in the index. Returns the entry or undefined.
+ * Tools call this rather than ever taking a path argument from the caller.
+ */
+export function lookup(index, fileId) {
+    if (typeof fileId !== "string")
+        return undefined;
+    return index.get(fileId);
+}

package/dist/dashboard-fs/grep.d.ts

@@ -0,0 +1,25 @@
+import type { FileIndex } from "./file-index.js";
+interface GrepArgs {
+    pattern: unknown;
+}
+interface ToolResult {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Runs ripgrep restricted to the absolute paths in the file index.
+ *
+ * The pattern is passed as an argv argument to ripgrep, not interpolated into
+ * a shell — so shell metacharacters in the pattern are safe. The file list is
+ * piped via stdin so very large indexes don't blow the command-line length.
+ *
+ * Output is capped at MAX_MATCHES results and lines longer than MAX_LINE_LENGTH
+ * are truncated. A 5s wall-clock timeout caps catastrophic-regex CPU per the
+ * implementation-time hardening checklist (M4 in the design doc).
+ */
+export declare function executeGrepFiles(index: FileIndex, args: GrepArgs): Promise<ToolResult>;
+export {};

package/dist/dashboard-fs/grep.js

@@ -0,0 +1,106 @@
+import { spawn } from "child_process";
+const MAX_MATCHES = 100;
+const MAX_LINE_LENGTH = 2000;
+const RIPGREP_TIMEOUT_MS = 5_000;
+/**
+ * Runs ripgrep restricted to the absolute paths in the file index.
+ *
+ * The pattern is passed as an argv argument to ripgrep, not interpolated into
+ * a shell — so shell metacharacters in the pattern are safe. The file list is
+ * piped via stdin so very large indexes don't blow the command-line length.
+ *
+ * Output is capped at MAX_MATCHES results and lines longer than MAX_LINE_LENGTH
+ * are truncated. A 5s wall-clock timeout caps catastrophic-regex CPU per the
+ * implementation-time hardening checklist (M4 in the design doc).
+ */
+export async function executeGrepFiles(index, args) {
+    const pattern = args.pattern;
+    if (typeof pattern !== "string" || pattern.length === 0) {
+        return {
+            content: [{ type: "text", text: `Error: pattern must be a non-empty string` }],
+            isError: true
+        };
+    }
+    const filePaths = [...index.values()].map((e) => e.absolutePath);
+    if (filePaths.length === 0) {
+        return {
+            content: [{ type: "text", text: `(no files in index to search)` }]
+        };
+    }
+    const child = spawn("rg", [
+        "--no-config",
+        "--line-number",
+        "--no-heading",
+        "--color=never",
+        "--max-count", "10", // up to 10 matches per file before moving on
+        "--max-columns", String(MAX_LINE_LENGTH),
+        "--max-columns-preview",
+        "--files-from", "-",
+        "--regexp", pattern
+    ], { stdio: ["pipe", "pipe", "pipe"] });
+    // Pipe the file list to ripgrep on stdin
+    child.stdin.write(filePaths.join("\n"));
+    child.stdin.end();
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (c) => stdoutChunks.push(c));
+    child.stderr.on("data", (c) => stderrChunks.push(c));
+    const timeout = setTimeout(() => {
+        child.kill("SIGKILL");
+    }, RIPGREP_TIMEOUT_MS);
+    let killed = false;
+    child.on("close", (_code, signal) => {
+        if (signal === "SIGKILL")
+            killed = true;
+    });
+    const exitCode = await new Promise((resolve) => {
+        child.on("close", (code) => resolve(code));
+    });
+    clearTimeout(timeout);
+    if (killed) {
+        return {
+            content: [{ type: "text", text: `Error: search timed out after ${RIPGREP_TIMEOUT_MS / 1000}s. Try a more specific pattern.` }],
+            isError: true
+        };
+    }
+    // ripgrep exits 0 when matches found, 1 when no matches, 2+ on errors.
+    if (exitCode === 1) {
+        return {
+            content: [{ type: "text", text: `(no matches for ${JSON.stringify(pattern)})` }]
+        };
+    }
+    if (exitCode !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+        return {
+            content: [{ type: "text", text: `Error running ripgrep (exit ${exitCode}): ${stderr.slice(0, 500)}` }],
+            isError: true
+        };
+    }
+    const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+    const lines = stdout.split("\n").filter((l) => l.length > 0);
+    const truncated = lines.length > MAX_MATCHES;
+    const shown = truncated ? lines.slice(0, MAX_MATCHES) : lines;
+    // ripgrep emits absolute paths since we passed absolute paths in. Rewrite
+    // them to relative paths via the index so the agent never sees the absolute
+    // form. (No security guarantee — just consistency with the read formatter.)
+    const absToRel = new Map();
+    for (const entry of index.values())
+        absToRel.set(entry.absolutePath, entry.relativePath);
+    const rewritten = shown.map((line) => {
+        const colon = line.indexOf(":");
+        if (colon === -1)
+            return line;
+        const path = line.slice(0, colon);
+        const rel = absToRel.get(path);
+        return rel ? `${rel}${line.slice(colon)}` : line;
+    });
+    const footer = truncated
+        ? `\n\n(Showing ${MAX_MATCHES} of ${lines.length} matches. Refine the pattern to narrow results.)`
+        : `\n\n(${lines.length} match${lines.length === 1 ? "" : "es"})`;
+    return {
+        content: [{
+                type: "text",
+                text: rewritten.join("\n") + footer
+            }]
+    };
+}

package/dist/dashboard-fs/index.d.ts

@@ -0,0 +1,23 @@
+import type { FileIndex } from "./file-index.js";
+interface CreateOptions {
+    dashboardRoot: string;
+    queryFiles?: string[];
+}
+/**
+ * Builds the dashboard-fs MCP server for a chat session. Walks the dashboard
+ * folder once to construct a handle-based file index; all subsequent reads,
+ * writes, edits, and grep calls resolve `fileId` against that index. The agent
+ * never sees or constructs a path string — there is no `..`, no symlink to
+ * resolve, no case to fold.
+ *
+ * Registers all six tools (ListFiles, ReadFile, GrepFiles, WriteFile, EditFile,
+ * CreateFile). Per the design plan, shared-view chat sessions allowlist only the
+ * read-only subset (List, Read, Grep) via `allowedTools`. The write-set is
+ * available for future use cases.
+ */
+export declare function createDashboardFsServer(options: CreateOptions): Promise<{
+    server: import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+    index: FileIndex;
+    listFileIds: () => string[];
+}>;
+export {};

package/dist/dashboard-fs/index.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { buildFileIndex } from "./file-index.js";
+import { executeListFiles, executeReadFile } from "./read.js";
+import { executeGrepFiles } from "./grep.js";
+import { executeWriteFile, executeCreateFile } from "./write.js";
+import { executeEditFile } from "./edit.js";
+/**
+ * Builds the dashboard-fs MCP server for a chat session. Walks the dashboard
+ * folder once to construct a handle-based file index; all subsequent reads,
+ * writes, edits, and grep calls resolve `fileId` against that index. The agent
+ * never sees or constructs a path string — there is no `..`, no symlink to
+ * resolve, no case to fold.
+ *
+ * Registers all six tools (ListFiles, ReadFile, GrepFiles, WriteFile, EditFile,
+ * CreateFile). Per the design plan, shared-view chat sessions allowlist only the
+ * read-only subset (List, Read, Grep) via `allowedTools`. The write-set is
+ * available for future use cases.
+ */
+export async function createDashboardFsServer(options) {
+    const index = await buildFileIndex({
+        dashboardRoot: options.dashboardRoot,
+        queryFiles: options.queryFiles
+    });
+    const listFiles = tool("ListFiles", "Lists every file the agent can read in this session, with a stable fileId for each. Call this first to discover what's available. Returns relativePath, size, writable, and the fileId you'll pass to ReadFile, WriteFile, EditFile, and GrepFiles.", {}, async () => executeListFiles(index));
+    const readFile = tool("ReadFile", "Reads a file by its fileId (from ListFiles). Returns line-numbered content. Use offset/limit to page through large files.", {
+        fileId: z.string().describe("The opaque file handle from ListFiles"),
+        offset: z.number().int().min(1).optional().describe("Line number to start reading from (1-indexed). Default: 1."),
+        limit: z.number().int().min(1).optional().describe("Maximum lines to read. Default: 2000.")
+    }, async (args) => executeReadFile(index, args));
+    const grepFiles = tool("GrepFiles", "Searches for a pattern across every file in this session's index using ripgrep. Returns matches as path:line:content. Pattern is a regex. Capped at 100 matches.", {
+        pattern: z.string().describe("The regex pattern to search for")
+    }, async (args) => executeGrepFiles(index, args));
+    const writeFile = tool("WriteFile", "Overwrites a file's content by fileId. Preserves the original line-ending style. Returns a unified diff of the change. The file must already exist in the index and be writable.", {
+        fileId: z.string().describe("The opaque file handle from ListFiles"),
+        content: z.string().describe("The new full content of the file")
+    }, async (args) => executeWriteFile(index, args));
+    const editFile = tool("EditFile", "Replaces a substring in a file by fileId. Tries exact match first, then line-trimmed and block-anchor matching to absorb minor whitespace drift. Set replaceAll: true to replace every occurrence.", {
+        fileId: z.string().describe("The opaque file handle from ListFiles"),
+        oldString: z.string().describe("The text to replace. Must match the file content (exact, line-trimmed, or block-anchored)."),
+        newString: z.string().describe("The text to replace it with"),
+        replaceAll: z.boolean().optional().describe("If true, replace every match. If false (default), require a unique match.")
+    }, async (args) => executeEditFile(index, args));
+    const createFile = tool("CreateFile", "Creates a new file under the dashboard root and adds it to the index. Returns the new fileId. The relativePath must not contain `.` or `..` segments and must not refer to an existing file.", {
+        relativePath: z.string().describe("Path relative to the dashboard root, e.g. 'components/Card.tsx'"),
+        content: z.string().describe("The content of the new file")
+    }, async (args) => executeCreateFile(index, options.dashboardRoot, args));
+    return {
+        server: createSdkMcpServer({
+            name: "dashboard-fs",
+            tools: [listFiles, readFile, grepFiles, writeFile, editFile, createFile]
+        }),
+        index,
+        // Useful for tests / inspection.
+        listFileIds: () => [...index.keys()]
+    };
+}

package/dist/dashboard-fs/read.d.ts

@@ -0,0 +1,28 @@
+import type { FileIndex } from "./file-index.js";
+interface ReadFileArgs {
+    fileId: unknown;
+    offset?: unknown;
+    limit?: unknown;
+}
+interface ToolResult {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Reads a file by handle. The agent never sees or constructs a path; the
+ * `fileId` is opaque and resolves to an absolute path only via the
+ * server-built index. Output format mirrors what models trained on the
+ * SDK Read tool already expect: `<line>: <content>` with truncation
+ * markers and a footer explaining offset/total.
+ */
+export declare function executeReadFile(index: FileIndex, args: ReadFileArgs): Promise<ToolResult>;
+/**
+ * Returns the index as a list of `{ fileId, relativePath, size, writable }`.
+ * The agent uses this to discover what's readable before issuing ReadFile.
+ */
+export declare function executeListFiles(index: FileIndex): ToolResult;
+export {};