@co0ontty/wand 1.18.12 → 1.20.4

package/dist/process-manager.js

@@ -10,7 +10,7 @@ import { ClaudePtyBridge } from "./claude-pty-bridge.js";
 import { truncateMessagesForTransport } from "./message-truncator.js";
 import { appendWindow, hasExplicitConfirmSyntax, hasPermissionActionContext, normalizePromptText } from "./pty-text-utils.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
-import { getResumeCommandSessionId, hasRealConversationMessages, } from "./resume-policy.js";
+import { getResumeCommandSessionId } from "./resume-policy.js";
 function resolveProviderFromCommand(command) {
     return /^codex\b/.test(command.trim()) ? "codex" : "claude";
 }
@@ -127,52 +127,8 @@ function selectClaudeProjectSessionForRecord(record) {
     }
     return candidates[0] ?? null;
 }
-/**
- * Broader fallback: find a JSONL file by mtime proximity when strict
- * mtime-correlation fails (e.g., file existed before session but Claude
- * wrote conversation content during this session).
- * Looks for the most recently modified file that was active near the
- * session's start time and has real conversation content.
- */
-function selectClaudeProjectSessionByProximity(record) {
-    const hasUserTurn = record.messages.some((turn) => turn.role === "user"
-        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
-    if (!hasUserTurn) {
-        return null;
-    }
-    const startedAtMs = Date.parse(record.startedAt);
-    const now = Date.now();
-    // Look for files modified from ~60s before session start up to now
-    const proximityWindowMs = 60 * 1000;
-    const candidates = listClaudeProjectSessionCandidates(record.cwd)
-        .filter((candidate) => {
-        if (!Number.isFinite(startedAtMs))
-            return true;
-        return candidate.mtimeMs >= startedAtMs - proximityWindowMs
-            && candidate.mtimeMs <= now + DISCOVERY_RECENT_WINDOW_MS;
-    })
-        .map((candidate) => readClaudeProjectSessionDetails(candidate.filePath, candidate.id))
-        .filter((candidate) => Boolean(candidate?.hasConversation))
-        .sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return candidates[0] ?? null;
-}
-function getResumeEligibility(record) {
-    const hasClaudeSessionId = Boolean(record.claudeSessionId);
-    const hasRealConversation = hasRealConversationMessages(record.messages);
-    return {
-        hasClaudeSessionId,
-        hasRealConversation,
-        eligible: hasClaudeSessionId && hasRealConversation
-    };
-}
-function hasResumeEligibleConversation(record) {
-    return getResumeEligibility(record).eligible;
-}
 function getLatestClaudeProjectSessionId(record) {
-    // Try strict mtime-correlation first, then fall back to mtime proximity
-    return selectClaudeProjectSessionForRecord(record)?.id
-        ?? selectClaudeProjectSessionByProximity(record)?.id
-        ?? null;
+    return selectClaudeProjectSessionForRecord(record)?.id ?? null;
 }
 function listRecentClaudeProjectSessionIds(cwd, startedAt) {
     return listClaudeProjectSessionCandidates(cwd)
@@ -180,33 +136,6 @@ function listRecentClaudeProjectSessionIds(cwd, startedAt) {
         .sort((a, b) => b.mtimeMs - a.mtimeMs)
         .map((candidate) => candidate.id);
 }
-function findRealClaudeProjectSessionId(cwd, startedAt) {
-    // Strict mtime-based discovery first
-    const candidates = listRecentClaudeProjectSessionIds(cwd, startedAt)
-        .map((id) => {
-        const filePath = path.join(getClaudeProjectDir(cwd), `${id}.jsonl`);
-        return readClaudeProjectSessionDetails(filePath, id);
-    })
-        .filter((candidate) => Boolean(candidate?.hasConversation))
-        .sort((a, b) => b.mtimeMs - a.mtimeMs);
-    if (candidates.length > 0)
-        return candidates[0].id;
-    // Fallback: broader proximity search for files with conversation content
-    const startedAtMs = Date.parse(startedAt);
-    const now = Date.now();
-    const proximityWindowMs = 60 * 1000;
-    const proximityCandidates = listClaudeProjectSessionCandidates(cwd)
-        .filter((candidate) => {
-        if (!Number.isFinite(startedAtMs))
-            return true;
-        return candidate.mtimeMs >= startedAtMs - proximityWindowMs
-            && candidate.mtimeMs <= now + DISCOVERY_RECENT_WINDOW_MS;
-    })
-        .map((candidate) => readClaudeProjectSessionDetails(candidate.filePath, candidate.id))
-        .filter((candidate) => Boolean(candidate?.hasConversation))
-        .sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return proximityCandidates[0]?.id ?? null;
-}
 function isClaudeSessionFileAvailable(cwd, claudeSessionId) {
     const filePath = path.join(getClaudeProjectDir(cwd), `${claudeSessionId}.jsonl`);
     return Boolean(readClaudeProjectSessionDetails(filePath, claudeSessionId));
@@ -348,18 +277,6 @@ function listAllClaudeHistorySessions() {
         return [];
     }
 }
-function shouldAutoResumeSession(record) {
-    return record.status === "exited"
-        && !record.archived
-        && record.ptyProcess === null
-        && hasResumeEligibleConversation(record);
-}
-function shouldBackfillClaudeSessionId(record) {
-    return record.status === "exited"
-        && !record.claudeSessionId
-        && /^claude\b/.test(record.command.trim())
-        && hasRealConversationMessages(record.messages);
-}
 function snapshotMessages(record) {
     return record.ptyBridge?.getMessages() ?? record.messages;
 }
@@ -455,6 +372,8 @@ export class ProcessManager extends EventEmitter {
     persistDebounceTimers = new Map();
     /** Last persisted message state per session — used to skip redundant message writes */
     lastPersistedMessageState = new Map();
+    /** 启动时被识别为孤儿 PTY 并标记为 exited 的旧会话数（旧服务器进程已死） */
+    orphanRecoveredCount = 0;
     constructor(config, storage, configDir) {
         super();
         this.config = config;
@@ -509,7 +428,7 @@ export class ProcessManager extends EventEmitter {
                     claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId,
                     approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
                 });
-                console.error(`[ProcessManager] Restored session ${snapshot.id} marked as exited (PTY orphaned)`);
+                this.orphanRecoveredCount += 1;
             }
             else {
                 this.sessions.set(snapshot.id, {
@@ -544,12 +463,6 @@ export class ProcessManager extends EventEmitter {
                 });
             }
         }
-        // Defer expensive file-system scanning and auto-recovery so the server
-        // can start responding to requests immediately.
-        setImmediate(() => {
-            this.backfillExitedClaudeSessionIds();
-            this.autoRecoverExitedSessions();
-        });
         this.archiveExpiredSessions();
         this.archiveTimer = setInterval(() => {
             try {
@@ -564,6 +477,10 @@ export class ProcessManager extends EventEmitter {
     on(event, listener) {
         return super.on("process", listener);
     }
+    /** 启动时被识别为孤儿 PTY 并标记为 exited 的旧会话数量（仅用于启动摘要展示）。 */
+    getOrphanRecoveredCount() {
+        return this.orphanRecoveredCount;
+    }
     emitEvent(event) {
         this.emit("process", event);
     }
@@ -939,15 +856,13 @@ export class ProcessManager extends EventEmitter {
     get(id) {
         const record = this.sessions.get(id);
         if (!record) {
-            // Fallback: check SQLite for sessions that were evicted from memory
             return this.storage.getSession(id) ?? null;
         }
-        // For sessions loaded from storage on startup, in-memory output starts empty.
-        // Prefer in-memory output (live PTY data), fall back to stored output.
+        const result = this.snapshot(record);
         if (!record.output && record.storedOutput) {
-            record.output = record.storedOutput;
+            result.output = record.storedOutput;
         }
-        return this.snapshot(record);
+        return result;
     }
     getPtyTranscript(id) {
         return this.logger.readPtyOutput(id);
@@ -1374,70 +1289,6 @@ export class ProcessManager extends EventEmitter {
         }
         this.persist(record);
     }
-    backfillExitedClaudeSessionIds() {
-        for (const record of this.sessions.values()) {
-            record.messages = snapshotMessages(record);
-            if (!shouldBackfillClaudeSessionId(record)) {
-                continue;
-            }
-            const discoveredSessionId = findRealClaudeProjectSessionId(record.cwd, record.startedAt);
-            if (!discoveredSessionId) {
-                continue;
-            }
-            record.claudeSessionId = discoveredSessionId;
-            this.persist(record);
-        }
-    }
-    /**
-     * Auto-recover the most recent exited session that has a Claude session ID.
-     * Only resumes one session per server start, using the most recent eligible
-     * session. Reuses the original session ID (in-place resume) and sets
-     * `autoRecovered: true`.
-     */
-    autoRecoverExitedSessions() {
-        // Find eligible exited sessions
-        const eligibleSessions = [];
-        for (const record of this.sessions.values()) {
-            record.messages = snapshotMessages(record);
-            if (shouldAutoResumeSession(record)) {
-                eligibleSessions.push(record);
-            }
-        }
-        if (eligibleSessions.length === 0)
-            return;
-        // Sort by startedAt descending (most recent first)
-        eligibleSessions.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
-        // Only auto-recover the single most recent session
-        const original = eligibleSessions[0];
-        const isClaude = /^claude\b/.test(original.command.trim());
-        if (!isClaude)
-            return;
-        // If no claudeSessionId is bound yet, try to discover it via proximity search
-        if (!original.claudeSessionId) {
-            const discovered = findRealClaudeProjectSessionId(original.cwd, original.startedAt);
-            if (discovered) {
-                original.claudeSessionId = discovered;
-                process.stderr.write(`[wand] Backfilled Claude session ID for auto-recovery: ${discovered}\n`);
-                this.persist(original);
-            }
-        }
-        if (!original.claudeSessionId) {
-            console.error(`[ProcessManager] Skipping auto-recovery: no Claude session ID for session ${original.id}`);
-            return;
-        }
-        console.error(`[ProcessManager] Auto-recovering session ${original.id} with Claude session ID ${original.claudeSessionId}`);
-        const resumeCommand = `${original.command.trim()} --resume ${original.claudeSessionId}`;
-        try {
-            const snapshot = this.start(resumeCommand, original.cwd, original.mode, undefined, {
-                reuseId: original.id,
-                autoRecovered: true
-            });
-            console.error(`[ProcessManager] Auto-recovered session ${snapshot.id} (in-place)`);
-        }
-        catch (err) {
-            console.error(`[ProcessManager] Auto-recovery failed: ${String(err)}`);
-        }
-    }
     archiveExpiredSessions() {
         const now = Date.now();
         for (const record of this.sessions.values()) {

package/dist/prompt-optimizer.d.ts

@@ -0,0 +1,5 @@
+export declare class PromptOptimizeError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare function optimizePrompt(rawText: string, language: string, cwd?: string): Promise<string>;

package/dist/prompt-optimizer.js

@@ -0,0 +1,72 @@
+import { execFile } from "node:child_process";
+const CLAUDE_TIMEOUT_MS = 60_000;
+const MAX_INPUT_LENGTH = 8000;
+export class PromptOptimizeError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "PromptOptimizeError";
+    }
+}
+function callClaudeText(prompt, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = execFile("claude", ["-p", "--output-format", "text"], {
+            cwd: cwd && cwd.length > 0 ? cwd : undefined,
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+            timeout: CLAUDE_TIMEOUT_MS,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const e = error;
+                if (e.code === "ENOENT") {
+                    reject(new PromptOptimizeError("未找到 claude CLI。", "CLAUDE_CLI_MISSING"));
+                    return;
+                }
+                if (e.code === "ETIMEDOUT") {
+                    reject(new PromptOptimizeError("Claude 优化超时，请稍后重试。", "CLAUDE_TIMEOUT"));
+                    return;
+                }
+                const msg = (stderr || "").trim() || e.message || "claude 调用失败";
+                reject(new PromptOptimizeError(`Claude CLI 失败：${msg}`, "CLAUDE_CLI_FAILED"));
+                return;
+            }
+            resolve((stdout || "").trim());
+        });
+        child.stdin?.end(prompt);
+    });
+}
+function buildOptimizePrompt(userInput, language) {
+    const lang = (language || "").trim() || "中文";
+    return [
+        `你是一名提示词优化助手。请把用户写给编码 AI 的「原始提示词」改写得更清晰、结构化、可执行，便于 AI 理解并完成任务。`,
+        `要求：`,
+        `1. 保留用户原意和所有关键信息（文件路径、变量名、技术名词、数字、约束等），不要删减事实，也不要新增臆测的需求。`,
+        `2. 必要时拆分为「目标 / 上下文 / 约束 / 验收标准」几个部分；如果原文很短或很简单，则只做语句润色，不要硬塞结构。`,
+        `3. 用${lang}输出。语气克制专业，不寒暄、不解释你做了什么。`,
+        `4. 只输出优化后的提示词正文，不要包裹在代码块或引号里，不要加任何前后缀（比如「优化后：」之类）。`,
+        ``,
+        `原始提示词：`,
+        userInput,
+    ].join("\n");
+}
+export async function optimizePrompt(rawText, language, cwd) {
+    const text = (rawText || "").trim();
+    if (!text) {
+        throw new PromptOptimizeError("请先输入要优化的内容。", "EMPTY_INPUT");
+    }
+    if (text.length > MAX_INPUT_LENGTH) {
+        throw new PromptOptimizeError(`输入过长（${text.length} 字符），请缩短到 ${MAX_INPUT_LENGTH} 以内。`, "INPUT_TOO_LONG");
+    }
+    const prompt = buildOptimizePrompt(text, language);
+    const raw = await callClaudeText(prompt, cwd);
+    const cleaned = raw
+        .replace(/^```[a-zA-Z]*\n?/, "")
+        .replace(/\n?```$/, "")
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .trim();
+    if (!cleaned) {
+        throw new PromptOptimizeError("Claude 返回了空结果。", "EMPTY_RESULT");
+    }
+    return cleaned;
+}

package/dist/server-session-routes.d.ts

@@ -2,7 +2,7 @@ import { Express } from "express";
 import { ProcessManager } from "./process-manager.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
 import { WandStorage } from "./storage.js";
-import { ExecutionMode } from "./types.js";
+import { ExecutionMode, WandConfig } from "./types.js";
 export declare function getErrorMessage(error: unknown, fallback: string): string;
-export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode): void;
+export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig): void;
 export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, storage: WandStorage): void;

package/dist/server-session-routes.js

@@ -1,6 +1,7 @@
 import express from "express";
 import { SessionInputError } from "./process-manager.js";
 import { checkSessionWorktreeMergeability, cleanupSessionWorktree, getWorktreeMergeErrorCode, mergeSessionWorktree, WorktreeMergeError } from "./git-worktree.js";
+import { getGitStatus, QuickCommitError, runQuickCommit, generateCommitMessageOnly } from "./git-quick-commit.js";
 export function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
@@ -135,7 +136,7 @@ function canMergeSession(snapshot) {
 function isMergeActionAllowed(snapshot) {
     return snapshot.status !== "running";
 }
-export function registerSessionRoutes(app, processes, structured, storage, defaultMode) {
+export function registerSessionRoutes(app, processes, structured, storage, defaultMode, config) {
     app.get("/api/sessions", (_req, res) => {
         const all = listAllSessionsSlim(processes, structured);
         console.log("[WAND] GET /api/sessions count:", all.length, "sessions:", all.map(s => ({ id: s.id.substring(0, 8), kind: s.sessionKind, runner: s.runner, status: s.status })));
@@ -302,6 +303,77 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(getWorktreeMergeResponseStatus(error)).json(getWorktreeMergePayload(error, "无法合并 worktree。"));
         }
     });
+    app.get("/api/sessions/:id/git-status", (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.json({ isGit: false });
+            return;
+        }
+        try {
+            res.json(getGitStatus(snapshot.cwd));
+        }
+        catch (error) {
+            res.json({ isGit: false, error: getErrorMessage(error, "无法读取 git 状态。") });
+        }
+    });
+    app.post("/api/sessions/:id/quick-commit", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runQuickCommit({
+                cwd: snapshot.cwd,
+                language: config.language ?? "",
+                autoMessage: body.autoMessage !== false,
+                customMessage: typeof body.customMessage === "string" ? body.customMessage : undefined,
+                tag: typeof body.tag === "string" ? body.tag : undefined,
+                autoTag: !!body.autoTag,
+                push: !!body.push,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                const status = error.code === "NOTHING_TO_COMMIT" || error.code === "TAG_EXISTS" ? 409 : 400;
+                res.status(status).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "快捷提交失败。") });
+        }
+    });
+    app.post("/api/sessions/:id/generate-commit-message", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。" });
+            return;
+        }
+        try {
+            const message = await generateCommitMessageOnly(snapshot.cwd, config.language ?? "");
+            res.json({ message });
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                res.status(400).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "生成 commit message 失败。") });
+        }
+    });
     app.post("/api/sessions/:id/worktree/cleanup", (req, res) => {
         try {
             const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));

package/dist/server.d.ts

@@ -1,2 +1,20 @@
+import { ProcessManager } from "./process-manager.js";
+import { StructuredSessionManager } from "./structured-session-manager.js";
 import { WandConfig } from "./types.js";
-export declare function startServer(config: WandConfig, configPath: string): Promise<void>;
+export interface ServerUrl {
+    url: string;
+    scheme: "HTTP" | "HTTPS";
+}
+export interface ServerHandle {
+    processManager: ProcessManager;
+    structuredSessions: StructuredSessionManager;
+    configPath: string;
+    dbPath: string;
+    urls: ServerUrl[];
+    bindAddr: string;
+    httpsEnabled: boolean;
+    version: string;
+    orphanRecoveredCount: number;
+    close(): Promise<void>;
+}
+export declare function startServer(config: WandConfig, configPath: string): Promise<ServerHandle>;

package/dist/server.js

@@ -20,7 +20,9 @@ import { StructuredSessionManager } from "./structured-session-manager.js";
 import { generatePwaManifest, generateServiceWorker } from "./pwa.js";
 import { getErrorMessage, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
 import { registerUploadRoutes } from "./upload-routes.js";
+import { optimizePrompt, PromptOptimizeError } from "./prompt-optimizer.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
+import { isLogBusActive, wandTuiLog } from "./tui/log-bus.js";
 import { renderApp } from "./web-ui/index.js";
 import { WsBroadcastManager } from "./ws-broadcast.js";
 import { checkRateLimit, recordFailedLogin, resetRateLimit } from "./middleware/rate-limit.js";
@@ -445,12 +447,24 @@ process.on("unhandledRejection", (reason) => {
     wandError("未处理的异步错误", msg);
 });
 function wandError(label, message, suggestion) {
+    if (isLogBusActive()) {
+        wandTuiLog("error", `✗ [wand] ${label}：${message}`);
+        if (suggestion)
+            wandTuiLog("error", `  解决方法：${suggestion}`);
+        return;
+    }
     process.stderr.write(`\n✗ [wand] ${label}：${message}\n`);
     if (suggestion)
         process.stderr.write(`  解决方法：${suggestion}\n`);
     process.stderr.write("\n");
 }
 function wandWarn(message, hint) {
+    if (isLogBusActive()) {
+        wandTuiLog("warn", `⚠️  [wand] 警告：${message}`);
+        if (hint)
+            wandTuiLog("warn", `  提示：${hint}`);
+        return;
+    }
     process.stderr.write(`⚠️  [wand] 警告：${message}\n`);
     if (hint)
         process.stderr.write(`  提示：${hint}\n`);
@@ -493,7 +507,6 @@ function getLanguageFromExt(ext, filePath) {
         return "plaintext";
     return map[ext] || "plaintext";
 }
-// ── Main server ──
 export async function startServer(config, configPath) {
     const app = express();
     const storage = new WandStorage(resolveDatabasePath(configPath));
@@ -906,9 +919,31 @@ export async function startServer(config, configPath) {
             updateInFlight = false;
         }
     });
-    registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode);
+    registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode, config);
     registerClaudeHistoryRoutes(app, processes, storage);
     registerUploadRoutes(app, processes);
+    app.post("/api/optimize-prompt", express.json({ limit: "256kb" }), async (req, res) => {
+        const body = (req.body ?? {});
+        const text = typeof body.text === "string" ? body.text : "";
+        let cwd;
+        if (typeof body.sessionId === "string" && body.sessionId.length > 0) {
+            const snap = storage.getSession(body.sessionId);
+            if (snap?.cwd)
+                cwd = snap.cwd;
+        }
+        try {
+            const optimized = await optimizePrompt(text, config.language ?? "", cwd);
+            res.json({ optimized });
+        }
+        catch (error) {
+            if (error instanceof PromptOptimizeError) {
+                const status = error.code === "EMPTY_INPUT" || error.code === "INPUT_TOO_LONG" ? 400 : 500;
+                res.status(status).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(500).json({ error: getErrorMessage(error, "提示词优化失败。") });
+        }
+    });
     // ── Path suggestion ──
     app.get("/api/path-suggestions", async (req, res) => {
         const query = typeof req.query.q === "string" ? req.query.q : "";
@@ -1240,11 +1275,20 @@ export async function startServer(config, configPath) {
             setTimeout(() => process.exit(0), 5000);
         }, 600);
     });
+    let bindAddr = config.host === "0.0.0.0" ? "0.0.0.0" : config.host;
+    const collectedUrls = [];
     await new Promise((resolve, reject) => {
         server.listen(config.port, config.host, () => {
-            const listenAddr = config.host === "0.0.0.0" ? "0.0.0.0 (所有接口)" : config.host;
-            process.stdout.write(`[wand] Web console listening on ${listenAddr}:${config.port}\n` +
-                `[wand] 本地访问: ${protocol}://127.0.0.1:${config.port}\n`);
+            bindAddr = `${config.host}:${config.port}`;
+            const scheme = useHttps ? "HTTPS" : "HTTP";
+            // 主 URL：本机回环；若绑定 0.0.0.0 再补一个对外提示。
+            collectedUrls.push({ url: `${protocol}://127.0.0.1:${config.port}`, scheme });
+            if (config.host === "0.0.0.0") {
+                collectedUrls.push({ url: `${protocol}://0.0.0.0:${config.port}`, scheme });
+            }
+            else if (config.host !== "127.0.0.1" && config.host !== "localhost") {
+                collectedUrls.push({ url: `${protocol}://${config.host}:${config.port}`, scheme });
+            }
             resolve();
         });
         server.on("error", (err) => {
@@ -1336,4 +1380,45 @@ export async function startServer(config, configPath) {
     setInterval(() => {
         performAutoUpdate().catch(() => { });
     }, 30 * 60 * 1000);
+    const close = () => new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            try {
+                storage.close();
+            }
+            catch { /* ignore */ }
+            resolve();
+        };
+        try {
+            wss.clients.forEach((c) => c.close());
+        }
+        catch { /* ignore */ }
+        try {
+            wss.close();
+        }
+        catch { /* ignore */ }
+        try {
+            server.close(() => finish());
+        }
+        catch {
+            finish();
+            return;
+        }
+        setTimeout(finish, 3000); // 兜底：3s 内未关完强制 resolve
+    });
+    return {
+        processManager: processes,
+        structuredSessions,
+        configPath,
+        dbPath: resolveDatabasePath(configPath),
+        urls: collectedUrls,
+        bindAddr,
+        httpsEnabled: useHttps,
+        version: PKG_VERSION,
+        orphanRecoveredCount: processes.getOrphanRecoveredCount(),
+        close,
+    };
 }

package/dist/tui/index.d.ts

@@ -0,0 +1,24 @@
+import { ProcessManager } from "../process-manager.js";
+import { StructuredSessionManager } from "../structured-session-manager.js";
+export interface TuiDeps {
+    processManager: ProcessManager;
+    structuredSessions: StructuredSessionManager;
+    version: string;
+    configPath: string;
+    dbPath: string;
+    bindAddr: string;
+    httpsEnabled: boolean;
+    urls: Array<{
+        url: string;
+        scheme: "HTTP" | "HTTPS";
+    }>;
+    orphanRecoveredCount: number;
+    /** 退出 TUI 时调用。返回的 Promise resolve 后 cli 才会 process.exit。 */
+    onExit: (reason: ExitReason) => void | Promise<void>;
+}
+export type ExitReason = "user" | "signal" | "error";
+export interface TuiHandle {
+    isActive: boolean;
+    stop(reason: ExitReason): Promise<void>;
+}
+export declare function startTui(deps: TuiDeps): TuiHandle;