@ricsam/isolate-daemon 0.0.1 → 0.1.1

package/README.md

@@ -1,45 +1,50 @@
 # @ricsam/isolate-daemon
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+Node.js daemon server that manages isolated-vm runtimes via Unix socket or TCP. Allows non-Node.js runtimes (Bun, Deno, etc.) to use isolated-vm through IPC.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+```bash
+npm add @ricsam/isolate-daemon
+```
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+**Features:**
+- Unix domain socket and TCP transport
+- Multiple concurrent connections
+- Runtime lifecycle management (create, dispose)
+- Bidirectional callback bridging (console, fetch, fs)
+- Test environment and Playwright integration
+- Connection-scoped resource cleanup
 
-## Purpose
+**Starting the Daemon:**
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/isolate-daemon`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```typescript
+import { startDaemon } from "@ricsam/isolate-daemon";
 
-## What is OIDC Trusted Publishing?
+const daemon = await startDaemon({
+  socketPath: "/tmp/isolate-daemon.sock", // Unix socket
+  // Or TCP: host: "127.0.0.1", port: 47891
+  maxIsolates: 100,
+  defaultMemoryLimit: 128,
+});
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+console.log(`Daemon listening on ${daemon.socketPath}`);
 
-## Setup Instructions
+// Get stats
+const stats = daemon.getStats();
+console.log(`Active isolates: ${stats.activeIsolates}`);
 
-To properly configure OIDC trusted publishing for this package:
+// Graceful shutdown
+await daemon.close();
+```
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+**CLI Usage:**
 
-## DO NOT USE THIS PACKAGE
+```bash
+# Start daemon on default socket
+npx isolate-daemon
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+# Custom socket path
+npx isolate-daemon --socket /var/run/isolate.sock
 
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+# TCP mode
+npx isolate-daemon --host 127.0.0.1 --port 47891
+```

package/bin/daemon.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * CLI entry point for the isolate daemon.
+ *
+ * Usage:
+ *   isolate-daemon [options]
+ *
+ * Options:
+ *   --socket <path>   Unix socket path (default: /tmp/isolate-daemon.sock)
+ *   --host <host>     TCP host (default: 127.0.0.1)
+ *   --port <port>     TCP port (default: 47891)
+ *   --max-isolates <n>  Maximum isolates (default: 100)
+ *   --memory-limit <mb> Default memory limit (default: 128)
+ */
+
+import { startDaemon } from "../src/index.ts";
+
+function parseArgs(args) {
+  const options = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    switch (arg) {
+      case "--socket":
+        options.socketPath = args[++i];
+        break;
+      case "--host":
+        options.host = args[++i];
+        options.socketPath = undefined; // Use TCP instead
+        break;
+      case "--port":
+        options.port = parseInt(args[++i], 10);
+        options.socketPath = undefined; // Use TCP instead
+        break;
+      case "--max-isolates":
+        options.maxIsolates = parseInt(args[++i], 10);
+        break;
+      case "--memory-limit":
+        options.defaultMemoryLimit = parseInt(args[++i], 10);
+        break;
+      case "--help":
+      case "-h":
+        console.log(`
+Isolate Daemon - Run isolated-vm runtimes accessible via IPC
+
+Usage:
+  isolate-daemon [options]
+
+Options:
+  --socket <path>       Unix socket path (default: /tmp/isolate-daemon.sock)
+  --host <host>         TCP host (default: 127.0.0.1, disables Unix socket)
+  --port <port>         TCP port (default: 47891, disables Unix socket)
+  --max-isolates <n>    Maximum isolates (default: 100)
+  --memory-limit <mb>   Default memory limit in MB (default: 128)
+  --help, -h            Show this help message
+`);
+        process.exit(0);
+      default:
+        if (arg.startsWith("-")) {
+          console.error(`Unknown option: ${arg}`);
+          process.exit(1);
+        }
+    }
+  }
+
+  return options;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  const daemon = await startDaemon(options);
+
+  // Handle shutdown signals
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    await daemon.close();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // Log stats periodically
+  setInterval(() => {
+    const stats = daemon.getStats();
+    console.log(
+      `[stats] connections: ${stats.activeConnections}, isolates: ${stats.activeIsolates}, total requests: ${stats.totalRequestsProcessed}`
+    );
+  }, 60000);
+}
+
+main().catch((err) => {
+  console.error("Failed to start daemon:", err);
+  process.exit(1);
+});

package/dist/cjs/callback-fs-handler.cjs

@@ -0,0 +1,314 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/isolate-daemon/src/callback-fs-handler.ts
+var exports_callback_fs_handler = {};
+__export(exports_callback_fs_handler, {
+  createCallbackFileSystemHandler: () => createCallbackFileSystemHandler
+});
+module.exports = __toCommonJS(exports_callback_fs_handler);
+function createCallbackFileSystemHandler(options) {
+  const { connection, callbacks, invokeClientCallback, basePath = "" } = options;
+  const resolvePath = (path) => {
+    const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+    if (!basePath || basePath === "/") {
+      return `/${cleanPath}`;
+    }
+    const cleanBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+    return `${cleanBase}/${cleanPath}`;
+  };
+  return {
+    async getFileHandle(path, opts) {
+      const fullPath = resolvePath(path);
+      if (opts?.create) {
+        if (callbacks.writeFile) {
+          try {
+            if (callbacks.stat) {
+              try {
+                await invokeClientCallback(connection, callbacks.stat.callbackId, [fullPath]);
+                return;
+              } catch {}
+            }
+            await invokeClientCallback(connection, callbacks.writeFile.callbackId, [
+              fullPath,
+              new Uint8Array(0)
+            ]);
+          } catch (err) {
+            const error = err;
+            throw new Error(`[NotFoundError]${error.message}`);
+          }
+        }
+        return;
+      }
+      if (callbacks.stat) {
+        try {
+          const result = await invokeClientCallback(connection, callbacks.stat.callbackId, [
+            fullPath
+          ]);
+          if (!result.isFile) {
+            throw new Error(`[TypeMismatchError]Not a file: ${fullPath}`);
+          }
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("TypeMismatchError"))
+            throw error;
+          throw new Error(`[NotFoundError]File not found: ${fullPath}`);
+        }
+      }
+    },
+    async getDirectoryHandle(path, opts) {
+      const fullPath = resolvePath(path);
+      if (opts?.create) {
+        if (callbacks.mkdir) {
+          try {
+            await invokeClientCallback(connection, callbacks.mkdir.callbackId, [
+              fullPath,
+              { recursive: true }
+            ]);
+          } catch {}
+        }
+        return;
+      }
+      if (callbacks.stat) {
+        try {
+          const result = await invokeClientCallback(connection, callbacks.stat.callbackId, [
+            fullPath
+          ]);
+          if (!result.isDirectory) {
+            throw new Error(`[TypeMismatchError]Not a directory: ${fullPath}`);
+          }
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("TypeMismatchError"))
+            throw error;
+          throw new Error(`[NotFoundError]Directory not found: ${fullPath}`);
+        }
+      }
+    },
+    async removeEntry(path, opts) {
+      const fullPath = resolvePath(path);
+      let isFile = true;
+      if (callbacks.stat) {
+        try {
+          const result = await invokeClientCallback(connection, callbacks.stat.callbackId, [
+            fullPath
+          ]);
+          isFile = result.isFile;
+        } catch {
+          throw new Error(`[NotFoundError]Entry not found: ${fullPath}`);
+        }
+      }
+      if (isFile) {
+        if (!callbacks.unlink) {
+          throw new Error(`[NotAllowedError]File deletion not supported`);
+        }
+        await invokeClientCallback(connection, callbacks.unlink.callbackId, [fullPath]);
+      } else {
+        if (!callbacks.rmdir) {
+          throw new Error(`[NotAllowedError]Directory deletion not supported`);
+        }
+        await invokeClientCallback(connection, callbacks.rmdir.callbackId, [fullPath]);
+      }
+    },
+    async readDirectory(path) {
+      const fullPath = resolvePath(path);
+      if (!callbacks.readdir) {
+        throw new Error(`[NotAllowedError]Directory reading not supported`);
+      }
+      const entries = await invokeClientCallback(connection, callbacks.readdir.callbackId, [
+        fullPath
+      ]);
+      const result = [];
+      for (const name of entries) {
+        const entryPath = fullPath ? `${fullPath}/${name}` : name;
+        let kind = "file";
+        if (callbacks.stat) {
+          try {
+            const stat = await invokeClientCallback(connection, callbacks.stat.callbackId, [
+              entryPath
+            ]);
+            kind = stat.isDirectory ? "directory" : "file";
+          } catch {}
+        }
+        result.push({ name, kind });
+      }
+      return result;
+    },
+    async readFile(path) {
+      const fullPath = resolvePath(path);
+      if (!callbacks.readFile) {
+        throw new Error(`[NotAllowedError]File reading not supported`);
+      }
+      const data = await invokeClientCallback(connection, callbacks.readFile.callbackId, [
+        fullPath
+      ]);
+      let bytes;
+      if (data instanceof Uint8Array) {
+        bytes = data;
+      } else if (Array.isArray(data)) {
+        bytes = new Uint8Array(data);
+      } else if (data instanceof ArrayBuffer) {
+        bytes = new Uint8Array(data);
+      } else {
+        bytes = new Uint8Array(0);
+      }
+      let size = bytes.length;
+      let lastModified = Date.now();
+      if (callbacks.stat) {
+        try {
+          const stat = await invokeClientCallback(connection, callbacks.stat.callbackId, [
+            fullPath
+          ]);
+          size = stat.size;
+          if (stat.lastModified) {
+            lastModified = stat.lastModified;
+          }
+        } catch {}
+      }
+      const ext = path.split(".").pop()?.toLowerCase() || "";
+      const mimeTypes = {
+        txt: "text/plain",
+        html: "text/html",
+        htm: "text/html",
+        css: "text/css",
+        js: "text/javascript",
+        json: "application/json",
+        xml: "application/xml",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        pdf: "application/pdf"
+      };
+      const type = mimeTypes[ext] || "application/octet-stream";
+      return { data: bytes, size, lastModified, type };
+    },
+    async writeFile(path, data, position) {
+      const fullPath = resolvePath(path);
+      if (!callbacks.writeFile) {
+        throw new Error(`[NotAllowedError]File writing not supported`);
+      }
+      if (position !== undefined && position > 0) {
+        if (callbacks.readFile) {
+          try {
+            const existing = await invokeClientCallback(connection, callbacks.readFile.callbackId, [fullPath]);
+            let existingBytes;
+            if (existing instanceof Uint8Array) {
+              existingBytes = existing;
+            } else if (Array.isArray(existing)) {
+              existingBytes = new Uint8Array(existing);
+            } else if (existing instanceof ArrayBuffer) {
+              existingBytes = new Uint8Array(existing);
+            } else {
+              existingBytes = new Uint8Array(0);
+            }
+            const newSize = Math.max(existingBytes.length, position + data.length);
+            const merged = new Uint8Array(newSize);
+            merged.set(existingBytes);
+            merged.set(data, position);
+            await invokeClientCallback(connection, callbacks.writeFile.callbackId, [
+              fullPath,
+              merged
+            ]);
+            return;
+          } catch {
+            const newData = new Uint8Array(position + data.length);
+            newData.set(data, position);
+            await invokeClientCallback(connection, callbacks.writeFile.callbackId, [
+              fullPath,
+              newData
+            ]);
+            return;
+          }
+        }
+      }
+      await invokeClientCallback(connection, callbacks.writeFile.callbackId, [fullPath, data]);
+    },
+    async truncateFile(path, size) {
+      const fullPath = resolvePath(path);
+      if (!callbacks.readFile || !callbacks.writeFile) {
+        throw new Error(`[NotAllowedError]File truncation not supported`);
+      }
+      const existing = await invokeClientCallback(connection, callbacks.readFile.callbackId, [
+        fullPath
+      ]);
+      let existingBytes;
+      if (existing instanceof Uint8Array) {
+        existingBytes = existing;
+      } else if (Array.isArray(existing)) {
+        existingBytes = new Uint8Array(existing);
+      } else if (existing instanceof ArrayBuffer) {
+        existingBytes = new Uint8Array(existing);
+      } else {
+        existingBytes = new Uint8Array(0);
+      }
+      const truncated = new Uint8Array(size);
+      truncated.set(existingBytes.slice(0, size));
+      await invokeClientCallback(connection, callbacks.writeFile.callbackId, [fullPath, truncated]);
+    },
+    async getFileMetadata(path) {
+      const fullPath = resolvePath(path);
+      if (!callbacks.stat) {
+        throw new Error(`[NotAllowedError]File stat not supported`);
+      }
+      const stat = await invokeClientCallback(connection, callbacks.stat.callbackId, [
+        fullPath
+      ]);
+      if (!stat.isFile) {
+        throw new Error(`[TypeMismatchError]Not a file: ${fullPath}`);
+      }
+      const ext = path.split(".").pop()?.toLowerCase() || "";
+      const mimeTypes = {
+        txt: "text/plain",
+        html: "text/html",
+        htm: "text/html",
+        css: "text/css",
+        js: "text/javascript",
+        json: "application/json",
+        xml: "application/xml",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        pdf: "application/pdf"
+      };
+      const type = mimeTypes[ext] || "application/octet-stream";
+      return {
+        size: stat.size,
+        lastModified: stat.lastModified ?? Date.now(),
+        type
+      };
+    }
+  };
+}
+})
+
+//# debugId=6BC1EED73784E89264756E2164756E21

package/dist/cjs/callback-fs-handler.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/callback-fs-handler.ts"],
+  "sourcesContent": [
+    "/**\n * Callback-based FileSystemHandler adapter.\n *\n * Adapts simple client callbacks (readFile, writeFile, etc.) to the\n * FileSystemHandler interface used by @ricsam/isolate-fs.\n */\n\nimport type { FileSystemHandler } from \"@ricsam/isolate-fs\";\nimport type { FsCallbackRegistrations, CallbackRegistration } from \"@ricsam/isolate-protocol\";\nimport type { ConnectionState } from \"./types.cjs\";\n\ninterface InvokeClientCallback {\n  (connection: ConnectionState, callbackId: number, args: unknown[]): Promise<unknown>;\n}\n\ninterface CallbackFsHandlerOptions {\n  connection: ConnectionState;\n  callbacks: FsCallbackRegistrations;\n  invokeClientCallback: InvokeClientCallback;\n  basePath?: string;\n}\n\n/**\n * Create a FileSystemHandler that invokes client callbacks.\n *\n * Maps WHATWG FileSystem API operations to simple POSIX-like callbacks.\n */\nexport function createCallbackFileSystemHandler(\n  options: CallbackFsHandlerOptions\n): FileSystemHandler {\n  const { connection, callbacks, invokeClientCallback, basePath = \"\" } = options;\n\n  const resolvePath = (path: string): string => {\n    // Remove leading slash from the path\n    const cleanPath = path.startsWith(\"/\") ? path.slice(1) : path;\n    // Handle root case\n    if (!basePath || basePath === \"/\") {\n      return `/${cleanPath}`;\n    }\n    // Remove trailing slash from basePath\n    const cleanBase = basePath.endsWith(\"/\") ? basePath.slice(0, -1) : basePath;\n    return `${cleanBase}/${cleanPath}`;\n  };\n\n  return {\n    async getFileHandle(path: string, opts?: { create?: boolean }): Promise<void> {\n      const fullPath = resolvePath(path);\n\n      if (opts?.create) {\n        // Ensure file exists by writing empty content if it doesn't exist\n        if (callbacks.writeFile) {\n          try {\n            // Check if file exists first\n            if (callbacks.stat) {\n              try {\n                await invokeClientCallback(connection, callbacks.stat.callbackId, [fullPath]);\n                // File exists, nothing to do\n                return;\n              } catch {\n                // File doesn't exist, create it\n              }\n            }\n            // Create empty file\n            await invokeClientCallback(connection, callbacks.writeFile.callbackId, [\n              fullPath,\n              new Uint8Array(0),\n            ]);\n          } catch (err) {\n            const error = err as Error;\n            throw new Error(`[NotFoundError]${error.message}`);\n          }\n        }\n        return;\n      }\n\n      // Check file exists\n      if (callbacks.stat) {\n        try {\n          const result = (await invokeClientCallback(connection, callbacks.stat.callbackId, [\n            fullPath,\n          ])) as { isFile: boolean };\n          if (!result.isFile) {\n            throw new Error(`[TypeMismatchError]Not a file: ${fullPath}`);\n          }\n        } catch (err) {\n          const error = err as Error;\n          if (error.message.includes(\"TypeMismatchError\")) throw error;\n          throw new Error(`[NotFoundError]File not found: ${fullPath}`);\n        }\n      }\n    },\n\n    async getDirectoryHandle(path: string, opts?: { create?: boolean }): Promise<void> {\n      const fullPath = resolvePath(path);\n\n      if (opts?.create) {\n        if (callbacks.mkdir) {\n          try {\n            await invokeClientCallback(connection, callbacks.mkdir.callbackId, [\n              fullPath,\n              { recursive: true },\n            ]);\n          } catch {\n            // Ignore error if directory already exists\n          }\n        }\n        return;\n      }\n\n      // Check directory exists\n      if (callbacks.stat) {\n        try {\n          const result = (await invokeClientCallback(connection, callbacks.stat.callbackId, [\n            fullPath,\n          ])) as { isDirectory: boolean };\n          if (!result.isDirectory) {\n            throw new Error(`[TypeMismatchError]Not a directory: ${fullPath}`);\n          }\n        } catch (err) {\n          const error = err as Error;\n          if (error.message.includes(\"TypeMismatchError\")) throw error;\n          throw new Error(`[NotFoundError]Directory not found: ${fullPath}`);\n        }\n      }\n    },\n\n    async removeEntry(path: string, opts?: { recursive?: boolean }): Promise<void> {\n      const fullPath = resolvePath(path);\n\n      // Check if it's a file or directory\n      let isFile = true;\n      if (callbacks.stat) {\n        try {\n          const result = (await invokeClientCallback(connection, callbacks.stat.callbackId, [\n            fullPath,\n          ])) as { isFile: boolean; isDirectory: boolean };\n          isFile = result.isFile;\n        } catch {\n          throw new Error(`[NotFoundError]Entry not found: ${fullPath}`);\n        }\n      }\n\n      if (isFile) {\n        if (!callbacks.unlink) {\n          throw new Error(`[NotAllowedError]File deletion not supported`);\n        }\n        await invokeClientCallback(connection, callbacks.unlink.callbackId, [fullPath]);\n      } else {\n        if (!callbacks.rmdir) {\n          throw new Error(`[NotAllowedError]Directory deletion not supported`);\n        }\n        // Note: recursive option may need special handling\n        await invokeClientCallback(connection, callbacks.rmdir.callbackId, [fullPath]);\n      }\n    },\n\n    async readDirectory(\n      path: string\n    ): Promise<Array<{ name: string; kind: \"file\" | \"directory\" }>> {\n      const fullPath = resolvePath(path);\n\n      if (!callbacks.readdir) {\n        throw new Error(`[NotAllowedError]Directory reading not supported`);\n      }\n\n      const entries = (await invokeClientCallback(connection, callbacks.readdir.callbackId, [\n        fullPath,\n      ])) as string[];\n\n      // We need to stat each entry to determine if it's a file or directory\n      const result: Array<{ name: string; kind: \"file\" | \"directory\" }> = [];\n\n      for (const name of entries) {\n        const entryPath = fullPath ? `${fullPath}/${name}` : name;\n        let kind: \"file\" | \"directory\" = \"file\";\n\n        if (callbacks.stat) {\n          try {\n            const stat = (await invokeClientCallback(connection, callbacks.stat.callbackId, [\n              entryPath,\n            ])) as { isFile: boolean; isDirectory: boolean };\n            kind = stat.isDirectory ? \"directory\" : \"file\";\n          } catch {\n            // Default to file if stat fails\n          }\n        }\n\n        result.push({ name, kind });\n      }\n\n      return result;\n    },\n\n    async readFile(\n      path: string\n    ): Promise<{ data: Uint8Array; size: number; lastModified: number; type: string }> {\n      const fullPath = resolvePath(path);\n\n      if (!callbacks.readFile) {\n        throw new Error(`[NotAllowedError]File reading not supported`);\n      }\n\n      const data = (await invokeClientCallback(connection, callbacks.readFile.callbackId, [\n        fullPath,\n      ])) as Uint8Array | ArrayBuffer | number[];\n\n      // Convert to Uint8Array if needed\n      let bytes: Uint8Array;\n      if (data instanceof Uint8Array) {\n        bytes = data;\n      } else if (Array.isArray(data)) {\n        bytes = new Uint8Array(data);\n      } else if (data instanceof ArrayBuffer) {\n        bytes = new Uint8Array(data);\n      } else {\n        bytes = new Uint8Array(0);\n      }\n\n      // Get metadata if stat is available\n      let size = bytes.length;\n      let lastModified = Date.now();\n\n      if (callbacks.stat) {\n        try {\n          const stat = (await invokeClientCallback(connection, callbacks.stat.callbackId, [\n            fullPath,\n          ])) as { size: number; lastModified?: number };\n          size = stat.size;\n          if (stat.lastModified) {\n            lastModified = stat.lastModified;\n          }\n        } catch {\n          // Use byte length as fallback\n        }\n      }\n\n      // Determine MIME type from extension\n      const ext = path.split(\".\").pop()?.toLowerCase() || \"\";\n      const mimeTypes: Record<string, string> = {\n        txt: \"text/plain\",\n        html: \"text/html\",\n        htm: \"text/html\",\n        css: \"text/css\",\n        js: \"text/javascript\",\n        json: \"application/json\",\n        xml: \"application/xml\",\n        png: \"image/png\",\n        jpg: \"image/jpeg\",\n        jpeg: \"image/jpeg\",\n        gif: \"image/gif\",\n        svg: \"image/svg+xml\",\n        pdf: \"application/pdf\",\n      };\n      const type = mimeTypes[ext] || \"application/octet-stream\";\n\n      return { data: bytes, size, lastModified, type };\n    },\n\n    async writeFile(path: string, data: Uint8Array, position?: number): Promise<void> {\n      const fullPath = resolvePath(path);\n\n      if (!callbacks.writeFile) {\n        throw new Error(`[NotAllowedError]File writing not supported`);\n      }\n\n      // Note: position parameter for partial writes may need special handling\n      // Simple implementation overwrites entire file\n      if (position !== undefined && position > 0) {\n        // For positional writes, we need to read existing content and merge\n        if (callbacks.readFile) {\n          try {\n            const existing = (await invokeClientCallback(\n              connection,\n              callbacks.readFile.callbackId,\n              [fullPath]\n            )) as Uint8Array | ArrayBuffer | number[];\n\n            let existingBytes: Uint8Array;\n            if (existing instanceof Uint8Array) {\n              existingBytes = existing;\n            } else if (Array.isArray(existing)) {\n              existingBytes = new Uint8Array(existing);\n            } else if (existing instanceof ArrayBuffer) {\n              existingBytes = new Uint8Array(existing);\n            } else {\n              existingBytes = new Uint8Array(0);\n            }\n\n            // Create merged buffer\n            const newSize = Math.max(existingBytes.length, position + data.length);\n            const merged = new Uint8Array(newSize);\n            merged.set(existingBytes);\n            merged.set(data, position);\n\n            await invokeClientCallback(connection, callbacks.writeFile.callbackId, [\n              fullPath,\n              merged,\n            ]);\n            return;\n          } catch {\n            // File doesn't exist, create new one at position\n            const newData = new Uint8Array(position + data.length);\n            newData.set(data, position);\n            await invokeClientCallback(connection, callbacks.writeFile.callbackId, [\n              fullPath,\n              newData,\n            ]);\n            return;\n          }\n        }\n      }\n\n      await invokeClientCallback(connection, callbacks.writeFile.callbackId, [fullPath, data]);\n    },\n\n    async truncateFile(path: string, size: number): Promise<void> {\n      const fullPath = resolvePath(path);\n\n      if (!callbacks.readFile || !callbacks.writeFile) {\n        throw new Error(`[NotAllowedError]File truncation not supported`);\n      }\n\n      // Read existing content\n      const existing = (await invokeClientCallback(connection, callbacks.readFile.callbackId, [\n        fullPath,\n      ])) as Uint8Array | ArrayBuffer | number[];\n\n      let existingBytes: Uint8Array;\n      if (existing instanceof Uint8Array) {\n        existingBytes = existing;\n      } else if (Array.isArray(existing)) {\n        existingBytes = new Uint8Array(existing);\n      } else if (existing instanceof ArrayBuffer) {\n        existingBytes = new Uint8Array(existing);\n      } else {\n        existingBytes = new Uint8Array(0);\n      }\n\n      // Create truncated buffer\n      const truncated = new Uint8Array(size);\n      truncated.set(existingBytes.slice(0, size));\n\n      await invokeClientCallback(connection, callbacks.writeFile.callbackId, [fullPath, truncated]);\n    },\n\n    async getFileMetadata(\n      path: string\n    ): Promise<{ size: number; lastModified: number; type: string }> {\n      const fullPath = resolvePath(path);\n\n      if (!callbacks.stat) {\n        throw new Error(`[NotAllowedError]File stat not supported`);\n      }\n\n      const stat = (await invokeClientCallback(connection, callbacks.stat.callbackId, [\n        fullPath,\n      ])) as { size: number; lastModified?: number; isFile: boolean };\n\n      if (!stat.isFile) {\n        throw new Error(`[TypeMismatchError]Not a file: ${fullPath}`);\n      }\n\n      // Determine MIME type from extension\n      const ext = path.split(\".\").pop()?.toLowerCase() || \"\";\n      const mimeTypes: Record<string, string> = {\n        txt: \"text/plain\",\n        html: \"text/html\",\n        htm: \"text/html\",\n        css: \"text/css\",\n        js: \"text/javascript\",\n        json: \"application/json\",\n        xml: \"application/xml\",\n        png: \"image/png\",\n        jpg: \"image/jpeg\",\n        jpeg: \"image/jpeg\",\n        gif: \"image/gif\",\n        svg: \"image/svg+xml\",\n        pdf: \"application/pdf\",\n      };\n      const type = mimeTypes[ext] || \"application/octet-stream\";\n\n      return {\n        size: stat.size,\n        lastModified: stat.lastModified ?? Date.now(),\n        type,\n      };\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "6BC1EED73784E89264756E2164756E21",
+  "names": []
+}