@uniqbit/mate-core 0.16.0 → 0.17.0-canary.2

package/src/cli/commands/studio/server.ts

@@ -4,6 +4,7 @@ import { STUDIO_HOSTNAME } from "./routes";
 import { parseStudioSelection, resolveCompanion } from "./selection";
 import { createStudioSnapshotCache, type StudioSnapshotCache } from "./snapshot";
 import type { StudioPage } from "./views/model";
+import { createVaultManager, resolveVaultPath, VaultPathError, type VaultManager } from "./vault";
 
 export { STUDIO_HOSTNAME } from "./routes";
 
@@ -34,6 +35,13 @@ export interface StudioServerDeps {
   renderDocument?: (page: StudioPage) => string | Promise<string>;
   serve?: (options: StudioServeOptions) => StudioBoundServer;
   snapshots?: StudioSnapshotCache;
+  vault?: VaultManager;
+}
+
+export interface StudioServerOptions {
+  port?: number;
+  hostname?: string;
+  writable?: boolean;
 }
 
 /**
@@ -51,9 +59,21 @@ function html(body: string): Response {
   });
 }
 
+function json(value: unknown, status = 200): Response {
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+  });
+}
+
+interface StudioFetch {
+  (request: Request): Promise<Response>;
+  close(): void;
+}
+
 /**
- * The studio request handler. Read-only by construction: a non-read method is
- * refused before any collection runs, and no route writes. The response is
+ * The studio request handler. Read endpoints are refused before collection, and
+ * the vault save route is the only write path. The response is
  * already correct for the URL that asked for it — the companion, the change,
  * and the view are read from the request rather than reconciled in the browser.
  * Collection is held in one snapshot cache for the life of the handler, so a
@@ -62,31 +82,148 @@ function html(body: string): Response {
  */
 export function createStudioFetch(
   deps: StudioServerDeps = {},
-): (request: Request) => Promise<Response> {
+  options: Pick<StudioServerOptions, "writable"> = {},
+): StudioFetch {
   const inventory = deps.collectStudioInventory ?? collectStudioInventory;
   const companion = deps.assembleCompanionPayload ?? assembleCompanionPayload;
   const render = deps.renderDocument ?? renderStudioDocument;
   const snapshots =
     deps.snapshots ?? createStudioSnapshotCache({ assembleCompanionPayload: companion });
+  const vault = deps.vault ?? createVaultManager();
+  const writable = options.writable === true;
 
-  return async (request: Request): Promise<Response> => {
-    if (!READ_METHODS.has(request.method)) {
+  const handler = async (request: Request): Promise<Response> => {
+    const url = new URL(request.url);
+    const isSave = url.pathname === "/api/vault/save";
+    if (isSave && request.method !== "POST") {
+      return new Response("vault save requires POST", { status: 405, headers: { allow: "POST" } });
+    }
+    if (!READ_METHODS.has(request.method) && !(isSave && request.method === "POST")) {
       return new Response("studio serves read requests only", {
         status: 405,
-        headers: { allow: "GET, HEAD" },
+        headers: { allow: isSave ? "POST" : "GET, HEAD" },
       });
     }
 
-    const url = new URL(request.url);
     const respond = (response: Response) =>
       request.method === "HEAD"
         ? new Response(null, { status: response.status, headers: response.headers })
         : response;
 
+    if (url.pathname === "/api/vault/tree") {
+      const selected = await selectedCompanion(url, inventory);
+      if (!selected) return respond(json({ reason: "no registered companion was selected" }, 400));
+      try {
+        return respond(
+          json(await vault.tree(selected.path, url.searchParams.get("refresh") === "1")),
+        );
+      } catch (error) {
+        return respond(
+          json({ reason: error instanceof Error ? error.message : String(error) }, 400),
+        );
+      }
+    }
+
+    if (url.pathname === "/api/vault/file") {
+      const selected = await selectedCompanion(url, inventory);
+      if (!selected) return respond(json({ reason: "no registered companion was selected" }, 400));
+      try {
+        return respond(json(await vault.open(selected.path, url.searchParams.get("path") ?? "")));
+      } catch (error) {
+        return respond(
+          json({ reason: error instanceof Error ? error.message : String(error) }, 400),
+        );
+      }
+    }
+
+    if (url.pathname === "/api/vault/events") {
+      const selected = await selectedCompanion(url, inventory);
+      if (!selected) return respond(json({ reason: "no registered companion was selected" }, 400));
+      try {
+        const opened = await resolveVaultPath(selected.path, url.searchParams.get("path") ?? "");
+        return respond(vaultEvents(vault, selected.path, opened.relative));
+      } catch (error) {
+        return respond(
+          json({ reason: error instanceof Error ? error.message : String(error) }, 400),
+        );
+      }
+    }
+
+    if (isSave) {
+      if (!writable)
+        return respond(json({ reason: "start Studio with --writable to enable saving" }, 403));
+      let body: { companion?: string; path?: string; content?: string; token?: string };
+      try {
+        body = (await request.json()) as typeof body;
+      } catch {
+        return respond(json({ reason: "save requires a JSON body" }, 400));
+      }
+      const selected = await selectedCompanion(
+        new URL(`${url.origin}/?companion=${encodeURIComponent(body.companion ?? "")}`),
+        inventory,
+      );
+      if (!selected || typeof body.path !== "string" || typeof body.content !== "string") {
+        return respond(
+          json({ reason: "save requires a registered companion, path, and content" }, 400),
+        );
+      }
+      try {
+        const result = await vault.save(selected.path, body.path, body.content, body.token);
+        return respond(json(result, result.kind === "conflict" ? 409 : 200));
+      } catch (error) {
+        return respond(
+          json(
+            { reason: error instanceof Error ? error.message : String(error) },
+            error instanceof VaultPathError ? 400 : 500,
+          ),
+        );
+      }
+    }
+
     if (url.pathname !== "/") return respond(new Response("not found", { status: 404 }));
 
-    return respond(html(await render(await collectStudioPage(url, inventory, snapshots))));
+    return respond(
+      html(await render(await collectStudioPage(url, inventory, snapshots, vault, writable))),
+    );
   };
+
+  handler.close = () => vault.stop();
+  return handler;
+}
+
+async function selectedCompanion(
+  url: URL,
+  collectInventory: () => Promise<StudioInventory>,
+): Promise<ReturnType<typeof resolveCompanion>> {
+  const inventory = await collectInventory();
+  return resolveCompanion(inventory, parseStudioSelection(url).companionDigest);
+}
+
+function vaultEvents(vault: VaultManager, companionPath: string, requestedPath: string): Response {
+  const encoder = new TextEncoder();
+  let unsubscribe = () => {};
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoder.encode(": studio vault events\n\n"));
+      unsubscribe = vault.subscribe(companionPath, requestedPath, (event) => {
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+        } catch {
+          unsubscribe();
+        }
+      });
+    },
+    cancel() {
+      unsubscribe();
+    },
+  });
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+    },
+  });
 }
 
 /**
@@ -97,6 +234,8 @@ async function collectStudioPage(
   url: URL,
   collectInventory: () => Promise<StudioInventory>,
   snapshots: StudioSnapshotCache,
+  vault: VaultManager,
+  writable: boolean,
 ): Promise<StudioPage> {
   const selection = parseStudioSelection(url);
   const inventory = await collectInventory();
@@ -108,9 +247,51 @@ async function collectStudioPage(
     payload: null,
     error: null,
     collectedAt: null,
+    writable,
+    vault: null,
   };
 
-  if (!companion) return page;
+  if (!companion) {
+    vault.deactivate();
+    return page;
+  }
+
+  if (selection.view === "vault") {
+    try {
+      const tree = await vault.tree(companion.path, selection.refresh);
+      let open = null;
+      let refusal: string | null = null;
+      if (selection.openPath) {
+        try {
+          open = await vault.open(companion.path, selection.openPath);
+        } catch (error) {
+          refusal = error instanceof Error ? error.message : String(error);
+        }
+      }
+      return {
+        ...page,
+        vault: {
+          tree: tree.tree,
+          open,
+          refusal,
+          incoming: null,
+          overwritten: null,
+          watching: tree.watching,
+          warning: tree.warning,
+        },
+      };
+    } catch (error) {
+      return {
+        ...page,
+        error: {
+          companionPath: companion.path,
+          reason: error instanceof Error ? error.message : String(error),
+        },
+      };
+    }
+  }
+
+  vault.deactivate();
 
   try {
     const snapshot = await snapshots.read(companion.path, selection.refresh);
@@ -144,19 +325,33 @@ function bunServe(options: StudioServeOptions): StudioBoundServer {
 }
 
 /**
- * Binds the studio server to an operating-system-assigned loopback port. A
- * bind failure propagates: the caller reports it and exits rather than opening
- * a browser at a URL nothing answers.
+ * A bind failure propagates: the caller reports it and exits rather than
+ * opening a browser at a URL nothing answers.
  */
-export function startStudioServer(deps: StudioServerDeps = {}): StudioServerHandle {
+export function startStudioServer(
+  deps: StudioServerDeps = {},
+  options: StudioServerOptions = {},
+): StudioServerHandle {
   const serve = deps.serve ?? bunServe;
-  const server = serve({ port: 0, hostname: STUDIO_HOSTNAME, fetch: createStudioFetch(deps) });
+  const port = options.port ?? 0;
+  const hostname = options.hostname ?? STUDIO_HOSTNAME;
+  const fetchHandler = createStudioFetch(deps, { writable: options.writable });
+  const server = serve({ port, hostname, fetch: fetchHandler });
+  const urlHostname =
+    hostname === STUDIO_HOSTNAME || hostname === "localhost" || hostname === "::1"
+      ? "localhost"
+      : hostname.includes(":") && !hostname.startsWith("[")
+        ? `[${hostname}]`
+        : hostname;
 
   return {
-    url: `http://localhost:${server.port}`,
+    url: `http://${urlHostname}:${server.port}`,
     port: server.port,
-    hostname: STUDIO_HOSTNAME,
-    stop: () => server.stop(true),
+    hostname,
+    stop: async () => {
+      fetchHandler.close();
+      await server.stop(true);
+    },
   };
 }