@decocms/start 2.0.0 → 2.1.0

package/src/daemon/volumes.ts

@@ -0,0 +1,366 @@
+/**
+ * Volumes API — CRUD for .deco/ files with JSON patch support
+ * and WebSocket realtime broadcast of file changes.
+ *
+ * Ported from: deco-cx/deco daemon/realtime/app.ts (without CRDT)
+ */
+import { readdir, readFile, writeFile, mkdir, rm, stat } from "node:fs/promises";
+import { join, resolve, sep, posix } from "node:path";
+import type { IncomingMessage, ServerResponse, Server as HttpServer } from "node:http";
+import { WebSocketServer, WebSocket } from "ws";
+import fjp from "fast-json-patch";
+import type { Operation } from "fast-json-patch";
+
+// ---------------------------------------------------------------------------
+// Types — ported from daemon/realtime/types.ts
+// ---------------------------------------------------------------------------
+
+interface BaseFilePatch {
+  path: string;
+}
+
+interface JSONFilePatch extends BaseFilePatch {
+  patches: Operation[];
+}
+
+interface TextFileSet extends BaseFilePatch {
+  content: string | null;
+}
+
+type FilePatch = JSONFilePatch | TextFileSet;
+
+interface VolumePatchRequest {
+  messageId?: string;
+  patches: FilePatch[];
+}
+
+interface FilePatchResult {
+  path: string;
+  accepted: boolean;
+  content?: string;
+  deleted?: boolean;
+}
+
+interface VolumePatchResponse {
+  results: FilePatchResult[];
+  timestamp: number;
+}
+
+function isJSONFilePatch(patch: FilePatch): patch is JSONFilePatch {
+  return "patches" in patch && Array.isArray((patch as JSONFilePatch).patches);
+}
+
+function isTextFileSet(patch: FilePatch): patch is TextFileSet {
+  return "content" in patch && !("patches" in patch);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const toPosix = (p: string) => p.replaceAll(sep, "/");
+
+function safePath(base: string, untrusted: string): string | null {
+  const resolved = resolve(base, untrusted);
+  if (!resolved.startsWith(base + sep) && resolved !== base) return null;
+  return resolved;
+}
+
+async function readTextFileSafe(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, "utf-8");
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+async function ensureFile(path: string): Promise<void> {
+  const dir = join(path, "..");
+  await mkdir(dir, { recursive: true });
+}
+
+// ---------------------------------------------------------------------------
+// WebSocket realtime sessions
+// ---------------------------------------------------------------------------
+
+interface BroadcastMessage {
+  path: string;
+  timestamp: number;
+  deleted?: boolean;
+  messageId?: string;
+}
+
+interface VolumesState {
+  sessions: WebSocket[];
+  wss: WebSocketServer;
+  timestamp: number;
+}
+
+function broadcast(state: VolumesState, msg: BroadcastMessage): void {
+  const data = JSON.stringify(msg);
+  for (const ws of state.sessions) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(data);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Walk directory (Node.js equivalent of @std/fs/walk)
+// ---------------------------------------------------------------------------
+
+async function walkFiles(
+  root: string,
+): Promise<string[]> {
+  const results: string[] = [];
+  try {
+    const entries = await readdir(root, {
+      recursive: true,
+      withFileTypes: true,
+    });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const fullPath = join(entry.parentPath, entry.name);
+      const rel = toPosix(fullPath.replace(root, ""));
+      if (
+        rel.includes("/.git/") ||
+        rel.includes("/node_modules/") ||
+        rel.includes("/.agent-home/") ||
+        rel.includes("/.claude/")
+      ) {
+        continue;
+      }
+      results.push(fullPath);
+    }
+  } catch {
+    // root might be a file, not a directory
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Request handlers
+// ---------------------------------------------------------------------------
+
+const cwd = process.cwd();
+
+async function handleGetFiles(
+  req: IncomingMessage,
+  res: ServerResponse,
+  state: VolumesState,
+): Promise<void> {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const [, ...segments] = url.pathname.split("/files");
+  const filePath = segments.join("/files") || "/";
+  const withContent = url.searchParams.get("content") === "true";
+
+  const root = safePath(cwd, filePath);
+  if (!root) {
+    res.writeHead(403);
+    res.end("Path traversal denied");
+    return;
+  }
+  const fs: Record<string, { content: string | null }> = {};
+
+  const files = await walkFiles(root);
+  if (files.length > 0) {
+    for (const fullPath of files) {
+      const key = toPosix(fullPath.replace(root, "/"));
+      fs[key] = {
+        content: withContent ? await readTextFileSafe(fullPath) : null,
+      };
+    }
+  } else {
+    // Might be a single file
+    const content = withContent ? await readTextFileSafe(root) : null;
+    fs[toPosix(filePath)] = { content };
+  }
+
+  const body = JSON.stringify({ timestamp: state.timestamp, fs });
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(body);
+}
+
+async function handlePatchFiles(
+  req: IncomingMessage,
+  res: ServerResponse,
+  state: VolumesState,
+): Promise<void> {
+  const raw = await readBody(req);
+  let request: VolumePatchRequest;
+  try {
+    request = JSON.parse(raw);
+  } catch {
+    res.writeHead(400);
+    res.end("Invalid JSON");
+    return;
+  }
+
+  const results: FilePatchResult[] = [];
+
+  for (const patch of request.patches) {
+    // Validate path traversal for every patch
+    const resolvedPath = safePath(cwd, patch.path);
+    if (!resolvedPath) {
+      results.push({ accepted: false, path: patch.path });
+      continue;
+    }
+
+    if (isJSONFilePatch(patch)) {
+      const { path: filePath, patches: operations } = patch;
+      const content =
+        (await readTextFileSafe(resolvedPath)) ?? "{}";
+      try {
+        const newContent = JSON.stringify(
+          operations.reduce(fjp.applyReducer, JSON.parse(content)),
+        );
+        results.push({
+          accepted: true,
+          path: filePath,
+          content: newContent,
+          deleted: newContent === "null",
+        });
+      } catch (error) {
+        console.error(error);
+        results.push({ accepted: false, path: filePath, content });
+      }
+    } else if (isTextFileSet(patch)) {
+      const { path: filePath, content } = patch;
+      results.push({
+        accepted: true,
+        path: filePath,
+        content: content ?? "",
+        deleted: content === null,
+      });
+    }
+  }
+
+  state.timestamp = Date.now();
+
+  // Atomic: only commit writes if all patches accepted
+  const shouldWrite = results.every((r) => r.accepted);
+  if (shouldWrite) {
+    await Promise.all(
+      results.map(async (r) => {
+        try {
+          const system = join(cwd, r.path);
+          if (r.deleted) {
+            await rm(system, { force: true });
+          } else if (r.content != null) {
+            await ensureFile(system);
+            await writeFile(system, r.content, "utf-8");
+          }
+        } catch (error) {
+          console.error(error);
+          r.accepted = false;
+        }
+      }),
+    );
+  }
+
+  const body: VolumePatchResponse = { timestamp: state.timestamp, results };
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+// ---------------------------------------------------------------------------
+// Body reader helper
+// ---------------------------------------------------------------------------
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Setup: attach WebSocket server and file watcher
+// ---------------------------------------------------------------------------
+
+export interface VolumesOptions {
+  /** Vite's HTTP server to attach WebSocket upgrades to. */
+  httpServer: HttpServer;
+  /** Vite's file watcher (chokidar instance) for broadcasting changes. */
+  watcher: { on(event: string, cb: (...args: unknown[]) => void): void };
+}
+
+export function createVolumesHandler(opts: VolumesOptions) {
+  const state: VolumesState = {
+    sessions: [],
+    wss: new WebSocketServer({ noServer: true }),
+    timestamp: Date.now(),
+  };
+
+  // Handle WebSocket upgrades for /volumes/*/files paths with x-daemon-api
+  opts.httpServer.on("upgrade", (req, socket, head) => {
+    const isDaemon =
+      req.headers["x-daemon-api"] ?? req.headers["x-hypervisor-api"];
+    if (!isDaemon) return;
+
+    const url = req.url ?? "";
+    if (!url.includes("/volumes/") || !url.includes("/files")) return;
+
+    state.wss.handleUpgrade(req, socket, head, (ws) => {
+      state.sessions.push(ws);
+      console.log("[deco] admin websocket connected");
+
+      ws.on("close", () => {
+        console.log("[deco] admin websocket disconnected");
+        const idx = state.sessions.indexOf(ws);
+        if (idx > -1) state.sessions.splice(idx, 1);
+      });
+    });
+  });
+
+  // Broadcast file changes from Vite's watcher
+  const broadcastChange = (filePath: string, deleted = false) => {
+    const rel = toPosix(filePath).replace(toPosix(cwd), "");
+    if (
+      rel.includes("/.git/") ||
+      rel.includes("/node_modules/") ||
+      rel.includes("/.agent-home/") ||
+      rel.includes("/.claude/")
+    ) {
+      return;
+    }
+    broadcast(state, { path: rel, timestamp: Date.now(), deleted });
+  };
+
+  opts.watcher.on("change", (path: unknown) => {
+    if (typeof path === "string") broadcastChange(path);
+  });
+  opts.watcher.on("add", (path: unknown) => {
+    if (typeof path === "string") broadcastChange(path);
+  });
+  opts.watcher.on("unlink", (path: unknown) => {
+    if (typeof path === "string") broadcastChange(path, true);
+  });
+
+  // Connect-style middleware for HTTP requests
+  return async (
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: () => void,
+  ): Promise<void> => {
+    const url = req.url ?? "";
+
+    // Match /volumes/:id/files patterns
+    if (!url.includes("/volumes/") || !url.includes("/files")) {
+      next();
+      return;
+    }
+
+    if (req.method === "GET") {
+      await handleGetFiles(req, res, state);
+    } else if (req.method === "PATCH") {
+      await handlePatchFiles(req, res, state);
+    } else {
+      res.writeHead(405);
+      res.end();
+    }
+  };
+}

package/src/daemon/watch.ts

@@ -0,0 +1,272 @@
+/**
+ * SSE endpoint for file change events — initial sync + live updates.
+ *
+ * Ported from: deco-cx/deco daemon/sse/api.ts + daemon/sse/channel.ts
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, sep } from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+// ---------------------------------------------------------------------------
+// Event types — simplified from daemon/fs/common.ts
+// ---------------------------------------------------------------------------
+
+interface FSEvent {
+  type: "fs-sync" | "fs-snapshot" | "worker-status" | "meta-info";
+  detail: Record<string, unknown>;
+}
+
+// ---------------------------------------------------------------------------
+// Broadcast channel (EventTarget-based, same as daemon/sse/channel.ts)
+// ---------------------------------------------------------------------------
+
+const channel = new EventTarget();
+
+export function broadcastFSEvent(event: FSEvent): void {
+  channel.dispatchEvent(new CustomEvent("broadcast", { detail: event }));
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const toPosix = (p: string) => p.replaceAll(sep, "/");
+
+function shouldIgnore(path: string): boolean {
+  return (
+    path.includes(`${sep}.git${sep}`) ||
+    path.includes(`${sep}node_modules${sep}`) ||
+    path.includes(`${sep}.agent-home${sep}`) ||
+    path.includes(`${sep}.claude${sep}`)
+  );
+}
+
+/**
+ * Infer block type from __resolveType string.
+ * Maps to manifest block categories (pages, sections, loaders, etc.).
+ */
+function inferBlockType(resolveType: string): string | null {
+  if (!resolveType) return null;
+  if (resolveType.includes("/pages/")) return "pages";
+  if (resolveType.includes("/sections/")) return "sections";
+  if (resolveType.includes("/loaders/")) return "loaders";
+  if (resolveType.includes("/actions/")) return "actions";
+  if (resolveType.includes("/matchers/")) return "matchers";
+  if (resolveType.includes("/flags/")) return "sections";
+  return null;
+}
+
+export interface Metadata {
+  kind: "block" | "file";
+  blockType?: string;
+  __resolveType?: string;
+  name?: string;
+  path?: string;
+}
+
+/**
+ * Read a JSON file and infer its metadata (block type, resolveType, etc.).
+ * Matches the Deno daemon's inferMetadata from daemon/fs/api.ts.
+ */
+export async function inferMetadata(filepath: string): Promise<Metadata | null> {
+  try {
+    const raw = await readFile(filepath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const { __resolveType, name, path: pagePath } = parsed;
+
+    if (!__resolveType) return { kind: "file" };
+
+    const blockType = inferBlockType(__resolveType);
+    if (!blockType) return { kind: "file" };
+
+    if (blockType === "pages") {
+      return {
+        kind: "block",
+        blockType,
+        __resolveType,
+        name: name ?? undefined,
+        path: pagePath ?? undefined,
+      };
+    }
+
+    return { kind: "block", blockType, __resolveType };
+  } catch {
+    return { kind: "file" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Initial file scan — yields fs-sync events for each .deco/ file
+// ---------------------------------------------------------------------------
+
+async function* scanFiles(
+  cwd: string,
+  since: number,
+): AsyncGenerator<FSEvent> {
+  const decoDir = join(cwd, ".deco");
+  try {
+    const entries = await readdir(decoDir, {
+      recursive: true,
+      withFileTypes: true,
+    });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const fullPath = join(entry.parentPath, entry.name);
+      if (shouldIgnore(fullPath)) continue;
+
+      let mtime: number;
+      try {
+        const stats = await stat(fullPath);
+        mtime = stats.mtimeMs;
+      } catch {
+        mtime = Date.now();
+      }
+
+      if (mtime < since) continue;
+
+      const metadata = await inferMetadata(fullPath);
+      const filepath = toPosix(fullPath.replace(cwd, ""));
+      yield {
+        type: "fs-sync",
+        detail: { metadata, filepath, timestamp: mtime },
+      };
+    }
+  } catch {
+    // .deco dir might not exist yet
+  }
+
+  yield {
+    type: "fs-snapshot",
+    detail: { timestamp: Date.now() },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// SSE handler — Connect-style middleware
+// ---------------------------------------------------------------------------
+
+export function createWatchHandler(opts?: { getPort?: () => number }) {
+  const cwd = process.cwd();
+  const getPort = opts?.getPort ?? (() => 5173);
+
+  return async (
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: () => void,
+  ): Promise<void> => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+
+    // Only handle /watch or the root SSE endpoint
+    if (url.pathname !== "/watch" && url.pathname !== "/") {
+      next();
+      return;
+    }
+
+    if (req.method !== "GET") {
+      next();
+      return;
+    }
+
+    // SSE headers
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    });
+
+    const since = Number(url.searchParams.get("since")) || 0;
+    let closed = false;
+
+    req.on("close", () => {
+      closed = true;
+      console.log("[deco] SSE stream closed");
+    });
+
+    function sendEvent(event: FSEvent): void {
+      if (closed) return;
+      const data = encodeURIComponent(JSON.stringify(event));
+      res.write(`event: message\ndata: ${data}\n\n`);
+    }
+
+    // Live broadcast listener
+    const handler = (e: Event) => {
+      const ce = e as CustomEvent<FSEvent>;
+      sendEvent(ce.detail);
+    };
+    channel.addEventListener("broadcast", handler);
+    req.on("close", () => {
+      channel.removeEventListener("broadcast", handler);
+    });
+
+    console.log("[deco] SSE stream opened");
+
+    // Initial scan
+    for await (const event of scanFiles(cwd, since)) {
+      if (closed) break;
+      sendEvent(event);
+    }
+
+    if (closed) return;
+
+    // Worker status — Vite dev server is always ready
+    sendEvent({
+      type: "worker-status",
+      detail: { state: "ready" },
+    });
+
+    // Meta info — schema + manifest so admin knows about sections/loaders/actions.
+    // Fetch via HTTP so the request goes through Vite SSR where the data lives
+    // (daemon's native imports create separate module instances).
+    try {
+      const metaResponse = await fetch(`http://localhost:${getPort()}/live/_meta`);
+      if (metaResponse.ok) {
+        const metaData = await metaResponse.json();
+        sendEvent({
+          type: "meta-info",
+          detail: { ...metaData, timestamp: Date.now() },
+        });
+      }
+    } catch {
+      // Schema may not be initialized yet — admin will retry via /live/_meta
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Wire Vite watcher to broadcast channel
+// ---------------------------------------------------------------------------
+
+export function watchFS(watcher: {
+  on(event: string, cb: (...args: unknown[]) => void): void;
+}): void {
+  const cwd = process.cwd();
+
+  const onChange = async (filePath: unknown, deleted = false) => {
+    if (typeof filePath !== "string") return;
+    if (shouldIgnore(filePath)) return;
+
+    const metadata = deleted ? null : await inferMetadata(filePath);
+    let mtime = Date.now();
+    if (!deleted) {
+      try {
+        const stats = await stat(filePath);
+        mtime = stats.mtimeMs;
+      } catch {
+        // use Date.now()
+      }
+    }
+
+    broadcastFSEvent({
+      type: "fs-sync",
+      detail: {
+        metadata,
+        filepath: toPosix(filePath.replace(cwd, "")),
+        timestamp: mtime,
+      },
+    });
+  };
+
+  watcher.on("change", (path: unknown) => onChange(path));
+  watcher.on("add", (path: unknown) => onChange(path));
+  watcher.on("unlink", (path: unknown) => onChange(path, true));
+}

package/src/sdk/cachedLoader.ts

@@ -11,7 +11,7 @@
  * (e.g. "product") which derives timing from the unified profile system.
  */
 
-import { loaderCacheOptions, type CacheProfileName } from "./cacheHeaders";
+import { loaderCacheOptions, type CacheProfileName } from "./cacheHeaders.ts";
 
 export type CachePolicy = "no-store" | "no-cache" | "stale-while-revalidate";
 

package/src/vite/plugin.js

@@ -115,12 +115,53 @@ export function decoVitePlugin() {
           }
         }
       });
+
+      // Tunnel + daemon: connect local dev to admin.deco.cx
+      // Activated when DECO_SITE_NAME is set (e.g. DECO_SITE_NAME=mysite vite dev)
+      const siteName = process.env.DECO_SITE_NAME;
+      if (siteName) {
+        const envName = process.env.DECO_ENV_NAME || "dev";
+
+        // Add daemon middleware (x-daemon-api interception + auth + volumes + SSE + admin routes)
+        import("../daemon/middleware.ts").then(({ createDaemonMiddleware }) => {
+          server.middlewares.use(createDaemonMiddleware({ site: siteName, server }));
+        }).catch((err) => {
+          console.warn("[deco] Failed to load daemon middleware:", err.message);
+        });
+
+        // Start tunnel after HTTP server is listening (so we know the real port)
+        server.httpServer?.once("listening", async () => {
+          const addr = server.httpServer?.address();
+          const port = typeof addr === "object" && addr ? addr.port : 5173;
+          try {
+            const { startTunnel } = await import("../daemon/tunnel.ts");
+            const tunnel = await startTunnel({
+              site: siteName,
+              env: envName,
+              port,
+              decoHost: process.env.DECO_HOST === "true",
+            });
+            server.httpServer?.on("close", () => tunnel.close());
+          } catch (err) {
+            console.warn("[deco] Failed to start tunnel:", err.message);
+          }
+        });
+      }
     },
 
     config(_cfg, { command }) {
+      /** @type {import("vite").UserConfig} */
+      const cfg = {};
+
+      // Allow tunnel domains through Vite's host check
+      if (process.env.DECO_SITE_NAME) {
+        cfg.server = { allowedHosts: [".deco.host", ".decocdn.com"] };
+      }
+
       // Only split chunks for production builds — dev uses unbundled ESM.
-      if (command !== "build") return;
+      if (command !== "build") return cfg;
       return {
+        ...cfg,
         build: {
           rollupOptions: {
             output: {