@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.10

package/dist/chunk-HHUFVJF7.js

@@ -0,0 +1,1019 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-47QE246J.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-XQ3YIV5R.js";
+import {
+  QueryError,
+  askLookup,
+  graph,
+  impact,
+  openIndex,
+  translate
+} from "./chunk-N4QZJJVB.js";
+import {
+  baseClonePath,
+  gitUser,
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import {
+  API_VERSION,
+  DEFAULT_PORT,
+  Lens,
+  RECORD_KINDS,
+  Severity,
+  catalogDirOf,
+  factsDirOf,
+  fastPathOf,
+  inputsDirOf,
+  knowledgeDirOf,
+  layoutOf,
+  loadOrgPack,
+  openspecDirOf,
+  orgPackDirOf,
+  proposalsDirOf,
+  questionOfLens,
+  questionsDirOf,
+  runsDirOf,
+  specsDirOf,
+  withSignal
+} from "./chunk-577AJVRS.js";
+import {
+  SCHEMA_VERSION
+} from "./chunk-D3PO4DOZ.js";
+
+// packages/server/dist/http.js
+var HttpError = class extends Error {
+  status;
+  title;
+  detail;
+  extra;
+  constructor(status, title, detail, extra = {}) {
+    super(detail ?? title);
+    this.status = status;
+    this.title = title;
+    this.detail = detail;
+    this.extra = extra;
+  }
+};
+var badRequest = (detail, extra = {}) => new HttpError(400, "The request isn't valid", detail, extra);
+var notFound = (detail) => new HttpError(404, "Not found", detail);
+var conflict = (detail) => new HttpError(409, "Conflict", detail);
+var Router = class {
+  routes = [];
+  add(method, pattern, handler, o = {}) {
+    this.routes.push({
+      method,
+      parts: pattern.split("/").filter(Boolean),
+      handler,
+      ...o.maxBody ? { maxBody: o.maxBody } : {}
+    });
+    return this;
+  }
+  /** The handler and path params, or the methods the path does allow (for 405). */
+  match(method, path) {
+    const segs = path.split("/").filter(Boolean);
+    const allowed = [];
+    for (const r of this.routes) {
+      if (r.parts.length !== segs.length)
+        continue;
+      const params = {};
+      let ok = true;
+      for (let i = 0; i < segs.length; i++) {
+        const want = r.parts[i];
+        let got;
+        try {
+          got = decodeURIComponent(segs[i]);
+        } catch {
+          ok = false;
+          break;
+        }
+        if (want.startsWith("{") && want.endsWith("}"))
+          params[want.slice(1, -1)] = got;
+        else if (want !== got) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok)
+        continue;
+      if (r.method === method)
+        return { handler: r.handler, params, ...r.maxBody ? { maxBody: r.maxBody } : {} };
+      allowed.push(r.method);
+    }
+    return { allowed };
+  }
+};
+function problem(e) {
+  return {
+    type: `https://atticus.dev/problems/${e.status}`,
+    title: e.title,
+    status: e.status,
+    ...e.detail ? { detail: e.detail } : {},
+    ...e.extra
+  };
+}
+function intParam(q, name, min, max) {
+  const v = q.get(name);
+  if (v === null || v === "")
+    return void 0;
+  const n = Number(v);
+  if (!Number.isInteger(n) || n < min || n > max)
+    throw badRequest(`${name} must be a whole number from ${min} to ${max}.`);
+  return n;
+}
+var strParam = (q, name) => q.get(name) || void 0;
+
+// packages/server/dist/server.js
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+
+// packages/server/dist/jobs.js
+var JobManager = class {
+  publish;
+  now;
+  jobs = /* @__PURE__ */ new Map();
+  cancelledIds = /* @__PURE__ */ new Set();
+  aborts = /* @__PURE__ */ new Map();
+  seq = 0;
+  running = /* @__PURE__ */ new Map();
+  constructor(publish, now = () => /* @__PURE__ */ new Date()) {
+    this.publish = publish;
+    this.now = now;
+  }
+  /** The running job of a kind, if any (one scan at a time: a second asks gets 409). */
+  runningOf(kind) {
+    const id = this.running.get(kind);
+    return id ? this.jobs.get(id) : void 0;
+  }
+  get(id) {
+    return this.jobs.get(id);
+  }
+  start(kind, work) {
+    const id = `job-${++this.seq}`;
+    const job = {
+      id,
+      kind,
+      state: "running",
+      progress: { done: 0, total: 0, message: "Starting" },
+      startedAt: this.now().toISOString(),
+      errors: []
+    };
+    this.jobs.set(id, job);
+    this.running.set(kind, id);
+    const abort = new AbortController();
+    this.aborts.set(id, abort);
+    const cancelled = this.cancelledIds;
+    const control = {
+      progress: (done, total, message) => {
+        job.progress = { done, total, message };
+        this.publish({ type: "job.progress", jobId: id, done, total, message });
+      },
+      get cancelled() {
+        return cancelled.has(id);
+      }
+    };
+    void (async () => {
+      try {
+        const out = await withSignal(abort.signal, () => work(control));
+        if (out?.result)
+          job.result = out.result;
+        if (out?.errors?.length)
+          job.errors.push(...out.errors);
+        job.state = this.cancelledIds.has(id) ? "cancelled" : job.errors.length ? "failed" : "done";
+      } catch (e) {
+        if (this.cancelledIds.has(id))
+          job.state = "cancelled";
+        else {
+          job.errors.push(e instanceof Error ? e.message : String(e));
+          job.state = "failed";
+        }
+      }
+      this.aborts.delete(id);
+      job.finishedAt = this.now().toISOString();
+      if (this.running.get(kind) === id)
+        this.running.delete(kind);
+      this.publish({ type: "job.done", jobId: id, state: job.state });
+    })();
+    return job;
+  }
+  /** Ask a running job to stop; false when it already finished. */
+  cancel(id) {
+    const j = this.jobs.get(id);
+    if (!j || j.state !== "running")
+      return false;
+    this.cancelledIds.add(id);
+    this.aborts.get(id)?.abort();
+    return true;
+  }
+  /** Wait for a job to finish (tests and the CLI). */
+  async settle(id, timeoutMs = 6e4) {
+    const start = Date.now();
+    for (; ; ) {
+      const j = this.jobs.get(id);
+      if (!j)
+        throw new Error(`No job ${id}`);
+      if (j.state !== "running" && j.state !== "queued")
+        return j;
+      if (Date.now() - start > timeoutMs)
+        throw new Error(`Job ${id} did not finish`);
+      await new Promise((r) => setTimeout(r, 20));
+    }
+  }
+};
+
+// packages/server/dist/routes.js
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+var queues = /* @__PURE__ */ new Map();
+async function withIndex(root, f) {
+  const before = queues.get(root) ?? Promise.resolve();
+  const mine = before.then(async () => {
+    const ix = await openIndex(root);
+    try {
+      return f(ix);
+    } finally {
+      ix.close();
+    }
+  });
+  const settled = mine.catch(() => void 0);
+  queues.set(root, settled);
+  void settled.then(() => {
+    if (queues.get(root) === settled)
+      queues.delete(root);
+  });
+  return mine;
+}
+function kindParam(kind) {
+  if (!RECORD_KINDS.includes(kind))
+    throw badRequest(`${kind} is not a record kind. Kinds: ${RECORD_KINDS.join(", ")}.`);
+  return kind;
+}
+function enumParam(q, name, options) {
+  const v = strParam(q, name);
+  if (v !== void 0 && !options.includes(v))
+    throw badRequest(`${name} must be one of ${options.join(", ")}.`);
+  return v;
+}
+async function latestFindings(root, change) {
+  const out = [];
+  for (const gate of await reviewedGates(root, change)) {
+    const rounds = await roundsOf(root, change, gate);
+    if (rounds.length === 0)
+      continue;
+    const r = await readRound(root, change, gate, rounds[rounds.length - 1]);
+    out.push(...r.findings.map((f) => f.finding));
+  }
+  return out;
+}
+function summary(c, findings, fast = false) {
+  const open = { blocking: 0, gap: 0, risk: 0, idea: 0 };
+  for (const f of findings)
+    if (f.state === "open")
+      open[f.severity] += 1;
+  const last = c.history[c.history.length - 1];
+  return {
+    id: c.id,
+    title: c.title,
+    type: c.type,
+    state: c.state,
+    repos: c.touches.repos,
+    openFindings: open,
+    updatedAt: last?.at ?? c.createdAt,
+    ...fast ? { fastPath: true } : {}
+  };
+}
+function apiRoutes(r, ctx) {
+  const { root } = ctx;
+  return r.add("GET", "/api/health", () => ({
+    status: 200,
+    body: {
+      version: ctx.version,
+      apiVersion: API_VERSION,
+      schemaVersion: SCHEMA_VERSION,
+      root,
+      openspec: layoutOf(root).openspec.replace(/\/+$/, ""),
+      user: ctx.user,
+      full: ctx.full === true
+    }
+  })).add("GET", "/api/catalog/kinds", async () => ({
+    status: 200,
+    body: await withIndex(root, (ix) => ix.kinds())
+  })).add("GET", "/api/catalog/{kind}", async ({ params, query }) => {
+    const kind = kindParam(params.kind);
+    const limit = intParam(query, "limit", 1, 500);
+    const o = {
+      ...strParam(query, "status") ? { status: strParam(query, "status") } : {},
+      ...strParam(query, "system") ? { system: strParam(query, "system") } : {},
+      ...strParam(query, "q") ? { q: strParam(query, "q") } : {},
+      ...strParam(query, "cursor") ? { cursor: strParam(query, "cursor") } : {},
+      ...limit !== void 0 ? { limit } : {}
+    };
+    return { status: 200, body: await withIndex(root, (ix) => ix.list(kind, o)) };
+  }).add("GET", "/api/catalog/{kind}/{id}", async ({ params }) => {
+    const kind = kindParam(params.kind);
+    const rec = await withIndex(root, (ix) => ix.get(kind, params.id));
+    if (!rec)
+      throw notFound(`There is no ${kind} ${params.id}.`);
+    return { status: 200, body: rec };
+  }).add("GET", "/api/search", async ({ query }) => {
+    const q = strParam(query, "q");
+    if (!q)
+      throw badRequest("Say what to look for: ?q=<words or filters>.");
+    const limit = intParam(query, "limit", 1, 500) ?? 100;
+    const offset = intParam(query, "offset", 0, 1e6) ?? 0;
+    try {
+      return { status: 200, body: await withIndex(root, (ix) => ix.query(q, { limit, offset })) };
+    } catch (e) {
+      if (e instanceof QueryError)
+        throw badRequest(e.message);
+      throw e;
+    }
+  }).add("GET", "/api/ask", async ({ query }) => {
+    const q = strParam(query, "q");
+    if (!q)
+      throw badRequest("Ask a question: ?q=<plain words>.");
+    return {
+      status: 200,
+      body: await withIndex(root, (ix) => {
+        const asked = translate(q, askLookup(ix));
+        if (asked.action === "impact")
+          return { question: q, ...asked, impact: impact(ix, asked.id, 4) };
+        if (asked.action === "owner") {
+          const r2 = ix.find(asked.id)[0];
+          const owner = r2?.owner ?? r2?.ownerComponent ?? (r2 ? ix.find(String(r2.system ?? ""))[0]?.owner : void 0);
+          return { question: q, ...asked, owner: owner ?? null };
+        }
+        try {
+          return { question: q, ...asked, result: ix.query(asked.query, { limit: 60 }) };
+        } catch (e) {
+          if (e instanceof QueryError)
+            return { question: q, ...asked, error: e.message };
+          throw e;
+        }
+      })
+    };
+  }).add("GET", "/api/graph", async ({ query }) => {
+    const depth = intParam(query, "depth", 1, 6);
+    const o = {
+      ...strParam(query, "focus") ? { focus: strParam(query, "focus") } : {},
+      ...strParam(query, "status") ? { status: strParam(query, "status") } : {},
+      ...depth !== void 0 ? { depth } : {}
+    };
+    return { status: 200, body: await withIndex(root, (ix) => graph(ix, o)) };
+  }).add("GET", "/api/impact/{id}", async ({ params, query }) => {
+    const depth = intParam(query, "depth", 1, 10);
+    const res = await withIndex(root, (ix) => impact(ix, params.id, depth));
+    if (!res)
+      throw notFound(`There is no record ${params.id} in the catalog.`);
+    return { status: 200, body: res };
+  }).add("GET", "/api/incident/{id}", async ({ params }) => {
+    const res = await withIndex(root, (ix) => {
+      const reach = impact(ix, params.id, 3);
+      if (!reach)
+        return void 0;
+      const rootRec = ix.find(params.id)[0];
+      const ids = [params.id, ...reach.affected.map((a) => a.id)];
+      const kindOf = new Map(reach.affected.map((a) => [a.id, a.kind]));
+      kindOf.set(params.id, rootRec.kind);
+      const systems = /* @__PURE__ */ new Set();
+      for (const id of ids) {
+        const k = kindOf.get(id);
+        const sys = k === "System" ? id : ix.systemOf(k, id);
+        if (sys)
+          systems.add(sys);
+      }
+      const owners = /* @__PURE__ */ new Map();
+      const unowned = [];
+      for (const sys of [...systems].sort()) {
+        const rec = ix.get("System", sys);
+        if (!rec?.owner)
+          unowned.push(sys);
+        else {
+          const o = owners.get(rec.owner) ?? { owner: rec.owner, systems: [] };
+          o.systems.push(sys);
+          owners.set(rec.owner, o);
+        }
+      }
+      const components = new Set(ids.filter((id) => kindOf.get(id) === "Component"));
+      const watch2 = ix.query("kind:observabilityasset", { limit: 500 }).rows.map((r2) => ix.get(r2.kind, r2.id)).filter((a) => components.has(String(a.component))).map((a) => ({
+        component: String(a.component),
+        kind: String(a.assetKind),
+        name: String(a.name),
+        ...a.link ? { link: String(a.link) } : {}
+      }));
+      return {
+        reach,
+        systems: [...systems].sort(),
+        owners: [...owners.values()],
+        unowned,
+        watch: watch2
+      };
+    });
+    if (!res)
+      throw notFound(`There is no record ${params.id} in the catalog.`);
+    const near = /* @__PURE__ */ new Set([...res.systems, params.id, ...res.reach.affected.map((a) => a.id)]);
+    const changes = (await changeStore(root).list()).filter((c) => c.systems.some((s) => near.has(s)) || [...c.touches.records, ...c.touches.tables, ...c.touches.dataStores].some((x) => near.has(x))).map((c) => ({
+      id: c.id,
+      title: c.title,
+      state: c.state,
+      updatedAt: c.history.at(-1)?.at ?? c.createdAt,
+      systems: c.systems.filter((s) => near.has(s))
+    })).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return {
+      status: 200,
+      body: {
+        id: params.id,
+        blastRadius: res.reach.affected.length,
+        affected: res.reach.affected,
+        systems: res.systems,
+        call: res.owners,
+        ownerUnknown: res.unowned,
+        watch: res.watch,
+        recentChanges: changes
+      }
+    };
+  }).add("GET", "/api/repos", async () => {
+    const repos = await loadRepos(root);
+    const body = [];
+    for (const repo of repos) {
+      const present = await stat(join(baseClonePath(root, repo.id), ".git")).then(() => true, () => false);
+      body.push({ ...repo, baseClone: { present } });
+    }
+    return { status: 200, body };
+  }).add("GET", "/api/changes", async ({ query }) => {
+    const state = strParam(query, "state");
+    const changes = (await changeStore(root).list()).filter((c) => !state || c.state === state);
+    const body = [];
+    const types = await loadOrgPack(orgPackDirOf(root)).then((op) => op.changeTypes.types, () => []);
+    for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+      const type = types.find((t) => t.id === c.type);
+      const fast = !!type && (type.size === "small" || !!type.smallWhenBriefSays) && fastPathOf(type, await readFile(join(changeFolder(root, c.id), "brief.md"), "utf8").catch(() => "")).fast;
+      body.push(summary(c, await latestFindings(root, c.id), fast));
+    }
+    return { status: 200, body };
+  }).add("GET", "/api/findings", async ({ query }) => {
+    const change = strParam(query, "change");
+    const gate = strParam(query, "gate");
+    const state = strParam(query, "state");
+    const lens = enumParam(query, "lens", Lens.options);
+    const severity = enumParam(query, "severity", Severity.options);
+    const ids = change ? [change] : (await changeStore(root).list()).map((c) => c.id).sort();
+    const body = [];
+    for (const id of ids)
+      for (const f of await latestFindings(root, id))
+        if ((!gate || f.gate === gate) && (!state || f.state === state) && // A lens filter asks its question: an old lens name finds what its question raised.
+        (!lens || questionOfLens(f.lens) === questionOfLens(lens)) && (!severity || f.severity === severity))
+          body.push(f);
+    return { status: 200, body };
+  }).add("GET", "/api/findings/{changeId}/{findingId}", async ({ params }) => {
+    const f = (await latestFindings(root, params.changeId)).find((x) => x.id === params.findingId);
+    if (!f)
+      throw notFound(`Change ${params.changeId} has no finding ${params.findingId}.`);
+    return { status: 200, body: f };
+  }).add("GET", "/api/orgpack", async () => {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    return {
+      status: 200,
+      body: {
+        defaulted: op.defaulted,
+        counts: {
+          patterns: op.patterns.length,
+          dialects: op.dialects.length,
+          checklists: op.checklists.length,
+          agents: op.agents.length,
+          procedures: op.procedures.length,
+          serviceRequests: op.serviceRequests.length,
+          profiles: op.profiles.length,
+          gates: Object.keys(op.gates ?? {}).length
+        },
+        // Additive (ADR 0043): the patterns, checklists and procedures themselves, for the screen.
+        patterns: op.patterns,
+        checklists: op.checklists.map((c) => ({
+          name: c.name,
+          version: c.version,
+          rules: c.rules.length
+        })),
+        procedures: op.procedures.map((x) => ({
+          id: x.id,
+          title: x.title,
+          steps: x.steps?.length ?? 0
+        })),
+        problems: op.problems.map((p) => ({
+          file: p.file,
+          path: p.path ?? "",
+          message: p.message
+        }))
+      }
+    };
+  });
+}
+
+// packages/server/dist/static.js
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { extname, join as join2, normalize, sep } from "node:path";
+var TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8"
+};
+function appCsp(port, embed) {
+  return [
+    "default-src 'self'",
+    `connect-src 'self' ws://127.0.0.1:${port} ws://localhost:${port}`,
+    "img-src 'self' data:",
+    "style-src 'self' 'unsafe-inline'",
+    "font-src 'self' data:",
+    "script-src 'self'",
+    "object-src 'none'",
+    "base-uri 'none'",
+    embed === "vscode" ? "frame-ancestors vscode-webview:" : "frame-ancestors 'none'",
+    "form-action 'self'"
+  ].join("; ");
+}
+var escapeAttr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+async function staticFile(dir, path, token) {
+  let rel;
+  try {
+    rel = decodeURIComponent(path);
+  } catch {
+    return { status: 400, type: TYPES[".txt"], body: "Bad path", cache: "no-store" };
+  }
+  if (rel === "/" || rel === "")
+    rel = "/index.html";
+  const file = normalize(join2(dir, rel));
+  if (file !== dir && !file.startsWith(dir.endsWith(sep) ? dir : dir + sep))
+    return { status: 404, type: TYPES[".txt"], body: "Not found", cache: "no-store" };
+  const info = await stat2(file).catch(() => void 0);
+  const target = info?.isFile() ? file : extname(rel) ? void 0 : join2(dir, "index.html");
+  if (!target)
+    return { status: 404, type: TYPES[".txt"], body: "Not found", cache: "no-store" };
+  const ext = extname(target).toLowerCase();
+  const type = TYPES[ext] ?? "application/octet-stream";
+  if (ext === ".html") {
+    const html = (await readFile2(target, "utf8")).replace(/<meta name="atticus-token" content="[^"]*"\s*\/?>/, `<meta name="atticus-token" content="${escapeAttr(token)}" />`);
+    return { status: 200, type, body: html, cache: "no-store" };
+  }
+  return {
+    status: 200,
+    type,
+    body: await readFile2(target),
+    // Built assets carry a content hash in their name.
+    cache: /[.-][A-Za-z0-9_-]{8,}\.(js|css|woff2?)$/.test(target) ? "public, max-age=31536000, immutable" : "no-cache"
+  };
+}
+
+// packages/server/dist/watch.js
+import { statSync, watch } from "node:fs";
+import { join as join3, relative, sep as sep2 } from "node:path";
+var SKIP = /* @__PURE__ */ new Set([".git", "node_modules", ".index", "workspace", "logs", ".vitest-cache"]);
+var TEMP = /(~|\.swp|\.swx|\.tmp|\.crdownload|\.part)$/i;
+var posix = (p) => p.split(sep2).join("/");
+var isDir = (p) => {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+function watchMetarepo(o) {
+  const root = o.root;
+  const delay = o.delayMs ?? 300;
+  const maxPaths = o.maxPaths ?? 50;
+  const watchers = /* @__PURE__ */ new Map();
+  const problems = [];
+  const pending = /* @__PURE__ */ new Set();
+  let timer;
+  let first = 0;
+  let closed = false;
+  const skipped = (rel) => rel === "" || rel.startsWith("..") || TEMP.test(rel) || rel.split("/").some((s) => SKIP.has(s));
+  const flush = () => {
+    timer = void 0;
+    first = 0;
+    if (closed || !pending.size)
+      return;
+    let out = [...pending].sort();
+    pending.clear();
+    if (out.length > maxPaths)
+      out = [...new Set(out.map((p) => p.split("/").slice(0, 2).join("/")))].sort();
+    for (const path of out)
+      o.publish({ type: "file.changed", path });
+  };
+  const note = (abs) => {
+    const rel = posix(relative(root, abs));
+    if (skipped(rel))
+      return;
+    pending.add(rel);
+    const now = Date.now();
+    if (!first)
+      first = now;
+    clearTimeout(timer);
+    timer = setTimeout(flush, now - first > delay * 5 ? 0 : delay);
+  };
+  const folders = () => {
+    const all = [
+      orgPackDirOf(root),
+      catalogDirOf(root),
+      openspecDirOf(root),
+      specsDirOf(root),
+      questionsDirOf(root),
+      knowledgeDirOf(root),
+      proposalsDirOf(root),
+      inputsDirOf(root),
+      runsDirOf(root),
+      // ADR 0124: the facts and the verifier's reports, for the Map's Trust tab.
+      factsDirOf(root),
+      join3(root, ".atticus", "history")
+    ].filter((d) => !skipped(posix(relative(root, d))));
+    const unique = [...new Set(all)].sort();
+    return unique.filter((d) => !unique.some((p) => p !== d && d.startsWith(p + sep2)));
+  };
+  const follow = (dir, recursive) => {
+    if (closed || watchers.has(dir) || !isDir(dir))
+      return;
+    try {
+      const w = watch(dir, { recursive }, (_event, name) => {
+        if (!recursive && name) {
+          attach();
+          if (watchers.has(join3(dir, String(name))))
+            return;
+        }
+        note(name ? join3(dir, String(name)) : dir);
+      });
+      w.on("error", (e) => {
+        problems.push(`${posix(relative(root, dir)) || "."}: ${e.message}`);
+        w.close();
+        watchers.delete(dir);
+      });
+      watchers.set(dir, w);
+    } catch (e) {
+      problems.push(`${posix(relative(root, dir)) || "."}: ${e.message}`);
+    }
+  };
+  const attach = () => {
+    for (const d of folders())
+      follow(d, true);
+  };
+  follow(root, false);
+  follow(join3(root, ".atticus"), false);
+  attach();
+  return {
+    get following() {
+      return [...watchers.keys()].filter((d) => d !== root && d !== join3(root, ".atticus")).map((d) => posix(relative(root, d))).sort();
+    },
+    problems,
+    close() {
+      closed = true;
+      clearTimeout(timer);
+      for (const w of watchers.values())
+        w.close();
+      watchers.clear();
+      pending.clear();
+    }
+  };
+}
+
+// packages/server/dist/ws.js
+import { createHash } from "node:crypto";
+var GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function acceptKey(key) {
+  return createHash("sha1").update(key + GUID).digest("base64");
+}
+function frame(opcode, payload) {
+  const len = payload.length;
+  let head;
+  if (len < 126)
+    head = Buffer.from([128 | opcode, len]);
+  else if (len < 65536) {
+    head = Buffer.alloc(4);
+    head[0] = 128 | opcode;
+    head[1] = 126;
+    head.writeUInt16BE(len, 2);
+  } else {
+    head = Buffer.alloc(10);
+    head[0] = 128 | opcode;
+    head[1] = 127;
+    head.writeBigUInt64BE(BigInt(len), 2);
+  }
+  return Buffer.concat([head, payload]);
+}
+var Socket = class {
+  sock;
+  onClose;
+  buf = Buffer.alloc(0);
+  closed = false;
+  constructor(sock, onClose) {
+    this.sock = sock;
+    this.onClose = onClose;
+    sock.on("data", (d) => this.read(d));
+    sock.on("close", () => this.end());
+    sock.on("error", () => this.end());
+  }
+  send(text) {
+    if (!this.closed)
+      this.sock.write(frame(1, Buffer.from(text, "utf8")));
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.sock.write(frame(8, Buffer.alloc(0)));
+    this.sock.end();
+    this.end();
+  }
+  end() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.onClose(this);
+  }
+  /** Client frames are masked; only control frames matter to us. */
+  read(d) {
+    this.buf = Buffer.concat([this.buf, d]);
+    while (this.buf.length >= 2) {
+      const opcode = this.buf[0] & 15;
+      const masked = (this.buf[1] & 128) !== 0;
+      let len = this.buf[1] & 127;
+      let off = 2;
+      if (len === 126) {
+        if (this.buf.length < 4)
+          return;
+        len = this.buf.readUInt16BE(2);
+        off = 4;
+      } else if (len === 127) {
+        if (this.buf.length < 10)
+          return;
+        len = Number(this.buf.readBigUInt64BE(2));
+        off = 10;
+      }
+      const maskOff = off;
+      if (masked)
+        off += 4;
+      if (this.buf.length < off + len)
+        return;
+      const payload = Buffer.from(this.buf.subarray(off, off + len));
+      if (masked)
+        for (let i = 0; i < payload.length; i++)
+          payload[i] ^= this.buf[maskOff + i % 4];
+      this.buf = this.buf.subarray(off + len);
+      if (opcode === 8)
+        return this.close();
+      if (opcode === 9)
+        this.sock.write(frame(10, payload));
+    }
+  }
+};
+function upgrade(req, sock, onClose) {
+  const key = req.headers["sec-websocket-key"];
+  if (typeof key !== "string" || req.headers["sec-websocket-version"] !== "13") {
+    sock.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+    return void 0;
+  }
+  sock.write([
+    "HTTP/1.1 101 Switching Protocols",
+    "Upgrade: websocket",
+    "Connection: Upgrade",
+    `Sec-WebSocket-Accept: ${acceptKey(key)}`,
+    "",
+    ""
+  ].join("\r\n"));
+  return new Socket(sock, onClose);
+}
+
+// packages/server/dist/server.js
+var EventHub = class {
+  sockets = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  /** Hear every event in this process too (ADR 0119: a reader that keeps files in memory). */
+  listen(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  add(s) {
+    this.sockets.add(s);
+  }
+  remove(s) {
+    this.sockets.delete(s);
+  }
+  get size() {
+    return this.sockets.size;
+  }
+  publish(e) {
+    for (const fn of this.listeners)
+      fn(e);
+    const text = JSON.stringify(e);
+    for (const s of this.sockets)
+      s.send(text);
+  }
+  closeAll() {
+    for (const s of [...this.sockets])
+      s.close();
+  }
+};
+var MAX_BODY = 4 * 1024 * 1024;
+function sameToken(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+async function readBody(req, max = MAX_BODY) {
+  const chunks = [];
+  let size = 0;
+  for await (const c of req) {
+    size += c.length;
+    if (size > max)
+      throw new HttpError(413, "The request body is too large");
+    chunks.push(c);
+  }
+  if (size === 0)
+    return void 0;
+  const type = req.headers["content-type"] ?? "";
+  if (!type.startsWith("application/json"))
+    throw new HttpError(415, "Send the body as application/json");
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new HttpError(400, "The request isn't valid", "The body is not valid JSON.");
+  }
+}
+var HARDENING = {
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY",
+  "Cross-Origin-Resource-Policy": "same-origin",
+  "Cross-Origin-Opener-Policy": "same-origin",
+  "Referrer-Policy": "no-referrer",
+  "Permissions-Policy": "camera=(), microphone=(), geolocation=(), usb=(), payment=()"
+};
+function send(res, status, body, type = "application/json") {
+  const text = body === void 0 ? "" : JSON.stringify(body);
+  res.writeHead(status, {
+    ...HARDENING,
+    "Content-Type": `${type}; charset=utf-8`,
+    "Cache-Control": "no-store"
+  });
+  res.end(text);
+}
+async function startServer(o) {
+  const host = o.host ?? "127.0.0.1";
+  if (host !== "127.0.0.1")
+    throw new Error(`Atticus only listens on 127.0.0.1 (asked for ${host}).`);
+  const token = o.token && /^[A-Za-z0-9_-]{32,}$/.test(o.token) ? o.token : randomBytes(32).toString("base64url");
+  const events = new EventHub();
+  const jobs = new JobManager((e) => events.publish(e));
+  const person = o.user ? { handle: o.user, source: "given" } : await gitUser(o.root);
+  const ctx = {
+    root: o.root,
+    user: person.handle,
+    person,
+    version: o.version ?? "0.0.0",
+    full: o.full === true,
+    events,
+    jobs
+  };
+  const router = apiRoutes(new Router(), ctx).add("GET", "/api/jobs/{jobId}", ({ params }) => {
+    const j = jobs.get(params.jobId);
+    if (!j)
+      throw notFound(`There is no job ${params.jobId}.`);
+    return { status: 200, body: j };
+  }).add("POST", "/api/jobs/{jobId}/cancel", ({ params }) => {
+    const j = jobs.get(params.jobId);
+    if (!j)
+      throw notFound(`There is no job ${params.jobId}.`);
+    if (!jobs.cancel(j.id))
+      throw conflict(`Job ${j.id} already finished (${j.state}).`);
+    return { status: 200, body: j };
+  });
+  o.extend?.(router, ctx);
+  let port = 0;
+  const allowedHosts = () => /* @__PURE__ */ new Set([`127.0.0.1:${port}`, `localhost:${port}`]);
+  const guard = (req, url, tokenFromQuery) => {
+    if (!allowedHosts().has(req.headers.host ?? ""))
+      throw new HttpError(403, "Requests must be addressed to this server");
+    const origin = req.headers.origin;
+    if (origin && !allowedHosts().has(origin.replace(/^https?:\/\//, "")))
+      throw new HttpError(403, "Requests from other sites are not allowed");
+    const given = req.headers["x-atticus-token"] ?? (tokenFromQuery ? url.searchParams.get("token") ?? void 0 : void 0);
+    if (!given || !sameToken(given, token))
+      throw new HttpError(401, "Missing or wrong session token");
+  };
+  const server = createServer(async (req, res) => {
+    const t0 = Date.now();
+    const done = (status, error) => {
+      const path = (req.url ?? "/").split("?")[0];
+      if (path.startsWith("/api/"))
+        o.onRequest?.({
+          method: req.method ?? "GET",
+          path,
+          status,
+          ms: Date.now() - t0,
+          ...error ? { error } : {}
+        });
+    };
+    try {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (!url.pathname.startsWith("/api/")) {
+        if (!allowedHosts().has(req.headers.host ?? ""))
+          throw new HttpError(403, "Requests must be addressed to this server");
+        if (!o.staticDir || req.method !== "GET" && req.method !== "HEAD")
+          throw new HttpError(404, "Not found", `Nothing is served at ${url.pathname}.`);
+        const f = await staticFile(o.staticDir, url.pathname, token);
+        const { "X-Frame-Options": deny, ...rest } = HARDENING;
+        res.writeHead(f.status, {
+          ...o.embed ? rest : { ...rest, "X-Frame-Options": deny },
+          "Content-Type": f.type,
+          "Cache-Control": f.cache,
+          "Content-Security-Policy": appCsp(port, o.embed)
+        });
+        res.end(req.method === "HEAD" ? void 0 : f.body);
+        return;
+      }
+      guard(req, url, false);
+      const m = router.match(req.method ?? "GET", url.pathname);
+      if ("allowed" in m) {
+        if (m.allowed.length === 0)
+          throw new HttpError(404, "Not found", `There is no API call ${url.pathname}.`);
+        throw new HttpError(405, "Method not allowed", `Use ${m.allowed.join(" or ")}.`);
+      }
+      const body = await readBody(req, m.maxBody);
+      const out = await m.handler({
+        method: req.method ?? "GET",
+        path: url.pathname,
+        params: m.params,
+        query: url.searchParams,
+        body
+      });
+      send(res, out.status, out.body);
+      done(out.status);
+    } catch (e) {
+      const err = e instanceof HttpError ? e : new HttpError(500, "Something went wrong", e instanceof Error ? e.message : String(e));
+      send(res, err.status, problem(err), "application/problem+json");
+      done(err.status, err.status >= 500 && e instanceof Error ? e : void 0);
+    }
+  });
+  server.on("upgrade", (req, sock) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    try {
+      if (url.pathname !== "/api/events")
+        throw new HttpError(404, "Not found");
+      guard(req, url, true);
+    } catch (e) {
+      const err = e instanceof HttpError ? e : new HttpError(400, "Bad request");
+      sock.end(`HTTP/1.1 ${err.status} ${err.title}\r
+Connection: close\r
+\r
+`);
+      return;
+    }
+    const s = upgrade(req, sock, (x) => events.remove(x));
+    if (s)
+      events.add(s);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(o.port ?? DEFAULT_PORT, host, () => resolve());
+  });
+  port = server.address().port;
+  const watcher = o.watch === false ? void 0 : watchMetarepo({ root: o.root, publish: (e) => events.publish(e) });
+  return {
+    url: `http://127.0.0.1:${port}`,
+    port,
+    token,
+    events,
+    jobs,
+    person,
+    get following() {
+      return watcher?.following ?? [];
+    },
+    close: () => new Promise((resolve) => {
+      watcher?.close();
+      events.closeAll();
+      server.closeAllConnections?.();
+      server.close(() => resolve());
+    })
+  };
+}
+
+export {
+  HttpError,
+  badRequest,
+  notFound,
+  conflict,
+  strParam,
+  startServer
+};