@flue/sdk 0.1.0

package/dist/sandbox.d.mts

@@ -0,0 +1,28 @@
+import { b as SessionEnv, c as CommandDef, r as BashLike, u as FileStat, v as SandboxFactory, w as ShellResult } from "./types-xNvqlohs.mjs";
+
+//#region src/sandbox.d.ts
+declare function bashToSessionEnv(bash: BashLike): SessionEnv;
+/** Interface that remote sandbox providers must implement. */
+interface SandboxApi {
+  readFile(path: string): Promise<string>;
+  readFileBuffer(path: string): Promise<Uint8Array>;
+  writeFile(path: string, content: string | Uint8Array): Promise<void>;
+  stat(path: string): Promise<FileStat>;
+  readdir(path: string): Promise<string[]>;
+  exists(path: string): Promise<boolean>;
+  mkdir(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  rm(path: string, options?: {
+    recursive?: boolean;
+    force?: boolean;
+  }): Promise<void>;
+  exec(command: string, options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+  }): 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;
+//#endregion
+export { type CommandDef, type FileStat, SandboxApi, type SandboxFactory, type SessionEnv, bashToSessionEnv, createSandboxSessionEnv };

package/dist/sandbox.mjs

@@ -0,0 +1,101 @@
+import { r as normalizePath } from "./session-BD0MEuO3.mjs";
+
+//#region src/sandbox.ts
+function bashToSessionEnv(bash) {
+	const fs = bash.fs;
+	const cwd = bash.getCwd();
+	const resolve = (p) => p.startsWith("/") ? p : fs.resolvePath(cwd, p);
+	let commandSupport;
+	if (typeof bash.registerCommand === "function") {
+		const registerCommand = bash.registerCommand.bind(bash);
+		commandSupport = {
+			register(cmd) {
+				registerCommand({
+					name: cmd.name,
+					execute: cmd.execute
+				});
+			},
+			unregister(name) {
+				registerCommand({
+					name,
+					execute: async () => ({
+						stdout: "",
+						stderr: name + ": command not available (not registered for this call)",
+						exitCode: 127
+					})
+				});
+			}
+		};
+	}
+	return {
+		exec: (cmd, opts) => bash.exec(cmd, opts),
+		readFile: (p) => fs.readFile(resolve(p)),
+		readFileBuffer: (p) => fs.readFileBuffer(resolve(p)),
+		writeFile: async (p, content) => {
+			const resolved = resolve(p);
+			const dir = resolved.replace(/\/[^/]*$/, "");
+			if (dir && dir !== resolved) try {
+				await fs.mkdir(dir, { recursive: true });
+			} catch {}
+			await fs.writeFile(resolved, content);
+		},
+		stat: (p) => fs.stat(resolve(p)),
+		readdir: (p) => fs.readdir(resolve(p)),
+		exists: (p) => fs.exists(resolve(p)),
+		mkdir: (p, o) => fs.mkdir(resolve(p), o),
+		rm: (p, o) => fs.rm(resolve(p), o),
+		cwd,
+		resolvePath: resolve,
+		commandSupport,
+		cleanup: async () => {}
+	};
+}
+/** Wrap a SandboxApi into SessionEnv. No just-bash, no intermediate filesystem layer. */
+function createSandboxSessionEnv(api, cwd, cleanup) {
+	const resolvePath = (p) => {
+		if (p.startsWith("/")) return normalizePath(p);
+		if (cwd === "/") return normalizePath("/" + p);
+		return normalizePath(cwd + "/" + p);
+	};
+	return {
+		async exec(command, options) {
+			return api.exec(command, {
+				cwd: options?.cwd ?? cwd,
+				env: options?.env
+			});
+		},
+		async readFile(path) {
+			return api.readFile(resolvePath(path));
+		},
+		async readFileBuffer(path) {
+			return api.readFileBuffer(resolvePath(path));
+		},
+		async writeFile(path, content) {
+			return api.writeFile(resolvePath(path), content);
+		},
+		async stat(path) {
+			return api.stat(resolvePath(path));
+		},
+		async readdir(path) {
+			return api.readdir(resolvePath(path));
+		},
+		async exists(path) {
+			return api.exists(resolvePath(path));
+		},
+		async mkdir(path, options) {
+			return api.mkdir(resolvePath(path), options);
+		},
+		async rm(path, options) {
+			return api.rm(resolvePath(path), options);
+		},
+		cwd,
+		resolvePath,
+		commandSupport: void 0,
+		async cleanup() {
+			if (cleanup) await cleanup();
+		}
+	};
+}
+
+//#endregion
+export { bashToSessionEnv, createSandboxSessionEnv };