@dazitech/cli 3.0.6 → 3.0.8

package/dist/clis/dazi.js

@@ -966,8 +966,8 @@ var require_command = __commonJS({
   "node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess2 = require("node:child_process");
-    var path13 = require("node:path");
-    var fs16 = require("node:fs");
+    var path15 = require("node:path");
+    var fs18 = require("node:fs");
     var process8 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1899,11 +1899,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path13.resolve(baseDir, baseName);
-          if (fs16.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path13.extname(baseName))) return void 0;
+          const localBin = path15.resolve(baseDir, baseName);
+          if (fs18.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path15.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs16.existsSync(`${localBin}${ext}`)
+            (ext) => fs18.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1915,21 +1915,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs16.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
           } catch (err2) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path13.resolve(
-            path13.dirname(resolvedScriptPath),
+          executableDir = path15.resolve(
+            path15.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path13.basename(
+            const legacyName = path15.basename(
               this._scriptPath,
-              path13.extname(this._scriptPath)
+              path15.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1940,7 +1940,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path13.extname(executableFile));
+        launchWithNode = sourceExt.includes(path15.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2780,7 +2780,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path13.basename(filename, path13.extname(filename));
+        this._name = path15.basename(filename, path15.extname(filename));
         return this;
       }
       /**
@@ -2794,9 +2794,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path14) {
-        if (path14 === void 0) return this._executableDir;
-        this._executableDir = path14;
+      executableDir(path16) {
+        if (path16 === void 0) return this._executableDir;
+        this._executableDir = path16;
         return this;
       }
       /**
@@ -3726,11 +3726,11 @@ function buildHttpErrorMessage(ctx, detail) {
   ].filter(Boolean);
   return parts.join(" \u2014 ");
 }
-async function apiRequest(path13, opts = {}) {
+async function apiRequest(path15, opts = {}) {
   const auth = opts.token || opts.serverUrl ? { token: opts.token ?? "", serverUrl: opts.serverUrl ?? "" } : loadAuth();
   const method = (opts.method ?? "GET").toUpperCase();
   const serverBase = auth.serverUrl.replace(/\/$/, "");
-  const url = `${serverBase}${path13}`;
+  const url = `${serverBase}${path15}`;
   const headers = {
     "Content-Type": "application/json",
     Authorization: `Bearer ${auth.token}`,
@@ -3764,7 +3764,7 @@ async function apiRequest(path13, opts = {}) {
     }
     const ctx = {
       method,
-      path: path13,
+      path: path15,
       url,
       status: res.status,
       label: opts.label,
@@ -3852,12 +3852,83 @@ function resolveWorkspace(cwd = process.cwd()) {
 }
 
 // cli/shared/src/version.ts
-var DAZI_VERSION = true ? "3.0.6" : readDevVersion();
+var DAZI_VERSION = true ? "3.0.8" : readDevVersion();
+
+// cli/shared/src/ontoWorkspaceAudit.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var WORKSPACE_PROJECTS_DIR = "\u9879\u76EE";
+var ONTO_SUBDIR = "\u672C\u4F53";
+var ONTO_ITEMS_DIR = "ontos";
+var PLANS_DIR = "plans";
+var LEGACY_PLANS_DIR = "\u89C4\u5212";
+var LEGACY_SCRIPT_DIR = "\u811A\u672C";
+function existsDir(p) {
+  try {
+    return import_fs3.default.existsSync(p) && import_fs3.default.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function scanOntoLegacyPaths(wsRoot) {
+  const findings = [];
+  const projectsDir = import_path4.default.join(wsRoot, WORKSPACE_PROJECTS_DIR);
+  if (!existsDir(projectsDir)) return findings;
+  for (const ent of import_fs3.default.readdirSync(projectsDir, { withFileTypes: true })) {
+    if (!ent.isDirectory()) continue;
+    const projectDir = import_path4.default.join(projectsDir, ent.name);
+    const relProject = `${WORKSPACE_PROJECTS_DIR}/${ent.name}`;
+    if (/^onto_/i.test(ent.name)) {
+      findings.push({
+        kind: "onto_prefix_project",
+        path: projectDir,
+        message: `\u65E7\u7248\u672C\u4F53\u9879\u76EE\u524D\u7F00\u76EE\u5F55\u300C${relProject}\u300D\u3002\u8BF7\u624B\u52A8\u8FC1\u5165\u300C${WORKSPACE_PROJECTS_DIR}/<\u4E1A\u52A1\u540D>/${ONTO_SUBDIR}/${ONTO_ITEMS_DIR}/<\u5B9E\u73B0\u540D>/\u300D\u3002`
+      });
+    }
+    if (existsDir(import_path4.default.join(projectDir, LEGACY_PLANS_DIR)) || existsDir(import_path4.default.join(projectDir, LEGACY_SCRIPT_DIR))) {
+      findings.push({
+        kind: "legacy_plan_or_script",
+        path: projectDir,
+        message: `\u300C${relProject}\u300D\u542B\u65E7\u76EE\u5F55\u300C${LEGACY_PLANS_DIR}/\u300D\u6216\u300C${LEGACY_SCRIPT_DIR}/\u300D\u3002\u89C4\u5212\u8FC1\u81F3 ${ONTO_SUBDIR}/${ONTO_ITEMS_DIR}/<\u5B9E\u73B0\u540D>/${PLANS_DIR}/\uFF0C\u811A\u672C\u8FC1\u81F3 setup/\u3001functions/\u3002`
+      });
+    }
+    const ontoRoot = import_path4.default.join(projectDir, ONTO_SUBDIR);
+    if (existsDir(import_path4.default.join(ontoRoot, PLANS_DIR))) {
+      findings.push({
+        kind: "onto_root_plans",
+        path: import_path4.default.join(ontoRoot, PLANS_DIR),
+        message: `\u300C${relProject}/${ONTO_SUBDIR}/${PLANS_DIR}/\u300D\u4E3A\u65E7\u811A\u624B\u67B6\u4F4D\u7F6E\u3002\u89C4\u5212\u76EE\u5F55\u5E94\u5728\u300C${ONTO_SUBDIR}/${ONTO_ITEMS_DIR}/<\u5B9E\u73B0\u540D>/${PLANS_DIR}/\u300D\u3002`
+      });
+    }
+    const itemsDir = import_path4.default.join(ontoRoot, ONTO_ITEMS_DIR);
+    if (!existsDir(itemsDir)) continue;
+    for (const item of import_fs3.default.readdirSync(itemsDir, { withFileTypes: true })) {
+      if (!item.isDirectory()) continue;
+      const itemDir = import_path4.default.join(itemsDir, item.name);
+      const relItem = `${relProject}/${ONTO_SUBDIR}/${ONTO_ITEMS_DIR}/${item.name}`;
+      if (existsDir(import_path4.default.join(itemDir, LEGACY_PLANS_DIR))) {
+        findings.push({
+          kind: "legacy_plan_or_script",
+          path: import_path4.default.join(itemDir, LEGACY_PLANS_DIR),
+          message: `\u300C${relItem}/${LEGACY_PLANS_DIR}/\u300D\u8BF7\u91CD\u547D\u540D\u4E3A\u300C${PLANS_DIR}/\u300D\u3002`
+        });
+      }
+      if (existsDir(import_path4.default.join(itemDir, LEGACY_SCRIPT_DIR))) {
+        findings.push({
+          kind: "legacy_plan_or_script",
+          path: import_path4.default.join(itemDir, LEGACY_SCRIPT_DIR),
+          message: `\u300C${relItem}/${LEGACY_SCRIPT_DIR}/\u300D\u8BF7\u5C06\u811A\u672C\u8FC1\u5165 setup/\u3001functions/\u3002`
+        });
+      }
+    }
+  }
+  return findings;
+}
 
 // cli/dazi/src/commands/auth.ts
 var import_os3 = __toESM(require("os"), 1);
-var import_path4 = __toESM(require("path"), 1);
-var import_fs3 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
 function makeAuthCommand() {
   const cmd = new Command("auth").description("\u8D26\u53F7\u8BA4\u8BC1");
   cmd.command("login").description("\u767B\u5F55\u642D\u5B50\u5E73\u53F0").option("-s, --server <url>", "\u5E73\u53F0\u5730\u5740", getServerUrl()).option("--token <token>", "\u76F4\u63A5\u4F7F\u7528 token \u767B\u5F55\uFF08CI / Token \u6A21\u5F0F\uFF09").option("-u, --username <username>", "\u7528\u6237\u540D\u6216\u90AE\u7BB1\uFF08\u8D26\u53F7\u5BC6\u7801\u6A21\u5F0F\uFF09").option("-p, --password <password>", "\u5BC6\u7801\uFF08\u8D26\u53F7\u5BC6\u7801\u6A21\u5F0F\uFF09").action(async (opts) => {
@@ -3942,10 +4013,10 @@ function makeAuthCommand() {
   });
   cmd.command("migrate").description("\u5C06\u65E7\u7248\u8BA4\u8BC1\u6587\u4EF6\u8FC1\u79FB\u5230 ~/.dazi/auth.json").option("--dry-run", "\u4EC5\u9884\u89C8\uFF0C\u4E0D\u5199\u5165").action(async (opts) => {
     const candidates = [];
-    const appAuth = import_path4.default.join(import_os3.default.homedir(), ".dazi-app", "auth.json");
-    if (import_fs3.default.existsSync(appAuth)) {
+    const appAuth = import_path5.default.join(import_os3.default.homedir(), ".dazi-app", "auth.json");
+    if (import_fs4.default.existsSync(appAuth)) {
       try {
-        const d = JSON.parse(import_fs3.default.readFileSync(appAuth, "utf-8"));
+        const d = JSON.parse(import_fs4.default.readFileSync(appAuth, "utf-8"));
         if (d.token) candidates.push({ src: appAuth, label: "dazi-app", data: d });
       } catch {
       }
@@ -3988,6 +4059,8 @@ function makeAuthCommand() {
 
 // cli/dazi/src/commands/doctor.ts
 var import_os4 = __toESM(require("os"), 1);
+var import_path6 = __toESM(require("path"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
 function makeDoctorCommand() {
   return new Command("doctor").description("\u68C0\u67E5\u8FD0\u884C\u73AF\u5883").action(async () => {
     const checks = [];
@@ -4007,6 +4080,25 @@ function makeDoctorCommand() {
       networkDetail = String(err2);
     }
     checks.push({ name: `\u7F51\u7EDC\u8FDE\u901A (${getServerUrl()})`, ok: networkOk, detail: networkDetail });
+    const ontoWarnings = [];
+    const projectsDir = import_path6.default.join(process.cwd(), WORKSPACE_PROJECTS_DIR);
+    if (import_fs5.default.existsSync(projectsDir)) {
+      const findings = scanOntoLegacyPaths(process.cwd());
+      if (!findings.length) {
+        checks.push({
+          name: "\u672C\u4F53\u76EE\u5F55\u7ED3\u6784",
+          ok: true,
+          detail: "\u672A\u53D1\u73B0 onto_* / \u89C4\u5212 / \u811A\u672C \u7B49\u65E7\u5E03\u5C40"
+        });
+      } else {
+        ontoWarnings.push(...findings.map((f) => f.message));
+        checks.push({
+          name: "\u672C\u4F53\u76EE\u5F55\u7ED3\u6784",
+          ok: true,
+          detail: `\u53D1\u73B0 ${findings.length} \u5904\u65E7\u5E03\u5C40\uFF08\u89C1\u4E0B\u65B9 \u26A0 \u63D0\u793A\uFF09`
+        });
+      }
+    }
     checks.push({ name: "\u64CD\u4F5C\u7CFB\u7EDF", ok: true, detail: `${import_os4.default.type()} ${import_os4.default.release()} (${import_os4.default.arch()})` });
     let allOk = true;
     for (const c of checks) {
@@ -4014,6 +4106,9 @@ function makeDoctorCommand() {
       console.log(`${icon} ${c.name}: ${c.detail}`);
       if (!c.ok) allOk = false;
     }
+    for (const w of ontoWarnings) {
+      console.log(`\u26A0\uFE0F  ${w}`);
+    }
     ok({ checks, allOk });
     if (!allOk) process.exit(1);
   });
@@ -4044,8 +4139,8 @@ function makeEnvCommand() {
 }
 
 // cli/dazi/src/commands/data.ts
-var import_path5 = __toESM(require("path"), 1);
-var import_fs4 = __toESM(require("fs"), 1);
+var import_path7 = __toESM(require("path"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
 function tableListLabel(t) {
   const display = t.display_name?.trim();
   const physical = (t.table_name ?? t.name ?? "").trim();
@@ -4376,14 +4471,14 @@ function makeFileSubCmd() {
   });
   cmd.command("upload <localFile>").description("\u4E0A\u4F20\u672C\u5730\u6587\u4EF6\u5230\u5E73\u53F0").requiredOption("--space <spaceId>", "\u7A7A\u95F4 ID").option("--dest <destPath>", "\u76EE\u6807\u8DEF\u5F84", "/").action(async (localFile, opts) => {
     try {
-      if (!import_fs4.default.existsSync(localFile)) {
+      if (!import_fs6.default.existsSync(localFile)) {
         console.error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${localFile}`);
         process.exit(1);
       }
       const auth = loadAuth();
-      const buf = import_fs4.default.readFileSync(localFile);
+      const buf = import_fs6.default.readFileSync(localFile);
       const formData = new FormData();
-      formData.append("file", new Blob([buf]), import_path5.default.basename(localFile));
+      formData.append("file", new Blob([buf]), import_path7.default.basename(localFile));
       formData.append("destDir", opts.dest);
       formData.append("spaceId", opts.space);
       const url = `${auth.serverUrl.replace(/\/$/, "")}/api/dataspaces/${opts.space}/native-scripts/upload`;
@@ -4414,36 +4509,36 @@ function makeDataCommand() {
 }
 
 // cli/dazi/src/commands/docs.ts
-var import_path6 = __toESM(require("path"), 1);
-var import_fs5 = __toESM(require("fs"), 1);
+var import_path8 = __toESM(require("path"), 1);
+var import_fs7 = __toESM(require("fs"), 1);
 function resolveBundledDocsDir() {
   const bundledDir = process.env.DAZI_BUNDLED_DIR;
   if (bundledDir) {
-    const p = import_path6.default.resolve(bundledDir, "..", "docs");
-    if (import_fs5.default.existsSync(p)) return p;
+    const p = import_path8.default.resolve(bundledDir, "..", "docs");
+    if (import_fs7.default.existsSync(p)) return p;
   }
   const candidates = [
-    import_path6.default.resolve(__dirname, "..", "..", "docs"),
+    import_path8.default.resolve(__dirname, "..", "..", "docs"),
     // dist layout
-    import_path6.default.resolve(process.execPath, "..", "docs")
+    import_path8.default.resolve(process.execPath, "..", "docs")
   ];
-  return candidates.find((c) => import_fs5.default.existsSync(c)) ?? null;
+  return candidates.find((c) => import_fs7.default.existsSync(c)) ?? null;
 }
 function loadBundledIndex(bundledDir) {
-  const indexPath = import_path6.default.join(bundledDir, "index.json");
-  if (!import_fs5.default.existsSync(indexPath)) return [];
+  const indexPath = import_path8.default.join(bundledDir, "index.json");
+  if (!import_fs7.default.existsSync(indexPath)) return [];
   try {
-    const raw = JSON.parse(import_fs5.default.readFileSync(indexPath, "utf-8"));
+    const raw = JSON.parse(import_fs7.default.readFileSync(indexPath, "utf-8"));
     return raw.docs ?? [];
   } catch {
     return [];
   }
 }
 function loadWorkspaceIndex(ws) {
-  const indexPath = import_path6.default.join(ws.docs, "index.json");
-  if (!import_fs5.default.existsSync(indexPath)) return [];
+  const indexPath = import_path8.default.join(ws.docs, "index.json");
+  if (!import_fs7.default.existsSync(indexPath)) return [];
   try {
-    const raw = JSON.parse(import_fs5.default.readFileSync(indexPath, "utf-8"));
+    const raw = JSON.parse(import_fs7.default.readFileSync(indexPath, "utf-8"));
     return raw.docs ?? [];
   } catch {
     return [];
@@ -4494,9 +4589,9 @@ function makeDocsCommand() {
       const wsIndex = loadWorkspaceIndex(ws);
       const wsEntry = wsIndex.find((d) => d.id === topicId);
       if (wsEntry) {
-        const p = import_path6.default.join(ws.docs, wsEntry.file);
-        if (import_fs5.default.existsSync(p)) {
-          content = import_fs5.default.readFileSync(p, "utf-8");
+        const p = import_path8.default.join(ws.docs, wsEntry.file);
+        if (import_fs7.default.existsSync(p)) {
+          content = import_fs7.default.readFileSync(p, "utf-8");
           source = "workspace";
         }
       }
@@ -4504,9 +4599,9 @@ function makeDocsCommand() {
         const bIndex = loadBundledIndex(bundledDir);
         const bEntry = bIndex.find((d) => d.id === topicId);
         if (bEntry) {
-          const p = import_path6.default.join(bundledDir, bEntry.file);
-          if (import_fs5.default.existsSync(p)) {
-            content = import_fs5.default.readFileSync(p, "utf-8");
+          const p = import_path8.default.join(bundledDir, bEntry.file);
+          if (import_fs7.default.existsSync(p)) {
+            content = import_fs7.default.readFileSync(p, "utf-8");
             source = "bundled";
           }
         }
@@ -4526,7 +4621,7 @@ function makeDocsCommand() {
   cmd.command("sync").description("\u5C06\u5185\u7F6E\u6587\u6863\u540C\u6B65\u5230\u5DE5\u4F5C\u533A \u8D44\u6E90/docs/\uFF08\u9ED8\u8BA4\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\uFF09").option("--skip-existing", "\u5DF2\u5B58\u5728\u65F6\u8DF3\u8FC7\uFF08\u4E0D\u8986\u76D6\uFF09").option("--from-platform", "\u4ECE\u5E73\u53F0\u540C\u6B65\u6587\u6863\uFF08\u9700\u767B\u5F55\uFF09").option("--dry-run", "\u4EC5\u9884\u89C8").action(async (opts) => {
     try {
       const ws = resolveWorkspace();
-      if (!import_fs5.default.existsSync(ws.docs)) import_fs5.default.mkdirSync(ws.docs, { recursive: true });
+      if (!import_fs7.default.existsSync(ws.docs)) import_fs7.default.mkdirSync(ws.docs, { recursive: true });
       if (opts.fromPlatform) {
         const docs = await apiRequest(
           "/api/v1/docs"
@@ -4543,24 +4638,24 @@ function makeDocsCommand() {
       const index = loadBundledIndex(bundledDir);
       let synced = 0, skipped = 0;
       for (const entry of index) {
-        const srcFile = import_path6.default.join(bundledDir, entry.file);
-        const dstFile = import_path6.default.join(ws.docs, entry.file);
-        if (!import_fs5.default.existsSync(srcFile)) continue;
-        if (import_fs5.default.existsSync(dstFile) && opts.skipExisting) {
+        const srcFile = import_path8.default.join(bundledDir, entry.file);
+        const dstFile = import_path8.default.join(ws.docs, entry.file);
+        if (!import_fs7.default.existsSync(srcFile)) continue;
+        if (import_fs7.default.existsSync(dstFile) && opts.skipExisting) {
           skipped++;
           if (opts.dryRun) console.log(`  skip (\u5DF2\u5B58\u5728): ${entry.file}`);
           continue;
         }
         if (!opts.dryRun) {
-          const dstDir = import_path6.default.dirname(dstFile);
-          if (!import_fs5.default.existsSync(dstDir)) import_fs5.default.mkdirSync(dstDir, { recursive: true });
-          import_fs5.default.copyFileSync(srcFile, dstFile);
+          const dstDir = import_path8.default.dirname(dstFile);
+          if (!import_fs7.default.existsSync(dstDir)) import_fs7.default.mkdirSync(dstDir, { recursive: true });
+          import_fs7.default.copyFileSync(srcFile, dstFile);
         }
         console.log(`  ${opts.dryRun ? "[dry-run] " : ""}\u2192 ${entry.file}`);
         synced++;
       }
       if (!opts.dryRun) {
-        import_fs5.default.copyFileSync(import_path6.default.join(bundledDir, "index.json"), import_path6.default.join(ws.docs, "index.json"));
+        import_fs7.default.copyFileSync(import_path8.default.join(bundledDir, "index.json"), import_path8.default.join(ws.docs, "index.json"));
       }
       console.log(`${opts.dryRun ? "[dry-run] " : ""}\u540C\u6B65 ${synced} \u7BC7\uFF0C\u8DF3\u8FC7 ${skipped} \u7BC7`);
       ok({ synced, skipped, dryRun: opts.dryRun });
@@ -4571,10 +4666,10 @@ function makeDocsCommand() {
   cmd.command("index").description("\u91CD\u5EFA\u5DE5\u4F5C\u533A docs/index.json").action(() => {
     try {
       const ws = resolveWorkspace();
-      if (!import_fs5.default.existsSync(ws.docs)) import_fs5.default.mkdirSync(ws.docs, { recursive: true });
-      const files = import_fs5.default.readdirSync(ws.docs, { recursive: true }).filter((f) => typeof f === "string" && f.endsWith(".md")).map((f) => ({ file: f.replace(/\\/g, "/"), id: f.replace(/\\/g, "/").replace(/\.md$/, "") }));
-      const indexPath = import_path6.default.join(ws.docs, "index.json");
-      import_fs5.default.writeFileSync(indexPath, JSON.stringify({ docs: files, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+      if (!import_fs7.default.existsSync(ws.docs)) import_fs7.default.mkdirSync(ws.docs, { recursive: true });
+      const files = import_fs7.default.readdirSync(ws.docs, { recursive: true }).filter((f) => typeof f === "string" && f.endsWith(".md")).map((f) => ({ file: f.replace(/\\/g, "/"), id: f.replace(/\\/g, "/").replace(/\.md$/, "") }));
+      const indexPath = import_path8.default.join(ws.docs, "index.json");
+      import_fs7.default.writeFileSync(indexPath, JSON.stringify({ docs: files, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
       console.log(`\u2705 docs/index.json \u5DF2\u66F4\u65B0 (${files.length} \u7BC7)`);
       ok({ count: files.length });
     } catch (err2) {
@@ -4585,24 +4680,24 @@ function makeDocsCommand() {
 }
 
 // cli/dazi/src/commands/prompt.ts
-var import_path7 = __toESM(require("path"), 1);
-var import_fs6 = __toESM(require("fs"), 1);
+var import_path9 = __toESM(require("path"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
 function resolveBundledPromptsDir() {
   const bundledDir = process.env.DAZI_BUNDLED_DIR;
   if (bundledDir) {
-    const p = import_path7.default.resolve(bundledDir, "..", "prompts");
-    if (import_fs6.default.existsSync(p)) return p;
+    const p = import_path9.default.resolve(bundledDir, "..", "prompts");
+    if (import_fs8.default.existsSync(p)) return p;
   }
   const candidates = [
-    import_path7.default.resolve(__dirname, "..", "..", "prompts")
+    import_path9.default.resolve(__dirname, "..", "..", "prompts")
   ];
-  return candidates.find((c) => import_fs6.default.existsSync(c)) ?? null;
+  return candidates.find((c) => import_fs8.default.existsSync(c)) ?? null;
 }
 function loadIndex(dir) {
-  const indexPath = import_path7.default.join(dir, "index.json");
-  if (!import_fs6.default.existsSync(indexPath)) return [];
+  const indexPath = import_path9.default.join(dir, "index.json");
+  if (!import_fs8.default.existsSync(indexPath)) return [];
   try {
-    const raw = JSON.parse(import_fs6.default.readFileSync(indexPath, "utf-8"));
+    const raw = JSON.parse(import_fs8.default.readFileSync(indexPath, "utf-8"));
     return raw.prompts ?? [];
   } catch {
     return [];
@@ -4616,7 +4711,7 @@ function makePromptCommand() {
       const bundled = bundledDir ? loadIndex(bundledDir) : [];
       const ws = resolveWorkspace();
       const wsPromptDir = ws.prompts;
-      const workspace = import_fs6.default.existsSync(wsPromptDir) ? loadIndex(wsPromptDir) : [];
+      const workspace = import_fs8.default.existsSync(wsPromptDir) ? loadIndex(wsPromptDir) : [];
       const map = /* @__PURE__ */ new Map();
       bundled.forEach((p) => map.set(p.id, { ...p, source: "bundled" }));
       workspace.forEach((p) => map.set(p.id, { ...p, source: "workspace" }));
@@ -4652,13 +4747,13 @@ function makePromptCommand() {
       let content = null;
       let source = "";
       const wsPromptDir = ws.prompts;
-      if (import_fs6.default.existsSync(wsPromptDir)) {
+      if (import_fs8.default.existsSync(wsPromptDir)) {
         const wsIndex = loadIndex(wsPromptDir);
         const entry = wsIndex.find((p) => p.id === topicId);
         if (entry) {
-          const p = import_path7.default.join(wsPromptDir, entry.file);
-          if (import_fs6.default.existsSync(p)) {
-            content = import_fs6.default.readFileSync(p, "utf-8");
+          const p = import_path9.default.join(wsPromptDir, entry.file);
+          if (import_fs8.default.existsSync(p)) {
+            content = import_fs8.default.readFileSync(p, "utf-8");
             source = "workspace";
           }
         }
@@ -4667,9 +4762,9 @@ function makePromptCommand() {
         const bIndex = loadIndex(bundledDir);
         const entry = bIndex.find((p) => p.id === topicId);
         if (entry) {
-          const p = import_path7.default.join(bundledDir, entry.file);
-          if (import_fs6.default.existsSync(p)) {
-            content = import_fs6.default.readFileSync(p, "utf-8");
+          const p = import_path9.default.join(bundledDir, entry.file);
+          if (import_fs8.default.existsSync(p)) {
+            content = import_fs8.default.readFileSync(p, "utf-8");
             source = "bundled";
           }
         }
@@ -4695,28 +4790,28 @@ function makePromptCommand() {
       }
       const ws = resolveWorkspace();
       const wsPromptDir = ws.prompts;
-      if (!import_fs6.default.existsSync(wsPromptDir)) import_fs6.default.mkdirSync(wsPromptDir, { recursive: true });
+      if (!import_fs8.default.existsSync(wsPromptDir)) import_fs8.default.mkdirSync(wsPromptDir, { recursive: true });
       const index = loadIndex(bundledDir);
       let synced = 0, skipped = 0;
       for (const entry of index) {
-        const srcFile = import_path7.default.join(bundledDir, entry.file);
-        const dstFile = import_path7.default.join(wsPromptDir, entry.file);
-        if (!import_fs6.default.existsSync(srcFile)) continue;
-        if (import_fs6.default.existsSync(dstFile) && opts.skipExisting) {
+        const srcFile = import_path9.default.join(bundledDir, entry.file);
+        const dstFile = import_path9.default.join(wsPromptDir, entry.file);
+        if (!import_fs8.default.existsSync(srcFile)) continue;
+        if (import_fs8.default.existsSync(dstFile) && opts.skipExisting) {
           skipped++;
           if (opts.dryRun) console.log(`  skip (\u5DF2\u5B58\u5728): ${entry.file}`);
           continue;
         }
         if (!opts.dryRun) {
-          const dstDir = import_path7.default.dirname(dstFile);
-          if (!import_fs6.default.existsSync(dstDir)) import_fs6.default.mkdirSync(dstDir, { recursive: true });
-          import_fs6.default.copyFileSync(srcFile, dstFile);
+          const dstDir = import_path9.default.dirname(dstFile);
+          if (!import_fs8.default.existsSync(dstDir)) import_fs8.default.mkdirSync(dstDir, { recursive: true });
+          import_fs8.default.copyFileSync(srcFile, dstFile);
         }
         console.log(`  ${opts.dryRun ? "[dry-run] " : ""}\u2192 ${entry.file}`);
         synced++;
       }
       if (!opts.dryRun) {
-        import_fs6.default.copyFileSync(import_path7.default.join(bundledDir, "index.json"), import_path7.default.join(wsPromptDir, "index.json"));
+        import_fs8.default.copyFileSync(import_path9.default.join(bundledDir, "index.json"), import_path9.default.join(wsPromptDir, "index.json"));
       }
       console.log(`${opts.dryRun ? "[dry-run] " : ""}\u540C\u6B65 ${synced} \u7BC7\uFF0C\u8DF3\u8FC7 ${skipped} \u7BC7`);
       ok({ synced, skipped });
@@ -4728,37 +4823,37 @@ function makePromptCommand() {
 }
 
 // cli/dazi/src/commands/examples.ts
-var import_path8 = __toESM(require("path"), 1);
-var import_fs7 = __toESM(require("fs"), 1);
+var import_path10 = __toESM(require("path"), 1);
+var import_fs9 = __toESM(require("fs"), 1);
 function resolveBundledExamplesDir() {
   const bundledDir = process.env.DAZI_BUNDLED_DIR;
   if (bundledDir) {
-    const p = import_path8.default.resolve(bundledDir, "..", "examples");
-    if (import_fs7.default.existsSync(p)) return p;
+    const p = import_path10.default.resolve(bundledDir, "..", "examples");
+    if (import_fs9.default.existsSync(p)) return p;
   }
   const candidates = [
-    import_path8.default.resolve(__dirname, "..", "..", "examples")
+    import_path10.default.resolve(__dirname, "..", "..", "examples")
   ];
-  return candidates.find((c) => import_fs7.default.existsSync(c)) ?? null;
+  return candidates.find((c) => import_fs9.default.existsSync(c)) ?? null;
 }
 function loadIndex2(dir) {
-  const indexPath = import_path8.default.join(dir, "index.json");
-  if (!import_fs7.default.existsSync(indexPath)) return [];
+  const indexPath = import_path10.default.join(dir, "index.json");
+  if (!import_fs9.default.existsSync(indexPath)) return [];
   try {
-    const raw = JSON.parse(import_fs7.default.readFileSync(indexPath, "utf-8"));
+    const raw = JSON.parse(import_fs9.default.readFileSync(indexPath, "utf-8"));
     return raw.examples ?? [];
   } catch {
     return [];
   }
 }
 function resolveExampleFile(topicId, wsExamplesDir, bundledDir) {
-  if (import_fs7.default.existsSync(wsExamplesDir)) {
+  if (import_fs9.default.existsSync(wsExamplesDir)) {
     const wsIndex = loadIndex2(wsExamplesDir);
     const wsEntry = wsIndex.find((e) => e.id === topicId);
     if (wsEntry) {
-      const p = import_path8.default.join(wsExamplesDir, wsEntry.file);
-      if (import_fs7.default.existsSync(p)) {
-        return { content: import_fs7.default.readFileSync(p, "utf-8"), source: "workspace", filePath: p };
+      const p = import_path10.default.join(wsExamplesDir, wsEntry.file);
+      if (import_fs9.default.existsSync(p)) {
+        return { content: import_fs9.default.readFileSync(p, "utf-8"), source: "workspace", filePath: p };
       }
     }
   }
@@ -4766,9 +4861,9 @@ function resolveExampleFile(topicId, wsExamplesDir, bundledDir) {
     const bIndex = loadIndex2(bundledDir);
     const bEntry = bIndex.find((e) => e.id === topicId);
     if (bEntry) {
-      const p = import_path8.default.join(bundledDir, bEntry.file);
-      if (import_fs7.default.existsSync(p)) {
-        return { content: import_fs7.default.readFileSync(p, "utf-8"), source: "bundled", filePath: p };
+      const p = import_path10.default.join(bundledDir, bEntry.file);
+      if (import_fs9.default.existsSync(p)) {
+        return { content: import_fs9.default.readFileSync(p, "utf-8"), source: "bundled", filePath: p };
       }
     }
   }
@@ -4782,7 +4877,7 @@ function makeExamplesCommand() {
       const bundled = bundledDir ? loadIndex2(bundledDir) : [];
       const ws = resolveWorkspace();
       const wsExamplesDir = ws.examples;
-      const workspace = import_fs7.default.existsSync(wsExamplesDir) ? loadIndex2(wsExamplesDir) : [];
+      const workspace = import_fs9.default.existsSync(wsExamplesDir) ? loadIndex2(wsExamplesDir) : [];
       const map = /* @__PURE__ */ new Map();
       bundled.forEach((e) => map.set(e.id, { ...e, source: "bundled" }));
       workspace.forEach((e) => map.set(e.id, { ...e, source: "workspace" }));
@@ -4838,31 +4933,31 @@ function makeExamplesCommand() {
       }
       const ws = resolveWorkspace();
       const wsExamplesDir = ws.examples;
-      if (!import_fs7.default.existsSync(wsExamplesDir)) import_fs7.default.mkdirSync(wsExamplesDir, { recursive: true });
+      if (!import_fs9.default.existsSync(wsExamplesDir)) import_fs9.default.mkdirSync(wsExamplesDir, { recursive: true });
       const index = loadIndex2(bundledDir);
       let synced = 0, skipped = 0;
       for (const entry of index) {
-        const srcFile = import_path8.default.join(bundledDir, entry.file);
-        const dstFile = import_path8.default.join(wsExamplesDir, entry.file);
-        if (!import_fs7.default.existsSync(srcFile)) {
+        const srcFile = import_path10.default.join(bundledDir, entry.file);
+        const dstFile = import_path10.default.join(wsExamplesDir, entry.file);
+        if (!import_fs9.default.existsSync(srcFile)) {
           console.warn(`  \u8DF3\u8FC7\uFF08\u6E90\u6587\u4EF6\u7F3A\u5931\uFF09: ${entry.file}`);
           continue;
         }
-        if (import_fs7.default.existsSync(dstFile) && opts.skipExisting) {
+        if (import_fs9.default.existsSync(dstFile) && opts.skipExisting) {
           skipped++;
           if (opts.dryRun) console.log(`  skip (\u5DF2\u5B58\u5728): ${entry.file}`);
           continue;
         }
         if (!opts.dryRun) {
-          const dstDir = import_path8.default.dirname(dstFile);
-          if (!import_fs7.default.existsSync(dstDir)) import_fs7.default.mkdirSync(dstDir, { recursive: true });
-          import_fs7.default.copyFileSync(srcFile, dstFile);
+          const dstDir = import_path10.default.dirname(dstFile);
+          if (!import_fs9.default.existsSync(dstDir)) import_fs9.default.mkdirSync(dstDir, { recursive: true });
+          import_fs9.default.copyFileSync(srcFile, dstFile);
         }
         console.log(`  ${opts.dryRun ? "[dry-run] " : ""}\u2192 ${entry.file}`);
         synced++;
       }
       if (!opts.dryRun) {
-        import_fs7.default.copyFileSync(import_path8.default.join(bundledDir, "index.json"), import_path8.default.join(wsExamplesDir, "index.json"));
+        import_fs9.default.copyFileSync(import_path10.default.join(bundledDir, "index.json"), import_path10.default.join(wsExamplesDir, "index.json"));
       }
       console.log(`${opts.dryRun ? "[dry-run] " : ""}\u540C\u6B65 ${synced} \u4E2A\uFF0C\u8DF3\u8FC7 ${skipped} \u4E2A`);
       ok({ synced, skipped });
@@ -4875,44 +4970,44 @@ function makeExamplesCommand() {
 
 // cli/dazi/src/commands/migrate.ts
 var import_os6 = __toESM(require("os"), 1);
-var import_path9 = __toESM(require("path"), 1);
-var import_fs8 = __toESM(require("fs"), 1);
+var import_path11 = __toESM(require("path"), 1);
+var import_fs10 = __toESM(require("fs"), 1);
 function buildMigratePlan(wsRoot) {
   const actions = [];
-  const ontologyDir = import_path9.default.join(wsRoot, "ontology");
-  const ontoDir = import_path9.default.join(wsRoot, "onto");
-  if (import_fs8.default.existsSync(ontologyDir) && !import_fs8.default.existsSync(ontoDir)) {
+  const ontologyDir = import_path11.default.join(wsRoot, "ontology");
+  const ontoDir = import_path11.default.join(wsRoot, "onto");
+  if (import_fs10.default.existsSync(ontologyDir) && !import_fs10.default.existsSync(ontoDir)) {
     actions.push({ type: "rename", src: ontologyDir, dest: ontoDir, label: "ontology/ \u2192 onto/" });
-  } else if (!import_fs8.default.existsSync(ontoDir)) {
+  } else if (!import_fs10.default.existsSync(ontoDir)) {
     actions.push({ type: "create", dest: ontoDir, label: "\u65B0\u5EFA onto/" });
   }
-  const isDrapRoot = (dir) => import_fs8.default.existsSync(import_path9.default.join(dir, "templates")) && import_fs8.default.existsSync(import_path9.default.join(dir, "sdk"));
-  const runtimeAppsDir = import_path9.default.join(wsRoot, "runtime-apps");
-  const appsDir = import_path9.default.join(wsRoot, "apps");
-  if (import_fs8.default.existsSync(runtimeAppsDir) && isDrapRoot(runtimeAppsDir)) {
-  } else if (import_fs8.default.existsSync(runtimeAppsDir) && !import_fs8.default.existsSync(appsDir)) {
+  const isDrapRoot = (dir) => import_fs10.default.existsSync(import_path11.default.join(dir, "templates")) && import_fs10.default.existsSync(import_path11.default.join(dir, "sdk"));
+  const runtimeAppsDir = import_path11.default.join(wsRoot, "runtime-apps");
+  const appsDir = import_path11.default.join(wsRoot, "apps");
+  if (import_fs10.default.existsSync(runtimeAppsDir) && isDrapRoot(runtimeAppsDir)) {
+  } else if (import_fs10.default.existsSync(runtimeAppsDir) && !import_fs10.default.existsSync(appsDir)) {
     actions.push({ type: "rename", src: runtimeAppsDir, dest: appsDir, label: "runtime-apps/ \u2192 apps/" });
-  } else if (!import_fs8.default.existsSync(appsDir) && !import_fs8.default.existsSync(runtimeAppsDir)) {
+  } else if (!import_fs10.default.existsSync(appsDir) && !import_fs10.default.existsSync(runtimeAppsDir)) {
     actions.push({ type: "create", dest: appsDir, label: "\u65B0\u5EFA apps/" });
   }
-  const resourcesDir = import_path9.default.join(wsRoot, "\u8D44\u6E90");
+  const resourcesDir = import_path11.default.join(wsRoot, "\u8D44\u6E90");
   for (const dir of ["flows", "data", ".dazi"]) {
-    const p = import_path9.default.join(wsRoot, dir);
-    if (!import_fs8.default.existsSync(p)) {
+    const p = import_path11.default.join(wsRoot, dir);
+    if (!import_fs10.default.existsSync(p)) {
       actions.push({ type: "create", dest: p, label: `\u65B0\u5EFA ${dir}/` });
     }
   }
-  if (!import_fs8.default.existsSync(resourcesDir)) {
+  if (!import_fs10.default.existsSync(resourcesDir)) {
     actions.push({ type: "create", dest: resourcesDir, label: "\u65B0\u5EFA \u8D44\u6E90/" });
   }
   for (const sub of ["dataspaces", "datasources", "docs", "prompts"]) {
-    const p = import_path9.default.join(resourcesDir, sub);
-    if (!import_fs8.default.existsSync(p)) {
+    const p = import_path11.default.join(resourcesDir, sub);
+    if (!import_fs10.default.existsSync(p)) {
       actions.push({ type: "create", dest: p, label: `\u65B0\u5EFA \u8D44\u6E90/${sub}/` });
     }
   }
-  const cfgPath = import_path9.default.join(wsRoot, ".dazi", "config.json");
-  if (!import_fs8.default.existsSync(cfgPath)) {
+  const cfgPath = import_path11.default.join(wsRoot, ".dazi", "config.json");
+  if (!import_fs10.default.existsSync(cfgPath)) {
     actions.push({ type: "copy-config", dest: cfgPath, label: "\u751F\u6210 .dazi/config.json" });
   }
   return actions;
@@ -4920,10 +5015,10 @@ function buildMigratePlan(wsRoot) {
 function executeActions(actions, wsRoot, backup) {
   if (backup) {
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupDir = import_path9.default.join(wsRoot, ".dazi", "backup", ts);
-    import_fs8.default.mkdirSync(backupDir, { recursive: true });
+    const backupDir = import_path11.default.join(wsRoot, ".dazi", "backup", ts);
+    import_fs10.default.mkdirSync(backupDir, { recursive: true });
     for (const a of actions.filter((x) => x.type === "rename" && x.src)) {
-      const backupPath = import_path9.default.join(backupDir, import_path9.default.basename(a.src));
+      const backupPath = import_path11.default.join(backupDir, import_path11.default.basename(a.src));
       copyDirSync(a.src, backupPath);
       console.log(`  \u{1F4E6} \u5907\u4EFD: ${a.src} \u2192 ${backupPath}`);
     }
@@ -4931,16 +5026,16 @@ function executeActions(actions, wsRoot, backup) {
   for (const action of actions) {
     switch (action.type) {
       case "rename":
-        import_fs8.default.renameSync(action.src, action.dest);
+        import_fs10.default.renameSync(action.src, action.dest);
         console.log(`  \u2705 \u91CD\u547D\u540D: ${action.label}`);
         break;
       case "create":
-        import_fs8.default.mkdirSync(action.dest, { recursive: true });
+        import_fs10.default.mkdirSync(action.dest, { recursive: true });
         console.log(`  \u2705 \u521B\u5EFA: ${action.label}`);
         break;
       case "copy-config":
-        import_fs8.default.mkdirSync(import_path9.default.dirname(action.dest), { recursive: true });
-        import_fs8.default.writeFileSync(action.dest, JSON.stringify({
+        import_fs10.default.mkdirSync(import_path11.default.dirname(action.dest), { recursive: true });
+        import_fs10.default.writeFileSync(action.dest, JSON.stringify({
           migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
           migratedBy: "dazi migrate workspace"
         }, null, 2));
@@ -4950,26 +5045,26 @@ function executeActions(actions, wsRoot, backup) {
   }
 }
 function copyDirSync(src, dest) {
-  if (!import_fs8.default.existsSync(src)) return;
-  import_fs8.default.mkdirSync(dest, { recursive: true });
-  for (const entry of import_fs8.default.readdirSync(src, { withFileTypes: true })) {
-    const s = import_path9.default.join(src, entry.name);
-    const d = import_path9.default.join(dest, entry.name);
+  if (!import_fs10.default.existsSync(src)) return;
+  import_fs10.default.mkdirSync(dest, { recursive: true });
+  for (const entry of import_fs10.default.readdirSync(src, { withFileTypes: true })) {
+    const s = import_path11.default.join(src, entry.name);
+    const d = import_path11.default.join(dest, entry.name);
     if (entry.isDirectory()) copyDirSync(s, d);
-    else import_fs8.default.copyFileSync(s, d);
+    else import_fs10.default.copyFileSync(s, d);
   }
 }
 function makeMigrateCommand() {
   const cmd = new Command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E / \u5DE5\u4F5C\u533A");
   cmd.command("config").description("\u5C06\u65E7\u7248 ~/.dazi-app/auth.json \u2192 ~/.dazi/auth.json").action(() => {
     try {
-      const legacyPath = import_path9.default.join(import_os6.default.homedir(), ".dazi-app", "auth.json");
-      if (!import_fs8.default.existsSync(legacyPath)) {
+      const legacyPath = import_path11.default.join(import_os6.default.homedir(), ".dazi-app", "auth.json");
+      if (!import_fs10.default.existsSync(legacyPath)) {
         console.log("\u672A\u627E\u5230\u65E7\u7248\u8BA4\u8BC1\u6587\u4EF6\uFF0C\u65E0\u9700\u8FC1\u79FB");
         ok({ migrated: false });
         return;
       }
-      const legacy = JSON.parse(import_fs8.default.readFileSync(legacyPath, "utf-8"));
+      const legacy = JSON.parse(import_fs10.default.readFileSync(legacyPath, "utf-8"));
       saveAuth({
         token: legacy.token ?? "",
         userId: legacy.userId ?? "",
@@ -4985,9 +5080,9 @@ function makeMigrateCommand() {
   });
   cmd.command("workspace").description("\u5C06\u65E7\u7248\u5DE5\u4F5C\u533A\u76EE\u5F55\u5E03\u5C40\u8FC1\u79FB\u81F3 v3 \u89C4\u8303").argument("[dir]", "\u5DE5\u4F5C\u533A\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09", ".").option("--dry-run", "\u4EC5\u9884\u89C8\u53D8\u66F4\uFF0C\u4E0D\u6267\u884C", false).option("--no-backup", "\u8DF3\u8FC7\u5907\u4EFD\u6B65\u9AA4\uFF08\u5371\u9669\uFF09").action((dir, opts) => {
     try {
-      const wsRoot = import_path9.default.resolve(dir);
+      const wsRoot = import_path11.default.resolve(dir);
       console.log(`\u5DE5\u4F5C\u533A: ${wsRoot}`);
-      if (!import_fs8.default.existsSync(wsRoot)) {
+      if (!import_fs10.default.existsSync(wsRoot)) {
         console.error(`\u76EE\u5F55\u4E0D\u5B58\u5728: ${wsRoot}`);
         process.exit(1);
       }
@@ -5047,8 +5142,8 @@ function makeQuickstartCommand() {
 }
 
 // cli/dazi/src/commands/mcp.ts
-var import_path10 = __toESM(require("path"), 1);
-var import_fs9 = __toESM(require("fs"), 1);
+var import_path12 = __toESM(require("path"), 1);
+var import_fs11 = __toESM(require("fs"), 1);
 var import_child_process = require("child_process");
 function resolveBundledCliDir() {
   return process.env.DAZI_BUNDLED_DIR ?? null;
@@ -5056,14 +5151,14 @@ function resolveBundledCliDir() {
 function resolveBundledRoot() {
   const cliDir = resolveBundledCliDir();
   if (!cliDir) return null;
-  const parent = import_path10.default.resolve(cliDir, "..");
-  return import_fs9.default.existsSync(parent) ? parent : null;
+  const parent = import_path12.default.resolve(cliDir, "..");
+  return import_fs11.default.existsSync(parent) ? parent : null;
 }
 function resolveCli(name) {
   const dir = resolveBundledCliDir();
   if (!dir) return null;
-  const p = import_path10.default.join(dir, `${name}.js`);
-  return import_fs9.default.existsSync(p) ? p : null;
+  const p = import_path12.default.join(dir, `${name}.js`);
+  return import_fs11.default.existsSync(p) ? p : null;
 }
 function callCli(cliName, args) {
   const cliPath = resolveCli(cliName);
@@ -5100,10 +5195,10 @@ function err(msg) {
 function loadDocs() {
   const root = resolveBundledRoot();
   if (!root) return [];
-  const idx = import_path10.default.join(root, "docs", "index.json");
-  if (!import_fs9.default.existsSync(idx)) return [];
+  const idx = import_path12.default.join(root, "docs", "index.json");
+  if (!import_fs11.default.existsSync(idx)) return [];
   try {
-    return JSON.parse(import_fs9.default.readFileSync(idx, "utf-8")).docs ?? [];
+    return JSON.parse(import_fs11.default.readFileSync(idx, "utf-8")).docs ?? [];
   } catch {
     return [];
   }
@@ -5111,16 +5206,16 @@ function loadDocs() {
 function loadPrompts() {
   const root = resolveBundledRoot();
   if (!root) return [];
-  const idx = import_path10.default.join(root, "prompts", "index.json");
-  if (!import_fs9.default.existsSync(idx)) return [];
+  const idx = import_path12.default.join(root, "prompts", "index.json");
+  if (!import_fs11.default.existsSync(idx)) return [];
   try {
-    return JSON.parse(import_fs9.default.readFileSync(idx, "utf-8")).prompts ?? [];
+    return JSON.parse(import_fs11.default.readFileSync(idx, "utf-8")).prompts ?? [];
   } catch {
     return [];
   }
 }
 function readFile(filePath) {
-  return import_fs9.default.existsSync(filePath) ? import_fs9.default.readFileSync(filePath, "utf-8") : null;
+  return import_fs11.default.existsSync(filePath) ? import_fs11.default.readFileSync(filePath, "utf-8") : null;
 }
 var MCP_TOOLS = [
   // ── 文档 ──────────────────────────────────────────────────────────────
@@ -5461,7 +5556,7 @@ function handleToolCall(name, args) {
       const entry = loadDocs().find((d) => d.id === String(args.id));
       if (!entry)
         return err(`\u6587\u6863\u672A\u627E\u5230: ${args.id}\uFF08\u4F7F\u7528 list_docs \u67E5\u770B\u53EF\u7528\u6587\u6863\uFF09`);
-      const content = readFile(import_path10.default.join(root, "docs", entry.file));
+      const content = readFile(import_path12.default.join(root, "docs", entry.file));
       return content ? text(content) : err(`\u6587\u6863\u6587\u4EF6\u4E0D\u5B58\u5728: ${entry.file}`);
     }
     case "list_prompts": {
@@ -5478,7 +5573,7 @@ function handleToolCall(name, args) {
         return err(
           `\u63D0\u793A\u8BCD\u672A\u627E\u5230: ${args.id}\uFF08\u4F7F\u7528 list_prompts \u67E5\u770B\u53EF\u7528\u63D0\u793A\u8BCD\uFF09`
         );
-      const content = readFile(import_path10.default.join(root, "prompts", entry.file));
+      const content = readFile(import_path12.default.join(root, "prompts", entry.file));
       return content ? text(content) : err(`\u63D0\u793A\u8BCD\u6587\u4EF6\u4E0D\u5B58\u5728: ${entry.file}`);
     }
     case "auth_whoami": {
@@ -5797,13 +5892,13 @@ function makeMcpCommand() {
 
 // cli/dazi/src/index.ts
 var import_child_process2 = require("child_process");
-var import_path11 = __toESM(require("path"), 1);
-var import_fs10 = __toESM(require("fs"), 1);
+var import_path13 = __toESM(require("path"), 1);
+var import_fs12 = __toESM(require("fs"), 1);
 function resolveBundledCli(name) {
   const dir = process.env.DAZI_BUNDLED_DIR;
   if (!dir) return null;
-  const p = import_path11.default.join(dir, `${name}.js`);
-  return import_fs10.default.existsSync(p) ? p : null;
+  const p = import_path13.default.join(dir, `${name}.js`);
+  return import_fs12.default.existsSync(p) ? p : null;
 }
 function forwardToCli(cliName, extraArgs) {
   const bundled = resolveBundledCli(cliName);