@flue/sdk 0.2.0 → 0.3.0

package/dist/internal.d.mts

@@ -1,15 +0,0 @@
-import { S as SessionStore, y as SessionData } from "./types-C0nqbu6Z.mjs";
-import { FlueContextConfig, FlueContextInternal, createFlueContext } from "./client.mjs";
-import { bashToSessionEnv } from "./sandbox.mjs";
-import "valibot";
-
-//#region src/session.d.ts
-/** In-memory session store. Sessions persist for the lifetime of the process. */
-declare class InMemorySessionStore implements SessionStore {
-  private store;
-  save(id: string, data: SessionData): Promise<void>;
-  load(id: string): Promise<SessionData | null>;
-  delete(id: string): Promise<void>;
-}
-//#endregion
-export { type FlueContextConfig, type FlueContextInternal, InMemorySessionStore, bashToSessionEnv, createFlueContext };

package/dist/internal.mjs

@@ -1,6 +0,0 @@
-import "./agent-BYG0nVbQ.mjs";
-import { t as InMemorySessionStore } from "./session-CiAMTsLZ.mjs";
-import { bashToSessionEnv } from "./sandbox.mjs";
-import { createFlueContext } from "./client.mjs";
-
-export { InMemorySessionStore, bashToSessionEnv, createFlueContext };

package/dist/node/index.d.mts

@@ -1,14 +0,0 @@
-import { s as Command } from "../types-C0nqbu6Z.mjs";
-import { t as CommandExecutor } from "../command-helpers-C8SHLdaA.mjs";
-import { execFile } from "node:child_process";
-
-//#region src/node/define-command.d.ts
-/**
- * Options forwarded directly to Node's `child_process.execFile`. Full pass-through.
- */
-type CommandOptions = NonNullable<Parameters<typeof execFile>[2]>;
-declare function defineCommand(name: string): Command;
-declare function defineCommand(name: string, options: CommandOptions): Command;
-declare function defineCommand(name: string, execute: CommandExecutor): Command;
-//#endregion
-export { type CommandOptions, defineCommand };

package/dist/node/index.mjs

@@ -1,75 +0,0 @@
-import { t as normalizeExecutor } from "../command-helpers-CxRhK1my.mjs";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-//#region src/node/define-command.ts
-/**
-* Node-specific `defineCommand`. Supports three forms:
-*
-* ```ts
-* defineCommand('agent-browser');
-* defineCommand('gh', { env: { GH_TOKEN: process.env.GH_TOKEN } });
-* defineCommand('gh', async (args) => ({ stdout: '...' }));
-* ```
-*
-* Forms A and B shell out via `child_process.execFile`. Form C lets the user
-* implement the command however they like. All three forms benefit from
-* return-shape normalization and throw-catching — no `try`/`catch` or
-* `return { stdout, stderr, exitCode: 0 }` boilerplate required.
-*/
-const execFileAsync = promisify(execFile);
-/**
-* Essential, non-sensitive environment variables automatically forwarded to
-* pass-through commands (forms A and B). Users can override any of these —
-* or add their own (e.g. `GH_TOKEN`) — via `options.env`. Anything not listed
-* here (API keys, tokens, secrets, etc.) stays on the host and is NEVER
-* exposed to the spawned process unless the caller opts in explicitly.
-*
-* If you need full control over the env, use the function form:
-* `defineCommand('gh', async (args) => { ... })`.
-*/
-const DEFAULT_ENV = {
-	PATH: process.env.PATH,
-	HOME: process.env.HOME,
-	USER: process.env.USER,
-	LOGNAME: process.env.LOGNAME,
-	HOSTNAME: process.env.HOSTNAME,
-	SHELL: process.env.SHELL,
-	LANG: process.env.LANG,
-	LC_ALL: process.env.LC_ALL,
-	LC_CTYPE: process.env.LC_CTYPE,
-	TZ: process.env.TZ,
-	TERM: process.env.TERM,
-	TMPDIR: process.env.TMPDIR,
-	TMP: process.env.TMP,
-	TEMP: process.env.TEMP
-};
-function defineCommand(name, arg) {
-	if (typeof arg === "function") return {
-		name,
-		execute: normalizeExecutor(arg)
-	};
-	const userOpts = arg ?? {};
-	const mergedOpts = {
-		maxBuffer: 50 * 1024 * 1024,
-		...userOpts,
-		env: {
-			...DEFAULT_ENV,
-			...userOpts.env ?? {}
-		}
-	};
-	const executor = async (args) => {
-		const { stdout, stderr } = await execFileAsync(name, args, mergedOpts);
-		return {
-			stdout: String(stdout ?? ""),
-			stderr: String(stderr ?? "")
-		};
-	};
-	return {
-		name,
-		execute: normalizeExecutor(executor)
-	};
-}
-
-//#endregion
-export { defineCommand };

package/dist/sandbox.d.mts

@@ -1,28 +0,0 @@
-import { b as SessionEnv, c as CommandDef, r as BashLike, u as FileStat, v as SandboxFactory, w as ShellResult } from "./types-C0nqbu6Z.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

@@ -1,102 +0,0 @@
-import "./agent-BYG0nVbQ.mjs";
-import { r as normalizePath } from "./session-CiAMTsLZ.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 };