zdashboard 1.6.2 → 2.1.0

package/dist/cli.js

@@ -1,266 +1,943 @@
 #!/usr/bin/env node
 
-// src/server/index.ts
-import http from "http";
-import fs6 from "fs";
-import path6 from "path";
-import crypto from "crypto";
-import { exec } from "child_process";
+// src/cli.ts
+import path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { access, readdir } from "fs/promises";
 
-// src/server/spec-scan.ts
+// src/server/detect.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 });
-    }
+import { execFile } from "child_process";
+function justAvailable(cwd) {
+  return new Promise((resolve) => {
+    const child = execFile("just", ["--list", "--unsorted"], { cwd, timeout: 5e3 }, (err) => {
+      resolve(!err);
+    });
+    if (child.killed) resolve(false);
+  });
+}
+async function detect(root) {
+  const hasOpenspec = fs.existsSync(path.join(root, "openspec"));
+  const hasDocs = fs.existsSync(path.join(root, "docs"));
+  const hasJust = await justAvailable(root);
+  const hasBugs = fs.existsSync(path.join(root, ".zgoal", "config.yaml"));
+  return { hasOpenspec, hasDocs, hasJust, hasBugs };
+}
+
+// src/cli.ts
+import { Context } from "cordis";
+
+// src/core/server.ts
+import http from "http";
+import fs3 from "fs";
+import path3 from "path";
+import crypto from "crypto";
+import { fileURLToPath } from "url";
+
+// package.json
+var package_default = {
+  name: "zdashboard",
+  version: "2.1.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",
+    "@uidotdev/usehooks": "^2.4.0",
+    "ansi-to-react": "^6.1.6",
+    "class-variance-authority": "^0.7.0",
+    clsx: "^2.1.1",
+    cordis: "4.0.0-rc.8",
+    cosmokit: "^1.8.1",
+    "date-fns": "^3.6.0",
+    filesize: "^11.0.0",
+    "highlight.js": "^11.11.1",
+    katex: "^0.16.11",
+    ky: "^1.7.0",
+    "lodash-es": "^4.17.21",
+    "lucide-react": "^0.460.0",
+    react: "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-error-boundary": "^5.0.0",
+    "react-markdown": "^9.0.1",
+    "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",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-math": "^6.0.0",
+    sonner: "^1.5.0",
+    "tailwind-merge": "^2.5.4",
+    tsx: "^4.7.0",
+    "use-debounce": "^10.0.0",
+    yaml: "^2.9.0"
+  },
+  devDependencies: {
+    "@tailwindcss/typography": "^0.5.20",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.9.0",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.7.0",
+    autoprefixer: "^10.4.20",
+    jsdom: "^30.0.1",
+    postcss: "^8.4.49",
+    tailwindcss: "^3.4.14",
+    "tailwindcss-animate": "^1.0.7",
+    tsup: "^8.3.5",
+    typescript: "^5.6.3",
+    vite: "^5.4.10",
+    vitest: "^1.6.0"
+  },
+  pnpm: {
+    onlyBuiltDependencies: [
+      "esbuild"
+    ]
   }
-  nodes.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1);
-  return nodes;
+};
+
+// src/core/server.ts
+import { Service } from "cordis";
+
+// src/core/instance.ts
+import fs2 from "fs";
+import path2 from "path";
+var RECORD_FILE = ".zdev/dashboard.json";
+var VERIFY_TIMEOUT_MS = 1500;
+var STOP_POLL_MS = 2e3;
+var STOP_POLL_INTERVAL_MS = 100;
+var STOP_FINAL_WAIT_MS = 100;
+function recordPath(root) {
+  return path2.join(root, RECORD_FILE);
 }
-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: "archive", 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: "specs", kind: "dir", children: specs });
+function readRecord(root) {
+  try {
+    const fp = recordPath(root);
+    const raw = fs2.readFileSync(fp, "utf-8");
+    const rec = JSON.parse(raw);
+    if (typeof rec.pid === "number" && typeof rec.port === "number" && typeof rec.root === "string" && typeof rec.startedAt === "string") {
+      return rec;
     }
+    return null;
+  } catch {
+    return null;
   }
-  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 });
+}
+function writeRecord(root, port) {
+  fs2.mkdirSync(path2.dirname(recordPath(root)), { recursive: true });
+  const rec = {
+    pid: process.pid,
+    port,
+    root,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs2.writeFileSync(recordPath(root), JSON.stringify(rec, null, 2) + "\n");
+}
+function clearRecord(root) {
+  try {
+    const rec = readRecord(root);
+    if (rec && rec.pid !== process.pid) return;
+    fs2.unlinkSync(recordPath(root));
+  } catch {
   }
-  const skip = /* @__PURE__ */ new Set(["openspec", "docs", "node_modules", ".git", "dist", "test-server"]);
-  const etc = [];
+}
+function isAlive(pid) {
   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 });
-    }
+    process.kill(pid, 0);
+    return true;
   } catch (e) {
-    console.error("[zdashboard] scan root etc failed:", e);
+    if (e.code === "ESRCH") return false;
+    return true;
   }
-  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;
+async function fetchWithTimeout(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), VERIFY_TIMEOUT_MS);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
   }
-  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);
-      });
-    });
+}
+async function verifyRoot(port, root) {
+  try {
+    const res = await fetchWithTimeout(`http://127.0.0.1:${port}/__config`);
+    if (res.status !== 200) return false;
+    const body = await res.json();
+    if (typeof body.root !== "string") return false;
+    return body.root === root;
+  } catch {
+    return false;
   }
-  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);
+}
+async function findReusable(root) {
+  const rec = readRecord(root);
+  if (!rec) return null;
+  if (!isAlive(rec.pid)) return null;
+  if (!await verifyRoot(rec.port, root)) return null;
+  return rec;
+}
+async function stopInstance(record) {
+  try {
+    process.kill(record.pid, "SIGTERM");
+  } catch {
+    return;
   }
-  emit(ev) {
-    for (const fn of this.clients) fn(ev);
+  const deadline = Date.now() + STOP_POLL_MS;
+  while (Date.now() < deadline) {
+    if (!isAlive(record.pid)) return;
+    await new Promise((r) => setTimeout(r, STOP_POLL_INTERVAL_MS));
   }
-  info() {
-    return { state: this.state, recipe: this.recipe, code: this.code };
+  try {
+    process.kill(record.pid, "SIGKILL");
+  } catch {
   }
-  /** 启动 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(`[zdashboard] spawn error: ${err.message}
-`);
-    });
-    child.on("exit", (code) => {
-      if (this.pending) {
-        this.pushLine(this.pending + "\n");
-        this.pending = "";
+  await new Promise((r) => setTimeout(r, STOP_FINAL_WAIT_MS));
+}
+
+// src/core/open-url.ts
+import { exec } from "child_process";
+function openUrl2(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${url}`);
+}
+
+// src/core/server.ts
+var VERSION = package_default.version;
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+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",
+  ".sql": "text/plain; charset=utf-8",
+  ".csv": "text/plain; charset=utf-8",
+  ".tsv": "text/plain; charset=utf-8",
+  ".yaml": "text/yaml; charset=utf-8",
+  ".yml": "text/yaml; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".py": "text/plain; charset=utf-8",
+  ".ts": "text/plain; charset=utf-8",
+  ".java": "text/plain; charset=utf-8",
+  ".go": "text/plain; charset=utf-8",
+  ".rs": "text/plain; charset=utf-8",
+  ".rb": "text/plain; charset=utf-8",
+  ".php": "text/plain; charset=utf-8",
+  ".c": "text/plain; charset=utf-8",
+  ".cpp": "text/plain; charset=utf-8",
+  ".h": "text/plain; charset=utf-8",
+  ".cs": "text/plain; charset=utf-8",
+  ".swift": "text/plain; charset=utf-8",
+  ".kt": "text/plain; charset=utf-8",
+  ".scala": "text/plain; charset=utf-8",
+  ".sh": "text/plain; charset=utf-8",
+  ".bash": "text/plain; charset=utf-8",
+  ".zsh": "text/plain; charset=utf-8",
+  ".fish": "text/plain; charset=utf-8",
+  ".env": "text/plain; charset=utf-8",
+  ".gitignore": "text/plain; charset=utf-8",
+  ".dockerfile": "text/plain; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/woff",
+  ".map": "application/json; charset=utf-8"
+};
+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 PLUGIN_STATIC_PREFIX = "/__plugin/";
+var ServerService = class extends Service {
+  stopToken;
+  root;
+  appDir;
+  open;
+  page;
+  det;
+  routes = /* @__PURE__ */ new Map();
+  sses = /* @__PURE__ */ new Map();
+  prefixStatic = /* @__PURE__ */ new Map();
+  server;
+  onListen;
+  constructor(ctx, config) {
+    super(ctx, "server");
+    this.stopToken = crypto.randomBytes(12).toString("hex");
+    this.root = config.root;
+    this.appDir = config.appDir;
+    this.open = config.open;
+    this.page = config.page;
+    this.det = config.detect;
+    this.onListen = config.onListen;
+    ctx.effect(() => () => this.dispose());
+    this.route("/__config", (_req, res) => {
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+      res.end(JSON.stringify({ stopToken: this.stopToken, version: VERSION, root: this.root }));
+    });
+    this.route("/__stop", async (req, res) => {
+      if (req.headers["x-stop-token"] !== this.stopToken) {
+        res.writeHead(403);
+        res.end("forbidden");
+        return;
       }
-      this.child = null;
-      this.state = "exited";
-      this.code = code ?? 0;
-      this.emit({ type: "state", state: "exited", recipe: this.recipe, code: this.code });
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+      res.end('{"ok":true}');
+      this.stop();
     });
+    this.start(config.port);
   }
-  pushLine(line) {
-    this.buffer.push(line);
-    if (this.buffer.length > MAX_BUFFER) this.buffer.shift();
-    this.emit({ type: "log", text: line });
+  route(path11, handler) {
+    this.routes.set(path11, handler);
+    this.ctx.effect(() => () => this.routes.delete(path11));
   }
-  stop() {
-    this.killChild();
+  sse(path11, onConnect) {
+    this.sses.set(path11, onConnect);
+    this.ctx.effect(() => () => this.sses.delete(path11));
   }
-  restart(recipe) {
-    const target = recipe ?? this.recipe;
-    if (target) this.start(target);
+  static(prefix, dir) {
+    this.prefixStatic.set(prefix, dir);
+    this.ctx.effect(() => () => this.prefixStatic.delete(prefix));
   }
-  killChild() {
-    const child = this.child;
-    if (child?.pid) {
+  serveFile(filePath, res, injectHtml) {
+    fs3.readFile(filePath, (err, data) => {
+      if (err) {
+        res.writeHead(404);
+        return res.end("Not found");
+      }
+      const ext = path3.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);
+    });
+  }
+  servePrefix(url, res) {
+    for (const [prefix, dir] of this.prefixStatic) {
+      if (url.indexOf(prefix) === 0) {
+        let rel = this.safeDecode(url.slice(prefix.length));
+        if (!rel || rel === "/" || !path3.extname(rel)) rel = path3.join(rel || "", "index.html");
+        const fp = path3.join(dir, rel);
+        if (fp.indexOf(dir + path3.sep) !== 0) {
+          res.writeHead(403);
+          return res.end("Forbidden");
+        }
+        this.serveFile(fp, res, true);
+        return true;
+      }
+    }
+    return false;
+  }
+  safeDecode(raw) {
+    try {
+      return decodeURIComponent(raw);
+    } catch {
+      return raw;
+    }
+  }
+  handler = (req, res) => {
+    try {
+      const rawUrl = req.url || "/";
+      const url = rawUrl.split("?")[0];
+      const rh = this.routes.get(url);
+      if (rh) {
+        rh(req, res);
+        return;
+      }
+      const sh = this.sses.get(url);
+      if (sh) {
+        res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+        res.write(": connected\n\n");
+        const cleanup = sh(res);
+        req.on("close", () => {
+          cleanup?.();
+        });
+        return;
+      }
+      if (this.servePrefix(url, res)) return;
+      if (url === "/" || url.indexOf("/__app/") === 0 || url.indexOf("/assets/") === 0) {
+        let fp2 = this.appDir;
+        if (url !== "/") fp2 = path3.join(this.appDir, this.safeDecode(url));
+        if (url.indexOf("/__app/") === 0) fp2 = path3.join(this.appDir, url.slice(7));
+        if (fp2 !== this.appDir && fp2.indexOf(this.appDir + path3.sep) !== 0) {
+          res.writeHead(403);
+          return res.end("Forbidden");
+        }
+        if (url === "/") fp2 = path3.join(this.appDir, "index.html");
+        return this.serveFile(fp2, res, false);
+      }
+      const fp = path3.join(this.root, this.safeDecode(url));
+      if (fp !== this.root && fp.indexOf(this.root + path3.sep) !== 0) {
+        res.writeHead(403);
+        return res.end("Forbidden");
+      }
+      return this.serveFile(fp, res, true);
+    } catch (e) {
       try {
-        if (process.platform === "win32") spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"]);
-        else child.kill("SIGTERM");
+        res.writeHead(400);
+        res.end("bad request");
       } catch {
       }
+      console.error("[zdashboard] handler error", e);
+    }
+  };
+  start(port) {
+    this.server = http.createServer(this.handler);
+    this.server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.log(`[zdashboard] port ${port} busy, trying ${port + 1}`);
+        this.start(port + 1);
+      } else throw err;
+    });
+    this.server.listen(port, "127.0.0.1", () => {
+      const u = `http://localhost:${port}`;
+      const target = this.page ? `${u}#${this.page}` : u;
+      console.log(`[zdashboard] v${VERSION} dashboard -> ${u}`);
+      console.log(`[zdashboard] project   -> ${this.root}`);
+      console.log(`[zdashboard] detect    -> openspec:${this.det.hasOpenspec} docs:${this.det.hasDocs} just:${this.det.hasJust} bugs:${this.det.hasBugs}`);
+      if (this.open) openUrl2(target);
+      this.onListen?.(port);
+    });
+  }
+  stop() {
+    if (this.server) {
+      try {
+        this.server.close();
+      } catch {
+      }
+    }
+    try {
+      clearRecord(this.root);
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        this.ctx.root.fiber.dispose();
+      } catch {
+      }
+      process.exit(0);
+    }, 50);
+  }
+  dispose() {
+    if (this.server) {
+      try {
+        this.server.close();
+      } catch {
+      }
+    }
+    try {
+      clearRecord(this.root);
+    } catch {
     }
-    this.child = null;
   }
 };
 
-// src/server/bugs.ts
-import fs2 from "fs";
-import path2 from "path";
-
-// src/server/api/fetch.ts
-import ky from "ky";
+// src/core/reload.ts
+import fs4 from "fs";
+import { Service as Service2 } from "cordis";
+var WATCH_DEBOUNCE_MS = 150;
+var ReloadService = class extends Service2 {
+  static inject = ["server"];
+  clients = /* @__PURE__ */ new Set();
+  watcher;
+  timer;
+  constructor(ctx, config) {
+    super(ctx, "reload");
+    this.ctx.effect(() => () => this.dispose());
+    this.ctx.server.sse("/__reload", (res) => {
+      this.clients.add(res);
+      return () => this.clients.delete(res);
+    });
+    try {
+      this.watcher = fs4.watch(config.root, { recursive: true }, () => {
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+          this.broadcast("reload");
+          this.broadcast("files");
+        }, WATCH_DEBOUNCE_MS);
+      });
+    } catch {
+    }
+  }
+  broadcast(ev, data = "") {
+    const payload = `event: ${ev}
+data: ${JSON.stringify(data == null ? "" : data)}
 
-// src/server/errors.ts
-var HttpError = class extends Error {
-  constructor(status, message, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "HttpError";
+`;
+    for (const c of this.clients) {
+      try {
+        c.write(payload);
+      } catch {
+      }
+    }
   }
-  status;
-  body;
-};
-var NetworkError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "NetworkError";
+  dispose() {
+    if (this.watcher) {
+      try {
+        this.watcher.close();
+      } catch {
+      }
+    }
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
+    for (const c of this.clients) {
+      try {
+        c.end();
+      } catch {
+      }
+    }
+    this.clients.clear();
   }
-  cause;
 };
 
-// src/server/api/fetch.ts
-async function fetchJson(url, init) {
+// src/server/spec-scan.ts
+import fs5 from "fs";
+import path4 from "path";
+function walkFiles(absDir, relDir, depth = 0) {
+  if (depth > 4) return [];
+  let ents;
   try {
-    const res = await ky(url, { ...init, timeout: 8e3, retry: 2 });
-    return await res.json();
-  } catch (e) {
-    if (e instanceof HttpError) throw e;
-    if (e instanceof Error && e.name === "TimeoutError") {
-      throw new NetworkError(`\u8BF7\u6C42\u8D85\u65F6: ${url}`);
+    ents = fs5.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(path4.join(absDir, ent.name), rel, depth + 1) });
+    } else {
+      nodes.push({ name: ent.name, kind: "file", path: rel });
     }
-    if (e instanceof Error && e.name === "HTTPError") {
-      throw new HttpError(e.status ?? 500, e.message);
+  }
+  nodes.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1);
+  return nodes;
+}
+function scanTree(root, hasOpenspec, hasDocs) {
+  const tree = [];
+  if (hasOpenspec && fs5.existsSync(path4.join(root, "openspec", "changes"))) {
+    const changesDir = path4.join(root, "openspec", "changes");
+    const active = [];
+    const archived = [];
+    for (const ent of fs5.readdirSync(changesDir, { withFileTypes: true })) {
+      if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
+      active.push({ name: ent.name, kind: "dir", children: walkFiles(path4.join(changesDir, ent.name), `openspec/changes/${ent.name}`) });
     }
-    throw new NetworkError(`\u8BF7\u6C42\u5931\u8D25: ${url}`, e);
+    active.sort((a, b) => a.name.localeCompare(b.name));
+    const archiveDir = path4.join(changesDir, "archive");
+    if (fs5.existsSync(archiveDir)) {
+      for (const ent of fs5.readdirSync(archiveDir, { withFileTypes: true })) {
+        if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+        archived.push({ name: ent.name, kind: "dir", children: walkFiles(path4.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: "archive", kind: "dir", defaultCollapsed: true, children: archived });
+    const specsDir = path4.join(root, "openspec", "specs");
+    if (fs5.existsSync(specsDir)) {
+      const specs = walkFiles(specsDir, "openspec/specs");
+      if (specs.length) tree.push({ name: "specs", kind: "dir", children: specs });
+    }
+  }
+  if (hasDocs && fs5.existsSync(path4.join(root, "docs"))) {
+    const docs = walkFiles(path4.join(root, "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 fs5.readdirSync(root, { withFileTypes: true })) {
+      if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
+      const ext = path4.extname(ent.name).toLowerCase();
+      if (ent.isFile() && (ext === ".md" || ext === ".markdown")) etc.push({ name: ent.name, kind: "file", path: ent.name });
+    }
+  } catch (e) {
+    console.error("[zdashboard] scan root etc failed:", e);
   }
+  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/bugs.ts
-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, "");
-  }
+// src/core/tree.ts
+var apply = {
+  inject: ["server"],
+  apply(ctx, config) {
+    let cached = null;
+    const getDet = async () => {
+      if (cached?.v) return cached.v;
+      if (!cached) cached = { p: detect(config.root).catch(() => ({ hasOpenspec: false, hasDocs: false, hasJust: false, hasBugs: false })) };
+      const d = await cached.p;
+      cached.v = d;
+      return d;
+    };
+    const server = ctx.server;
+    if (server?.route) {
+      server.route("/__files", async (_req, res) => {
+        try {
+          const d = await getDet();
+          const tree = scanTree(config.root, d.hasOpenspec, d.hasDocs);
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify({ tree, ...d }));
+        } catch {
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify({ tree: [], hasOpenspec: false, hasDocs: false, hasJust: false, hasBugs: false }));
+        }
+      });
+    }
+  }
+};
+
+// src/core/manifest.ts
+import { Service as Service3 } from "cordis";
+var DashboardService = class extends Service3 {
+  static inject = ["server"];
+  plugins = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    super(ctx, "dashboard");
+    this.ctx.effect(() => () => this.plugins.clear());
+    this.ctx.server.route("/__plugins", (_req, res) => {
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+      res.end(JSON.stringify({ plugins: Array.from(this.plugins.values()) }));
+    });
+  }
+  register(manifest) {
+    this.plugins.set(manifest.mode, manifest);
+    this.ctx.effect(() => () => this.plugins.delete(manifest.mode));
+  }
+  list() {
+    return Array.from(this.plugins.values());
+  }
+  get(mode) {
+    return this.plugins.get(mode);
+  }
+};
+
+// src/server/just-runner.ts
+import { spawn, execFile as execFile2 } 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) => {
+      execFile2("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(`[zdashboard] 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/plugins/just/index.ts
+var apply2 = {
+  inject: ["server", "dashboard"],
+  apply(ctx, config) {
+    const root = config.root;
+    ctx.inject(["server"], () => {
+      if (!ctx.server?.route) return;
+      const runner = new JustRunner(root);
+      ctx.effect(() => () => runner.stop());
+      ctx.server.route("/__just/recipes", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        try {
+          const recipes = await runner.recipes();
+          res.end(JSON.stringify(recipes));
+        } catch {
+          res.end(JSON.stringify([]));
+        }
+      });
+      ctx.server.sse("/__just/logs", (res) => {
+        const unsub = runner.subscribe((ev) => {
+          res.write(`data: ${JSON.stringify(ev)}
+
+`);
+        });
+        return unsub;
+      });
+      ctx.server.route("/__just/start", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        const body = await readBody(req);
+        let recipe;
+        try {
+          recipe = JSON.parse(body || "{}").recipe;
+        } catch {
+        }
+        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);
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(runner.info()));
+      });
+      ctx.server.route("/__just/stop", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        runner.stop();
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(runner.info()));
+      });
+      ctx.server.route("/__just/restart", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        const body = await readBody(req);
+        let recipe;
+        try {
+          recipe = JSON.parse(body || "{}").recipe;
+        } catch {
+        }
+        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.restart(target);
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(runner.info()));
+      });
+      ctx.dashboard.register({ mode: "just", label: "Just Runner", icon: "\u{1F4DC}", description: "Just \u4EFB\u52A1\u65E5\u5FD7\u4E0E\u6267\u884C" });
+    });
+  }
+};
+async function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (c) => {
+      data += c;
+    });
+    req.on("end", () => resolve(data));
+  });
+}
+
+// src/server/bugs.ts
+import fs6 from "fs";
+import path5 from "path";
+
+// src/server/api/fetch.ts
+import ky from "ky";
+
+// src/server/errors.ts
+var HttpError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+  status;
+  body;
+};
+var NetworkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "NetworkError";
+  }
+  cause;
+};
+
+// src/server/api/fetch.ts
+async function fetchJson(url, init) {
+  try {
+    const res = await ky(url, { ...init, timeout: 8e3, retry: 2 });
+    return await res.json();
+  } catch (e) {
+    if (e instanceof HttpError) throw e;
+    if (e instanceof Error && e.name === "TimeoutError") {
+      throw new NetworkError(`\u8BF7\u6C42\u8D85\u65F6: ${url}`);
+    }
+    if (e instanceof Error && e.name === "HTTPError") {
+      throw new HttpError(e.status ?? 500, e.message);
+    }
+    throw new NetworkError(`\u8BF7\u6C42\u5931\u8D25: ${url}`, e);
+  }
+}
+
+// src/server/bugs.ts
+function loadZgoalConfig(root) {
+  const file = path5.join(root, ".zgoal", "config.yaml");
+  if (!fs6.existsSync(file)) return null;
+  const kv = {};
+  for (const line of fs6.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 {
@@ -302,8 +979,8 @@ function normBug(b, account) {
     mine
   };
 }
-async function fetchBugs(root2) {
-  const cfg = loadZgoalConfig(root2);
+async function fetchBugs(root) {
+  const cfg = loadZgoalConfig(root);
   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);
@@ -319,561 +996,152 @@ async function fetchBugs(root2) {
   }
 }
 
-// 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());
-}
-
-// src/server/review-store.ts
-import fs4 from "fs";
-import path4 from "path";
-import YAML from "yaml";
-var REVIEW_FILE = "review.yaml";
-var ReviewStore = class {
-  root;
-  file;
-  onChange;
-  constructor(root2, onChange) {
-    this.root = root2;
-    this.file = path4.join(root2, REVIEW_FILE);
-    this.onChange = onChange;
-  }
-  exists() {
-    return fs4.existsSync(this.file);
-  }
-  read() {
-    try {
-      const parsed = YAML.parse(fs4.readFileSync(this.file, "utf8"));
-      if (!parsed || !Array.isArray(parsed.items)) return { status: "draft", items: [] };
-      return parsed;
-    } catch {
-      return { status: "draft", items: [] };
-    }
-  }
-  write(data) {
-    fs4.writeFileSync(this.file, YAML.stringify(data), "utf8");
-    this.onChange?.();
-  }
-  updateItem(id, patch) {
-    const data = this.read();
-    const item = data.items.find((i) => i.id === id);
-    if (!item) throw new Error(`item ${id} not found`);
-    if (patch.answer !== void 0) item.answer = patch.answer;
-    if (patch.state !== void 0) item.state = patch.state;
-    if (patch.state === "answered" && !patch.answer && !item.answer) item.answer = "";
-    this.write(data);
-    return data;
-  }
-  setStatus(status) {
-    const data = this.read();
-    if (status === "passed" && data.items.some((i) => i.state === "open")) {
-      throw new Error("\u5B58\u5728\u672A\u5904\u7406\u7684\u8BC4\u5BA1\u9879(open),\u4E0D\u80FD\u901A\u8FC7");
-    }
-    data.status = status;
-    this.write(data);
-    return data;
-  }
-  docs() {
-    try {
-      return fs4.readdirSync(this.root).filter((f) => /\.(md|markdown)$/i.test(f) && fs4.statSync(path4.join(this.root, f)).isFile()).sort();
-    } catch {
-      return [];
-    }
-  }
-};
-
-// src/server/design-assets.ts
-import fs5 from "fs";
-import path5 from "path";
-var PAGE_EXTS = [".html", ".htm"];
-var ICON_EXTS = [".svg", ".png", ".ico", ".jpg", ".jpeg", ".gif", ".webp"];
-var VIDEO_EXTS = [".mp4", ".webm", ".mov", ".ogg", ".ogv"];
-var AUDIO_EXTS = [".mp3", ".wav", ".flac", ".aac", ".m4a"];
-var CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".jsx", ".css", ".json", ".txt", ".xml", ".yml", ".yaml", ".sh", ".md"];
-var FONT_EXTS = [".woff", ".woff2", ".ttf", ".otf"];
-var TOKEN_RE = /token|theme|design|color|palette|typograph/i;
-function categorize(rel, ext) {
-  if (rel.indexOf("components/") === 0) return "component";
-  if (VIDEO_EXTS.includes(ext)) return "video";
-  if (AUDIO_EXTS.includes(ext)) return "audio";
-  if (ext === ".pdf") return "pdf";
-  if (ext === ".md") return "md";
-  if (FONT_EXTS.includes(ext)) return "font";
-  if (ICON_EXTS.includes(ext)) return "icon";
-  if (PAGE_EXTS.includes(ext)) return "page";
-  if (CODE_EXTS.includes(ext)) return TOKEN_RE.test(rel) && (ext === ".css" || ext === ".json") ? "token" : "code";
-  return "other";
-}
-function scanAssets(root2) {
-  const out = {};
-  const keys = ["page", "component", "icon", "token", "md", "video", "audio", "pdf", "code", "font", "other"];
-  for (const k of keys) out[k] = [];
-  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".next", ".cache"]);
-  function walk(dir, rel) {
-    let ents;
-    try {
-      ents = fs5.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const ent of ents) {
-      if (ent.name.startsWith(".") || SKIP.has(ent.name)) continue;
-      const r = rel ? `${rel}/${ent.name}` : ent.name;
-      if (ent.isDirectory()) {
-        walk(path5.join(dir, ent.name), r);
-        continue;
-      }
-      const ext = path5.extname(ent.name).toLowerCase();
-      const t = categorize(r, ext);
-      out[t].push({ path: r, name: ent.name, ext, type: t });
-    }
-  }
-  walk(root2, "");
-  return out;
-}
-
-// package.json
-var package_default = {
-  name: "zdashboard",
-  version: "1.6.2",
-  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",
-    "@uidotdev/usehooks": "^2.4.0",
-    "ansi-to-react": "^6.1.6",
-    "class-variance-authority": "^0.7.0",
-    clsx: "^2.1.1",
-    "date-fns": "^3.6.0",
-    filesize: "^11.0.0",
-    "highlight.js": "^11.11.1",
-    katex: "^0.16.11",
-    ky: "^1.7.0",
-    "lodash-es": "^4.17.21",
-    "lucide-react": "^0.460.0",
-    react: "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-error-boundary": "^5.0.0",
-    "react-markdown": "^9.0.1",
-    "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",
-    "remark-frontmatter": "^5.0.0",
-    "remark-gfm": "^4.0.0",
-    "remark-math": "^6.0.0",
-    sonner: "^1.5.0",
-    "tailwind-merge": "^2.5.4",
-    "use-debounce": "^10.0.0",
-    yaml: "^2.9.0"
-  },
-  devDependencies: {
-    "@tailwindcss/typography": "^0.5.20",
-    "@testing-library/jest-dom": "^7.0.1",
-    "@testing-library/react": "^16.3.2",
-    "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.9.0",
-    "@types/react": "^18.3.12",
-    "@types/react-dom": "^18.3.1",
-    "@vitejs/plugin-react": "^4.7.0",
-    autoprefixer: "^10.4.20",
-    jsdom: "^30.0.1",
-    postcss: "^8.4.49",
-    tailwindcss: "^3.4.14",
-    "tailwindcss-animate": "^1.0.7",
-    tsup: "^8.3.5",
-    typescript: "^5.6.3",
-    vite: "^5.4.10",
-    vitest: "^1.6.0"
-  },
-  pnpm: {
-    onlyBuiltDependencies: [
-      "esbuild"
-    ]
-  }
-};
-
-// src/server/index.ts
-var VERSION = package_default.version;
-var __dirname2 = path6.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",
-  ".sql": "text/plain; charset=utf-8",
-  ".csv": "text/plain; charset=utf-8",
-  ".tsv": "text/plain; charset=utf-8",
-  ".yaml": "text/yaml; charset=utf-8",
-  ".yml": "text/yaml; charset=utf-8",
-  ".xml": "application/xml; charset=utf-8",
-  ".py": "text/plain; charset=utf-8",
-  ".ts": "text/plain; charset=utf-8",
-  ".java": "text/plain; charset=utf-8",
-  ".go": "text/plain; charset=utf-8",
-  ".rs": "text/plain; charset=utf-8",
-  ".rb": "text/plain; charset=utf-8",
-  ".php": "text/plain; charset=utf-8",
-  ".c": "text/plain; charset=utf-8",
-  ".cpp": "text/plain; charset=utf-8",
-  ".h": "text/plain; charset=utf-8",
-  ".cs": "text/plain; charset=utf-8",
-  ".swift": "text/plain; charset=utf-8",
-  ".kt": "text/plain; charset=utf-8",
-  ".scala": "text/plain; charset=utf-8",
-  ".sh": "text/plain; charset=utf-8",
-  ".bash": "text/plain; charset=utf-8",
-  ".zsh": "text/plain; charset=utf-8",
-  ".fish": "text/plain; charset=utf-8",
-  ".env": "text/plain; charset=utf-8",
-  ".gitignore": "text/plain; charset=utf-8",
-  ".dockerfile": "text/plain; charset=utf-8",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/woff",
-  ".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 = path6.resolve(opts.root);
-  const PORT0 = opts.port ?? 4190;
-  const OPEN = !!opts.open;
-  const APP_DIR = opts.dashboardDir ?? path6.resolve(__dirname2, "web");
-  if (!fs6.existsSync(ROOT)) fs6.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" });
-  const reviewStore = new ReviewStore(ROOT);
-  registerBuiltin({
-    mode: "review",
-    label: "\u6587\u6863\u8BC4\u5BA1",
-    icon: "\u2705",
-    apiRoutes: {
-      "/__review": async (_, res) => {
+// src/plugins/bugs/index.ts
+var apply3 = {
+  inject: ["server", "dashboard"],
+  apply(ctx, config) {
+    const root = config.root;
+    ctx.inject(["server"], () => {
+      if (!ctx.server?.route) return;
+      ctx.dashboard.register({ mode: "bugs", label: "\u7985\u9053 Bugs", icon: "\u{1F3AF}", description: "\u53EA\u8BFB bug \u5217\u8868" });
+      ctx.server.route("/__bugs", async (_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-        res.end(JSON.stringify(reviewStore.read()));
-      },
-      "/__review/item": async (req, res) => {
-        if (req.headers["x-stop-token"] !== STOP_TOKEN) {
-          res.writeHead(403);
-          res.end("forbidden");
-          return;
-        }
-        (async () => {
-          try {
-            const body = JSON.parse(await readBody(req) || "{}");
-            const data = reviewStore.updateItem(body.id, { answer: body.answer, state: body.state });
-            res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
-            res.end(JSON.stringify(data));
-          } catch (e) {
-            res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
-            res.end(JSON.stringify({ error: e.message }));
-          }
-        })();
-        return;
-      },
-      "/__review/status": async (req, res) => {
-        if (req.headers["x-stop-token"] !== STOP_TOKEN) {
-          res.writeHead(403);
-          res.end("forbidden");
-          return;
+        try {
+          const result = await fetchBugs(root);
+          res.end(JSON.stringify(result));
+        } catch (e) {
+          res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : "unknown error" }));
         }
-        (async () => {
-          try {
-            const body = JSON.parse(await readBody(req) || "{}");
-            const data = reviewStore.setStatus(body.status);
-            res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
-            res.end(JSON.stringify(data));
-          } catch (e) {
-            res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
-            res.end(JSON.stringify({ error: e.message }));
-          }
-        })();
-        return;
-      },
-      "/__docs": async (_, res) => {
-        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-        res.end(JSON.stringify(reviewStore.docs()));
-      }
-    }
-  });
-  registerBuiltin({ mode: "design", label: "\u8BBE\u8BA1\u8D44\u4EA7", icon: "\u{1F3A8}" });
-  registerBuiltin({
-    mode: "apply",
-    label: "\u6267\u884C\u8FDB\u5EA6",
-    icon: "\u2699\uFE0F",
-    apiRoutes: {
-      "/__apply": async (_, res) => {
-        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-        res.end(JSON.stringify(scanApplyChanges(ROOT)));
-      },
-      "/__apply/change": async (req, res) => {
-        (async () => {
-          try {
-            const url = new URL(req.url || "", "http://x");
-            const name = url.searchParams.get("name");
-            if (!name) {
-              res.writeHead(400);
-              res.end(JSON.stringify({ error: "missing name" }));
-              return;
-            }
-            const data = readApplyChange(ROOT, name);
-            res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-            res.end(JSON.stringify(data));
-          } catch (e) {
-            res.writeHead(400);
-            res.end(JSON.stringify({ error: e.message }));
-          }
-        })();
-        return;
-      }
-    }
-  });
-  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) {
-    fs6.readFile(filePath, (err, data) => {
-      if (err) {
-        res.writeHead(404);
-        return res.end("Not found");
-      }
-      const ext = path6.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, mode: MODE ?? null }));
-    }
-    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 (e) {
-            console.error("[zdashboard] server close failed:", e);
-          }
-          process.exit(0);
-        }, 50);
-      } else {
-        res.writeHead(403);
-        res.end("forbidden");
-      }
-      return;
+};
+
+// src/server/review-store.ts
+import fs7 from "fs";
+import path6 from "path";
+import YAML from "yaml";
+var REVIEW_FILE = "review.yaml";
+var ReviewStore = class {
+  root;
+  file;
+  onChange;
+  constructor(root, onChange) {
+    this.root = root;
+    this.file = path6.join(root, REVIEW_FILE);
+    this.onChange = onChange;
+  }
+  exists() {
+    return fs7.existsSync(this.file);
+  }
+  read() {
+    try {
+      const parsed = YAML.parse(fs7.readFileSync(this.file, "utf8"));
+      if (!parsed || !Array.isArray(parsed.items)) return { status: "draft", items: [] };
+      return parsed;
+    } catch {
+      return { status: "draft", items: [] };
     }
-    if (url === "/__files") {
-      if (MODE === "design") {
-        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-        return res.end(JSON.stringify(scanAssets(ROOT)));
-      }
-      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));
+  }
+  write(data) {
+    fs7.writeFileSync(this.file, YAML.stringify(data), "utf8");
+    this.onChange?.();
+  }
+  updateItem(id, patch) {
+    const data = this.read();
+    const item = data.items.find((i) => i.id === id);
+    if (!item) throw new Error(`item ${id} not found`);
+    if (patch.answer !== void 0) item.answer = patch.answer;
+    if (patch.state !== void 0) item.state = patch.state;
+    if (patch.state === "answered" && !patch.answer && !item.answer) item.answer = "";
+    this.write(data);
+    return data;
+  }
+  setStatus(status) {
+    const data = this.read();
+    if (status === "passed" && data.items.some((i) => i.state === "open")) {
+      throw new Error("\u5B58\u5728\u672A\u5904\u7406\u7684\u8BC4\u5BA1\u9879(open),\u4E0D\u80FD\u901A\u8FC7");
     }
-    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;
+    data.status = status;
+    this.write(data);
+    return data;
+  }
+  docs() {
+    try {
+      return fs7.readdirSync(this.root).filter((f) => /\.(md|markdown)$/i.test(f) && fs7.statSync(path6.join(this.root, f)).isFile()).sort();
+    } catch {
+      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) {
+// src/plugins/review/index.ts
+var apply4 = {
+  inject: ["server", "dashboard", "reload"],
+  apply(ctx, config) {
+    const root = config.root;
+    ctx.inject(["server"], () => {
+      if (!ctx.server?.route) return;
+      ctx.dashboard.register({ mode: "review", label: "\u6587\u6863\u8BC4\u5BA1", icon: "\u2705", description: "review.yaml \u9010\u9879\u5BF9\u9F50" });
+      const reviewStore = new ReviewStore(root, () => {
+        ctx.reload.broadcast("files");
+      });
+      ctx.server.route("/__review", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(reviewStore.read()));
+      });
+      ctx.server.route("/__review/item", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
           res.writeHead(403);
           res.end("forbidden");
           return;
         }
-        const body = await readBody(req);
-        let recipe;
         try {
-          recipe = JSON.parse(body || "{}").recipe;
+          const body = JSON.parse(await readBody2(req) || "{}");
+          const data = reviewStore.updateItem(body.id, { answer: body.answer, state: body.state });
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(data));
         } catch (e) {
-          console.error("[zdashboard] invalid just action body:", e);
-        }
-        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(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
         }
-        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);
+      });
+      ctx.server.route("/__review/status", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
           return;
         }
-      }
-    }
-    if (url === "/") return serveFile(path6.join(APP_DIR, "index.html"), res, false);
-    if (url.indexOf("/__app/") === 0) {
-      const fp2 = path6.join(APP_DIR, url.slice(7));
-      if (fp2 !== APP_DIR && fp2.indexOf(APP_DIR + path6.sep) !== 0) {
-        res.writeHead(403);
-        return res.end("Forbidden");
-      }
-      return serveFile(fp2, res, false);
-    }
-    if (url.indexOf("/assets/") === 0) {
-      const fp2 = path6.join(APP_DIR, decodeURIComponent(url));
-      if (fp2.indexOf(APP_DIR + path6.sep) !== 0) {
-        res.writeHead(403);
-        return res.end("Forbidden");
-      }
-      return serveFile(fp2, res, false);
-    }
-    const fp = path6.join(ROOT, decodeURIComponent(url));
-    if (fp !== ROOT && fp.indexOf(ROOT + path6.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}`);
+        try {
+          const body = JSON.parse(await readBody2(req) || "{}");
+          const data = reviewStore.setStatus(body.status);
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(data));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__docs", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(reviewStore.docs()));
+      });
     });
   }
-  let debounce;
-  try {
-    fs6.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);
+};
+async function readBody2(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (c) => {
+      data += c;
     });
-  } catch {
-    console.log("[zdashboard] watch unavailable - static only.");
-  }
-  start(PORT0);
+    req.on("end", () => resolve(data));
+  });
 }
+
+// src/plugins/apply/scan.ts
+import fs8 from "fs";
+import path7 from "path";
 function countTasks(md) {
   const all = (md.match(/^\s*-\s*\[[ xX]\]\s*/gm) || []).length;
   const done = (md.match(/^\s*-\s*\[[xX]\]\s*/gm) || []).length;
@@ -881,73 +1149,389 @@ function countTasks(md) {
 }
 function readText(p) {
   try {
-    return fs6.readFileSync(p, "utf8");
+    return fs8.readFileSync(p, "utf8");
   } catch {
     return "";
   }
 }
-function scanApplyChanges(root2) {
-  const changesDir = path6.join(root2, "openspec", "changes");
-  if (!fs6.existsSync(changesDir)) return [];
+function scanApplyChanges(root) {
+  const changesDir = path7.join(root, "openspec", "changes");
+  if (!fs8.existsSync(changesDir)) return [];
   const out = [];
-  for (const ent of fs6.readdirSync(changesDir, { withFileTypes: true })) {
+  for (const ent of fs8.readdirSync(changesDir, { withFileTypes: true })) {
     if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
-    const dir = path6.join(changesDir, ent.name);
-    const tasks = readText(path6.join(dir, "tasks.md"));
+    const dir = path7.join(changesDir, ent.name);
+    const tasks = readText(path7.join(dir, "tasks.md"));
     const { total, done } = countTasks(tasks);
-    out.push({ name: ent.name, path: `openspec/changes/${ent.name}`, total, done, hasProposal: fs6.existsSync(path6.join(dir, "proposal.md")), hasDesign: fs6.existsSync(path6.join(dir, "design.md")) });
+    out.push({
+      name: ent.name,
+      path: `openspec/changes/${ent.name}`,
+      total,
+      done,
+      hasProposal: fs8.existsSync(path7.join(dir, "proposal.md")),
+      hasDesign: fs8.existsSync(path7.join(dir, "design.md"))
+    });
   }
   out.sort((a, b) => a.name.localeCompare(b.name));
   return out;
 }
-function readApplyChange(root2, name) {
-  const dir = path6.join(root2, "openspec", "changes", name);
-  const proposal = readText(path6.join(dir, "proposal.md"));
-  const design = readText(path6.join(dir, "design.md"));
-  const tasks = readText(path6.join(dir, "tasks.md"));
+function readApplyChange(root, name) {
+  const dir = path7.join(root, "openspec", "changes", name);
+  const proposal = readText(path7.join(dir, "proposal.md"));
+  const design = readText(path7.join(dir, "design.md"));
+  const tasks = readText(path7.join(dir, "tasks.md"));
   const { total, done } = countTasks(tasks);
-  return { name, path: `openspec/changes/${name}`, total, done, hasProposal: !!proposal, hasDesign: !!design, proposal, design, tasks };
+  return {
+    name,
+    path: `openspec/changes/${name}`,
+    total,
+    done,
+    hasProposal: !!proposal,
+    hasDesign: !!design,
+    proposal,
+    design,
+    tasks
+  };
 }
 
-// src/server/detect.ts
-import fs7 from "fs";
-import path7 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);
+// src/plugins/apply/index.ts
+var apply5 = {
+  inject: ["server", "dashboard"],
+  apply(ctx, config) {
+    const root = config.root;
+    ctx.inject(["server"], () => {
+      if (!ctx.server?.route) return;
+      ctx.dashboard.register({ mode: "apply", label: "\u6267\u884C\u8FDB\u5EA6", icon: "\u2699\uFE0F", description: "OpenSpec change \u4EFB\u52A1\u8FDB\u5EA6" });
+      ctx.server.route("/__apply", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(scanApplyChanges(root)));
+      });
+      ctx.server.route("/__apply/change", async (req, res) => {
+        const url = new URL(req.url || "", "http://x");
+        const name = url.searchParams.get("name");
+        if (!name) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "missing name" }));
+          return;
+        }
+        if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "invalid name" }));
+          return;
+        }
+        try {
+          const data = readApplyChange(root, name);
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(data));
+        } catch (e) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
     });
-    if (child.killed) resolve(false);
-  });
+  }
+};
+
+// src/server/design-assets.ts
+import fs9 from "fs";
+import path8 from "path";
+var PAGE_EXTS = [".html", ".htm"];
+var ICON_EXTS = [".svg", ".png", ".ico", ".jpg", ".jpeg", ".gif", ".webp"];
+var VIDEO_EXTS = [".mp4", ".webm", ".mov", ".ogg", ".ogv"];
+var AUDIO_EXTS = [".mp3", ".wav", ".flac", ".aac", ".m4a"];
+var CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".jsx", ".css", ".json", ".txt", ".xml", ".yml", ".yaml", ".sh", ".md"];
+var FONT_EXTS = [".woff", ".woff2", ".ttf", ".otf"];
+var TOKEN_RE = /token|theme|design|color|palette|typograph/i;
+function categorize(rel, ext) {
+  if (rel.indexOf("components/") === 0) return "component";
+  if (VIDEO_EXTS.includes(ext)) return "video";
+  if (AUDIO_EXTS.includes(ext)) return "audio";
+  if (ext === ".pdf") return "pdf";
+  if (ext === ".md") return "md";
+  if (FONT_EXTS.includes(ext)) return "font";
+  if (ICON_EXTS.includes(ext)) return "icon";
+  if (PAGE_EXTS.includes(ext)) return "page";
+  if (CODE_EXTS.includes(ext)) {
+    if (TOKEN_RE.test(rel) && (ext === ".css" || ext === ".json")) return "token";
+    return null;
+  }
+  return "other";
 }
-async function detect(root2) {
-  const hasOpenspec = fs7.existsSync(path7.join(root2, "openspec"));
-  const hasDocs = fs7.existsSync(path7.join(root2, "docs"));
-  const hasJust = await justAvailable(root2);
-  const hasBugs = fs7.existsSync(path7.join(root2, ".zgoal", "config.yaml"));
-  return { hasOpenspec, hasDocs, hasJust, hasBugs };
+function scanAssets(root) {
+  const out = {};
+  const keys = ["page", "component", "icon", "token", "md", "video", "audio", "pdf", "font", "other"];
+  for (const k of keys) out[k] = [];
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".next", ".cache"]);
+  function walk(dir, rel) {
+    let ents;
+    try {
+      ents = fs9.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of ents) {
+      if (ent.name.startsWith(".") || SKIP.has(ent.name)) continue;
+      const r = rel ? `${rel}/${ent.name}` : ent.name;
+      if (ent.isDirectory()) {
+        walk(path8.join(dir, ent.name), r);
+        continue;
+      }
+      const ext = path8.extname(ent.name).toLowerCase();
+      const t = categorize(r, ext);
+      if (t) out[t].push({ path: r, name: ent.name, ext, type: t });
+    }
+  }
+  walk(root, "");
+  return out;
+}
+
+// src/plugins/design/index.ts
+var apply6 = {
+  inject: ["server", "dashboard"],
+  apply(ctx, config) {
+    const root = config.root;
+    ctx.inject(["server"], () => {
+      if (!ctx.server?.route) return;
+      ctx.dashboard.register({ mode: "design", label: "\u8BBE\u8BA1\u8D44\u4EA7", icon: "\u{1F3A8}", description: "\u9875\u9762/\u7EC4\u4EF6/\u56FE\u6807/Token \u5206\u7C7B\u9884\u89C8" });
+      ctx.server.route("/__design/assets", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(scanAssets(root)));
+      });
+    });
+  }
+};
+
+// src/plugins/view/index.ts
+var apply7 = {
+  inject: ["dashboard"],
+  apply(ctx) {
+    ctx.dashboard.register({ mode: "view", label: "\u9879\u76EE\u6D4F\u89C8", icon: "\u{1F441}\uFE0F", description: "openspec / docs / \u6587\u6863\u9884\u89C8" });
+  }
+};
+
+// src/plugins/stats/index.ts
+import fs10 from "fs";
+import path9 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".cache"]);
+function scan(root) {
+  const stats = {
+    root: path9.basename(root),
+    files: 0,
+    dirs: 0,
+    totalSize: 0,
+    byExt: [],
+    markdown: 0,
+    openspec: { active: 0, archived: 0 },
+    hasJust: fs10.existsSync(path9.join(root, "justfile"))
+  };
+  const extMap = /* @__PURE__ */ new Map();
+  const walk = (dir) => {
+    let ents;
+    try {
+      ents = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of ents) {
+      if (ent.name.startsWith(".") || SKIP_DIRS.has(ent.name)) continue;
+      const abs = path9.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        stats.dirs++;
+        walk(abs);
+        continue;
+      }
+      stats.files++;
+      try {
+        stats.totalSize += fs10.statSync(abs).size;
+      } catch {
+      }
+      const ext = path9.extname(ent.name).toLowerCase() || "(\u65E0\u6269\u5C55\u540D)";
+      extMap.set(ext, (extMap.get(ext) ?? 0) + 1);
+      if (ext === ".md" || ext === ".markdown") stats.markdown++;
+    }
+  };
+  walk(root);
+  const changesDir = path9.join(root, "openspec", "changes");
+  if (fs10.existsSync(changesDir)) {
+    for (const ent of fs10.readdirSync(changesDir, { withFileTypes: true })) {
+      if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+      if (ent.name === "archive") {
+        try {
+          stats.openspec.archived = fs10.readdirSync(path9.join(changesDir, "archive"), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
+        } catch {
+        }
+      } else stats.openspec.active++;
+    }
+  }
+  stats.byExt = Array.from(extMap.entries()).map(([ext, count]) => ({ ext, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+  return stats;
 }
+var apply8 = {
+  inject: ["server", "dashboard"],
+  apply(ctx, config) {
+    ctx.inject(["server", "dashboard"], () => {
+      const server = ctx.server;
+      const dashboard = ctx.dashboard;
+      if (!server?.route || !dashboard?.register) return;
+      dashboard.register({
+        mode: "stats",
+        label: "\u9879\u76EE\u7EDF\u8BA1",
+        icon: "\u{1F4CA}",
+        description: "\u9879\u76EE\u6587\u4EF6\u7EDF\u8BA1 \xB7 \u626B\u63CF\u751F\u6210"
+      });
+      server.route("/__stats/data", (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(scan(config.root)));
+      });
+    });
+  }
+};
 
 // 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
+var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        opts[key] = next;
+        i++;
+      } else {
+        opts[key] = true;
+      }
+    }
+  }
+  return {
+    dir: typeof opts.dir === "string" ? opts.dir : process.cwd(),
+    port: typeof opts.port === "string" ? Number(opts.port) : 4190,
+    open: !!opts.open,
+    page: typeof opts.page === "string" ? opts.page : null,
+    restart: !!opts.restart,
+    plugins: typeof opts.plugins === "string" ? opts.plugins : null
+  };
+}
+async function pathExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadExternal(ctx, dir, root) {
+  if (!dir) return;
+  let tsxLoaded = false;
+  try {
+    const { register } = await import("tsx/esm/api");
+    register();
+    tsxLoaded = true;
+  } catch {
+  }
+  try {
+    const entries = await pathExists(dir) ? await readdir(dir, { withFileTypes: true }) : [];
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      const candidates = tsxLoaded ? ["index.ts", "index.js", "index.mjs"] : ["index.js", "index.mjs"];
+      for (const name of candidates) {
+        const p = path10.join(dir, ent.name, name);
+        if (await pathExists(p)) {
+          try {
+            const mod = await import(p);
+            const plugin = mod.default ?? mod;
+            if (plugin?.apply) {
+              try {
+                await ctx.plugin(plugin, { root });
+              } catch (e) {
+                console.error(`[zdashboard] failed to apply plugin ${ent.name}:`, e);
+                break;
+              }
+              const m = ctx.dashboard.get(ent.name);
+              if (m && m.mode === ent.name) {
+                const patch = { external: true };
+                const webDir = path10.join(dir, ent.name, "web");
+                if (await pathExists(path10.join(webDir, "index.html"))) {
+                  ctx.server.static(`${PLUGIN_STATIC_PREFIX}${ent.name}/`, webDir);
+                  if (!m.viewerUrl) patch.viewerUrl = `${PLUGIN_STATIC_PREFIX}${ent.name}/`;
+                }
+                ctx.dashboard.register({ ...m, ...patch });
+              }
+            }
+          } catch (e) {
+            console.error(`[zdashboard] failed to load plugin ${ent.name}:`, e);
+          }
+          break;
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function main() {
+  const args = parseArgs();
+  const root = path10.resolve(args.dir);
+  const existing = await findReusable(root);
+  if (existing && !args.restart) {
+    const u = `http://localhost:${existing.port}` + (args.page ? `#${args.page}` : "");
+    if (args.open) openUrl(u);
+    console.log(`[zdashboard] \u5DF2\u590D\u7528\u5B9E\u4F8B ${u}\uFF08--restart \u53EF\u5F3A\u5236\u91CD\u5F00\uFF09`);
+    await new Promise((resolve) => process.stdout.write("", () => resolve()));
+    process.exit(0);
+  }
+  if (existing && args.restart) {
+    console.log(`[zdashboard] --restart\uFF1A\u505C\u6B62\u65E7\u5B9E\u4F8B pid=${existing.pid}`);
+    await stopInstance(existing);
+  }
+  const appDir = path10.resolve(__dirname2, "web");
+  const det = await detect(root);
+  const ctx = new Context();
+  ctx.plugin(ServerService, {
+    root,
+    appDir,
+    port: args.port,
+    open: args.open,
+    detect: det,
+    page: args.page,
+    onListen: (port) => writeRecord(root, port)
+  });
+  ctx.plugin(ReloadService, { root });
+  ctx.plugin(apply, { root });
+  ctx.plugin(DashboardService);
+  const plugins = [
+    { name: "stats", apply: apply8 },
+    { name: "just", apply: apply2 },
+    { name: "bugs", apply: apply3 },
+    { name: "review", apply: apply4 },
+    { name: "apply", apply: apply5 },
+    { name: "design", apply: apply6 },
+    { name: "view", apply: apply7 }
+  ];
+  for (const p of plugins) {
+    try {
+      ctx.plugin(p.apply, { root });
+    } catch (e) {
+      console.error(`[zdashboard] plugin ${p.name} failed:`, e);
+    }
+  }
+  if (args.plugins) {
+    await loadExternal(ctx, path10.resolve(args.plugins), root);
+  }
+  const shutdown = () => {
+    try {
+      clearRecord(root);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  return ctx;
+}
+await main().catch((e) => {
+  console.error(e);
+  process.exit(1);
 });
 //# sourceMappingURL=cli.js.map