@axiom-lattice/core 3.0.1 → 3.0.2

package/dist/index.js

@@ -7762,12 +7762,26 @@ var VolumeFilesystem = class {
       return { error: String(err) };
     }
   }
+  /** Delete an existing regular file from the mounted volume. */
+  async delete(filePath) {
+    if (!this.client.delete) {
+      return { error: "Error: Backend does not support file deletion" };
+    }
+    try {
+      await this.client.delete(filePath);
+      return { path: filePath, filesUpdate: null };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Error deleting file '${filePath}': ${message}` };
+    }
+  }
   edit(_filePath, _oldString, _newString, _replaceAll) {
     throw new Error("Not supported on volume backend");
   }
 };
 
 // src/sandbox_lattice/pathUtils.ts
+var import_node_path = require("path");
 function normalizeExternalSandboxPath(inputPath) {
   if (inputPath === "~" || inputPath === "~/") {
     return "/";
@@ -7780,6 +7794,60 @@ function normalizeExternalSandboxPath(inputPath) {
   }
   return `/${inputPath}`;
 }
+function normalizeDeleteSandboxPath(inputPath) {
+  const normalized = normalizeExternalSandboxPath(inputPath);
+  if (normalized.split("/").includes("..")) {
+    throw new Error(`Path traversal denied: ${inputPath}`);
+  }
+  return normalized;
+}
+function resolveWorkspacePath(workspace, inputPath) {
+  const root = import_node_path.posix.resolve("/", workspace);
+  const normalizedInput = normalizeExternalSandboxPath(inputPath);
+  if (normalizedInput.split("/").includes("..")) {
+    throw new Error(`Path traversal denied: ${inputPath}`);
+  }
+  const alreadyInWorkspace = normalizedInput === root || normalizedInput.startsWith(`${root}/`);
+  const resolved = alreadyInWorkspace ? import_node_path.posix.resolve(normalizedInput) : import_node_path.posix.resolve(root, `.${normalizedInput}`);
+  const relative4 = import_node_path.posix.relative(root, resolved);
+  if (relative4 === ".." || relative4.startsWith("../") || import_node_path.posix.isAbsolute(relative4)) {
+    throw new Error(`Path traversal denied: ${inputPath}`);
+  }
+  return resolved;
+}
+function quotePosixShellArg(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function buildRegularFileGuard(filePath, successCommand, containmentRoot) {
+  const quotedPath = quotePosixShellArg(filePath);
+  const commands = [`target=${quotedPath};`];
+  if (containmentRoot !== void 0) {
+    commands.push(
+      `root=${quotePosixShellArg(containmentRoot)};`,
+      `root_real=$(CDPATH= cd -P "$root" 2>/dev/null && pwd -P) || { printf '%s\\n' 'containment root not found' >&2; exit 5; };`,
+      `case "$target" in /*) target_for_dir=$target ;; *) target_for_dir=./$target ;; esac;`,
+      `parent=$(dirname "$target_for_dir") || exit 5;`,
+      "base=${target_for_dir##*/};",
+      `parent_real=$(CDPATH= cd -P "$parent" 2>/dev/null && pwd -P) || { printf '%s\\n' 'file parent not found' >&2; exit 5; };`,
+      `case "$parent_real" in "$root_real"|"$root_real"/*) ;; *) printf '%s\\n' 'path outside containment root' >&2; exit 6 ;; esac;`,
+      `CDPATH= cd -P "$parent_real" 2>/dev/null || exit 5;`,
+      `target=./$base;`
+    );
+  }
+  commands.push(
+    `if [ -L "$target" ]; then printf '%s\\n' 'symlinks are not allowed' >&2; exit 2;`,
+    `elif [ ! -e "$target" ]; then printf '%s\\n' 'file not found' >&2; exit 3;`,
+    `elif [ ! -f "$target" ]; then printf '%s\\n' 'target is not a regular file' >&2; exit 4;`,
+    `else ${successCommand}; fi`
+  );
+  return commands.join(" ");
+}
+function buildAssertRegularFileCommand(filePath, containmentRoot) {
+  return buildRegularFileGuard(filePath, ":", containmentRoot);
+}
+function buildDeleteRegularFileCommand(filePath, containmentRoot) {
+  return buildRegularFileGuard(filePath, 'rm -- "$target"', containmentRoot);
+}
 
 // src/sandbox_lattice/utils.ts
 var import_node_crypto = require("crypto");
@@ -7828,7 +7896,8 @@ function stripPrefixClient(client, prefix) {
     write: (p, c) => client.write(strip(p), c),
     list: (p) => client.list(strip(p)),
     readRaw: (p) => client.readRaw(strip(p)),
-    writeRaw: (p, d) => client.writeRaw(strip(p), d)
+    writeRaw: (p, d) => client.writeRaw(strip(p), d),
+    ...client.delete ? { delete: (p) => client.delete(strip(p)) } : {}
   };
 }
 function computeSandboxName(config) {
@@ -9283,15 +9352,15 @@ function globSearchFiles(files, pattern, path8 = "/") {
   const effectivePattern = pattern;
   const matches = [];
   for (const [filePath, fileData] of Object.entries(filtered)) {
-    let relative3 = filePath.substring(normalizedPath.length);
-    if (relative3.startsWith("/")) {
-      relative3 = relative3.substring(1);
+    let relative4 = filePath.substring(normalizedPath.length);
+    if (relative4.startsWith("/")) {
+      relative4 = relative4.substring(1);
     }
-    if (!relative3) {
+    if (!relative4) {
       const parts = filePath.split("/");
-      relative3 = parts[parts.length - 1] || "";
+      relative4 = parts[parts.length - 1] || "";
     }
-    if (import_micromatch.default.isMatch(relative3, effectivePattern, {
+    if (import_micromatch.default.isMatch(relative4, effectivePattern, {
       dot: true,
       nobrace: false
     })) {
@@ -9445,9 +9514,9 @@ var StateBackend = class {
       if (!k.startsWith(normalizedPath)) {
         continue;
       }
-      const relative3 = k.substring(normalizedPath.length);
-      if (relative3.includes("/")) {
-        const subdirName = relative3.split("/")[0];
+      const relative4 = k.substring(normalizedPath.length);
+      if (relative4.includes("/")) {
+        const subdirName = relative4.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -9543,6 +9612,17 @@ var StateBackend = class {
       occurrences
     };
   }
+  /** Delete an existing file through a LangGraph state update. */
+  delete(filePath) {
+    const files = this.getFiles();
+    if (!files[filePath]) {
+      return { error: `Error: File '${filePath}' not found` };
+    }
+    return {
+      path: filePath,
+      filesUpdate: { [filePath]: null }
+    };
+  }
   /**
    * Structured search results or error string for invalid input.
    */
@@ -9933,12 +10013,14 @@ Path conventions:
 - read_file: read a file from the filesystem
 - write_file: write to a file in the filesystem
 - edit_file: edit a file in the filesystem
+- delete_file: permanently and irreversibly delete an existing regular file from the filesystem
 - glob: find files matching a pattern (e.g., "/project/**/*.py")
 - grep: search for text within files`;
 var LS_TOOL_DESCRIPTION = "List files and directories in a directory";
 var READ_FILE_TOOL_DESCRIPTION = "Read the contents of a file. For image files (png, jpg, gif, webp, bmp, svg), returns a visual description when the current model supports vision; otherwise returns an error suggesting a vision-capable model. For audio files (webm, wav, mp3, m4a, ogg, flac, aac, wma, opus, amr), transcribes the content using the default STT model; if none is registered, returns an error with registration instructions.";
 var WRITE_FILE_TOOL_DESCRIPTION = "Write content to a new file. Returns an error if the file already exists";
 var EDIT_FILE_TOOL_DESCRIPTION = "Edit a file by replacing a specific string with a new string";
+var DELETE_FILE_TOOL_DESCRIPTION = "Permanently and irreversibly delete an existing regular file. Directories and symbolic links are not allowed. If the target is ambiguous, use ask_user_to_clarify before deleting";
 var GLOB_TOOL_DESCRIPTION = "Find files matching a glob pattern (e.g., '**/*.py' for all Python files)";
 var GREP_TOOL_DESCRIPTION = "Search for a regex pattern in files. Returns matching files and line numbers";
 function createLsTool(backend, options) {
@@ -10147,6 +10229,48 @@ function createEditFileTool(backend, options) {
     }
   );
 }
+function createDeleteFileTool(backend, options) {
+  const { customDescription } = options;
+  return (0, import_langchain40.tool)(
+    async (input, config) => {
+      const toolConfig = config;
+      const runConfig = toolConfig.configurable?.runConfig ?? {};
+      const stateAndStore = {
+        state: (0, import_langgraph4.getCurrentTaskInput)(config),
+        store: toolConfig.store,
+        ...runConfig
+      };
+      const resolvedBackend = await getBackend(backend, stateAndStore);
+      const { file_path } = input;
+      if (!resolvedBackend.delete) {
+        return "Error: Backend does not support file deletion";
+      }
+      const result = await resolvedBackend.delete(file_path);
+      if (result.error) {
+        return result.error;
+      }
+      const message = new import_langchain40.ToolMessage({
+        content: `Successfully deleted '${file_path}'`,
+        tool_call_id: toolConfig.toolCall?.id ?? "",
+        name: "delete_file",
+        metadata: result.metadata
+      });
+      if (result.filesUpdate) {
+        return new import_langgraph4.Command({
+          update: { files: result.filesUpdate, messages: [message] }
+        });
+      }
+      return message;
+    },
+    {
+      name: "delete_file",
+      description: customDescription || DELETE_FILE_TOOL_DESCRIPTION,
+      schema: import_v3.z.object({
+        file_path: import_v3.z.string().describe("Absolute path to the file to delete")
+      })
+    }
+  );
+}
 function createGlobTool(backend, options) {
   const { customDescription } = options;
   return (0, import_langchain40.tool)(
@@ -10238,6 +10362,9 @@ function createFilesystemMiddleware(options = {}) {
     createEditFileTool(backend, {
       customDescription: customToolDescriptions?.edit_file
     }),
+    createDeleteFileTool(backend, {
+      customDescription: customToolDescriptions?.delete_file
+    }),
     createGlobTool(backend, {
       customDescription: customToolDescriptions?.glob
     }),
@@ -12817,6 +12944,19 @@ var SandboxFilesystem = class {
       return { error: `Error writing file '${filePath}': ${e.message}` };
     }
   }
+  /** Delete an existing regular file in the sandbox. */
+  async delete(filePath) {
+    if (!this.sandbox.file.deleteFile) {
+      return { error: "Error: Backend does not support file deletion" };
+    }
+    try {
+      await this.sandbox.file.deleteFile(filePath);
+      return { path: filePath, filesUpdate: null };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Error deleting file '${filePath}': ${message}` };
+    }
+  }
   async edit(filePath, oldString, newString, replaceAll = false) {
     try {
       await this.sandbox.file.strReplaceEditor({
@@ -17479,9 +17619,9 @@ var StoreBackend = class {
       if (!itemKey.startsWith(normalizedPath)) {
         continue;
       }
-      const relative3 = itemKey.substring(normalizedPath.length);
-      if (relative3.includes("/")) {
-        const subdirName = relative3.split("/")[0];
+      const relative4 = itemKey.substring(normalizedPath.length);
+      if (relative4.includes("/")) {
+        const subdirName = relative4.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -17588,6 +17728,22 @@ var StoreBackend = class {
       return { error: `Error: ${e.message}` };
     }
   }
+  /** Delete an existing persistent file. */
+  async delete(filePath) {
+    try {
+      const store = this.getStore();
+      const namespace = this.getNamespace();
+      const existing = await store.get(namespace, filePath);
+      if (!existing) {
+        return { error: `Error: File '${filePath}' not found` };
+      }
+      await store.delete(namespace, filePath);
+      return { path: filePath, filesUpdate: null };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Error deleting file '${filePath}': ${message}` };
+    }
+  }
   /**
    * Structured search results or error string for invalid input.
    */
@@ -17680,8 +17836,8 @@ var FilesystemBackend = class {
         throw new Error("Path traversal not allowed");
       }
       const full = path4.resolve(this.cwd, vpath.substring(1));
-      const relative3 = path4.relative(this.cwd, full);
-      if (relative3.startsWith("..") || path4.isAbsolute(relative3)) {
+      const relative4 = path4.relative(this.cwd, full);
+      if (relative4.startsWith("..") || path4.isAbsolute(relative4)) {
         throw new Error(`Path: ${full} outside root directory: ${this.cwd}`);
       }
       return full;
@@ -17695,6 +17851,31 @@ var FilesystemBackend = class {
     }
     return path4.resolve(this.cwd, target);
   }
+  async assertVirtualParentContained(resolvedPath) {
+    if (!this.virtualMode) {
+      return;
+    }
+    const [rootPath, parentPath] = await Promise.all([
+      fs2.realpath(this.cwd),
+      fs2.realpath(path4.dirname(resolvedPath))
+    ]);
+    const relative4 = path4.relative(rootPath, parentPath);
+    if (relative4 === ".." || relative4.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative4)) {
+      throw new Error(`Path: ${resolvedPath} outside root directory: ${this.cwd}`);
+    }
+  }
+  validateDeleteTarget(filePath, stat4) {
+    if (stat4.isSymbolicLink()) {
+      return `Error: Cannot delete '${filePath}': symlinks are not allowed`;
+    }
+    if (stat4.isDirectory()) {
+      return `Error: Cannot delete '${filePath}': target is a directory`;
+    }
+    if (!stat4.isFile()) {
+      return `Error: Cannot delete '${filePath}': target is not a regular file`;
+    }
+    return void 0;
+  }
   /**
    * List files and directories in the specified directory (non-recursive).
    *
@@ -17896,6 +18077,50 @@ var FilesystemBackend = class {
       return { error: `Error writing file '${filePath}': ${e.message}` };
     }
   }
+  /** Delete an existing regular file without following symbolic links. */
+  async delete(filePath) {
+    let resolvedPath;
+    try {
+      resolvedPath = this.resolvePath(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Error deleting file '${filePath}': ${message}` };
+    }
+    let stat4;
+    try {
+      stat4 = await fs2.lstat(resolvedPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { error: `Error: File '${filePath}' not found` };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Error deleting file '${filePath}': ${message}` };
+    }
+    const validationError = this.validateDeleteTarget(filePath, stat4);
+    if (validationError) {
+      return { error: validationError };
+    }
+    try {
+      await this.assertVirtualParentContained(resolvedPath);
+      const currentStat = await fs2.lstat(resolvedPath);
+      const currentValidationError = this.validateDeleteTarget(filePath, currentStat);
+      if (currentValidationError) {
+        return { error: currentValidationError };
+      }
+      if (currentStat.dev !== stat4.dev || currentStat.ino !== stat4.ino) {
+        return { error: `Error: Cannot delete '${filePath}': target changed during deletion` };
+      }
+      await this.assertVirtualParentContained(resolvedPath);
+      await fs2.unlink(resolvedPath);
+      return { path: filePath, filesUpdate: null };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { error: `Error: File '${filePath}' not found` };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Error deleting file '${filePath}': ${message}` };
+    }
+  }
   /**
    * Edit a file by replacing string occurrences.
    * Returns EditResult. External storage sets filesUpdate=null.
@@ -18020,9 +18245,9 @@ var FilesystemBackend = class {
             if (this.virtualMode) {
               try {
                 const resolved = path4.resolve(ftext);
-                const relative3 = path4.relative(this.cwd, resolved);
-                if (relative3.startsWith("..")) continue;
-                const normalizedRelative = relative3.split(path4.sep).join("/");
+                const relative4 = path4.relative(this.cwd, resolved);
+                if (relative4.startsWith("..")) continue;
+                const normalizedRelative = relative4.split(path4.sep).join("/");
                 virtPath = "/" + normalizedRelative;
               } catch {
                 continue;
@@ -18084,9 +18309,9 @@ var FilesystemBackend = class {
             let virtPath;
             if (this.virtualMode) {
               try {
-                const relative3 = path4.relative(this.cwd, fp);
-                if (relative3.startsWith("..")) continue;
-                const normalizedRelative = relative3.split(path4.sep).join("/");
+                const relative4 = path4.relative(this.cwd, fp);
+                if (relative4.startsWith("..")) continue;
+                const normalizedRelative = relative4.split(path4.sep).join("/");
                 virtPath = "/" + normalizedRelative;
               } catch {
                 continue;
@@ -18337,6 +18562,14 @@ var CompositeBackend = class {
     const [backend, strippedKey] = this.getBackendAndKey(filePath);
     return await backend.write(strippedKey, content);
   }
+  /** Delete a file, routing to the same backend selected for write and edit. */
+  async delete(filePath) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    if (!backend.delete) {
+      return { error: "Error: Backend does not support file deletion" };
+    }
+    return await backend.delete(strippedKey);
+  }
   /**
    * Edit a file, routing to appropriate backend.
    *
@@ -18369,9 +18602,9 @@ var MemoryBackend = class {
       if (!k.startsWith(normalizedPath)) {
         continue;
       }
-      const relative3 = k.substring(normalizedPath.length);
-      if (relative3.includes("/")) {
-        const subdirName = relative3.split("/")[0];
+      const relative4 = k.substring(normalizedPath.length);
+      if (relative4.includes("/")) {
+        const subdirName = relative4.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -18439,6 +18672,14 @@ var MemoryBackend = class {
     this.files.set(filePath, newFileData);
     return { path: filePath, filesUpdate: null, occurrences };
   }
+  /** Delete an existing in-memory file. */
+  delete(filePath) {
+    if (!this.files.has(filePath)) {
+      return { error: `Error: File '${filePath}' not found` };
+    }
+    this.files.delete(filePath);
+    return { path: filePath, filesUpdate: null };
+  }
   grepRaw(pattern, path8 = "/", glob = null) {
     const files = this.getFiles();
     return grepMatchesFromFiles(files, pattern, path8, glob);
@@ -24848,6 +25089,9 @@ var MicrosandboxRemoteInstance = class {
         }
         return Buffer.from(result.content ?? "");
       },
+      deleteFile: async (file) => {
+        await this.client.deleteFile(this.name, normalizeExternalSandboxPath(file));
+      },
       deletePath: async (path8) => {
         const resolved = normalizeExternalSandboxPath(path8);
         await this.client.execCommand({
@@ -24954,6 +25198,12 @@ var MicrosandboxServiceClient = class {
       body: { sandboxName, path: path8, content }
     });
   }
+  async deleteFile(sandboxName, path8) {
+    return this.request("/api/files/delete", {
+      method: "POST",
+      body: { sandboxName, path: path8 }
+    });
+  }
   async listPath(sandboxName, path8, recursive) {
     return this.request("/api/files/list", {
       method: "POST",
@@ -25015,6 +25265,15 @@ var MicrosandboxServiceClient = class {
       }
     );
   }
+  async volumeFsDelete(volumeName, path8) {
+    await this.request(
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/delete`,
+      {
+        method: "POST",
+        body: { path: path8 }
+      }
+    );
+  }
   async volumeFsList(volumeName, path8) {
     console.log(`[volumeFsList] volume=${volumeName} path="${path8}" url=POST /api/volumes/${encodeURIComponent(volumeName)}/fs/list`);
     const result = await this.request(
@@ -25146,7 +25405,10 @@ var MicrosandboxRemoteProvider = class {
       return new MicrosandboxRemoteInstance(name, this.client);
     })();
     this.creating.set(name, creation);
-    creation.finally(() => this.creating.delete(name));
+    creation.then(
+      () => this.creating.delete(name),
+      () => this.creating.delete(name)
+    );
     return creation;
   }
   async getSandbox(name) {
@@ -25169,6 +25431,7 @@ var MicrosandboxRemoteProvider = class {
     return {
       read: (path8) => this.client.volumeFsRead(volumeName, path8),
       write: (path8, content) => this.client.volumeFsWrite(volumeName, path8, content),
+      delete: (path8) => this.client.volumeFsDelete(volumeName, path8),
       list: (path8) => this.client.volumeFsList(volumeName, path8),
       readRaw: (path8) => this.client.volumeFsDownload(volumeName, path8),
       writeRaw: (path8, data) => this.client.volumeFsUpload(volumeName, path8, data),
@@ -25346,6 +25609,22 @@ var RemoteSandboxInstance = class {
         const buffer2 = await result.body.arrayBuffer();
         return Buffer.from(buffer2);
       },
+      deleteFile: async (file) => {
+        const resolved = this.resolveDeletePath(file);
+        const result = await this.client.shell.execCommand({
+          command: buildDeleteRegularFileCommand(
+            resolved,
+            resolveWorkspacePath(this.workspace, "/")
+          )
+        });
+        if (!result.ok) {
+          throw new Error(`deleteFile failed: ${extractFetcherError(result.error)}`);
+        }
+        const exitCode = result.body.data?.exit_code ?? 0;
+        if (exitCode !== 0) {
+          throw new Error(`deleteFile failed: ${result.body.data?.output ?? `exit code ${exitCode}`}`);
+        }
+      },
       deletePath: async (path8) => {
         const resolved = this.resolvePath(path8);
         const result = await this.client.shell.execCommand({
@@ -25392,6 +25671,9 @@ var RemoteSandboxInstance = class {
     }
     return `${this.workspace}${file}`;
   }
+  resolveDeletePath(file) {
+    return resolveWorkspacePath(this.workspace, file);
+  }
   async start() {
   }
   async stop() {
@@ -25511,6 +25793,19 @@ var RemoteSandboxProvider = class {
       }
       return `${workspace}/${p}`;
     };
+    const resolveDelete = (p) => {
+      if (!p || p === "/") {
+        return resolveWorkspacePath(workspace, pathPrefix ?? "/");
+      }
+      if (p === workspace || p.startsWith(`${workspace}/`)) {
+        return resolveWorkspacePath(workspace, p);
+      }
+      if (p.startsWith("/")) {
+        return resolveWorkspacePath(workspace, p);
+      }
+      const prefixed = pathPrefix ? `/${pathPrefix.replace(/^\//, "")}/${p}` : p;
+      return resolveWorkspacePath(workspace, prefixed);
+    };
     return {
       read: async (path8) => {
         const resolved = resolve4(path8);
@@ -25527,6 +25822,24 @@ var RemoteSandboxProvider = class {
           throw new Error(`Volume write failed: ${extractFetcherError(result.error)}`);
         }
       },
+      delete: async (path8) => {
+        const resolved = resolveDelete(path8);
+        const result = await this.client.shell.execCommand({
+          command: buildDeleteRegularFileCommand(
+            resolved,
+            resolveWorkspacePath(workspace, "/")
+          )
+        });
+        if (!result.ok) {
+          throw new Error(`Volume delete failed: ${extractFetcherError(result.error)}`);
+        }
+        const exitCode = result.body.data?.exit_code ?? 0;
+        if (exitCode !== 0) {
+          throw new Error(
+            `Volume delete failed: ${result.body.data?.output ?? `exit code ${exitCode}`}`
+          );
+        }
+      },
       mkdir: async (path8) => {
         const resolved = resolve4(path8);
         const result = await this.client.shell.execCommand({
@@ -25645,6 +25958,20 @@ var E2BInstance = class {
         const data = await this.native.files.read(params.file, { format: "bytes" });
         return Buffer.isBuffer(data) ? data : Buffer.from(data);
       },
+      deleteFile: async (file) => {
+        const deletePath = normalizeDeleteSandboxPath(file);
+        const info = await this.native.files.getInfo(deletePath);
+        if (info.symlinkTarget) {
+          throw new Error(`Cannot delete '${file}': symlinks are not allowed`);
+        }
+        if (info.type === "dir") {
+          throw new Error(`Cannot delete '${file}': target is a directory`);
+        }
+        if (info.type !== "file") {
+          throw new Error(`Cannot delete '${file}': target is not a regular file`);
+        }
+        await this.native.files.remove(deletePath);
+      },
       deletePath: async (path8) => {
         await this.native.commands.run(`rm -rf "${path8}"`);
       },
@@ -25768,6 +26095,10 @@ function toRelativePath(inputPath) {
   const normalized = normalizeExternalSandboxPath(inputPath);
   return normalized === "/" ? "" : normalized.slice(1);
 }
+function toDeleteRelativePath(inputPath) {
+  const normalized = normalizeDeleteSandboxPath(inputPath);
+  return normalized === "/" ? "" : normalized.slice(1);
+}
 var DaytonaInstance = class {
   constructor(name, native) {
     this.native = native;
@@ -25828,6 +26159,18 @@ var DaytonaInstance = class {
         const buffer2 = await this.native.fs.downloadFile(toRelativePath(params.file));
         return Buffer.isBuffer(buffer2) ? buffer2 : Buffer.from(buffer2);
       },
+      deleteFile: async (file) => {
+        const relativePath = toDeleteRelativePath(file);
+        const check = await this.native.process.executeCommand(
+          buildAssertRegularFileCommand(relativePath, "."),
+          void 0,
+          void 0
+        );
+        if (check.exitCode !== 0) {
+          throw new Error(check.result || `Cannot delete '${file}': target is not a regular file`);
+        }
+        await this.native.fs.deleteFile(relativePath, false);
+      },
       deletePath: async (path8) => {
         await this.native.process.executeCommand(`rm -rf "${toRelativePath(path8)}"`, void 0, void 0);
       },
@@ -26091,10 +26434,21 @@ var fs4 = __toESM(require("fs/promises"));
 var import_node_child_process = require("child_process");
 var fs3 = __toESM(require("fs/promises"));
 var path5 = __toESM(require("path"));
-var posix = __toESM(require("path/posix"));
+var posix2 = __toESM(require("path/posix"));
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var isWin = process.platform === "win32";
+function assertRegularDeleteTarget(file, stat4) {
+  if (stat4.isSymbolicLink()) {
+    throw new Error(`Cannot delete '${file}': symlinks are not allowed`);
+  }
+  if (stat4.isDirectory()) {
+    throw new Error(`Cannot delete '${file}': target is a directory`);
+  }
+  if (!stat4.isFile()) {
+    throw new Error(`Cannot delete '${file}': target is not a regular file`);
+  }
+}
 var LocalSandboxInstance = class {
   constructor(name, rootDir) {
     this.file = {
@@ -26118,7 +26472,7 @@ var LocalSandboxInstance = class {
             const full = path5.join(hp, e.name);
             const stat4 = await fs3.stat(full).catch(() => null);
             files.push({
-              path: posix.join(targetPath, e.name),
+              path: posix2.join(targetPath, e.name),
               is_dir: e.isDirectory(),
               size: stat4?.size ?? 0,
               modified_at: stat4?.mtime.toISOString()
@@ -26135,7 +26489,7 @@ var LocalSandboxInstance = class {
         );
         await this.walkDirFilter(hp, regex, results);
         const hpNorm = hp + path5.sep;
-        const toSandboxPath = (hostPath) => posix.join(targetPath, hostPath.slice(hpNorm.length).split(path5.sep).join("/"));
+        const toSandboxPath = (hostPath) => posix2.join(targetPath, hostPath.slice(hpNorm.length).split(path5.sep).join("/"));
         return { files: results.map(toSandboxPath) };
       },
       searchInFile: async (file, regex) => {
@@ -26178,6 +26532,38 @@ var LocalSandboxInstance = class {
         const data = await fs3.readFile(this.hostPath(params.file));
         return data;
       },
+      deleteFile: async (file) => {
+        const hp = this.hostPath(file);
+        let stat4;
+        try {
+          stat4 = await fs3.lstat(hp);
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            throw new Error(`File '${file}' not found`);
+          }
+          throw error;
+        }
+        assertRegularDeleteTarget(file, stat4);
+        const [rootPath, parentPath] = await Promise.all([
+          fs3.realpath(this.rootDir),
+          fs3.realpath(path5.dirname(hp))
+        ]);
+        const relativeParent = path5.relative(rootPath, parentPath);
+        if (relativeParent === ".." || relativeParent.startsWith(`..${path5.sep}`) || path5.isAbsolute(relativeParent)) {
+          throw new Error(`Path traversal denied: ${file}`);
+        }
+        const currentStat = await fs3.lstat(hp);
+        assertRegularDeleteTarget(file, currentStat);
+        if (currentStat.dev !== stat4.dev || currentStat.ino !== stat4.ino) {
+          throw new Error(`Cannot delete '${file}': target changed during deletion`);
+        }
+        const currentParentPath = await fs3.realpath(path5.dirname(hp));
+        const currentRelativeParent = path5.relative(rootPath, currentParentPath);
+        if (currentRelativeParent === ".." || currentRelativeParent.startsWith(`..${path5.sep}`) || path5.isAbsolute(currentRelativeParent)) {
+          throw new Error(`Path traversal denied: ${file}`);
+        }
+        await fs3.unlink(hp);
+      },
       deletePath: async (targetPath) => {
         await fs3.rm(this.hostPath(targetPath), { recursive: true, force: true });
       },
@@ -26254,7 +26640,7 @@ ${errOut}`.trim() : out.trim();
       }
       for (const e of entries) {
         const fullHost = path5.join(hostDir, e.name);
-        const fullSandbox = posix.join(sandboxDir, e.name);
+        const fullSandbox = posix2.join(sandboxDir, e.name);
         try {
           const stat4 = await fs3.stat(fullHost);
           result.push({