@uniqbit/mate-core 0.17.0-canary.11 → 0.17.0-canary.13

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

@@ -13,24 +13,47 @@ export const STUDIO_VIEWS: readonly StudioView[] = [
 ];
 
 export const COMPANION_PARAM = "companion";
-const VIEW_PARAM = "view";
+export const VIEW_PARAM = "view";
 export const REFRESH_PARAM = "refresh";
 export const FILE_PARAM = "path";
+export const DIR_PARAM = "dir";
+
+/** Every URL parameter Studio names; no other module writes one out. */
+export const STUDIO_PARAMS: readonly string[] = [
+  COMPANION_PARAM,
+  VIEW_PARAM,
+  REFRESH_PARAM,
+  FILE_PARAM,
+  DIR_PARAM,
+];
 
 /** Filled into a prompt when no change is named, so a prompt is never half-written. */
 export const CHANGE_PLACEHOLDER = "<change-name>";
 
 const DIGEST_LENGTH = 10;
 
-export interface StudioSelection {
+interface SelectionBase {
   companionDigest: string | null;
-  view: StudioView;
-  /**
-   * One-shot: the refresh control asks for it, and it is never carried forward
-   * into the URL another control builds. Switching a view is not a refresh.
-   */
+  /** One-shot: only the `refresh` move sets it, and every other move clears it. */
   refresh: boolean;
+}
+
+export interface StudioVaultSelection extends SelectionBase {
+  view: "vault";
   openPath: string | null;
+  /** A folder of the listed tree; never looked up on disk. */
+  openDir: string | null;
+}
+
+export interface StudioPlainSelection extends SelectionBase {
+  view: Exclude<StudioView, "vault">;
+}
+
+export type StudioSelection = StudioVaultSelection | StudioPlainSelection;
+
+export interface SelectionField {
+  name: string;
+  value: string;
 }
 
 /**
@@ -60,11 +83,104 @@ function readView(value: string | null): StudioView {
   return STUDIO_VIEWS.includes(value as StudioView) ? (value as StudioView) : "dashboard";
 }
 
-export function parseStudioSelection(url: URL): StudioSelection {
+function readText(value: string | null): string | null {
+  return value?.trim() || null;
+}
+
+/** An empty or malformed digest selects no companion, as an unmatched one already does. */
+function readDigest(value: string | null): string | null {
+  const digest = readText(value);
+  return digest && COMPANION_DIGEST_PATTERN.test(digest) ? digest : null;
+}
+
+function readBase(params: URLSearchParams): SelectionBase {
+  return {
+    companionDigest: readDigest(params.get(COMPANION_PARAM)),
+    refresh: params.get(REFRESH_PARAM) === "1",
+  };
+}
+
+function readVault(params: URLSearchParams): StudioVaultSelection {
+  return {
+    ...readBase(params),
+    view: "vault",
+    openPath: readText(params.get(FILE_PARAM)),
+    openDir: readText(params.get(DIR_PARAM)),
+  };
+}
+
+/** Forgiving: parameters the named view does not have are ignored. */
+export function parse(url: URL): StudioSelection {
+  const view = readView(url.searchParams.get(VIEW_PARAM));
+  if (view === "vault") return readVault(url.searchParams);
+  return { ...readBase(url.searchParams), view };
+}
+
+/** For the `/api/vault/*` routes, which imply the vault view whatever `view` says. */
+export function parseVaultSelection(url: URL): StudioVaultSelection {
+  return readVault(url.searchParams);
+}
+
+/** Drops the vault's target. */
+export function switchView(selection: StudioSelection, view: StudioView): StudioSelection {
+  const base = { companionDigest: selection.companionDigest, refresh: false };
+  if (view === "vault") return { ...base, view, openPath: null, openDir: null };
+  return { ...base, view };
+}
+
+/** Keeps the view and drops the vault's target: it belongs to the companion being left. */
+export function switchCompanion(
+  selection: StudioSelection,
+  digest: string | null,
+): StudioSelection {
+  return { ...switchView(selection, selection.view), companionDigest: digest };
+}
+
+export function openFile(selection: StudioSelection, path: string): StudioVaultSelection {
   return {
-    companionDigest: url.searchParams.get(COMPANION_PARAM)?.trim() || null,
-    view: readView(url.searchParams.get(VIEW_PARAM)),
-    refresh: url.searchParams.get(REFRESH_PARAM) === "1",
-    openPath: url.searchParams.get(FILE_PARAM)?.trim() || null,
+    companionDigest: selection.companionDigest,
+    refresh: false,
+    view: "vault",
+    openPath: path,
+    openDir: null,
   };
 }
+
+/** `null` opens the companion root. */
+export function openFolder(selection: StudioSelection, dir: string | null): StudioVaultSelection {
+  return {
+    companionDigest: selection.companionDigest,
+    refresh: false,
+    view: "vault",
+    openPath: null,
+    openDir: dir,
+  };
+}
+
+export function refresh(selection: StudioSelection): StudioSelection {
+  return { ...selection, refresh: true };
+}
+
+/** Omits defaults (the Dashboard view, an unset target), so URLs stay short. */
+export function toFields(selection: StudioSelection): SelectionField[] {
+  const fields: SelectionField[] = [];
+  if (selection.companionDigest) {
+    fields.push({ name: COMPANION_PARAM, value: selection.companionDigest });
+  }
+  if (selection.view !== "dashboard") fields.push({ name: VIEW_PARAM, value: selection.view });
+  if (selection.view === "vault") {
+    if (selection.openPath) fields.push({ name: FILE_PARAM, value: selection.openPath });
+    if (selection.openDir) fields.push({ name: DIR_PARAM, value: selection.openDir });
+  }
+  if (selection.refresh) fields.push({ name: REFRESH_PARAM, value: "1" });
+  return fields;
+}
+
+export function toSearchParams(selection: StudioSelection): URLSearchParams {
+  return new URLSearchParams(toFields(selection).map(({ name, value }) => [name, value]));
+}
+
+export function toHref(selection: StudioSelection, route = "/"): string {
+  const query = toSearchParams(selection).toString();
+  return query ? `${route}?${query}` : route;
+}

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

@@ -8,9 +8,15 @@ import {
 import { collectStudioInventory, type StudioInventory } from "./inventory";
 import { assembleCompanionPayload, type StudioCompanionResponse } from "./payload";
 import { STUDIO_HOSTNAME } from "./routes";
-import { companionDigest, parseStudioSelection, resolveCompanion } from "./selection";
+import {
+  companionDigest,
+  parse,
+  parseVaultSelection,
+  resolveCompanion,
+  type StudioVaultSelection,
+} from "./selection";
 import { createStudioSnapshotCache, type StudioSnapshotCache } from "./snapshot";
-import type { StudioPage } from "./views/model";
+import type { StudioPage, StudioVaultPage } from "./views/model";
 import { createVaultManager, resolveVaultPath, VaultPathError, type VaultManager } from "./vault";
 import {
   DEFAULT_DETACH_MINUTES,
@@ -41,11 +47,17 @@ export interface StudioSocket {
 
 export interface StudioUpgrader {
   upgrade(request: Request, options: { data: StudioSocket["data"] }): boolean;
+  /** Per-request idle timeout in seconds; `0` disables it. */
+  timeout?(request: Request, seconds: number): void;
 }
 
+/** Bun's maximum; its 10 s default cut slow Vault listings into empty responses. */
+export const STUDIO_IDLE_TIMEOUT_SECONDS = 255;
+
 export interface StudioServeOptions {
   port: number;
   hostname: string;
+  idleTimeout: number;
   fetch: (request: Request, server: StudioUpgrader) => Promise<Response | undefined>;
   websocket?: {
     open(ws: StudioSocket): void;
@@ -97,6 +109,8 @@ export interface StudioServerOptions {
   detachMinutes?: number;
   /** Pins every terminal launch to this registered companion. */
   launchCompanion?: string | null;
+  /** Seconds; defaults to `STUDIO_IDLE_TIMEOUT_SECONDS`. */
+  idleTimeout?: number;
   /** Terminal launches skip companion Git synchronization. */
   noGit?: boolean;
 }
@@ -110,6 +124,22 @@ async function renderStudioDocument(page: StudioPage): Promise<string> {
   return views.renderStudioDocument(page);
 }
 
+async function renderVaultView(page: StudioPage): Promise<string> {
+  const views = await import("./views/document");
+  return views.renderVaultView(page);
+}
+
+/** Keep the CLI entry free of eager Studio view imports. */
+async function collectVaultState(
+  vault: VaultManager,
+  companionPath: string,
+  selection: StudioVaultSelection,
+  options: { tree: "prefetch" | "await" },
+): Promise<StudioVaultPage> {
+  const { vaultState } = await import("./views/vault/state");
+  return vaultState(vault, companionPath, selection, options);
+}
+
 function html(body: string): Response {
   return new Response(body, {
     headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" },
@@ -301,12 +331,11 @@ export function createStudioFetch(
     }
 
     if (url.pathname === "/api/vault/tree") {
-      const selected = await selectedCompanion(url, inventory);
+      const selection = parseVaultSelection(url);
+      const selected = await selectedCompanion(selection.companionDigest, 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")),
-        );
+        return respond(json(await vault.tree(selected.path, selection.refresh)));
       } catch (error) {
         return respond(
           json({ reason: error instanceof Error ? error.message : String(error) }, 400),
@@ -314,11 +343,36 @@ export function createStudioFetch(
       }
     }
 
+    if (url.pathname === "/api/vault/view") {
+      const collected = await inventory();
+      const selection = parseVaultSelection(url);
+      const companion = resolveCompanion(collected, selection.companionDigest);
+      if (!companion) return respond(json({ reason: "no registered companion was selected" }, 400));
+      const state = await collectVaultState(vault, companion.path, selection, { tree: "await" });
+      return respond(
+        new Response(
+          await renderVaultView({
+            inventory: collected,
+            selection,
+            companion,
+            payload: null,
+            error: null,
+            collectedAt: null,
+            writable,
+            vault: state,
+            terminal: null,
+          }),
+          { headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" } },
+        ),
+      );
+    }
+
     if (url.pathname === "/api/vault/file") {
-      const selected = await selectedCompanion(url, inventory);
+      const selection = parseVaultSelection(url);
+      const selected = await selectedCompanion(selection.companionDigest, 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") ?? "")));
+        return respond(json(await vault.open(selected.path, selection.openPath ?? "")));
       } catch (error) {
         return respond(
           json({ reason: error instanceof Error ? error.message : String(error) }, 400),
@@ -327,10 +381,12 @@ export function createStudioFetch(
     }
 
     if (url.pathname === "/api/vault/events") {
-      const selected = await selectedCompanion(url, inventory);
+      const selection = parseVaultSelection(url);
+      const selected = await selectedCompanion(selection.companionDigest, inventory);
       if (!selected) return respond(json({ reason: "no registered companion was selected" }, 400));
       try {
-        const opened = await resolveVaultPath(selected.path, url.searchParams.get("path") ?? "");
+        const opened = await resolveVaultPath(selected.path, selection.openPath ?? "");
+        server?.timeout?.(request, 0);
         return respond(vaultEvents(vault, selected.path, opened.relative));
       } catch (error) {
         return respond(
@@ -355,7 +411,7 @@ export function createStudioFetch(
         return respond(json({ reason: "save requires a JSON body" }, 400));
       }
       const selected = await selectedCompanion(
-        new URL(`${url.origin}/?companion=${encodeURIComponent(body.companion ?? "")}`),
+        typeof body.companion === "string" ? body.companion : null,
         inventory,
       );
       if (!selected || typeof body.path !== "string" || typeof body.content !== "string") {
@@ -403,11 +459,10 @@ export function createStudioFetch(
 }
 
 async function selectedCompanion(
-  url: URL,
+  digest: string | null,
   collectInventory: () => Promise<StudioInventory>,
 ): Promise<ReturnType<typeof resolveCompanion>> {
-  const inventory = await collectInventory();
-  return resolveCompanion(inventory, parseStudioSelection(url).companionDigest);
+  return resolveCompanion(await collectInventory(), digest);
 }
 
 function vaultEvents(vault: VaultManager, companionPath: string, requestedPath: string): Response {
@@ -448,7 +503,7 @@ async function collectStudioPage(
   vault: VaultManager,
   writable: boolean,
 ): Promise<StudioPage> {
-  const selection = parseStudioSelection(url);
+  const selection = parse(url);
   const inventory = await collectInventory();
   const companion = resolveCompanion(inventory, selection.companionDigest);
   const page: StudioPage = {
@@ -469,38 +524,10 @@ async function collectStudioPage(
   }
 
   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),
-        },
-      };
-    }
+    return {
+      ...page,
+      vault: await collectVaultState(vault, companion.path, selection, { tree: "prefetch" }),
+    };
   }
 
   vault.deactivate();
@@ -569,6 +596,7 @@ export function startStudioServer(
   const server = serve({
     port,
     hostname,
+    idleTimeout: options.idleTimeout ?? STUDIO_IDLE_TIMEOUT_SECONDS,
     fetch: fetchHandler,
     ...(registry
       ? {