@axiom-lattice/microsandbox-service 0.0.51 → 0.0.53

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @axiom-lattice/microsandbox-service
 
+## 0.0.53
+
+### Patch Changes
+
+- e2f0a28: Add native `delete_file` support across filesystem backends, sandbox transports, and React middleware metadata.
+
+## 0.0.52
+
+### Patch Changes
+
+- 18749ee: fix sandbox issue
+
 ## 0.0.51
 
 ### Patch Changes

package/dist/{chunk-IKWYDXRG.mjs → chunk-TRJCQNF4.mjs}

@@ -6,6 +6,9 @@ var DEFAULT_IMAGE = process.env.MICROSANDBOX_IMAGE ?? "daytonaio/sandbox:0.6.0";
 var DEFAULT_IDLE_TIMEOUT_MS = Number(process.env.MICROSANDBOX_IDLE_TIMEOUT_MS) || 6e5;
 var DEFAULT_REMOVE_AFTER_PAUSED_MS = 7 * 24 * 60 * 60 * 1e3;
 var SWEEP_INTERVAL_MS = 3e4;
+var SWEEP_STOP_TIMEOUT_MS = 6e4;
+var HEALTH_CHECK_TIMEOUT_MS = 2e3;
+var HEALTH_CHECK_INTERVAL_MS = 3e4;
 var SANDBOX_AGENT_SOCKET_DIR = "/root/.microsandbox/run/agent";
 function extractConfig(configJson) {
   try {
@@ -37,6 +40,7 @@ var SandboxRegistry = class {
   constructor(idleTimeoutMs) {
     this.handles = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
+    this.stopping = /* @__PURE__ */ new Set();
     this.idleTimeoutMs = idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
     this.cleanupOrphanedSockets();
     if (this.idleTimeoutMs > 0) {
@@ -48,14 +52,22 @@ var SandboxRegistry = class {
       const now = Date.now();
       for (const [name, entry] of this.handles) {
         if (entry.native && now - entry.lastAccessedAt > this.idleTimeoutMs) {
+          if (this.stopping.has(name)) {
+            continue;
+          }
           console.log(`[SandboxRegistry] sweeper pausing idle sandbox name=${name} idleMs=${now - entry.lastAccessedAt}`);
-          void entry.native.stop().then(() => {
+          this.stopping.add(name);
+          void Promise.race([
+            entry.native.stop(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("stop timed out")), SWEEP_STOP_TIMEOUT_MS))
+          ]).then(() => {
             console.log(`[SandboxRegistry] sweeper paused name=${name}`);
           }).catch((err) => {
             console.log(`[SandboxRegistry] sweeper pause failed name=${name} err=${err.message}`);
           }).finally(() => {
             entry.native = null;
             entry.pausedAt = Date.now();
+            this.stopping.delete(name);
           });
         } else if (!entry.native && entry.pausedAt && now - entry.pausedAt > DEFAULT_REMOVE_AFTER_PAUSED_MS) {
           console.log(`[SandboxRegistry] sweeper removing paused sandbox name=${name} pausedMs=${now - entry.pausedAt}`);
@@ -104,15 +116,30 @@ var SandboxRegistry = class {
     }
   }
   async removeAndDelete(name) {
-    const handle = await Sandbox.get(name);
-    if (handle.status === "running") {
-      try {
-        const native = await handle.connect();
-        await native.stop();
-      } catch {
+    try {
+      const handle = await Promise.race([
+        Sandbox.get(name),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Sandbox.get timed out")), SWEEP_STOP_TIMEOUT_MS))
+      ]);
+      if (handle.status === "running") {
+        try {
+          const native = await Promise.race([
+            handle.connect(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("handle.connect timed out")), SWEEP_STOP_TIMEOUT_MS))
+          ]);
+          await Promise.race([
+            native.stop(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("stop timed out")), SWEEP_STOP_TIMEOUT_MS))
+          ]);
+        } catch {
+        }
       }
+      await Promise.race([
+        Sandbox.remove(name),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Sandbox.remove timed out")), SWEEP_STOP_TIMEOUT_MS))
+      ]);
+    } catch {
     }
-    await Sandbox.remove(name);
     this.remove(name);
     this.cleanupOrphanedSockets();
   }
@@ -133,11 +160,26 @@ var SandboxRegistry = class {
     entry.native = null;
     entry.pausedAt = Date.now();
   }
+  async healthCheck(native) {
+    const fs2 = native.fs();
+    try {
+      await Promise.race([
+        fs2.list("/"),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("health check timed out")), HEALTH_CHECK_TIMEOUT_MS))
+      ]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   async waitForFs(native, maxRetries = 10) {
     const fs2 = native.fs();
     for (let i = 0; i < maxRetries; i++) {
       try {
-        await fs2.list("/");
+        await Promise.race([
+          fs2.list("/"),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("FS check timed out")), 5e3))
+        ]);
         return;
       } catch {
         await new Promise((r) => setTimeout(r, 200));
@@ -150,9 +192,10 @@ var SandboxRegistry = class {
     const requestEnv = createOptions.env;
     if (volumeDefs && Object.keys(volumeDefs).length > 0) {
       const existingGuests = new Set((originalConfig?.mounts ?? []).map((m) => m.guest));
-      const requestedGuests = new Set(Object.keys(volumeDefs));
-      if (existingGuests.size !== requestedGuests.size || ![...requestedGuests].every((g) => existingGuests.has(g))) {
-        console.log(`[SandboxRegistry] volumes mismatch, recreating...`);
+      const requestedGuests = Object.keys(volumeDefs);
+      const missing = requestedGuests.filter((g) => !existingGuests.has(g));
+      if (missing.length > 0) {
+        console.log(`[SandboxRegistry] volumes mismatch, missing=${missing.join(",")}, recreating...`);
         return true;
       }
     }
@@ -169,10 +212,29 @@ var SandboxRegistry = class {
   async ensure(name, createOptions) {
     const tStart = Date.now();
     const cached = this.handles.get(name);
-    if (cached?.native) {
-      cached.lastAccessedAt = Date.now();
-      console.log(`[SandboxRegistry] ensure name=${name} CACHE_HIT elapsed=${Date.now() - tStart}ms`);
-      return cached.native;
+    if (cached?.native && !this.stopping.has(name)) {
+      const now = Date.now();
+      if (!cached.lastCheckedAt || now - cached.lastCheckedAt > HEALTH_CHECK_INTERVAL_MS) {
+        const tCheck = Date.now();
+        const ok2 = await this.healthCheck(cached.native);
+        cached.lastCheckedAt = now;
+        if (ok2) {
+          cached.lastAccessedAt = now;
+          console.log(`[SandboxRegistry] ensure name=${name} CACHE_HIT elapsed=${Date.now() - tStart}ms health_ok elapsed=${Date.now() - tCheck}ms`);
+          return cached.native;
+        }
+        console.log(`[SandboxRegistry] ensure name=${name} HEALTH_FAIL will_recreate elapsed=${Date.now() - tStart}ms`);
+        cached.native = null;
+        cached.broken = true;
+      } else {
+        cached.lastAccessedAt = now;
+        console.log(`[SandboxRegistry] ensure name=${name} CACHE_HIT elapsed=${Date.now() - tStart}ms`);
+        return cached.native;
+      }
+    }
+    if (cached?.native && this.stopping.has(name)) {
+      console.log(`[SandboxRegistry] ensure name=${name} STALE_NATIVE (being stopped), forcing revive`);
+      cached.native = null;
     }
     if (cached && !cached.native) {
       cached.pausedAt = void 0;
@@ -191,44 +253,62 @@ var SandboxRegistry = class {
       const memoryMib = createOptions?.memoryMib ?? 512;
       const env = createOptions?.env ?? void 0;
       let originalConfig;
-      try {
-        const tGet = Date.now();
-        const handle = await Sandbox.get(name);
-        console.log(`[SandboxRegistry] Sandbox.get name=${name} status=${handle.status} elapsed=${Date.now() - tGet}ms`);
-        originalConfig = extractConfig(handle.configJson);
-        if (handle.status === "running" || handle.status === "stopped") {
-          const isNewConnection = !cached;
-          if (isNewConnection && createOptions && this.hasConfigMismatch(originalConfig, createOptions)) {
-            await this.removeAndDelete(name);
-            native = void 0;
-          } else if (handle.status === "running") {
-            const tConnect = Date.now();
-            native = await handle.connect();
-            console.log(`[SandboxRegistry] handle.connect name=${name} elapsed=${Date.now() - tConnect}ms`);
-            const tFs = Date.now();
-            await this.waitForFs(native);
-            console.log(`[SandboxRegistry] waitForFs name=${name} elapsed=${Date.now() - tFs}ms`);
-          } else {
-            try {
-              const tStart2 = Date.now();
-              native = await Sandbox.startDetached(name);
-              console.log(`[SandboxRegistry] startDetached name=${name} elapsed=${Date.now() - tStart2}ms`);
+      const existing = this.handles.get(name);
+      if (existing?.broken) {
+        console.log(`[SandboxRegistry] ensure name=${name} BROKEN removing before recreate`);
+        await this.removeAndDelete(name);
+        this.handles.set(name, { native: null, lastAccessedAt: Date.now(), createOptions: existing.createOptions ?? cached?.createOptions });
+      } else {
+        try {
+          const tGet = Date.now();
+          const handle = await Sandbox.get(name);
+          console.log(`[SandboxRegistry] Sandbox.get name=${name} status=${handle.status} elapsed=${Date.now() - tGet}ms`);
+          originalConfig = extractConfig(handle.configJson);
+          if (handle.status === "running" || handle.status === "stopped") {
+            const isNewConnection = !cached;
+            if (isNewConnection && createOptions && this.hasConfigMismatch(originalConfig, createOptions)) {
+              await this.removeAndDelete(name);
+              native = void 0;
+            } else if (handle.status === "running") {
+              const tConnect = Date.now();
+              native = await Promise.race([
+                handle.connect(),
+                new Promise(
+                  (_, reject) => setTimeout(() => reject(new Error("handle.connect timed out")), SWEEP_STOP_TIMEOUT_MS)
+                )
+              ]);
+              console.log(`[SandboxRegistry] handle.connect name=${name} elapsed=${Date.now() - tConnect}ms`);
               const tFs = Date.now();
               await this.waitForFs(native);
               console.log(`[SandboxRegistry] waitForFs name=${name} elapsed=${Date.now() - tFs}ms`);
-            } catch {
-              if (!native) {
-                await this.removeAndDelete(name);
+            } else {
+              try {
+                const tStart2 = Date.now();
+                native = await Promise.race([
+                  Sandbox.startDetached(name),
+                  new Promise(
+                    (_, reject) => setTimeout(() => reject(new Error("startDetached timed out")), SWEEP_STOP_TIMEOUT_MS)
+                  )
+                ]);
+                console.log(`[SandboxRegistry] startDetached name=${name} elapsed=${Date.now() - tStart2}ms`);
+                const tFs = Date.now();
+                await this.waitForFs(native);
+                console.log(`[SandboxRegistry] waitForFs name=${name} elapsed=${Date.now() - tFs}ms`);
+              } catch {
+                if (!native) {
+                  await this.removeAndDelete(name);
+                }
               }
             }
+          } else if (handle.status === "crashed" || handle.status === "draining") {
+            await this.removeAndDelete(name);
+          } else {
+            await this.removeAndDelete(name);
           }
-        } else if (handle.status === "crashed" || handle.status === "draining") {
-          await this.removeAndDelete(name);
-        } else {
-          await this.removeAndDelete(name);
+        } catch (err) {
+          console.log(`[SandboxRegistry] ensure name=${name} existing_check failed err=${err.message}`);
+          native = void 0;
         }
-      } catch {
-        native = void 0;
       }
       console.log(`[SandboxRegistry] phase=existing_check name=${name} hasNative=${!!native} elapsed=${Date.now() - tCreate}ms`);
       if (!native) {
@@ -294,7 +374,12 @@ var SandboxRegistry = class {
           }
           applyVolumes(builder);
           const tCreateInner = Date.now();
-          const result = await builder.create();
+          const result = await Promise.race([
+            builder.create(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("builder.create timed out")), SWEEP_STOP_TIMEOUT_MS)
+            )
+          ]);
           console.log(
             `[SandboxRegistry] builder.create name=${name} image=${resolvedImage} elapsed=${Date.now() - tCreateInner}ms envKeys=${resolvedEnv ? Object.keys(resolvedEnv).join(",") : "none"} volumes=${volumeDefs ? Object.keys(volumeDefs).join(",") : "none"}`
           );
@@ -316,7 +401,13 @@ var SandboxRegistry = class {
         console.log(`[SandboxRegistry] waitForFs name=${name} elapsed=${Date.now() - tFs}ms`);
       }
       const totalElapsed = Date.now() - tStart;
-      this.handles.set(name, { native, lastAccessedAt: Date.now(), createOptions: createOptions ?? cached?.createOptions });
+      const entry = {
+        native,
+        lastAccessedAt: Date.now(),
+        lastCheckedAt: Date.now(),
+        createOptions: createOptions ?? cached?.createOptions
+      };
+      this.handles.set(name, entry);
       console.log(`[SandboxRegistry] ensure DONE name=${name} total=${totalElapsed}ms idleTimeout=${Math.round(this.idleTimeoutMs / 1e3)}s`);
       return native;
     })();
@@ -418,6 +509,24 @@ function parseMsbInspectEnvVolumes(stdout) {
   }
   return { env, volumes };
 }
+function isFileNotFoundError(error) {
+  if (typeof error === "string") {
+    const message2 = error.toLowerCase();
+    return message2.includes("not found") || message2.includes("no such file");
+  }
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  if (candidate.code === "ENOENT") {
+    return true;
+  }
+  if (typeof candidate.message !== "string") {
+    return false;
+  }
+  const message = candidate.message.toLowerCase();
+  return message.includes("not found") || message.includes("no such file");
+}
 var MicrosandboxRuntimeService = class {
   constructor(deps = {}) {
     this.deps = deps;
@@ -434,6 +543,13 @@ var MicrosandboxRuntimeService = class {
     }
     return path2;
   }
+  resolveDeletePath(path2) {
+    const resolvedPath = this.resolvePath(path2);
+    if (resolvedPath.replace(/\\/g, "/").split("/").includes("..")) {
+      throw new HttpError(403, "PATH_TRAVERSAL", `Path traversal denied: ${path2}`);
+    }
+    return resolvedPath;
+  }
   toListItem(info) {
     const config = parseConfigJson(info.configJson);
     const env = config.env ? Array.isArray(config.env) ? config.env : config.env : [];
@@ -639,6 +755,40 @@ var MicrosandboxRuntimeService = class {
     await native.fs().write(resolvedPath, Buffer.from(content));
     return { path: resolvedPath };
   }
+  async deleteFile(sandboxName, path2) {
+    const resolvedPath = this.resolveDeletePath(path2);
+    const native = await this.getOrEnsureNative(sandboxName);
+    const sandboxFs = native.fs();
+    let metadata;
+    try {
+      metadata = await sandboxFs.stat(resolvedPath);
+    } catch (error) {
+      if (isFileNotFoundError(error)) {
+        throw new HttpError(404, "FILE_NOT_FOUND", `File '${path2}' not found`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new HttpError(500, "FILE_STAT_ERROR", `Failed to inspect '${path2}': ${message}`);
+    }
+    if (metadata.kind === "symlink") {
+      throw new HttpError(400, "FILE_NOT_REGULAR", `Cannot delete '${path2}': symlinks are not allowed`);
+    }
+    if (metadata.kind === "directory") {
+      throw new HttpError(400, "FILE_NOT_REGULAR", `Cannot delete '${path2}': target is a directory`);
+    }
+    if (metadata.kind !== "file") {
+      throw new HttpError(400, "FILE_NOT_REGULAR", `Cannot delete '${path2}': target is not a regular file`);
+    }
+    try {
+      await sandboxFs.remove(resolvedPath);
+    } catch (error) {
+      if (isFileNotFoundError(error)) {
+        throw new HttpError(404, "FILE_NOT_FOUND", `File '${path2}' not found`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new HttpError(500, "FILE_DELETE_ERROR", `Failed to delete '${path2}': ${message}`);
+    }
+    return { path: resolvedPath };
+  }
   async listPath(sandboxName, path2, recursive) {
     const resolvedPath = this.resolvePath(path2);
     const native = await this.getOrEnsureNative(sandboxName);
@@ -862,6 +1012,7 @@ var readFileSchema = sandboxAndPathSchema;
 var writeFileSchema = sandboxAndPathSchema.extend({
   content: z2.string()
 });
+var deleteFileSchema = sandboxAndPathSchema;
 var listPathSchema = sandboxAndPathSchema.extend({
   recursive: z2.boolean().optional()
 });
@@ -942,6 +1093,13 @@ function createSandboxController(runtimeService) {
       const body = writeFileSchema.parse(request.body ?? {});
       return reply.send(ok(await runtimeService.writeFile(body.sandboxName, body.path, body.content)));
     },
+    deleteFile: async (request, reply) => {
+      const parsed = deleteFileSchema.safeParse(request.body ?? {});
+      if (!parsed.success) {
+        throw new HttpError(400, "VALIDATION_ERROR", parsed.error.message);
+      }
+      return reply.send(ok(await runtimeService.deleteFile(parsed.data.sandboxName, parsed.data.path)));
+    },
     listPath: async (request, reply) => {
       const body = listPathSchema.parse(request.body ?? {});
       return reply.send(ok(await runtimeService.listPath(body.sandboxName, body.path, body.recursive)));
@@ -996,6 +1154,7 @@ function registerSandboxRoutes(app, runtimeService) {
   app.post("/api/sandboxes/:name/logs", controller.getSandboxLogs);
   app.post("/api/files/read", controller.readFile);
   app.post("/api/files/write", controller.writeFile);
+  app.post("/api/files/delete", controller.deleteFile);
   app.post("/api/files/list", controller.listPath);
   app.post("/api/files/find", controller.findFiles);
   app.post("/api/files/search", controller.searchInFile);
@@ -1021,6 +1180,9 @@ var volumeFsWriteSchema = z3.object({
   path: z3.string(),
   content: z3.string()
 });
+var volumeFsDeleteSchema = z3.object({
+  path: z3.string().min(1)
+});
 var volumeFsListSchema = z3.object({
   path: z3.string()
 });
@@ -1031,12 +1193,46 @@ var volumeFsUploadSchema = z3.object({
 var volumeFsDownloadSchema = z3.object({
   path: z3.string()
 });
+var volumeFsMkdirSchema = z3.object({
+  path: z3.string()
+});
 
 // src/controllers/volume-fs.ts
 var MSB_DATA_DIR = path.join(os.homedir(), ".microsandbox");
+var VOLUME_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function assertVolumeName(name) {
+  if (name === "." || name === ".." || !VOLUME_NAME_PATTERN.test(name)) {
+    throw new HttpError(400, "INVALID_VOLUME_NAME", "Invalid volume name");
+  }
+}
+function assertRegularVolumeFile(guestPath, stat) {
+  if (stat.isSymbolicLink()) {
+    throw new HttpError(
+      400,
+      "VOLUME_FILE_NOT_REGULAR",
+      `Cannot delete '${guestPath}': symlinks are not allowed`
+    );
+  }
+  if (stat.isDirectory()) {
+    throw new HttpError(
+      400,
+      "VOLUME_FILE_NOT_REGULAR",
+      `Cannot delete '${guestPath}': target is a directory`
+    );
+  }
+  if (!stat.isFile()) {
+    throw new HttpError(
+      400,
+      "VOLUME_FILE_NOT_REGULAR",
+      `Cannot delete '${guestPath}': target is not a regular file`
+    );
+  }
+}
 async function resolveVolumeHostPath(name) {
+  assertVolumeName(name);
   try {
     const handle = await Volume2.get(name);
+    assertVolumeName(handle.name);
     const vol = await Volume2.builder(handle.name).create();
     return vol.path;
   } catch {
@@ -1056,6 +1252,23 @@ function resolveGuestPath(hostRoot, guestPath) {
   }
   return resolved;
 }
+function resolveDeleteGuestPath(hostRoot, guestPath) {
+  const pathSegments = guestPath.replace(/\\/g, "/").split("/");
+  if (pathSegments.includes("..")) {
+    throw new HttpError(403, "PATH_TRAVERSAL", "Path traversal detected");
+  }
+  return resolveGuestPath(hostRoot, guestPath);
+}
+async function assertDeleteParentContained(hostRoot, fullPath) {
+  const [rootPath, parentPath] = await Promise.all([
+    fs.realpath(hostRoot),
+    fs.realpath(path.dirname(fullPath))
+  ]);
+  const relative = path.relative(rootPath, parentPath);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new HttpError(403, "PATH_TRAVERSAL", "Path traversal detected");
+  }
+}
 function createVolumeFsController() {
   return {
     readFile: async (request, reply) => {
@@ -1091,6 +1304,46 @@ function createVolumeFsController() {
         throw new HttpError(500, "VOLUME_WRITE_ERROR", `Failed to write to volume '${name}': ${String(err)}`);
       }
     },
+    deleteFile: async (request, reply) => {
+      const { name } = request.params;
+      try {
+        const { path: guestPath } = volumeFsDeleteSchema.parse(request.body ?? {});
+        const hostRoot = await resolveVolumeHostPath(name);
+        const fullPath = resolveDeleteGuestPath(hostRoot, guestPath);
+        await assertDeleteParentContained(hostRoot, fullPath);
+        const stat = await fs.lstat(fullPath);
+        assertRegularVolumeFile(guestPath, stat);
+        const currentStat = await fs.lstat(fullPath);
+        assertRegularVolumeFile(guestPath, currentStat);
+        if (currentStat.dev !== stat.dev || currentStat.ino !== stat.ino) {
+          throw new HttpError(
+            409,
+            "VOLUME_FILE_CHANGED",
+            `Cannot delete '${guestPath}': target changed during deletion`
+          );
+        }
+        await assertDeleteParentContained(hostRoot, fullPath);
+        await fs.unlink(fullPath);
+        return reply.send(ok({ path: guestPath }));
+      } catch (err) {
+        if (err instanceof z4.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        if (err.code === "ENOENT") {
+          throw new HttpError(
+            404,
+            "VOLUME_FILE_NOT_FOUND",
+            `File not found in volume '${name}'`
+          );
+        }
+        throw new HttpError(
+          500,
+          "VOLUME_DELETE_ERROR",
+          `Failed to delete from volume '${name}': ${String(err)}`
+        );
+      }
+    },
     listPath: async (request, reply) => {
       const { name } = request.params;
       try {
@@ -1147,6 +1400,22 @@ function createVolumeFsController() {
         if (err instanceof HttpError) throw err;
         throw new HttpError(500, "VOLUME_UPLOAD_ERROR", `Failed to upload to volume '${name}': ${String(err)}`);
       }
+    },
+    mkdir: async (request, reply) => {
+      const { name } = request.params;
+      try {
+        const { path: guestPath } = volumeFsMkdirSchema.parse(request.body ?? {});
+        const hostRoot = await resolveVolumeHostPath(name);
+        const fullPath = resolveGuestPath(hostRoot, guestPath);
+        await fs.mkdir(fullPath, { recursive: true });
+        return reply.send(ok({ path: guestPath }));
+      } catch (err) {
+        if (err instanceof z4.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        throw new HttpError(500, "VOLUME_MKDIR_ERROR", `Failed to create directory in volume '${name}': ${String(err)}`);
+      }
     }
   };
 }
@@ -1156,9 +1425,11 @@ function registerVolumeFsRoutes(app) {
   const controller = createVolumeFsController();
   app.post("/api/volumes/:name/fs/read", controller.readFile);
   app.post("/api/volumes/:name/fs/write", controller.writeFile);
+  app.post("/api/volumes/:name/fs/delete", controller.deleteFile);
   app.post("/api/volumes/:name/fs/list", controller.listPath);
   app.get("/api/volumes/:name/fs/download", controller.downloadFile);
   app.post("/api/volumes/:name/fs/upload", controller.uploadFile);
+  app.post("/api/volumes/:name/fs/mkdir", controller.mkdir);
 }
 
 // src/services/ImageService.ts
@@ -1331,4 +1602,4 @@ export {
   MicrosandboxRuntimeService,
   buildApp
 };
-//# sourceMappingURL=chunk-IKWYDXRG.mjs.map
+//# sourceMappingURL=chunk-TRJCQNF4.mjs.map