pipe-kan 0.9.1

package/dist/pipe-kan.js

@@ -0,0 +1,817 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+
+// src/board.ts
+function formatDueDate(value) {
+  if (typeof value !== "string" || !value)
+    return;
+  const day = /^(\d{4})-(\d{2})-(\d{2})/.exec(value);
+  const date = day ? new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3])) : new Date(value);
+  if (Number.isNaN(date.getTime()))
+    return value;
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function createdAt(fields) {
+  return typeof fields?.created === "string" && fields.created ? fields.created : undefined;
+}
+function issueType(fields) {
+  const name = fields?.issuetype?.name ?? fields?.issueType?.name;
+  return typeof name === "string" ? name : undefined;
+}
+function epicKey(fields) {
+  return typeof fields?.parent?.key === "string" ? fields.parent.key : undefined;
+}
+function labelName(item) {
+  if (typeof item === "string" && item)
+    return item;
+  if (item && typeof item === "object" && "name" in item) {
+    const name = item.name;
+    if (typeof name === "string" && name)
+      return name;
+  }
+  return;
+}
+function issueLabels(fields) {
+  const raw = [
+    ...Array.isArray(fields?.labels) ? fields.labels : [],
+    ...Array.isArray(fields?.components) ? fields.components : []
+  ];
+  const labels = [...new Set(raw.map(labelName).filter((name) => !!name))];
+  return labels.length > 0 ? labels : undefined;
+}
+function issueStatus(fields) {
+  return typeof fields?.status?.name === "string" && fields.status.name ? fields.status.name : undefined;
+}
+function toEpic(face) {
+  return {
+    key: face.key,
+    summary: face.summary,
+    ...face.status ? { status: face.status } : {},
+    ...face.priority ? { priority: face.priority } : {},
+    ...face.assignee ? { assignee: face.assignee } : {},
+    ...face.dueDate ? { dueDate: face.dueDate } : {}
+  };
+}
+function toCard(issue, key) {
+  const summary = typeof issue.fields?.summary === "string" ? issue.fields.summary : "";
+  const priority = typeof issue.fields?.priority?.name === "string" ? issue.fields.priority.name : undefined;
+  const assignee = typeof issue.fields?.assignee?.displayName === "string" ? issue.fields.assignee.displayName : undefined;
+  const dueDate = formatDueDate(issue.fields?.duedate);
+  const type = issueType(issue.fields);
+  const epic = epicKey(issue.fields);
+  const labels = issueLabels(issue.fields);
+  const created = createdAt(issue.fields);
+  return {
+    key,
+    summary,
+    ...priority ? { priority } : {},
+    ...assignee ? { assignee } : {},
+    ...dueDate ? { dueDate } : {},
+    ...type ? { type } : {},
+    ...epic ? { epic } : {},
+    ...labels ? { labels } : {},
+    ...created ? { created } : {}
+  };
+}
+function issuesToBoard(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("jira-cli --raw payload must be a JSON array");
+  }
+  const columns = [];
+  const byStatus = new Map;
+  const epics = [];
+  const epicByKey = new Map;
+  function rememberEpic(epic) {
+    const existing = epicByKey.get(epic.key);
+    if (!existing) {
+      epicByKey.set(epic.key, epic);
+      epics.push(epic);
+      return;
+    }
+    if (!existing.summary && epic.summary) {
+      Object.assign(existing, epic);
+    }
+  }
+  for (const issue of raw) {
+    const key = typeof issue?.key === "string" ? issue.key : "";
+    const status = typeof issue?.fields?.status?.name === "string" ? issue.fields.status.name : "";
+    if (!key || !status)
+      continue;
+    const card = toCard(issue, key);
+    if ((card.type ?? "").toLowerCase() === "epic") {
+      rememberEpic(toEpic({ ...card, status: issueStatus(issue.fields) }));
+      continue;
+    }
+    if (card.epic) {
+      rememberEpic({ key: card.epic, summary: card.epic });
+    }
+    let column = byStatus.get(status);
+    if (!column) {
+      column = { id: status, title: status, cards: [] };
+      byStatus.set(status, column);
+      columns.push(column);
+    }
+    column.cards.push(card);
+  }
+  return { columns, epics };
+}
+function mergeEpics(listed, fromBoard) {
+  const byKey = new Map;
+  for (const epic of listed)
+    byKey.set(epic.key, { ...epic });
+  for (const epic of fromBoard) {
+    const existing = byKey.get(epic.key);
+    if (!existing) {
+      byKey.set(epic.key, { ...epic });
+      continue;
+    }
+    if (!existing.summary && epic.summary)
+      Object.assign(existing, epic);
+  }
+  return [...byKey.values()];
+}
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join, resolve } from "node:path";
+
+// src/flags.ts
+var DEFAULT_FLAGS = "";
+function tokens(input) {
+  const out = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let match;
+  while (match = re.exec(input)) {
+    out.push(match[1] ?? match[2] ?? match[3]);
+  }
+  return out;
+}
+function takeValue(list, index, flag) {
+  const glued = list[index].slice(flag.length);
+  if (glued)
+    return [glued, index];
+  return [list[index + 1] ?? "", index + 1];
+}
+function flagsToJql(flags) {
+  const list = tokens(flags.trim() || DEFAULT_FLAGS);
+  let assignee = "";
+  let epic = "";
+  let type = "";
+  let raw = "";
+  const statusEq = [];
+  const statusNeq = [];
+  for (let i = 0;i < list.length; i++) {
+    const token = list[i];
+    if (token === "--raw")
+      continue;
+    if (token.startsWith("-a")) {
+      [assignee, i] = takeValue(list, i, "-a");
+      continue;
+    }
+    if (token.startsWith("-P")) {
+      [epic, i] = takeValue(list, i, "-P");
+      continue;
+    }
+    if (token.startsWith("-t")) {
+      [type, i] = takeValue(list, i, "-t");
+      continue;
+    }
+    if (token.startsWith("-s")) {
+      const [status, next] = takeValue(list, i, "-s");
+      i = next;
+      if (status.startsWith("~"))
+        statusNeq.push(status.slice(1));
+      else
+        statusEq.push(status);
+      continue;
+    }
+    if (token === "-q" || token === "--jql") {
+      raw = list[++i] ?? "";
+      continue;
+    }
+    if (token.startsWith("-q")) {
+      raw = token.slice(2);
+    }
+  }
+  if (raw)
+    return raw;
+  const clauses = ['project="DEMO"'];
+  if (assignee)
+    clauses.push(`assignee="${assignee}"`);
+  if (type)
+    clauses.push(`type="${type}"`);
+  if (epic)
+    clauses.push(`parent="${epic}"`);
+  for (const status of statusEq)
+    clauses.push(`status="${status}"`);
+  for (const status of statusNeq)
+    clauses.push(`status!="${status}"`);
+  return clauses.join(" AND ");
+}
+
+// src/cli.ts
+function emptyList(text) {
+  return /no result found/i.test(text);
+}
+function createStoreCli(store) {
+  return {
+    async list(flags) {
+      const issues = store.list(flagsToJql(flags || DEFAULT_FLAGS));
+      return JSON.stringify(issues, null, 2);
+    },
+    async listEpics() {
+      const issues = store.list(flagsToJql("-tEpic"));
+      return JSON.stringify(issues, null, 2);
+    },
+    async listEpic(key) {
+      const issues = store.list(`project="DEMO" AND parent="${key}"`);
+      return JSON.stringify(issues, null, 2);
+    },
+    async move(key, status) {
+      return store.move(key, status);
+    },
+    async open(key) {
+      return `/browse/${key}`;
+    }
+  };
+}
+function resolveJiraBin(bin = process.env.JIRA_BIN ?? "jira", pathVar = process.env.PATH ?? "") {
+  if (!bin)
+    return;
+  if (bin.includes("/") || bin.includes("\\")) {
+    const abs = resolve(bin);
+    return existsSync(abs) ? abs : undefined;
+  }
+  for (const dir of pathVar.split(delimiter)) {
+    if (!dir)
+      continue;
+    const candidate = join(dir, bin);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return;
+}
+function createJiraCli(opts = {}) {
+  const bin = opts.bin ?? "jira";
+  function run(args) {
+    return new Promise((resolveRun, reject) => {
+      const env = { ...process.env };
+      if (opts.configPath)
+        env.JIRA_CONFIG_FILE = resolve(opts.configPath);
+      if (opts.token)
+        env.JIRA_API_TOKEN = opts.token;
+      const child = spawn(bin, args, { env });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      child.on("error", reject);
+      child.on("close", (code) => resolveRun({ code: code ?? 1, stdout, stderr }));
+    });
+  }
+  return {
+    async list(flags) {
+      const extra = (flags || DEFAULT_FLAGS).split(/\s+/).filter(Boolean);
+      const result = await run(["issue", "list", ...extra, "--raw"]);
+      if (result.code !== 0) {
+        const text = result.stderr || result.stdout || "jira issue list failed";
+        if (emptyList(text))
+          return "[]";
+        throw new Error(text);
+      }
+      return result.stdout;
+    },
+    async listEpics() {
+      const result = await run(["issue", "list", "-tEpic", "--raw"]);
+      if (result.code !== 0) {
+        const text = result.stderr || result.stdout || "jira issue list failed";
+        if (emptyList(text))
+          return "[]";
+        throw new Error(text);
+      }
+      return result.stdout;
+    },
+    async listEpic(key) {
+      const result = await run([
+        "issue",
+        "list",
+        "-q",
+        `parent="${key}" OR "Epic Link"="${key}"`,
+        "--raw"
+      ]);
+      if (result.code !== 0) {
+        const text = result.stderr || result.stdout || "jira issue list failed";
+        if (emptyList(text))
+          return "[]";
+        throw new Error(text);
+      }
+      return result.stdout;
+    },
+    async move(key, status) {
+      const result = await run(["issue", "move", key, status]);
+      if (result.code !== 0) {
+        return {
+          ok: false,
+          error: (result.stderr || result.stdout).trim()
+        };
+      }
+      return { ok: true };
+    },
+    async open(key) {
+      const result = await run(["open", key, "--no-browser"]);
+      return result.stdout.trim().split(`
+`).pop() ?? `/browse/${key}`;
+    }
+  };
+}
+
+// src/app.ts
+function createApp(opts) {
+  const cli = opts.cli ?? createStoreCli(opts.store);
+  let flags = DEFAULT_FLAGS;
+  let payload = [];
+  let epicsPayload = [];
+  const app = {
+    get flags() {
+      return flags;
+    },
+    board() {
+      const board = issuesToBoard(payload);
+      return {
+        columns: board.columns,
+        epics: mergeEpics(issuesToBoard(epicsPayload).epics, board.epics)
+      };
+    },
+    hydrate(raw) {
+      payload = Array.isArray(raw) ? raw : [];
+      epicsPayload = [];
+      return app.board();
+    },
+    async refresh(next) {
+      if (next !== undefined)
+        flags = next;
+      const [issues, epics] = await Promise.all([
+        cli.list(flags),
+        cli.listEpics()
+      ]);
+      payload = JSON.parse(issues);
+      epicsPayload = JSON.parse(epics);
+      return app.board();
+    },
+    async children(epic) {
+      const board = issuesToBoard(JSON.parse(await cli.listEpic(epic)));
+      for (const column of board.columns) {
+        for (const card of column.cards) {
+          if (!card.epic)
+            card.epic = epic;
+        }
+      }
+      return board;
+    },
+    async move(key, status) {
+      const current = payload.find((issue) => issue.key === key)?.fields?.status?.name;
+      if (current === status) {
+        return { ok: true, noop: true, board: app.board() };
+      }
+      const result = await cli.move(key, status);
+      if (!result.ok) {
+        return { ok: false, error: result.error, board: app.board() };
+      }
+      await app.refresh();
+      return { ok: true, board: app.board() };
+    },
+    async open(key) {
+      return cli.open(key);
+    }
+  };
+  return app;
+}
+
+// src/store.ts
+var ME = {
+  displayName: "Person A",
+  emailAddress: "user@test.com",
+  name: "user@test.com"
+};
+var TRANSITIONS = [
+  { id: "11", name: "To Do" },
+  { id: "21", name: "In Progress" },
+  { id: "31", name: "Done" }
+];
+var ALLOWED = {
+  "To Do": ["In Progress"],
+  "In Progress": ["To Do", "Done"],
+  Done: ["In Progress"]
+};
+function fieldValue(issue, field) {
+  switch (field) {
+    case "project":
+      return issue.key.split("-")[0] ?? "";
+    case "assignee":
+      return [
+        issue.fields.assignee?.emailAddress,
+        issue.fields.assignee?.displayName
+      ].filter(Boolean).join(`
+`);
+    case "status":
+      return issue.fields.status.name;
+    case "parent":
+      return issue.fields.parent?.key ?? "";
+    case "type": {
+      const named = issue.fields.issuetype ?? issue.fields.issueType;
+      if (named && typeof named === "object" && "name" in named && typeof named.name === "string") {
+        return named.name;
+      }
+      return "";
+    }
+    case "key":
+      return issue.key;
+    default:
+      return "";
+  }
+}
+function matchesClause(issue, clause) {
+  const match = clause.trim().match(/^(\w+)\s*(!=|=)\s*"?([^"]+)"?$/);
+  if (!match)
+    return true;
+  const [, field, op, raw] = match;
+  const expected = raw.trim();
+  const actual = fieldValue(issue, field);
+  const hit = field === "assignee" ? actual.split(`
+`).some((value) => value.toLowerCase() === expected.toLowerCase()) : actual.toLowerCase() === expected.toLowerCase();
+  return op === "!=" ? !hit : hit;
+}
+function matchJql(issue, jql) {
+  const stripped = jql.replace(/\s+ORDER BY\s+.+$/i, "").trim();
+  if (!stripped)
+    return true;
+  return stripped.split(/\s+AND\s+/i).every((clause) => matchesClause(issue, clause));
+}
+
+class IssueStore {
+  issues;
+  constructor(issues) {
+    this.issues = issues;
+  }
+  static fromRaw(raw) {
+    if (!Array.isArray(raw)) {
+      throw new Error("Fixture must be a JSON array");
+    }
+    return new IssueStore(structuredClone(raw));
+  }
+  all() {
+    return this.issues;
+  }
+  rawJson() {
+    return JSON.stringify(this.issues, null, 2);
+  }
+  get(key) {
+    return this.issues.find((issue) => issue.key.toUpperCase() === key.toUpperCase());
+  }
+  list(jql = "") {
+    return this.issues.filter((issue) => matchJql(issue, jql));
+  }
+  transitions(key) {
+    const issue = this.get(key);
+    if (!issue)
+      return [];
+    const allowed = ALLOWED[issue.fields.status.name] ?? [];
+    return TRANSITIONS.map((transition) => ({
+      ...transition,
+      isAvailable: allowed.includes(transition.name)
+    }));
+  }
+  move(key, status) {
+    const issue = this.get(key);
+    if (!issue)
+      return { ok: false, error: `Issue ${key} not found` };
+    const transition = this.transitions(key).find((item) => item.name.toLowerCase() === status.toLowerCase() || item.id === status);
+    if (!transition || !transition.isAvailable) {
+      const available = this.transitions(key).filter((item) => item.isAvailable).map((item) => item.name).join(", ");
+      return {
+        ok: false,
+        error: `invalid transition state "${status}"
+Available states for issue ${key}: ${available}`
+      };
+    }
+    issue.fields.status.name = transition.name;
+    if (transition.name === "Done") {
+      issue.fields.resolution = { name: "Done" };
+    } else {
+      delete issue.fields.resolution;
+    }
+    return { ok: true };
+  }
+}
+
+// src/boot.ts
+async function createBoardApp(opts) {
+  const env = opts.env ?? process.env;
+  const store = IssueStore.fromRaw(opts.raw);
+  const bin = resolveJiraBin(env.JIRA_BIN ?? "jira", env.PATH ?? "");
+  const cli = bin ? createJiraCli({
+    bin,
+    configPath: env.JIRA_CONFIG_FILE,
+    token: env.JIRA_API_TOKEN
+  }) : createStoreCli(store);
+  const app = createApp({ store, cli });
+  if (opts.piped) {
+    app.hydrate(opts.raw);
+  } else {
+    const local = createStoreCli(store);
+    app.hydrate(JSON.parse(await local.list(app.flags)));
+  }
+  return { app, store, kind: bin ? "jira" : "store" };
+}
+async function refreshFromJira(app, kind, opts = {}) {
+  if (kind !== "jira" || opts.piped)
+    return;
+  await app.refresh();
+}
+
+// src/app-api.ts
+function json(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+}
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function pathOf(req) {
+  return new URL(req.url ?? "/", "http://127.0.0.1");
+}
+function handleAppApi(req, res, app) {
+  const url = pathOf(req);
+  const method = (req.method ?? "GET").toUpperCase();
+  if (url.pathname === "/api/board" && method === "GET") {
+    json(res, 200, { ...app.board(), flags: app.flags });
+    return true;
+  }
+  if (url.pathname === "/api/refresh" && method === "POST") {
+    readBody(req).then(async (text) => {
+      const body = text ? JSON.parse(text) : {};
+      const board = await app.refresh(body.flags);
+      json(res, 200, board);
+    });
+    return true;
+  }
+  if (url.pathname === "/api/move" && method === "POST") {
+    readBody(req).then(async (text) => {
+      const body = text ? JSON.parse(text) : {};
+      const result = await app.move(String(body.key ?? ""), String(body.status ?? ""));
+      json(res, result.ok ? 200 : 409, result);
+    });
+    return true;
+  }
+  if (url.pathname === "/api/epic" && method === "POST") {
+    readBody(req).then(async (text) => {
+      const body = text ? JSON.parse(text) : {};
+      json(res, 200, await app.children(String(body.key ?? "")));
+    });
+    return true;
+  }
+  if (url.pathname === "/api/open" && method === "POST") {
+    readBody(req).then(async (text) => {
+      const body = text ? JSON.parse(text) : {};
+      const url2 = await app.open(String(body.key ?? ""));
+      json(res, 200, { url: url2 });
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/fake-jira.ts
+function json2(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+}
+function readBody2(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function pathOf2(req) {
+  return new URL(req.url ?? "/", "http://127.0.0.1");
+}
+function handleFakeJira(req, res, store) {
+  const url = pathOf2(req);
+  const path = url.pathname;
+  const method = (req.method ?? "GET").toUpperCase();
+  if (path === "/rest/api/2/myself" || path === "/rest/api/3/myself") {
+    json2(res, 200, ME);
+    return true;
+  }
+  if ((path === "/rest/api/3/search/jql" || path === "/rest/api/2/search" || path === "/rest/api/3/search") && method === "GET") {
+    const issues = store.list(url.searchParams.get("jql") ?? "");
+    json2(res, 200, { expand: "schema,names", isLast: true, issues });
+    return true;
+  }
+  const transition = path.match(/^\/rest\/api\/[23]\/issue\/([^/]+)\/transitions$/);
+  if (transition) {
+    const key = decodeURIComponent(transition[1]);
+    if (method === "GET") {
+      if (!store.get(key)) {
+        json2(res, 404, { errorMessages: [`Issue ${key} not found`] });
+        return true;
+      }
+      json2(res, 200, {
+        expand: "transitions",
+        transitions: store.transitions(key)
+      });
+      return true;
+    }
+    if (method === "POST") {
+      readBody2(req).then((text) => {
+        const body = text ? JSON.parse(text) : {};
+        const target = body.transition?.name ?? body.transition?.id ?? "";
+        const result = store.move(key, String(target));
+        if (!result.ok) {
+          json2(res, 400, { errorMessages: [result.error] });
+          return;
+        }
+        res.statusCode = 204;
+        res.end();
+      });
+      return true;
+    }
+  }
+  const browse = path.match(/^\/browse\/([^/]+)$/);
+  if (browse && method === "GET") {
+    const key = decodeURIComponent(browse[1]);
+    const issue = store.get(key);
+    res.statusCode = issue ? 200 : 404;
+    res.setHeader("content-type", "text/html; charset=utf-8");
+    const fields = issue?.fields;
+    const type = fields?.issuetype?.name ?? fields?.issueType?.name ?? "Issue";
+    res.end(issue ? `<!doctype html><html><head><meta charset="utf-8"><title>${issue.key}</title>
+<style>
+  :root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, sans-serif; }
+  body { margin: 0; padding: 1.25rem; }
+  .key { font-size: 12px; letter-spacing: .02em; opacity: .7; }
+  h1 { font-size: 1.25rem; margin: .35rem 0 1rem; }
+  dl { display: grid; grid-template-columns: 7rem 1fr; gap: .4rem 1rem; font-size: 14px; }
+  dt { opacity: .65; }
+</style></head><body>
+  <div class="key">${issue.key} · ${type}</div>
+  <h1>${issue.fields.summary}</h1>
+  <dl>
+    <dt>Status</dt><dd>${issue.fields.status.name}</dd>
+    <dt>Assignee</dt><dd>${issue.fields.assignee?.displayName ?? "Unassigned"}</dd>
+    <dt>Priority</dt><dd>${fields?.priority?.name ?? "—"}</dd>
+  </dl>
+</body></html>` : "not found");
+    return true;
+  }
+  return false;
+}
+
+// src/http.ts
+function handleRequest(req, res, ctx) {
+  return handleAppApi(req, res, ctx.app) || handleFakeJira(req, res, ctx.store);
+}
+
+// src/jira-config.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function writeJiraConfig(dir, server) {
+  mkdirSync(dir, { recursive: true });
+  const path = join2(dir, "jira.config.yml");
+  writeFileSync(path, [
+    "installation: Cloud",
+    `server: ${server}`,
+    `login: ${ME.emailAddress}`,
+    "auth_type: basic",
+    "project:",
+    "  key: DEMO",
+    "  type: classic",
+    'board: ""',
+    ""
+  ].join(`
+`));
+  return path;
+}
+
+// src/listen.ts
+function resolveListen(env = process.env) {
+  return {
+    host: env.HOST ?? "127.0.0.1",
+    port: Number(env.PORT ?? 5173)
+  };
+}
+
+// src/ui.ts
+import { createReadStream, existsSync as existsSync2, statSync } from "node:fs";
+import { dirname, extname, join as join3, resolve as resolve2, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var types = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".svg": "image/svg+xml",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function packageRoot(from = import.meta.url) {
+  return resolve2(dirname(fileURLToPath(from)), "..");
+}
+function uiDir(root) {
+  return join3(root, "dist", "ui");
+}
+function inside(root, file) {
+  const base = resolve2(root);
+  const target = resolve2(file);
+  return target === base || target.startsWith(base + sep);
+}
+function sendUi(root, req, res) {
+  const ui = uiDir(root);
+  const index = join3(ui, "index.html");
+  if (!existsSync2(index))
+    return false;
+  const path = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+  const wanted = resolve2(ui, `.${decodeURIComponent(path)}`);
+  const file = inside(ui, wanted) && existsSync2(wanted) && statSync(wanted).isFile() ? wanted : index;
+  res.setHeader("content-type", types[extname(file)] ?? "application/octet-stream");
+  createReadStream(file).pipe(res);
+  return true;
+}
+
+// src/server.ts
+async function readPipe() {
+  if (process.stdin.isTTY)
+    return null;
+  const chunks = [];
+  for await (const chunk of process.stdin)
+    chunks.push(chunk);
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  return text ? JSON.parse(text) : null;
+}
+async function runServer(opts) {
+  const piped = await readPipe();
+  const raw = piped ?? JSON.parse(readFileSync(join4(opts.root, "fixtures/issues.json"), "utf8"));
+  const { app, store, kind } = await createBoardApp({
+    raw,
+    piped: Boolean(piped)
+  });
+  const server = createServer((req, res) => {
+    if (handleRequest(req, res, { app, store }))
+      return;
+    if (opts.fallback) {
+      opts.fallback(req, res);
+      return;
+    }
+    if (!sendUi(opts.root, req, res)) {
+      res.statusCode = 404;
+      res.end("pipe-kan UI is missing. Run bun run build.");
+    }
+  });
+  const { host, port } = resolveListen();
+  await new Promise((resolve3) => server.listen(port, host, resolve3));
+  const origin = `http://127.0.0.1:${port}`;
+  const fakeConfig = writeJiraConfig(join4(tmpdir(), "pipe-kan"), origin);
+  if (kind === "jira") {
+    try {
+      await refreshFromJira(app, kind, { piped: Boolean(piped) });
+    } catch (err) {
+      console.error("jira Refresh failed; keeping Fixture Board");
+      console.error(err);
+    }
+  }
+  console.log(`pipe-kan http://${host}:${port}`);
+  console.log(`cli ${kind === "jira" ? resolveJiraBin() : "store"}`);
+  console.log(`Fake Jira ${origin}/rest/api/2/search`);
+  console.log(`Fake Jira config ${fakeConfig}`);
+}
+
+// src/bin.ts
+runServer({ root: packageRoot() }).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});