@chrisjowen/wheelhouse 0.1.1 → 0.2.0

package/build/server/chunks/chunks/square-terminal.js-D9D9_9_V.js

@@ -0,0 +1,30 @@
+import { ac as spread_props } from './index.js-B0NFhRTN.js';
+import { I as Icon } from './Icon.js-CVZZ-yuB.js';
+
+function Square_terminal($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "square-terminal",
+    "size": 24,
+    "node": [
+      ["path", { "d": "m7 11 2-2-2-2" }],
+      ["path", { "d": "M11 13h4" }],
+      [
+        "rect",
+        {
+          "width": "18",
+          "height": "18",
+          "x": "3",
+          "y": "3",
+          "rx": "2",
+          "ry": "2"
+        }
+      ]
+    ],
+    "aliases": ["terminal-square"]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+
+export { Square_terminal as S };
+//# sourceMappingURL=square-terminal.js-D9D9_9_V.js.map

package/build/server/chunks/chunks/store.js-XXOawxPN.js

@@ -0,0 +1,317 @@
+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';
+import { c as changeNoteOf } from './prreview.js-Cg9LDxJp.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 wheelhouseRequest(m) {
+  if (FEEDBACK_PREFIX.test(m.text)) {
+    return { kind: "preview", text: m.text.replace(FEEDBACK_PREFIX, "").trim(), where: null };
+  }
+  const note = changeNoteOf(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-XXOawxPN.js.map

package/build/server/chunks/chunks/tone.js-Dxsl-adt.js

@@ -0,0 +1,31 @@
+function tone(t) {
+  if (t.attention?.owner === "captain") return "you";
+  if (["blocked", "failed", "lost", "unknown"].includes(t.status)) return "trouble";
+  if (t.status === "landed") return "landed";
+  if (t.status === "with-firstmate") return "firstmate";
+  return "normal";
+}
+const alertTone = {
+  "pr-green": "you",
+  question: "you",
+  stuck: "trouble",
+  landed: "landed",
+  issue: "you"
+};
+const dotClass = {
+  you: "bg-sea",
+  trouble: "bg-danger",
+  landed: "bg-success",
+  firstmate: "bg-warning",
+  normal: "bg-foreground"
+};
+const textClass = {
+  you: "text-sea",
+  trouble: "text-danger",
+  landed: "text-success",
+  firstmate: "text-warning",
+  normal: "text-foreground"
+};
+
+export { alertTone as a, tone as b, dotClass as d, textClass as t };
+//# sourceMappingURL=tone.js-Dxsl-adt.js.map

package/build/server/chunks/chunks/triangle-alert.js-ClLszsZE.js

@@ -0,0 +1,25 @@
+import { ac as spread_props } from './index.js-B0NFhRTN.js';
+import { I as Icon } from './Icon.js-CVZZ-yuB.js';
+
+function Triangle_alert($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "triangle-alert",
+    "size": 24,
+    "node": [
+      [
+        "path",
+        {
+          "d": "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"
+        }
+      ],
+      ["path", { "d": "M12 9v4" }],
+      ["path", { "d": "M12 17h.01" }]
+    ],
+    "aliases": ["alert-triangle"]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+
+export { Triangle_alert as T };
+//# sourceMappingURL=triangle-alert.js-ClLszsZE.js.map

package/build/server/chunks/chunks/uploads.js-D45pIvPk.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-XXOawxPN.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-D45pIvPk.js.map

package/build/server/chunks/chunks/urls.js-BrlC6XZ8.js

@@ -0,0 +1,8 @@
+const URL_RE = /https?:\/\/[^\s<>"'`]+/g;
+const TRAILING = /[.,;:!?)\]}'"]+$/;
+function extractUrls(text) {
+  return [...text.matchAll(URL_RE)].map((m) => m[0].replace(TRAILING, ""));
+}
+
+export { extractUrls as e };
+//# sourceMappingURL=urls.js-BrlC6XZ8.js.map