zdashboard 2.0.0 → 2.1.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path8 from "path";
+import path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { access, readdir } from "fs/promises";
 
@@ -30,16 +30,15 @@ import { Context } from "cordis";
 
 // src/core/server.ts
 import http from "http";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import crypto from "crypto";
-import { exec } from "child_process";
 import { fileURLToPath } from "url";
 
 // package.json
 var package_default = {
   name: "zdashboard",
-  version: "2.0.0",
+  version: "2.1.0",
   description: "ZCode skill dashboard platform \u2014 pluggable viewers for zdesign/zview/zreview/zgoal",
   type: "module",
   bin: {
@@ -123,8 +122,113 @@ var package_default = {
 
 // 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 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;
+  }
+}
+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 {
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    if (e.code === "ESRCH") return false;
+    return true;
+  }
+}
+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);
+  }
+}
+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;
+  }
+}
+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;
+  }
+  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));
+  }
+  try {
+    process.kill(record.pid, "SIGKILL");
+  } catch {
+  }
+  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 = path2.dirname(fileURLToPath(import.meta.url));
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".htm": "text/html; charset=utf-8",
@@ -186,6 +290,7 @@ var ServerService = class extends Service {
   sses = /* @__PURE__ */ new Map();
   prefixStatic = /* @__PURE__ */ new Map();
   server;
+  onListen;
   constructor(ctx, config) {
     super(ctx, "server");
     this.stopToken = crypto.randomBytes(12).toString("hex");
@@ -194,6 +299,7 @@ var ServerService = class extends Service {
     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" });
@@ -211,25 +317,25 @@ var ServerService = class extends Service {
     });
     this.start(config.port);
   }
-  route(path9, handler) {
-    this.routes.set(path9, handler);
-    this.ctx.effect(() => () => this.routes.delete(path9));
+  route(path11, handler) {
+    this.routes.set(path11, handler);
+    this.ctx.effect(() => () => this.routes.delete(path11));
   }
-  sse(path9, onConnect) {
-    this.sses.set(path9, onConnect);
-    this.ctx.effect(() => () => this.sses.delete(path9));
+  sse(path11, onConnect) {
+    this.sses.set(path11, onConnect);
+    this.ctx.effect(() => () => this.sses.delete(path11));
   }
   static(prefix, dir) {
     this.prefixStatic.set(prefix, dir);
     this.ctx.effect(() => () => this.prefixStatic.delete(prefix));
   }
   serveFile(filePath, res, injectHtml) {
-    fs2.readFile(filePath, (err, data) => {
+    fs3.readFile(filePath, (err, data) => {
       if (err) {
         res.writeHead(404);
         return res.end("Not found");
       }
-      const ext = path2.extname(filePath).toLowerCase();
+      const ext = path3.extname(filePath).toLowerCase();
       const ct = MIME[ext] ?? "application/octet-stream";
       let body = data;
       if (injectHtml && ext === ".html") {
@@ -244,9 +350,9 @@ var ServerService = class extends Service {
     for (const [prefix, dir] of this.prefixStatic) {
       if (url.indexOf(prefix) === 0) {
         let rel = this.safeDecode(url.slice(prefix.length));
-        if (!rel || rel === "/" || !path2.extname(rel)) rel = path2.join(rel || "", "index.html");
-        const fp = path2.join(dir, rel);
-        if (fp.indexOf(dir + path2.sep) !== 0) {
+        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");
         }
@@ -285,17 +391,17 @@ var ServerService = class extends Service {
       if (this.servePrefix(url, res)) return;
       if (url === "/" || url.indexOf("/__app/") === 0 || url.indexOf("/assets/") === 0) {
         let fp2 = this.appDir;
-        if (url !== "/") fp2 = path2.join(this.appDir, this.safeDecode(url));
-        if (url.indexOf("/__app/") === 0) fp2 = path2.join(this.appDir, url.slice(7));
-        if (fp2 !== this.appDir && fp2.indexOf(this.appDir + path2.sep) !== 0) {
+        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 = path2.join(this.appDir, "index.html");
+        if (url === "/") fp2 = path3.join(this.appDir, "index.html");
         return this.serveFile(fp2, res, false);
       }
-      const fp = path2.join(this.root, this.safeDecode(url));
-      if (fp !== this.root && fp.indexOf(this.root + path2.sep) !== 0) {
+      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");
       }
@@ -323,7 +429,8 @@ var ServerService = class extends Service {
       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) exec(process.platform === "darwin" ? `open ${target}` : `start ${target}`);
+      if (this.open) openUrl2(target);
+      this.onListen?.(port);
     });
   }
   stop() {
@@ -333,6 +440,10 @@ var ServerService = class extends Service {
       } catch {
       }
     }
+    try {
+      clearRecord(this.root);
+    } catch {
+    }
     setTimeout(() => {
       try {
         this.ctx.root.fiber.dispose();
@@ -348,11 +459,15 @@ var ServerService = class extends Service {
       } catch {
       }
     }
+    try {
+      clearRecord(this.root);
+    } catch {
+    }
   }
 };
 
 // src/core/reload.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import { Service as Service2 } from "cordis";
 var WATCH_DEBOUNCE_MS = 150;
 var ReloadService = class extends Service2 {
@@ -368,7 +483,7 @@ var ReloadService = class extends Service2 {
       return () => this.clients.delete(res);
     });
     try {
-      this.watcher = fs3.watch(config.root, { recursive: true }, () => {
+      this.watcher = fs4.watch(config.root, { recursive: true }, () => {
         if (this.timer) clearTimeout(this.timer);
         this.timer = setTimeout(() => {
           this.broadcast("reload");
@@ -411,13 +526,13 @@ data: ${JSON.stringify(data == null ? "" : data)}
 };
 
 // src/server/spec-scan.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 function walkFiles(absDir, relDir, depth = 0) {
   if (depth > 4) return [];
   let ents;
   try {
-    ents = fs4.readdirSync(absDir, { withFileTypes: true });
+    ents = fs5.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -426,7 +541,7 @@ function walkFiles(absDir, relDir, depth = 0) {
     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(path3.join(absDir, ent.name), rel, depth + 1) });
+      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 });
     }
@@ -436,41 +551,41 @@ function walkFiles(absDir, relDir, depth = 0) {
 }
 function scanTree(root, hasOpenspec, hasDocs) {
   const tree = [];
-  if (hasOpenspec && fs4.existsSync(path3.join(root, "openspec", "changes"))) {
-    const changesDir = path3.join(root, "openspec", "changes");
+  if (hasOpenspec && fs5.existsSync(path4.join(root, "openspec", "changes"))) {
+    const changesDir = path4.join(root, "openspec", "changes");
     const active = [];
     const archived = [];
-    for (const ent of fs4.readdirSync(changesDir, { withFileTypes: true })) {
+    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(path3.join(changesDir, ent.name), `openspec/changes/${ent.name}`) });
+      active.push({ name: ent.name, kind: "dir", children: walkFiles(path4.join(changesDir, ent.name), `openspec/changes/${ent.name}`) });
     }
     active.sort((a, b) => a.name.localeCompare(b.name));
-    const archiveDir = path3.join(changesDir, "archive");
-    if (fs4.existsSync(archiveDir)) {
-      for (const ent of fs4.readdirSync(archiveDir, { withFileTypes: true })) {
+    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(path3.join(archiveDir, ent.name), `openspec/changes/archive/${ent.name}`) });
+        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 = path3.join(root, "openspec", "specs");
-    if (fs4.existsSync(specsDir)) {
+    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 && fs4.existsSync(path3.join(root, "docs"))) {
-    const docs = walkFiles(path3.join(root, "docs"), "docs");
+  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 fs4.readdirSync(root, { withFileTypes: true })) {
+    for (const ent of fs5.readdirSync(root, { withFileTypes: true })) {
       if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
-      const ext = path3.extname(ent.name).toLowerCase();
+      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) {
@@ -771,8 +886,8 @@ async function readBody(req) {
 }
 
 // src/server/bugs.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 
 // src/server/api/fetch.ts
 import ky from "ky";
@@ -816,10 +931,10 @@ async function fetchJson(url, init) {
 
 // src/server/bugs.ts
 function loadZgoalConfig(root) {
-  const file = path4.join(root, ".zgoal", "config.yaml");
-  if (!fs5.existsSync(file)) return null;
+  const file = path5.join(root, ".zgoal", "config.yaml");
+  if (!fs6.existsSync(file)) return null;
   const kv = {};
-  for (const line of fs5.readFileSync(file, "utf8").split("\n")) {
+  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, "");
   }
@@ -903,8 +1018,8 @@ var apply3 = {
 };
 
 // src/server/review-store.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 import YAML from "yaml";
 var REVIEW_FILE = "review.yaml";
 var ReviewStore = class {
@@ -913,15 +1028,15 @@ var ReviewStore = class {
   onChange;
   constructor(root, onChange) {
     this.root = root;
-    this.file = path5.join(root, REVIEW_FILE);
+    this.file = path6.join(root, REVIEW_FILE);
     this.onChange = onChange;
   }
   exists() {
-    return fs6.existsSync(this.file);
+    return fs7.existsSync(this.file);
   }
   read() {
     try {
-      const parsed = YAML.parse(fs6.readFileSync(this.file, "utf8"));
+      const parsed = YAML.parse(fs7.readFileSync(this.file, "utf8"));
       if (!parsed || !Array.isArray(parsed.items)) return { status: "draft", items: [] };
       return parsed;
     } catch {
@@ -929,7 +1044,7 @@ var ReviewStore = class {
     }
   }
   write(data) {
-    fs6.writeFileSync(this.file, YAML.stringify(data), "utf8");
+    fs7.writeFileSync(this.file, YAML.stringify(data), "utf8");
     this.onChange?.();
   }
   updateItem(id, patch) {
@@ -953,7 +1068,7 @@ var ReviewStore = class {
   }
   docs() {
     try {
-      return fs6.readdirSync(this.root).filter((f) => /\.(md|markdown)$/i.test(f) && fs6.statSync(path5.join(this.root, f)).isFile()).sort();
+      return fs7.readdirSync(this.root).filter((f) => /\.(md|markdown)$/i.test(f) && fs7.statSync(path6.join(this.root, f)).isFile()).sort();
     } catch {
       return [];
     }
@@ -1025,8 +1140,8 @@ async function readBody2(req) {
 }
 
 // src/plugins/apply/scan.ts
-import fs7 from "fs";
-import path6 from "path";
+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;
@@ -1034,37 +1149,37 @@ function countTasks(md) {
 }
 function readText(p) {
   try {
-    return fs7.readFileSync(p, "utf8");
+    return fs8.readFileSync(p, "utf8");
   } catch {
     return "";
   }
 }
 function scanApplyChanges(root) {
-  const changesDir = path6.join(root, "openspec", "changes");
-  if (!fs7.existsSync(changesDir)) return [];
+  const changesDir = path7.join(root, "openspec", "changes");
+  if (!fs8.existsSync(changesDir)) return [];
   const out = [];
-  for (const ent of fs7.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: fs7.existsSync(path6.join(dir, "proposal.md")),
-      hasDesign: fs7.existsSync(path6.join(dir, "design.md"))
+      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(root, name) {
-  const dir = path6.join(root, "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"));
+  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,
@@ -1118,8 +1233,8 @@ var apply5 = {
 };
 
 // src/server/design-assets.ts
-import fs8 from "fs";
-import path7 from "path";
+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"];
@@ -1136,18 +1251,21 @@ function categorize(rel, ext) {
   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";
+  if (CODE_EXTS.includes(ext)) {
+    if (TOKEN_RE.test(rel) && (ext === ".css" || ext === ".json")) return "token";
+    return null;
+  }
   return "other";
 }
 function scanAssets(root) {
   const out = {};
-  const keys = ["page", "component", "icon", "token", "md", "video", "audio", "pdf", "code", "font", "other"];
+  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 = fs8.readdirSync(dir, { withFileTypes: true });
+      ents = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1155,12 +1273,12 @@ function scanAssets(root) {
       if (ent.name.startsWith(".") || SKIP.has(ent.name)) continue;
       const r = rel ? `${rel}/${ent.name}` : ent.name;
       if (ent.isDirectory()) {
-        walk(path7.join(dir, ent.name), r);
+        walk(path8.join(dir, ent.name), r);
         continue;
       }
-      const ext = path7.extname(ent.name).toLowerCase();
+      const ext = path8.extname(ent.name).toLowerCase();
       const t = categorize(r, ext);
-      out[t].push({ path: r, name: ent.name, ext, type: t });
+      if (t) out[t].push({ path: r, name: ent.name, ext, type: t });
     }
   }
   walk(root, "");
@@ -1191,8 +1309,86 @@ var apply7 = {
   }
 };
 
+// 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
-var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
 function parseArgs() {
   const args = process.argv.slice(2);
   const opts = {};
@@ -1214,6 +1410,7 @@ function parseArgs() {
     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
   };
 }
@@ -1240,7 +1437,7 @@ async function loadExternal(ctx, dir, root) {
       if (!ent.isDirectory()) continue;
       const candidates = tsxLoaded ? ["index.ts", "index.js", "index.mjs"] : ["index.js", "index.mjs"];
       for (const name of candidates) {
-        const p = path8.join(dir, ent.name, name);
+        const p = path10.join(dir, ent.name, name);
         if (await pathExists(p)) {
           try {
             const mod = await import(p);
@@ -1255,8 +1452,8 @@ async function loadExternal(ctx, dir, root) {
               const m = ctx.dashboard.get(ent.name);
               if (m && m.mode === ent.name) {
                 const patch = { external: true };
-                const webDir = path8.join(dir, ent.name, "web");
-                if (await pathExists(path8.join(webDir, "index.html"))) {
+                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}/`;
                 }
@@ -1275,15 +1472,36 @@ async function loadExternal(ctx, dir, root) {
 }
 async function main() {
   const args = parseArgs();
-  const root = path8.resolve(args.dir);
-  const appDir = path8.resolve(__dirname2, "web");
+  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 });
+  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 },
@@ -1299,8 +1517,17 @@ async function main() {
     }
   }
   if (args.plugins) {
-    await loadExternal(ctx, path8.resolve(args.plugins), root);
+    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) => {