@axiom-lattice/core 3.0.1 → 3.0.2

package/dist/index.mjs

@@ -5905,12 +5905,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
+import { posix } from "path";
 function normalizeExternalSandboxPath(inputPath) {
   if (inputPath === "~" || inputPath === "~/") {
     return "/";
@@ -5923,6 +5937,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 = 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 ? posix.resolve(normalizedInput) : posix.resolve(root, `.${normalizedInput}`);
+  const relative4 = posix.relative(root, resolved);
+  if (relative4 === ".." || relative4.startsWith("../") || 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
 import { createHash } from "crypto";
@@ -5971,7 +6039,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) {
@@ -7431,15 +7500,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 (micromatch.isMatch(relative3, effectivePattern, {
+    if (micromatch.isMatch(relative4, effectivePattern, {
       dot: true,
       nobrace: false
     })) {
@@ -7593,9 +7662,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;
       }
@@ -7691,6 +7760,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.
    */
@@ -8078,12 +8158,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) {
@@ -8292,6 +8374,48 @@ function createEditFileTool(backend, options) {
     }
   );
 }
+function createDeleteFileTool(backend, options) {
+  const { customDescription } = options;
+  return tool38(
+    async (input, config) => {
+      const toolConfig = config;
+      const runConfig = toolConfig.configurable?.runConfig ?? {};
+      const stateAndStore = {
+        state: 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 ToolMessage({
+        content: `Successfully deleted '${file_path}'`,
+        tool_call_id: toolConfig.toolCall?.id ?? "",
+        name: "delete_file",
+        metadata: result.metadata
+      });
+      if (result.filesUpdate) {
+        return new Command({
+          update: { files: result.filesUpdate, messages: [message] }
+        });
+      }
+      return message;
+    },
+    {
+      name: "delete_file",
+      description: customDescription || DELETE_FILE_TOOL_DESCRIPTION,
+      schema: z310.object({
+        file_path: z310.string().describe("Absolute path to the file to delete")
+      })
+    }
+  );
+}
 function createGlobTool(backend, options) {
   const { customDescription } = options;
   return tool38(
@@ -8383,6 +8507,9 @@ function createFilesystemMiddleware(options = {}) {
     createEditFileTool(backend, {
       customDescription: customToolDescriptions?.edit_file
     }),
+    createDeleteFileTool(backend, {
+      customDescription: customToolDescriptions?.delete_file
+    }),
     createGlobTool(backend, {
       customDescription: customToolDescriptions?.glob
     }),
@@ -10962,6 +11089,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({
@@ -15651,9 +15791,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;
       }
@@ -15760,6 +15900,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.
    */
@@ -15852,8 +16008,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;
@@ -15867,6 +16023,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).
    *
@@ -16068,6 +16249,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.
@@ -16192,9 +16417,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;
@@ -16256,9 +16481,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;
@@ -16509,6 +16734,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.
    *
@@ -16541,9 +16774,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;
       }
@@ -16611,6 +16844,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);
@@ -23005,6 +23246,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({
@@ -23111,6 +23355,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",
@@ -23172,6 +23422,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(
@@ -23303,7 +23562,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) {
@@ -23326,6 +23588,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),
@@ -23503,6 +23766,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({
@@ -23549,6 +23828,9 @@ var RemoteSandboxInstance = class {
     }
     return `${this.workspace}${file}`;
   }
+  resolveDeletePath(file) {
+    return resolveWorkspacePath(this.workspace, file);
+  }
   async start() {
   }
   async stop() {
@@ -23668,6 +23950,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);
@@ -23684,6 +23979,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({
@@ -23802,6 +24115,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}"`);
       },
@@ -23925,6 +24252,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;
@@ -23985,6 +24316,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);
       },
@@ -24248,10 +24591,21 @@ import * as fs4 from "fs/promises";
 import { execFile } from "child_process";
 import * as fs3 from "fs/promises";
 import * as path5 from "path";
-import * as posix from "path/posix";
+import * as posix2 from "path/posix";
 import { promisify } from "util";
 var execFileAsync = promisify(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 = {
@@ -24275,7 +24629,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()
@@ -24292,7 +24646,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) => {
@@ -24335,6 +24689,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 });
       },
@@ -24411,7 +24797,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({