@sandboxxjs/core 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -8,6 +8,8 @@ interface StateConfig {
 	initializeLog?: StateLog;
 	/** Enable state recording */
 	enableRecord?: boolean;
+	/** Store type (default: resourcex, test: memory) */
+	store?: "resourcex" | "memory";
 }
 interface SandboxConfig {
 	/** Isolator type */
@@ -44,9 +46,11 @@ interface PythonConfig {
 	useVenv?: boolean;
 }
 /**
-* Base Sandbox interface - 4 core APIs
+* Base Sandbox interface - 4 core APIs + ID
 */
 interface Sandbox {
+	/** Unique sandbox ID */
+	readonly id: string;
 	/** Execute shell command */
 	shell(command: string): Promise<ShellResult>;
 	/** Upload file to sandbox */
@@ -125,6 +129,7 @@ declare abstract class Isolator {
 	abstract destroy(): Promise<void>;
 }
 declare class BaseSandbox implements Sandbox {
+	readonly id: string;
 	protected isolator: Isolator;
 	protected config: SandboxConfig;
 	constructor(config: SandboxConfig);

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) {
@@ -7397,9 +7427,11 @@ class CloudflareContainerIsolator extends Isolator {
 
 // src/Sandbox.ts
 class BaseSandbox {
+  id;
   isolator;
   config;
   constructor(config) {
+    this.id = `sandbox-${nanoid()}`;
     this.config = config;
     this.isolator = this.createIsolator(config.isolator);
   }
@@ -7432,9 +7464,15 @@ class BaseSandbox {
   }
 }
 // ../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) {
@@ -7724,57 +7762,6 @@ async function replayStateLog(log, target) {
     }
   }
 }
-function createRecordingProxy(target, namespace, log) {
-  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 (result instanceof Promise) {
-          return result.then((res) => {
-            record();
-            return res;
-          });
-        } else {
-          record();
-          return result;
-        }
-      };
-    }
-  });
-}
-function createState(options) {
-  const { sandbox, env, enableRecord } = 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();
-  return {
-    fs: createRecordingProxy(baseFS, "fs", stateLog),
-    env: createRecordingProxy(baseEnv, "env", stateLog),
-    storage: createRecordingProxy(baseStorage, "storage", stateLog),
-    stateLog
-  };
-}
 
 class ResourceXError extends Error {
   constructor(message, options) {
@@ -7782,6 +7769,16 @@ class ResourceXError extends Error {
     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) {
@@ -7799,6 +7796,35 @@ class SemanticError extends ResourceXError {
     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);
+  }
+  return { semantic, transport, location };
+}
+
 class HttpTransportHandler {
   name;
   protocol;
@@ -7930,11 +7956,99 @@ class FileTransportHandler {
   }
 }
 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) {
@@ -8046,20 +8160,218 @@ 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() {
-    return [...this.logs.keys()];
+    const keys = new Set([...this.logs.keys(), ...this.entries.keys()]);
+    return [...keys];
   }
   async saveBlob(ref, data) {
     this.blobs.set(ref, data);
@@ -8070,6 +8382,172 @@ class MemoryStateStore {
   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");
@@ -8117,7 +8595,9 @@ function withState(Base) {
       const state = createState({
         sandbox: this,
         env: stateConfig?.env,
-        enableRecord: stateConfig?.enableRecord
+        enableRecord: stateConfig?.enableRecord,
+        store: stateConfig?.store,
+        sandboxId: this.id
       });
       this.fs = state.fs;
       this.env = state.env;
@@ -8207,4 +8687,4 @@ export {
   BaseSandbox
 };
 
-//# debugId=7693E135F99AC4E664756E2164756E21
+//# debugId=09AEF7B255D0477C64756E2164756E21