@nickmeriano/task 0.11.0 → 0.12.0

package/dist/functions/board.js

@@ -0,0 +1,709 @@
+class TarError extends Error {
+}
+const BLOCK = 512;
+class ByteReader {
+  reader;
+  chunks = [];
+  have = 0;
+  done = false;
+  constructor(stream) {
+    this.reader = stream.getReader();
+  }
+  async pull() {
+    if (this.done) return false;
+    const { done, value } = await this.reader.read();
+    if (done) {
+      this.done = true;
+      return false;
+    }
+    if (value && value.length > 0) {
+      this.chunks.push(value);
+      this.have += value.length;
+    }
+    return true;
+  }
+  /** Exactly `n` bytes; null at a clean end-of-stream, throws mid-entry. */
+  async read(n) {
+    while (this.have < n) {
+      if (!await this.pull()) {
+        if (this.have === 0) return null;
+        throw new TarError("truncated archive");
+      }
+    }
+    const out = new Uint8Array(n);
+    let filled = 0;
+    while (filled < n) {
+      const head = this.chunks[0];
+      const take = Math.min(head.length, n - filled);
+      out.set(head.subarray(0, take), filled);
+      filled += take;
+      if (take === head.length) this.chunks.shift();
+      else this.chunks[0] = head.subarray(take);
+    }
+    this.have -= n;
+    return out;
+  }
+  /** Discard `n` bytes without accumulating them. */
+  async skip(n) {
+    while (n > 0) {
+      if (this.chunks.length === 0) {
+        if (!await this.pull()) throw new TarError("truncated archive");
+        continue;
+      }
+      const head = this.chunks[0];
+      const take = Math.min(head.length, n);
+      if (take === head.length) this.chunks.shift();
+      else this.chunks[0] = head.subarray(take);
+      this.have -= take;
+      n -= take;
+    }
+  }
+}
+const decoder = new TextDecoder();
+function field$1(header, start, length) {
+  const slice = header.subarray(start, start + length);
+  const nul = slice.indexOf(0);
+  return decoder.decode(nul < 0 ? slice : slice.subarray(0, nul));
+}
+function octal(header, start, length) {
+  const text = field$1(header, start, length).trim();
+  if (text === "") return 0;
+  const value = parseInt(text, 8);
+  if (Number.isNaN(value) || value < 0) throw new TarError("bad size field");
+  return value;
+}
+function paxPath(data) {
+  const text = decoder.decode(data);
+  for (let at = 0; at < text.length; ) {
+    const space = text.indexOf(" ", at);
+    if (space < 0) break;
+    const length = Number(text.slice(at, space));
+    if (!Number.isInteger(length) || length <= 0) break;
+    const record = text.slice(space + 1, at + length);
+    if (record.startsWith("path=")) return record.slice(5).replace(/\n$/, "");
+    at += length;
+  }
+  return null;
+}
+async function readTar(stream, keep) {
+  const bytes = new ByteReader(stream);
+  const paths = [];
+  const files = /* @__PURE__ */ new Map();
+  let overridePath = null;
+  for (; ; ) {
+    const header = await bytes.read(BLOCK);
+    if (header === null) break;
+    if (header.every((b) => b === 0)) {
+      break;
+    }
+    const size = octal(header, 124, 12);
+    const padded = Math.ceil(size / BLOCK) * BLOCK;
+    const type = header[156];
+    if (type === 120 || type === 76) {
+      const data = await bytes.read(size);
+      if (data === null) throw new TarError("truncated archive");
+      overridePath = type === 120 ? paxPath(data) ?? overridePath : decoder.decode(data).replace(/\0+$/, "");
+      await bytes.skip(padded - size);
+      continue;
+    }
+    let name = field$1(header, 0, 100);
+    const prefix = field$1(header, 257, 6).startsWith("ustar") ? field$1(header, 345, 155) : "";
+    if (prefix) name = `${prefix}/${name}`;
+    if (overridePath !== null) {
+      name = overridePath;
+      overridePath = null;
+    }
+    if (type !== 48 && type !== 0) {
+      await bytes.skip(padded);
+      continue;
+    }
+    const slash = name.indexOf("/");
+    if (slash < 0) {
+      await bytes.skip(padded);
+      continue;
+    }
+    const path = name.slice(slash + 1);
+    if (path === "") {
+      await bytes.skip(padded);
+      continue;
+    }
+    paths.push(path);
+    if (keep(path)) {
+      const data = await bytes.read(size);
+      if (data === null) throw new TarError("truncated archive");
+      files.set(path, data);
+      await bytes.skip(padded - size);
+    } else {
+      await bytes.skip(padded);
+    }
+  }
+  return { paths, files };
+}
+
+const API = "https://api.github.com";
+const UA = "@nickmeriano/task";
+class GitHubError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "GitHubError";
+    this.status = status;
+  }
+}
+async function apiGet(token, path) {
+  const res = await fetch(`${API}${path}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "User-Agent": UA
+    }
+  });
+  if (!res.ok) throw new GitHubError(res.status, `GET ${path} failed (${res.status})`);
+  return await res.json();
+}
+async function repoInfo(token, owner, repo) {
+  const data = await apiGet(
+    token,
+    `/repos/${owner}/${repo}`
+  );
+  return { defaultBranch: data.default_branch, private: data.private };
+}
+async function listBranches(token, owner, repo) {
+  const data = await apiGet(
+    token,
+    `/repos/${owner}/${repo}/branches?per_page=100`
+  );
+  return data.map((branch) => branch.name);
+}
+async function headCommit(token, owner, repo, ref) {
+  const data = await apiGet(token, `/repos/${owner}/${repo}/commits/${encodeURIComponent(ref)}`);
+  return {
+    sha: data.sha,
+    committedAt: data.commit.committer.date,
+    message: data.commit.message.split("\n")[0]
+  };
+}
+function isMissingRef(error) {
+  return error instanceof GitHubError && (error.status === 404 || error.status === 422);
+}
+async function fetchRepoArchive(token, owner, repo, sha, keep) {
+  const res = await fetch(`${API}/repos/${owner}/${repo}/tarball/${encodeURIComponent(sha)}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "User-Agent": UA
+    }
+  });
+  if (!res.ok || !res.body) {
+    throw new GitHubError(res.status, `could not read the repository archive (${res.status})`);
+  }
+  try {
+    return await readTar(res.body.pipeThrough(new DecompressionStream("gzip")), keep);
+  } catch (error) {
+    if (error instanceof TarError) {
+      throw new GitHubError(502, `could not read the repository archive (${error.message})`);
+    }
+    throw error;
+  }
+}
+
+const STATUSES = [
+  "backlog",
+  "todo",
+  "in_progress",
+  "done",
+  "canceled"
+];
+function isStatus(value) {
+  return STATUSES.includes(value);
+}
+
+function parseScalar(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") return "";
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+function splitRaw(text, where) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  if (lines[0] !== "---") {
+    return null;
+  }
+  const end = lines.indexOf("---", 1);
+  if (end < 0) {
+    return null;
+  }
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of lines.slice(1, end)) {
+    if (!line.trim()) continue;
+    const colon = line.indexOf(":");
+    if (colon < 0) {
+      continue;
+    }
+    fields.set(line.slice(0, colon).trim(), line.slice(colon + 1));
+  }
+  const body = lines.slice(end + 1).join("\n");
+  return { fields, body: body.replace(/^\n+/, "").replace(/\s+$/, "") };
+}
+function field(raw, key) {
+  const value = raw.fields.get(key);
+  return value === void 0 ? void 0 : parseScalar(value);
+}
+function splitTitle(body) {
+  if (!body.startsWith("# ")) return { title: null, description: body };
+  const newline = body.indexOf("\n");
+  if (newline < 0) return { title: body.slice(2).trim(), description: "" };
+  return {
+    title: body.slice(2, newline).trim(),
+    description: body.slice(newline + 1).replace(/^\n+/, "")
+  };
+}
+function parseGoalLenient(text) {
+  const raw = splitRaw(text);
+  if (!raw) return null;
+  const { title, description } = splitTitle(raw.body);
+  return {
+    title: title ?? "",
+    description,
+    createdAt: lenientString(field(raw, "created")),
+    updatedAt: lenientString(field(raw, "updated"))
+  };
+}
+function parseAskLenient(text) {
+  const raw = splitRaw(text);
+  if (!raw) return null;
+  const resolvedAt = field(raw, "resolved");
+  return {
+    author: lenientString(field(raw, "author")),
+    createdAt: lenientString(field(raw, "created")),
+    resolvedAt: typeof resolvedAt === "string" && resolvedAt !== "" ? resolvedAt : null,
+    resolvedBy: lenientString(field(raw, "resolved_by")) || null,
+    body: raw.body
+  };
+}
+function lenientStrings(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+function lenientKeys(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+function lenientString(value) {
+  return typeof value === "string" ? value : "";
+}
+function parseTicketLenient(text) {
+  const raw = splitRaw(text);
+  if (!raw) return null;
+  const status = field(raw, "status");
+  const goal = field(raw, "goal");
+  const position = field(raw, "position");
+  const { title, description } = splitTitle(raw.body);
+  return {
+    title: title ?? "",
+    description,
+    status: typeof status === "string" && isStatus(status) ? status : "backlog",
+    tags: lenientStrings(field(raw, "tags")),
+    goal: typeof goal === "string" && goal !== "" ? goal : null,
+    blockedBy: [...new Set(lenientKeys(field(raw, "blocked_by")))].sort(),
+    prs: lenientStrings(field(raw, "prs")),
+    position: typeof position === "number" && Number.isFinite(position) ? position : 0,
+    createdAt: lenientString(field(raw, "created")),
+    updatedAt: lenientString(field(raw, "updated"))
+  };
+}
+function parseCommentLenient(text) {
+  const raw = splitRaw(text);
+  if (!raw) return null;
+  return {
+    author: lenientString(field(raw, "author")),
+    createdAt: lenientString(field(raw, "created")),
+    body: raw.body
+  };
+}
+
+const KEY_PATTERN = /^(?=.*[a-z])[a-z0-9]{4,12}$/;
+function isTicketKey(value) {
+  return KEY_PATTERN.test(value);
+}
+
+const TASK_DIR = ".task";
+const CONFIG_FILE = "config.json";
+const TICKETS_DIR = "tickets";
+const TICKET_FILE = "ticket.md";
+const COMMENTS_DIR = "comments";
+const ASKS_DIR = "asks";
+const GOALS_DIR = "goals";
+const MAX_DEPTH = 6;
+class BoardSourceError extends Error {
+  status;
+  /**
+   * Machine-readable cause, sent beside the message so the SPA can choose a
+   * screen rather than infer one from a status code. Optional: most of these
+   * are one of a kind and the message is the whole story.
+   */
+  reason;
+  constructor(status, message, reason = null) {
+    super(message);
+    this.name = "BoardSourceError";
+    this.status = status;
+    this.reason = reason;
+  }
+}
+function str(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function num(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function parseConfig(bytes, fallbackName) {
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(bytes));
+    if (parsed && typeof parsed === "object") {
+      const config = parsed;
+      return {
+        name: str(config.name, fallbackName),
+        prefix: str(config.prefix, "TASK").toUpperCase(),
+        version: num(config.version, 1)
+      };
+    }
+  } catch {
+  }
+  return { name: fallbackName, prefix: "TASK", version: 1 };
+}
+function findBoardDirs(paths) {
+  const marker = `${TASK_DIR}/${CONFIG_FILE}`;
+  const dirs = [];
+  for (const path of paths) {
+    if (path !== marker && !path.endsWith(`/${marker}`)) continue;
+    const dir = path.slice(0, -(TASK_DIR.length + CONFIG_FILE.length + 2));
+    const id = dir === "" ? "." : dir.replace(/\/$/, "");
+    if (id !== "." && id.split("/").length > MAX_DEPTH) continue;
+    dirs.push(id);
+  }
+  dirs.sort((a, b) => a === "." ? -1 : b === "." ? 1 : a < b ? -1 : 1);
+  return dirs;
+}
+function nameFromDir(id) {
+  if (id === ".") return "tasks";
+  return id.split("/").pop() ?? "tasks";
+}
+function readTicketsBoard(id, configBytes, files) {
+  const config = parseConfig(configBytes, nameFromDir(id));
+  const decoder = new TextDecoder();
+  const docs = /* @__PURE__ */ new Map();
+  const comments = /* @__PURE__ */ new Map();
+  const asks = /* @__PURE__ */ new Map();
+  const goals = [];
+  for (const [path, bytes] of files) {
+    const goalMatch = new RegExp(`^${GOALS_DIR}/(archive/)?([^/]+)\\.md$`).exec(path);
+    if (goalMatch) {
+      if (goalMatch[2].startsWith(".")) continue;
+      const doc = parseGoalLenient(decoder.decode(bytes));
+      if (doc) {
+        goals.push({
+          slug: goalMatch[2],
+          title: doc.title,
+          description: doc.description,
+          createdAt: doc.createdAt,
+          updatedAt: doc.updatedAt,
+          ...goalMatch[1] ? { archived: true } : {}
+        });
+      }
+      continue;
+    }
+    const ticketMatch = new RegExp(`^${TICKETS_DIR}/([^/]+)/${TICKET_FILE}$`).exec(path);
+    if (ticketMatch && isTicketKey(ticketMatch[1])) {
+      const doc = parseTicketLenient(decoder.decode(bytes));
+      if (doc) docs.set(ticketMatch[1], doc);
+      continue;
+    }
+    const commentMatch = new RegExp(`^${TICKETS_DIR}/([^/]+)/${COMMENTS_DIR}/([^/]+)\\.md$`).exec(
+      path
+    );
+    if (commentMatch && isTicketKey(commentMatch[1]) && !commentMatch[2].startsWith(".")) {
+      const doc = parseCommentLenient(decoder.decode(bytes));
+      if (!doc) continue;
+      const taskKey = commentMatch[1];
+      const list = comments.get(taskKey) ?? [];
+      list.push({
+        id: commentMatch[2],
+        taskId: `${config.prefix}-${taskKey}`,
+        author: doc.author,
+        body: doc.body,
+        createdAt: doc.createdAt
+      });
+      comments.set(taskKey, list);
+      continue;
+    }
+    const askMatch = new RegExp(`^${TICKETS_DIR}/([^/]+)/${ASKS_DIR}/([^/]+)\\.md$`).exec(path);
+    if (askMatch && isTicketKey(askMatch[1]) && !askMatch[2].startsWith(".")) {
+      const doc = parseAskLenient(decoder.decode(bytes));
+      if (!doc) continue;
+      const taskKey = askMatch[1];
+      const list = asks.get(taskKey) ?? [];
+      list.push({
+        id: askMatch[2],
+        taskId: `${config.prefix}-${taskKey}`,
+        ordinal: 0,
+        text: doc.body,
+        author: doc.author,
+        createdAt: doc.createdAt,
+        resolvedAt: doc.resolvedAt,
+        resolvedBy: doc.resolvedBy
+      });
+      asks.set(taskKey, list);
+    }
+  }
+  for (const taskKey of comments.keys()) {
+    if (!docs.has(taskKey)) comments.delete(taskKey);
+  }
+  for (const list of comments.values()) {
+    list.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+  }
+  for (const taskKey of asks.keys()) {
+    if (!docs.has(taskKey)) asks.delete(taskKey);
+  }
+  for (const list of asks.values()) {
+    list.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+    list.forEach((ask, index) => ask.ordinal = index + 1);
+  }
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, doc] of docs) {
+    for (const blocker of doc.blockedBy) {
+      blocks.set(blocker, [...blocks.get(blocker) ?? [], key]);
+    }
+  }
+  for (const list of blocks.values()) list.sort((a, b) => a.localeCompare(b));
+  const tasks = [...docs.entries()].map(([key, doc]) => ({
+    id: `${config.prefix}-${key}`,
+    key,
+    title: doc.title,
+    description: doc.description,
+    status: doc.status,
+    tags: doc.tags,
+    goal: doc.goal,
+    needsHuman: (asks.get(key) ?? []).some((a) => !a.resolvedAt),
+    asks: asks.get(key) ?? [],
+    blocks: blocks.get(key) ?? [],
+    blockedBy: doc.blockedBy,
+    prs: doc.prs,
+    position: doc.position,
+    createdAt: doc.createdAt,
+    updatedAt: doc.updatedAt,
+    commentCount: comments.get(key)?.length ?? 0
+  })).sort(
+    (a, b) => a.position - b.position || a.createdAt.localeCompare(b.createdAt) || a.key.localeCompare(b.key)
+  );
+  goals.sort(
+    (a, b) => Number(a.archived === true) - Number(b.archived === true) || a.slug.localeCompare(b.slug)
+  );
+  return { info: { id, name: config.name, prefix: config.prefix }, tasks, comments, goals };
+}
+async function snapshotAt(token, owner, repo, commit, ref = "HEAD") {
+  const { paths, files } = await fetchRepoArchive(
+    token,
+    owner,
+    repo,
+    commit.sha,
+    (path) => path.startsWith(`${TASK_DIR}/`) || path.includes(`/${TASK_DIR}/`)
+  );
+  const dirs = findBoardDirs(paths);
+  if (dirs.length === 0) {
+    throw new BoardSourceError(
+      404,
+      ref === "HEAD" ? "no .task directory in this repository — run `task init` and commit it" : `no .task directory on ${ref}`,
+      "no-boards"
+    );
+  }
+  const data = /* @__PURE__ */ new Map();
+  for (const id of dirs) {
+    const base = id === "." ? TASK_DIR : `${id}/${TASK_DIR}`;
+    const configBytes = files.get(`${base}/${CONFIG_FILE}`);
+    if (!configBytes) continue;
+    const prefix = `${base}/`;
+    const ticketPaths = paths.filter(
+      (path) => (path.startsWith(`${prefix}${TICKETS_DIR}/`) || path.startsWith(`${prefix}${GOALS_DIR}/`)) && path.endsWith(".md")
+    );
+    if (ticketPaths.length === 0 && parseConfig(configBytes, "").version < 2) continue;
+    const tickets = /* @__PURE__ */ new Map();
+    for (const path of ticketPaths) {
+      const bytes = files.get(path);
+      if (bytes) tickets.set(path.slice(prefix.length), bytes);
+    }
+    const board = readTicketsBoard(id, configBytes, tickets);
+    data.set(board.info.id, board);
+  }
+  if (data.size === 0) {
+    throw new BoardSourceError(
+      404,
+      "found .task/config.json but no committed tickets — are .task/tickets/ gitignored, or is this a pre-0.6 SQLite board that still needs `task migrate` (@nickmeriano/task@0.6)?"
+    );
+  }
+  return {
+    commit,
+    boards: [...data.values()].map((board) => board.info),
+    data,
+    truncated: false
+  };
+}
+class SnapshotMemory {
+  snapshots = /* @__PURE__ */ new Map();
+  max;
+  constructor(max = 24) {
+    this.max = max;
+  }
+  get(key) {
+    return this.snapshots.get(key);
+  }
+  remember(key, snapshot) {
+    this.snapshots.set(key, snapshot);
+    while (this.snapshots.size > this.max) {
+      const oldest = this.snapshots.keys().next().value;
+      if (oldest === void 0) break;
+      this.snapshots.delete(oldest);
+    }
+    return snapshot;
+  }
+}
+
+const REF_PATTERN = /^[\w.\-/]{1,255}$/;
+const REPO_PATTERN = /^[\w.-]+\/[\w.-]+$/;
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      // Every answer is "the repository right now"; nothing between this
+      // function and the browser should hold on to one.
+      "Cache-Control": "no-store"
+    }
+  });
+}
+function pickBoard(snapshot, requested) {
+  const id = requested && snapshot.data.has(requested) ? requested : snapshot.boards[0]?.id;
+  return id === void 0 ? null : snapshot.data.get(id) ?? null;
+}
+function createBoardHandler(options) {
+  const { repo: slug, ref: defaultRef = "HEAD" } = options;
+  if (!REPO_PATTERN.test(slug)) throw new Error(`repo must be owner/name — got ${JSON.stringify(slug)}`);
+  const [owner, repo] = slug.split("/");
+  const basePath = (options.basePath ?? "/api").replace(/\/+$/, "");
+  const memory = new SnapshotMemory(options.maxCachedSnapshots);
+  const inFlight = /* @__PURE__ */ new Map();
+  async function resolveToken() {
+    const token = typeof options.token === "function" ? await options.token() : options.token;
+    if (!token) {
+      throw new BoardSourceError(503, "no GitHub token configured for the live board", "no-token");
+    }
+    return token;
+  }
+  async function load(token, ref, explicit) {
+    let commit;
+    try {
+      commit = await headCommit(token, owner, repo, ref);
+    } catch (error) {
+      if (explicit && isMissingRef(error)) {
+        throw new BoardSourceError(404, `no such branch or ref: ${ref}`, "no-such-ref");
+      }
+      throw error;
+    }
+    const key = `${owner}/${repo}@${commit.sha}`;
+    const cached = memory.get(key);
+    if (cached) return cached;
+    let pending = inFlight.get(key);
+    if (!pending) {
+      pending = snapshotAt(token, owner, repo, commit, ref).then((snapshot) => memory.remember(key, snapshot)).finally(() => inFlight.delete(key));
+      inFlight.set(key, pending);
+    }
+    return pending;
+  }
+  async function handle(request) {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      return json(
+        { error: "this board is read-only — commit and push to change it", reason: "read-only" },
+        405
+      );
+    }
+    const url = new URL(request.url);
+    if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`)) {
+      return json({ error: `not an API path: ${url.pathname}` }, 404);
+    }
+    const route = url.pathname.slice(basePath.length) || "/";
+    const token = await resolveToken();
+    if (route === "/branches") {
+      const [names, info] = await Promise.all([
+        listBranches(token, owner, repo),
+        repoInfo(token, owner, repo)
+      ]);
+      const branches = names.map((name) => ({ name, isDefault: name === info.defaultBranch })).sort((a, b) => Number(b.isDefault) - Number(a.isDefault) || a.name.localeCompare(b.name));
+      return json({ branches });
+    }
+    const requestedRef = url.searchParams.get("ref");
+    const ref = requestedRef && REF_PATTERN.test(requestedRef) && !requestedRef.includes("..") ? requestedRef : null;
+    const snapshot = await load(token, ref ?? defaultRef, ref !== null);
+    if (route === "/boards") return json({ boards: snapshot.boards });
+    const board = pickBoard(snapshot, url.searchParams.get("board"));
+    if (!board) return json({ error: "no such board" }, 404);
+    if (route === "/project") {
+      return json({
+        name: board.info.name,
+        prefix: board.info.prefix,
+        statuses: STATUSES,
+        // The payload the SPA reads to decide whether to offer editing at all.
+        // The data is a commit; the only way to change one is to push.
+        readOnly: true,
+        // Locally this is who would author a comment. Nothing here can
+        // comment, and nothing here knows who is looking.
+        author: ""
+      });
+    }
+    if (route === "/tasks") return json({ tasks: board.tasks });
+    if (route === "/goals") return json({ goals: board.goals });
+    const detail = /^\/tasks\/([^/]+)$/.exec(route);
+    if (detail) {
+      const match = /^(?:[A-Za-z0-9]+-)?([A-Za-z0-9]+)$/.exec(decodeURIComponent(detail[1]));
+      if (!match) return json({ error: "invalid task id" }, 400);
+      const key = match[1].toLowerCase();
+      const task = board.tasks.find((candidate) => candidate.key === key);
+      if (!task) return json({ error: `no such task: ${key}` }, 404);
+      return json({ task, comments: board.comments.get(key) ?? [] });
+    }
+    return json({ error: `not here: ${route}` }, 404);
+  }
+  return async (request) => {
+    try {
+      return await handle(request);
+    } catch (error) {
+      if (error instanceof BoardSourceError) {
+        return json({ error: error.message, reason: error.reason }, error.status);
+      }
+      if (error instanceof GitHubError) {
+        return json(
+          {
+            error: `GitHub answered ${error.status} — check the token and the repository name`,
+            reason: "github"
+          },
+          502
+        );
+      }
+      return json({ error: error instanceof Error ? error.message : "internal error" }, 500);
+    }
+  };
+}
+
+const REPO = "__TASK_EXPORT_REPO__";
+const BASE_PATH = "__TASK_EXPORT_BASE_PATH__";
+const TOKEN_SECRET = "TASK_GITHUB_TOKEN";
+let currentToken = "";
+let handler = null;
+function onRequest(context) {
+  const token = context.env[TOKEN_SECRET];
+  if (!token) return new Response(null, { status: 503 });
+  currentToken = token;
+  handler ??= createBoardHandler({ token: () => currentToken, repo: REPO, basePath: BASE_PATH });
+  return handler(context.request);
+}
+
+export { TOKEN_SECRET, onRequest };