@flue/sdk 0.1.0

package/dist/cloudflare/index.mjs

@@ -0,0 +1,206 @@
+import "../session-BD0MEuO3.mjs";
+import { createSandboxSessionEnv } from "../sandbox.mjs";
+import { Workspace, WorkspaceFileSystem } from "@cloudflare/shell";
+
+//#region src/cloudflare/context.ts
+let currentContext = null;
+function setCloudflareContext(ctx) {
+	currentContext = ctx;
+}
+function getCloudflareContext() {
+	if (!currentContext) throw new Error("[flue:cloudflare] Not running in a Cloudflare context. This function can only be called inside a Cloudflare Worker or Durable Object.");
+	return currentContext;
+}
+function clearCloudflareContext() {
+	currentContext = null;
+}
+
+//#endregion
+//#region src/cloudflare/virtual-sandbox.ts
+/**
+* In-process just-bash sandbox for Cloudflare Workers (no container).
+* Without args: empty in-memory. With R2 bucket: persistent files via DO SQLite + R2.
+*/
+function adaptStat(cfStat) {
+	return {
+		isFile: cfStat.type === "file",
+		isDirectory: cfStat.type === "directory",
+		isSymbolicLink: cfStat.type === "symlink",
+		mode: cfStat.mode ?? (cfStat.type === "directory" ? 493 : 420),
+		size: cfStat.size,
+		mtime: cfStat.mtime
+	};
+}
+function adaptToJustBash(cfFs) {
+	return {
+		readFile: (path, _opts) => cfFs.readFile(path),
+		readFileBuffer: (path) => cfFs.readFileBytes(path),
+		async writeFile(path, content, _opts) {
+			if (typeof content === "string") await cfFs.writeFile(path, content);
+			else await cfFs.writeFileBytes(path, content);
+		},
+		appendFile: (path, content, _opts) => cfFs.appendFile(path, content),
+		exists: (path) => cfFs.exists(path),
+		async stat(path) {
+			return adaptStat(await cfFs.stat(path));
+		},
+		async lstat(path) {
+			return adaptStat(await cfFs.lstat(path));
+		},
+		mkdir: (path, opts) => cfFs.mkdir(path, opts),
+		readdir: (path) => cfFs.readdir(path),
+		async readdirWithFileTypes(path) {
+			return (await cfFs.readdirWithFileTypes(path)).map((e) => ({
+				name: e.name,
+				isFile: e.type === "file",
+				isDirectory: e.type === "directory",
+				isSymbolicLink: e.type === "symlink"
+			}));
+		},
+		rm: (path, opts) => cfFs.rm(path, opts),
+		cp: (src, dest, opts) => cfFs.cp(src, dest, opts),
+		mv: (src, dest) => cfFs.mv(src, dest),
+		resolvePath: (base, path) => cfFs.resolvePath(base, path),
+		getAllPaths: () => [],
+		async chmod(_path, _mode) {},
+		symlink: (target, linkPath) => cfFs.symlink(target, linkPath),
+		async link(existingPath, newPath) {
+			const content = await cfFs.readFileBytes(existingPath);
+			await cfFs.writeFileBytes(newPath, content);
+		},
+		readlink: (path) => cfFs.readlink(path),
+		realpath: (path) => cfFs.realpath(path),
+		async utimes(_path, _atime, _mtime) {}
+	};
+}
+async function getVirtualSandbox(bucket, options) {
+	if (bucket === void 0) {
+		const { Bash, InMemoryFs } = await import(
+			/* @vite-ignore */
+			"just-bash"
+);
+		return new Bash({
+			fs: new InMemoryFs(),
+			network: { dangerouslyAllowFullInternetAccess: true }
+		});
+	}
+	const { storage } = getCloudflareContext();
+	const prefix = options?.prefix ?? "default";
+	const r2Adapter = adaptToJustBash(new WorkspaceFileSystem(new Workspace({
+		sql: storage.sql,
+		r2: bucket,
+		name: () => prefix
+	})));
+	const { Bash, MountableFs, InMemoryFs } = await import(
+		/* @vite-ignore */
+		"just-bash"
+);
+	const fs = new MountableFs({ base: new InMemoryFs() });
+	fs.mount("/workspace", r2Adapter);
+	return new Bash({
+		fs,
+		cwd: "/workspace",
+		network: { dangerouslyAllowFullInternetAccess: true }
+	});
+}
+
+//#endregion
+//#region src/cloudflare/cf-sandbox.ts
+/** Wraps a @cloudflare/sandbox instance (from getSandbox()) into SessionEnv. */
+async function cfSandboxToSessionEnv(sandbox, cwd = "/workspace") {
+	return createSandboxSessionEnv({
+		async readFile(path) {
+			return (await sandbox.readFile(path)).content;
+		},
+		async readFileBuffer(path) {
+			const file = await sandbox.readFile(path, { encoding: "base64" });
+			const binary = atob(file.content);
+			const bytes = new Uint8Array(binary.length);
+			for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+			return bytes;
+		},
+		async writeFile(path, content) {
+			if (typeof content === "string") await sandbox.writeFile(path, content);
+			else {
+				let binary = "";
+				for (let i = 0; i < content.length; i++) binary += String.fromCharCode(content[i]);
+				const b64 = btoa(binary);
+				await sandbox.writeFile(path, b64, { encoding: "base64" });
+			}
+		},
+		async stat(path) {
+			const result = await sandbox.exec(`stat -c '{"size":%s,"isDir":%F}' '${path.replace(/'/g, "'\\''")}'`);
+			if (!result.success) throw new Error(`stat failed for ${path}: ${result.stderr}`);
+			try {
+				const raw = result.stdout.trim();
+				const sizeMatch = raw.match(/"size":(\d+)/);
+				const isDir = raw.includes("directory");
+				return {
+					isFile: !isDir,
+					isDirectory: isDir,
+					isSymbolicLink: false,
+					size: sizeMatch ? parseInt(sizeMatch[1], 10) : 0,
+					mtime: /* @__PURE__ */ new Date()
+				};
+			} catch {
+				throw new Error(`Failed to parse stat output for ${path}: ${result.stdout}`);
+			}
+		},
+		async readdir(path) {
+			const result = await sandbox.exec(`ls -1 '${path.replace(/'/g, "'\\''")}'`);
+			if (!result.success) throw new Error(`readdir failed for ${path}: ${result.stderr}`);
+			return result.stdout.trim().split("\n").filter((s) => s.length > 0);
+		},
+		async exists(path) {
+			return (await sandbox.exists(path)).exists;
+		},
+		async mkdir(path, opts) {
+			await sandbox.mkdir(path, opts);
+		},
+		async rm(path, opts) {
+			if (opts?.recursive || opts?.force) {
+				const flags = [opts.recursive ? "-r" : "", opts.force ? "-f" : ""].filter(Boolean).join("");
+				await sandbox.exec(`rm ${flags} '${path.replace(/'/g, "'\\''")}'`);
+			} else await sandbox.deleteFile(path);
+		},
+		async exec(command, execOpts) {
+			const result = await sandbox.exec(command, {
+				cwd: execOpts?.cwd,
+				env: execOpts?.env
+			});
+			return {
+				stdout: result.stdout ?? "",
+				stderr: result.stderr ?? "",
+				exitCode: result.exitCode ?? (result.success ? 0 : 1)
+			};
+		}
+	}, cwd);
+}
+
+//#endregion
+//#region src/cloudflare/session-store.ts
+function store() {
+	return {
+		async save(_id, data) {
+			const { agentInstance } = getCloudflareContext();
+			agentInstance.setState({
+				...agentInstance.state,
+				sessionData: data
+			});
+		},
+		async load(_id) {
+			const { agentInstance } = getCloudflareContext();
+			return agentInstance.state?.sessionData ?? null;
+		},
+		async delete(_id) {
+			const { agentInstance } = getCloudflareContext();
+			agentInstance.setState({
+				...agentInstance.state,
+				sessionData: null
+			});
+		}
+	};
+}
+
+//#endregion
+export { cfSandboxToSessionEnv, clearCloudflareContext, getCloudflareContext, getVirtualSandbox, setCloudflareContext, store };

package/dist/index.d.mts

@@ -0,0 +1,26 @@
+import { C as ShellOptions, D as TaskOptions, E as SkillOptions, O as ToolDef, S as SessionStore, T as Skill, _ as Role, a as BuildOptions, b as SessionEnv, c as CommandDef, d as FlueContext, f as FlueEvent, g as PromptResponse, h as PromptOptions, i as BuildContext, l as CommandSupport, m as FlueSession, n as AgentInfo, o as BuildPlugin, p as FlueEventCallback, r as BashLike, s as Command, t as AgentConfig, u as FileStat, v as SandboxFactory, w as ShellResult, x as SessionInit, y as SessionData } from "./types-xNvqlohs.mjs";
+import { FlueContextConfig, FlueContextInternal, createFlueContext } from "./client.mjs";
+import { AgentTool } from "@mariozechner/pi-agent-core";
+import "valibot";
+
+//#region src/build.d.ts
+/**
+ * Build a workspace into a deployable artifact.
+ * AGENTS.md and .agents/skills/ are NOT bundled — discovered at runtime from session cwd.
+ */
+declare function build(options: BuildOptions): Promise<void>;
+//#endregion
+//#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
+//#region src/agent.d.ts
+declare const BUILTIN_TOOL_NAMES: Set<string>;
+declare function createTools(env: SessionEnv): AgentTool<any>[];
+//#endregion
+export { type AgentConfig, type AgentInfo, BUILTIN_TOOL_NAMES, type BashLike, type BuildContext, type BuildOptions, type BuildPlugin, type Command, type CommandDef, type CommandSupport, type FileStat, type FlueContext, type FlueContextConfig, type FlueContextInternal, type FlueEvent, type FlueEventCallback, type FlueSession, InMemorySessionStore, type PromptOptions, type PromptResponse, type Role, type SandboxFactory, type SessionData, type SessionEnv, type SessionInit, type SessionStore, type ShellOptions, type ShellResult, type Skill, type SkillOptions, type TaskOptions, type ToolDef, build, createFlueContext, createTools };