zdashboard 1.0.0

package/dist/cli.js

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+
+// src/server/index.ts
+import http from "http";
+import fs4 from "fs";
+import path4 from "path";
+import crypto from "crypto";
+import { exec } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/server/spec-scan.ts
+import fs from "fs";
+import path from "path";
+function walkFiles(absDir, relDir, depth = 0) {
+  if (depth > 4) return [];
+  let ents;
+  try {
+    ents = fs.readdirSync(absDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const nodes = [];
+  for (const ent of ents) {
+    if (ent.name.startsWith(".") || ent.name === "node_modules") continue;
+    const rel = relDir ? `${relDir}/${ent.name}` : ent.name;
+    if (ent.isDirectory()) {
+      nodes.push({ name: ent.name, kind: "dir", children: walkFiles(path.join(absDir, ent.name), rel, depth + 1) });
+    } else {
+      nodes.push({ name: ent.name, kind: "file", path: rel });
+    }
+  }
+  nodes.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1);
+  return nodes;
+}
+function scanTree(root2, hasOpenspec, hasDocs) {
+  const tree = [];
+  if (hasOpenspec && fs.existsSync(path.join(root2, "openspec", "changes"))) {
+    const changesDir = path.join(root2, "openspec", "changes");
+    const active = [];
+    const archived = [];
+    for (const ent of fs.readdirSync(changesDir, { withFileTypes: true })) {
+      if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
+      active.push({ name: ent.name, kind: "dir", children: walkFiles(path.join(changesDir, ent.name), `openspec/changes/${ent.name}`) });
+    }
+    active.sort((a, b) => a.name.localeCompare(b.name));
+    const archiveDir = path.join(changesDir, "archive");
+    if (fs.existsSync(archiveDir)) {
+      for (const ent of fs.readdirSync(archiveDir, { withFileTypes: true })) {
+        if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+        archived.push({ name: ent.name, kind: "dir", children: walkFiles(path.join(archiveDir, ent.name), `openspec/changes/archive/${ent.name}`) });
+      }
+      archived.sort((a, b) => b.name.localeCompare(a.name));
+    }
+    if (active.length) tree.push({ name: `\u8FDB\u884C\u4E2D (${active.length})`, kind: "dir", children: active });
+    if (archived.length) tree.push({ name: `\u5F52\u6863 (${archived.length})`, kind: "dir", defaultCollapsed: true, children: archived });
+    const specsDir = path.join(root2, "openspec", "specs");
+    if (fs.existsSync(specsDir)) {
+      const specs = walkFiles(specsDir, "openspec/specs");
+      if (specs.length) tree.push({ name: "\u80FD\u529B Specs", kind: "dir", children: specs });
+    }
+  }
+  if (hasDocs && fs.existsSync(path.join(root2, "docs"))) {
+    const docs = walkFiles(path.join(root2, "docs"), "docs");
+    if (docs.length) tree.push({ name: "docs", kind: "dir", children: docs });
+  }
+  const skip = /* @__PURE__ */ new Set(["openspec", "docs", "node_modules", ".git", "dist", "test-server"]);
+  const etc = [];
+  try {
+    for (const ent of fs.readdirSync(root2, { withFileTypes: true })) {
+      if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
+      const ext = path.extname(ent.name).toLowerCase();
+      if (ent.isFile() && (ext === ".md" || ext === ".markdown")) etc.push({ name: ent.name, kind: "file", path: ent.name });
+    }
+  } catch {
+  }
+  etc.sort((a, b) => a.name.localeCompare(b.name));
+  if (etc.length) tree.push({ name: `\u5176\u4ED6 (${etc.length})`, kind: "dir", children: etc });
+  return tree;
+}
+
+// src/server/just-runner.ts
+import { spawn, execFile } from "child_process";
+var MAX_BUFFER = 1e3;
+var JustRunner = class {
+  cwd;
+  child = null;
+  recipe = null;
+  state = "idle";
+  code = null;
+  buffer = [];
+  pending = "";
+  // 行缓冲:块缓冲输出(如 maven)的 chunk 会在行中间断开,攒到 \n 才切行
+  clients = /* @__PURE__ */ new Set();
+  recipesCache = null;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  recipes() {
+    if (this.recipesCache) return Promise.resolve(this.recipesCache);
+    return new Promise((resolve) => {
+      execFile("just", ["--list", "--unsorted"], { cwd: this.cwd, maxBuffer: 1 << 20, timeout: 8e3 }, (err, stdout) => {
+        if (err) {
+          resolve([]);
+          return;
+        }
+        const out = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const line of stdout.split(/\r?\n/).slice(1)) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          const hashIdx = trimmed.indexOf("#");
+          const sig = (hashIdx >= 0 ? trimmed.slice(0, hashIdx) : trimmed).trim();
+          if (!sig) continue;
+          const name = sig.split(/\s+/)[0];
+          if (seen.has(name)) continue;
+          seen.add(name);
+          out.push({ name, description: hashIdx >= 0 ? trimmed.slice(hashIdx + 1).trim() : "" });
+        }
+        this.recipesCache = out;
+        resolve(out);
+      });
+    });
+  }
+  subscribe(fn) {
+    this.clients.add(fn);
+    for (const text of this.buffer) fn({ type: "log", text });
+    fn({ type: "state", state: this.state, recipe: this.recipe, code: this.code });
+    return () => this.clients.delete(fn);
+  }
+  emit(ev) {
+    for (const fn of this.clients) fn(ev);
+  }
+  info() {
+    return { state: this.state, recipe: this.recipe, code: this.code };
+  }
+  /** 启动 recipe(调用方须先用 recipes() 校验名字);自动停旧进程 */
+  start(recipe) {
+    this.killChild();
+    this.recipe = recipe;
+    this.code = null;
+    this.state = "running";
+    this.buffer = [];
+    this.pending = "";
+    this.emit({ type: "clear" });
+    this.emit({ type: "state", state: "running", recipe, code: null });
+    const child = spawn("just", [recipe], {
+      cwd: this.cwd,
+      shell: true,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+        // node 生态(chalk 等)
+        // maven 检测非 tty 会关颜色;经 MAVEN_OPTS 强制开(保留用户已有值)
+        MAVEN_OPTS: `${process.env.MAVEN_OPTS ?? ""} -Dstyle.color=always`.trim(),
+        CI: ""
+      }
+    });
+    this.child = child;
+    const push = (d) => {
+      this.pending += d.toString();
+      let idx;
+      while ((idx = this.pending.indexOf("\n")) >= 0) {
+        const line = this.pending.slice(0, idx + 1);
+        this.pending = this.pending.slice(idx + 1);
+        this.pushLine(line);
+      }
+    };
+    child.stdout?.on("data", push);
+    child.stderr?.on("data", push);
+    child.on("error", (err) => {
+      this.pushLine(`[zview] spawn error: ${err.message}
+`);
+    });
+    child.on("exit", (code) => {
+      if (this.pending) {
+        this.pushLine(this.pending + "\n");
+        this.pending = "";
+      }
+      this.child = null;
+      this.state = "exited";
+      this.code = code ?? 0;
+      this.emit({ type: "state", state: "exited", recipe: this.recipe, code: this.code });
+    });
+  }
+  pushLine(line) {
+    this.buffer.push(line);
+    if (this.buffer.length > MAX_BUFFER) this.buffer.shift();
+    this.emit({ type: "log", text: line });
+  }
+  stop() {
+    this.killChild();
+  }
+  restart(recipe) {
+    const target = recipe ?? this.recipe;
+    if (target) this.start(target);
+  }
+  killChild() {
+    const child = this.child;
+    if (child?.pid) {
+      try {
+        if (process.platform === "win32") spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"]);
+        else child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    this.child = null;
+  }
+};
+
+// src/server/bugs.ts
+import fs2 from "fs";
+import path2 from "path";
+function loadZgoalConfig(root2) {
+  const file = path2.join(root2, ".zgoal", "config.yaml");
+  if (!fs2.existsSync(file)) return null;
+  const kv = {};
+  for (const line of fs2.readFileSync(file, "utf8").split("\n")) {
+    const m = line.match(/^\s*([A-Za-z_]\w*)\s*:\s*(.+?)\s*$/);
+    if (m && !m[2].startsWith("#")) kv[m[1]] = m[2].replace(/^["']|["']$/g, "");
+  }
+  const product = Number(kv.product);
+  if (!kv.url || !product) return null;
+  return {
+    url: kv.url.replace(/\/+$/, ""),
+    account: kv.account ?? "",
+    password: kv.password,
+    token: kv.token,
+    product
+  };
+}
+async function fetchJson(url, init) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 8e3);
+  try {
+    const res = await fetch(url, { ...init, signal: ctrl.signal });
+    const text = await res.text();
+    let json = {};
+    try {
+      json = JSON.parse(text);
+    } catch {
+    }
+    if (!res.ok) {
+      const err = json.error;
+      throw new Error(`HTTP ${res.status}${typeof err === "string" ? `: ${err}` : ""}`);
+    }
+    return json;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var tokenCache = null;
+async function getToken(cfg) {
+  if (cfg.token) return cfg.token;
+  const key = `${cfg.url}|${cfg.account}|${cfg.password ?? ""}`;
+  if (tokenCache && tokenCache.key === key && Date.now() - tokenCache.at < 10 * 6e4) return tokenCache.token;
+  const json = await fetchJson(`${cfg.url}/api.php/v1/tokens`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ account: cfg.account, password: cfg.password })
+  });
+  const token = typeof json.token === "string" ? json.token : "";
+  if (!token) throw new Error("token \u83B7\u53D6\u5931\u8D25:\u68C0\u67E5 account / password");
+  tokenCache = { key, token, at: Date.now() };
+  return token;
+}
+function normBug(b, account) {
+  const assigned = b.assignedTo;
+  const assignedTo = typeof assigned === "string" ? assigned : assigned && typeof assigned === "object" && "realname" in assigned ? String(assigned.realname ?? "") : "";
+  const assignedAccount = typeof assigned === "string" ? assigned : assigned && typeof assigned === "object" ? String(assigned.account ?? "") : "";
+  const mine = !!account && (assignedAccount === account || assignedTo === account);
+  return {
+    id: Number(b.id),
+    title: String(b.title ?? ""),
+    severity: b.severity ?? 4,
+    pri: b.pri ?? 3,
+    status: String(b.status ?? ""),
+    assignedTo,
+    openedBy: typeof b.openedBy === "string" ? b.openedBy : void 0,
+    mine
+  };
+}
+async function fetchBugs(root2) {
+  const cfg = loadZgoalConfig(root2);
+  if (!cfg) return { ok: false, error: ".zgoal/config.yaml \u7F3A\u5931\u6216 url/product \u672A\u914D\u7F6E(\u7531 zgoal skill \u521B\u5EFA)" };
+  try {
+    const token = await getToken(cfg);
+    const json = await fetchJson(
+      `${cfg.url}/api.php/v1/products/${cfg.product}/bugs?page=1&limit=100`,
+      { headers: { Token: token } }
+    );
+    const raw = Array.isArray(json.bugs) ? json.bugs : [];
+    return { ok: true, url: cfg.url, total: Number(json.total ?? raw.length), bugs: raw.map((b) => normBug(b, cfg.account)) };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: `\u7985\u9053\u8BF7\u6C42\u5931\u8D25(${msg})\u2014\u2014\u68C0\u67E5 url / \u51ED\u636E / \u662F\u5426\u5F00\u542F RESTful API v1` };
+  }
+}
+
+// src/server/plugins.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var builtinPlugins = /* @__PURE__ */ new Map();
+function registerBuiltin(plugin) {
+  builtinPlugins.set(plugin.mode, plugin);
+}
+function allBuiltins() {
+  return Array.from(builtinPlugins.values());
+}
+
+// package.json
+var package_default = {
+  name: "zdashboard",
+  version: "1.0.0",
+  description: "ZCode skill dashboard platform \u2014 pluggable viewers for zdesign/zview/zreview/zgoal",
+  type: "module",
+  bin: { zdashboard: "./dist/cli.js" },
+  files: ["dist"],
+  publishConfig: { access: "public" },
+  scripts: {
+    dev: "vite",
+    build: "tsup && vite build",
+    "build:web": "vite build",
+    "build:node": "tsup",
+    start: "node dist/cli.js",
+    preview: "vite preview"
+  },
+  dependencies: {
+    "@radix-ui/react-scroll-area": "^1.2.0",
+    "@radix-ui/react-separator": "^1.1.0",
+    "@radix-ui/react-slot": "^1.1.0",
+    "@radix-ui/react-tooltip": "^1.1.2",
+    "ansi-to-react": "^6.1.6",
+    "class-variance-authority": "^0.7.0",
+    clsx: "^2.1.1",
+    "highlight.js": "^11.11.1",
+    katex: "^0.16.11",
+    "lucide-react": "^0.460.0",
+    react: "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-markdown": "^9.0.1",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-math": "^6.0.0",
+    "rehype-autolink-headings": "^7.1.0",
+    "rehype-highlight": "^7.0.1",
+    "rehype-katex": "^7.0.1",
+    "rehype-raw": "^7.0.0",
+    "rehype-slug": "^6.0.0",
+    "tailwind-merge": "^2.5.4"
+  },
+  devDependencies: {
+    "@tailwindcss/typography": "^0.5.20",
+    "@types/node": "^22.9.0",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    typescript: "^5.6.3",
+    vite: "^5.4.10",
+    "@vitejs/plugin-react": "^4.3.3",
+    tailwindcss: "^3.4.14",
+    "tailwindcss-animate": "^1.0.7",
+    postcss: "^8.4.49",
+    autoprefixer: "^10.4.20",
+    tsup: "^8.3.5"
+  },
+  pnpm: {
+    onlyBuiltDependencies: ["esbuild"]
+  }
+};
+
+// src/server/index.ts
+var VERSION = package_default.version;
+var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var STOP_TOKEN = crypto.randomBytes(12).toString("hex");
+var INJECT = `<script>(function(){try{var es=new EventSource('/__reload');es.addEventListener('reload',function(){location.reload();});es.onerror=function(){es.close();};}catch(e){}document.addEventListener('click',function(e){var t=e.target;if(t&&t.closest){var a=t.closest('a[target]');if(a&&a.target!=='_self'){a.target='_self';}}},true);})();</script>`;
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".md": "text/markdown; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".yml": "text/yaml; charset=utf-8",
+  ".yaml": "text/yaml; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8"
+};
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (c) => data += c);
+    req.on("end", () => resolve(data));
+  });
+}
+function createServer(opts) {
+  const ROOT = path4.resolve(opts.root);
+  const PORT0 = opts.port ?? 4190;
+  const OPEN = !!opts.open;
+  const APP_DIR = opts.dashboardDir ?? path4.resolve(__dirname2, "web");
+  if (!fs4.existsSync(ROOT)) fs4.mkdirSync(ROOT, { recursive: true });
+  const det2 = opts.detect;
+  const runner = new JustRunner(ROOT);
+  const MODE = opts.mode;
+  registerBuiltin({
+    mode: "bugs",
+    label: "\u7985\u9053 Bugs",
+    icon: "\u{1F3AF}",
+    apiRoutes: { "/__bugs": async (_, res) => {
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+      fetchBugs(ROOT).then((r) => res.end(JSON.stringify(r)));
+    } }
+  });
+  registerBuiltin({ mode: "view", label: "\u9879\u76EE\u6D4F\u89C8", icon: "\u{1F441}\uFE0F" });
+  registerBuiltin({ mode: "review", label: "\u6587\u6863\u8BC4\u5BA1", icon: "\u2705" });
+  const clients = /* @__PURE__ */ new Set();
+  const broadcast = (ev, data = "") => {
+    const payload = `event: ${ev}
+data: ${JSON.stringify(data == null ? "" : data)}
+
+`;
+    for (const c of clients) c.write(payload);
+  };
+  function serveFile(filePath, res, injectHtml) {
+    fs4.readFile(filePath, (err, data) => {
+      if (err) {
+        res.writeHead(404);
+        return res.end("Not found");
+      }
+      const ext = path4.extname(filePath).toLowerCase();
+      const ct = MIME[ext] ?? "application/octet-stream";
+      let body = data;
+      if (injectHtml && ext === ".html") {
+        const s = data.toString("utf8");
+        body = Buffer.from(s.indexOf("</body>") >= 0 ? s.replace("</body>", INJECT + "</body>") : s + INJECT);
+      }
+      res.writeHead(200, { "Content-Type": ct, "Cache-Control": "no-cache" });
+      res.end(body);
+    });
+  }
+  function handler(req, res) {
+    const url = req.url.split("?")[0];
+    if (url === "/__reload") {
+      res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+      res.write(": connected\n\n");
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    if (url === "/__config") {
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+      return res.end(JSON.stringify({ stopToken: STOP_TOKEN }));
+    }
+    if (url === "/__stop" && req.method === "POST") {
+      if (req.headers["x-stop-token"] === STOP_TOKEN) {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end('{"ok":true}');
+        runner.stop();
+        setTimeout(() => {
+          try {
+            server.close();
+          } catch {
+          }
+          process.exit(0);
+        }, 50);
+      } else {
+        res.writeHead(403);
+        res.end("forbidden");
+      }
+      return;
+    }
+    if (url === "/__files") {
+      const tree = scanTree(ROOT, det2.hasOpenspec, det2.hasDocs);
+      const payload = { tree, ...det2 };
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+      return res.end(JSON.stringify(payload));
+    }
+    if (url === "/__just/recipes") {
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+      runner.recipes().then((r) => res.end(JSON.stringify(r)));
+      return;
+    }
+    if (url === "/__just/logs") {
+      res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+      res.write(": connected\n\n");
+      const unsub = runner.subscribe((ev) => res.write(`data: ${JSON.stringify(ev)}
+
+`));
+      req.on("close", unsub);
+      return;
+    }
+    const justAction = url.match(/^\/__just\/(start|stop|restart)$/);
+    if (justAction && req.method === "POST") {
+      (async () => {
+        if (req.headers["x-stop-token"] !== STOP_TOKEN) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        const body = await readBody(req);
+        let recipe;
+        try {
+          recipe = JSON.parse(body || "{}").recipe;
+        } catch {
+        }
+        const act = justAction[1];
+        if (act === "start" || act === "restart") {
+          const target = recipe ?? runner.info().recipe;
+          if (!target) {
+            res.writeHead(400);
+            res.end('{"error":"no recipe"}');
+            return;
+          }
+          const recipes = await runner.recipes();
+          if (!recipes.some((r) => r.name === target)) {
+            res.writeHead(403);
+            res.end('{"error":"unknown recipe"}');
+            return;
+          }
+          runner.start(target);
+        } else {
+          runner.stop();
+        }
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(runner.info()));
+      })();
+      return;
+    }
+    let handled = false;
+    for (const plugin of allBuiltins()) {
+      if (!plugin.apiRoutes) continue;
+      for (const [route, handler2] of Object.entries(plugin.apiRoutes)) {
+        if (url === route) {
+          handled = true;
+          handler2(req, res, ROOT);
+          return;
+        }
+      }
+    }
+    if (url === "/") return serveFile(path4.join(APP_DIR, "index.html"), res, false);
+    if (url.indexOf("/__app/") === 0) {
+      const fp2 = path4.join(APP_DIR, url.slice(7));
+      if (fp2 !== APP_DIR && fp2.indexOf(APP_DIR + path4.sep) !== 0) {
+        res.writeHead(403);
+        return res.end("Forbidden");
+      }
+      return serveFile(fp2, res, false);
+    }
+    if (url.indexOf("/assets/") === 0) {
+      const fp2 = path4.join(APP_DIR, decodeURIComponent(url));
+      if (fp2.indexOf(APP_DIR + path4.sep) !== 0) {
+        res.writeHead(403);
+        return res.end("Forbidden");
+      }
+      return serveFile(fp2, res, false);
+    }
+    const fp = path4.join(ROOT, decodeURIComponent(url));
+    if (fp !== ROOT && fp.indexOf(ROOT + path4.sep) !== 0) {
+      res.writeHead(403);
+      return res.end("Forbidden");
+    }
+    return serveFile(fp, res, true);
+  }
+  let server;
+  function start(port) {
+    server = http.createServer(handler);
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.log(`[zdashboard] port ${port} busy, trying ${port + 1}`);
+        start(port + 1);
+      } else throw err;
+    });
+    server.listen(port, () => {
+      const u = `http://localhost:${port}`;
+      console.log(`[zdashboard] v${VERSION} dashboard -> ${u}`);
+      console.log(`[zdashboard] project   -> ${ROOT}`);
+      console.log(`[zdashboard] mode      -> ${MODE ?? "(auto)"}`);
+      console.log(`[zdashboard] detect    -> openspec:${det2.hasOpenspec} docs:${det2.hasDocs} just:${det2.hasJust} bugs:${det2.hasBugs}`);
+      if (OPEN) exec(process.platform === "darwin" ? `open ${u}` : `start ${u}`);
+    });
+  }
+  let debounce;
+  try {
+    fs4.watch(ROOT, { recursive: true }, () => {
+      clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        broadcast("reload");
+        broadcast("files");
+        console.log(`[zdashboard] change -> reload + refresh tree (${clients.size} client${clients.size === 1 ? "" : "s"})`);
+      }, 150);
+    });
+  } catch {
+    console.log("[zdashboard] watch unavailable - static only.");
+  }
+  start(PORT0);
+}
+
+// src/server/detect.ts
+import fs5 from "fs";
+import path5 from "path";
+import { execFile as execFile2 } from "child_process";
+function justAvailable(cwd) {
+  return new Promise((resolve) => {
+    const child = execFile2("just", ["--list", "--unsorted"], { cwd, timeout: 5e3 }, (err) => {
+      resolve(!err);
+    });
+    if (child.killed) resolve(false);
+  });
+}
+async function detect(root2) {
+  const hasOpenspec = fs5.existsSync(path5.join(root2, "openspec"));
+  const hasDocs = fs5.existsSync(path5.join(root2, "docs"));
+  const hasJust = await justAvailable(root2);
+  const hasBugs = fs5.existsSync(path5.join(root2, ".zgoal", "config.yaml"));
+  return { hasOpenspec, hasDocs, hasJust, hasBugs };
+}
+
+// src/cli.ts
+function parseArgs(a) {
+  const o = {};
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].indexOf("--") === 0) {
+      const n = a[i + 1];
+      o[a[i].slice(2)] = n && n.indexOf("--") !== 0 ? a[++i] : true;
+    }
+  }
+  return o;
+}
+var args = parseArgs(process.argv.slice(2));
+var root = args.dir ?? ".";
+var det = await detect(root);
+createServer({
+  root,
+  port: args.port ? parseInt(args.port, 10) : void 0,
+  open: !!args.open,
+  detect: det,
+  mode: args.mode
+});
+//# sourceMappingURL=cli.js.map