@chrisjowen/wheelhouse 0.1.1 → 0.2.1

package/build/server/chunks/chunks/vault.js-CTaWe09z.js

@@ -0,0 +1,162 @@
+import { e as extractUrls } from './urls.js-BrlC6XZ8.js';
+
+const LIMITS = {
+  blocks: 24,
+  items: 200,
+  columns: 12,
+  text: 4e3,
+  field: 400,
+  cards: 50,
+  mentions: 20
+};
+const TONES = ["ok", "warn", "fail", "pending", "unknown"];
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v, max = LIMITS.field) => typeof v === "string" ? v.length > max ? `${v.slice(0, max - 1)}…` : v : null;
+const list = (v, max = LIMITS.items) => Array.isArray(v) ? v.slice(0, max) : [];
+function safeHref(v) {
+  if (typeof v !== "string" || v.length > 2048) return null;
+  if (v.startsWith("/") && !v.startsWith("//") && !v.startsWith("/\\")) return v;
+  try {
+    const u = new URL(v);
+    return u.protocol === "http:" || u.protocol === "https:" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function preview(v) {
+  let s;
+  try {
+    s = JSON.stringify(v) ?? String(v);
+  } catch {
+    s = String(v);
+  }
+  return s.length > 300 ? `${s.slice(0, 299)}…` : s;
+}
+function unknownBlock(v, type) {
+  return { block: "unknown", type, preview: preview(v) };
+}
+function one(v) {
+  if (!isRecord(v)) return unknownBlock(v, typeof v);
+  const type = typeof v.block === "string" ? v.block : "(none)";
+  switch (type) {
+    case "text.v1": {
+      const text = str(v.text, LIMITS.text);
+      if (text === null) break;
+      return v.muted === true ? { block: "text.v1", text, muted: true } : { block: "text.v1", text };
+    }
+    case "kv.v1":
+      return {
+        block: "kv.v1",
+        items: list(v.items).flatMap((i) => {
+          if (!isRecord(i)) return [];
+          const key = str(i.key);
+          const value = str(i.value);
+          if (key === null || value === null) return [];
+          const href = safeHref(i.href);
+          return [href ? { key, value, href } : { key, value }];
+        })
+      };
+    case "table.v1": {
+      const columns = list(v.columns, LIMITS.columns).map((c) => str(c) ?? "");
+      const rows = list(v.rows).map(
+        (r) => list(r, columns.length || LIMITS.columns).map((c) => {
+          if (isRecord(c)) {
+            const text = str(c.text) ?? "";
+            const href = safeHref(c.href);
+            return href ? { text, href } : text;
+          }
+          return str(c) ?? (typeof c === "number" ? String(c) : "");
+        })
+      );
+      return { block: "table.v1", columns, rows };
+    }
+    case "links.v1":
+      return {
+        block: "links.v1",
+        links: list(v.links).flatMap((l) => {
+          if (!isRecord(l)) return [];
+          const label = str(l.label);
+          const href = safeHref(l.href);
+          if (label === null || href === null) return [];
+          const note = str(l.note);
+          return [note ? { label, href, note } : { label, href }];
+        })
+      };
+    case "image.v1": {
+      const src = safeHref(v.src);
+      if (!src) break;
+      const href = safeHref(v.href);
+      const alt = str(v.alt) ?? "";
+      return href ? { block: "image.v1", src, alt, href } : { block: "image.v1", src, alt };
+    }
+    case "status.v1": {
+      const label = str(v.label);
+      if (label === null) break;
+      const tone = TONES.includes(v.tone) ? v.tone : "unknown";
+      const detail = str(v.detail, LIMITS.text);
+      return detail ? { block: "status.v1", tone, label, detail } : { block: "status.v1", tone, label };
+    }
+    case "graph.v1": {
+      const nodes = list(v.nodes).flatMap((n) => {
+        if (!isRecord(n)) return [];
+        const id = str(n.id);
+        if (id === null) return [];
+        const kind = str(n.kind);
+        const label = str(n.label) ?? id;
+        return [kind ? { id, label, kind } : { id, label }];
+      });
+      const ids = new Set(nodes.map((n) => n.id));
+      const edges = list(v.edges).flatMap((e) => {
+        if (!isRecord(e)) return [];
+        const from = str(e.from);
+        const to = str(e.to);
+        if (from === null || to === null || !ids.has(from) || !ids.has(to)) return [];
+        const label = str(e.label);
+        return [label ? { from, to, label } : { from, to }];
+      });
+      return { block: "graph.v1", nodes, edges };
+    }
+  }
+  return unknownBlock(v, type);
+}
+function normalizeBlocks(v) {
+  if (!Array.isArray(v)) return { ok: false, reason: "the plugin did not return a list of blocks" };
+  return { ok: true, blocks: v.slice(0, LIMITS.blocks).map(one) };
+}
+function normalizeCards(v) {
+  if (!Array.isArray(v)) return { ok: false, reason: "the plugin did not return a list of cards" };
+  const cards = v.slice(0, LIMITS.cards).flatMap((c) => {
+    if (!isRecord(c)) return [];
+    const key = str(c.key);
+    const title = str(c.title);
+    if (key === null || title === null) return [];
+    const mentions = list(c.mentions, LIMITS.mentions).flatMap((m) => {
+      const href = safeHref(m);
+      return href && !href.startsWith("/") ? [href] : [];
+    });
+    const blocks = normalizeBlocks(c.blocks);
+    return mentions.length ? [{ key, title, mentions, blocks: blocks.ok ? blocks.blocks : [] }] : [];
+  });
+  return { ok: true, cards };
+}
+function matchBridgeCards(text, entries) {
+  const urls = new Set(extractUrls(text));
+  if (!urls.size) return [];
+  const out = [];
+  for (const entry of entries) {
+    if (entry.slot !== "bridge.card" || !entry.content.available) continue;
+    for (const card of entry.content.value) {
+      if (card.mentions.some((m) => urls.has(m))) out.push({ entry, card });
+    }
+  }
+  return out;
+}
+const SECRET_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+const PROJECT_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function andList(items) {
+  if (items.length <= 1) return items.join("");
+  return `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+
+export { PROJECT_ID as P, SECRET_NAME as S, normalizeBlocks as a, andList as b, matchBridgeCards as m, normalizeCards as n, safeHref as s };
+//# sourceMappingURL=vault.js-CTaWe09z.js.map

package/build/server/chunks/chunks/view.js-BPycofxX.js

@@ -0,0 +1,76 @@
+import { g as getRuntime, P as PROJECT_ID } from './runtime.js-4msnOWzY.js';
+
+async function known(id) {
+  const runtime = await getRuntime();
+  if (!runtime.configured)
+    return { ok: false, status: 503, message: runtime.error };
+  if (!PROJECT_ID.test(id))
+    return { ok: false, status: 400, message: "Not a project id." };
+  if (!runtime.collector.getFleet().projects.some((p) => p.id === id)) {
+    return {
+      ok: false,
+      status: 404,
+      message: `There is no project called ${id}.`
+    };
+  }
+  return { ok: true, passages: runtime.passages };
+}
+async function projectPassage(id) {
+  const k = await known(id);
+  if (!k.ok) return k;
+  return { ok: true, view: await k.passages.view(id) };
+}
+async function setPassageConsent(id, digest) {
+  const k = await known(id);
+  if (!k.ok) return k;
+  await k.passages.view(id);
+  let r;
+  try {
+    r = await k.passages.setConsent(id, digest);
+  } catch (e) {
+    return {
+      ok: false,
+      status: 500,
+      message: `Wheelhouse could not save your consent: ${e.message}`
+    };
+  }
+  if (!r.ok) return r;
+  return { ok: true, view: await k.passages.view(id) };
+}
+async function setCommandConsent(id, digest) {
+  const k = await known(id);
+  if (!k.ok) return k;
+  await k.passages.view(id);
+  let r;
+  try {
+    r = await k.passages.setCommandConsent(id, digest);
+  } catch (e) {
+    return {
+      ok: false,
+      status: 500,
+      message: `Wheelhouse could not save your consent: ${e.message}`
+    };
+  }
+  if (!r.ok) return r;
+  return { ok: true, view: await k.passages.view(id) };
+}
+async function passageEditor(id, target) {
+  const k = await known(id);
+  if (!k.ok) return k;
+  const editor = await k.passages.editorFile(id, target);
+  const runtime = await getRuntime();
+  const testable = new Set(k.passages.testable(id));
+  const tasks = runtime.configured ? runtime.collector.getFleet().tasks.filter((t) => t.projectId === id && testable.has(t.id)).map((t) => ({
+    id: t.id,
+    title: t.shortTitle || t.title,
+    track: t.passage.track,
+    step: t.passage.steps[t.passage.current]?.label ?? null
+  })) : [];
+  return { ok: true, editor, tasks };
+}
+async function editorService(id) {
+  return known(id);
+}
+
+export { passageEditor as a, setPassageConsent as b, editorService as e, projectPassage as p, setCommandConsent as s };
+//# sourceMappingURL=view.js-BPycofxX.js.map

package/build/server/chunks/chunks/views.js-DyGxvskG.js

@@ -0,0 +1,124 @@
+import { l as landedAt, n as needsYou, i as isTrouble, a as isCompleted, p as progress, c as completedAt } from './harbour.js-PHLHOFea.js';
+
+const BOARD_VIEWS = ["large", "compact", "list"];
+const VIEW_COOKIE = { harbour: "wh-harbour-view" };
+function viewOf(value, views) {
+  return views.includes(value) ? value : views[0];
+}
+const ms = (iso) => {
+  const t = iso ? Date.parse(iso) : NaN;
+  return Number.isNaN(t) ? null : t;
+};
+function updatedAt(t) {
+  const times = [ms(t.activity?.at), landedAt(t), ms(t.since)].filter(
+    (x) => x !== null
+  );
+  return times.length ? Math.max(...times) : null;
+}
+function waitingOn(t) {
+  if (needsYou(t))
+    return {
+      who: "you",
+      label: t.attention?.kind !== "review" ? "You: decision" : t.attention.approved ? "You: merge" : "You: review"
+    };
+  if (t.status === "with-firstmate" || isTrouble(t))
+    return { who: "firstmate", label: "Firstmate" };
+  if (t.status === "with-reviewers") return { who: "reviewers", label: "Reviewers" };
+  if (isCompleted(t)) return { who: "nobody", label: "—" };
+  if (t.status === "queued")
+    return {
+      who: "queue",
+      label: t.blockedBy.length ? `${t.blockedBy.length} earlier ${t.blockedBy.length === 1 ? "task" : "tasks"}` : "Its turn"
+    };
+  return { who: "crew", label: "Crew" };
+}
+const WAITING_ORDER = {
+  you: 0,
+  firstmate: 1,
+  reviewers: 2,
+  crew: 3,
+  queue: 4,
+  nobody: 5
+};
+const STATUS_ORDER = {
+  "needs-review": 0,
+  "needs-decision": 0,
+  blocked: 1,
+  failed: 1,
+  lost: 2,
+  unknown: 2,
+  "with-firstmate": 3,
+  "with-reviewers": 3,
+  waiting: 4,
+  working: 5,
+  queued: 6,
+  done: 7,
+  landed: 8
+};
+const statusRank = (t) => needsYou(t) ? 0 : STATUS_ORDER[t.status] ?? 5;
+const TASK_FIRST_DIR = {
+  task: "asc",
+  project: "asc",
+  stage: "desc",
+  status: "asc",
+  waiting: "asc",
+  updated: "desc"
+};
+function sortTasks(tasks, sort, projectName) {
+  const text = (a, b) => a.localeCompare(b, void 0, { sensitivity: "base" });
+  const when = (t) => (isCompleted(t) ? completedAt(t) : updatedAt(t)) ?? 0;
+  const by = {
+    task: (a, b) => text(a.shortTitle, b.shortTitle),
+    project: (a, b) => text(projectName(a), projectName(b)),
+    stage: (a, b) => progress(a) - progress(b) || a.passage.current - b.passage.current,
+    status: (a, b) => statusRank(a) - statusRank(b),
+    waiting: (a, b) => WAITING_ORDER[waitingOn(a).who] - WAITING_ORDER[waitingOn(b).who],
+    updated: (a, b) => when(a) - when(b)
+  };
+  const sign = sort.dir === "asc" ? 1 : -1;
+  return tasks.toSorted(
+    (a, b) => sign * by[sort.key](a, b) || statusRank(a) - statusRank(b) || when(b) - when(a)
+  );
+}
+const PROJECT_LANDED_MS = 7 * 24 * 3600 * 1e3;
+function projectStats(tasks, now) {
+  const s = { underWay: 0, needsYou: 0, landed: 0, queued: 0, lastActivity: null };
+  for (const t of tasks) {
+    if (needsYou(t)) s.needsYou++;
+    else if (t.status === "queued") s.queued++;
+    else if (isCompleted(t)) {
+      const at2 = completedAt(t);
+      if (t.status === "landed" && at2 !== null && now - at2 <= PROJECT_LANDED_MS) s.landed++;
+    } else s.underWay++;
+    const at = isCompleted(t) ? completedAt(t) : updatedAt(t);
+    if (at !== null && (s.lastActivity === null || at > s.lastActivity)) s.lastActivity = at;
+  }
+  return s;
+}
+function postureWords(p) {
+  if (!p.registered) return null;
+  const tokens = (p.posture ?? "").split(/\s+/).filter(Boolean);
+  const mode = tokens.find((x) => !x.startsWith("+") && !x.includes("=")) ?? "no-mistakes";
+  const gerrit = tokens.includes("forge=gerrit") ? " on Gerrit" : "";
+  const SHIPS = {
+    "no-mistakes": `Every change runs the full checks before its pull request${gerrit}`,
+    "direct-PR": `Changes go straight to a pull request${gerrit}`,
+    "local-only": "Kept on this machine: changes land locally, with no pull request",
+    "no-mistakes-prod-only": `Product changes run the full checks; internal tooling goes straight to a pull request${gerrit}`
+  };
+  const SHORT = {
+    "no-mistakes": "Full checks",
+    "direct-PR": "Straight to PR",
+    "local-only": "Local only",
+    "no-mistakes-prod-only": "Full checks for product work"
+  };
+  const yolo = mode !== "local-only" && tokens.includes("+yolo");
+  return {
+    ships: SHIPS[mode] ?? `Ships as "${mode}"`,
+    merges: mode === "local-only" ? "You approve each landing" : yolo ? "Firstmate merges once checks are green" : "You merge each pull request",
+    short: `${SHORT[mode] ?? mode} · ${mode === "local-only" ? "you approve" : yolo ? "Firstmate merges" : "you merge"}`
+  };
+}
+
+export { BOARD_VIEWS as B, PROJECT_LANDED_MS as P, TASK_FIRST_DIR as T, VIEW_COOKIE as V, postureWords as a, projectStats as p, sortTasks as s, updatedAt as u, viewOf as v, waitingOn as w };
+//# sourceMappingURL=views.js-DyGxvskG.js.map

package/build/server/chunks/chunks/words.js-Cte4wOB4.js

@@ -0,0 +1,48 @@
+const SLOT_WORDS = {
+  "project.tab": "a tab on each project",
+  "harbour.card": "a card in the Harbour",
+  "task.section": "a section on each task",
+  "step.evidence": "notes on a task’s steps",
+  "bridge.card": "a card in the Firstmate chat",
+  "home.card": "a tab beside the Firstmate chat",
+  "header.indicator": "a sign in the header",
+  "nav.page": "a page of its own in the menu"
+};
+function addsWords(slots) {
+  const words = [...new Set(slots.map((s) => SLOT_WORDS[s]))];
+  if (!words.length) return "Nothing on the pages";
+  const list = words.length === 1 ? words[0] : `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+  return list.charAt(0).toUpperCase() + list.slice(1);
+}
+function addressWords(hostRoutes, addressRewrites) {
+  return [
+    ...hostRoutes.map((h) => `Answers ${h} on Wheelhouse’s port`),
+    ...addressRewrites.map((t) => `Opens addresses on this computer at ${t}`)
+  ];
+}
+function defaultWords(p) {
+  if (p.enabledWhenHomeFile) return "On while Firstmate uses it";
+  if (p.enabledWhenFile) return `On for projects that have a ${p.enabledWhenFile} file`;
+  return p.enabledByDefault ? "On for every project" : "Off until you turn it on";
+}
+function onState(v) {
+  if (v.projects.every((p) => p.on === v.on)) return v.on ? "on" : "off";
+  return v.projects.some((p) => p.on) ? "mixed" : "off";
+}
+function whereOnWords(v) {
+  const total = v.projects.length;
+  const on = v.projects.filter((p) => p.on).length;
+  const state = onState(v);
+  if (state === "off") return "Off";
+  if (state === "on") return total > 1 ? "On for every project" : "On";
+  if (on === total) return `On for ${on === 1 ? "1 project" : `${on} projects`}`;
+  return `On for ${on} of ${total} projects`;
+}
+function backToDefaultWords(v) {
+  const except = v.projects.some((x) => x.enabled !== null) ? " except those you set yourself" : "";
+  return `${v.plugin.name} is back to its default: ${midSentence(defaultWords(v.plugin))}${except}.`;
+}
+const midSentence = (s) => s.charAt(0).toLowerCase() + s.slice(1);
+
+export { addressWords as a, backToDefaultWords as b, addsWords as c, defaultWords as d, midSentence as m, onState as o, whereOnWords as w };
+//# sourceMappingURL=words.js-Cte4wOB4.js.map

package/build/server/chunks/chunks/x.js-YxaUOlq9.js

@@ -0,0 +1,18 @@
+import { ac as spread_props } from './index.js-B0NFhRTN.js';
+import { I as Icon } from './Icon.js-CVZZ-yuB.js';
+
+function X($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "x",
+    "size": 24,
+    "node": [
+      ["path", { "d": "M18 6 6 18" }],
+      ["path", { "d": "m6 6 12 12" }]
+    ]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+
+export { X };
+//# sourceMappingURL=x.js-YxaUOlq9.js.map

package/build/server/chunks/entries/endpoints/api/apps/_op_/_server.ts.js-DqDt7aNN.js

@@ -0,0 +1,90 @@
+import { j as json, C as error } from '../../../../../chunks/utils.js-BJgm9WbO.js';
+import { g as getRuntime, M as MAX_CHAT_CALLS } from '../../../../../chunks/runtime.js-4msnOWzY.js';
+import { N as NO_STORE, r as readJson } from '../../../../../chunks/http.js-CBM8xgUM.js';
+import '../../../../../chunks/utils2.js-BQzn9ikS.js';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:fs';
+import 'node:child_process';
+import '../../../../../chunks/store.js-ByNV-OHV.js';
+import 'node:crypto';
+import '../../../../../chunks/inbox.js-Dv8a1ecX.js';
+import '../../../../../chunks/preview.js-hrimfbCG.js';
+import 'yaml';
+import '../../../../../chunks/passage-meta.js-uvNUyJkg.js';
+import 'node:os';
+import '../../../../../chunks/format.js-D3lWEg6U.js';
+import '../../../../../chunks/checks.js-DR3fVVpO.js';
+import '../../../../../chunks/insights.js-CzzfyHGp.js';
+import '../../../../../chunks/plain.js-Dc97sYaJ.js';
+import '../../../../../chunks/buildlog.js-BCKtSKOt.js';
+import '../../../../../chunks/bell.js-CXJp-3UZ.js';
+import '../../../../../chunks/docpath.js-D27w_pf9.js';
+import '../../../../../chunks/settings.js-C_6kvzhM.js';
+import '../../../../../chunks/urls.js-BrlC6XZ8.js';
+import 'node:url';
+import '../../../../../chunks/vault.js-CTaWe09z.js';
+import '../../../../../chunks/keys.js-iHygUPeb.js';
+import '../../../../../chunks/pullrequests2.js-CCzk2sqm.js';
+import 'node:net';
+import 'node:http';
+import 'ws';
+import '../../../../../chunks/harbour.js-PHLHOFea.js';
+
+const MAX_REQUEST_BYTES = 256 * 1024;
+const str = (v) => typeof v === "string" && v ? v : null;
+function ref(body) {
+  const chat = str(body.chat);
+  if (chat) return { chat };
+  const plugin = str(body.plugin);
+  const contribution = str(body.contribution);
+  if (!plugin || !contribution) error(400, "Name the plugin and the contribution.");
+  return { plugin, contribution, project: str(body.project), task: str(body.task) };
+}
+const POST = async ({ params, request }) => {
+  const r = await getRuntime();
+  if (!r.configured) return json({ message: r.error }, { status: 503, headers: NO_STORE });
+  const read = await readJson(request, MAX_REQUEST_BYTES);
+  if (!read.ok) return read.response;
+  const body = read.body;
+  if (params.op === "chat") {
+    const calls = body.calls;
+    if (!Array.isArray(calls) || calls.length > MAX_CHAT_CALLS || !calls.every((c) => typeof c === "string")) {
+      error(400, `Name at most ${MAX_CHAT_CALLS} tool calls.`);
+    }
+    return json(await r.apps.chatApps(calls), { headers: NO_STORE });
+  }
+  const at = ref(body);
+  const answer = (v) => {
+    if (!v) error(404, "No such app here.");
+    const status = !("ok" in v) || v.ok ? 200 : v.confirm ? 409 : v.refused ? 403 : 502;
+    return json(v, { status, headers: NO_STORE });
+  };
+  switch (params.op) {
+    case "open":
+      return answer(await r.apps.open(at));
+    case "run":
+      return answer(await r.apps.run(at));
+    case "call": {
+      const name = str(body.name);
+      if (!name) error(400, "Name the tool to call.");
+      const args = body.arguments ?? {};
+      if (typeof args !== "object" || args === null || Array.isArray(args)) {
+        error(400, "The arguments must be an object.");
+      }
+      return answer(
+        await r.apps.call(at, name, args, body.confirmed === true)
+      );
+    }
+    case "read": {
+      const uri = str(body.uri);
+      if (!uri) error(400, "Name the resource to read.");
+      return answer(await r.apps.read(at, uri));
+    }
+    default:
+      error(404, "No such app request.");
+  }
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-DqDt7aNN.js.map

package/build/server/chunks/entries/endpoints/api/events/_server.ts.js-D-mwPJ4E.js

@@ -0,0 +1,100 @@
+import { g as getRuntime, k as currentMessages, m as serverInstance, u as unconfiguredFleet, n as unconfiguredHealth } from '../../../../chunks/runtime.js-4msnOWzY.js';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:fs';
+import 'node:child_process';
+import '../../../../chunks/store.js-ByNV-OHV.js';
+import 'node:crypto';
+import '../../../../chunks/inbox.js-Dv8a1ecX.js';
+import '../../../../chunks/preview.js-hrimfbCG.js';
+import 'yaml';
+import '../../../../chunks/passage-meta.js-uvNUyJkg.js';
+import 'node:os';
+import '../../../../chunks/format.js-D3lWEg6U.js';
+import '../../../../chunks/checks.js-DR3fVVpO.js';
+import '../../../../chunks/insights.js-CzzfyHGp.js';
+import '../../../../chunks/plain.js-Dc97sYaJ.js';
+import '../../../../chunks/buildlog.js-BCKtSKOt.js';
+import '../../../../chunks/bell.js-CXJp-3UZ.js';
+import '../../../../chunks/docpath.js-D27w_pf9.js';
+import '../../../../chunks/settings.js-C_6kvzhM.js';
+import '../../../../chunks/urls.js-BrlC6XZ8.js';
+import 'node:url';
+import '../../../../chunks/vault.js-CTaWe09z.js';
+import '../../../../chunks/keys.js-iHygUPeb.js';
+import '../../../../chunks/pullrequests2.js-CCzk2sqm.js';
+import 'node:net';
+import 'node:http';
+import 'ws';
+import '../../../../chunks/harbour.js-PHLHOFea.js';
+
+const HEARTBEAT_MS = 15e3;
+const GET = async ({ request }) => {
+  const runtime = await getRuntime();
+  const messages = await currentMessages();
+  const encoder = new TextEncoder();
+  let cleanup = () => {
+  };
+  const stream = new ReadableStream({
+    start(controller) {
+      let closed = false;
+      const send = (chunk) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(chunk));
+        } catch {
+          cleanup();
+        }
+      };
+      const event = (e) => send(`event: ${e.type}
+data: ${JSON.stringify(e.data)}
+
+`);
+      send("retry: 3000\n\n");
+      send(`event: server
+data: ${JSON.stringify({ id: serverInstance() })}
+
+`);
+      if (runtime.configured) {
+        event({ type: "fleet", data: runtime.collector.getFleet() });
+        event({ type: "health", data: runtime.collector.health() });
+        event({ type: "alerts", data: runtime.bell.recent() });
+      } else {
+        event({ type: "fleet", data: unconfiguredFleet(runtime.error) });
+        event({ type: "health", data: unconfiguredHealth(runtime.error) });
+      }
+      event({ type: "messages", data: messages });
+      const unsubscribe = runtime.configured ? runtime.collector.subscribe(event) : () => {
+      };
+      const unring = runtime.configured ? runtime.bell.subscribe(event) : () => {
+      };
+      const heartbeat = setInterval(() => send(": keep-alive\n\n"), HEARTBEAT_MS);
+      cleanup = () => {
+        if (closed) return;
+        closed = true;
+        clearInterval(heartbeat);
+        unsubscribe();
+        unring();
+        try {
+          controller.close();
+        } catch {
+        }
+      };
+      request.signal.addEventListener("abort", () => cleanup());
+    },
+    cancel() {
+      cleanup();
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-store",
+      connection: "keep-alive",
+      "x-accel-buffering": "no"
+    }
+  });
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-D-mwPJ4E.js.map

package/build/server/chunks/entries/endpoints/api/files/_server.ts.js-DTl4eBah.js

@@ -0,0 +1,49 @@
+import { C as error } from '../../../../chunks/utils.js-BJgm9WbO.js';
+import { o as currentFileRoots, p as readAsset } from '../../../../chunks/runtime.js-4msnOWzY.js';
+import '../../../../chunks/utils2.js-BQzn9ikS.js';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:fs';
+import 'node:child_process';
+import '../../../../chunks/store.js-ByNV-OHV.js';
+import 'node:crypto';
+import '../../../../chunks/inbox.js-Dv8a1ecX.js';
+import '../../../../chunks/preview.js-hrimfbCG.js';
+import 'yaml';
+import '../../../../chunks/passage-meta.js-uvNUyJkg.js';
+import 'node:os';
+import '../../../../chunks/format.js-D3lWEg6U.js';
+import '../../../../chunks/checks.js-DR3fVVpO.js';
+import '../../../../chunks/insights.js-CzzfyHGp.js';
+import '../../../../chunks/plain.js-Dc97sYaJ.js';
+import '../../../../chunks/buildlog.js-BCKtSKOt.js';
+import '../../../../chunks/bell.js-CXJp-3UZ.js';
+import '../../../../chunks/docpath.js-D27w_pf9.js';
+import '../../../../chunks/settings.js-C_6kvzhM.js';
+import '../../../../chunks/urls.js-BrlC6XZ8.js';
+import 'node:url';
+import '../../../../chunks/vault.js-CTaWe09z.js';
+import '../../../../chunks/keys.js-iHygUPeb.js';
+import '../../../../chunks/pullrequests2.js-CCzk2sqm.js';
+import 'node:net';
+import 'node:http';
+import 'ws';
+import '../../../../chunks/harbour.js-PHLHOFea.js';
+
+const GET = async ({ url }) => {
+  const roots = await currentFileRoots();
+  if (!roots) error(503, "Firstmate is not set up.");
+  const r = await readAsset(url.searchParams.get("path") ?? "", roots);
+  if (!r.ok) error(r.status, r.message);
+  return new Response(new Uint8Array(r.data), {
+    headers: {
+      "content-type": r.type,
+      "cache-control": "private, no-cache",
+      "x-content-type-options": "nosniff",
+      "content-security-policy": "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; sandbox"
+    }
+  });
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-DTl4eBah.js.map