@flue/sdk 0.3.11 → 0.4.1

package/dist/sandbox.d.mts

@@ -1,9 +1,29 @@
-import { A as ShellResult, E as SessionEnv, d as FileStat, i as BashFactory, u as CommandDef, w as SandboxFactory } from "./types-DGpyKMFm.mjs";
+import { E as SandboxFactory, M as ShellResult, O as SessionEnv, h as FlueFs, i as BashFactory, u as FileStat } from "./types-BAmV4f3Q.mjs";
 
 //#region src/sandbox.d.ts
+/** Adapt a SessionEnv to the public FlueFs surface. */
+declare function createFlueFs(env: SessionEnv): FlueFs;
 declare function createCwdSessionEnv(parentEnv: SessionEnv, cwd: string): SessionEnv;
 declare function bashFactoryToSessionEnv(factory: BashFactory): Promise<SessionEnv>;
-/** Interface that remote sandbox providers must implement. */
+/**
+ * Interface that remote sandbox providers must implement.
+ *
+ * `exec()` cancellation is expressed two ways. Connectors should honor at
+ * least one — preferably `timeout`, since most provider SDKs expose a
+ * native timeout option but few support mid-flight cancellation:
+ *
+ *   - `timeout?: number` (seconds): the **primary** cancellation contract.
+ *     Forward to the provider's native timeout option (E2B `timeoutMs`,
+ *     Daytona `timeout`, Modal `timeout`, etc.). Required for parity with
+ *     the LLM bash tool, which always passes a `timeout` hint when the
+ *     model requests one.
+ *   - `signal?: AbortSignal` (optional): for connectors whose SDK supports
+ *     mid-flight cancellation (Mirage's executor, in-process bash). Lets
+ *     SDK callers do ad-hoc `abort()`. Connectors that can't honor it
+ *     should ignore it; the deadline is still enforced via `timeout`.
+ *
+ * Connectors that support both should observe whichever fires first.
+ */
 interface SandboxApi {
   readFile(path: string): Promise<string>;
   readFileBuffer(path: string): Promise<Uint8Array>;
@@ -22,9 +42,10 @@ interface SandboxApi {
     cwd?: string;
     env?: Record<string, string>;
     timeout?: number;
+    signal?: AbortSignal;
   }): Promise<ShellResult>;
 }
 /** Wrap a SandboxApi into SessionEnv. No just-bash, no intermediate filesystem layer. */
-declare function createSandboxSessionEnv(api: SandboxApi, cwd: string, cleanup?: () => Promise<void>): SessionEnv;
+declare function createSandboxSessionEnv(api: SandboxApi, cwd: string): SessionEnv;
 //#endregion
-export { type CommandDef, type FileStat, SandboxApi, type SandboxFactory, type SessionEnv, bashFactoryToSessionEnv, createCwdSessionEnv, createSandboxSessionEnv };
+export { type FileStat, SandboxApi, type SandboxFactory, type SessionEnv, bashFactoryToSessionEnv, createCwdSessionEnv, createFlueFs, createSandboxSessionEnv };

package/dist/sandbox.mjs

@@ -1,7 +1,22 @@
-import "./agent-Cahthgu3.mjs";
-import { i as normalizePath, o as createScopedEnv } from "./session-DlwIt7wq.mjs";
+import "./result-K1IRhWKM.mjs";
+import "./providers-DeFRIwp0.mjs";
+import { t as abortErrorFor } from "./abort-Bg3qsAkU.mjs";
+import { i as normalizePath } from "./session-CFOByKnM.mjs";
 
 //#region src/sandbox.ts
+/** Adapt a SessionEnv to the public FlueFs surface. */
+function createFlueFs(env) {
+	return {
+		readFile: (path) => env.readFile(path),
+		readFileBuffer: (path) => env.readFileBuffer(path),
+		writeFile: (path, content) => env.writeFile(path, content),
+		stat: (path) => env.stat(path),
+		readdir: (path) => env.readdir(path),
+		exists: (path) => env.exists(path),
+		mkdir: (path, options) => env.mkdir(path, options),
+		rm: (path, options) => env.rm(path, options)
+	};
+}
 function createCwdSessionEnv(parentEnv, cwd) {
 	const scopedCwd = normalizePath(cwd);
 	const resolvePath = (p) => {
@@ -13,9 +28,9 @@ function createCwdSessionEnv(parentEnv, cwd) {
 		exec: (cmd, opts) => parentEnv.exec(cmd, {
 			cwd: opts?.cwd ?? scopedCwd,
 			env: opts?.env,
-			timeout: opts?.timeout
+			timeout: opts?.timeout,
+			signal: opts?.signal
 		}),
-		scope: async (options) => createCwdSessionEnv(await createScopedEnv(parentEnv, options?.commands ?? []), scopedCwd),
 		readFile: (p) => parentEnv.readFile(resolvePath(p)),
 		readFileBuffer: (p) => parentEnv.readFileBuffer(resolvePath(p)),
 		writeFile: (p, c) => parentEnv.writeFile(resolvePath(p), c),
@@ -25,57 +40,31 @@ function createCwdSessionEnv(parentEnv, cwd) {
 		mkdir: (p, o) => parentEnv.mkdir(resolvePath(p), o),
 		rm: (p, o) => parentEnv.rm(resolvePath(p), o),
 		cwd: scopedCwd,
-		resolvePath,
-		cleanup: () => parentEnv.cleanup()
+		resolvePath
 	};
 }
 async function bashFactoryToSessionEnv(factory) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	async function createBash() {
-		const bash = await factory();
-		assertBashLike(bash);
-		if (seen.has(bash)) throw new Error("[flue] BashFactory must return a fresh Bash-like instance for each operation. Share the filesystem object in the factory closure to persist files across calls.");
-		seen.add(bash);
-		return bash;
-	}
-	async function createBashScopedEnv(commands) {
-		const scoped = await createBash();
-		registerCommands(scoped, commands);
-		return createBashSessionEnv(scoped, createBashScopedEnv);
-	}
-	return createBashSessionEnv(await createBash(), createBashScopedEnv);
+	const bash = await factory();
+	assertBashLike(bash);
+	return createBashSessionEnv(bash);
 }
-function createBashSessionEnv(bash, createScope) {
+function createBashSessionEnv(bash) {
 	const fs = bash.fs;
 	const cwd = bash.getCwd();
 	const resolve = (p) => p.startsWith("/") ? p : fs.resolvePath(cwd, p);
 	return {
 		exec: async (cmd, opts) => {
 			const exec = bash.exec;
-			const timeout = opts?.timeout;
-			let timeoutSignal;
-			let timer;
-			if (typeof timeout === "number") {
-				const controller = new AbortController();
-				timeoutSignal = controller.signal;
-				timer = setTimeout(() => controller.abort(), timeout * 1e3);
-			}
-			try {
-				const result = await exec.call(bash, cmd, opts ? {
-					cwd: opts.cwd,
-					env: opts.env,
-					signal: timeoutSignal
-				} : void 0);
-				if (timeoutSignal?.aborted) return {
-					...result,
-					stderr: result.stderr || `[flue] Command timed out after ${timeout} seconds.`
-				};
-				return result;
-			} finally {
-				if (timer) clearTimeout(timer);
-			}
+			const timeoutSignal = typeof opts?.timeout === "number" ? AbortSignal.timeout(opts.timeout * 1e3) : void 0;
+			const mergedSignal = opts?.signal && timeoutSignal ? AbortSignal.any([opts.signal, timeoutSignal]) : opts?.signal ?? timeoutSignal;
+			const result = await exec.call(bash, cmd, opts ? {
+				cwd: opts.cwd,
+				env: opts.env,
+				signal: mergedSignal
+			} : void 0);
+			if (opts?.signal?.aborted) throw abortErrorFor(opts.signal);
+			return result;
 		},
-		scope: (options) => createScope(options?.commands ?? []),
 		readFile: (p) => fs.readFile(resolve(p)),
 		readFileBuffer: (p) => fs.readFileBuffer(resolve(p)),
 		writeFile: async (p, content) => {
@@ -92,23 +81,14 @@ function createBashSessionEnv(bash, createScope) {
 		mkdir: (p, o) => fs.mkdir(resolve(p), o),
 		rm: (p, o) => fs.rm(resolve(p), o),
 		cwd,
-		resolvePath: resolve,
-		cleanup: async () => {}
+		resolvePath: resolve
 	};
 }
-function registerCommands(bash, commands) {
-	if (commands.length === 0) return;
-	if (typeof bash.registerCommand !== "function") throw new Error("[flue] Cannot use commands: this Bash-like sandbox does not support command registration.");
-	for (const cmd of commands) bash.registerCommand({
-		name: cmd.name,
-		execute: cmd.execute
-	});
-}
 function assertBashLike(value) {
 	if (typeof value !== "object" || value === null || !("exec" in value) || !("getCwd" in value) || !("fs" in value) || typeof value.exec !== "function" || typeof value.getCwd !== "function" || typeof value.fs !== "object") throw new Error("[flue] BashFactory must return a Bash-like object.");
 }
 /** Wrap a SandboxApi into SessionEnv. No just-bash, no intermediate filesystem layer. */
-function createSandboxSessionEnv(api, cwd, cleanup) {
+function createSandboxSessionEnv(api, cwd) {
 	const resolvePath = (p) => {
 		if (p.startsWith("/")) return normalizePath(p);
 		if (cwd === "/") return normalizePath("/" + p);
@@ -116,11 +96,16 @@ function createSandboxSessionEnv(api, cwd, cleanup) {
 	};
 	return {
 		async exec(command, options) {
-			return api.exec(command, {
+			const signal = options?.signal;
+			if (signal?.aborted) throw abortErrorFor(signal);
+			const result = await api.exec(command, {
 				cwd: options?.cwd ?? cwd,
 				env: options?.env,
-				timeout: options?.timeout
+				timeout: options?.timeout,
+				signal
 			});
+			if (signal?.aborted) throw abortErrorFor(signal);
+			return result;
 		},
 		async readFile(path) {
 			return api.readFile(resolvePath(path));
@@ -147,12 +132,9 @@ function createSandboxSessionEnv(api, cwd, cleanup) {
 			return api.rm(resolvePath(path), options);
 		},
 		cwd,
-		resolvePath,
-		async cleanup() {
-			if (cleanup) await cleanup();
-		}
+		resolvePath
 	};
 }
 
 //#endregion
-export { bashFactoryToSessionEnv, createCwdSessionEnv, createSandboxSessionEnv };
+export { bashFactoryToSessionEnv, createCwdSessionEnv, createFlueFs, createSandboxSessionEnv };