@chrisjowen/wheelhouse 0.2.0 → 0.2.1

package/build/server/chunks/chunks/slots.svelte.js-CLIV5nwM.js

@@ -0,0 +1,34 @@
+import { b as slotsUrl } from './keys.js-iHygUPeb.js';
+
+const MIN_INTERVAL_MS = 15e3;
+class Slots {
+  fetched = {};
+  seen = /* @__PURE__ */ new Map();
+  last = /* @__PURE__ */ new Map();
+  /**
+   * The newer of the page's own load (made at `loadedAt`) and the last refetch;
+   * a page without its own load keeps the last one a page provided.
+   */
+  entries(key, initial, loadedAt) {
+    const view = initial?.[key];
+    if (view && loadedAt >= (this.seen.get(key)?.at ?? -Infinity)) this.seen.set(key, { at: loadedAt, view });
+    const s = this.seen.get(key);
+    const f = this.fetched[key];
+    return (f && f.at > (s?.at ?? -Infinity) ? f.view : s?.view)?.entries ?? [];
+  }
+  /** Refetch, unless this key was loaded or refetched within the last 15 s. */
+  refresh(key, loadedAt) {
+    const now = Date.now();
+    const last = Math.max(this.last.get(key) ?? 0, loadedAt, this.seen.get(key)?.at ?? 0);
+    if (now - last < MIN_INTERVAL_MS) return;
+    this.last.set(key, now);
+    fetch(slotsUrl(key)).then((r) => r.ok ? r.json() : null).then((v) => {
+      if (v?.schema === "wheelhouse-slots.v1") this.fetched[key] = { at: now, view: v };
+    }).catch(() => {
+    });
+  }
+}
+const slots = new Slots();
+
+export { slots as s };
+//# sourceMappingURL=slots.svelte.js-CLIV5nwM.js.map

package/build/server/chunks/chunks/store.js-ByNV-OHV.js

@@ -0,0 +1,323 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { readFile, rename, mkdir, writeFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { a as answerOf } from './inbox.js-Dv8a1ecX.js';
+import { F as FEEDBACK_PREFIX } from './preview.js-hrimfbCG.js';
+
+const CI_READY_NOTE = /\bPR\b.*checks green|checks green.*\bPR\b/;
+const DECISIVE = /* @__PURE__ */ new Set(["done", "working", "blocked", "failed", "needs-decision"]);
+const isCiReady = (s) => s.state === "done" && CI_READY_NOTE.test(s.text);
+function readyTimes(prUrl, ledger) {
+  const times = (ledger?.statuses ?? []).filter(isCiReady).map((s) => s.ts);
+  if (ledger?.prReady && ledger.prReady.pr === prUrl) times.push(ledger.prReady.ts);
+  return [...new Set(times)].sort((a, b) => a - b);
+}
+const TEXT_MAX = 2e3;
+const iso = (ts) => new Date(ts * 1e3).toISOString();
+function reviewNoteOf(text) {
+  const m = /^Change requested from the PR review(?: \([^)\n]*\))?(?: at (.+), line (\d+))?:\n([\s\S]*)$/.exec(
+    text
+  );
+  if (!m) return null;
+  return { where: m[1] ? { path: m[1], line: Number(m[2]) } : null, text: m[3].trim() };
+}
+function wheelhouseRequest(m) {
+  if (FEEDBACK_PREFIX.test(m.text)) {
+    return { kind: "preview", text: m.text.replace(FEEDBACK_PREFIX, "").trim(), where: null };
+  }
+  const note = reviewNoteOf(m.text);
+  if (note) return { kind: "pr-review", text: note.text, where: note.where };
+  const answer = answerOf(m.text);
+  if (answer?.choice === "fix") {
+    return {
+      kind: "decision",
+      text: answer.note ?? (answer.question ? `Fix: ${answer.question}` : "Fix it."),
+      where: null
+    };
+  }
+  return null;
+}
+const isChangeRequest = (m) => m.taskId !== null && wheelhouseRequest(m) !== null;
+function taskRuns(i) {
+  const ready = readyTimes(i.prUrl, i.ledger);
+  if (!ready.length) return null;
+  const firstReady = ready[0];
+  const f = i.feedback;
+  const head = f?.head ?? null;
+  const readyAfter = (at) => ready.some((r) => r > at);
+  const github = (f?.items ?? []).map((x) => ({
+    id: `github:${x.id}`,
+    source: "github",
+    kind: x.kind,
+    author: x.author,
+    text: x.text.slice(0, TEXT_MAX) || (x.state === "CHANGES_REQUESTED" ? "Changes requested." : ""),
+    at: iso(x.at),
+    ts: x.at,
+    url: x.url,
+    where: x.path ? { path: x.path, line: x.line } : null,
+    state: x.resolved ? "resolved" : readyAfter(x.at) ? "addressed" : "open"
+  }));
+  const wheelhouse = i.sent.flatMap((m) => {
+    if (m.taskId !== i.taskId || m.delivery === "failed") return [];
+    const ts = Math.floor(Date.parse(m.submittedAt) / 1e3);
+    if (Number.isNaN(ts) || ts <= firstReady) return [];
+    const r = wheelhouseRequest(m);
+    if (!r) return [];
+    return [
+      {
+        id: `wheelhouse:${m.requestId}`,
+        source: "wheelhouse",
+        ...r,
+        text: r.text.slice(0, TEXT_MAX),
+        author: null,
+        at: m.submittedAt,
+        ts,
+        url: null,
+        state: readyAfter(ts) ? "addressed" : "open"
+      }
+    ];
+  });
+  const triggers = [
+    ...[...github, ...wheelhouse].filter((x) => x.state !== "resolved" || x.source === "wheelhouse").map((item) => ({ ts: item.ts, kind: "asked", item })),
+    ...head?.at != null && head.at > firstReady ? [{ ts: head.at, kind: "commits" }] : [],
+    ...(i.ledger?.statuses ?? []).filter((s) => s.state === "working" && s.ts > firstReady).map((s) => ({ ts: s.ts, kind: "worker" }))
+  ];
+  const resolved = github.filter((x) => x.state === "resolved");
+  const events = [
+    ...ready.map((ts) => ({ ts, ready: true })),
+    ...triggers.map((t) => ({ ...t, ready: false }))
+  ].sort((a, b) => a.ts - b.ts || (a.ready ? -1 : 1));
+  const runs = [
+    {
+      n: 1,
+      start: i.ledger?.dispatched?.ts ?? null,
+      readyAt: null,
+      endedAt: null,
+      kinds: /* @__PURE__ */ new Set(),
+      items: []
+    }
+  ];
+  const early = [];
+  for (const e of events) {
+    const cur = runs[runs.length - 1];
+    if (e.ready) {
+      if (cur.readyAt === null) cur.readyAt = e.ts;
+      continue;
+    }
+    if (cur.readyAt === null) {
+      if (e.item) (cur.n > 1 ? cur.items : early).push(e.item);
+      if (cur.n > 1) cur.kinds.add(e.kind);
+      continue;
+    }
+    cur.endedAt = e.ts;
+    runs.push({
+      n: cur.n + 1,
+      start: e.ts,
+      readyAt: null,
+      endedAt: null,
+      kinds: /* @__PURE__ */ new Set([e.kind]),
+      items: [...cur.n === 1 ? early.splice(0) : [], ...e.item ? [e.item] : []]
+    });
+  }
+  for (const x of resolved) {
+    const run = [...runs].reverse().find((r) => r.n > 1 && r.start !== null && r.start <= x.ts);
+    if (run && !run.items.includes(x)) run.items.push(x);
+  }
+  const open = !f?.state || f.state === "open";
+  const last = runs[runs.length - 1];
+  const out = runs.map((r) => {
+    const sources = new Set(r.items.map((x) => x.source));
+    const where = [
+      sources.has("github") && "on GitHub",
+      sources.has("wheelhouse") && "from Wheelhouse"
+    ].filter(Boolean);
+    const basis = r.n === 1 ? null : where.length ? `You asked for changes ${where.join(" and ")} after run ${r.n - 1} was reported ready.` : r.kinds.has("commits") ? `New commits were pushed after run ${r.n - 1} was reported ready.` : `The worker went back to work after run ${r.n - 1} was reported ready.`;
+    const outcome = r !== last ? "changes-requested" : i.merged ? "landed" : r.readyAt !== null ? "ready" : open ? "building" : "closed";
+    return {
+      n: r.n,
+      startedAt: r.start === null ? null : iso(r.start),
+      readyAt: r.readyAt === null ? null : iso(r.readyAt),
+      endedAt: r.endedAt === null ? null : iso(r.endedAt),
+      outcome,
+      basis,
+      changes: r.items.sort((a, b) => a.ts - b.ts).map(({ ts, ...x }) => x)
+    };
+  });
+  const current = out[out.length - 1];
+  return {
+    current: current.n,
+    reworking: current.n > 1 && current.outcome === "building",
+    runs: out
+  };
+}
+const workerWindow = (target) => target?.split(":").pop()?.trim() || null;
+function changeRoute(f) {
+  if (!f.prUrl || !readyTimes(f.prUrl, f.ledger).length) return null;
+  const send = `send it this change with \`fm-send.sh ${f.taskId}\``;
+  const exists = f.snapshotCurrent ? f.row ? f.row.endpoint.exists : false : null;
+  if (exists === true) {
+    const name = workerWindow(f.row.endpoint.target);
+    return `Routing: the worker that opened ${f.prUrl}${name ? ` (${name})` : ""} is still live; ${send} instead of starting another session.`;
+  }
+  if (exists === false) {
+    return `Routing: the worker that opened ${f.prUrl} is gone; start a new run on that pull request for this change.`;
+  }
+  return `Routing: Wheelhouse could not tell whether the worker that opened ${f.prUrl} is still live. If it is, ${send}; start a new run only if it is gone.`;
+}
+const STORE_SCHEMA = "wheelhouse-message-store.v1";
+const STORE_MAX_MESSAGES = 500;
+const STORE_MAX_CHANGE_REQUESTS = 2e3;
+function defaultStateDir(env) {
+  if (env.WHEELHOUSE_STATE_DIR) return path.resolve(env.WHEELHOUSE_STATE_DIR);
+  if (env.XDG_STATE_HOME) return path.join(path.resolve(env.XDG_STATE_HOME), "wheelhouse");
+  return path.join(env.HOME ?? "", ".local", "state", "wheelhouse");
+}
+function real(p) {
+  const abs = path.resolve(p);
+  try {
+    return realpathSync(abs);
+  } catch {
+    const parent = path.dirname(abs);
+    return parent === abs ? abs : path.join(real(parent), path.basename(abs));
+  }
+}
+function storeFileFor(stateDir, homeDir) {
+  const key = createHash("sha256").update(real(homeDir)).digest("hex").slice(0, 16);
+  return path.join(stateDir, "homes", key, "messages.json");
+}
+function isInside(p, dir) {
+  const rel = path.relative(real(dir), real(p));
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+const DELIVERIES = [
+  "sending",
+  "delivered",
+  "saved-unannounced",
+  "uncertain",
+  "failed"
+];
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => typeof v === "string" ? v : null;
+const bool = (v) => typeof v === "boolean" ? v : null;
+function parseMessage(v) {
+  if (!isObj(v)) return null;
+  const requestId = str(v.requestId);
+  const body = str(v.body);
+  if (!requestId || body === null) return null;
+  const delivery = DELIVERIES.includes(v.delivery) ? v.delivery : null;
+  const reply = isObj(v.reply) ? { body: str(v.reply.body) ?? "", at: str(v.reply.at), cursor: str(v.reply.cursor) ?? "" } : null;
+  return {
+    requestId,
+    text: str(v.text) ?? body,
+    taskId: str(v.taskId),
+    body,
+    submittedAt: str(v.submittedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    delivery: delivery ?? "uncertain",
+    deliveryDetail: str(v.deliveryDetail),
+    noteId: str(v.noteId),
+    acknowledged: bool(v.acknowledged),
+    announced: bool(v.announced),
+    reply,
+    attempts: typeof v.attempts === "number" ? v.attempts : 0,
+    lastAttemptAt: str(v.lastAttemptAt)
+  };
+}
+class MessageStore {
+  file;
+  home;
+  receiptCursor = "";
+  /** Set when an unreadable store file was moved aside on load. */
+  recovered = null;
+  list = [];
+  writing = Promise.resolve();
+  constructor(file, home) {
+    this.file = file;
+    this.home = home;
+  }
+  /**
+   * Load the store for `home`. A missing file is an empty store. An unreadable
+   * one is moved aside (never deleted) and the store starts empty. A message
+   * left `sending` by a Wheelhouse that stopped mid-send becomes `uncertain`,
+   * so the next reconciliation re-checks it with the same request id.
+   */
+  static async open(file, home) {
+    const store = new MessageStore(file, home);
+    let text = null;
+    try {
+      text = await readFile(file, "utf8");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    if (text !== null) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = null;
+      }
+      if (isObj(parsed) && parsed.schema === STORE_SCHEMA && Array.isArray(parsed.messages)) {
+        store.receiptCursor = str(parsed.receiptCursor) ?? "";
+        store.list = parsed.messages.map(parseMessage).filter((m) => m !== null);
+      } else {
+        const aside = `${file}.unreadable-${Date.now()}`;
+        await rename(file, aside);
+        store.recovered = aside;
+      }
+    }
+    for (const m of store.list) {
+      if (m.delivery === "sending") {
+        m.delivery = "uncertain";
+        m.deliveryDetail = "Wheelhouse stopped while sending this; it is checking again.";
+      }
+    }
+    return store;
+  }
+  messages() {
+    return this.list;
+  }
+  get(requestId) {
+    return this.list.find((m) => m.requestId === requestId);
+  }
+  add(m) {
+    this.list.push(m);
+    const kept = (x) => isChangeRequest(x) && x.delivery !== "failed";
+    const asks = this.list.filter(kept);
+    const rest = this.list.filter((x) => !kept(x));
+    const drop = /* @__PURE__ */ new Set([
+      ...asks.slice(0, Math.max(0, asks.length - STORE_MAX_CHANGE_REQUESTS)),
+      ...rest.slice(0, Math.max(0, rest.length - STORE_MAX_MESSAGES))
+    ]);
+    if (drop.size) this.list = this.list.filter((x) => !drop.has(x));
+  }
+  remove(requestId) {
+    this.list = this.list.filter((m) => m.requestId !== requestId);
+  }
+  /** Write the store as it is now. Writes are serialised, so the latest save wins. */
+  save() {
+    const data = {
+      schema: STORE_SCHEMA,
+      home: this.home,
+      receiptCursor: this.receiptCursor,
+      messages: this.list
+    };
+    const text = JSON.stringify(data, null, "	") + "\n";
+    this.writing = this.writing.catch(() => {
+    }).then(() => this.write(text));
+    return this.writing;
+  }
+  async write(text) {
+    await mkdir(path.dirname(this.file), { recursive: true, mode: 448 });
+    const tmp = `${this.file}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+    try {
+      await writeFile(tmp, text, { mode: 384 });
+      await rename(tmp, this.file);
+    } catch (e) {
+      await rm(tmp, { force: true });
+      throw e;
+    }
+  }
+}
+
+export { CI_READY_NOTE as C, DECISIVE as D, MessageStore as M, isChangeRequest as a, changeRoute as c, defaultStateDir as d, isInside as i, readyTimes as r, storeFileFor as s, taskRuns as t, workerWindow as w };
+//# sourceMappingURL=store.js-ByNV-OHV.js.map

package/build/server/chunks/chunks/uploads.js-4OZ09onz.js

@@ -0,0 +1,107 @@
+import { randomBytes } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { readdir, rm, mkdir, open } from 'node:fs/promises';
+import path from 'node:path';
+import { Transform, Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { U as UPLOAD_KEEP_DAYS, a as UPLOAD_MAX_BYTES } from './attachments.js-BAnnqpd-.js';
+import { d as defaultStateDir, i as isInside } from './store.js-ByNV-OHV.js';
+
+const uploadsDir = (env) => path.join(defaultStateDir(env), "uploads");
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+const ID = /^[a-f0-9]{12}$/;
+const NAME_MAX = 120;
+function safeName(raw) {
+  const base = raw.split(/[/\\]/).pop() ?? "";
+  let name = base.normalize("NFC").replace(/\s+/g, " ").replace(/[\u0000-\u001f\u007f]/g, "").replace(/[<>:"|?*[\]`$\\]/g, "_").trim().replace(/^[.\s-]+/, "");
+  if (name.length > NAME_MAX) {
+    const ext = /\.[A-Za-z0-9]{1,10}$/.exec(name)?.[0] ?? "";
+    name = name.slice(0, NAME_MAX - ext.length).trimEnd() + ext;
+  }
+  return name || "file";
+}
+function safeType(raw) {
+  const t = (raw ?? "").split(";")[0].trim().toLowerCase();
+  return /^[a-z0-9][\w.+-]*\/[a-z0-9][\w.+-]*$/.test(t) && t.length <= 100 ? t : "";
+}
+const TOO_LARGE = `That file is over ${UPLOAD_MAX_BYTES / (1024 * 1024)} MB, the most Wheelhouse takes.`;
+async function saveUpload(dir, opts) {
+  if (!opts.body) return { ok: false, status: 400, error: "The file is empty." };
+  const name = safeName(opts.name);
+  const day = (opts.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const folder = path.join(dir, day, randomBytes(6).toString("hex"));
+  const file = path.join(folder, name);
+  await mkdir(folder, { recursive: true, mode: 448 });
+  let size = 0;
+  const count = new Transform({
+    transform(chunk, _enc, done) {
+      size += chunk.length;
+      if (size > UPLOAD_MAX_BYTES) done(new RangeError(TOO_LARGE));
+      else done(null, chunk);
+    }
+  });
+  try {
+    await pipeline(
+      Readable.fromWeb(opts.body),
+      count,
+      createWriteStream(file, { mode: 384, flags: "wx" })
+    );
+  } catch (e) {
+    await rm(folder, { recursive: true, force: true });
+    if (e instanceof RangeError) return { ok: false, status: 413, error: TOO_LARGE };
+    return { ok: false, status: 500, error: "Wheelhouse could not save the file." };
+  }
+  if (size === 0) {
+    await rm(folder, { recursive: true, force: true });
+    return { ok: false, status: 400, error: "The file is empty." };
+  }
+  return { ok: true, upload: { path: file, name, size, type: opts.type } };
+}
+async function cleanUploads(dir, now = /* @__PURE__ */ new Date(), keepDays = UPLOAD_KEEP_DAYS) {
+  const cutoff = new Date(now.getTime() - keepDays * 864e5).toISOString().slice(0, 10);
+  let days;
+  try {
+    days = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const old = days.filter((d) => DAY.test(d) && d < cutoff);
+  await Promise.all(
+    old.map((d) => rm(path.join(dir, d), { recursive: true, force: true }).catch(() => {
+    }))
+  );
+  return old;
+}
+function sniffImage(head) {
+  const b = Buffer.from(head);
+  if (b.length >= 8 && b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+    return "image/png";
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return "image/jpeg";
+  if (b.length >= 6 && /^GIF8[79]a$/.test(b.subarray(0, 6).toString("latin1"))) return "image/gif";
+  if (b.length >= 12 && b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP")
+    return "image/webp";
+  if (b.length >= 12 && /^ftypavi[fs]$/.test(b.subarray(4, 12).toString("latin1")))
+    return "image/avif";
+  return null;
+}
+async function uploadedImage(dir, day, id, name) {
+  if (!DAY.test(day) || !ID.test(id) || safeName(name) !== name) return null;
+  const file = path.join(dir, day, id, name);
+  if (!isInside(file, dir)) return null;
+  let fh;
+  try {
+    fh = await open(file, "r");
+    const st = await fh.stat();
+    if (!st.isFile() || st.size > UPLOAD_MAX_BYTES) return null;
+    const bytes = await fh.readFile();
+    const type = sniffImage(bytes.subarray(0, 16));
+    return type ? { file, type, bytes } : null;
+  } catch {
+    return null;
+  } finally {
+    await fh?.close();
+  }
+}
+
+export { TOO_LARGE as T, safeType as a, uploadedImage as b, cleanUploads as c, saveUpload as s, uploadsDir as u };
+//# sourceMappingURL=uploads.js-4OZ09onz.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/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