@drej/flue 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { SandboxFactory } from "@flue/runtime";
+import { Sandbox } from "drej";
+
+//#region src/index.d.ts
+/**
+ * Flue `SandboxFactory` backed by a drej `Sandbox`.
+ *
+ * Pass an already-created `Sandbox` (lifecycle is the caller's responsibility —
+ * the adapter never calls `sb.close()`). Returns a factory suitable for
+ * Flue's `sandbox` agent option.
+ *
+ * @example
+ * ```ts
+ * // src/sandboxes/drej.ts  (Flue adapter file)
+ * import { drej } from "@drej/flue";
+ * import { Drej } from "drej";
+ * import { SQLiteAdapter } from "@drej/sqlite";
+ *
+ * const client = new Drej({ baseUrl: "http://localhost:8080", adapter: new SQLiteAdapter("./drej.db") });
+ *
+ * export default drej(
+ *   await client.sandbox({ image: "node:22", resources: { cpu: "500m", memory: "256Mi" } }),
+ * );
+ * ```
+ */
+declare function drej(sandbox: Sandbox, opts?: {
+  cwd?: string;
+}): SandboxFactory;
+//#endregion
+export { drej };

package/dist/index.mjs

@@ -0,0 +1,113 @@
+import { createSandboxSessionEnv } from "@flue/runtime";
+//#region src/index.ts
+function esc(p) {
+	return `'${p.replace(/'/g, "'\\''")}'`;
+}
+function rejectAfter(ms) {
+	return new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`exec timed out after ${ms}ms`)), ms));
+}
+function uint8ToBase64(buf) {
+	let binary = "";
+	for (let i = 0; i < buf.length; i++) binary += String.fromCharCode(buf[i]);
+	return btoa(binary);
+}
+function base64ToUint8(b64) {
+	const binary = atob(b64);
+	const buf = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
+	return buf;
+}
+var DrejSandboxApi = class {
+	sb;
+	constructor(sb) {
+		this.sb = sb;
+	}
+	async exec(command, opts) {
+		const run = Promise.resolve(this.sb.exec(command, {
+			cwd: opts?.cwd,
+			env: opts?.env,
+			strict: false
+		}));
+		if (opts?.timeoutMs == null) return run;
+		return Promise.race([run, rejectAfter(Math.ceil(opts.timeoutMs))]);
+	}
+	readFile(path) {
+		return this.sb.readFile(path);
+	}
+	async readFileBuffer(path) {
+		const { stdout } = await this.sb.exec(`base64 -w0 ${esc(path)}`);
+		return base64ToUint8(stdout.trim());
+	}
+	/**
+	* Write a file into the sandbox.
+	*
+	* When `content` is a `Uint8Array`, the bytes are base64-encoded and piped
+	* through `base64 -d` in the container. This relies on the shell `ARG_MAX`
+	* limit (~2 MB on Linux), so binary writes are capped at roughly **1.5 MB**.
+	* For larger binary files, write via string (pre-encoded) or split writes.
+	*/
+	async writeFile(path, content) {
+		if (typeof content === "string") {
+			await this.sb.writeFile(path, content);
+			return;
+		}
+		const b64 = uint8ToBase64(content);
+		await this.sb.exec(`echo '${b64}' | base64 -d > ${esc(path)}`);
+	}
+	async stat(path) {
+		const { stdout, exitCode } = await this.sb.exec(`stat -c '%F|%s|%Y' ${esc(path)}`, { strict: false });
+		if (exitCode !== 0) throw new Error(`stat: cannot stat '${path}': No such file or directory`);
+		const [typeStr, sizeStr, mtimeStr] = stdout.trim().split("|");
+		return {
+			isFile: typeStr === "regular file",
+			isDirectory: typeStr === "directory",
+			isSymbolicLink: typeStr === "symbolic link",
+			size: parseInt(sizeStr, 10),
+			mtime: /* @__PURE__ */ new Date(parseInt(mtimeStr, 10) * 1e3)
+		};
+	}
+	async readdir(path) {
+		const entries = await this.sb.listDirectory(path, { depth: 1 });
+		const prefix = (path.endsWith("/") ? path.slice(0, -1) : path) + "/";
+		return entries.filter((e) => e.path.startsWith(prefix) && !e.path.slice(prefix.length).includes("/")).map((e) => e.path.slice(prefix.length)).filter(Boolean);
+	}
+	async exists(path) {
+		const { exitCode } = await this.sb.exec(`test -e ${esc(path)}`, { strict: false });
+		return exitCode === 0;
+	}
+	async mkdir(path, opts) {
+		await this.sb.exec(`mkdir ${opts?.recursive ? "-p " : ""}${esc(path)}`);
+	}
+	async rm(path, opts) {
+		const flags = [opts?.recursive && "-r", opts?.force && "-f"].filter(Boolean).join(" ");
+		await this.sb.exec(`rm ${flags ? flags + " " : ""}${esc(path)}`);
+	}
+};
+/**
+* Flue `SandboxFactory` backed by a drej `Sandbox`.
+*
+* Pass an already-created `Sandbox` (lifecycle is the caller's responsibility —
+* the adapter never calls `sb.close()`). Returns a factory suitable for
+* Flue's `sandbox` agent option.
+*
+* @example
+* ```ts
+* // src/sandboxes/drej.ts  (Flue adapter file)
+* import { drej } from "@drej/flue";
+* import { Drej } from "drej";
+* import { SQLiteAdapter } from "@drej/sqlite";
+*
+* const client = new Drej({ baseUrl: "http://localhost:8080", adapter: new SQLiteAdapter("./drej.db") });
+*
+* export default drej(
+*   await client.sandbox({ image: "node:22", resources: { cpu: "500m", memory: "256Mi" } }),
+* );
+* ```
+*/
+function drej(sandbox, opts) {
+	return { async createSessionEnv(_) {
+		return createSandboxSessionEnv(new DrejSandboxApi(sandbox), opts?.cwd ?? "/");
+	} };
+}
+//#endregion
+export { drej };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@drej/flue",
+  "version": "1.0.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@flue/runtime": "1.0.0-beta.3",
+    "bun-types": "1.3.14",
+    "drej": "workspace:*",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3"
+  },
+  "peerDependencies": {
+    "@flue/runtime": ">=1.0.0-beta",
+    "drej": ">=0.8.0"
+  }
+}