@sandboxxjs/core 0.1.0 → 0.3.0

package/dist/index.js

@@ -474,6 +474,36 @@ var require_cross_spawn = __commonJS((exports, module) => {
   module.exports._enoent = enoent;
 });
 
+// ../../node_modules/.bun/nanoid@5.1.6/node_modules/nanoid/index.js
+import { webcrypto as crypto } from "node:crypto";
+
+// ../../node_modules/.bun/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.bun/nanoid@5.1.6/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
 // ../../node_modules/.bun/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) {
@@ -7234,119 +7264,58 @@ class FileSystemError extends SandboxError {
 // src/isolators/LocalIsolator.ts
 class LocalIsolator extends Isolator {
   workDir;
-  runtime;
-  constructor(runtime = "node") {
+  constructor() {
     super();
-    this.runtime = runtime;
     this.workDir = path6.join(process.cwd(), ".sandbox", `session-${Date.now()}`);
   }
-  async execute(options) {
-    const { code, env = {}, timeout = 30000 } = options;
+  async shell(command, options = {}) {
+    const { timeout = 30000, env = {} } = options;
     const startTime = Date.now();
     await fs.mkdir(this.workDir, { recursive: true });
     try {
-      const command = this.buildCommand(code);
-      const result = await execa(command[0], command.slice(1), {
+      const result = await execa("sh", ["-c", command], {
         cwd: this.workDir,
         env: { ...process.env, ...env },
         timeout,
         maxBuffer: 10 * 1024 * 1024,
-        reject: true,
+        reject: false,
         all: true
       });
       return {
         success: result.exitCode === 0,
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: result.exitCode || 0,
-        metadata: {
-          executionTime: Date.now() - startTime,
-          timestamp: new Date().toISOString()
-        }
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        exitCode: result.exitCode ?? 0,
+        executionTime: Date.now() - startTime
       };
     } catch (error) {
-      if (error.timedOut) {
+      if (error && typeof error === "object" && "timedOut" in error && error.timedOut) {
         throw new TimeoutError(`Execution timed out after ${timeout}ms`);
       }
-      if (error.exitCode !== undefined) {
-        return {
-          success: false,
-          stdout: error.stdout || "",
-          stderr: error.stderr || "",
-          exitCode: error.exitCode,
-          metadata: {
-            executionTime: Date.now() - startTime,
-            timestamp: new Date().toISOString()
-          }
-        };
-      }
-      throw new ExecutionError(`Execution failed: ${error.message}`);
+      throw new ExecutionError(`Shell execution failed: ${error.message}`);
     }
   }
-  buildCommand(code) {
-    switch (this.runtime) {
-      case "node":
-        return ["node", "--eval", code];
-      case "python":
-        return ["python3", "-c", code];
-      case "bash":
-        return ["bash", "-c", code];
-      default:
-        throw new ExecutionError(`Unsupported runtime: ${this.runtime}`);
+  async upload(data, remotePath) {
+    try {
+      const fullPath = path6.join(this.workDir, remotePath);
+      await fs.mkdir(path6.dirname(fullPath), { recursive: true });
+      await fs.writeFile(fullPath, data);
+    } catch (error) {
+      throw new FileSystemError(`Failed to upload file: ${error.message}`);
     }
   }
-  getFileSystem() {
-    return {
-      write: async (filePath, data) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          await fs.mkdir(path6.dirname(fullPath), { recursive: true });
-          await fs.writeFile(fullPath, data, "utf-8");
-        } catch (error) {
-          throw new FileSystemError(`Failed to write file: ${error.message}`);
-        }
-      },
-      read: async (filePath) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          return await fs.readFile(fullPath, "utf-8");
-        } catch (error) {
-          throw new FileSystemError(`Failed to read file: ${error.message}`);
-        }
-      },
-      list: async (dirPath) => {
-        try {
-          const fullPath = path6.join(this.workDir, dirPath);
-          return await fs.readdir(fullPath);
-        } catch (error) {
-          throw new FileSystemError(`Failed to list directory: ${error.message}`);
-        }
-      },
-      delete: async (filePath) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          await fs.rm(fullPath, { recursive: true, force: true });
-        } catch (error) {
-          throw new FileSystemError(`Failed to delete: ${error.message}`);
-        }
-      },
-      exists: async (filePath) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          await fs.access(fullPath);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-    };
+  async download(remotePath) {
+    try {
+      const fullPath = path6.join(this.workDir, remotePath);
+      return await fs.readFile(fullPath);
+    } catch (error) {
+      throw new FileSystemError(`Failed to download file: ${error.message}`);
+    }
   }
   async destroy() {
     try {
       await fs.rm(this.workDir, { recursive: true, force: true });
-    } catch (error) {
-      console.warn(`Failed to clean up work directory: ${error.message}`);
-    }
+    } catch {}
   }
 }
 
@@ -7360,10 +7329,8 @@ class CloudflareContainerIsolator extends Isolator {
   serverProcess;
   serverUrl;
   isReady = false;
-  runtime;
-  constructor(runtime = "node") {
+  constructor() {
     super();
-    this.runtime = runtime;
   }
   async findFreePort() {
     return new Promise((resolve, reject) => {
@@ -7411,17 +7378,19 @@ class CloudflareContainerIsolator extends Isolator {
     await this.waitForReady(this.serverUrl);
     this.isReady = true;
   }
-  async execute(options) {
+  async shell(command, options = {}) {
+    const { timeout = 30000, env = {} } = options;
+    const startTime = Date.now();
     await this.ensureServerRunning();
     try {
       const response = await fetch(`${this.serverUrl}/execute`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          code: options.code,
-          runtime: this.runtime,
-          env: options.env || {},
-          timeout: options.timeout || 30000
+          code: command,
+          runtime: "bash",
+          env,
+          timeout
         })
       });
       if (!response.ok) {
@@ -7429,29 +7398,22 @@ class CloudflareContainerIsolator extends Isolator {
         throw new ExecutionError(`Server execution failed: ${error}`);
       }
       const result = await response.json();
-      return result;
+      return {
+        success: result.success,
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        exitCode: result.exitCode ?? (result.success ? 0 : 1),
+        executionTime: Date.now() - startTime
+      };
     } catch (error) {
-      throw new ExecutionError(`Execution failed: ${error.message}`);
+      throw new ExecutionError(`Shell execution failed: ${error.message}`);
     }
   }
-  getFileSystem() {
-    return {
-      write: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      read: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      list: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      delete: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      exists: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      }
-    };
+  async upload(_data, _remotePath) {
+    throw new FileSystemError("Upload not yet implemented for CloudflareContainerIsolator");
+  }
+  async download(_remotePath) {
+    throw new FileSystemError("Download not yet implemented for CloudflareContainerIsolator");
   }
   async destroy() {
     if (this.serverProcess) {
@@ -7463,103 +7425,1266 @@ class CloudflareContainerIsolator extends Isolator {
   }
 }
 
-// src/runtimes/Runtime.ts
-class Runtime {
-}
-
-// src/runtimes/GenericRuntime.ts
-class GenericRuntime extends Runtime {
-  isolator;
-  constructor(isolator) {
-    super();
-    this.isolator = isolator;
-  }
-  async execute(options) {
-    return this.isolator.execute(options);
-  }
-  async prepare() {}
-  async cleanup() {}
-}
-
 // src/Sandbox.ts
-class Sandbox {
+class BaseSandbox {
+  id;
   isolator;
-  runtime;
-  eventHandlers = new Map;
-  fs;
+  config;
   constructor(config) {
-    this.isolator = this.createIsolator(config.isolator, config.runtime);
-    this.fs = this.isolator.getFileSystem();
-    this.runtime = this.createRuntime(config.runtime, this.isolator);
+    this.id = `sandbox-${nanoid()}`;
+    this.config = config;
+    this.isolator = this.createIsolator(config.isolator);
   }
-  createIsolator(isolatorType, runtime) {
+  createIsolator(isolatorType) {
     switch (isolatorType) {
       case "local":
-        return new LocalIsolator(runtime);
+        return new LocalIsolator;
       case "cloudflare":
-        return new CloudflareContainerIsolator(runtime);
+        return new CloudflareContainerIsolator;
       case "e2b":
-      case "firecracker":
       case "docker":
         throw new SandboxError(`Isolator "${isolatorType}" not yet implemented`);
       default:
         throw new SandboxError(`Unknown isolator type: ${isolatorType}`);
     }
   }
-  createRuntime(_runtimeType, isolator) {
-    return new GenericRuntime(isolator);
+  async shell(command) {
+    return this.isolator.shell(command, {
+      timeout: this.config.limits?.timeout
+    });
+  }
+  async upload(data, remotePath) {
+    return this.isolator.upload(data, remotePath);
+  }
+  async download(remotePath) {
+    return this.isolator.download(remotePath);
+  }
+  async destroy() {
+    return this.isolator.destroy();
+  }
+}
+// ../state/dist/index.js
+import { createRequire as createRequire3 } from "node:module";
+import { readFile as readFile2, writeFile as writeFile2, readdir, mkdir as mkdir2, rm as rm2, access, stat as fsStat } from "node:fs/promises";
+import { resolve, dirname as dirname2 } from "node:path";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { readFile as readFile22, writeFile as writeFile22, readdir as readdir2, access as access2, unlink, mkdir as mkdir22, stat, rm as rm22 } from "node:fs/promises";
+import { join as join22 } from "node:path";
+import { createHash } from "crypto";
+var __require2 = /* @__PURE__ */ createRequire3(import.meta.url);
+
+class StateError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StateError";
+  }
+}
+
+class FileSystemError2 extends StateError {
+  constructor(message) {
+    super(message);
+    this.name = "FileSystemError";
+  }
+}
+
+class StateFS {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  async read(path7) {
+    const result = await this.sandbox.shell(`cat "${path7}"`);
+    if (!result.success) {
+      throw new FileSystemError2(`Failed to read file: ${path7}`);
+    }
+    return result.stdout;
+  }
+  async write(path7, data) {
+    const dir = path7.substring(0, path7.lastIndexOf("/"));
+    if (dir) {
+      await this.sandbox.shell(`mkdir -p "${dir}"`);
+    }
+    const result = await this.sandbox.shell(`cat > "${path7}" << 'SANDBOX_EOF'
+${data}
+SANDBOX_EOF`);
+    if (!result.success) {
+      throw new FileSystemError2(`Failed to write file: ${path7}`);
+    }
+  }
+  async exists(path7) {
+    const result = await this.sandbox.shell(`test -e "${path7}" && echo "yes" || echo "no"`);
+    return result.stdout.trim() === "yes";
+  }
+  async delete(path7) {
+    await this.sandbox.shell(`rm -rf "${path7}"`);
+  }
+  async list(path7) {
+    const result = await this.sandbox.shell(`ls -1 "${path7}" 2>/dev/null`);
+    if (!result.success || !result.stdout.trim()) {
+      return [];
+    }
+    return result.stdout.trim().split(`
+`).filter(Boolean);
+  }
+}
+
+class StateEnv {
+  vars;
+  constructor(initial) {
+    this.vars = new Map(Object.entries(initial ?? {}));
+  }
+  get(key) {
+    return this.vars.get(key);
+  }
+  set(key, value) {
+    this.vars.set(key, value);
+  }
+  has(key) {
+    return this.vars.has(key);
+  }
+  delete(key) {
+    this.vars.delete(key);
+  }
+  keys() {
+    return [...this.vars.keys()];
+  }
+  all() {
+    return Object.fromEntries(this.vars);
+  }
+}
+
+class StateStorage {
+  data;
+  constructor(initial) {
+    this.data = new Map(Object.entries(initial ?? {}));
+  }
+  getItem(key) {
+    return this.data.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.data.set(key, value);
+  }
+  removeItem(key) {
+    this.data.delete(key);
+  }
+  clear() {
+    this.data.clear();
+  }
+  keys() {
+    return [...this.data.keys()];
+  }
+}
+
+class StateLog {
+  entries = [];
+  fs = {
+    write: (path7, data) => {
+      this.entries.push({ op: "fs.write", args: { path: path7, data } });
+      return this;
+    },
+    delete: (path7) => {
+      this.entries.push({ op: "fs.delete", args: { path: path7 } });
+      return this;
+    }
+  };
+  env = {
+    set: (key, value) => {
+      this.entries.push({ op: "env.set", args: { key, value } });
+      return this;
+    },
+    delete: (key) => {
+      this.entries.push({ op: "env.delete", args: { key } });
+      return this;
+    }
+  };
+  storage = {
+    set: (key, value) => {
+      this.entries.push({ op: "storage.set", args: { key, value } });
+      return this;
+    },
+    delete: (key) => {
+      this.entries.push({ op: "storage.delete", args: { key } });
+      return this;
+    },
+    clear: () => {
+      this.entries.push({ op: "storage.clear", args: {} });
+      return this;
+    }
+  };
+  recordEntry(op, args) {
+    this.entries.push({ op, args });
+    return this;
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  toJSON() {
+    return JSON.stringify(this.entries);
+  }
+  static fromJSON(json) {
+    const log = new StateLog;
+    log.entries = JSON.parse(json);
+    return log;
+  }
+  static fromEntries(entries) {
+    const log = new StateLog;
+    log.entries = [...entries];
+    return log;
+  }
+  compact() {
+    const fsState = new Map;
+    const envState = new Map;
+    const storageState = new Map;
+    let storageClear = null;
+    for (const entry of this.entries) {
+      const { op, args } = entry;
+      if (op === "fs.write") {
+        fsState.set(args.path, entry);
+      } else if (op === "fs.delete") {
+        fsState.set(args.path, entry);
+      } else if (op === "env.set") {
+        envState.set(args.key, entry);
+      } else if (op === "env.delete") {
+        envState.set(args.key, entry);
+      } else if (op === "storage.set") {
+        storageState.set(args.key, entry);
+      } else if (op === "storage.delete") {
+        storageState.set(args.key, entry);
+      } else if (op === "storage.clear") {
+        storageClear = entry;
+        storageState.clear();
+      }
+    }
+    const compactedEntries = [];
+    for (const entry of fsState.values()) {
+      compactedEntries.push(entry);
+    }
+    for (const entry of envState.values()) {
+      compactedEntries.push(entry);
+    }
+    if (storageClear) {
+      compactedEntries.push(storageClear);
+    }
+    for (const entry of storageState.values()) {
+      compactedEntries.push(entry);
+    }
+    return StateLog.fromEntries(compactedEntries);
+  }
+}
+function buildStateLog() {
+  return new StateLog;
+}
+function loadStateLog(json) {
+  return StateLog.fromJSON(json);
+}
+var opRegistry = {
+  "fs.write": {
+    namespace: "fs",
+    method: "write",
+    args: ["path", "data"],
+    replay: async (target, args) => {
+      await target.fs.write(args.path, args.data);
+    }
+  },
+  "fs.delete": {
+    namespace: "fs",
+    method: "delete",
+    args: ["path"],
+    replay: async (target, args) => {
+      await target.fs.delete(args.path);
+    }
+  },
+  "env.set": {
+    namespace: "env",
+    method: "set",
+    args: ["key", "value"],
+    replay: (target, args) => {
+      target.env.set(args.key, args.value);
+    }
+  },
+  "env.delete": {
+    namespace: "env",
+    method: "delete",
+    args: ["key"],
+    replay: (target, args) => {
+      target.env.delete(args.key);
+    }
+  },
+  "storage.set": {
+    namespace: "storage",
+    method: "setItem",
+    args: ["key", "value"],
+    replay: (target, args) => {
+      target.storage.setItem(args.key, args.value);
+    }
+  },
+  "storage.delete": {
+    namespace: "storage",
+    method: "removeItem",
+    args: ["key"],
+    replay: (target, args) => {
+      target.storage.removeItem(args.key);
+    }
+  },
+  "storage.clear": {
+    namespace: "storage",
+    method: "clear",
+    args: [],
+    replay: (target) => {
+      target.storage.clear();
+    }
+  }
+};
+function findOp(namespace, method) {
+  for (const [op, config] of Object.entries(opRegistry)) {
+    if (config.namespace === namespace && config.method === method) {
+      return op;
+    }
+  }
+  return;
+}
+function argsToEntry(op, methodArgs) {
+  const config = opRegistry[op];
+  if (!config)
+    return {};
+  const entry = {};
+  config.args.forEach((name, index) => {
+    entry[name] = methodArgs[index];
+  });
+  return entry;
+}
+async function replayStateLog(log, target) {
+  for (const entry of log.getEntries()) {
+    const config = opRegistry[entry.op];
+    if (config) {
+      await config.replay(target, entry.args);
+    }
+  }
+}
+
+class ResourceXError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+
+class ParseError extends ResourceXError {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.url = url;
+    this.name = "ParseError";
+  }
+}
+
+class TransportError extends ResourceXError {
+  transport;
+  constructor(message, transport, options) {
+    super(message, options);
+    this.transport = transport;
+    this.name = "TransportError";
+  }
+}
+
+class SemanticError extends ResourceXError {
+  semantic;
+  constructor(message, semantic, options) {
+    super(message, options);
+    this.semantic = semantic;
+    this.name = "SemanticError";
+  }
+}
+function parseARP(url) {
+  if (!url.startsWith("arp:")) {
+    throw new ParseError(`Invalid ARP URL: must start with "arp:"`, url);
+  }
+  const content = url.substring(4);
+  const separatorIndex = content.indexOf("://");
+  if (separatorIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: missing "://"`, url);
+  }
+  const typePart = content.substring(0, separatorIndex);
+  const location = content.substring(separatorIndex + 3);
+  const colonIndex = typePart.indexOf(":");
+  if (colonIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);
+  }
+  const semantic = typePart.substring(0, colonIndex);
+  const transport = typePart.substring(colonIndex + 1);
+  if (!semantic) {
+    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);
+  }
+  if (!transport) {
+    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);
+  }
+  if (!location) {
+    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);
   }
-  async execute(options) {
-    this.emit("execute:start", options);
+  return { semantic, transport, location };
+}
+
+class HttpTransportHandler {
+  name;
+  protocol;
+  capabilities = {
+    canRead: true,
+    canWrite: false,
+    canList: false,
+    canDelete: false,
+    canStat: false
+  };
+  constructor(protocol = "https") {
+    this.protocol = protocol;
+    this.name = protocol;
+  }
+  async read(location) {
+    const url = `${this.protocol}://${location}`;
     try {
-      const result = await this.runtime.execute(options);
-      this.emit("execute:success", result);
-      return result;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.name);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
     } catch (error) {
-      this.emit("execute:error", error);
-      throw error;
-    } finally {
-      this.emit("execute:complete");
+      if (error instanceof TransportError) {
+        throw error;
+      }
+      throw new TransportError(`Network error: ${url}`, this.name, {
+        cause: error
+      });
     }
   }
-  async writeFile(filePath, data) {
-    return this.fs.write(filePath, data);
+}
+var httpsHandler = new HttpTransportHandler("https");
+var httpHandler = new HttpTransportHandler("http");
+
+class FileTransportHandler {
+  name = "file";
+  capabilities = {
+    canRead: true,
+    canWrite: true,
+    canList: true,
+    canDelete: true,
+    canStat: true
+  };
+  resolvePath(location) {
+    return resolve(process.cwd(), location);
   }
-  async readFile(filePath) {
-    return this.fs.read(filePath);
+  async read(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      return await readFile2(filePath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
   }
-  async destroy() {
-    await this.runtime.cleanup();
-    await this.isolator.destroy();
-    this.eventHandlers.clear();
+  async write(location, content) {
+    const filePath = this.resolvePath(location);
+    try {
+      await mkdir2(dirname2(filePath), { recursive: true });
+      await writeFile2(filePath, content);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File write error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
   }
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, []);
+  async list(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      return await readdir(dirPath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory list error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
     }
-    this.eventHandlers.get(event).push(handler);
   }
-  emit(event, ...args) {
-    const handlers = this.eventHandlers.get(event);
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(...args);
+  async mkdir(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      await mkdir2(dirPath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async exists(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      const stats = await fsStat(filePath);
+      return {
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        isDirectory: stats.isDirectory()
+      };
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File stat error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async delete(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await rm2(filePath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+}
+var fileHandler = new FileTransportHandler;
+function deepracticeHandler(config = {}) {
+  const parentDir = config.parentDir || homedir();
+  const baseDir = join2(parentDir, ".deepractice");
+  function resolvePath(location) {
+    return join2(baseDir, location);
+  }
+  return {
+    name: "deepractice",
+    capabilities: {
+      canRead: true,
+      canWrite: true,
+      canList: true,
+      canDelete: true,
+      canStat: true
+    },
+    async read(location) {
+      const fullPath = resolvePath(location);
+      try {
+        return await readFile22(fullPath);
+      } catch (error) {
+        throw new TransportError(`Failed to read from deepractice: ${error.message}`, "deepractice", { cause: error });
       }
+    },
+    async write(location, content) {
+      const fullPath = resolvePath(location);
+      try {
+        await mkdir22(join2(fullPath, ".."), { recursive: true });
+        await writeFile22(fullPath, content);
+      } catch (error) {
+        throw new TransportError(`Failed to write to deepractice: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async list(location) {
+      const fullPath = resolvePath(location);
+      try {
+        return await readdir2(fullPath);
+      } catch (error) {
+        throw new TransportError(`Failed to list deepractice directory: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async exists(location) {
+      const fullPath = resolvePath(location);
+      try {
+        await access2(fullPath);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async stat(location) {
+      const fullPath = resolvePath(location);
+      try {
+        const stats = await stat(fullPath);
+        return {
+          size: stats.size,
+          isDirectory: stats.isDirectory(),
+          modifiedAt: stats.mtime
+        };
+      } catch (error) {
+        throw new TransportError(`Failed to stat deepractice resource: ${error.message}`, "deepractice", { cause: error });
+      }
+    },
+    async delete(location) {
+      const fullPath = resolvePath(location);
+      try {
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+          await rm22(fullPath, { recursive: true, force: true });
+        } else {
+          await unlink(fullPath);
+        }
+      } catch (error) {
+        throw new TransportError(`Failed to delete from deepractice: ${error.message}`, "deepractice", { cause: error });
+      }
+    }
+  };
+}
+var handlers = new Map([
+  ["https", httpsHandler],
+  ["http", httpHandler],
+  ["file", fileHandler]
+]);
+function getTransportHandler(name) {
+  const handler = handlers.get(name);
+  if (!handler) {
+    throw new TransportError(`Unsupported transport type: ${name}`, name);
+  }
+  return handler;
+}
+function registerTransportHandler(handler) {
+  handlers.set(handler.name, handler);
+}
+
+class TextSemanticHandler {
+  name = "text";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const text = buffer.toString("utf-8");
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "text",
+      content: text,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = Buffer.from(data, "utf-8");
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var textHandler = new TextSemanticHandler;
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (Array.isArray(data)) {
+    return Buffer.from(data);
+  }
+  throw new SemanticError(`Unsupported binary input type`, "binary");
+}
+
+class BinarySemanticHandler {
+  name = "binary";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "binary",
+      content: buffer,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = toBuffer(data);
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
     }
+    await transport.delete(location);
+  }
+}
+var binaryHandler = new BinarySemanticHandler;
+var handlers2 = new Map([
+  ["text", textHandler],
+  ["binary", binaryHandler]
+]);
+function getSemanticHandler(name) {
+  const handler = handlers2.get(name);
+  if (!handler) {
+    throw new SemanticError(`Unsupported semantic type: ${name}`, name);
   }
+  return handler;
+}
+function registerSemanticHandler(handler) {
+  handlers2.set(handler.name, handler);
+}
+function createContext(url, semantic, transport, location) {
+  return {
+    url,
+    semantic,
+    transport,
+    location,
+    timestamp: new Date
+  };
+}
+async function resolve2(url) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  return semantic.resolve(transport, parsed.location, context);
+}
+async function deposit(url, data) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  if (!semantic.deposit) {
+    throw new SemanticError(`Semantic "${semantic.name}" does not support deposit operation`, parsed.semantic);
+  }
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  await semantic.deposit(transport, parsed.location, data, context);
+}
+async function resourceExists(url) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  if (semantic.exists) {
+    return semantic.exists(transport, parsed.location, context);
+  }
+  if (transport.exists) {
+    return transport.exists(parsed.location);
+  }
+  try {
+    await transport.read(parsed.location);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resourceDelete(url) {
+  const parsed = parseARP(url);
+  const transport = getTransportHandler(parsed.transport);
+  const semantic = getSemanticHandler(parsed.semantic);
+  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
+  if (semantic.delete) {
+    return semantic.delete(transport, parsed.location, context);
+  }
+  if (!transport.delete) {
+    throw new SemanticError(`Neither semantic "${semantic.name}" nor transport "${transport.name}" supports delete operation`, parsed.semantic);
+  }
+  await transport.delete(parsed.location);
+}
+function createResourceRegistry() {
+  const registry = new Map;
+  return {
+    register(definition) {
+      if (!/^[a-z][a-z0-9-]*$/.test(definition.name)) {
+        throw new ParseError(`Invalid resource name: "${definition.name}". Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens.`, definition.name);
+      }
+      getSemanticHandler(definition.semantic);
+      getTransportHandler(definition.transport);
+      registry.set(definition.name, definition);
+    },
+    get(name) {
+      return registry.get(name);
+    },
+    has(name) {
+      return registry.has(name);
+    },
+    clear() {
+      registry.clear();
+    }
+  };
+}
+
+class ResourceX {
+  timeout;
+  alias;
+  resourceRegistry;
+  constructor(config = {}) {
+    this.timeout = config.timeout;
+    this.alias = config.alias || "@";
+    this.resourceRegistry = createResourceRegistry();
+    if (config.transports) {
+      for (const handler of config.transports) {
+        registerTransportHandler(handler);
+      }
+    }
+    if (config.semantics) {
+      for (const handler of config.semantics) {
+        registerSemanticHandler(handler);
+      }
+    }
+    if (config.resources) {
+      for (const resource of config.resources) {
+        this.resourceRegistry.register(resource);
+      }
+    }
+  }
+  parseURL(url) {
+    let content;
+    if (url.startsWith("arp:")) {
+      content = url.substring(4);
+    } else if (url.startsWith(this.alias)) {
+      content = url.substring(this.alias.length);
+    } else {
+      throw new ParseError(`Invalid URL prefix: must start with "arp:" or "${this.alias}"`, url);
+    }
+    const separatorIndex = content.indexOf("://");
+    if (separatorIndex === -1) {
+      throw new ParseError(`Invalid URL format: missing "://"`, url);
+    }
+    const beforeSeparator = content.substring(0, separatorIndex);
+    const location = content.substring(separatorIndex + 3);
+    const colonCount = (beforeSeparator.match(/:/g) || []).length;
+    if (colonCount === 1) {
+      const parts = beforeSeparator.split(":");
+      if (parts.length !== 2) {
+        throw new ParseError(`Invalid ARP URL format`, url);
+      }
+      const [semantic, transport] = parts;
+      if (!semantic || !transport || !location) {
+        throw new ParseError(`Invalid ARP URL: semantic, transport, and location are required`, url);
+      }
+      const arpUrl = `arp:${semantic}:${transport}://${location}`;
+      return {
+        arpUrl,
+        parsed: { semantic, transport, location }
+      };
+    }
+    if (colonCount === 0) {
+      const name = beforeSeparator;
+      if (!name || !location) {
+        throw new ParseError(`Invalid Resource URL: name and location are required`, url);
+      }
+      const definition = this.resourceRegistry.get(name);
+      if (!definition) {
+        throw new ParseError(`Unknown resource: "${name}"`, url);
+      }
+      const fullLocation = definition.basePath ? join22(definition.basePath, location) : location;
+      const arpUrl = `arp:${definition.semantic}:${definition.transport}://${fullLocation}`;
+      return {
+        arpUrl,
+        parsed: {
+          semantic: definition.semantic,
+          transport: definition.transport,
+          location: fullLocation
+        }
+      };
+    }
+    throw new ParseError(`Invalid URL format: unexpected colon count in "${beforeSeparator}"`, url);
+  }
+  parse(url) {
+    return this.parseURL(url).parsed;
+  }
+  async resolve(url) {
+    const { arpUrl } = this.parseURL(url);
+    return resolve2(arpUrl);
+  }
+  async deposit(url, data) {
+    const { arpUrl } = this.parseURL(url);
+    return deposit(arpUrl, data);
+  }
+  async exists(url) {
+    const { arpUrl } = this.parseURL(url);
+    return resourceExists(arpUrl);
+  }
+  async delete(url) {
+    const { arpUrl } = this.parseURL(url);
+    return resourceDelete(arpUrl);
+  }
+}
+function createResourceX(config) {
+  return new ResourceX(config);
+}
+
+class MemoryStateStore {
+  logs = new Map;
+  blobs = new Map;
+  entries = new Map;
+  async saveLog(key, data) {
+    this.logs.set(key, data);
+  }
+  async loadLog(key) {
+    const entries = this.entries.get(key);
+    if (entries && entries.length > 0) {
+      return JSON.stringify(entries);
+    }
+    return this.logs.get(key) ?? null;
+  }
+  async deleteLog(key) {
+    this.logs.delete(key);
+    this.entries.delete(key);
+  }
+  async listLogs() {
+    const keys = new Set([...this.logs.keys(), ...this.entries.keys()]);
+    return [...keys];
+  }
+  async saveBlob(ref, data) {
+    this.blobs.set(ref, data);
+  }
+  async loadBlob(ref) {
+    return this.blobs.get(ref) ?? null;
+  }
+  async deleteBlob(ref) {
+    this.blobs.delete(ref);
+  }
+  async appendEntry(sandboxId, entry) {
+    const entries = this.entries.get(sandboxId) ?? [];
+    entries.push(entry);
+    this.entries.set(sandboxId, entries);
+  }
+}
+
+class ResourceXStateStore {
+  rx;
+  basePath;
+  constructor() {
+    this.rx = createResourceX({
+      transports: [deepracticeHandler()]
+    });
+    const os = __require2("os");
+    const path7 = __require2("path");
+    this.basePath = path7.join(os.homedir(), ".deepractice/sandbox");
+  }
+  logUrl(key) {
+    return `@text:deepractice://sandbox/state-logs/${key}.json`;
+  }
+  logPath(sandboxId) {
+    const path7 = __require2("path");
+    return path7.join(this.basePath, "state-logs", `${sandboxId}.jsonl`);
+  }
+  blobUrl(ref) {
+    return `@binary:deepractice://sandbox/blobs/${ref}`;
+  }
+  async saveLog(key, data) {
+    await this.rx.deposit(this.logUrl(key), data);
+  }
+  async loadLog(key) {
+    const fs2 = __require2("fs/promises");
+    const jsonlPath = this.logPath(key);
+    try {
+      const content = await fs2.readFile(jsonlPath, "utf-8");
+      const entries = content.trim().split(`
+`).filter((line) => line).map((line) => JSON.parse(line));
+      return JSON.stringify(entries);
+    } catch {
+      try {
+        const exists = await this.rx.exists(this.logUrl(key));
+        if (!exists)
+          return null;
+        const resource = await this.rx.resolve(this.logUrl(key));
+        return resource.content;
+      } catch {
+        return null;
+      }
+    }
+  }
+  async deleteLog(key) {
+    const fs2 = __require2("fs/promises");
+    try {
+      await fs2.unlink(this.logPath(key));
+    } catch {}
+    try {
+      const exists = await this.rx.exists(this.logUrl(key));
+      if (exists) {
+        await this.rx.delete(this.logUrl(key));
+      }
+    } catch {}
+  }
+  async listLogs() {
+    return [];
+  }
+  async appendEntry(sandboxId, entry) {
+    const fs2 = __require2("fs/promises");
+    const path7 = __require2("path");
+    const filePath = this.logPath(sandboxId);
+    await fs2.mkdir(path7.dirname(filePath), { recursive: true });
+    const line = JSON.stringify(entry) + `
+`;
+    await fs2.appendFile(filePath, line, "utf-8");
+  }
+  async saveBlob(ref, data) {
+    await this.rx.deposit(this.blobUrl(ref), data);
+  }
+  async loadBlob(ref) {
+    try {
+      const exists = await this.rx.exists(this.blobUrl(ref));
+      if (!exists)
+        return null;
+      const resource = await this.rx.resolve(this.blobUrl(ref));
+      return resource.content;
+    } catch {
+      return null;
+    }
+  }
+  async deleteBlob(ref) {
+    try {
+      const exists = await this.rx.exists(this.blobUrl(ref));
+      if (exists) {
+        await this.rx.delete(this.blobUrl(ref));
+      }
+    } catch {}
+  }
+}
+function createStateStore(options) {
+  if (options.type === "memory") {
+    return new MemoryStateStore;
+  }
+  if (options.type === "resourcex") {
+    return new ResourceXStateStore;
+  }
+  throw new Error(`StateStore type "${options.type}" not implemented`);
+}
+function createRecordingProxy(target, namespace, log, onRecord) {
+  return new Proxy(target, {
+    get(obj, prop) {
+      const value = obj[prop];
+      if (typeof value !== "function") {
+        return value;
+      }
+      const method = prop;
+      const op = findOp(namespace, method);
+      if (!op) {
+        return value.bind(obj);
+      }
+      return (...args) => {
+        const result = value.apply(obj, args);
+        const record = () => {
+          const entryArgs = argsToEntry(op, args);
+          log.recordEntry(op, entryArgs);
+          if (onRecord) {
+            onRecord({ op, args: entryArgs });
+          }
+        };
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            record();
+            return res;
+          });
+        } else {
+          record();
+          return result;
+        }
+      };
+    }
+  });
+}
+function createState(options) {
+  const { sandbox, env, enableRecord, store = "resourcex", sandboxId } = options;
+  const baseFS = new StateFS(sandbox);
+  const baseEnv = new StateEnv(env);
+  const baseStorage = new StateStorage;
+  if (!enableRecord) {
+    return {
+      fs: baseFS,
+      env: baseEnv,
+      storage: baseStorage
+    };
+  }
+  const stateLog = buildStateLog();
+  const stateStore = createStateStore({ type: store });
+  const onRecord = (entry) => {
+    stateStore.appendEntry(sandboxId, entry).catch((err) => {
+      console.error(`[SandboX] Failed to persist entry:`, err);
+    });
+  };
+  return {
+    fs: createRecordingProxy(baseFS, "fs", stateLog, onRecord),
+    env: createRecordingProxy(baseEnv, "env", stateLog, onRecord),
+    storage: createRecordingProxy(baseStorage, "storage", stateLog, onRecord),
+    stateLog
+  };
+}
+function generateRef(data) {
+  const hash = createHash("sha256").update(data).digest("hex");
+  return `sha256-${hash}`;
+}
+
+class StateAssetsImpl {
+  sandbox;
+  store;
+  uploadedPaths = new Set;
+  constructor(options) {
+    this.sandbox = options.sandbox;
+    this.store = options.store;
+  }
+  async uploadBuffer(data, remotePath) {
+    const ref = generateRef(data);
+    await this.sandbox.upload(data, remotePath);
+    await this.store.saveBlob(ref, data);
+    this.uploadedPaths.add(remotePath);
+    return ref;
+  }
+  async downloadBuffer(remotePath, options) {
+    const data = await this.sandbox.download(remotePath);
+    if (options?.persist) {
+      const ref = generateRef(data);
+      await this.store.saveBlob(ref, data);
+      return ref;
+    }
+    return data;
+  }
+  list() {
+    return [...this.uploadedPaths];
+  }
+}
+// src/mixins/withState.ts
+function withState(Base) {
+  return class extends Base {
+    fs;
+    env;
+    storage;
+    stateLog;
+    constructor(config) {
+      super(config);
+      const stateConfig = config.state;
+      const state = createState({
+        sandbox: this,
+        env: stateConfig?.env,
+        enableRecord: stateConfig?.enableRecord,
+        store: stateConfig?.store,
+        sandboxId: this.id
+      });
+      this.fs = state.fs;
+      this.env = state.env;
+      this.storage = state.storage;
+      this.stateLog = state.stateLog;
+      if (stateConfig?.initializeLog) {
+        replayStateLog(stateConfig.initializeLog, this);
+      }
+    }
+    getStateLog() {
+      return this.stateLog;
+    }
+  };
+}
+// src/mixins/withNodeExecute.ts
+function withNodeExecute(Base) {
+  return class extends Base {
+    nodeChecked = false;
+    constructor(config) {
+      super(config);
+    }
+    async execute(code) {
+      if (!this.nodeChecked) {
+        const check = await this.shell("which node");
+        if (!check.success) {
+          throw new ExecutionError("Node.js is not installed. Please install Node.js or use a different isolator (cloudflare/e2b).");
+        }
+        this.nodeChecked = true;
+      }
+      const escapedCode = code.replace(/'/g, "'\\''");
+      const result = await this.shell(`node -e '${escapedCode}'`);
+      return {
+        success: result.success,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        executionTime: result.executionTime
+      };
+    }
+  };
+}
+// src/mixins/withPythonExecute.ts
+function withPythonExecute(Base) {
+  return class extends Base {
+    pythonChecked = false;
+    constructor(config) {
+      super(config);
+    }
+    async execute(code) {
+      if (!this.pythonChecked) {
+        const check = await this.shell("which python3");
+        if (!check.success) {
+          throw new ExecutionError("Python 3 is not installed. Please install Python 3 or use a different isolator (cloudflare/e2b).");
+        }
+        this.pythonChecked = true;
+      }
+      const escapedCode = code.replace(/'/g, "'\\''");
+      const result = await this.shell(`python3 -c '${escapedCode}'`);
+      return {
+        success: result.success,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        executionTime: result.executionTime
+      };
+    }
+  };
 }
 export {
+  withState,
+  withPythonExecute,
+  withNodeExecute,
+  loadStateLog,
+  buildStateLog,
   TimeoutError,
+  StateStorage,
+  StateFS,
+  StateError,
+  StateEnv,
   SandboxError,
-  Sandbox,
-  Runtime,
   LocalIsolator,
   Isolator,
   IsolationError,
-  GenericRuntime,
-  FileSystemError,
+  FileSystemError2 as FileSystemError,
   ExecutionError,
-  CloudflareContainerIsolator
+  CloudflareContainerIsolator,
+  BaseSandbox
 };
 
-//# debugId=09D6DD78D2CFDED564756E2164756E21
+//# debugId=09AEF7B255D0477C64756E2164756E21