@stablemodels/durable-bash 0.1.0

package/tests/integration.test.ts

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { DurableFs } from "../src/durable-fs.js";
+import type { FsObject } from "../src/fs-object.js";
+import { createDirectStub, createTestFsObject } from "./helpers.js";
+
+let fs: DurableFs;
+let obj: FsObject;
+
+beforeEach(async () => {
+	const result = await createTestFsObject();
+	obj = result.obj;
+	const stub = createDirectStub(obj);
+	fs = new DurableFs(stub, "/home");
+	await fs.sync();
+});
+
+describe("integration: DurableFs + FsObject", () => {
+	test("create, read, list cycle", async () => {
+		await fs.writeFile("hello.txt", "world");
+		const content = await fs.readFile("hello.txt");
+		expect(content).toBe("world");
+
+		const entries = await fs.readdir("/home");
+		expect(entries).toContain("hello.txt");
+	});
+
+	test("nested directory tree", async () => {
+		await fs.mkdir("a/b/c", { recursive: true });
+		await fs.writeFile("a/b/c/deep.txt", "deep");
+
+		const aEntries = await fs.readdir("/home/a");
+		expect(aEntries).toEqual(["b"]);
+
+		const bEntries = await fs.readdir("/home/a/b");
+		expect(bEntries).toEqual(["c"]);
+
+		const cEntries = await fs.readdir("/home/a/b/c");
+		expect(cEntries).toEqual(["deep.txt"]);
+
+		const content = await fs.readFile("a/b/c/deep.txt");
+		expect(content).toBe("deep");
+	});
+
+	test("overwrite preserves directory structure", async () => {
+		await fs.writeFile("dir/file.txt", "first");
+		await fs.writeFile("dir/file.txt", "second");
+
+		const content = await fs.readFile("dir/file.txt");
+		expect(content).toBe("second");
+
+		// Parent dir still exists
+		expect(await fs.exists("/home/dir")).toBe(true);
+		const stat = await fs.stat("/home/dir");
+		expect(stat.isDirectory).toBe(true);
+	});
+
+	test("rm -rf on tree", async () => {
+		await fs.writeFile("tree/a.txt", "a");
+		await fs.writeFile("tree/sub/b.txt", "b");
+		await fs.writeFile("tree/sub/deep/c.txt", "c");
+
+		await fs.rm("tree", { recursive: true });
+
+		expect(await fs.exists("/home/tree")).toBe(false);
+		expect(await fs.exists("/home/tree/a.txt")).toBe(false);
+		expect(await fs.exists("/home/tree/sub/b.txt")).toBe(false);
+	});
+
+	test("symlink chain", async () => {
+		await fs.writeFile("actual.txt", "real content");
+		await fs.symlink("/home/actual.txt", "link1.txt");
+		await fs.symlink("/home/link1.txt", "link2.txt");
+
+		// Reading through chain of symlinks
+		const content = await fs.readFile("link2.txt");
+		expect(content).toBe("real content");
+
+		// lstat sees symlink
+		const lstat = await fs.lstat("link2.txt");
+		expect(lstat.isSymbolicLink).toBe(true);
+
+		// stat follows symlinks
+		const stat = await fs.stat("link2.txt");
+		expect(stat.isFile).toBe(true);
+		expect(stat.isSymbolicLink).toBe(false);
+	});
+
+	test("concurrent writes to different files", async () => {
+		await Promise.all([
+			fs.writeFile("file1.txt", "content1"),
+			fs.writeFile("file2.txt", "content2"),
+			fs.writeFile("file3.txt", "content3"),
+		]);
+
+		expect(await fs.readFile("file1.txt")).toBe("content1");
+		expect(await fs.readFile("file2.txt")).toBe("content2");
+		expect(await fs.readFile("file3.txt")).toBe("content3");
+	});
+
+	test("stat returns correct FsStat shape", async () => {
+		await fs.writeFile("file.txt", "hello");
+		const stat = await fs.stat("file.txt");
+
+		expect(stat.isFile).toBe(true);
+		expect(stat.isDirectory).toBe(false);
+		expect(stat.isSymbolicLink).toBe(false);
+		expect(stat.size).toBe(5);
+		expect(stat.mode).toBe(0o644);
+		expect(stat.mtime).toBeInstanceOf(Date);
+	});
+
+	test("readdirWithFileTypes returns DirentEntry shape", async () => {
+		await fs.writeFile("dir/file.txt", "data");
+		await fs.mkdir("dir/subdir");
+
+		const entries = await fs.readdirWithFileTypes("/home/dir");
+		expect(entries).toHaveLength(2);
+
+		const file = entries.find((e) => e.name === "file.txt")!;
+		expect(file.isFile).toBe(true);
+		expect(file.isDirectory).toBe(false);
+		expect(file.isSymbolicLink).toBe(false);
+
+		const dir = entries.find((e) => e.name === "subdir")!;
+		expect(dir.isFile).toBe(false);
+		expect(dir.isDirectory).toBe(true);
+	});
+
+	test("getAllPaths reflects writes", async () => {
+		await fs.writeFile("new.txt", "data");
+		const paths = fs.getAllPaths();
+		expect(paths).toContain("/home/new.txt");
+	});
+
+	test("copy file end-to-end", async () => {
+		await fs.writeFile("original.txt", "copy me");
+		await fs.cp("original.txt", "copied.txt");
+		expect(await fs.readFile("copied.txt")).toBe("copy me");
+		expect(await fs.readFile("original.txt")).toBe("copy me");
+	});
+
+	test("move file end-to-end", async () => {
+		await fs.writeFile("before.txt", "moving");
+		await fs.mv("before.txt", "after.txt");
+		expect(await fs.exists("/home/before.txt")).toBe(false);
+		expect(await fs.readFile("after.txt")).toBe("moving");
+	});
+
+	test("append creates and appends", async () => {
+		await fs.appendFile("log.txt", "line1\n");
+		await fs.appendFile("log.txt", "line2\n");
+		expect(await fs.readFile("log.txt")).toBe("line1\nline2\n");
+	});
+
+	test("chmod changes permissions", async () => {
+		await fs.writeFile("script.sh", "#!/bin/sh");
+		await fs.chmod("script.sh", 0o755);
+		const stat = await fs.stat("script.sh");
+		expect(stat.mode).toBe(0o755);
+	});
+
+	test("utimes changes mtime", async () => {
+		await fs.writeFile("file.txt", "data");
+		const mtime = new Date(1700000000000);
+		await fs.utimes("file.txt", mtime, mtime);
+		const stat = await fs.stat("file.txt");
+		expect(stat.mtime.getTime()).toBe(1700000000000);
+	});
+
+	test("hard link shares content", async () => {
+		await fs.writeFile("original.txt", "shared");
+		await fs.link("original.txt", "linked.txt");
+		expect(await fs.readFile("linked.txt")).toBe("shared");
+	});
+
+	test("realpath resolves symlinks", async () => {
+		await fs.writeFile("real.txt", "data");
+		await fs.symlink("/home/real.txt", "alias.txt");
+		const resolved = await fs.realpath("alias.txt");
+		expect(resolved).toBe("/home/real.txt");
+	});
+
+	test("binary file roundtrip", async () => {
+		const binary = new Uint8Array([0, 1, 127, 128, 255]);
+		await fs.writeFile("binary.bin", binary);
+		const result = await fs.readFileBuffer("binary.bin");
+		expect(result).toEqual(binary);
+	});
+});

package/tests/just-bash.test.ts

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { Bash } from "just-bash";
+import { DurableFs } from "../src/durable-fs.js";
+import { createDirectStub, createTestFsObject } from "./helpers.js";
+
+let bash: Bash;
+
+beforeEach(async () => {
+	const { obj } = await createTestFsObject();
+	const stub = createDirectStub(obj);
+	const fs = new DurableFs(stub, "/home");
+	await fs.sync();
+	bash = new Bash({ fs: fs as never, cwd: "/home" });
+});
+
+describe("just-bash smoke tests with DurableFs", () => {
+	test('echo "hello" > file.txt && cat file.txt', async () => {
+		const result = await bash.exec('echo "hello" > file.txt && cat file.txt');
+		expect(result.stdout.trim()).toBe("hello");
+		expect(result.exitCode).toBe(0);
+	});
+
+	test("mkdir -p a/b/c && ls a/b", async () => {
+		await bash.exec("mkdir -p a/b/c");
+		const result = await bash.exec("ls a/b");
+		expect(result.stdout.trim()).toBe("c");
+		expect(result.exitCode).toBe(0);
+	});
+
+	test("cp file.txt copy.txt && cat copy.txt", async () => {
+		await bash.exec('echo "original" > file.txt');
+		await bash.exec("cp file.txt copy.txt");
+		const result = await bash.exec("cat copy.txt");
+		expect(result.stdout.trim()).toBe("original");
+	});
+
+	test("append with >>", async () => {
+		await bash.exec('echo "line1" > f.txt');
+		await bash.exec('echo "line2" >> f.txt');
+		const result = await bash.exec("cat f.txt");
+		expect(result.stdout).toContain("line1");
+		expect(result.stdout).toContain("line2");
+	});
+
+	test("rm -rf removes directory tree", async () => {
+		await bash.exec("mkdir -p /tmp/test/sub");
+		await bash.exec('echo "data" > /tmp/test/sub/file.txt');
+		await bash.exec("rm -rf /tmp/test");
+		const result = await bash.exec("ls /tmp/test 2>&1; echo $?");
+		// Should fail since /tmp/test was removed
+		expect(result.stdout).toContain("2");
+	});
+
+	test("pwd reflects cwd option", async () => {
+		const result = await bash.exec("pwd");
+		expect(result.stdout.trim()).toBe("/home");
+	});
+
+	test("write and read binary-safe through hex", async () => {
+		await bash.exec('printf "hello\\nworld" > multi.txt');
+		const result = await bash.exec("cat multi.txt");
+		expect(result.stdout).toContain("hello");
+		expect(result.stdout).toContain("world");
+	});
+
+	test("mv renames file", async () => {
+		await bash.exec('echo "moveme" > old.txt');
+		await bash.exec("mv old.txt new.txt");
+		const result = await bash.exec("cat new.txt");
+		expect(result.stdout.trim()).toBe("moveme");
+
+		// old file should be gone
+		const check = await bash.exec("cat old.txt 2>/dev/null");
+		expect(check.exitCode).not.toBe(0);
+	});
+
+	test("multiple commands in sequence", async () => {
+		const result = await bash.exec(`
+			mkdir -p project/src
+			echo 'console.log("hi")' > project/src/index.js
+			cat project/src/index.js
+		`);
+		expect(result.stdout).toContain('console.log("hi")');
+	});
+});

package/tests/setup.ts

@@ -0,0 +1,14 @@
+// This file must be imported (via preload) before any test files.
+// It mocks cloudflare:workers so FsObject can be imported in tests.
+import { mock } from "bun:test";
+
+mock.module("cloudflare:workers", () => ({
+	DurableObject: class DurableObject {
+		ctx: unknown;
+		env: unknown;
+		constructor(ctx: unknown, env: unknown) {
+			this.ctx = ctx;
+			this.env = env;
+		}
+	},
+}));

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ES2022",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"outDir": "dist",
+		"rootDir": "src",
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"types": ["@cloudflare/workers-types"]
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["node_modules", "dist", "tests"]
+}

package/wrangler.toml

@@ -0,0 +1,13 @@
+# Example wrangler.toml — consumers should add these bindings to their own config.
+# This file is provided as a reference.
+
+name = "durable-bash-example"
+compatibility_date = "2025-03-01"
+
+[[durable_objects.bindings]]
+name = "FS"
+class_name = "FsObject"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["FsObject"]