zdashboard 2.2.0 → 2.3.1

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path10 from "path";
+import path11 from "path";
 import fs11 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { access, readdir } from "fs/promises";
+import { parseArgs as utilParseArgs } from "util";
 
 // src/server/detect.ts
 import fs2 from "fs";
@@ -14,6 +15,7 @@ import { execFile } from "child_process";
 // src/server/bugs.ts
 import fs from "fs";
 import path from "path";
+import YAML from "yaml";
 
 // src/server/api/fetch.ts
 import ky from "ky";
@@ -61,20 +63,23 @@ function loadConfig(root) {
   for (const rel of BUGS_CONFIG_CANDIDATES) {
     const file = path.join(root, rel);
     if (!fs.existsSync(file)) continue;
-    const kv = {};
-    for (const line of fs.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, "");
+    try {
+      const kv = YAML.parse(fs.readFileSync(file, "utf8"));
+      if (!kv || typeof kv !== "object") return null;
+      const record = kv;
+      const product = Number(record.product);
+      if (!record.url || !product) return null;
+      const str = (v) => typeof v === "string" ? v : v == null ? void 0 : String(v);
+      return {
+        url: String(record.url).replace(/\/+$/, ""),
+        account: str(record.account) ?? "",
+        password: str(record.password),
+        token: str(record.token),
+        product
+      };
+    } catch {
+      return null;
     }
-    const product = Number(kv.product);
-    if (!kv.url || !product) return null;
-    return {
-      url: kv.url.replace(/\/+$/, ""),
-      account: kv.account ?? "",
-      password: kv.password,
-      token: kv.token,
-      product
-    };
   }
   return null;
 }
@@ -162,7 +167,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "zdashboard",
-  version: "2.2.0",
+  version: "2.3.1",
   description: "ZCode skill dashboard platform \u2014 pluggable viewers for zdesign/zview/zreview/zgoal",
   type: "module",
   bin: {
@@ -344,13 +349,18 @@ async function stopInstance(record) {
 }
 
 // src/core/open-url.ts
-import { exec } from "child_process";
+import { exec, execFile as execFile2 } from "child_process";
 function openUrl(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  exec(`${cmd} ${url}`);
+  if (process.platform === "win32") {
+    exec(`start "" "${url}"`);
+  } else {
+    execFile2(cmd, [url]);
+  }
 }
 
 // src/core/server.ts
+import { execFile as execFile3 } from "child_process";
 var VERSION = package_default.version;
 var __dirname = path4.dirname(fileURLToPath(import.meta.url));
 var MIME = {
@@ -367,6 +377,7 @@ var MIME = {
   ".jpeg": "image/jpeg",
   ".gif": "image/gif",
   ".webp": "image/webp",
+  ".avif": "image/avif",
   ".md": "text/markdown; charset=utf-8",
   ".txt": "text/plain; charset=utf-8",
   ".sql": "text/plain; charset=utf-8",
@@ -396,6 +407,11 @@ var MIME = {
   ".env": "text/plain; charset=utf-8",
   ".gitignore": "text/plain; charset=utf-8",
   ".dockerfile": "text/plain; charset=utf-8",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".m4a": "audio/mp4",
+  ".aac": "audio/aac",
   ".woff": "font/woff",
   ".woff2": "font/woff2",
   ".ttf": "font/woff",
@@ -427,9 +443,10 @@ var ServerService = class extends Service {
     this.dataDir = config.dataDir;
     this.onListen = config.onListen;
     ctx.effect(() => () => this.dispose());
+    this.refreshGitInfo();
     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 }));
+      res.end(JSON.stringify({ stopToken: this.stopToken, version: VERSION, root: this.root, ...this.gitInfo }));
     });
     this.route("/__stop", async (req, res) => {
       if (req.headers["x-stop-token"] !== this.stopToken) {
@@ -443,36 +460,74 @@ var ServerService = class extends Service {
     });
     this.start(config.port);
   }
-  route(path11, handler) {
-    this.routes.set(path11, handler);
-    this.ctx.effect(() => () => this.routes.delete(path11));
+  route(path12, handler) {
+    this.routes.set(path12, handler);
+    this.ctx.effect(() => () => this.routes.delete(path12));
   }
-  sse(path11, onConnect) {
-    this.sses.set(path11, onConnect);
-    this.ctx.effect(() => () => this.sses.delete(path11));
+  sse(path12, onConnect) {
+    this.sses.set(path12, onConnect);
+    this.ctx.effect(() => () => this.sses.delete(path12));
   }
   static(prefix, dir) {
     this.prefixStatic.set(prefix, dir);
     this.ctx.effect(() => () => this.prefixStatic.delete(prefix));
   }
-  serveFile(filePath, res, injectHtml) {
-    fs4.readFile(filePath, (err, data) => {
+  serveFile(filePath, req, res, injectHtml) {
+    fs4.stat(filePath, (err, stat) => {
       if (err) {
         res.writeHead(404);
         return res.end("Not found");
       }
       const ext = path4.extname(filePath).toLowerCase();
       const ct = MIME[ext] ?? "application/octet-stream";
-      let body = data;
-      if (injectHtml && ext === ".html") {
-        const s = data.toString("utf8");
-        body = Buffer.from(s.indexOf("</body>") >= 0 ? s.replace("</body>", INJECT + "</body>") : s + INJECT);
+      const rangeHeader = req.headers["range"];
+      let range = null;
+      if (rangeHeader) {
+        const m = rangeHeader.match(/^bytes=(\d+)-(\d*)$/);
+        if (m) {
+          const start = Number(m[1]);
+          const end = m[2] !== "" ? Number(m[2]) : stat.size - 1;
+          if (!Number.isNaN(start) && !Number.isNaN(end) && start <= end && start < stat.size) {
+            range = { start, end: Math.min(end, stat.size - 1) };
+          }
+        }
       }
-      res.writeHead(200, { "Content-Type": ct, "Cache-Control": "no-cache" });
-      res.end(body);
+      if (range) {
+        const { start, end } = range;
+        const chunkSize = end - start + 1;
+        res.writeHead(206, {
+          "Content-Type": ct,
+          "Content-Length": String(chunkSize),
+          "Content-Range": `bytes ${start}-${end}/${stat.size}`,
+          "Accept-Ranges": "bytes",
+          "Cache-Control": "no-cache"
+        });
+        const stream = fs4.createReadStream(filePath, { start, end });
+        stream.on("error", () => {
+          try {
+            res.destroy();
+          } catch {
+          }
+        });
+        stream.pipe(res);
+        return;
+      }
+      fs4.readFile(filePath, (err2, data) => {
+        if (err2) {
+          res.writeHead(404);
+          return res.end("Not found");
+        }
+        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, "Accept-Ranges": "bytes", "Cache-Control": "no-cache" });
+        res.end(body);
+      });
     });
   }
-  servePrefix(url, res) {
+  servePrefix(url, req, res) {
     for (const [prefix, dir] of this.prefixStatic) {
       if (url.indexOf(prefix) === 0) {
         let rel = this.safeDecode(url.slice(prefix.length));
@@ -480,9 +535,10 @@ var ServerService = class extends Service {
         const fp = path4.join(dir, rel);
         if (fp.indexOf(dir + path4.sep) !== 0) {
           res.writeHead(403);
-          return res.end("Forbidden");
+          res.end("Forbidden");
+          return false;
         }
-        this.serveFile(fp, res, true);
+        this.serveFile(fp, req, res, true);
         return true;
       }
     }
@@ -514,7 +570,7 @@ var ServerService = class extends Service {
         });
         return;
       }
-      if (this.servePrefix(url, res)) return;
+      if (this.servePrefix(url, req, res)) return;
       if (url === "/" || url.indexOf("/__app/") === 0 || url.indexOf("/assets/") === 0) {
         let fp2 = this.appDir;
         if (url !== "/") fp2 = path4.join(this.appDir, this.safeDecode(url));
@@ -524,14 +580,14 @@ var ServerService = class extends Service {
           return res.end("Forbidden");
         }
         if (url === "/") fp2 = path4.join(this.appDir, "index.html");
-        return this.serveFile(fp2, res, false);
+        return this.serveFile(fp2, req, res, false);
       }
       const fp = path4.join(this.root, this.safeDecode(url));
       if (fp !== this.root && fp.indexOf(this.root + path4.sep) !== 0) {
         res.writeHead(403);
         return res.end("Forbidden");
       }
-      return this.serveFile(fp, res, true);
+      return this.serveFile(fp, req, res, true);
     } catch (e) {
       try {
         res.writeHead(400);
@@ -562,6 +618,21 @@ var ServerService = class extends Service {
       this.onListen?.(port);
     });
   }
+  /** 项目 git 信息(分支/脏文件数),启动探测一次,文件变更时刷新 */
+  gitInfo = {};
+  refreshGitInfo() {
+    const run = (args) => new Promise((resolve) => {
+      execFile3("git", args, { cwd: this.root, timeout: 3e3 }, (err, stdout) => resolve(err ? "" : stdout));
+    });
+    void (async () => {
+      const [branch, status] = await Promise.all([
+        run(["rev-parse", "--abbrev-ref", "HEAD"]),
+        run(["status", "--porcelain"])
+      ]);
+      const b = branch.trim();
+      this.gitInfo = b ? { branch: b, dirty: status ? status.split("\n").filter(Boolean).length : 0 } : {};
+    })();
+  }
   stop() {
     if (this.server) {
       try {
@@ -615,6 +686,7 @@ var ReloadService = class extends Service2 {
       this.watcher = fs5.watch(config.root, { recursive: true }, () => {
         if (this.timer) clearTimeout(this.timer);
         this.timer = setTimeout(() => {
+          this.ctx.server.refreshGitInfo();
           this.broadcast("reload");
           this.broadcast("files");
         }, WATCH_DEBOUNCE_MS);
@@ -655,73 +727,128 @@ data: ${JSON.stringify(data == null ? "" : data)}
 };
 
 // src/server/spec-scan.ts
+import fs7 from "fs";
+import path6 from "path";
+
+// src/server/walk.ts
 import fs6 from "fs";
 import path5 from "path";
-function walkFiles(absDir, relDir, depth = 0) {
-  if (depth > 4) return [];
-  let ents;
-  try {
-    ents = fs6.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(path5.join(absDir, ent.name), rel, depth + 1) });
-    } else {
-      nodes.push({ name: ent.name, kind: "file", path: rel });
+function walkDir(root, opts = {}) {
+  const { skip = /* @__PURE__ */ new Set(), maxDepth, onFile, onDir } = opts;
+  function walk(dir, rel, depth) {
+    if (typeof maxDepth === "number" && depth > maxDepth) return;
+    let ents;
+    try {
+      ents = fs6.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of ents) {
+      if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
+      const abs = path5.join(dir, ent.name);
+      const r = rel ? `${rel}/${ent.name}` : ent.name;
+      if (ent.isDirectory()) {
+        onDir?.(abs, r);
+        walk(abs, r, depth + 1);
+      } else if (onFile) {
+        onFile(abs, r);
+      }
+    }
+  }
+  walk(root, "", 0);
+}
+
+// src/server/spec-scan.ts
+function buildTree(paths) {
+  const root = [];
+  const map = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const parts = p.split("/");
+    let current = "";
+    let parent = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      current = current ? `${current}/${part}` : part;
+      const isLast = i === parts.length - 1;
+      if (!map.has(current)) {
+        const node = {
+          name: part,
+          kind: isLast ? "file" : "dir",
+          ...isLast ? { path: p } : { children: [] }
+        };
+        map.set(current, node);
+        parent.push(node);
+      }
+      if (!isLast) {
+        parent = map.get(current).children;
+      }
     }
   }
-  nodes.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1);
-  return nodes;
+  const sortNodes = (nodes) => {
+    nodes.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1);
+    for (const n of nodes) {
+      if (n.children) sortNodes(n.children);
+    }
+  };
+  sortNodes(root);
+  return root;
 }
 function scanTree(root, hasOpenspec, hasDocs) {
   const tree = [];
-  if (hasOpenspec && fs6.existsSync(path5.join(root, "openspec", "changes"))) {
-    const changesDir = path5.join(root, "openspec", "changes");
+  if (hasOpenspec && fs7.existsSync(path6.join(root, "openspec", "changes"))) {
+    const changesDir = path6.join(root, "openspec", "changes");
     const active = [];
     const archived = [];
-    for (const ent of fs6.readdirSync(changesDir, { withFileTypes: true })) {
+    for (const ent of fs7.readdirSync(changesDir, { withFileTypes: true })) {
       if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
-      active.push({ name: ent.name, kind: "dir", children: walkFiles(path5.join(changesDir, ent.name), `openspec/changes/${ent.name}`) });
+      const relBase = `openspec/changes/${ent.name}`;
+      const paths = [];
+      walkDir(path6.join(changesDir, ent.name), { maxDepth: 4, onFile: (_, rel) => paths.push(rel ? `${relBase}/${rel}` : relBase) });
+      const children = buildTree(paths).map((n) => ({ ...n, path: n.path ? `${relBase}/${n.path}` : void 0 }));
+      active.push({ name: ent.name, kind: "dir", children });
     }
     active.sort((a, b) => a.name.localeCompare(b.name));
-    const archiveDir = path5.join(changesDir, "archive");
-    if (fs6.existsSync(archiveDir)) {
-      for (const ent of fs6.readdirSync(archiveDir, { withFileTypes: true })) {
+    const archiveDir = path6.join(changesDir, "archive");
+    if (fs7.existsSync(archiveDir)) {
+      for (const ent of fs7.readdirSync(archiveDir, { withFileTypes: true })) {
         if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
-        archived.push({ name: ent.name, kind: "dir", children: walkFiles(path5.join(archiveDir, ent.name), `openspec/changes/archive/${ent.name}`) });
+        const relBase = `openspec/changes/archive/${ent.name}`;
+        const paths = [];
+        walkDir(path6.join(archiveDir, ent.name), { maxDepth: 4, onFile: (_, rel) => paths.push(rel ? `${relBase}/${rel}` : relBase) });
+        const children = buildTree(paths).map((n) => ({ ...n, path: n.path ? `${relBase}/${n.path}` : void 0 }));
+        archived.push({ name: ent.name, kind: "dir", children });
       }
       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 = path5.join(root, "openspec", "specs");
-    if (fs6.existsSync(specsDir)) {
-      const specs = walkFiles(specsDir, "openspec/specs");
+    if (active.length) tree.push({ name: `changes (${active.length})`, kind: "dir", children: active });
+    if (archived.length) tree.push({ name: `archive (${archived.length})`, kind: "dir", defaultCollapsed: true, children: archived });
+    const specsDir = path6.join(root, "openspec", "specs");
+    if (fs7.existsSync(specsDir)) {
+      const paths = [];
+      walkDir(specsDir, { maxDepth: 4, onFile: (_, rel) => paths.push(`openspec/specs/${rel}`) });
+      const specs = buildTree(paths).map((n) => ({ ...n, path: n.path ? `openspec/specs/${n.path}` : void 0 }));
       if (specs.length) tree.push({ name: "specs", kind: "dir", children: specs });
     }
   }
-  if (hasDocs && fs6.existsSync(path5.join(root, "docs"))) {
-    const docs = walkFiles(path5.join(root, "docs"), "docs");
+  if (hasDocs && fs7.existsSync(path6.join(root, "docs"))) {
+    const paths = [];
+    walkDir(path6.join(root, "docs"), { maxDepth: 4, onFile: (_, rel) => paths.push(`docs/${rel}`) });
+    const docs = buildTree(paths).map((n) => ({ ...n, path: n.path ? `docs/${n.path}` : void 0 }));
     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 fs6.readdirSync(root, { withFileTypes: true })) {
+    for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
       if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
-      const ext = path5.extname(ent.name).toLowerCase();
+      const ext = path6.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 });
+  if (etc.length) tree.push({ name: `other (${etc.length})`, kind: "dir", children: etc });
   return tree;
 }
 
@@ -755,12 +882,12 @@ var apply = {
 };
 
 // src/core/worktrees.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 var GIT_TIMEOUT_MS = 5e3;
 var ZWORKTREE_SEGMENT = ".zworktree/";
 function runGit(args, cwd) {
   return new Promise((resolve) => {
-    execFile2("git", args, { cwd, timeout: GIT_TIMEOUT_MS }, (err, stdout) => {
+    execFile4("git", args, { cwd, timeout: GIT_TIMEOUT_MS }, (err, stdout) => {
       if (err) return resolve("");
       resolve(stdout);
     });
@@ -858,7 +985,7 @@ var DashboardService = class extends Service3 {
 };
 
 // src/server/just-runner.ts
-import { spawn, execFile as execFile3 } from "child_process";
+import { spawn, execFile as execFile5 } from "child_process";
 var MAX_BUFFER = 1e3;
 var JustRunner = class {
   cwd;
@@ -871,7 +998,7 @@ var JustRunner = class {
   recipes() {
     if (this.recipesCache) return Promise.resolve(this.recipesCache);
     return new Promise((resolve) => {
-      execFile3("just", ["--list", "--unsorted"], { cwd: this.cwd, maxBuffer: 1 << 20, timeout: 8e3 }, (err, stdout) => {
+      execFile5("just", ["--list", "--unsorted"], { cwd: this.cwd, maxBuffer: 1 << 20, timeout: 8e3 }, (err, stdout) => {
         if (err) {
           resolve([]);
           return;
@@ -996,6 +1123,18 @@ var JustRunner = class {
   }
 };
 
+// src/core/read-body.ts
+async function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", () => resolve(""));
+  });
+}
+
 // src/plugins/just/index.ts
 var apply3 = {
   inject: ["server", "dashboard"],
@@ -1077,16 +1216,6 @@ var apply3 = {
     });
   }
 };
-async function readBody(req) {
-  return new Promise((resolve) => {
-    let data = "";
-    req.on("data", (c) => {
-      data += c;
-    });
-    req.on("end", () => resolve(data));
-    req.on("error", () => resolve(""));
-  });
-}
 
 // src/plugins/bugs/index.ts
 var apply4 = {
@@ -1110,9 +1239,9 @@ var apply4 = {
 };
 
 // src/server/review-store.ts
-import fs7 from "fs";
-import path6 from "path";
-import YAML from "yaml";
+import fs8 from "fs";
+import path7 from "path";
+import YAML2 from "yaml";
 var REVIEW_CANDIDATES = [".zdev/review.yaml", "review.yaml"];
 var ReviewStore = class {
   root;
@@ -1121,15 +1250,15 @@ var ReviewStore = class {
   constructor(root, onChange) {
     this.root = root;
     this.onChange = onChange;
-    const existing = REVIEW_CANDIDATES.find((rel) => fs7.existsSync(path6.join(root, rel)));
-    this.file = path6.join(root, existing ?? REVIEW_CANDIDATES[0]);
+    const existing = REVIEW_CANDIDATES.find((rel) => fs8.existsSync(path7.join(root, rel)));
+    this.file = path7.join(root, existing ?? REVIEW_CANDIDATES[0]);
   }
   exists() {
-    return fs7.existsSync(this.file);
+    return fs8.existsSync(this.file);
   }
   read() {
     try {
-      const parsed = YAML.parse(fs7.readFileSync(this.file, "utf8"));
+      const parsed = YAML2.parse(fs8.readFileSync(this.file, "utf8"));
       if (!parsed || !Array.isArray(parsed.items)) return { status: "draft", items: [] };
       return parsed;
     } catch {
@@ -1137,8 +1266,8 @@ var ReviewStore = class {
     }
   }
   write(data) {
-    fs7.mkdirSync(path6.dirname(this.file), { recursive: true });
-    fs7.writeFileSync(this.file, YAML.stringify(data), "utf8");
+    fs8.mkdirSync(path7.dirname(this.file), { recursive: true });
+    fs8.writeFileSync(this.file, YAML2.stringify(data), "utf8");
     this.onChange?.();
   }
   updateItem(id, patch) {
@@ -1162,9 +1291,9 @@ var ReviewStore = class {
   }
   docs() {
     try {
-      const zdevDir = path6.join(this.root, ".zdev");
-      if (!fs7.existsSync(zdevDir) || !fs7.statSync(zdevDir).isDirectory()) return [];
-      return fs7.readdirSync(zdevDir).filter((f) => /\.(md|markdown)$/i.test(f) && fs7.statSync(path6.join(zdevDir, f)).isFile()).sort();
+      const zdevDir = path7.join(this.root, ".zdev");
+      if (!fs8.existsSync(zdevDir) || !fs8.statSync(zdevDir).isDirectory()) return [];
+      return fs8.readdirSync(zdevDir).filter((f) => /\.(md|markdown)$/i.test(f) && fs8.statSync(path7.join(zdevDir, f)).isFile()).sort();
     } catch {
       return [];
     }
@@ -1193,7 +1322,7 @@ var apply5 = {
           return;
         }
         try {
-          const body = JSON.parse(await readBody2(req) || "{}");
+          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", "Cache-Control": "no-cache" });
           res.end(JSON.stringify(data));
@@ -1209,7 +1338,7 @@ var apply5 = {
           return;
         }
         try {
-          const body = JSON.parse(await readBody2(req) || "{}");
+          const body = JSON.parse(await readBody(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));
@@ -1225,36 +1354,37 @@ var apply5 = {
     });
   }
 };
-async function readBody2(req) {
-  return new Promise((resolve) => {
-    let data = "";
-    req.on("data", (c) => {
-      data += c;
-    });
-    req.on("end", () => resolve(data));
-  });
-}
 
 // src/plugins/apply/scan.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
+
+// src/plugins/apply/parse-tasks.ts
+var TASK_RE = /^\s*-\s*\[([ xX])\]\s*(.*)$/;
+function parseTasks(md) {
+  return md.split("\n").filter((l) => TASK_RE.test(l)).map((l) => {
+    const m = l.match(TASK_RE);
+    return { text: (m?.[2] ?? l).trim(), checked: m?.[1] !== " " };
+  });
+}
 function countTasks(md) {
-  const all = (md.match(/^\s*-\s*\[[ xX]\]\s*/gm) || []).length;
-  const done = (md.match(/^\s*-\s*\[[xX]\]\s*/gm) || []).length;
-  return { total: all, done };
+  const tasks = parseTasks(md);
+  return { total: tasks.length, done: tasks.filter((t) => t.checked).length };
 }
+
+// src/plugins/apply/scan.ts
 function readText(p) {
   try {
-    return fs8.readFileSync(p, "utf8");
+    return fs9.readFileSync(p, "utf8");
   } catch {
     return "";
   }
 }
 function worktreeDir(root, name) {
-  return path7.join(root, ".zworktree", name);
+  return path8.join(root, ".zworktree", name);
 }
 function changeDir(root, name) {
-  return path7.join(root, "openspec", "changes", name);
+  return path8.join(root, "openspec", "changes", name);
 }
 function parseDependsOn(proposal) {
   const deps = [];
@@ -1268,42 +1398,42 @@ function parseDependsOn(proposal) {
   return deps;
 }
 function scanApplyChanges(root) {
-  const changesDir = path7.join(root, "openspec", "changes");
-  if (!fs8.existsSync(changesDir)) return [];
+  const changesDir = path8.join(root, "openspec", "changes");
+  if (!fs9.existsSync(changesDir)) return [];
   const out = [];
-  for (const ent of fs8.readdirSync(changesDir, { withFileTypes: true })) {
+  for (const ent of fs9.readdirSync(changesDir, { withFileTypes: true })) {
     if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
     const wt = worktreeDir(root, ent.name);
-    const tasks = readText(path7.join(wt, "openspec", "changes", ent.name, "tasks.md"));
+    const tasks = readText(path8.join(wt, "openspec", "changes", ent.name, "tasks.md"));
     if (!tasks) {
-      const fallback = readText(path7.join(changesDir, ent.name, "tasks.md"));
+      const fallback = readText(path8.join(changesDir, ent.name, "tasks.md"));
       if (fallback) {
         const { total, done } = countTasks(fallback);
-        const wtChange = path7.join(wt, "openspec", "changes", ent.name);
-        const mainChange = path7.join(changesDir, ent.name);
+        const wtChange = path8.join(wt, "openspec", "changes", ent.name);
+        const mainChange = path8.join(changesDir, ent.name);
         out.push({
           name: ent.name,
           path: `openspec/changes/${ent.name}`,
           total,
           done,
-          hasProposal: fs8.existsSync(path7.join(wtChange, "proposal.md")) || fs8.existsSync(path7.join(mainChange, "proposal.md")),
-          hasDesign: fs8.existsSync(path7.join(wtChange, "design.md")) || fs8.existsSync(path7.join(mainChange, "design.md")),
+          hasProposal: fs9.existsSync(path8.join(wtChange, "proposal.md")) || fs9.existsSync(path8.join(mainChange, "proposal.md")),
+          hasDesign: fs9.existsSync(path8.join(wtChange, "design.md")) || fs9.existsSync(path8.join(mainChange, "design.md")),
           // worktree 目录存在即算执行中（tasks.md 可能尚未落盘）
-          inWorktree: fs8.existsSync(wtChange)
+          inWorktree: fs9.existsSync(wtChange)
         });
       }
     } else {
       const { total, done } = countTasks(tasks);
-      const wtChange = path7.join(wt, "openspec", "changes", ent.name);
-      const mainChange = path7.join(changesDir, ent.name);
+      const wtChange = path8.join(wt, "openspec", "changes", ent.name);
+      const mainChange = path8.join(changesDir, ent.name);
       out.push({
         name: ent.name,
         path: `openspec/changes/${ent.name}`,
         total,
         done,
         // 任一侧存在即算（详情读取是 worktree 优先、主目录兜底，列表标记保持一致）
-        hasProposal: fs8.existsSync(path7.join(wtChange, "proposal.md")) || fs8.existsSync(path7.join(mainChange, "proposal.md")),
-        hasDesign: fs8.existsSync(path7.join(wtChange, "design.md")) || fs8.existsSync(path7.join(mainChange, "design.md")),
+        hasProposal: fs9.existsSync(path8.join(wtChange, "proposal.md")) || fs9.existsSync(path8.join(mainChange, "proposal.md")),
+        hasDesign: fs9.existsSync(path8.join(wtChange, "design.md")) || fs9.existsSync(path8.join(mainChange, "design.md")),
         inWorktree: true
       });
     }
@@ -1314,14 +1444,14 @@ function scanApplyChanges(root) {
 function readApplyChange(root, name) {
   const wt = worktreeDir(root, name);
   const mainChangeDir = changeDir(root, name);
-  const proposalFrom = fs8.existsSync(path7.join(wt, "openspec", "changes", name, "proposal.md")) ? path7.join(wt, "openspec", "changes", name, "proposal.md") : path7.join(mainChangeDir, "proposal.md");
-  const designFrom = fs8.existsSync(path7.join(wt, "openspec", "changes", name, "design.md")) ? path7.join(wt, "openspec", "changes", name, "design.md") : path7.join(mainChangeDir, "design.md");
-  const tasksFrom = fs8.existsSync(path7.join(wt, "openspec", "changes", name, "tasks.md")) ? path7.join(wt, "openspec", "changes", name, "tasks.md") : path7.join(mainChangeDir, "tasks.md");
+  const proposalFrom = fs9.existsSync(path8.join(wt, "openspec", "changes", name, "proposal.md")) ? path8.join(wt, "openspec", "changes", name, "proposal.md") : path8.join(mainChangeDir, "proposal.md");
+  const designFrom = fs9.existsSync(path8.join(wt, "openspec", "changes", name, "design.md")) ? path8.join(wt, "openspec", "changes", name, "design.md") : path8.join(mainChangeDir, "design.md");
+  const tasksFrom = fs9.existsSync(path8.join(wt, "openspec", "changes", name, "tasks.md")) ? path8.join(wt, "openspec", "changes", name, "tasks.md") : path8.join(mainChangeDir, "tasks.md");
   const proposal = readText(proposalFrom);
   const design = readText(designFrom);
   const tasks = readText(tasksFrom);
   const { total, done } = countTasks(tasks);
-  const inWorktree = fs8.existsSync(path7.join(wt, "openspec", "changes", name));
+  const inWorktree = fs9.existsSync(path8.join(wt, "openspec", "changes", name));
   const dependsOn = parseDependsOn(proposal);
   const hasTestStrategy = /^##\s+测试策略\s*$/m.test(design);
   return {
@@ -1379,13 +1509,12 @@ var apply6 = {
 };
 
 // src/server/design-assets.ts
-import fs9 from "fs";
-import path8 from "path";
+import path9 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 CODE_EXTS = [".js", ".mjs", ".cjs", ".mts", ".cts", ".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) {
@@ -1408,26 +1537,11 @@ function scanAssets(root) {
   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, "");
+  walkDir(root, { skip: SKIP, onFile: (abs, rel) => {
+    const ext = path9.extname(abs).toLowerCase();
+    const t = categorize(rel, ext);
+    if (t) out[t].push({ path: rel, name: path9.basename(abs), ext, type: t });
+  } });
   return out;
 }
 
@@ -1457,53 +1571,42 @@ var apply8 = {
 
 // src/plugins/stats/index.ts
 import fs10 from "fs";
-import path9 from "path";
+import path10 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".cache"]);
 function scan(root) {
   const stats = {
-    root: path9.basename(root),
+    root: path10.basename(root),
     files: 0,
     dirs: 0,
     totalSize: 0,
     byExt: [],
     markdown: 0,
     openspec: { active: 0, archived: 0 },
-    hasJust: fs10.existsSync(path9.join(root, "justfile"))
+    hasJust: fs10.existsSync(path10.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;
-      }
+    walkDir(dir, { skip: SKIP_DIRS, onDir: () => {
+      stats.dirs++;
+    }, onFile: (abs) => {
       stats.files++;
       try {
         stats.totalSize += fs10.statSync(abs).size;
       } catch {
       }
-      const ext = path9.extname(ent.name).toLowerCase() || "(\u65E0\u6269\u5C55\u540D)";
+      const ext = path10.extname(abs).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");
+  const changesDir = path10.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;
+          stats.openspec.archived = fs10.readdirSync(path10.join(changesDir, "archive"), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
         } catch {
         }
       } else stats.openspec.active++;
@@ -1534,34 +1637,31 @@ var apply9 = {
 };
 
 // src/cli.ts
-var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
 var DEFAULT_PORT = 4190;
 function parseArgs() {
   const args = process.argv.slice(2);
-  const opts = {};
-  let portExplicit = false;
-  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;
-      }
-      if (key === "port") portExplicit = true;
-    }
-  }
+  const { values } = utilParseArgs({
+    options: {
+      dir: { type: "string" },
+      port: { type: "string" },
+      open: { type: "boolean", default: false },
+      page: { type: "string" },
+      restart: { type: "boolean", default: false },
+      plugins: { type: "string" }
+    },
+    args,
+    strict: false,
+    allowPositionals: false
+  });
   return {
-    dir: typeof opts.dir === "string" ? opts.dir : process.cwd(),
-    port: typeof opts.port === "string" ? Number(opts.port) : DEFAULT_PORT,
-    portExplicit,
-    open: !!opts.open,
-    page: typeof opts.page === "string" ? opts.page : null,
-    restart: !!opts.restart,
-    plugins: typeof opts.plugins === "string" ? opts.plugins : null
+    dir: typeof values.dir === "string" ? values.dir : process.cwd(),
+    port: typeof values.port === "string" ? Number(values.port) : DEFAULT_PORT,
+    portExplicit: args.some((a) => a === "--port" || a.startsWith("--port=")),
+    open: !!values.open,
+    page: typeof values.page === "string" ? values.page : null,
+    restart: !!values.restart,
+    plugins: typeof values.plugins === "string" ? values.plugins : null
   };
 }
 async function pathExists(p) {
@@ -1587,7 +1687,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 = path10.join(dir, ent.name, name);
+        const p = path11.join(dir, ent.name, name);
         if (await pathExists(p)) {
           try {
             const mod = await import(p);
@@ -1602,8 +1702,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 = path10.join(dir, ent.name, "web");
-                if (await pathExists(path10.join(webDir, "index.html"))) {
+                const webDir = path11.join(dir, ent.name, "web");
+                if (await pathExists(path11.join(webDir, "index.html"))) {
                   ctx.server.static(`${PLUGIN_STATIC_PREFIX}${ent.name}/`, webDir);
                   if (!m.viewerUrl) patch.viewerUrl = `${PLUGIN_STATIC_PREFIX}${ent.name}/`;
                 }
@@ -1622,7 +1722,7 @@ async function loadExternal(ctx, dir, root) {
 }
 async function main() {
   const args = parseArgs();
-  const root = path10.resolve(args.dir);
+  const root = path11.resolve(args.dir);
   const existing = await findReusable(root);
   if (existing && !args.restart) {
     const u = `http://localhost:${existing.port}` + (args.page ? `#${args.page}` : "");
@@ -1636,9 +1736,9 @@ async function main() {
     console.log(`[zdashboard] --restart\uFF1A\u505C\u6B62\u65E7\u5B9E\u4F8B pid=${oldRecord.pid}`);
     await stopInstance(oldRecord);
   }
-  const appDir = path10.resolve(__dirname2, "web");
+  const appDir = path11.resolve(__dirname2, "web");
   const startPort = oldRecord && !args.portExplicit ? oldRecord.port : args.port;
-  const zdevDir = path10.join(root, ".zdev");
+  const zdevDir = path11.join(root, ".zdev");
   const dataDir = fs11.existsSync(zdevDir) ? ".zdev/" : "";
   const det = await detect(root);
   const ctx = new Context();
@@ -1673,7 +1773,7 @@ async function main() {
     }
   }
   if (args.plugins) {
-    await loadExternal(ctx, path10.resolve(args.plugins), root);
+    await loadExternal(ctx, path11.resolve(args.plugins), root);
   }
   const shutdown = () => {
     try {