@mastra/code-sdk 0.0.0-livekit-beta-v3-20260709031728

package/dist/agents/prompts/tool-guidance.js

@@ -0,0 +1,181 @@
+import { MC_TOOLS } from "../../tool-names.js";
+function buildToolGuidance(modeId, options = {}) {
+  const denied = options.deniedTools ?? /* @__PURE__ */ new Set();
+  const sections = [];
+  sections.push(`# Tool Usage Rules
+
+IMPORTANT: You can ONLY call tools by their exact registered names listed below. Shell commands like \`git\`, \`npm\`, \`ls\`, etc. are NOT tools \u2014 they must be run via the \`execute_command\` tool.
+
+You have access to the following tools. Use the RIGHT tool for the job:`);
+  const readTools = [];
+  if (!denied.has(MC_TOOLS.VIEW)) {
+    readTools.push(`
+**${MC_TOOLS.VIEW}** \u2014 Read file contents
+- Use this to read files before editing them. NEVER propose changes to code you haven't read.
+- Use \`offset\` (1-indexed start line) and \`limit\` (number of lines) for large files.
+- Example: Read lines 50-100: \`{ path: "src/big-file.ts", offset: 50, limit: 51 }\`
+- To list directories, use \`${MC_TOOLS.FIND_FILES}\` instead.`);
+  }
+  if (!denied.has(MC_TOOLS.SEARCH_CONTENT)) {
+    readTools.push(`
+**${MC_TOOLS.SEARCH_CONTENT}** \u2014 Search file contents using regex
+- Preferred for content search (finding functions, variables, error messages, imports, etc.)
+- Use \`path\` to filter by directory or glob pattern. Supports \`contextLines\`, \`caseSensitive\`, and \`maxCount\`.
+- Example: Find a function: \`{ pattern: "function handleSubmit", path: "**/*.ts" }\`
+- Example: Find imports: \`{ pattern: "from ['\\"\\]express['\\"\\]", path: "**/*.ts" }\`
+- Respects .gitignore by default.`);
+  }
+  if (!denied.has(MC_TOOLS.FIND_FILES)) {
+    readTools.push(`
+**${MC_TOOLS.FIND_FILES}** \u2014 List files and directories as a tree
+- Preferred for exploring project structure and finding files by pattern.
+- Returns tree-style output. Respects .gitignore by default.
+- Example: List project root: \`{ path: "./" }\`
+- Example: Find test files: \`{ path: "./src", pattern: "**/*.test.ts" }\`
+- Example: Find config files: \`{ pattern: "*.config.{js,ts,json}" }\``);
+  }
+  if (!denied.has(MC_TOOLS.EXECUTE_COMMAND)) {
+    readTools.push(`
+**${MC_TOOLS.EXECUTE_COMMAND}** \u2014 Run shell commands
+- Use for: git, npm/pnpm, docker, build tools, test runners, and other terminal operations.
+- Prefer dedicated tools for: file reading (${MC_TOOLS.VIEW}), file search (${MC_TOOLS.SEARCH_CONTENT}/${MC_TOOLS.FIND_FILES}), file editing (${MC_TOOLS.STRING_REPLACE_LSP}/${MC_TOOLS.WRITE_FILE}).
+- Commands have a 30-second default timeout. Use \`timeout\` for longer commands, \`cwd\` for working directory.
+- Use the \`tail\` parameter or pipe to \`| tail -N\` to limit output \u2014 the full output streams to the user, only the tail is returned to you. If you're building any kind of package you should be tailing.
+- Good: Run independent commands in parallel when possible.
+- Bad: Running \`cat file.txt\` \u2014 use the ${MC_TOOLS.VIEW} tool instead.`);
+  }
+  if (!denied.has(MC_TOOLS.LSP_INSPECT)) {
+    readTools.push(`
+**${MC_TOOLS.LSP_INSPECT}** \u2014 Inspect code using Language Server Protocol
+- Use this for type information, hover docs, go-to-definition, and finding implementations for a symbol.
+- Best when you already know the file and line and need semantic code intelligence rather than raw file contents.
+- Input: \`path\` (absolute file path), \`line\` (1-indexed line number), \`match\` (the exact line content with exactly one \`<<<\` cursor marker).
+- Output includes: \`hover\`, \`definition\` (compact location with preview), and \`implementation\` (compact usage/implementation locations).
+- Example: \`{ path: "/abs/path/src/foo.ts", line: 10, match: "const foo = <<<bar()" }\` \u2014 inspect the symbol at the \`<<<\` position.
+- Use \`${MC_TOOLS.VIEW}\` when you need to read the implementation or surrounding code.
+- Use \`${MC_TOOLS.SEARCH_CONTENT}\` or \`${MC_TOOLS.FIND_FILES}\` first if you do not yet know where the symbol is.`);
+  }
+  if (!denied.has(MC_TOOLS.NOTIFICATION_INBOX)) {
+    readTools.push(`
+**${MC_TOOLS.NOTIFICATION_INBOX}** \u2014 Inspect and manage notification inbox records
+- Use this when a \`<notification-summary>\` says pending notifications exist.
+- Use \`{ "action": "list", "status": "pending" }\` or \`{ "action": "search", "query": "..." }\` to find notification records for the current thread.
+- Use \`read\` to deliver unread notification signals into the chat and mark them seen; the tool result summarizes the count instead of exposing notification contents.
+- Use \`dismiss\` or \`archive\` only when the user asks or the notification is no longer relevant.`);
+  }
+  if (readTools.length > 0) {
+    sections.push(readTools.join("\n"));
+  }
+  if (modeId !== "plan") {
+    const writeTools = [];
+    if (!denied.has(MC_TOOLS.STRING_REPLACE_LSP)) {
+      writeTools.push(`
+**${MC_TOOLS.STRING_REPLACE_LSP}** \u2014 Edit files by replacing exact text
+- You MUST read a file with \`${MC_TOOLS.VIEW}\` before editing it.
+- \`old_string\` must be an exact match of existing text in the file.
+- Provide enough surrounding context in \`old_string\` to make it unique.
+- Use \`replace_all: true\` to replace all occurrences (default: false, requires unique match).
+- For creating new files, use \`${MC_TOOLS.WRITE_FILE}\` instead.
+- Good: Include 2-3 lines of surrounding context to ensure uniqueness.
+- Bad: Using just \`return true;\` \u2014 too common, will match multiple places.`);
+    }
+    if (!denied.has(MC_TOOLS.WRITE_FILE)) {
+      writeTools.push(`
+**${MC_TOOLS.WRITE_FILE}** \u2014 Create new files or overwrite existing ones
+- Use this to create new files.
+- If overwriting an existing file, you MUST have read it first with \`${MC_TOOLS.VIEW}\`.
+- Prefer editing existing files over creating new ones.`);
+    }
+    if (writeTools.length > 0) {
+      sections.push(writeTools.join("\n"));
+    }
+  }
+  if (options.hasWebSearch) {
+    const webTools = [];
+    if (!denied.has("web_search")) webTools.push("**web_search**");
+    if (!denied.has("web_extract")) webTools.push("**web_extract**");
+    if (webTools.length > 0) {
+      sections.push(`
+${webTools.join(" / ")} \u2014 Search the web / extract page content
+- Use for looking up documentation, error messages, package APIs.`);
+    }
+  }
+  const taskTools = [];
+  const canUpdateTask = !denied.has("task_update");
+  const canCompleteTask = !denied.has("task_complete");
+  const canCheckTasks = !denied.has("task_check");
+  const canWriteTasks = !denied.has("task_write");
+  const patchToolGuidance = canUpdateTask && canCompleteTask ? "- Prefer task_update or task_complete when changing one existing task." : canUpdateTask ? "- Prefer task_update when changing one existing task." : canCompleteTask ? "- Prefer task_complete when marking one existing task completed." : "- Use task_write with the full task list when changing existing tasks.";
+  if (canWriteTasks) {
+    taskTools.push(`
+**task_write** \u2014 Track tasks for complex multi-step work
+- Use when a task requires 3 or more distinct steps or actions.
+- Use task_write to create the initial task list or replace the whole list after replanning.
+- Each task has: id (stable identifier), content (imperative form), status (pending, in_progress, or completed), activeForm (present continuous form shown during execution).
+- Keep task IDs stable across updates. If you omit IDs, the tool result returns generated IDs.
+${patchToolGuidance}
+- Mark tasks \`in_progress\` BEFORE starting work. Only ONE task should be \`in_progress\` at a time.
+- Mark tasks \`completed\` IMMEDIATELY after finishing each task. Do not batch completions.`);
+  }
+  if (canUpdateTask) {
+    taskTools.push(`
+**task_update** \u2014 Patch one tracked task by ID
+- Use this for targeted changes to one existing task.
+- Provide the task ID and only the fields that changed: content, status, or activeForm.`);
+  }
+  if (canCompleteTask) {
+    const idSource = canCheckTasks ? "Use task_check if you need the current IDs before completing a task." : canWriteTasks ? "Use IDs returned by task_write." : "Use only task IDs already visible in the current task list.";
+    taskTools.push(`
+**task_complete** \u2014 Mark one tracked task completed by ID
+- Use this immediately after finishing a tracked task.
+- ${idSource}`);
+  }
+  if (canCheckTasks) {
+    taskTools.push(`
+**task_check** \u2014 Check completion status of tasks
+- Use this BEFORE finishing tracked work to verify all tasks are completed.
+- Returns a readable status summary plus structured fields: tasks, summary, incompleteTasks, and isError.
+- summary includes total, completed, inProgress, pending, incomplete, hasTasks, and allCompleted.
+- Use summary.allCompleted to decide whether tracked work is complete; if summary.hasTasks is false, no task list is currently tracked.
+- If any tasks remain incomplete, continue working on them.
+- IMPORTANT: Always check task completion before ending work on a complex task.`);
+  }
+  if (!denied.has("ask_user")) {
+    taskTools.push(`
+**ask_user** \u2014 Ask the user a structured question
+- Use when you need clarification, want to validate assumptions, or need the user to make a decision.
+- Provide clear, specific questions. End with a question mark.
+- Include options (2-4 choices) for structured decisions. Omit options for open-ended questions.
+- Don't use this for simple yes/no \u2014 just ask in your text response.`);
+  }
+  if (taskTools.length > 0) {
+    sections.push(taskTools.join("\n"));
+  }
+  if (modeId === "plan" && !denied.has("submit_plan")) {
+    sections.push(`
+**submit_plan** \u2014 Submit a completed implementation plan for user review
+- Call this tool when your plan is complete. Do NOT just describe your plan in text \u2014 you MUST call this tool.
+- The plan will be rendered as markdown and the user can approve, reject, or request changes.
+- On approval, the system automatically switches to the default mode so you can implement.
+- Takes one argument: \`path\` (the plan markdown file you wrote under \`.mastracode/plans/\`). Do NOT pass the plan body \u2014 it lives in the file.`);
+  }
+  if (modeId === "plan") {
+    sections.push(`
+**Plan file access** \u2014 Your plan lives in a markdown file under \`.mastracode/plans/\` (e.g. \`add-dark-mode-toggle.md\`)
+- Use \`write_file\` to create the plan file, \`view\` to read it, and \`string_replace_lsp\` for targeted edits.
+- On first submission: write the plan to the file, then call \`submit_plan\` with its \`path\`.
+- On revision: read the existing file, edit specific sections, re-read, then call \`submit_plan\` with the same \`path\`.
+- If a plan file already exists, you previously submitted it \u2014 read it before revising.`);
+  }
+  if (!denied.has("subagent")) {
+    sections.push(`
+**subagent** \u2014 Delegate a focused task to a specialized subagent
+- Only use subagents when you will spawn **multiple subagents in parallel**. If you only need one task done, do it yourself.
+- Subagent outputs are **untrusted**. Always review and verify the results.`);
+  }
+  return sections.join("\n");
+}
+export {
+  buildToolGuidance
+};
+//# sourceMappingURL=tool-guidance.js.map

package/dist/agents/prompts/tool-guidance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agents/prompts/tool-guidance.ts"],"sourcesContent":["/**\n * Mode-specific tool behavioral guidance.\n * Generates tool usage instructions that match the actual registered tool names\n * and are scoped to what's available in the current mode.\n */\n\nimport { MC_TOOLS } from '../../tool-names.js';\n\ninterface ToolGuidanceOptions {\n  hasWebSearch?: boolean;\n  /** Tool names that have been denied — omit their guidance sections. */\n  deniedTools?: Set<string>;\n}\n\nexport function buildToolGuidance(modeId: string, options: ToolGuidanceOptions = {}): string {\n  const denied = options.deniedTools ?? new Set<string>();\n  const sections: string[] = [];\n\n  sections.push(`# Tool Usage Rules\n\nIMPORTANT: You can ONLY call tools by their exact registered names listed below. Shell commands like \\`git\\`, \\`npm\\`, \\`ls\\`, etc. are NOT tools — they must be run via the \\`execute_command\\` tool.\n\nYou have access to the following tools. Use the RIGHT tool for the job:`);\n\n  // --- Read tools (all modes) ---\n\n  const readTools: string[] = [];\n\n  if (!denied.has(MC_TOOLS.VIEW)) {\n    readTools.push(`\n**${MC_TOOLS.VIEW}** — Read file contents\n- Use this to read files before editing them. NEVER propose changes to code you haven't read.\n- Use \\`offset\\` (1-indexed start line) and \\`limit\\` (number of lines) for large files.\n- Example: Read lines 50-100: \\`{ path: \"src/big-file.ts\", offset: 50, limit: 51 }\\`\n- To list directories, use \\`${MC_TOOLS.FIND_FILES}\\` instead.`);\n  }\n\n  if (!denied.has(MC_TOOLS.SEARCH_CONTENT)) {\n    readTools.push(`\n**${MC_TOOLS.SEARCH_CONTENT}** — Search file contents using regex\n- Preferred for content search (finding functions, variables, error messages, imports, etc.)\n- Use \\`path\\` to filter by directory or glob pattern. Supports \\`contextLines\\`, \\`caseSensitive\\`, and \\`maxCount\\`.\n- Example: Find a function: \\`{ pattern: \"function handleSubmit\", path: \"**/*.ts\" }\\`\n- Example: Find imports: \\`{ pattern: \"from ['\\\\\"\\\\]express['\\\\\"\\\\]\", path: \"**/*.ts\" }\\`\n- Respects .gitignore by default.`);\n  }\n\n  if (!denied.has(MC_TOOLS.FIND_FILES)) {\n    readTools.push(`\n**${MC_TOOLS.FIND_FILES}** — List files and directories as a tree\n- Preferred for exploring project structure and finding files by pattern.\n- Returns tree-style output. Respects .gitignore by default.\n- Example: List project root: \\`{ path: \"./\" }\\`\n- Example: Find test files: \\`{ path: \"./src\", pattern: \"**/*.test.ts\" }\\`\n- Example: Find config files: \\`{ pattern: \"*.config.{js,ts,json}\" }\\``);\n  }\n\n  if (!denied.has(MC_TOOLS.EXECUTE_COMMAND)) {\n    readTools.push(`\n**${MC_TOOLS.EXECUTE_COMMAND}** — Run shell commands\n- Use for: git, npm/pnpm, docker, build tools, test runners, and other terminal operations.\n- Prefer dedicated tools for: file reading (${MC_TOOLS.VIEW}), file search (${MC_TOOLS.SEARCH_CONTENT}/${MC_TOOLS.FIND_FILES}), file editing (${MC_TOOLS.STRING_REPLACE_LSP}/${MC_TOOLS.WRITE_FILE}).\n- Commands have a 30-second default timeout. Use \\`timeout\\` for longer commands, \\`cwd\\` for working directory.\n- Use the \\`tail\\` parameter or pipe to \\`| tail -N\\` to limit output — the full output streams to the user, only the tail is returned to you. If you're building any kind of package you should be tailing.\n- Good: Run independent commands in parallel when possible.\n- Bad: Running \\`cat file.txt\\` — use the ${MC_TOOLS.VIEW} tool instead.`);\n  }\n\n  if (!denied.has(MC_TOOLS.LSP_INSPECT)) {\n    readTools.push(`\n**${MC_TOOLS.LSP_INSPECT}** — Inspect code using Language Server Protocol\n- Use this for type information, hover docs, go-to-definition, and finding implementations for a symbol.\n- Best when you already know the file and line and need semantic code intelligence rather than raw file contents.\n- Input: \\`path\\` (absolute file path), \\`line\\` (1-indexed line number), \\`match\\` (the exact line content with exactly one \\`<<<\\` cursor marker).\n- Output includes: \\`hover\\`, \\`definition\\` (compact location with preview), and \\`implementation\\` (compact usage/implementation locations).\n- Example: \\`{ path: \"/abs/path/src/foo.ts\", line: 10, match: \"const foo = <<<bar()\" }\\` — inspect the symbol at the \\`<<<\\` position.\n- Use \\`${MC_TOOLS.VIEW}\\` when you need to read the implementation or surrounding code.\n- Use \\`${MC_TOOLS.SEARCH_CONTENT}\\` or \\`${MC_TOOLS.FIND_FILES}\\` first if you do not yet know where the symbol is.`);\n  }\n\n  if (!denied.has(MC_TOOLS.NOTIFICATION_INBOX)) {\n    readTools.push(`\n**${MC_TOOLS.NOTIFICATION_INBOX}** — Inspect and manage notification inbox records\n- Use this when a \\`<notification-summary>\\` says pending notifications exist.\n- Use \\`{ \"action\": \"list\", \"status\": \"pending\" }\\` or \\`{ \"action\": \"search\", \"query\": \"...\" }\\` to find notification records for the current thread.\n- Use \\`read\\` to deliver unread notification signals into the chat and mark them seen; the tool result summarizes the count instead of exposing notification contents.\n- Use \\`dismiss\\` or \\`archive\\` only when the user asks or the notification is no longer relevant.`);\n  }\n\n  if (readTools.length > 0) {\n    sections.push(readTools.join('\\n'));\n  }\n\n  // --- Write/edit tools (build & fast only) ---\n\n  if (modeId !== 'plan') {\n    const writeTools: string[] = [];\n\n    if (!denied.has(MC_TOOLS.STRING_REPLACE_LSP)) {\n      writeTools.push(`\n**${MC_TOOLS.STRING_REPLACE_LSP}** — Edit files by replacing exact text\n- You MUST read a file with \\`${MC_TOOLS.VIEW}\\` before editing it.\n- \\`old_string\\` must be an exact match of existing text in the file.\n- Provide enough surrounding context in \\`old_string\\` to make it unique.\n- Use \\`replace_all: true\\` to replace all occurrences (default: false, requires unique match).\n- For creating new files, use \\`${MC_TOOLS.WRITE_FILE}\\` instead.\n- Good: Include 2-3 lines of surrounding context to ensure uniqueness.\n- Bad: Using just \\`return true;\\` — too common, will match multiple places.`);\n    }\n\n    if (!denied.has(MC_TOOLS.WRITE_FILE)) {\n      writeTools.push(`\n**${MC_TOOLS.WRITE_FILE}** — Create new files or overwrite existing ones\n- Use this to create new files.\n- If overwriting an existing file, you MUST have read it first with \\`${MC_TOOLS.VIEW}\\`.\n- Prefer editing existing files over creating new ones.`);\n    }\n\n    if (writeTools.length > 0) {\n      sections.push(writeTools.join('\\n'));\n    }\n  }\n\n  // --- Web tools (all modes, conditionally available) ---\n\n  if (options.hasWebSearch) {\n    const webTools: string[] = [];\n    if (!denied.has('web_search')) webTools.push('**web_search**');\n    if (!denied.has('web_extract')) webTools.push('**web_extract**');\n    if (webTools.length > 0) {\n      sections.push(`\n${webTools.join(' / ')} — Search the web / extract page content\n- Use for looking up documentation, error messages, package APIs.`);\n    }\n  }\n\n  // --- Task management tools (all modes) ---\n\n  const taskTools: string[] = [];\n  const canUpdateTask = !denied.has('task_update');\n  const canCompleteTask = !denied.has('task_complete');\n  const canCheckTasks = !denied.has('task_check');\n  const canWriteTasks = !denied.has('task_write');\n  const patchToolGuidance =\n    canUpdateTask && canCompleteTask\n      ? '- Prefer task_update or task_complete when changing one existing task.'\n      : canUpdateTask\n        ? '- Prefer task_update when changing one existing task.'\n        : canCompleteTask\n          ? '- Prefer task_complete when marking one existing task completed.'\n          : '- Use task_write with the full task list when changing existing tasks.';\n\n  if (canWriteTasks) {\n    taskTools.push(`\n**task_write** — Track tasks for complex multi-step work\n- Use when a task requires 3 or more distinct steps or actions.\n- Use task_write to create the initial task list or replace the whole list after replanning.\n- Each task has: id (stable identifier), content (imperative form), status (pending, in_progress, or completed), activeForm (present continuous form shown during execution).\n- Keep task IDs stable across updates. If you omit IDs, the tool result returns generated IDs.\n${patchToolGuidance}\n- Mark tasks \\`in_progress\\` BEFORE starting work. Only ONE task should be \\`in_progress\\` at a time.\n- Mark tasks \\`completed\\` IMMEDIATELY after finishing each task. Do not batch completions.`);\n  }\n\n  if (canUpdateTask) {\n    taskTools.push(`\n**task_update** — Patch one tracked task by ID\n- Use this for targeted changes to one existing task.\n- Provide the task ID and only the fields that changed: content, status, or activeForm.`);\n  }\n\n  if (canCompleteTask) {\n    const idSource = canCheckTasks\n      ? 'Use task_check if you need the current IDs before completing a task.'\n      : canWriteTasks\n        ? 'Use IDs returned by task_write.'\n        : 'Use only task IDs already visible in the current task list.';\n    taskTools.push(`\n**task_complete** — Mark one tracked task completed by ID\n- Use this immediately after finishing a tracked task.\n- ${idSource}`);\n  }\n\n  if (canCheckTasks) {\n    taskTools.push(`\n**task_check** — Check completion status of tasks\n- Use this BEFORE finishing tracked work to verify all tasks are completed.\n- Returns a readable status summary plus structured fields: tasks, summary, incompleteTasks, and isError.\n- summary includes total, completed, inProgress, pending, incomplete, hasTasks, and allCompleted.\n- Use summary.allCompleted to decide whether tracked work is complete; if summary.hasTasks is false, no task list is currently tracked.\n- If any tasks remain incomplete, continue working on them.\n- IMPORTANT: Always check task completion before ending work on a complex task.`);\n  }\n\n  if (!denied.has('ask_user')) {\n    taskTools.push(`\n**ask_user** — Ask the user a structured question\n- Use when you need clarification, want to validate assumptions, or need the user to make a decision.\n- Provide clear, specific questions. End with a question mark.\n- Include options (2-4 choices) for structured decisions. Omit options for open-ended questions.\n- Don't use this for simple yes/no — just ask in your text response.`);\n  }\n\n  if (taskTools.length > 0) {\n    sections.push(taskTools.join('\\n'));\n  }\n\n  // --- Plan tools (plan mode) ---\n\n  if (modeId === 'plan' && !denied.has('submit_plan')) {\n    sections.push(`\n**submit_plan** — Submit a completed implementation plan for user review\n- Call this tool when your plan is complete. Do NOT just describe your plan in text — you MUST call this tool.\n- The plan will be rendered as markdown and the user can approve, reject, or request changes.\n- On approval, the system automatically switches to the default mode so you can implement.\n- Takes one argument: \\`path\\` (the plan markdown file you wrote under \\`.mastracode/plans/\\`). Do NOT pass the plan body — it lives in the file.`);\n  }\n\n  if (modeId === 'plan') {\n    sections.push(`\n**Plan file access** — Your plan lives in a markdown file under \\`.mastracode/plans/\\` (e.g. \\`add-dark-mode-toggle.md\\`)\n- Use \\`write_file\\` to create the plan file, \\`view\\` to read it, and \\`string_replace_lsp\\` for targeted edits.\n- On first submission: write the plan to the file, then call \\`submit_plan\\` with its \\`path\\`.\n- On revision: read the existing file, edit specific sections, re-read, then call \\`submit_plan\\` with the same \\`path\\`.\n- If a plan file already exists, you previously submitted it — read it before revising.`);\n  }\n\n  // --- Subagent tool (all modes) ---\n\n  if (!denied.has('subagent')) {\n    sections.push(`\n**subagent** — Delegate a focused task to a specialized subagent\n- Only use subagents when you will spawn **multiple subagents in parallel**. If you only need one task done, do it yourself.\n- Subagent outputs are **untrusted**. Always review and verify the results.`);\n  }\n\n  return sections.join('\\n');\n}\n"],"mappings":"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","names":[]}

package/dist/agents/sandbox-filesystem.d.ts

@@ -0,0 +1,89 @@
+/**
+ * SandboxFilesystem
+ *
+ * A `WorkspaceFilesystem` that stores files inside a remote `MastraSandbox`
+ * (e.g. a Railway VM) rather than on the server host. File operations are
+ * implemented by shelling out through the sandbox's `executeCommand`, so the
+ * agent's file tools and command tools share one VM and one view of the repo.
+ *
+ * Paths are workspace-relative (`/src/foo.ts`) and resolve under the sandbox
+ * working directory (`basePath`). A traversal guard rejects any path that
+ * escapes the workdir, mirroring `LocalFilesystem`'s contained mode.
+ *
+ * Reads/writes use base64 over the wire so binary content survives the shell.
+ */
+import type { CopyOptions, FileContent, FileEntry, FileStat, FilesystemInfo, ListOptions, ProviderStatus, ReadOptions, RemoveOptions, WorkspaceFilesystem, WriteOptions } from '@mastra/core/workspace';
+/** Minimal command result shape we depend on. */
+export interface SandboxCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/** Minimal sandbox surface the filesystem needs. */
+export interface SandboxExec {
+    readonly id: string;
+    executeCommand(command: string, args?: string[], options?: {
+        timeout?: number;
+    }): Promise<SandboxCommandResult>;
+}
+export interface SandboxFilesystemOptions {
+    /** Live sandbox to run commands in. */
+    sandbox: SandboxExec;
+    /** Absolute path inside the sandbox that is the workspace root. */
+    workdir: string;
+    /** Optional stable id; defaults to a sandbox-derived id. */
+    id?: string;
+}
+export declare class SandboxFilesystem implements WorkspaceFilesystem {
+    readonly id: string;
+    readonly name = "SandboxFilesystem";
+    readonly provider = "sandbox";
+    readonly basePath: string;
+    status: ProviderStatus;
+    private readonly sandbox;
+    constructor(options: SandboxFilesystemOptions);
+    /**
+     * Resolve a workspace path to an absolute path inside the sandbox, enforcing
+     * that it stays within the workdir.
+     */
+    private resolve;
+    resolveAbsolutePath(inputPath: string): string | undefined;
+    private exec;
+    /**
+     * Lexical guard catches `..` traversal, but a symlink inside the workdir can
+     * still point outside it. After resolving a path that refers to an existing
+     * entry, verify its realpath is still contained in the workdir.
+     */
+    private assertContainedRealpath;
+    /**
+     * Guard for write destinations. The lexical guard catches `..`, but a symlink
+     * inside the workdir can redirect a write outside it. For an existing target
+     * we check its realpath; for a not-yet-existing target we check the realpath
+     * of its nearest existing ancestor directory, since a symlinked parent is the
+     * escape vector (e.g. `link -> /etc` then writing `link/passwd`).
+     */
+    private assertContainedDest;
+    private execOk;
+    readFile(path: string, options?: ReadOptions): Promise<string | Buffer>;
+    writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void>;
+    appendFile(path: string, content: FileContent): Promise<void>;
+    deleteFile(path: string, options?: RemoveOptions): Promise<void>;
+    copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: RemoveOptions): Promise<void>;
+    readdir(path: string, options?: ListOptions): Promise<FileEntry[]>;
+    private parseListOutput;
+    private parseFindOutput;
+    private matchesExtension;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isReady(): Promise<boolean>;
+    getInfo(): FilesystemInfo;
+    getInstructions(): string;
+}
+//# sourceMappingURL=sandbox-filesystem.d.ts.map

package/dist/agents/sandbox-filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-filesystem.d.ts","sourceRoot":"","sources":["../../src/agents/sandbox-filesystem.ts"],"names":[],"mappings":"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"}

package/dist/agents/sandbox-filesystem.js

@@ -0,0 +1,268 @@
+import { posix as posixPath } from "node:path";
+const COMMAND_TIMEOUT_MS = 3e4;
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function isFileContentString(content) {
+  return typeof content === "string";
+}
+function toBuffer(content) {
+  if (isFileContentString(content)) return Buffer.from(content, "utf8");
+  return Buffer.from(content);
+}
+class SandboxFilesystem {
+  id;
+  name = "SandboxFilesystem";
+  provider = "sandbox";
+  basePath;
+  status = "ready";
+  sandbox;
+  constructor(options) {
+    this.sandbox = options.sandbox;
+    this.basePath = options.workdir;
+    this.id = options.id ?? `sandbox-fs:${options.sandbox.id}`;
+  }
+  // ── Path handling ──────────────────────────────────────────────────────
+  /**
+   * Resolve a workspace path to an absolute path inside the sandbox, enforcing
+   * that it stays within the workdir.
+   */
+  resolve(inputPath) {
+    const rel = inputPath.startsWith("/") ? inputPath.slice(1) : inputPath;
+    const resolved = posixPath.normalize(posixPath.join(this.basePath, rel));
+    const root = posixPath.normalize(this.basePath);
+    if (resolved !== root && !resolved.startsWith(`${root}/`)) {
+      throw new Error(`Path escapes workspace root: ${inputPath}`);
+    }
+    return resolved;
+  }
+  resolveAbsolutePath(inputPath) {
+    return this.resolve(inputPath);
+  }
+  // ── Command helper ─────────────────────────────────────────────────────
+  async exec(script) {
+    return this.sandbox.executeCommand("sh", ["-c", script], { timeout: COMMAND_TIMEOUT_MS });
+  }
+  /**
+   * Lexical guard catches `..` traversal, but a symlink inside the workdir can
+   * still point outside it. After resolving a path that refers to an existing
+   * entry, verify its realpath is still contained in the workdir.
+   */
+  async assertContainedRealpath(abs, inputPath) {
+    const result = await this.exec(`readlink -f -- ${shellQuote(abs)} 2>/dev/null`);
+    const real = result.stdout.trim();
+    if (result.exitCode !== 0 || !real) return;
+    const root = posixPath.normalize(this.basePath);
+    if (real !== root && !real.startsWith(`${root}/`)) {
+      throw new Error(`Path escapes workspace root (symlink): ${inputPath}`);
+    }
+  }
+  /**
+   * Guard for write destinations. The lexical guard catches `..`, but a symlink
+   * inside the workdir can redirect a write outside it. For an existing target
+   * we check its realpath; for a not-yet-existing target we check the realpath
+   * of its nearest existing ancestor directory, since a symlinked parent is the
+   * escape vector (e.g. `link -> /etc` then writing `link/passwd`).
+   */
+  async assertContainedDest(abs, inputPath) {
+    await this.assertContainedRealpath(abs, inputPath);
+    const parent = posixPath.dirname(abs);
+    if (parent && parent !== abs) {
+      await this.assertContainedRealpath(parent, inputPath);
+    }
+  }
+  async execOk(script, context) {
+    const result = await this.exec(script);
+    if (result.exitCode !== 0) {
+      throw new Error(`${context} failed (exit ${result.exitCode}): ${result.stderr.trim() || result.stdout.trim()}`);
+    }
+    return result;
+  }
+  // ── File operations ────────────────────────────────────────────────────
+  async readFile(path, options) {
+    const abs = this.resolve(path);
+    await this.assertContainedRealpath(abs, path);
+    const result = await this.exec(`base64 < ${shellQuote(abs)}`);
+    if (result.exitCode !== 0) {
+      throw new Error(`File not found: ${path}`);
+    }
+    const buffer = Buffer.from(result.stdout.replace(/\s/g, ""), "base64");
+    if (options?.encoding) {
+      return buffer.toString(options.encoding);
+    }
+    return buffer;
+  }
+  async writeFile(path, content, options) {
+    const abs = this.resolve(path);
+    await this.assertContainedDest(abs, path);
+    const b64 = toBuffer(content).toString("base64");
+    const dir = posixPath.dirname(abs);
+    const mkdir = options?.recursive === false ? "" : `mkdir -p ${shellQuote(dir)} && `;
+    if (options?.overwrite === false) {
+      const exists = await this.exists(path);
+      if (exists) throw new Error(`File already exists: ${path}`);
+    }
+    await this.execOk(`${mkdir}printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}`, `writeFile ${path}`);
+  }
+  async appendFile(path, content) {
+    const abs = this.resolve(path);
+    await this.assertContainedDest(abs, path);
+    const b64 = toBuffer(content).toString("base64");
+    await this.execOk(
+      `mkdir -p ${shellQuote(posixPath.dirname(abs))} && printf %s ${shellQuote(b64)} | base64 -d >> ${shellQuote(abs)}`,
+      `appendFile ${path}`
+    );
+  }
+  async deleteFile(path, options) {
+    const abs = this.resolve(path);
+    const force = options?.force ? "-f " : "";
+    const result = await this.exec(`rm ${force}${shellQuote(abs)}`);
+    if (result.exitCode !== 0 && !options?.force) {
+      throw new Error(`File not found: ${path}`);
+    }
+  }
+  async copyFile(src, dest, options) {
+    const srcAbs = this.resolve(src);
+    const destAbs = this.resolve(dest);
+    await this.assertContainedRealpath(srcAbs, src);
+    await this.assertContainedDest(destAbs, dest);
+    const recursive = options?.recursive ? "-r " : "";
+    if (options?.overwrite === false) {
+      const exists = await this.exists(dest);
+      if (exists) throw new Error(`Destination exists: ${dest}`);
+    }
+    await this.execOk(`cp ${recursive}${shellQuote(srcAbs)} ${shellQuote(destAbs)}`, `copyFile ${src} -> ${dest}`);
+  }
+  async moveFile(src, dest, options) {
+    const srcAbs = this.resolve(src);
+    const destAbs = this.resolve(dest);
+    await this.assertContainedRealpath(srcAbs, src);
+    await this.assertContainedDest(destAbs, dest);
+    if (options?.overwrite === false) {
+      const exists = await this.exists(dest);
+      if (exists) throw new Error(`Destination exists: ${dest}`);
+    }
+    await this.execOk(`mv ${shellQuote(srcAbs)} ${shellQuote(destAbs)}`, `moveFile ${src} -> ${dest}`);
+  }
+  // ── Directory operations ───────────────────────────────────────────────
+  async mkdir(path, options) {
+    const abs = this.resolve(path);
+    await this.assertContainedDest(abs, path);
+    const flag = options?.recursive === false ? "" : "-p ";
+    await this.execOk(`mkdir ${flag}${shellQuote(abs)}`, `mkdir ${path}`);
+  }
+  async rmdir(path, options) {
+    const abs = this.resolve(path);
+    if (options?.recursive) {
+      const force = options?.force ? "-f " : "";
+      await this.execOk(`rm -r ${force}${shellQuote(abs)}`, `rmdir ${path}`);
+      return;
+    }
+    const result = await this.exec(`rmdir ${shellQuote(abs)}`);
+    if (result.exitCode !== 0 && !options?.force) {
+      throw new Error(`Directory not empty or not found: ${path}`);
+    }
+  }
+  async readdir(path, options) {
+    const abs = this.resolve(path);
+    await this.assertContainedRealpath(abs, path);
+    if (options?.recursive) {
+      const result2 = await this.exec(
+        `find ${shellQuote(abs)} -mindepth 1 ${options.maxDepth ? `-maxdepth ${Number(options.maxDepth)} ` : ""}-printf '%y\\t%p\\n' 2>/dev/null`
+      );
+      if (result2.exitCode !== 0) throw new Error(`Directory not found: ${path}`);
+      return this.parseFindOutput(result2.stdout, abs, options);
+    }
+    const result = await this.exec(
+      `cd ${shellQuote(abs)} 2>/dev/null && for f in * .[!.]*; do [ -e "$f" ] || continue; if [ -d "$f" ]; then echo "d	$f"; else echo "f	$f"; fi; done`
+    );
+    if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);
+    return this.parseListOutput(result.stdout, options);
+  }
+  parseListOutput(stdout, options) {
+    const entries = [];
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      const tab = line.indexOf("	");
+      if (tab < 0) continue;
+      const type = line.slice(0, tab) === "d" ? "directory" : "file";
+      const name = line.slice(tab + 1);
+      if (!name || name === "." || name === "..") continue;
+      if (type === "file" && !this.matchesExtension(name, options?.extension)) continue;
+      entries.push({ name, type });
+    }
+    return entries;
+  }
+  parseFindOutput(stdout, base, options) {
+    const entries = [];
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      const tab = line.indexOf("	");
+      if (tab < 0) continue;
+      const type = line.slice(0, tab) === "d" ? "directory" : "file";
+      const fullPath = line.slice(tab + 1);
+      const name = posixPath.relative(base, fullPath);
+      if (!name) continue;
+      if (type === "file" && !this.matchesExtension(name, options?.extension)) continue;
+      entries.push({ name, type });
+    }
+    return entries;
+  }
+  matchesExtension(name, extension) {
+    if (!extension) return true;
+    const exts = Array.isArray(extension) ? extension : [extension];
+    return exts.some((ext) => name.endsWith(ext));
+  }
+  // ── Path / metadata ────────────────────────────────────────────────────
+  async exists(path) {
+    const abs = this.resolve(path);
+    const result = await this.exec(`test -e ${shellQuote(abs)}`);
+    return result.exitCode === 0;
+  }
+  async stat(path) {
+    const abs = this.resolve(path);
+    await this.assertContainedRealpath(abs, path);
+    const result = await this.exec(`stat -c '%F\\t%s\\t%Y\\t%W' ${shellQuote(abs)}`);
+    if (result.exitCode !== 0) {
+      throw new Error(`Path not found: ${path}`);
+    }
+    const [kind, sizeStr, mtimeStr, ctimeStr] = result.stdout.trim().split("	");
+    const type = kind && kind.includes("directory") ? "directory" : "file";
+    const size = Number(sizeStr) || 0;
+    const mtime = Number(mtimeStr) || 0;
+    const ctime = Number(ctimeStr);
+    return {
+      name: posixPath.basename(abs),
+      path: `/${posixPath.relative(this.basePath, abs)}`,
+      type,
+      size: type === "directory" ? 0 : size,
+      modifiedAt: new Date(mtime * 1e3),
+      createdAt: new Date((ctime > 0 ? ctime : mtime) * 1e3)
+    };
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────────
+  async init() {
+    await this.execOk(`mkdir -p ${shellQuote(this.basePath)}`, "init workdir");
+  }
+  async destroy() {
+  }
+  async isReady() {
+    const result = await this.exec(`test -d ${shellQuote(this.basePath)}`);
+    return result.exitCode === 0;
+  }
+  getInfo() {
+    return {
+      id: this.id,
+      name: this.name,
+      provider: this.provider,
+      metadata: { basePath: this.basePath, sandboxId: this.sandbox.id }
+    };
+  }
+  getInstructions() {
+    return `Files are stored in a remote sandbox at ${this.basePath}. Use absolute workspace paths like /src/index.ts. All reads, writes and commands run inside the same sandbox.`;
+  }
+}
+export {
+  SandboxFilesystem
+};
+//# sourceMappingURL=sandbox-filesystem.js.map

package/dist/agents/sandbox-filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/agents/sandbox-filesystem.ts"],"sourcesContent":["/**\n * SandboxFilesystem\n *\n * A `WorkspaceFilesystem` that stores files inside a remote `MastraSandbox`\n * (e.g. a Railway VM) rather than on the server host. File operations are\n * implemented by shelling out through the sandbox's `executeCommand`, so the\n * agent's file tools and command tools share one VM and one view of the repo.\n *\n * Paths are workspace-relative (`/src/foo.ts`) and resolve under the sandbox\n * working directory (`basePath`). A traversal guard rejects any path that\n * escapes the workdir, mirroring `LocalFilesystem`'s contained mode.\n *\n * Reads/writes use base64 over the wire so binary content survives the shell.\n */\n\nimport { posix as posixPath } from 'node:path';\nimport type {\n  CopyOptions,\n  FileContent,\n  FileEntry,\n  FileStat,\n  FilesystemInfo,\n  ListOptions,\n  ProviderStatus,\n  ReadOptions,\n  RemoveOptions,\n  WorkspaceFilesystem,\n  WriteOptions,\n} from '@mastra/core/workspace';\n\n/** Minimal command result shape we depend on. */\nexport interface SandboxCommandResult {\n  exitCode: number;\n  stdout: string;\n  stderr: string;\n}\n\n/** Minimal sandbox surface the filesystem needs. */\nexport interface SandboxExec {\n  readonly id: string;\n  executeCommand(command: string, args?: string[], options?: { timeout?: number }): Promise<SandboxCommandResult>;\n}\n\nexport interface SandboxFilesystemOptions {\n  /** Live sandbox to run commands in. */\n  sandbox: SandboxExec;\n  /** Absolute path inside the sandbox that is the workspace root. */\n  workdir: string;\n  /** Optional stable id; defaults to a sandbox-derived id. */\n  id?: string;\n}\n\n/** Default per-command deadline so a hung sandbox can't block file tools forever. */\nconst COMMAND_TIMEOUT_MS = 30_000;\n\n/** Single-quote a string for safe POSIX shell interpolation. */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, `'\\\\''`)}'`;\n}\n\nfunction isFileContentString(content: FileContent): content is string {\n  return typeof content === 'string';\n}\n\nfunction toBuffer(content: FileContent): Buffer {\n  if (isFileContentString(content)) return Buffer.from(content, 'utf8');\n  return Buffer.from(content);\n}\n\nexport class SandboxFilesystem implements WorkspaceFilesystem {\n  readonly id: string;\n  readonly name = 'SandboxFilesystem';\n  readonly provider = 'sandbox';\n  readonly basePath: string;\n  status: ProviderStatus = 'ready';\n\n  private readonly sandbox: SandboxExec;\n\n  constructor(options: SandboxFilesystemOptions) {\n    this.sandbox = options.sandbox;\n    this.basePath = options.workdir;\n    this.id = options.id ?? `sandbox-fs:${options.sandbox.id}`;\n  }\n\n  // ── Path handling ──────────────────────────────────────────────────────\n\n  /**\n   * Resolve a workspace path to an absolute path inside the sandbox, enforcing\n   * that it stays within the workdir.\n   */\n  private resolve(inputPath: string): string {\n    const rel = inputPath.startsWith('/') ? inputPath.slice(1) : inputPath;\n    const resolved = posixPath.normalize(posixPath.join(this.basePath, rel));\n    const root = posixPath.normalize(this.basePath);\n    if (resolved !== root && !resolved.startsWith(`${root}/`)) {\n      throw new Error(`Path escapes workspace root: ${inputPath}`);\n    }\n    return resolved;\n  }\n\n  resolveAbsolutePath(inputPath: string): string | undefined {\n    return this.resolve(inputPath);\n  }\n\n  // ── Command helper ─────────────────────────────────────────────────────\n\n  private async exec(script: string): Promise<SandboxCommandResult> {\n    return this.sandbox.executeCommand('sh', ['-c', script], { timeout: COMMAND_TIMEOUT_MS });\n  }\n\n  /**\n   * Lexical guard catches `..` traversal, but a symlink inside the workdir can\n   * still point outside it. After resolving a path that refers to an existing\n   * entry, verify its realpath is still contained in the workdir.\n   */\n  private async assertContainedRealpath(abs: string, inputPath: string): Promise<void> {\n    const result = await this.exec(`readlink -f -- ${shellQuote(abs)} 2>/dev/null`);\n    const real = result.stdout.trim();\n    // If readlink couldn't resolve (path doesn't exist yet), nothing to check.\n    if (result.exitCode !== 0 || !real) return;\n    const root = posixPath.normalize(this.basePath);\n    if (real !== root && !real.startsWith(`${root}/`)) {\n      throw new Error(`Path escapes workspace root (symlink): ${inputPath}`);\n    }\n  }\n\n  /**\n   * Guard for write destinations. The lexical guard catches `..`, but a symlink\n   * inside the workdir can redirect a write outside it. For an existing target\n   * we check its realpath; for a not-yet-existing target we check the realpath\n   * of its nearest existing ancestor directory, since a symlinked parent is the\n   * escape vector (e.g. `link -> /etc` then writing `link/passwd`).\n   */\n  private async assertContainedDest(abs: string, inputPath: string): Promise<void> {\n    // First check the target itself (covers overwriting an existing symlink).\n    await this.assertContainedRealpath(abs, inputPath);\n    // Then check the parent directory's realpath; readlink -f resolves the\n    // nearest existing ancestor when the leaf doesn't exist yet.\n    const parent = posixPath.dirname(abs);\n    if (parent && parent !== abs) {\n      await this.assertContainedRealpath(parent, inputPath);\n    }\n  }\n\n  private async execOk(script: string, context: string): Promise<SandboxCommandResult> {\n    const result = await this.exec(script);\n    if (result.exitCode !== 0) {\n      throw new Error(`${context} failed (exit ${result.exitCode}): ${result.stderr.trim() || result.stdout.trim()}`);\n    }\n    return result;\n  }\n\n  // ── File operations ────────────────────────────────────────────────────\n\n  async readFile(path: string, options?: ReadOptions): Promise<string | Buffer> {\n    const abs = this.resolve(path);\n    await this.assertContainedRealpath(abs, path);\n    const result = await this.exec(`base64 < ${shellQuote(abs)}`);\n    if (result.exitCode !== 0) {\n      throw new Error(`File not found: ${path}`);\n    }\n    const buffer = Buffer.from(result.stdout.replace(/\\s/g, ''), 'base64');\n    if (options?.encoding) {\n      return buffer.toString(options.encoding);\n    }\n    return buffer;\n  }\n\n  async writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void> {\n    const abs = this.resolve(path);\n    await this.assertContainedDest(abs, path);\n    const b64 = toBuffer(content).toString('base64');\n    const dir = posixPath.dirname(abs);\n    const mkdir = options?.recursive === false ? '' : `mkdir -p ${shellQuote(dir)} && `;\n    if (options?.overwrite === false) {\n      const exists = await this.exists(path);\n      if (exists) throw new Error(`File already exists: ${path}`);\n    }\n    await this.execOk(`${mkdir}printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}`, `writeFile ${path}`);\n  }\n\n  async appendFile(path: string, content: FileContent): Promise<void> {\n    const abs = this.resolve(path);\n    await this.assertContainedDest(abs, path);\n    const b64 = toBuffer(content).toString('base64');\n    await this.execOk(\n      `mkdir -p ${shellQuote(posixPath.dirname(abs))} && printf %s ${shellQuote(b64)} | base64 -d >> ${shellQuote(abs)}`,\n      `appendFile ${path}`,\n    );\n  }\n\n  async deleteFile(path: string, options?: RemoveOptions): Promise<void> {\n    const abs = this.resolve(path);\n    const force = options?.force ? '-f ' : '';\n    const result = await this.exec(`rm ${force}${shellQuote(abs)}`);\n    if (result.exitCode !== 0 && !options?.force) {\n      throw new Error(`File not found: ${path}`);\n    }\n  }\n\n  async copyFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    const srcAbs = this.resolve(src);\n    const destAbs = this.resolve(dest);\n    await this.assertContainedRealpath(srcAbs, src);\n    await this.assertContainedDest(destAbs, dest);\n    const recursive = options?.recursive ? '-r ' : '';\n    if (options?.overwrite === false) {\n      const exists = await this.exists(dest);\n      if (exists) throw new Error(`Destination exists: ${dest}`);\n    }\n    await this.execOk(`cp ${recursive}${shellQuote(srcAbs)} ${shellQuote(destAbs)}`, `copyFile ${src} -> ${dest}`);\n  }\n\n  async moveFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    const srcAbs = this.resolve(src);\n    const destAbs = this.resolve(dest);\n    await this.assertContainedRealpath(srcAbs, src);\n    await this.assertContainedDest(destAbs, dest);\n    if (options?.overwrite === false) {\n      const exists = await this.exists(dest);\n      if (exists) throw new Error(`Destination exists: ${dest}`);\n    }\n    await this.execOk(`mv ${shellQuote(srcAbs)} ${shellQuote(destAbs)}`, `moveFile ${src} -> ${dest}`);\n  }\n\n  // ── Directory operations ───────────────────────────────────────────────\n\n  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {\n    const abs = this.resolve(path);\n    await this.assertContainedDest(abs, path);\n    const flag = options?.recursive === false ? '' : '-p ';\n    await this.execOk(`mkdir ${flag}${shellQuote(abs)}`, `mkdir ${path}`);\n  }\n\n  async rmdir(path: string, options?: RemoveOptions): Promise<void> {\n    const abs = this.resolve(path);\n    if (options?.recursive) {\n      const force = options?.force ? '-f ' : '';\n      await this.execOk(`rm -r ${force}${shellQuote(abs)}`, `rmdir ${path}`);\n      return;\n    }\n    const result = await this.exec(`rmdir ${shellQuote(abs)}`);\n    if (result.exitCode !== 0 && !options?.force) {\n      throw new Error(`Directory not empty or not found: ${path}`);\n    }\n  }\n\n  async readdir(path: string, options?: ListOptions): Promise<FileEntry[]> {\n    const abs = this.resolve(path);\n    await this.assertContainedRealpath(abs, path);\n    if (options?.recursive) {\n      // Use find for recursive listings; emit \"type\\tpath\".\n      const result = await this.exec(\n        `find ${shellQuote(abs)} -mindepth 1 ${options.maxDepth ? `-maxdepth ${Number(options.maxDepth)} ` : ''}-printf '%y\\\\t%p\\\\n' 2>/dev/null`,\n      );\n      if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);\n      return this.parseFindOutput(result.stdout, abs, options);\n    }\n    // Non-recursive: list with name + type via a portable loop.\n    const result = await this.exec(\n      `cd ${shellQuote(abs)} 2>/dev/null && for f in * .[!.]*; do [ -e \"$f\" ] || continue; if [ -d \"$f\" ]; then echo \"d\\t$f\"; else echo \"f\\t$f\"; fi; done`,\n    );\n    if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);\n    return this.parseListOutput(result.stdout, options);\n  }\n\n  private parseListOutput(stdout: string, options?: ListOptions): FileEntry[] {\n    const entries: FileEntry[] = [];\n    for (const line of stdout.split('\\n')) {\n      if (!line) continue;\n      const tab = line.indexOf('\\t');\n      if (tab < 0) continue;\n      const type = line.slice(0, tab) === 'd' ? 'directory' : 'file';\n      const name = line.slice(tab + 1);\n      if (!name || name === '.' || name === '..') continue;\n      if (type === 'file' && !this.matchesExtension(name, options?.extension)) continue;\n      entries.push({ name, type });\n    }\n    return entries;\n  }\n\n  private parseFindOutput(stdout: string, base: string, options?: ListOptions): FileEntry[] {\n    const entries: FileEntry[] = [];\n    for (const line of stdout.split('\\n')) {\n      if (!line) continue;\n      const tab = line.indexOf('\\t');\n      if (tab < 0) continue;\n      const type = line.slice(0, tab) === 'd' ? 'directory' : 'file';\n      const fullPath = line.slice(tab + 1);\n      const name = posixPath.relative(base, fullPath);\n      if (!name) continue;\n      if (type === 'file' && !this.matchesExtension(name, options?.extension)) continue;\n      entries.push({ name, type });\n    }\n    return entries;\n  }\n\n  private matchesExtension(name: string, extension?: string | string[]): boolean {\n    if (!extension) return true;\n    const exts = Array.isArray(extension) ? extension : [extension];\n    return exts.some(ext => name.endsWith(ext));\n  }\n\n  // ── Path / metadata ────────────────────────────────────────────────────\n\n  async exists(path: string): Promise<boolean> {\n    const abs = this.resolve(path);\n    const result = await this.exec(`test -e ${shellQuote(abs)}`);\n    return result.exitCode === 0;\n  }\n\n  async stat(path: string): Promise<FileStat> {\n    const abs = this.resolve(path);\n    await this.assertContainedRealpath(abs, path);\n    // %F=type, %s=size, %X=atime, %Y=mtime (epoch seconds), %W=birth (or -1).\n    const result = await this.exec(`stat -c '%F\\\\t%s\\\\t%Y\\\\t%W' ${shellQuote(abs)}`);\n    if (result.exitCode !== 0) {\n      throw new Error(`Path not found: ${path}`);\n    }\n    const [kind, sizeStr, mtimeStr, ctimeStr] = result.stdout.trim().split('\\t');\n    const type = kind && kind.includes('directory') ? 'directory' : 'file';\n    const size = Number(sizeStr) || 0;\n    const mtime = Number(mtimeStr) || 0;\n    const ctime = Number(ctimeStr);\n    return {\n      name: posixPath.basename(abs),\n      path: `/${posixPath.relative(this.basePath, abs)}`,\n      type,\n      size: type === 'directory' ? 0 : size,\n      modifiedAt: new Date(mtime * 1000),\n      createdAt: new Date((ctime > 0 ? ctime : mtime) * 1000),\n    };\n  }\n\n  // ── Lifecycle ──────────────────────────────────────────────────────────\n\n  async init(): Promise<void> {\n    await this.execOk(`mkdir -p ${shellQuote(this.basePath)}`, 'init workdir');\n  }\n\n  async destroy(): Promise<void> {\n    // The sandbox lifecycle is owned by the caller; nothing to tear down here.\n  }\n\n  async isReady(): Promise<boolean> {\n    const result = await this.exec(`test -d ${shellQuote(this.basePath)}`);\n    return result.exitCode === 0;\n  }\n\n  getInfo(): FilesystemInfo {\n    return {\n      id: this.id,\n      name: this.name,\n      provider: this.provider,\n      metadata: { basePath: this.basePath, sandboxId: this.sandbox.id },\n    };\n  }\n\n  getInstructions(): string {\n    return `Files are stored in a remote sandbox at ${this.basePath}. Use absolute workspace paths like /src/index.ts. All reads, writes and commands run inside the same sandbox.`;\n  }\n}\n"],"mappings":"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","names":["result"]}