syncorejs 0.2.3 → 0.2.5

package/dist/_vendor/core/cli.mjs

@@ -4,7 +4,8 @@ import { SyncoreRuntime } from "./runtime/runtime.mjs";
 import { createDevtoolsCommandHandler, createDevtoolsSubscriptionHost } from "./runtime/devtools.mjs";
 import { src_exports } from "./index.mjs";
 import { generateDevtoolsToken, isAllowedDashboardOrigin, isAuthorizedDashboardRequest, sanitizeDevtoolsToken } from "./devtools-auth.mjs";
-import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { connect } from "node:net";
 import path from "node:path";
@@ -36,6 +37,9 @@ const VALID_SYNCORE_TEMPLATES = [
 let pendingDevBootstrap;
 let devBootstrapInFlight = false;
 const PROJECT_TARGET_RUNTIME_ID = "syncore-project-target";
+const STORAGE_ACCESS_TICKET_TTL_MS = 300 * 1e3;
+const STORAGE_ACCESS_CHUNK_BYTES = 1024 * 1024;
+const STORAGE_ACCESS_MAX_PREVIEW_BYTES = 8e4;
 program.name("syncorejs").description("Syncore local-first toolkit CLI").version("0.1.0");
 program.command("init").description("Scaffold Syncore in the current directory").option("--template <template>", `Template to scaffold (${VALID_SYNCORE_TEMPLATES.join(", ")}, or auto)`, "auto").option("--force", "Overwrite Syncore-managed files when they already exist").action(async (options) => {
 	const cwd = process.cwd();
@@ -1161,6 +1165,19 @@ var HubFileStorageAdapter = class {
 			return null;
 		}
 	}
+	async readRange(id, offset, length) {
+		let handle;
+		try {
+			handle = await open(this.filePath(id), "r");
+			const buffer = Buffer.alloc(Math.max(length, 0));
+			const result = await handle.read(buffer, 0, buffer.byteLength, Math.max(offset, 0));
+			return buffer.subarray(0, result.bytesRead);
+		} catch {
+			return null;
+		} finally {
+			await handle?.close();
+		}
+	}
 	async delete(id) {
 		await rm(this.filePath(id), { force: true });
 	}
@@ -1252,6 +1269,11 @@ async function createProjectTargetBackend(cwd, externalChangeSignal) {
 		driver,
 		storage: new HubFileStorageAdapter(storageDirectory),
 		platform: "project",
+		runtimeCapabilities: { storage: {
+			available: true,
+			protocol: "file",
+			supportsRange: true
+		} },
 		...externalChangeSignal ? { externalChangeSignal } : {}
 	});
 	await runtime.start();
@@ -1310,6 +1332,13 @@ function createProjectDevtoolsCapabilities() {
 			mutate: true,
 			importExport: true
 		},
+		storage: {
+			browse: true,
+			download: true,
+			readRange: true,
+			delete: true,
+			maxPreviewBytes: 8e4
+		},
 		scheduler: {
 			read: true,
 			edit: true
@@ -1493,18 +1522,22 @@ async function startDevHub(options) {
 	await runDevProjectBootstrap(options.cwd, options.template);
 	await setupDevProjectWatch(options.cwd, options.template);
 	if (await isLocalPortInUse(devtoolsPort)) {
+		const activeSessionState = await readDevtoolsSessionState(options.cwd) ?? sessionState;
 		console.log(`Syncore devtools hub already running at ws://localhost:${devtoolsPort}. Reusing existing hub/dashboard.`);
-		return await readDevtoolsSessionState(options.cwd) ?? sessionState;
+		console.log(`Devtools dashboard token: ${activeSessionState.token}`);
+		console.log(`Dashboard shell: ${activeSessionState.authenticatedDashboardUrl}`);
+		return activeSessionState;
 	}
 	await writeDevtoolsSessionState(options.cwd, sessionState);
-	const httpServer = createServer((_request, response) => {
-		response.writeHead(200, { "content-type": "application/json" });
-		response.end(JSON.stringify({
-			ok: true,
-			wsPort: devtoolsPort
-		}));
+	const httpServer = createServer((request, response) => {
+		handleStorageAccessHttpRequest(request, response).catch((error) => {
+			if (!response.headersSent) writeJsonResponse(response, 500, { error: formatError(error) });
+			else response.destroy(error instanceof Error ? error : void 0);
+		});
 	});
 	const websocketServer = new WebSocketServer({ server: httpServer });
+	const storageAccessTickets = /* @__PURE__ */ new Map();
+	const pendingHubCommands = /* @__PURE__ */ new Map();
 	const runtimeSockets = /* @__PURE__ */ new Map();
 	const runtimeHellos = /* @__PURE__ */ new Map();
 	const runtimeEvents = /* @__PURE__ */ new Map();
@@ -1571,6 +1604,135 @@ async function startDevHub(options) {
 			event
 		})}\n`);
 	};
+	const requestRuntimeCommand = async (targetRuntimeId, payload, timeoutMs = 3e4) => {
+		if (targetRuntimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) return projectTargetBackend.handleCommand(payload);
+		const target = runtimeSockets.get(targetRuntimeId);
+		if (!target || target.readyState !== WebSocket.OPEN) throw new Error(`Runtime ${targetRuntimeId} is not connected.`);
+		const commandId = `hub:${randomUUID()}`;
+		return await new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				pendingHubCommands.delete(commandId);
+				reject(/* @__PURE__ */ new Error(`Runtime command ${payload.kind} timed out.`));
+			}, timeoutMs);
+			pendingHubCommands.set(commandId, {
+				resolve,
+				reject,
+				timeout
+			});
+			target.send(JSON.stringify({
+				type: "command",
+				commandId,
+				targetRuntimeId,
+				payload
+			}));
+		});
+	};
+	const createStorageAccessTicket = async (targetRuntimeId, id, purpose) => {
+		const metadata = await requestRuntimeCommand(targetRuntimeId, {
+			kind: "storage.readRange",
+			id,
+			offset: 0,
+			length: 0
+		});
+		if (metadata.kind !== "storage.readRange.result") return {
+			kind: "storage.access.create.result",
+			error: "Runtime returned an unexpected storage access response."
+		};
+		if (metadata.error || !metadata.entry) return {
+			kind: "storage.access.create.result",
+			error: metadata.error ?? "Storage object could not be accessed."
+		};
+		const ticket = randomUUID();
+		const expiresAt = Date.now() + STORAGE_ACCESS_TICKET_TTL_MS;
+		storageAccessTickets.set(ticket, {
+			id: ticket,
+			runtimeId: targetRuntimeId,
+			storageId: id,
+			purpose,
+			entry: metadata.entry,
+			supportsRange: metadata.supportsRange,
+			expiresAt
+		});
+		cleanupExpiredStorageTickets();
+		return {
+			kind: "storage.access.create.result",
+			entry: metadata.entry,
+			url: `http://127.0.0.1:${devtoolsPort}/storage/access/${ticket}`,
+			expiresAt,
+			supportsRange: metadata.supportsRange,
+			maxPreviewBytes: STORAGE_ACCESS_MAX_PREVIEW_BYTES
+		};
+	};
+	const cleanupExpiredStorageTickets = () => {
+		const now = Date.now();
+		for (const [ticket, access] of storageAccessTickets) if (access.expiresAt <= now) storageAccessTickets.delete(ticket);
+	};
+	const handleStorageAccessHttpRequest = async (request, response) => {
+		setStorageCorsHeaders(response);
+		if (request.method === "OPTIONS") {
+			response.writeHead(204);
+			response.end();
+			return;
+		}
+		const requestUrl = new URL(request.url ?? "/", `http://127.0.0.1:${devtoolsPort}`);
+		const match = /^\/storage\/access\/([^/]+)$/.exec(requestUrl.pathname);
+		if (!match) {
+			writeJsonResponse(response, 200, {
+				ok: true,
+				wsPort: devtoolsPort
+			});
+			return;
+		}
+		if (request.method !== "GET" && request.method !== "HEAD") {
+			writeTextResponse(response, 405, "Method not allowed.");
+			return;
+		}
+		cleanupExpiredStorageTickets();
+		const ticket = storageAccessTickets.get(match[1]);
+		if (!ticket || ticket.expiresAt <= Date.now()) {
+			writeTextResponse(response, 401, "Storage access ticket is invalid or expired.");
+			return;
+		}
+		const range = parseStorageRangeHeader(request.headers.range, ticket.entry.size);
+		if ("error" in range) {
+			writeTextResponse(response, range.status, range.error);
+			return;
+		}
+		const start = range.start;
+		const end = range.end;
+		const byteLength = end >= start ? end - start + 1 : 0;
+		if (!ticket.supportsRange && ticket.entry.size > STORAGE_ACCESS_CHUNK_BYTES) {
+			writeTextResponse(response, 409, "This storage backend does not support streaming large files.");
+			return;
+		}
+		writeStorageAccessHeaders(response, ticket, {
+			status: range.partial ? 206 : 200,
+			start,
+			end,
+			byteLength
+		});
+		if (request.method === "HEAD") {
+			response.end();
+			return;
+		}
+		let offset = start;
+		while (offset <= end) {
+			const chunkLength = Math.min(STORAGE_ACCESS_CHUNK_BYTES, end - offset + 1);
+			const chunk = await requestRuntimeCommand(ticket.runtimeId, {
+				kind: "storage.readRange",
+				id: ticket.storageId,
+				offset,
+				length: chunkLength
+			}, 6e4);
+			if (chunk.kind !== "storage.readRange.result") throw new Error("Runtime returned an unexpected storage chunk response.");
+			if (chunk.error || !chunk.base64) throw new Error(chunk.error ?? "Storage chunk could not be read.");
+			const bytes = Buffer.from(chunk.base64, "base64");
+			if (bytes.byteLength === 0) break;
+			await writeResponseChunk(response, bytes);
+			offset += bytes.byteLength;
+		}
+		response.end();
+	};
 	websocketServer.on("connection", (socket, request) => {
 		const isBrowserDashboardClient = isAllowedDashboardOrigin(request.headers.origin, dashboardPort);
 		const isAuthorizedDashboardClient = !isBrowserDashboardClient || isAuthorizedDashboardRequest({
@@ -1616,6 +1778,29 @@ async function startDevHub(options) {
 				if (!isAuthorizedDashboardClient) return;
 				const targetRuntimeId = message.targetRuntimeId;
 				if (!targetRuntimeId) return;
+				if (message.payload.kind === "storage.access.create") {
+					createStorageAccessTicket(targetRuntimeId, message.payload.id, message.payload.purpose).then((payload) => {
+						if (socket.readyState !== WebSocket.OPEN) return;
+						socket.send(JSON.stringify({
+							type: "command.result",
+							commandId: message.commandId,
+							runtimeId: targetRuntimeId,
+							payload
+						}));
+					}).catch((error) => {
+						if (socket.readyState !== WebSocket.OPEN) return;
+						socket.send(JSON.stringify({
+							type: "command.result",
+							commandId: message.commandId,
+							runtimeId: targetRuntimeId,
+							payload: {
+								kind: "storage.access.create.result",
+								error: formatError(error)
+							}
+						}));
+					});
+					return;
+				}
 				if (targetRuntimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
 					(async () => {
 						const payload = await projectTargetBackend.handleCommand(message.payload);
@@ -1719,6 +1904,15 @@ async function startDevHub(options) {
 				appendHubLog(message.event);
 			} else if (message.type === "event") appendHubLog(message.event);
 			if (message.type === "command.result" || message.type === "subscription.data" || message.type === "subscription.error") {
+				if (message.type === "command.result") {
+					const pending = pendingHubCommands.get(message.commandId);
+					if (pending) {
+						clearTimeout(pending.timeout);
+						pendingHubCommands.delete(message.commandId);
+						pending.resolve(message.payload);
+						return;
+					}
+				}
 				for (const client of dashboardSockets) if (client.readyState === WebSocket.OPEN) client.send(encoded);
 				return;
 			}
@@ -1787,19 +1981,18 @@ async function startDevHub(options) {
 	console.log(`Electron/Node runtimes: set devtoolsUrl to ws://localhost:${devtoolsPort}.`);
 	console.log(`Web/Next apps: connect the dashboard or worker bridge to ws://localhost:${devtoolsPort}.`);
 	console.log("Expo apps: use the same hub URL through LAN or adb reverse while developing.");
-	const dashboardRoot = path.resolve(CORE_PACKAGE_ROOT, "..", "..", "apps", "dashboard");
-	if (await fileExists(path.join(dashboardRoot, "vite.config.ts"))) try {
-		await (await (await import("vite")).createServer({
-			configFile: path.join(dashboardRoot, "vite.config.ts"),
-			root: dashboardRoot,
-			server: { port: dashboardPort }
-		})).listen();
+	let dashboardStaticServer;
+	const dashboardStaticRoot = await resolvePackagedDashboardRoot();
+	if (!dashboardStaticRoot) throw new Error("Syncore Dashboard build is missing. Expected the packaged dashboard at syncorejs/dist/_dashboard/index.html. Rebuild syncorejs before running `syncorejs dev`.");
+	try {
+		dashboardStaticServer = await startPackagedDashboardServer(dashboardStaticRoot, dashboardPort);
 		console.log(`Dashboard shell: ${sessionState.authenticatedDashboardUrl}`);
 	} catch (error) {
-		console.log(`Dashboard source not started automatically: ${formatError(error)}`);
+		throw new Error(`Syncore Dashboard shell could not start: ${formatError(error)}`, { cause: error });
 	}
 	const close = () => {
 		projectTargetBackend?.dispose();
+		dashboardStaticServer?.close();
 		websocketServer.close();
 		httpServer.close();
 		process.exit(0);
@@ -1808,6 +2001,155 @@ async function startDevHub(options) {
 	process.on("SIGTERM", close);
 	return sessionState;
 }
+async function resolvePackagedDashboardRoot() {
+	const candidates = [
+		path.resolve(CORE_PACKAGE_ROOT, "..", "_dashboard"),
+		path.resolve(CORE_PACKAGE_ROOT, "_dashboard"),
+		path.resolve(CORE_PACKAGE_ROOT, "..", "syncore", "dist", "_dashboard")
+	];
+	for (const candidate of candidates) if (await fileExists(path.join(candidate, "index.html"))) return candidate;
+	return null;
+}
+async function startPackagedDashboardServer(root, port) {
+	const server = createServer((request, response) => {
+		serveDashboardAsset(root, request, response).catch((error) => {
+			if (!response.headersSent) writeTextResponse(response, 500, formatError(error));
+			else response.destroy(error instanceof Error ? error : void 0);
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, "127.0.0.1", () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	return server;
+}
+async function serveDashboardAsset(root, request, response) {
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		writeTextResponse(response, 405, "Method not allowed.");
+		return;
+	}
+	const requestUrl = new URL(request.url ?? "/", "http://127.0.0.1");
+	const requestedPath = decodeURIComponent(requestUrl.pathname);
+	const relativePath = requestedPath === "/" ? "index.html" : requestedPath.slice(1);
+	let assetPath = path.resolve(root, relativePath);
+	if (!isPathInside(root, assetPath)) {
+		writeTextResponse(response, 403, "Forbidden.");
+		return;
+	}
+	try {
+		if ((await stat(assetPath)).isDirectory()) assetPath = path.join(assetPath, "index.html");
+	} catch {
+		assetPath = path.join(root, "index.html");
+	}
+	if (!isPathInside(root, assetPath)) {
+		writeTextResponse(response, 403, "Forbidden.");
+		return;
+	}
+	const body = await readFile(assetPath);
+	response.writeHead(200, {
+		"Content-Type": getDashboardAssetContentType(assetPath),
+		"Content-Length": body.byteLength
+	});
+	if (request.method === "HEAD") {
+		response.end();
+		return;
+	}
+	response.end(body);
+}
+function isPathInside(root, candidate) {
+	const relative = path.relative(root, candidate);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function getDashboardAssetContentType(filePath) {
+	switch (path.extname(filePath)) {
+		case ".html": return "text/html; charset=utf-8";
+		case ".js": return "text/javascript; charset=utf-8";
+		case ".css": return "text/css; charset=utf-8";
+		case ".json": return "application/json; charset=utf-8";
+		case ".svg": return "image/svg+xml";
+		case ".png": return "image/png";
+		case ".ico": return "image/x-icon";
+		case ".woff2": return "font/woff2";
+		default: return "application/octet-stream";
+	}
+}
+function setStorageCorsHeaders(response) {
+	response.setHeader("Access-Control-Allow-Origin", "*");
+	response.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+	response.setHeader("Access-Control-Allow-Headers", "Range");
+	response.setHeader("Access-Control-Expose-Headers", "Accept-Ranges, Content-Disposition, Content-Length, Content-Range, Content-Type");
+}
+function writeJsonResponse(response, status, payload) {
+	response.writeHead(status, { "content-type": "application/json" });
+	response.end(JSON.stringify(payload));
+}
+function writeTextResponse(response, status, message) {
+	response.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+	response.end(message);
+}
+function parseStorageRangeHeader(header, size) {
+	if (size === 0) {
+		if (!header) return {
+			start: 0,
+			end: -1,
+			partial: false
+		};
+		return {
+			error: "Requested range is not satisfiable.",
+			status: 416
+		};
+	}
+	if (!header) return {
+		start: 0,
+		end: size - 1,
+		partial: false
+	};
+	if (header.includes(",")) return {
+		error: "Multi-range requests are not supported.",
+		status: 416
+	};
+	const match = /^bytes=(\d+)-(\d*)$/.exec(header);
+	if (!match) return {
+		error: "Only simple byte ranges are supported.",
+		status: 416
+	};
+	const start = Number(match[1]);
+	const end = match[2] ? Number(match[2]) : size - 1;
+	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || start >= size) return {
+		error: "Requested range is not satisfiable.",
+		status: 416
+	};
+	return {
+		start,
+		end: Math.min(end, size - 1),
+		partial: true
+	};
+}
+function writeStorageAccessHeaders(response, ticket, range) {
+	const headers = {
+		"content-type": ticket.entry.contentType ?? "application/octet-stream",
+		"content-length": range.byteLength,
+		"accept-ranges": ticket.supportsRange ? "bytes" : "none",
+		"content-disposition": renderStorageContentDisposition(ticket)
+	};
+	if (range.status === 206) headers["content-range"] = `bytes ${range.start}-${range.end}/${ticket.entry.size}`;
+	response.writeHead(range.status, headers);
+}
+function renderStorageContentDisposition(ticket) {
+	return `${ticket.purpose === "download" ? "attachment" : "inline"}; filename="${sanitizeHeaderFilename(ticket.entry.fileName ?? ticket.entry.id)}"; filename*=UTF-8''${encodeURIComponent(ticket.entry.fileName ?? `${ticket.entry.id}.bin`)}`;
+}
+function sanitizeHeaderFilename(value) {
+	return value.replaceAll(/["\\\r\n]/g, "_");
+}
+async function writeResponseChunk(response, chunk) {
+	if (response.write(chunk)) return;
+	await new Promise((resolve) => {
+		response.once("drain", resolve);
+	});
+}
 async function writeDevtoolsSessionState(cwd, state) {
 	const sessionPath = path.join(cwd, DEVTOOLS_SESSION_FILE);
 	await mkdir(path.dirname(sessionPath), { recursive: true });