@kw-yeh/vibeflow 4.11.29 → 4.11.32

package/dist/vibeflow.mjs

@@ -1107,9 +1107,9 @@ var init_progress = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs26 from "fs";
-import os8 from "os";
-import path29 from "path";
+import fs27 from "fs";
+import os9 from "os";
+import path30 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render as render2, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -1235,17 +1235,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs26.mkdtempSync(path29.join(os8.tmpdir(), "vibeflow-"));
-  const file = path29.join(dir, "description.md");
+  const dir = fs27.mkdtempSync(path30.join(os9.tmpdir(), "vibeflow-"));
+  const file = path30.join(dir, "description.md");
   try {
-    fs26.writeFileSync(file, text);
+    fs27.writeFileSync(file, text);
     const cmd = editorCommand(process.env, process.platform);
     const r = spawnSync2(`${cmd} "${file}"`, { stdio: "inherit", shell: true });
     if (r.error) return { error: `\u7121\u6CD5\u555F\u52D5\u7DE8\u8F2F\u5668\uFF08${cmd}\uFF09\uFF1A${r.error.message}` };
     if (r.status !== 0) return { error: `\u7DE8\u8F2F\u5668\uFF08${cmd}\uFF09\u7D50\u675F\u78BC ${r.status}\uFF0C\u63CF\u8FF0\u672A\u8B8A\u66F4` };
-    return { text: fs26.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs27.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs26.rmSync(dir, { recursive: true, force: true });
+    fs27.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -1316,10 +1316,10 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
     if (editing === "title") setS((prev) => ({ ...prev, title: draft }));
     else if (editing === "branch") setS((prev) => ({ ...prev, branch: value2 }));
     else if (editing === "project") {
-      if (value2) setProject(path29.resolve(value2.replace(/^~(?=$|\/)/, os8.homedir())));
+      if (value2) setProject(path30.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path29.resolve(value2.replace(/^~(?=$|\/)/, os8.homedir()));
-      if (!fs26.existsSync(file) || !fs26.statSync(file).isFile()) {
+      const file = path30.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir()));
+      if (!fs27.existsSync(file) || !fs27.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -1402,7 +1402,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "branch":
         return s.branch || "\uFF08\u7559\u7A7A\u5247\u81EA\u52D5\u547D\u540D\uFF0C\u4F8B\u5982 feature/login-fix\uFF09";
       case "attachments":
-        return s.attachments.length ? s.attachments.map((a) => path29.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path30.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
       case "description": {
         if (!s.description) return "\uFF08Enter \u7528\u7DE8\u8F2F\u5668\u64B0\u5BEB\uFF09";
         const lines = s.description.split("\n");
@@ -1437,7 +1437,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
       if (s.mode === "edit" && projectChanged(s)) return "\u5206\u652F\u6703\u5728\u65B0\u5C08\u6848\u3001\u5361\u7247\u958B\u59CB\u57F7\u884C\u6642\u624D\u5EFA\u7ACB\u3002";
       if (info?.isRepo && !info.hasRemote) return `\u6B64 repository \u6C92\u6709 remote\uFF0C\u5C07\u4EE5\u76EE\u524D\u5206\u652F (${info.currentBranch ?? "HEAD"}) \u70BA\u57FA\u6E96\u5EFA\u7ACB\u672C\u5730 worktree\u3002`;
-      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path29.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path30.basename(s.projectPath)}`;
     }
     if (field === "branch") {
       const when = info?.hasRemote ? "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u4E26\u63A8\u5230 origin\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
@@ -1566,7 +1566,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync3 } from "child_process";
-import path30 from "path";
+import path31 from "path";
 import React2, { useEffect as useEffect2, useState as useState2 } from "react";
 import { Box as Box2, Text as Text2, render as render3, useApp as useApp2, useInput as useInput2, useStdout } from "ink";
 function findDetachKey(text) {
@@ -1862,7 +1862,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path30.join(opts.userDataDir, "tmux.conf");
+  const conf = path31.join(opts.userDataDir, "tmux.conf");
   const inOurServer = (process.env.TMUX ?? "").split(",")[0].endsWith(`/${TMUX_SOCKET}`);
   const args = inOurServer ? ["-L", TMUX_SOCKET, "-f", conf, "switch-client", "-t", `=${sessionName}`] : ["-L", TMUX_SOCKET, "-f", conf, "attach-session", "-t", `=${sessionName}`];
   spawnSync3("tmux", args, { stdio: "inherit", env: { ...process.env, TMUX: inOurServer ? process.env.TMUX : "" } });
@@ -1993,9 +1993,9 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs27 from "fs";
-import path31 from "path";
-import { fileURLToPath } from "url";
+import fs28 from "fs";
+import path32 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 import { spawn as spawn9 } from "node:child_process";
 
@@ -2601,6 +2601,9 @@ function createBridge(t) {
     },
     // Interactive terminal bridge (Phase 3).
     term: {
+      readFile: (sessionKey, path33) => t.invoke("terminal:readFile", { sessionKey, path: path33 }),
+      existingFiles: (sessionKey, paths) => t.invoke("terminal:existingFiles", { sessionKey, paths }),
+      openFile: (sessionKey, path33) => t.invoke("terminal:openFile", { sessionKey, path: path33 }),
       /**
        * Start a terminal for a task: its agent when `launch` is given, else an
        * interactive shell. Core resolves the cwd and builds the command.
@@ -4714,8 +4717,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs24 from "fs";
-import path27 from "path";
+import fs25 from "fs";
+import path28 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -5122,21 +5125,109 @@ async function syncBuiltinsAtStartup() {
 }
 
 // packages/core/src/service.ts
-import fs20 from "fs";
-import os7 from "os";
-import path23 from "path";
+import fs21 from "fs";
+
+// packages/core/src/terminal-files.ts
+import { constants } from "fs";
+import fs13 from "fs/promises";
+import os3 from "os";
+import path16 from "path";
+import { fileURLToPath } from "url";
+var MAX_PREVIEW_IMAGE_BYTES = 20 * 1024 * 1024;
+var MAX_TEXT_BYTES2 = 256 * 1024;
+var IMAGE_MIME2 = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".svg": "image/svg+xml"
+};
+function resolveTerminalFile(cwd, input) {
+  if (!input || input.includes("\0") || input.length > 32768) throw new Error("\u6A94\u6848\u8DEF\u5F91\u7121\u6548\u3002");
+  let target = input;
+  if (/^file:/i.test(target)) {
+    const url = new URL(target);
+    if (url.hostname && url.hostname !== "localhost") throw new Error("\u53EA\u652F\u63F4\u672C\u6A5F\u6A94\u6848\u3002");
+    target = fileURLToPath(url);
+  } else if (/^[a-z][a-z\d+.-]*:/i.test(target) && !/^[a-z]:[\\/]/i.test(target)) {
+    throw new Error("\u53EA\u652F\u63F4\u672C\u6A5F\u6A94\u6848\u8DEF\u5F91\u3002");
+  }
+  if (target.startsWith("~/") || target.startsWith("~\\")) target = path16.join(os3.homedir(), target.slice(2));
+  if (target.includes("\0")) throw new Error("\u6A94\u6848\u8DEF\u5F91\u7121\u6548\u3002");
+  return path16.resolve(cwd, target);
+}
+var MAX_FILE_CANDIDATES = 128;
+async function existingTerminalFiles(cwd, inputs) {
+  const found2 = await Promise.all(inputs.slice(0, MAX_FILE_CANDIDATES).map(async (input) => {
+    try {
+      return (await fs13.stat(resolveTerminalFile(cwd, input))).isFile();
+    } catch {
+      return false;
+    }
+  }));
+  return inputs.filter((_, i) => found2[i]);
+}
+async function readTerminalFile(cwd, input, metadataOnly = false) {
+  let target;
+  try {
+    target = resolveTerminalFile(cwd, input);
+  } catch (error) {
+    return { ok: false, error: "invalid_path", message: error instanceof Error ? error.message : "\u6A94\u6848\u8DEF\u5F91\u7121\u6548\u3002" };
+  }
+  let handle;
+  try {
+    if (!(await fs13.stat(target)).isFile()) return { ok: false, error: "not_file", message: "\u9019\u500B\u8DEF\u5F91\u4E0D\u662F\u4E00\u822C\u6A94\u6848\u3002" };
+    handle = await fs13.open(target, constants.O_RDONLY | constants.O_NONBLOCK);
+    const stat = await handle.stat();
+    if (!stat.isFile()) return { ok: false, error: "not_file", message: "\u9019\u500B\u8DEF\u5F91\u4E0D\u662F\u4E00\u822C\u6A94\u6848\u3002" };
+    if (metadataOnly) return { ok: true, path: target, kind: "binary", reason: "" };
+    const mime = IMAGE_MIME2[path16.extname(target).toLowerCase()];
+    if (mime && stat.size > MAX_PREVIEW_IMAGE_BYTES) {
+      return { ok: true, path: target, kind: "binary", reason: "\u5716\u7247\u8D85\u904E 20 MB \u9810\u89BD\u4E0A\u9650\u3002" };
+    }
+    const limit = mime ? MAX_PREVIEW_IMAGE_BYTES : MAX_TEXT_BYTES2;
+    const buffer = Buffer.alloc(Math.min(stat.size, limit + 1));
+    let bytes = 0;
+    while (bytes < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, bytes, buffer.length - bytes, bytes);
+      if (!bytesRead) break;
+      bytes += bytesRead;
+    }
+    if (mime) {
+      if (bytes > limit) return { ok: true, path: target, kind: "binary", reason: "\u5716\u7247\u8D85\u904E 20 MB \u9810\u89BD\u4E0A\u9650\u3002" };
+      return { ok: true, path: target, kind: "image", dataUrl: `data:${mime};base64,${buffer.subarray(0, bytes).toString("base64")}` };
+    }
+    const sample = buffer.subarray(0, Math.min(bytes, 8192));
+    if (/\.(pdf|zip|gz|tar|exe|dll|woff2?|mp4|mov|webm|mp3|wav)$/i.test(target) || sample.some((b) => b === 0 || (b < 9 || b > 13 && b < 32))) {
+      return { ok: true, path: target, kind: "binary", reason: "\u6B64\u683C\u5F0F\u7121\u6CD5\u5728 VibeFlow \u5167\u9810\u89BD\u3002" };
+    }
+    return { ok: true, path: target, kind: "text", text: buffer.subarray(0, Math.min(bytes, limit)).toString("utf8"), truncated: bytes > limit };
+  } catch (error) {
+    const code2 = error.code;
+    return code2 === "ENOENT" || code2 === "ENOTDIR" ? { ok: false, error: "not_found", message: "\u627E\u4E0D\u5230\u9019\u500B\u6A94\u6848\uFF0C\u53EF\u80FD\u5DF2\u88AB\u79FB\u52D5\u6216\u522A\u9664\u3002" } : { ok: false, error: "unreadable", message: "\u7121\u6CD5\u8B80\u53D6\u9019\u500B\u6A94\u6848\uFF0C\u8ACB\u78BA\u8A8D\u5B58\u53D6\u6B0A\u9650\u3002" };
+  } finally {
+    await handle?.close();
+  }
+}
+
+// packages/core/src/service.ts
+import os8 from "os";
+import path24 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // packages/core/src/agent-models.ts
-import fs14 from "fs";
-import os5 from "os";
-import path17 from "path";
+import fs15 from "fs";
+import os6 from "os";
+import path18 from "path";
 
 // packages/core/src/claude-models.ts
 init_effort();
-import fs13 from "fs";
-import os3 from "os";
-import path16 from "path";
+import fs14 from "fs";
+import os4 from "os";
+import path17 from "path";
 
 // packages/core/src/json-lines-process.ts
 import { spawn as spawn4 } from "child_process";
@@ -5240,11 +5331,11 @@ var CLAUDE_MODELS_TIMEOUT_MS = 15e3;
 var REQUEST_ID = "vibeflow-models";
 var CLAUDE_ARGS = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
 function openClaude() {
-  const cwd = fs13.mkdtempSync(path16.join(os3.tmpdir(), "vf-claude-models-"));
+  const cwd = fs14.mkdtempSync(path17.join(os4.tmpdir(), "vf-claude-models-"));
   return spawnJsonLines("claude", CLAUDE_ARGS, {
     cwd,
     timeoutMs: CLAUDE_MODELS_TIMEOUT_MS,
-    onExit: () => fs13.rmSync(cwd, { recursive: true, force: true })
+    onExit: () => fs14.rmSync(cwd, { recursive: true, force: true })
   });
 }
 function isRecord(value) {
@@ -5291,7 +5382,7 @@ async function fetchClaudeModels(open = openClaude) {
 // packages/core/src/codex-models.ts
 init_effort();
 init_env();
-import os4 from "os";
+import os5 from "os";
 var CODEX_MODELS_TIMEOUT_MS = 2e4;
 var MAX_PAGES = 20;
 var CodexLoginRequiredError = class extends Error {
@@ -5304,7 +5395,7 @@ function codexAppServerCommand() {
   return {
     bin: "codex",
     args: ["app-server", "--listen", "stdio://"],
-    cwd: os4.homedir(),
+    cwd: os5.homedir(),
     env: execEnv()
   };
 }
@@ -5393,7 +5484,7 @@ function builtinModels(id) {
 }
 function defaultCodexHome() {
   const configured = process.env.CODEX_HOME?.trim();
-  return configured ? configured : path17.join(os5.homedir(), ".codex");
+  return configured ? configured : path18.join(os6.homedir(), ".codex");
 }
 function parseCodexCatalog(raw) {
   const body = JSON.parse(raw);
@@ -5419,9 +5510,9 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function readCodexCache(codexHome) {
-  const cachePath = path17.join(codexHome, "models_cache.json");
+  const cachePath = path18.join(codexHome, "models_cache.json");
   try {
-    const raw = await fs14.promises.readFile(cachePath, "utf8");
+    const raw = await fs15.promises.readFile(cachePath, "utf8");
     return { models: parseCodexCatalog(raw), source: "codex-cache" };
   } catch (err) {
     const missing = err.code === "ENOENT";
@@ -5543,11 +5634,11 @@ function effortDescription(level) {
 }
 
 // packages/core/src/jev-credentials.ts
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function keyPath(dir) {
-  return path18.join(dir, "jev-api-key");
+  return path19.join(dir, "jev-api-key");
 }
 function dataDir() {
   return getPlatform().userDataDir();
@@ -5555,8 +5646,8 @@ function dataDir() {
 function readJevApiKey(dir = dataDir()) {
   try {
     const file = keyPath(dir);
-    if (fs15.lstatSync(file).isSymbolicLink()) throw new Error("Jev key file must not be a symlink");
-    const saved = fs15.readFileSync(file, "utf8").trim();
+    if (fs16.lstatSync(file).isSymbolicLink()) throw new Error("Jev key file must not be a symlink");
+    const saved = fs16.readFileSync(file, "utf8").trim();
     if (saved) return saved;
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
@@ -5566,8 +5657,8 @@ function readJevApiKey(dir = dataDir()) {
 function jevKeyStatus(dir = dataDir()) {
   try {
     const file = keyPath(dir);
-    if (fs15.lstatSync(file).isSymbolicLink()) throw new Error("Jev key file must not be a symlink");
-    if (fs15.readFileSync(file, "utf8").trim()) return { configured: true, source: "saved" };
+    if (fs16.lstatSync(file).isSymbolicLink()) throw new Error("Jev key file must not be a symlink");
+    if (fs16.readFileSync(file, "utf8").trim()) return { configured: true, source: "saved" };
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -5578,20 +5669,20 @@ function saveJevApiKey(value, dir = dataDir()) {
   if (!key || key.length > 4096 || !/^[\x21-\x7e]+$/.test(key)) {
     throw new Error("Jev API key \u683C\u5F0F\u7121\u6548");
   }
-  fs15.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs16.mkdirSync(dir, { recursive: true, mode: 448 });
   const file = keyPath(dir);
   const tmp = `${file}.${randomUUID3()}.tmp`;
   try {
-    fs15.writeFileSync(tmp, key, { mode: 384, flag: "wx" });
-    fs15.renameSync(tmp, file);
-    if (process.platform !== "win32") fs15.chmodSync(file, 384);
+    fs16.writeFileSync(tmp, key, { mode: 384, flag: "wx" });
+    fs16.renameSync(tmp, file);
+    if (process.platform !== "win32") fs16.chmodSync(file, 384);
   } finally {
-    fs15.rmSync(tmp, { force: true });
+    fs16.rmSync(tmp, { force: true });
   }
   return { configured: true, source: "saved" };
 }
 function removeJevApiKey(dir = dataDir()) {
-  fs15.rmSync(keyPath(dir), { force: true });
+  fs16.rmSync(keyPath(dir), { force: true });
   return jevKeyStatus(dir);
 }
 
@@ -6103,45 +6194,45 @@ function createJiraService(options) {
 }
 
 // packages/core/src/board-cli.ts
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path19.dirname(getStorePath());
+  const storeDir = path20.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs16.existsSync(entry)) return { storeDir, cliPath: entry };
+  if (entry && fs17.existsSync(entry)) return { storeDir, cliPath: entry };
   const root = getPlatform().sourceRoot();
   if (!root) return { storeDir };
-  const cliPath = path19.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path19.join(root, "test", "support", "register.mjs");
-  if (!fs16.existsSync(cliPath) || !fs16.existsSync(loaderPath)) return { storeDir };
+  const cliPath = path20.join(root, "scripts", "vibeflow.mjs");
+  const loaderPath = path20.join(root, "test", "support", "register.mjs");
+  if (!fs17.existsSync(cliPath) || !fs17.existsSync(loaderPath)) return { storeDir };
   return { storeDir, cliPath, loaderPath: pathToFileURL(loaderPath).href };
 }
 
 // packages/core/src/decisions.ts
-import fs17 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path21 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
 function decisionsKey(worktreePath, branch) {
-  return worktreePath ? path20.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path21.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path20.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path21.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
 function deleteDecisions(workspacePath, key) {
   try {
-    fs17.rmSync(decisionsPath(workspacePath, key), { force: true });
+    fs18.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
   }
 }
 
 // packages/core/src/specs.ts
-import fs18 from "fs";
-import path21 from "path";
+import fs19 from "fs";
+import path22 from "path";
 var SPEC_FILE_NAME = "spec.md";
 var MAX_SPEC_BYTES = 256 * 1024;
 function isSpecPath(p) {
-  return path21.posix.basename(p) === SPEC_FILE_NAME;
+  return path22.posix.basename(p) === SPEC_FILE_NAME;
 }
 function clip2(buf) {
   return {
@@ -6156,10 +6247,10 @@ async function readWorktreeSpecs(worktreePath, baseBranch) {
   for (const entry of entries) {
     if (entry.status === "D" || !isSpecPath(entry.path)) continue;
     try {
-      const full = path21.join(worktreePath, entry.path);
-      const stat = fs18.statSync(full);
+      const full = path22.join(worktreePath, entry.path);
+      const stat = fs19.statSync(full);
       if (!stat.isFile()) continue;
-      specs.push({ path: entry.path, ...clip2(fs18.readFileSync(full)), updatedAt: stat.mtimeMs });
+      specs.push({ path: entry.path, ...clip2(fs19.readFileSync(full)), updatedAt: stat.mtimeMs });
     } catch {
     }
   }
@@ -6511,17 +6602,17 @@ init_launch();
 // packages/core/src/progress-tracker.ts
 init_progress();
 init_launch();
-import fs19 from "fs";
-import os6 from "os";
-import path22 from "path";
+import fs20 from "fs";
+import os7 from "os";
+import path23 from "path";
 var SINCE_SLACK_MS = 5e3;
 function claudeProjectDir(home, cwd) {
-  return path22.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+  return path23.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
 }
 function pathAliases(p) {
-  const resolved = path22.resolve(p);
+  const resolved = path23.resolve(p);
   try {
-    const real = fs19.realpathSync(resolved);
+    const real = fs20.realpathSync(resolved);
     return real === resolved ? [resolved] : [resolved, real];
   } catch {
     return [resolved];
@@ -6537,7 +6628,7 @@ function samePath(a, b) {
 }
 function listFiles(dir, test) {
   try {
-    return fs19.readdirSync(dir).filter(test).map((name) => path22.join(dir, name));
+    return fs20.readdirSync(dir).filter(test).map((name) => path23.join(dir, name));
   } catch {
     return [];
   }
@@ -6545,22 +6636,22 @@ function listFiles(dir, test) {
 function firstLine(file) {
   let fd;
   try {
-    fd = fs19.openSync(file, "r");
+    fd = fs20.openSync(file, "r");
     const buf = Buffer.alloc(64 * 1024);
-    const n = fs19.readSync(fd, buf, 0, buf.length, 0);
+    const n = fs20.readSync(fd, buf, 0, buf.length, 0);
     const text = buf.subarray(0, n).toString("utf8");
     const nl = text.indexOf("\n");
     return nl === -1 ? null : text.slice(0, nl);
   } catch {
     return null;
   } finally {
-    if (fd !== void 0) fs19.closeSync(fd);
+    if (fd !== void 0) fs20.closeSync(fd);
   }
 }
 function advance(file, cursor, reduce, initial) {
   let size;
   try {
-    size = fs19.statSync(file).size;
+    size = fs20.statSync(file).size;
   } catch {
     return;
   }
@@ -6572,9 +6663,9 @@ function advance(file, cursor, reduce, initial) {
   if (size === cursor.offset) return;
   let fd;
   try {
-    fd = fs19.openSync(file, "r");
+    fd = fs20.openSync(file, "r");
     const chunk = Buffer.alloc(size - cursor.offset);
-    const n = fs19.readSync(fd, chunk, 0, chunk.length, cursor.offset);
+    const n = fs20.readSync(fd, chunk, 0, chunk.length, cursor.offset);
     cursor.offset += n;
     const data = Buffer.concat([cursor.rest, chunk.subarray(0, n)]);
     const nl = data.lastIndexOf(10);
@@ -6588,7 +6679,7 @@ function advance(file, cursor, reduce, initial) {
     }
   } catch {
   } finally {
-    if (fd !== void 0) fs19.closeSync(fd);
+    if (fd !== void 0) fs20.closeSync(fd);
   }
 }
 function newCursor(state) {
@@ -6607,14 +6698,14 @@ function codexDayDirs(sessionsRoot, since) {
   const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
   while (cur <= end) {
     const pad = (n) => String(n).padStart(2, "0");
-    days.push(path22.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
+    days.push(path23.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
     cur.setDate(cur.getDate() + 1);
   }
   return days;
 }
 function createProgressTracker(opts) {
-  const home = opts.homeDir ?? os6.homedir();
-  const codexHomes = opts.codexHomes ?? (() => [path22.join(home, ".codex")]);
+  const home = opts.homeDir ?? os7.homedir();
+  const codexHomes = opts.codexHomes ?? (() => [path23.join(home, ".codex")]);
   const pollMs = opts.pollMs ?? 2e3;
   const entries = /* @__PURE__ */ new Map();
   const belongsToRun = (target, startedAt) => target.since == null || startedAt != null && startedAt >= target.since - SINCE_SLACK_MS;
@@ -6623,7 +6714,7 @@ function createProgressTracker(opts) {
     const dirs = pathAliases(target.worktreePath).map((p) => claudeProjectDir(home, p));
     for (const file of dirs.flatMap((dir) => listFiles(dir, (n) => n.endsWith(".jsonl")))) {
       if (entry.claude.has(file) || entry.rejected.has(file)) continue;
-      const session = path22.basename(file, ".jsonl");
+      const session = path23.basename(file, ".jsonl");
       if (session !== target.sessionId) {
         const head = firstLine(file);
         if (head == null) continue;
@@ -6636,8 +6727,8 @@ function createProgressTracker(opts) {
       entry.claude.set(file, newCursor(initialClaudeState()));
     }
     for (const file of Array.from(entry.claude.keys())) {
-      if (file.includes(`${path22.sep}subagents${path22.sep}`)) continue;
-      const sub = path22.join(file.slice(0, -".jsonl".length), "subagents");
+      if (file.includes(`${path23.sep}subagents${path23.sep}`)) continue;
+      const sub = path23.join(file.slice(0, -".jsonl".length), "subagents");
       for (const f of listFiles(sub, (n) => n.endsWith(".jsonl"))) {
         if (!entry.claude.has(f)) entry.claude.set(f, newCursor(initialClaudeState()));
       }
@@ -6646,7 +6737,7 @@ function createProgressTracker(opts) {
   function discoverCodex(entry) {
     const { target } = entry;
     for (const codexHome of codexHomes()) {
-      for (const day of codexDayDirs(path22.join(codexHome, "sessions"), target.since)) {
+      for (const day of codexDayDirs(path23.join(codexHome, "sessions"), target.since)) {
         for (const file of listFiles(day, (n) => n.startsWith("rollout-") && n.endsWith(".jsonl"))) {
           if (entry.codex.has(file) || entry.rejected.has(file)) continue;
           const head = firstLine(file);
@@ -6663,11 +6754,11 @@ function createProgressTracker(opts) {
     }
   }
   function drainHooks(entry) {
-    const dir = path22.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
+    const dir = path23.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
     for (const file of listFiles(dir, (n) => n.endsWith(".json")).sort()) {
       try {
-        const at = fs19.statSync(file).mtimeMs;
-        const event = JSON.parse(fs19.readFileSync(file, "utf8"));
+        const at = fs20.statSync(file).mtimeMs;
+        const event = JSON.parse(fs20.readFileSync(file, "utf8"));
         const foreign = entry.target.sessionId && typeof event.session_id === "string" && event.session_id !== entry.target.sessionId;
         const activity = foreign ? null : activityFromHook(event, at);
         if (activity) entry.hookActivity = latestActivity(entry.hookActivity ?? activity, activity);
@@ -6675,7 +6766,7 @@ function createProgressTracker(opts) {
         continue;
       }
       try {
-        fs19.unlinkSync(file);
+        fs20.unlinkSync(file);
       } catch {
       }
     }
@@ -6687,8 +6778,8 @@ function createProgressTracker(opts) {
     if (target.agent === "claude") {
       for (const [file, cursor] of entry.claude) {
         runUsage = addUsage(runUsage, claudeUsageTotal(cursor.state));
-        if (file.includes(`${path22.sep}subagents${path22.sep}`)) continue;
-        const isExecutor = path22.basename(file, ".jsonl") === target.sessionId;
+        if (file.includes(`${path23.sep}subagents${path23.sep}`)) continue;
+        const isExecutor = path23.basename(file, ".jsonl") === target.sessionId;
         const s = cursor.state;
         if (isExecutor || !target.sessionId && (!primary || (s.startedAt ?? 0) > (primary.startedAt ?? 0))) {
           primary = { todos: s.todos, contextTokens: s.contextTokens, activity: s.activity, startedAt: s.startedAt };
@@ -6767,10 +6858,10 @@ function createProgressTracker(opts) {
       };
       entry.timer.unref?.();
       entries.set(target.taskId, entry);
-      const eventsDir = path22.join(target.worktreePath, PROGRESS_EVENTS_DIR);
+      const eventsDir = path23.join(target.worktreePath, PROGRESS_EVENTS_DIR);
       try {
-        fs19.mkdirSync(eventsDir, { recursive: true });
-        entry.watcher = fs19.watch(eventsDir, () => {
+        fs20.mkdirSync(eventsDir, { recursive: true });
+        entry.watcher = fs20.watch(eventsDir, () => {
           if (entry.pending) return;
           entry.pending = setTimeout(() => {
             entry.pending = null;
@@ -6862,15 +6953,16 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
   const router = jevRouter ?? createJevRouter({ getApiKey: readJevApiKey });
   const routing = /* @__PURE__ */ new Map();
   const standaloneTerminals = /* @__PURE__ */ new Map();
+  const terminalDirectories = /* @__PURE__ */ new Map();
   let libraryCodexHome = null;
   void libraryRoot().then((root) => {
     libraryCodexHome = libraryPaths(root).codexHome;
   }).catch(() => {
   });
-  const home = homeDir ?? os7.homedir();
+  const home = homeDir ?? os8.homedir();
   const progress = createProgressTracker({
     homeDir: home,
-    codexHomes: () => [path23.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
+    codexHomes: () => [path24.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
     onUpdate: (taskId, value) => bus.emit("progress:update", { taskId, progress: value }),
     onNotify: (taskId, list) => {
       const prefs = resolveNotificationSettings(getSettings());
@@ -6923,6 +7015,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       removeTerminals([key]);
     }
     standaloneTerminals.delete(key);
+    terminalDirectories.delete(key);
     unwatchSubAgents(key);
   }
   function isStandaloneKey(key) {
@@ -6944,6 +7037,21 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     requireTask(key.split(":")[0]);
     return key;
   }
+  function terminalDirectory(sessionKey) {
+    const key = requireSessionKey(sessionKey);
+    const known = standaloneTerminals.get(key) ?? terminalDirectories.get(key);
+    if (known) return known;
+    if (isStandaloneKey(key)) {
+      const saved = listTerminals().find((item) => item.sessionKey === key);
+      if (saved?.taskId) {
+        const task2 = requireTask(saved.taskId);
+        return str(task2.worktreePath ?? task2.projectPath, "directory");
+      }
+      return saved?.projectPath ?? os8.homedir();
+    }
+    const task = requireTask(key.split(":")[0]);
+    return str(task.worktreePath ?? task.projectPath, "directory");
+  }
   function launchEffort(task, route) {
     const effort = task.effort === "auto" ? route?.effort : task.effort;
     const model = models.findModel(taskAgent(task), taskModel(task));
@@ -6988,13 +7096,13 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path23.join(os7.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path24.join(os8.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
     const branch = task.branch || fallbackBranchName(task.id);
     await removeWorktree(task.projectPath, task.worktreePath);
-    deleteArtifacts(task.workspacePath ?? path23.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path24.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   function columnOf(taskId) {
@@ -7139,8 +7247,8 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path23.resolve(str(projectPath, "projectPath"));
-      if (!fs20.existsSync(p) || !fs20.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path24.resolve(str(projectPath, "projectPath"));
+      if (!fs21.existsSync(p) || !fs21.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -7193,7 +7301,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (!task.baseBranch) throw new Error("\u4EFB\u52D9\u6C92\u6709\u8A18\u9304 base branch\uFF0C\u7121\u6CD5\u9084\u539F worktree");
       await teardownTask(task.id);
       await resetWorktreeToBase(task.worktreePath, task.baseBranch);
-      const workspacePath = task.workspacePath ?? path23.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path24.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -7237,7 +7345,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         }
         const info = await getGitInfo(nextProject);
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
-        const projectName = path23.basename(nextProject);
+        const projectName = path24.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
@@ -7299,6 +7407,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         // Session ended (natural exit included), so stop its watcher.
         onExit: () => unwatchSubAgents(key)
       });
+      terminalDirectories.set(key, cwd);
       watchSubAgents(key, cwd, (subAgents) => {
         bus.emit("subagents:update", { taskId: task.id, subAgents });
       });
@@ -7329,12 +7438,12 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         cwd = str(p.projectPath, "projectPath");
         projectPath = cwd;
       } else {
-        cwd = os7.homedir();
+        cwd = os8.homedir();
       }
-      if (!path23.isAbsolute(cwd) || !fs20.existsSync(cwd) || !fs20.statSync(cwd).isDirectory()) {
+      if (!path24.isAbsolute(cwd) || !fs21.existsSync(cwd) || !fs21.statSync(cwd).isDirectory()) {
         invalid("terminal directory must be an existing absolute directory");
       }
-      const title = (typeof p.title === "string" ? p.title.trim() : "") || saved?.title || (projectPath ? path23.basename(projectPath) : "~");
+      const title = (typeof p.title === "string" ? p.title.trim() : "") || saved?.title || (projectPath ? path24.basename(projectPath) : "~");
       saveTerminal({
         sessionKey: key,
         title,
@@ -7351,6 +7460,26 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       }
       return sessions.start(key, { cwd, cols, rows });
     },
+    "terminal:readFile": async (payload) => {
+      const p = obj(payload, "payload");
+      return readTerminalFile(terminalDirectory(p.sessionKey), str(p.path, "path"));
+    },
+    "terminal:existingFiles": async (payload) => {
+      const p = obj(payload, "payload");
+      if (!Array.isArray(p.paths)) invalid("paths must be an array");
+      return existingTerminalFiles(terminalDirectory(p.sessionKey), p.paths.map((value) => str(value, "path")));
+    },
+    "terminal:openFile": async (payload) => {
+      const p = obj(payload, "payload");
+      const file = await readTerminalFile(terminalDirectory(p.sessionKey), str(p.path, "path"), true);
+      if (!file.ok) return { ok: false, message: file.message };
+      try {
+        const message = await getPlatform().openPath(file.path);
+        return message ? { ok: false, message } : { ok: true };
+      } catch (error) {
+        return { ok: false, message: error instanceof Error ? error.message : "\u7121\u6CD5\u958B\u555F\u6A94\u6848\u3002" };
+      }
+    },
     "terminal:rename": (payload) => {
       const p = obj(payload, "payload");
       const key = str(p.sessionKey, "sessionKey");
@@ -7389,7 +7518,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs20.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs21.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -7436,7 +7565,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs20.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs21.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getSpecs": async (taskId) => {
@@ -7571,7 +7700,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       }
       await removeTaskWorktree(task);
       if (task.workspacePath) {
-        fs20.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
+        fs21.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
       }
       clearConversation(task.id);
       removeTask(task.id);
@@ -7624,9 +7753,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     // Watch the containing directory, not the file: JsonStore renames a temp
     // file over the target and so replaces the inode on every save.
     watchStore() {
-      const file = path23.basename(getStorePath());
+      const file = path24.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs20.watch(path23.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs21.watch(path24.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -7663,9 +7792,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import http from "http";
-import path24 from "path";
+import path25 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -7720,14 +7849,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path24.posix.normalize(decoded).replace(/^\/+/, "");
-  const base2 = path24.resolve(root);
-  const candidates = [rel, path24.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path25.posix.normalize(decoded).replace(/^\/+/, "");
+  const base2 = path25.resolve(root);
+  const candidates = [rel, path25.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path24.resolve(base2, c);
-    if (full !== base2 && !full.startsWith(base2 + path24.sep)) return null;
+    const full = path25.resolve(base2, c);
+    if (full !== base2 && !full.startsWith(base2 + path25.sep)) return null;
     try {
-      if (fs21.statSync(full).isFile()) return full;
+      if (fs22.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -7788,7 +7917,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path24.extname(file).toLowerCase();
+    const ext = path25.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -7801,7 +7930,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs21.createReadStream(file).pipe(res);
+    fs22.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -7900,8 +8029,8 @@ Content-Length: 0\r
 }
 
 // packages/cli/src/update-command.ts
-import fs22 from "node:fs";
-import path25 from "node:path";
+import fs23 from "node:fs";
+import path26 from "node:path";
 import { spawnSync } from "node:child_process";
 function npmRunner(args, inherit) {
   const spawnOpts = {
@@ -7913,7 +8042,7 @@ function npmRunner(args, inherit) {
 }
 function packageName(packageRoot) {
   try {
-    const pkg = JSON.parse(fs22.readFileSync(path25.join(packageRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs23.readFileSync(path26.join(packageRoot, "package.json"), "utf8"));
     if (typeof pkg.name !== "string") return null;
     return /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i.test(pkg.name) ? pkg.name : null;
   } catch {
@@ -7928,7 +8057,7 @@ function runUpdate(options) {
     error("vibeflow update \u53EA\u9069\u7528\u65BC\u5168\u57DF npm \u5B89\u88DD\uFF1B\u76EE\u524D\u662F\u539F\u59CB\u78BC\u7248\u672C\u3002");
     return 1;
   }
-  const packageRoot = path25.dirname(path25.dirname(options.cliEntry));
+  const packageRoot = path26.dirname(path26.dirname(options.cliEntry));
   const name = packageName(packageRoot);
   if (!name) {
     error("\u7121\u6CD5\u8FA8\u8B58\u76EE\u524D VibeFlow \u7684 npm \u5957\u4EF6\u540D\u7A31\uFF0C\u5DF2\u53D6\u6D88\u66F4\u65B0\u3002");
@@ -7940,8 +8069,8 @@ function runUpdate(options) {
     return 1;
   }
   try {
-    const globalPackage = path25.join(String(root.stdout).trim(), ...name.split("/"));
-    if (fs22.lstatSync(globalPackage).isSymbolicLink() || fs22.realpathSync(globalPackage) !== fs22.realpathSync(packageRoot)) {
+    const globalPackage = path26.join(String(root.stdout).trim(), ...name.split("/"));
+    if (fs23.lstatSync(globalPackage).isSymbolicLink() || fs23.realpathSync(globalPackage) !== fs23.realpathSync(packageRoot)) {
       error("vibeflow update \u53EA\u9069\u7528\u65BC\u5168\u57DF npm \u5B89\u88DD\uFF1B\u76EE\u524D\u57F7\u884C\u7684\u5957\u4EF6\u4F86\u81EA\u5176\u4ED6\u4F4D\u7F6E\u3002");
       return 1;
     }
@@ -8086,8 +8215,8 @@ async function openUpdateTerminal(platform = process.platform, run3 = launch) {
 }
 
 // packages/cli/src/self-update.ts
-import fs23 from "node:fs";
-import path26 from "node:path";
+import fs24 from "node:fs";
+import path27 from "node:path";
 import { execFile as execFile10 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
 var execFileAsync2 = promisify7(execFile10);
@@ -8096,7 +8225,7 @@ var PROBE_RETRY_MS = 3e4;
 var HOST_TOKEN_ENV = "VIBEFLOW_HOST_TOKEN";
 function readInstalledVersion(packageRoot) {
   try {
-    const pkg = JSON.parse(fs23.readFileSync(path26.join(packageRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs24.readFileSync(path27.join(packageRoot, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -8192,7 +8321,7 @@ async function startHost(options) {
     const core = createCore({ sessions, bus, version: options.version });
     let updateTimer = null;
     let installTimer = null;
-    const packageRoot = options.cliEntry ? path27.dirname(path27.dirname(options.cliEntry)) : null;
+    const packageRoot = options.cliEntry ? path28.dirname(path28.dirname(options.cliEntry)) : null;
     const updates = createUpdateMonitor({
       packageName: options.sourceRoot || !packageRoot ? null : packageName(packageRoot),
       currentVersion: options.version,
@@ -8280,7 +8409,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs24.existsSync(path27.join(dir, "home", "index.html"));
+  return fs25.existsSync(path28.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -8397,8 +8526,8 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs25 from "fs";
-import path28 from "path";
+import fs26 from "fs";
+import path29 from "path";
 import { execFile as execFile11 } from "child_process";
 import { promisify as promisify8 } from "util";
 init_env();
@@ -8538,10 +8667,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs25.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path28.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs25.writeFileSync(probe, "");
-    fs25.rmSync(probe);
+    fs26.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path29.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs26.writeFileSync(probe, "");
+    fs26.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -8595,25 +8724,25 @@ Options:
   -h, --help               Show this help
 `.trim();
 function detectLayout() {
-  const file = fileURLToPath(import.meta.url);
-  const here = path31.dirname(file);
-  const bundledWeb = path31.join(here, "web");
-  if (isWebDir(bundledWeb) || path31.basename(here) === "dist") {
+  const file = fileURLToPath2(import.meta.url);
+  const here = path32.dirname(file);
+  const bundledWeb = path32.join(here, "web");
+  if (isWebDir(bundledWeb) || path32.basename(here) === "dist") {
     return {
-      version: readVersion(path31.join(here, "..", "package.json")),
+      version: readVersion(path32.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path31.resolve(here, "..", "..", "..");
+  const root = path32.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path31.join(root, "app")) ? path31.join(root, "app") : null;
-  return { version: readVersion(path31.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path32.join(root, "app")) ? path32.join(root, "app") : null;
+  return { version: readVersion(path32.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs27.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs28.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -8851,8 +8980,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path31.resolve(target);
-  if (!fs27.existsSync(dir) || !fs27.statSync(dir).isDirectory()) {
+  const dir = path32.resolve(target);
+  if (!fs28.existsSync(dir) || !fs28.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }