@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/code-intelligence.js

@@ -0,0 +1,141 @@
+import { Worker } from "node:worker_threads";
+import { join } from "node:path";
+import { realpath } from "node:fs/promises";
+import { git, repoRoot } from "./git.js";
+import { readEditableFile } from "./workspace.js";
+import { assertContextPathAllowed } from "./context-inspection.js";
+import { Slots } from "./slots.js";
+const slots = new Slots(1);
+const CODE_INTELLIGENCE_LIMITS = { files: 500, bytes: 8 * 1024 * 1024, hits: 200, timeoutMs: 1e4, memoryMb: 192 };
+const pool = /* @__PURE__ */ new Map();
+const codeIntelligenceHealth = { requests: 0, reused: 0, failures: 0 };
+async function closeCodeIntelligence() {
+  const entries = [...pool.values()];
+  pool.clear();
+  await Promise.all(entries.map(async (entry) => {
+    clearTimeout(entry.idle);
+    await entry.worker.terminate();
+  }));
+}
+async function discard(root, entry) {
+  clearTimeout(entry.idle);
+  if (pool.get(root) === entry) pool.delete(root);
+  await entry.worker.terminate();
+}
+async function workerFor(root) {
+  const cached = pool.get(root);
+  if (cached) {
+    codeIntelligenceHealth.reused++;
+    clearTimeout(cached.idle);
+    pool.delete(root);
+    pool.set(root, cached);
+    cached.worker.ref();
+    return cached;
+  }
+  if (pool.size >= 2) {
+    const [key, oldest] = pool.entries().next().value;
+    await discard(key, oldest);
+  }
+  const worker = new Worker(new URL("./code-intelligence-worker.mjs", import.meta.url), { workerData: { root }, resourceLimits: { maxOldGenerationSizeMb: CODE_INTELLIGENCE_LIMITS.memoryMb } });
+  const entry = { worker, sources: /* @__PURE__ */ new Map() };
+  pool.set(root, entry);
+  worker.on("error", () => {
+    codeIntelligenceHealth.failures++;
+    if (pool.get(root) === entry) pool.delete(root);
+  });
+  worker.once("exit", () => {
+    clearTimeout(entry.idle);
+    if (pool.get(root) === entry) pool.delete(root);
+  });
+  return entry;
+}
+async function inspect(repo, request, signal) {
+  const release = await slots.acquire(signal);
+  let entry, root = "", succeeded = false;
+  codeIntelligenceHealth.requests++;
+  try {
+    root = await realpath(await repoRoot(repo));
+    const listed = await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], root, { signal, timeoutMs: 1e4 });
+    if (listed.code) throw new Error("Cannot list sources for the language service");
+    const candidates = [...new Set(listed.stdout.split("\0").filter((path) => /\.[cm]?[jt]sx?$/.test(path) && !/(^|\/)(?:node_modules|vendor|dist|build|coverage|\.git)(\/|$)/.test(path)))].sort();
+    const sources = [];
+    let bytes = 0, truncated = false;
+    for (const path of candidates) {
+      signal?.throwIfAborted();
+      if (sources.length >= CODE_INTELLIGENCE_LIMITS.files) {
+        truncated = true;
+        break;
+      }
+      try {
+        assertContextPathAllowed(path);
+      } catch {
+        continue;
+      }
+      const file = await readEditableFile(root, path).catch(() => void 0);
+      if (!file) continue;
+      if (bytes + file.bytes > CODE_INTELLIGENCE_LIMITS.bytes) {
+        truncated = true;
+        break;
+      }
+      bytes += file.bytes;
+      sources.push({ absolute: join(root, path), text: file.text });
+    }
+    const operation = request.kind === "references" ? { ...request, file: join(root, assertContextPathAllowed(request.file)) } : request;
+    signal?.throwIfAborted();
+    entry = await workerFor(root);
+    const current = new Map(sources.map((file) => [file.absolute, file.text]));
+    const changed = sources.filter((file) => entry.sources.get(file.absolute) !== file.text);
+    const removed = [...entry.sources.keys()].filter((name) => !current.has(name));
+    const worker = entry.worker;
+    const result = await new Promise((accept, reject) => {
+      const finish = (error, result2) => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+        worker.off("message", message);
+        worker.off("error", fail);
+        worker.off("exit", exited);
+        error ? reject(error) : accept(result2);
+      };
+      const abort = () => finish(new Error("Language service inspection cancelled"));
+      const fail = (error) => finish(error);
+      const exited = () => finish(new Error("Language service exited before returning its bounded result"));
+      const message = (value) => value.error ? finish(new Error(value.error)) : finish(void 0, value);
+      const timer = setTimeout(() => finish(new Error("Language service inspection exceeded its time limit; narrow the repository")), CODE_INTELLIGENCE_LIMITS.timeoutMs);
+      signal?.addEventListener("abort", abort, { once: true });
+      worker.once("message", message);
+      worker.once("error", fail);
+      worker.once("exit", exited);
+      if (signal?.aborted) abort();
+      else worker.postMessage({ sources: changed, removed, request: operation });
+    });
+    entry.sources = current;
+    succeeded = true;
+    return { ...result, scanned: sources.length, truncated: truncated || result.truncated };
+  } finally {
+    if (entry) {
+      if (!succeeded) await discard(root, entry);
+      else {
+        const cached = entry;
+        entry.worker.unref();
+        entry.idle = setTimeout(() => void discard(root, cached), 6e4);
+        entry.idle.unref();
+      }
+    }
+    release();
+  }
+}
+function searchSemanticSymbols(repo, query, signal) {
+  if (typeof query !== "string" || !query.trim() || query.length > 300) throw new Error("Enter a symbol query of 1\u2013300 characters");
+  return inspect(repo, { kind: "symbols", query: query.trim() }, signal);
+}
+function findCodeReferences(repo, input, signal) {
+  if (!Number.isInteger(input.line) || input.line < 1 || !Number.isInteger(input.column) || input.column < 1) throw new Error("Reference lookup needs a one-based line and column");
+  return inspect(repo, { kind: "references", file: input.path, line: input.line, column: input.column }, signal);
+}
+export {
+  CODE_INTELLIGENCE_LIMITS,
+  closeCodeIntelligence,
+  codeIntelligenceHealth,
+  findCodeReferences,
+  searchSemanticSymbols
+};

package/src/collab/api.js

@@ -0,0 +1,365 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { HttpError, readJson, readLoginJson, send } from "../http.js";
+import { SharedAccountError } from "../shared-accounts.js";
+import { ATTEMPT_ID, CHECKPOINT_ID, CollabError, MAX, PATH_ID, RUNNER_TOKEN, SHA256_HEX, actorRole, roleAtLeast, validateText } from "./model.js";
+const looksLikeRunnerToken = (bearer) => typeof bearer === "string" && RUNNER_TOKEN.test(bearer);
+const isTeamApiPath = (parts) => parts[0] === "api" && parts[1] === "team";
+function runnerAllowed(route) {
+  return route !== void 0 && route.principals.includes("runner");
+}
+const KIB = 1024;
+const TEAM_BODY_LIMIT = { small: 16 * KIB, task: 64 * KIB, progress: 192 * KIB, manifest: 1280 * KIB, connect: 8 * KIB };
+const ALL = ["owner", "browser", "runner"], EXECUTING = ["owner", "runner"], OWNER_ONLY = ["owner"], NOBODY = [];
+const ID = Symbol("id");
+const r = (method, path, op, principals = ALL, bodyLimit) => bodyLimit === void 0 ? { method, path, op, principals } : { method, path, op, principals, bodyLimit };
+const ROUTES = [
+  r("POST", ["runners", "connect"], "connect", NOBODY, TEAM_BODY_LIMIT.connect),
+  r("GET", ["me"], "me"),
+  r("GET", ["board"], "board"),
+  r("GET", ["events"], "events"),
+  r("GET", ["tasks", ID], "task"),
+  r("POST", ["tasks"], "task-create", ALL, TEAM_BODY_LIMIT.task),
+  r("PUT", ["tasks", ID], "task-update", ALL, TEAM_BODY_LIMIT.task),
+  r("DELETE", ["tasks", ID], "task-delete", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "comments"], "comment", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "decisions"], "decision", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "review-request"], "review-request", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "reviews"], "review", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "instructions"], "instruction-propose", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "instructions", ID], "instruction-decide", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "attempts"], "attempt-claim", EXECUTING, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "handoff"], "handoff-offer", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["tasks", ID, "handoff", ID], "handoff-respond", ALL, TEAM_BODY_LIMIT.small),
+  r("POST", ["attempts", ID, "progress"], "attempt-progress", EXECUTING, TEAM_BODY_LIMIT.progress),
+  r("POST", ["attempts", ID, "heartbeat"], "attempt-heartbeat", EXECUTING),
+  r("POST", ["attempts", ID, "finish"], "attempt-finish", EXECUTING, TEAM_BODY_LIMIT.small),
+  r("POST", ["attempts", ID, "checkpoints"], "checkpoint-add", EXECUTING, TEAM_BODY_LIMIT.manifest),
+  r("POST", ["attempts", ID, "recover"], "attempt-recover", ALL, TEAM_BODY_LIMIT.small),
+  r("GET", ["checkpoints", ID], "checkpoint"),
+  r("DELETE", ["checkpoints", ID], "checkpoint-delete"),
+  r("PUT", ["checkpoints", ID, "bundle"], "bundle-upload", EXECUTING, MAX.bundle),
+  r("GET", ["checkpoints", ID, "bundle"], "bundle-download"),
+  r("GET", ["inbox"], "inbox"),
+  r("POST", ["inbox", "read"], "inbox-read", ALL, TEAM_BODY_LIMIT.small),
+  r("GET", ["runners"], "runners"),
+  r("DELETE", ["runners", ID], "runner-revoke"),
+  r("PUT", ["projects", ID, "repositories"], "repositories", ALL, TEAM_BODY_LIMIT.task),
+  r("PUT", ["profile"], "profile", OWNER_ONLY, TEAM_BODY_LIMIT.small)
+];
+const UNSAFE_KEYS = ["__proto__", "constructor", "prototype"];
+const idOk = (part) => part !== void 0 && PATH_ID.test(part) && !UNSAFE_KEYS.includes(part);
+function teamRoutePolicy(method, parts) {
+  if (!isTeamApiPath(parts) || parts.length > 6) return void 0;
+  const rest = parts.slice(2);
+  for (const spec of ROUTES) {
+    if (spec.method !== method || spec.path.length !== rest.length || !spec.path.every((segment, index) => segment === ID ? idOk(rest[index]) : segment === rest[index])) continue;
+    const route = { op: spec.op, principals: [...spec.principals] };
+    if (spec.bodyLimit !== void 0) route.bodyLimit = spec.bodyLimit;
+    return route;
+  }
+  return void 0;
+}
+function denied(route) {
+  if (!route.principals.length) return new HttpError(403, "Connect a computer without a session or runner credential: POST /api/team/runners/connect with { username, password, name }");
+  if (!route.principals.includes("runner")) return new HttpError(403, "Only the hub owner may do this, from the team server itself");
+  return new HttpError(403, "Only the computer executing an attempt may start it or report on it; run team tasks from your own code-flow (Settings \u2192 Team \u2192 Connect this computer)");
+}
+const checkpointIdOf = (value) => {
+  if (typeof value !== "string" || !CHECKPOINT_ID.test(value)) throw new CollabError("Send the checkpoint id as 32 lowercase hexadecimal characters");
+  return value;
+};
+const attemptIdOf = (value) => {
+  if (typeof value !== "string" || !ATTEMPT_ID.test(value)) throw new CollabError("Send the attempt id as 32 lowercase hexadecimal characters");
+  return value;
+};
+async function handleTeamApi(req, res, url, parts, host) {
+  const method = req.method ?? "GET", route = teamRoutePolicy(method, parts);
+  if (!route) throw new HttpError(404, "Unknown team operation");
+  if (!route.principals.includes(host.principal)) throw denied(route);
+  if (method !== "GET") host.mutation(req);
+  try {
+    await dispatch(req, res, url, parts, host, route);
+  } catch (error) {
+    if (error instanceof CollabError && !res.headersSent) return send(res, error.status, { error: error.message });
+    throw error;
+  }
+}
+async function dispatch(req, res, url, parts, host, route) {
+  const { store, actor } = host, id = parts[3] ?? "", sub = parts[5] ?? "", body = () => readJson(req, route.bodyLimit ?? TEAM_BODY_LIMIT.small, { timeoutMs: 1e4 });
+  switch (route.op) {
+    case "connect":
+      throw denied(route);
+    case "me": {
+      const { runners, ...me } = (await store.board(actor)).me;
+      return send(res, 200, { me, runners, linked: false });
+    }
+    case "board": {
+      const project = url.searchParams.get("project");
+      if (project) {
+        if (!idOk(project)) throw new CollabError("Project not found", 404);
+        return send(res, 200, await store.board(actor, project));
+      }
+      return send(res, 200, await store.board(actor));
+    }
+    case "events":
+      return openTeamEvents(res, url, host);
+    case "task":
+      return send(res, 200, await store.task(actor, id));
+    case "task-create":
+      return send(res, 201, await store.createTask(actor, await body()));
+    case "task-update": {
+      const patch = await body();
+      return send(res, 200, await store.updateTask(actor, id, patch, patch.revision));
+    }
+    case "task-delete":
+      return send(res, 200, await store.deleteTask(actor, id, (await body()).revision));
+    case "comment":
+      return send(res, 200, await store.comment(actor, id, (await body()).text));
+    case "decision":
+      return send(res, 200, await store.decide(actor, id, (await body()).text));
+    case "review-request": {
+      const input = await body();
+      return send(res, 200, await store.requestReview(actor, id, input.reviewer, input.revision));
+    }
+    case "review": {
+      const input = await body(), review = { checkpointId: checkpointIdOf(input.checkpointId), verdict: input.verdict };
+      if (input.text !== void 0 && input.text !== null) review.text = input.text;
+      return send(res, 200, await store.review(actor, id, review, input.revision));
+    }
+    case "instruction-propose":
+      return send(res, 200, await store.proposeInstruction(actor, id, (await body()).text));
+    case "instruction-decide": {
+      const input = await body();
+      if (input.action === "delivered") return send(res, 200, await store.markInstructionDelivered(actor, id, sub, attemptIdOf(input.attemptId)));
+      if (input.action !== "approve" && input.action !== "decline") throw new CollabError('Choose an action: "approve", "decline" or "delivered"');
+      return send(res, 200, await store.decideInstruction(actor, id, sub, input.action));
+    }
+    case "attempt-claim":
+      return send(res, 201, await store.claimAttempt(actor, id, await body()));
+    case "handoff-offer": {
+      const input = await body(), handoff = { to: input.to, checkpointId: input.checkpointId };
+      if (input.note !== void 0 && input.note !== null) handoff.note = input.note;
+      return send(res, 200, await store.offerHandoff(actor, id, handoff, input.revision));
+    }
+    case "handoff-respond": {
+      const input = await body();
+      return send(res, 200, await store.respondHandoff(actor, id, sub, input.action, input.revision));
+    }
+    case "attempt-progress":
+      return send(res, 200, await store.attemptProgress(actor, id, await body()));
+    case "attempt-heartbeat":
+      return send(res, 200, await store.heartbeat(actor, id));
+    case "attempt-finish":
+      return send(res, 200, await store.finishAttempt(actor, id, await body()));
+    case "attempt-recover":
+      return send(res, 200, await store.recoverAttempt(actor, id, await body()));
+    case "checkpoint-add":
+      return send(res, 201, await store.addCheckpoint(actor, id, await body()));
+    case "checkpoint":
+      return send(res, 200, await checkpointById(store, actor, id));
+    case "checkpoint-delete":
+      await store.deleteCheckpoint(actor, id);
+      return send(res, 200, { deleted: true });
+    case "bundle-upload":
+      return uploadBundle(req, res, store, actor, id);
+    case "bundle-download":
+      return downloadBundle(res, store, actor, id);
+    case "inbox":
+      return send(res, 200, await store.inbox(actor, url.searchParams.get("after") ?? void 0));
+    case "inbox-read": {
+      const input = await body();
+      return send(res, 200, await store.markRead(actor, input.all === true ? "all" : input.ids));
+    }
+    case "runners":
+      return send(res, 200, await store.runners(actor));
+    case "runner-revoke":
+      await store.revokeRunner(actor, id);
+      return send(res, 200, { revoked: true });
+    case "repositories": {
+      const input = await body();
+      return send(res, 200, await store.setRepositories(actor, id, input.repositories, input.revision));
+    }
+    case "profile":
+      return send(res, 200, await store.setOwnerName(actor, (await body()).displayName));
+  }
+}
+async function checkpointById(store, actor, id) {
+  if (CHECKPOINT_ID.test(id)) {
+    const board = await store.board(actor), order = board.tasks.filter((task) => task.checkpoint?.id === id).map((task) => task.id);
+    for (const task of board.tasks) if (!order.includes(task.id)) order.push(task.id);
+    for (const taskId of order) {
+      const found = (await store.task(actor, taskId)).checkpoints.find((checkpoint) => checkpoint.id === id);
+      if (found) return found;
+    }
+  }
+  throw new CollabError("Checkpoint not found", 404);
+}
+async function uploadBundle(req, res, store, actor, id) {
+  const declared = req.headers["content-length"], size = declared !== void 0 && /^\d{1,12}$/.test(declared) ? Number(declared) : void 0;
+  const refuse = (status, message) => {
+    send(res, status, { error: message });
+    if (req.complete || req.destroyed) return;
+    if (size !== void 0 && size <= MAX.bundle) req.resume();
+    else res.once("finish", () => req.destroy());
+  };
+  if (!/^application\/octet-stream(?:\s*;|$)/i.test(String(req.headers["content-type"] ?? ""))) return refuse(415, "Upload the checkpoint bundle as application/octet-stream");
+  if (size === void 0) return refuse(411, "Send content-length with the checkpoint bundle");
+  if (size > MAX.bundle) return refuse(413, `Checkpoint bundles are limited to ${MAX.bundle / 1024 / 1024} MiB`);
+  const sha256 = String(req.headers["x-codeflow-sha256"] ?? "").toLowerCase();
+  if (!SHA256_HEX.test(sha256)) return refuse(400, "Send the bundle's SHA-256 digest as 64 hexadecimal characters in the x-codeflow-sha256 header");
+  try {
+    const checkpoint = await store.storeBundle(actor, id, req, { size, sha256 });
+    send(res, 200, { checkpoint });
+  } catch (error) {
+    if (!(error instanceof CollabError)) throw error;
+    refuse(error.status, error.message);
+  }
+}
+async function downloadBundle(res, store, actor, id) {
+  const { path, checkpoint } = await store.bundlePath(actor, id), missing = () => new CollabError("The checkpoint bundle is missing from the hub's storage; create a new checkpoint", 404);
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)).catch(() => {
+    throw missing();
+  });
+  const info = await handle.stat().catch(() => void 0);
+  if (!info?.isFile() || info.size !== checkpoint.size) {
+    await handle.close().catch(() => void 0);
+    throw missing();
+  }
+  res.writeHead(200, { "content-type": "application/octet-stream", "content-length": String(checkpoint.size), "x-codeflow-sha256": checkpoint.sha256, "cache-control": "no-store", "content-disposition": `attachment; filename="${checkpoint.id}.bundle"` });
+  try {
+    await pipeline(handle.createReadStream(), res);
+  } catch {
+    res.destroy();
+  }
+}
+const teamStreams = /* @__PURE__ */ new Map();
+let totalTeamStreams = 0;
+const STREAM_BYTES = 2 * 1024 * 1024, PING_MS = 15e3, STREAMS_PER_USER = 4, STREAMS_TOTAL = 128, CURSOR_MAX = 100;
+function teamStream(res, userId) {
+  const count = teamStreams.get(userId) ?? 0;
+  if (count >= STREAMS_PER_USER || totalTeamStreams >= STREAMS_TOTAL) throw new HttpError(429, "Too many team event streams; close another tab and retry");
+  teamStreams.set(userId, count + 1);
+  totalTeamStreams++;
+  let closed = false;
+  const disposers = [];
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    const remaining = (teamStreams.get(userId) ?? 1) - 1;
+    if (remaining) teamStreams.set(userId, remaining);
+    else teamStreams.delete(userId);
+    totalTeamStreams--;
+    for (const dispose of disposers.splice(0)) dispose();
+    res.destroy();
+  };
+  const write = (frame) => {
+    if (closed) return;
+    const bytes = Buffer.byteLength(frame);
+    if (bytes > STREAM_BYTES || res.writableLength + bytes > STREAM_BYTES) return close();
+    res.write(frame);
+  };
+  res.on("close", close);
+  if (res.destroyed) close();
+  if (!closed) res.writeHead(200, { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-store", connection: "keep-alive", "x-accel-buffering": "no" });
+  return { close, add: (dispose) => {
+    if (closed) dispose();
+    else disposers.push(dispose);
+  }, emit: (frame) => write(`data: ${JSON.stringify(frame)}
+
+`), ping: () => write(": connected\n\n") };
+}
+const rolesKey = (actor) => actor.kind === "owner" ? "owner" : Object.entries(actor.roles).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([project, role]) => `${project}=${role}`).join(",");
+const seesAllRunners = (actor) => actor.kind === "owner";
+async function openTeamEvents(res, url, host) {
+  const after = url.searchParams.get("after") ?? void 0;
+  if (after !== void 0 && after.length > CURSOR_MAX) throw new HttpError(400, "Invalid team event cursor");
+  const { store } = host;
+  let actor = host.actor;
+  const { unread } = await store.inbox(actor);
+  const stream = teamStream(res, actor.userId);
+  let roles = rolesKey(actor), last = 0, counting = false;
+  const refresh = () => {
+    if (!host.reauthorize) return;
+    const next = host.reauthorize();
+    if (next.userId !== actor.userId) throw new HttpError(401, "Team session changed");
+    actor = next;
+    const key = rolesKey(next);
+    if (key !== roles) {
+      roles = key;
+      stream.emit({ type: "resync" });
+    }
+  };
+  const inboxFrame = () => {
+    if (counting) return;
+    counting = true;
+    store.inbox(actor).then(({ unread: unread2 }) => {
+      counting = false;
+      stream.emit({ type: "inbox", seq: last, unread: unread2 });
+    }, () => stream.close());
+  };
+  const deliver = (event) => {
+    if (event.seq <= last) return;
+    last = event.seq;
+    if (event.kind === "inbox") {
+      if (event.userIds?.includes(actor.userId)) inboxFrame();
+      return;
+    }
+    if (event.kind === "runners") {
+      if (!event.userIds || event.userIds.includes(actor.userId) || seesAllRunners(actor)) stream.emit({ type: "change", seq: event.seq, kind: "runners" });
+      return;
+    }
+    if (event.projectId !== void 0 ? actorRole(actor, event.projectId) === void 0 : event.kind !== "board") return;
+    const frame = { type: "change", seq: event.seq, kind: event.kind };
+    if (event.taskId !== void 0) frame.taskId = event.taskId;
+    if (event.projectId !== void 0) frame.projectId = event.projectId;
+    stream.emit(frame);
+  };
+  stream.add(store.onChange((event) => {
+    try {
+      refresh();
+      deliver(event);
+    } catch {
+      stream.close();
+    }
+  }));
+  const timer = setInterval(() => {
+    try {
+      refresh();
+      stream.ping();
+    } catch {
+      stream.close();
+    }
+  }, PING_MS);
+  timer.unref();
+  stream.add(() => clearInterval(timer));
+  const page = store.eventsSince(after);
+  stream.emit({ type: "hello", epoch: page.epoch, seq: page.seq, unread });
+  if (page.resync) stream.emit({ type: "resync" });
+  for (const event of page.events) deliver(event);
+  last = Math.max(last, page.seq);
+}
+async function handleRunnerConnect(req, res, host) {
+  const body = await readLoginJson(req);
+  try {
+    const name = validateText(body.name, MAX.runnerName, "computer name", { required: true, singleLine: true });
+    const user = await host.accounts.verifyCredentials({ username: body.username, password: body.password, ...host.transport });
+    if (!Object.values(user.roles).some((role) => roleAtLeast(role, "contributor"))) throw new CollabError("Ask the team server's owner for a contributor role before connecting a computer", 403);
+    const { runner, token } = await host.store.registerRunner(user.id, name, host.transport.address);
+    send(res, 201, { runner, token, user: { userId: user.id, username: user.username, displayName: user.displayName }, hub: { name: host.ownerName ?? host.store.ownerName } });
+  } catch (error) {
+    if (error instanceof CollabError || error instanceof SharedAccountError) return send(res, error.status, { error: error.message });
+    throw error;
+  }
+}
+export {
+  RUNNER_TOKEN,
+  TEAM_BODY_LIMIT,
+  handleRunnerConnect,
+  handleTeamApi,
+  isTeamApiPath,
+  looksLikeRunnerToken,
+  runnerAllowed,
+  teamRoutePolicy
+};