silosdk 0.0.0 → 0.0.1

package/dist/cli/kv.cjs

@@ -0,0 +1,63 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_wrangler = require('./wrangler.cjs');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+
+//#region src/cli/kv.ts
+async function runKvCreate() {
+	const dir = require_wrangler.siloDir();
+	console.log("Creating KV namespace SILO_SESSIONS...");
+	const { stdout, code } = await require_wrangler.runWranglerCaptured([
+		"kv",
+		"namespace",
+		"create",
+		"SILO_SESSIONS"
+	]);
+	if (code !== 0) {
+		console.error("Failed to create KV namespace. Check wrangler output above.");
+		process.exit(1);
+	}
+	const match = stdout.match(/"id"\s*:\s*"([a-f0-9]{32})"/) ?? stdout.match(/id\s*=\s*"([a-f0-9]{32})"/) ?? stdout.match(/id[^a-f0-9]*([a-f0-9]{32})/);
+	if (!match) {
+		console.error(`Could not parse KV namespace id from wrangler output.
+Run: silo kv create --id <namespace-id> to set it manually.
+
+Wrangler output:\n${stdout}`);
+		process.exit(1);
+	}
+	const id = match[1];
+	patchWrangler(dir, id);
+	console.log(`KV namespace created (id: ${id}) and patched into wrangler.jsonc`);
+}
+function runKvPatch(id) {
+	patchWrangler(require_wrangler.siloDir(), id);
+	console.log(`Patched wrangler.jsonc with KV namespace id: ${id}`);
+}
+function patchWrangler(dir, id) {
+	const wranglerPath = (0, node_path.resolve)(dir, "wrangler.jsonc");
+	let raw;
+	try {
+		raw = (0, node_fs.readFileSync)(wranglerPath, "utf8");
+	} catch {
+		console.error(`Could not read ${wranglerPath}`);
+		process.exit(1);
+	}
+	const patched = raw.replace(/("binding"\s*:\s*"SILO_SESSIONS"[^}]*"id"\s*:\s*)"[^"]*"/s, `$1"${id}"`);
+	if (patched === raw) {
+		console.warn("Could not find SILO_SESSIONS id placeholder in wrangler.jsonc — edit it manually.");
+		return;
+	}
+	(0, node_fs.writeFileSync)(wranglerPath, patched, "utf8");
+}
+async function runSecretPut(key) {
+	await require_wrangler.runWrangler([
+		"secret",
+		"put",
+		key
+	]);
+}
+
+//#endregion
+exports.runKvCreate = runKvCreate;
+exports.runKvPatch = runKvPatch;
+exports.runSecretPut = runSecretPut;

package/dist/cli/kv.mjs

@@ -0,0 +1,60 @@
+import { runWrangler, runWranglerCaptured, siloDir } from "./wrangler.mjs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+//#region src/cli/kv.ts
+async function runKvCreate() {
+	const dir = siloDir();
+	console.log("Creating KV namespace SILO_SESSIONS...");
+	const { stdout, code } = await runWranglerCaptured([
+		"kv",
+		"namespace",
+		"create",
+		"SILO_SESSIONS"
+	]);
+	if (code !== 0) {
+		console.error("Failed to create KV namespace. Check wrangler output above.");
+		process.exit(1);
+	}
+	const match = stdout.match(/"id"\s*:\s*"([a-f0-9]{32})"/) ?? stdout.match(/id\s*=\s*"([a-f0-9]{32})"/) ?? stdout.match(/id[^a-f0-9]*([a-f0-9]{32})/);
+	if (!match) {
+		console.error(`Could not parse KV namespace id from wrangler output.
+Run: silo kv create --id <namespace-id> to set it manually.
+
+Wrangler output:\n${stdout}`);
+		process.exit(1);
+	}
+	const id = match[1];
+	patchWrangler(dir, id);
+	console.log(`KV namespace created (id: ${id}) and patched into wrangler.jsonc`);
+}
+function runKvPatch(id) {
+	patchWrangler(siloDir(), id);
+	console.log(`Patched wrangler.jsonc with KV namespace id: ${id}`);
+}
+function patchWrangler(dir, id) {
+	const wranglerPath = resolve(dir, "wrangler.jsonc");
+	let raw;
+	try {
+		raw = readFileSync(wranglerPath, "utf8");
+	} catch {
+		console.error(`Could not read ${wranglerPath}`);
+		process.exit(1);
+	}
+	const patched = raw.replace(/("binding"\s*:\s*"SILO_SESSIONS"[^}]*"id"\s*:\s*)"[^"]*"/s, `$1"${id}"`);
+	if (patched === raw) {
+		console.warn("Could not find SILO_SESSIONS id placeholder in wrangler.jsonc — edit it manually.");
+		return;
+	}
+	writeFileSync(wranglerPath, patched, "utf8");
+}
+async function runSecretPut(key) {
+	await runWrangler([
+		"secret",
+		"put",
+		key
+	]);
+}
+
+//#endregion
+export { runKvCreate, runKvPatch, runSecretPut };

package/dist/cli/r2.cjs

@@ -0,0 +1,83 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_wrangler = require('./wrangler.cjs');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+
+//#region src/cli/r2.ts
+async function runR2(args) {
+	const nameFlag = args.indexOf("--name");
+	if (nameFlag !== -1) {
+		const bucketName = args[nameFlag + 1];
+		if (!bucketName) {
+			console.error("Error: --name requires a bucket name");
+			process.exit(1);
+		}
+		runR2Patch(bucketName);
+		return;
+	}
+	await runR2Create();
+}
+async function runR2Create() {
+	const wranglerPath = (0, node_path.resolve)(require_wrangler.siloDir(), "wrangler.jsonc");
+	let source;
+	try {
+		source = (0, node_fs.readFileSync)(wranglerPath, "utf8");
+	} catch {
+		console.error("Error: silo/wrangler.jsonc not found. Run `silo init` first.");
+		process.exit(1);
+	}
+	const bucketName = extractBucketName(source);
+	if (!bucketName) {
+		console.error("Error: Could not determine R2 bucket name from silo/wrangler.jsonc.");
+		console.error("Use: silo r2 create --name <bucket-name> to patch manually.");
+		process.exit(1);
+	}
+	console.log(`Creating R2 bucket: ${bucketName} ...`);
+	try {
+		await require_wrangler.runWrangler([
+			"r2",
+			"bucket",
+			"create",
+			bucketName
+		]);
+	} catch (err) {
+		console.error("wrangler r2 bucket create failed.");
+		process.exit(1);
+	}
+	runR2Patch(bucketName);
+	console.log(`R2 bucket created and patched: ${bucketName}`);
+}
+function runR2Patch(bucketName) {
+	const wranglerPath = (0, node_path.resolve)(require_wrangler.siloDir(), "wrangler.jsonc");
+	let source;
+	try {
+		source = (0, node_fs.readFileSync)(wranglerPath, "utf8");
+	} catch {
+		console.error("Error: silo/wrangler.jsonc not found. Run `silo init` first.");
+		process.exit(1);
+	}
+	const replaced = source.replace(/("binding"\s*:\s*"SILO_STORAGE"[^}]*"bucket_name"\s*:\s*)"[^"]*"/s, `$1"${bucketName}"`);
+	if (replaced !== source) {
+		(0, node_fs.writeFileSync)(wranglerPath, replaced, "utf8");
+		console.log(`Patched silo/wrangler.jsonc with R2 bucket_name = "${bucketName}"`);
+		return;
+	}
+	const insertion = `,\n  "r2_buckets": [\n    {\n      "binding": "SILO_STORAGE",\n      "bucket_name": "${bucketName}"\n    }\n  ]\n`;
+	const lastBrace = source.lastIndexOf("}");
+	if (lastBrace === -1) {
+		console.error("Error: Invalid JSONC in silo/wrangler.jsonc");
+		process.exit(1);
+	}
+	(0, node_fs.writeFileSync)(wranglerPath, source.slice(0, lastBrace) + insertion + source.slice(lastBrace), "utf8");
+	console.log(`Added r2_buckets to silo/wrangler.jsonc with bucket_name = "${bucketName}"`);
+}
+function extractBucketName(source) {
+	const existing = source.match(/"binding"\s*:\s*"SILO_STORAGE"[^}]*"bucket_name"\s*:\s*"([^"]+)"/s)?.[1];
+	if (existing && !existing.startsWith("TODO:")) return existing;
+	const workerName = source.match(/"name"\s*:\s*"([^"]+)"/)?.[1];
+	if (!workerName) return null;
+	return `${workerName}-storage`;
+}
+
+//#endregion
+exports.runR2 = runR2;

package/dist/cli/r2.mjs

@@ -0,0 +1,82 @@
+import { runWrangler, siloDir } from "./wrangler.mjs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+//#region src/cli/r2.ts
+async function runR2(args) {
+	const nameFlag = args.indexOf("--name");
+	if (nameFlag !== -1) {
+		const bucketName = args[nameFlag + 1];
+		if (!bucketName) {
+			console.error("Error: --name requires a bucket name");
+			process.exit(1);
+		}
+		runR2Patch(bucketName);
+		return;
+	}
+	await runR2Create();
+}
+async function runR2Create() {
+	const wranglerPath = resolve(siloDir(), "wrangler.jsonc");
+	let source;
+	try {
+		source = readFileSync(wranglerPath, "utf8");
+	} catch {
+		console.error("Error: silo/wrangler.jsonc not found. Run `silo init` first.");
+		process.exit(1);
+	}
+	const bucketName = extractBucketName(source);
+	if (!bucketName) {
+		console.error("Error: Could not determine R2 bucket name from silo/wrangler.jsonc.");
+		console.error("Use: silo r2 create --name <bucket-name> to patch manually.");
+		process.exit(1);
+	}
+	console.log(`Creating R2 bucket: ${bucketName} ...`);
+	try {
+		await runWrangler([
+			"r2",
+			"bucket",
+			"create",
+			bucketName
+		]);
+	} catch (err) {
+		console.error("wrangler r2 bucket create failed.");
+		process.exit(1);
+	}
+	runR2Patch(bucketName);
+	console.log(`R2 bucket created and patched: ${bucketName}`);
+}
+function runR2Patch(bucketName) {
+	const wranglerPath = resolve(siloDir(), "wrangler.jsonc");
+	let source;
+	try {
+		source = readFileSync(wranglerPath, "utf8");
+	} catch {
+		console.error("Error: silo/wrangler.jsonc not found. Run `silo init` first.");
+		process.exit(1);
+	}
+	const replaced = source.replace(/("binding"\s*:\s*"SILO_STORAGE"[^}]*"bucket_name"\s*:\s*)"[^"]*"/s, `$1"${bucketName}"`);
+	if (replaced !== source) {
+		writeFileSync(wranglerPath, replaced, "utf8");
+		console.log(`Patched silo/wrangler.jsonc with R2 bucket_name = "${bucketName}"`);
+		return;
+	}
+	const insertion = `,\n  "r2_buckets": [\n    {\n      "binding": "SILO_STORAGE",\n      "bucket_name": "${bucketName}"\n    }\n  ]\n`;
+	const lastBrace = source.lastIndexOf("}");
+	if (lastBrace === -1) {
+		console.error("Error: Invalid JSONC in silo/wrangler.jsonc");
+		process.exit(1);
+	}
+	writeFileSync(wranglerPath, source.slice(0, lastBrace) + insertion + source.slice(lastBrace), "utf8");
+	console.log(`Added r2_buckets to silo/wrangler.jsonc with bucket_name = "${bucketName}"`);
+}
+function extractBucketName(source) {
+	const existing = source.match(/"binding"\s*:\s*"SILO_STORAGE"[^}]*"bucket_name"\s*:\s*"([^"]+)"/s)?.[1];
+	if (existing && !existing.startsWith("TODO:")) return existing;
+	const workerName = source.match(/"name"\s*:\s*"([^"]+)"/)?.[1];
+	if (!workerName) return null;
+	return `${workerName}-storage`;
+}
+
+//#endregion
+export { runR2 };

package/dist/cli/wrangler.cjs

@@ -0,0 +1,93 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let node_path = require("node:path");
+let node_child_process = require("node:child_process");
+
+//#region src/cli/wrangler.ts
+/**
+* Resolve the user's project root — the directory that contains the silo/
+* directory. We assume the CLI is run from the project root (cwd).
+*/
+function projectRoot() {
+	return process.cwd();
+}
+/**
+* Absolute path to the user's silo/ directory.
+*/
+function siloDir() {
+	return (0, node_path.resolve)(projectRoot(), "silo");
+}
+/**
+* Absolute path to wrangler.jsonc config file.
+*/
+function wranglerConfigPath() {
+	return (0, node_path.resolve)(siloDir(), "wrangler.jsonc");
+}
+/**
+* Spawn wrangler with the given args, passing absolute config path.
+* Resolves when the process exits 0, rejects on non-zero exit.
+*/
+function runWrangler(args) {
+	return new Promise((resolve$1, reject) => {
+		const child = (0, node_child_process.spawn)("npx", [
+			"wrangler",
+			"--config",
+			wranglerConfigPath(),
+			...args
+		], {
+			cwd: siloDir(),
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", (err) => {
+			reject(/* @__PURE__ */ new Error(`Failed to spawn wrangler: ${err.message}`));
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve$1();
+			else reject(/* @__PURE__ */ new Error(`wrangler exited with code ${code}`));
+		});
+	});
+}
+/**
+* Spawn wrangler with stdout captured (for parsing output).
+* stderr is inherited so the user still sees errors.
+*/
+function runWranglerCaptured(args) {
+	return new Promise((resolve$1) => {
+		const chunks = [];
+		const child = (0, node_child_process.spawn)("npx", [
+			"wrangler",
+			"--config",
+			wranglerConfigPath(),
+			...args
+		], {
+			cwd: siloDir(),
+			stdio: [
+				"inherit",
+				"pipe",
+				"inherit"
+			],
+			shell: process.platform === "win32"
+		});
+		child.stdout?.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		child.on("error", (err) => {
+			resolve$1({
+				stdout: "",
+				code: 1
+			});
+		});
+		child.on("close", (code) => {
+			resolve$1({
+				stdout: Buffer.concat(chunks).toString("utf8"),
+				code: code ?? 1
+			});
+		});
+	});
+}
+
+//#endregion
+exports.projectRoot = projectRoot;
+exports.runWrangler = runWrangler;
+exports.runWranglerCaptured = runWranglerCaptured;
+exports.siloDir = siloDir;

package/dist/cli/wrangler.mjs

@@ -0,0 +1,89 @@
+import { resolve } from "node:path";
+import { spawn } from "node:child_process";
+
+//#region src/cli/wrangler.ts
+/**
+* Resolve the user's project root — the directory that contains the silo/
+* directory. We assume the CLI is run from the project root (cwd).
+*/
+function projectRoot() {
+	return process.cwd();
+}
+/**
+* Absolute path to the user's silo/ directory.
+*/
+function siloDir() {
+	return resolve(projectRoot(), "silo");
+}
+/**
+* Absolute path to wrangler.jsonc config file.
+*/
+function wranglerConfigPath() {
+	return resolve(siloDir(), "wrangler.jsonc");
+}
+/**
+* Spawn wrangler with the given args, passing absolute config path.
+* Resolves when the process exits 0, rejects on non-zero exit.
+*/
+function runWrangler(args) {
+	return new Promise((resolve$1, reject) => {
+		const child = spawn("npx", [
+			"wrangler",
+			"--config",
+			wranglerConfigPath(),
+			...args
+		], {
+			cwd: siloDir(),
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", (err) => {
+			reject(/* @__PURE__ */ new Error(`Failed to spawn wrangler: ${err.message}`));
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve$1();
+			else reject(/* @__PURE__ */ new Error(`wrangler exited with code ${code}`));
+		});
+	});
+}
+/**
+* Spawn wrangler with stdout captured (for parsing output).
+* stderr is inherited so the user still sees errors.
+*/
+function runWranglerCaptured(args) {
+	return new Promise((resolve$1) => {
+		const chunks = [];
+		const child = spawn("npx", [
+			"wrangler",
+			"--config",
+			wranglerConfigPath(),
+			...args
+		], {
+			cwd: siloDir(),
+			stdio: [
+				"inherit",
+				"pipe",
+				"inherit"
+			],
+			shell: process.platform === "win32"
+		});
+		child.stdout?.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		child.on("error", (err) => {
+			resolve$1({
+				stdout: "",
+				code: 1
+			});
+		});
+		child.on("close", (code) => {
+			resolve$1({
+				stdout: Buffer.concat(chunks).toString("utf8"),
+				code: code ?? 1
+			});
+		});
+	});
+}
+
+//#endregion
+export { projectRoot, runWrangler, runWranglerCaptured, siloDir };

package/dist/local/adapters/cloudflare.cjs

@@ -0,0 +1,200 @@
+const require_sync = require('../sync.cjs');
+
+//#region src/local/adapters/cloudflare.ts
+const INITIAL_BACKOFF = 1e3;
+const MAX_BACKOFF = 3e4;
+const SYNC_RETRY_WINDOW_MS = 3e4;
+const SYNC_MAX_RETRIES = 5;
+var CloudflareSyncAdapter = class extends require_sync.SyncAdapter {
+	constructor(options) {
+		super({ merge: options.merge });
+		this.ws = null;
+		this.reconnectTimer = null;
+		this.backoff = INITIAL_BACKOFF;
+		this.alive = true;
+		this.registeredViews = [];
+		this.failureCount = 0;
+		this.firstFailureAt = 0;
+		this.blocked = false;
+		this.warned = false;
+		this.ignoreClose = false;
+		this.pendingCommits = /* @__PURE__ */ new Map();
+		this.url = options.url;
+		this.getToken = options.getToken;
+		this.db = options.db;
+		this.subscribers = options.subscribers;
+	}
+	/** Register the view names this adapter should subscribe to on connect. */
+	registerViews(names) {
+		this.registeredViews = names;
+	}
+	async connect() {
+		if (!this.alive) return;
+		if (this.blocked) return;
+		try {
+			const wsUrl = this.url.replace(/^https?/, (m) => m === "https" ? "wss" : "ws");
+			const token = this.getToken ? await this.getToken() : null;
+			if (this.getToken && !token) return;
+			const url = token ? `${wsUrl}/sync?token=${encodeURIComponent(token)}` : `${wsUrl}/sync`;
+			this.ws = new WebSocket(url);
+			this.ws.onopen = () => {
+				this.backoff = INITIAL_BACKOFF;
+				if (this.registeredViews.length > 0) this.ws.send(JSON.stringify({
+					type: "subscribe",
+					views: this.registeredViews
+				}));
+			};
+			this.ws.onmessage = async (event) => {
+				const msg = JSON.parse(event.data);
+				await this.handleMessage(msg);
+			};
+			this.ws.onclose = () => {
+				if (this.ignoreClose) {
+					this.ignoreClose = false;
+					return;
+				}
+				if (this.alive) this.scheduleReconnect();
+			};
+			this.ws.onerror = () => {
+				this.ws?.close();
+			};
+		} catch {
+			if (this.alive) this.scheduleReconnect();
+		}
+	}
+	async handleMessage(msg) {
+		switch (msg.type) {
+			case "hydrate": {
+				const ops = (msg.rows ?? []).map((row) => ({
+					kind: "add",
+					view: { name: msg.view },
+					id: row.id,
+					value: row.data,
+					version: row.version ?? 1,
+					timestamp: row.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+				}));
+				if (ops.length > 0) await require_sync.applyRemoteOps(this.db, ops, this.subscribers, this.merge);
+				break;
+			}
+			case "push": {
+				const ops = msg.ops ?? [];
+				if (ops.length > 0) await require_sync.applyRemoteOps(this.db, ops, this.subscribers, this.merge);
+				break;
+			}
+			case "committed": {
+				const pending = this.pendingCommits.get(msg.requestId);
+				if (pending) {
+					pending.resolve();
+					this.pendingCommits.delete(msg.requestId);
+				}
+				break;
+			}
+			case "rejected": {
+				const pending = this.pendingCommits.get(msg.requestId);
+				if (pending) {
+					pending.reject(msg.reason ?? "Rejected by server");
+					this.pendingCommits.delete(msg.requestId);
+				}
+				break;
+			}
+			case "error":
+				console.error("[CloudflareSyncAdapter] server error:", msg.message);
+				break;
+		}
+		if (msg.type === "push" && this.receiveHandler) await this.receiveHandler({ ops: msg.ops ?? [] });
+	}
+	scheduleReconnect() {
+		this.recordFailure();
+		if (this.blocked) return;
+		if (this.reconnectTimer) return;
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF);
+			this.connect();
+		}, this.backoff);
+	}
+	recordFailure() {
+		const now = Date.now();
+		if (!this.firstFailureAt || now - this.firstFailureAt > SYNC_RETRY_WINDOW_MS) {
+			this.firstFailureAt = now;
+			this.failureCount = 0;
+		}
+		this.failureCount += 1;
+		if (this.failureCount > SYNC_MAX_RETRIES) {
+			this.blocked = true;
+			if (!this.warned) {
+				this.warned = true;
+				console.warn("[CloudflareSyncAdapter] Retry budget exceeded, blocking reconnects");
+			}
+		}
+	}
+	resetConnection() {
+		this.blocked = false;
+		this.warned = false;
+		this.failureCount = 0;
+		this.firstFailureAt = 0;
+		this.backoff = INITIAL_BACKOFF;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.ws) {
+			this.ignoreClose = true;
+			this.ws.close();
+			this.ws = null;
+		}
+		this.connect();
+	}
+	async send(payload) {
+		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+		const requestId = Math.random().toString(36).slice(2);
+		return new Promise((resolve, reject) => {
+			this.pendingCommits.set(requestId, {
+				resolve,
+				reject
+			});
+			this.ws.send(JSON.stringify({
+				type: "commit",
+				ops: payload.ops,
+				requestId
+			}));
+			setTimeout(() => {
+				if (this.pendingCommits.has(requestId)) {
+					this.pendingCommits.delete(requestId);
+					resolve();
+				}
+			}, 1e4);
+		});
+	}
+	onReceive(handler) {
+		this.receiveHandler = handler;
+	}
+	async fetchInitialState() {
+		return null;
+	}
+	disconnect() {
+		this.alive = false;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.ws?.close();
+		this.ws = null;
+	}
+	/**
+	* Reset backoff and force an immediate reconnect.
+	* Used after token changes (e.g. elevation from anonymous to authenticated).
+	*/
+	forceReconnect() {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.backoff = INITIAL_BACKOFF;
+		if (this.ws) this.ws.close();
+		else this.connect();
+	}
+};
+
+//#endregion
+exports.CloudflareSyncAdapter = CloudflareSyncAdapter;