@co0ontty/wand 1.18.12 → 1.21.4

package/dist/pty-text-utils.d.ts

@@ -5,8 +5,32 @@
 export declare function stripAnsi(text: string): string;
 /** Lines considered as UI noise that should be excluded from chat view. */
 export declare function isNoiseLine(line: string): boolean;
-/** Append text to a windowed buffer, trimming from start if over max size. */
+/**
+ * Append text to a windowed buffer, trimming from start if over max size.
+ *
+ * The cut point is chosen so it never lands inside:
+ * - a UTF-16 surrogate pair (would corrupt the leading codepoint)
+ * - an unterminated ANSI escape sequence (would feed orphan "[31m..."
+ *   text to a downstream terminal renderer)
+ *
+ * The returned buffer may be slightly shorter than maxSize.
+ */
 export declare function appendWindow(buffer: string, chunk: string, maxSize: number): string;
+/** Slice keeping the last ~maxSize chars on a safe boundary. Exported for tests. */
+export declare function safeSliceTail(text: string, maxSize: number): string;
+/**
+ * Strip a string down to the printable codepoints used for echo matching.
+ * Removes control characters, whitespace and ANSI escapes; keeps all other
+ * visible characters (including `/`, `()`, `:`, CJK, emoji, etc.) so that
+ * echo alignment works for any user input.
+ */
+export declare function stripForEchoMatch(input: string): string;
+/**
+ * Given an index pointing at ESC (0x1b), return the index of the first
+ * character AFTER the escape sequence. Handles CSI, OSC and simple ESC-
+ * letter forms. Returns idx+1 if nothing matches (best-effort skip).
+ */
+export declare function skipAnsiSequence(text: string, idx: number): number;
 export declare function hasExplicitConfirmSyntax(normalized: string): boolean;
 export declare function hasPermissionActionContext(normalized: string): boolean;
 /**

package/dist/pty-text-utils.js

@@ -115,10 +115,166 @@ export function isNoiseLine(line) {
         return true;
     return false;
 }
-/** Append text to a windowed buffer, trimming from start if over max size. */
+/**
+ * Append text to a windowed buffer, trimming from start if over max size.
+ *
+ * The cut point is chosen so it never lands inside:
+ * - a UTF-16 surrogate pair (would corrupt the leading codepoint)
+ * - an unterminated ANSI escape sequence (would feed orphan "[31m..."
+ *   text to a downstream terminal renderer)
+ *
+ * The returned buffer may be slightly shorter than maxSize.
+ */
 export function appendWindow(buffer, chunk, maxSize) {
     const next = buffer + chunk;
-    return next.length > maxSize ? next.slice(-maxSize) : next;
+    if (next.length <= maxSize)
+        return next;
+    return safeSliceTail(next, maxSize);
+}
+/** Slice keeping the last ~maxSize chars on a safe boundary. Exported for tests. */
+export function safeSliceTail(text, maxSize) {
+    if (text.length <= maxSize)
+        return text;
+    let start = text.length - maxSize;
+    // 1. Skip UTF-16 low surrogate half so we don't strand a high surrogate.
+    if (start > 0 && start < text.length) {
+        const code = text.charCodeAt(start);
+        if (code >= 0xdc00 && code <= 0xdfff)
+            start++;
+    }
+    // 2. Prefer cutting at the next newline within a small lookahead window.
+    //    Newlines are always safe boundaries (no ANSI sequence spans a newline
+    //    in well-formed terminal output) and keep lines aligned for replay.
+    const LOOKAHEAD = 4096;
+    const upper = Math.min(start + LOOKAHEAD, text.length);
+    for (let i = start; i < upper; i++) {
+        if (text.charCodeAt(i) === 0x0a)
+            return text.slice(i + 1);
+    }
+    // 3. No nearby newline. Detect whether `start` lands inside an open ANSI
+    //    escape sequence by scanning backward for an ESC (0x1b). If we find one
+    //    that is not yet terminated, advance past the sequence's final byte.
+    const lookback = Math.max(0, start - 256);
+    let escAt = -1;
+    for (let i = start - 1; i >= lookback; i--) {
+        const code = text.charCodeAt(i);
+        if (code === 0x1b) {
+            escAt = i;
+            break;
+        }
+        // If we hit a terminator before an ESC, the previous sequence is closed.
+        if (code === 0x07)
+            break;
+        if (code >= 0x40 && code <= 0x7e && i > 0 && isLikelyAnsiBody(text, i - 1))
+            break;
+    }
+    if (escAt !== -1) {
+        // OSC 序列以 `ESC ]` (0x1b 0x5d) 开头，必须用 BEL (0x07) 或
+        // ST (`ESC \\` = 0x1b 0x5c) 终止。其它范围内字节（包括裸 `\`）
+        // 都属于 payload，不能当终止符。CSI 等序列才用 0x40-0x7e final byte。
+        const isOsc = escAt + 1 < text.length && text.charCodeAt(escAt + 1) === 0x5d;
+        let terminated = false;
+        for (let i = escAt + 1; i < start; i++) {
+            const code = text.charCodeAt(i);
+            if (code === 0x07) {
+                terminated = true;
+                break;
+            }
+            if (isOsc) {
+                if (code === 0x1b && i + 1 < start && text.charCodeAt(i + 1) === 0x5c) {
+                    terminated = true;
+                    break;
+                }
+                continue;
+            }
+            if (code >= 0x40 && code <= 0x7e) {
+                terminated = true;
+                break;
+            }
+        }
+        if (!terminated) {
+            const ansiUpper = Math.min(start + 256, text.length);
+            for (let i = start; i < ansiUpper; i++) {
+                const code = text.charCodeAt(i);
+                if (code === 0x07)
+                    return text.slice(i + 1);
+                if (isOsc) {
+                    if (code === 0x1b && i + 1 < ansiUpper && text.charCodeAt(i + 1) === 0x5c) {
+                        return text.slice(i + 2);
+                    }
+                    continue;
+                }
+                if (code >= 0x40 && code <= 0x7e)
+                    return text.slice(i + 1);
+            }
+        }
+    }
+    return text.slice(start);
+}
+function isLikelyAnsiBody(text, idx) {
+    // CSI parameter/intermediate range covers most common ANSI bodies.
+    const code = text.charCodeAt(idx);
+    return code === 0x5b /* [ */ || code === 0x3f /* ? */ || (code >= 0x30 && code <= 0x3f);
+}
+/**
+ * Strip a string down to the printable codepoints used for echo matching.
+ * Removes control characters, whitespace and ANSI escapes; keeps all other
+ * visible characters (including `/`, `()`, `:`, CJK, emoji, etc.) so that
+ * echo alignment works for any user input.
+ */
+export function stripForEchoMatch(input) {
+    let out = "";
+    for (let i = 0; i < input.length; i++) {
+        const code = input.charCodeAt(i);
+        if (code === 0x1b) {
+            i = skipAnsiSequence(input, i) - 1;
+            continue;
+        }
+        if (code < 0x20 || code === 0x7f)
+            continue;
+        if (code === 0x20)
+            continue;
+        out += input[i];
+    }
+    return out;
+}
+/**
+ * Given an index pointing at ESC (0x1b), return the index of the first
+ * character AFTER the escape sequence. Handles CSI, OSC and simple ESC-
+ * letter forms. Returns idx+1 if nothing matches (best-effort skip).
+ */
+export function skipAnsiSequence(text, idx) {
+    if (text.charCodeAt(idx) !== 0x1b)
+        return idx;
+    const next = text.charCodeAt(idx + 1);
+    if (Number.isNaN(next))
+        return idx + 1;
+    // CSI: ESC [ ... final-byte (0x40-0x7E)
+    if (next === 0x5b /* [ */) {
+        let i = idx + 2;
+        while (i < text.length) {
+            const code = text.charCodeAt(i);
+            if (code >= 0x40 && code <= 0x7e)
+                return i + 1;
+            i++;
+        }
+        return text.length;
+    }
+    // OSC: ESC ] ... terminator (BEL or ESC \)
+    if (next === 0x5d /* ] */) {
+        let i = idx + 2;
+        while (i < text.length) {
+            const code = text.charCodeAt(i);
+            if (code === 0x07)
+                return i + 1;
+            if (code === 0x1b && text.charCodeAt(i + 1) === 0x5c)
+                return i + 2;
+            i++;
+        }
+        return text.length;
+    }
+    // Two-character ESC sequences (ESC = / ESC > / ESC M / etc.)
+    return idx + 2;
 }
 const EXPLICIT_CONFIRM_PATTERNS = [
     /(?:^|\b)(?:press\s+)?(?:y|yes)\s*(?:\/|\bor\b)\s*(?:n|no)(?:\b|$)/i,

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, onSessionCreated?: (cwd: string | undefined | null) => void): 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, onSessionCreated) {
     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 })));
@@ -145,19 +146,27 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         const body = req.body;
         console.log("[WAND] POST /api/structured-sessions body:", JSON.stringify({ cwd: body.cwd, mode: body.mode, runner: body.runner, provider: body.provider, worktreeEnabled: body.worktreeEnabled === true, hasPrompt: !!body.prompt, model: body.model }));
         try {
-            if (body.provider && body.provider !== "claude") {
-                res.status(400).json({ error: "结构化会话当前仅支持 Claude provider。" });
+            if (body.provider && body.provider !== "claude" && body.provider !== "codex") {
+                res.status(400).json({ error: "结构化会话当前仅支持 Claude 或 Codex provider。" });
                 return;
             }
+            const provider = body.provider === "codex" ? "codex" : "claude";
             const snapshot = structured.createSession({
                 cwd: body.cwd?.trim() || process.cwd(),
                 mode: normalizeMode(body.mode, defaultMode),
-                prompt: body.prompt,
-                runner: body.runner ?? "claude-cli-print",
+                provider,
+                runner: body.runner ?? (provider === "codex" ? "codex-cli-exec" : "claude-cli-print"),
                 worktreeEnabled: body.worktreeEnabled === true,
                 model: typeof body.model === "string" ? body.model.trim() : undefined,
             });
             console.log("[WAND] structured session created:", JSON.stringify({ id: snapshot.id, sessionKind: snapshot.sessionKind, runner: snapshot.runner, status: snapshot.status }));
+            onSessionCreated?.(body.cwd ?? snapshot.cwd);
+            const prompt = body.prompt?.trim();
+            if (prompt) {
+                const finished = await structured.sendMessage(snapshot.id, prompt);
+                res.status(201).json(finished);
+                return;
+            }
             res.status(201).json(snapshot);
         }
         catch (error) {
@@ -302,6 +311,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));
@@ -400,7 +480,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             }
             const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
             const resumeCommand = `${command} --resume ${claudeSessionId}`;
-            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId });
+            const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
+            const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
+            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId, cols: reqCols, rows: reqRows });
             res.status(201).json(newSnapshot);
         }
         catch (error) {
@@ -437,7 +519,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 }
                 const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
                 const resumeCommand = `${command} --resume ${claudeSessionId}`;
-                const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: existingSession.id });
+                const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
+                const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
+                const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: existingSession.id, cols: reqCols, rows: reqRows });
                 res.status(201).json({ resumedClaudeSessionId: claudeSessionId, ...newSnapshot });
             }
             else {
@@ -448,7 +532,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 }
                 const newMode = normalizeMode(body.mode, defaultMode);
                 const resumeCommand = `claude --resume ${claudeSessionId}`;
-                const newSnapshot = processes.start(resumeCommand, cwd, newMode);
+                const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
+                const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
+                const newSnapshot = processes.start(resumeCommand, cwd, newMode, undefined, { cols: reqCols, rows: reqRows });
                 res.status(201).json({ resumedClaudeSessionId: claudeSessionId, ...newSnapshot });
             }
         }

package/dist/server.d.ts

@@ -1,2 +1,23 @@
+import { ProcessManager } from "./process-manager.js";
+import { StructuredSessionManager } from "./structured-session-manager.js";
+import { WandStorage } from "./storage.js";
 import { WandConfig } from "./types.js";
-export declare function startServer(config: WandConfig, configPath: string): Promise<void>;
+/** Persist a cwd to recent paths. Used by both REST and session creation hooks. */
+export declare function recordRecentPath(storage: WandStorage, cwd: string | undefined | null): 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

@@ -16,11 +16,14 @@ import { ensureCertificates } from "./cert.js";
 import { isExecutionMode, normalizeCardDefaults, resolveConfigDir, saveConfig } from "./config.js";
 import { getCachedModels, refreshModels } from "./models.js";
 import { ProcessManager } from "./process-manager.js";
+import { SessionLogger } from "./session-logger.js";
 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 +448,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`);
@@ -467,6 +482,33 @@ function parseStoredPathList(raw) {
     }
 }
 const MAX_RECENT_PATHS = 10;
+/** Persist a cwd to recent paths. Used by both REST and session creation hooks. */
+export function recordRecentPath(storage, cwd) {
+    if (!cwd)
+        return;
+    const trimmed = cwd.trim();
+    if (!trimmed)
+        return;
+    let resolved;
+    try {
+        resolved = normalizeFolderPath(trimmed);
+    }
+    catch {
+        return;
+    }
+    if (isBlockedFolderPath(resolved))
+        return;
+    const stored = storage.getConfigValue("recent_paths");
+    let recent = parseStoredPathList(stored);
+    recent = recent.filter((r) => normalizeFolderPath(r.path) !== resolved);
+    recent.unshift({
+        path: resolved,
+        name: path.basename(resolved),
+        lastUsedAt: new Date().toISOString(),
+    });
+    recent = recent.slice(0, MAX_RECENT_PATHS);
+    storage.setConfigValue("recent_paths", JSON.stringify(recent));
+}
 // ── File language detection ──
 function getLanguageFromExt(ext, filePath) {
     const map = {
@@ -493,7 +535,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));
@@ -501,7 +542,8 @@ export async function startServer(config, configPath) {
     const configDir = resolveConfigDir(configPath);
     const avatarSeed = await ensureAvatarSeed(configDir);
     const processes = new ProcessManager(config, storage, configDir);
-    const structuredSessions = new StructuredSessionManager(storage, config);
+    const structuredLogger = new SessionLogger(configDir, config.shortcutLogMaxBytes);
+    const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger);
     const useHttps = config.https === true;
     const protocol = useHttps ? "https" : "http";
     const nodeModulesDir = path.join(RUNTIME_ROOT_DIR, "node_modules");
@@ -682,7 +724,10 @@ export async function startServer(config, configPath) {
             defaultMode: config.defaultMode,
             defaultCwd: config.defaultCwd,
             commandPresets: config.commandPresets,
-            structuredRunners: [{ label: "Claude Structured", runner: "claude-cli-print" }],
+            structuredRunners: [
+                { label: "Claude Structured", runner: "claude-cli-print" },
+                { label: "Codex Structured", runner: "codex-cli-exec" },
+            ],
             structuredChatPersona,
             cardDefaults: config.cardDefaults,
             updateAvailable: cachedUpdateInfo?.updateAvailable ?? false,
@@ -834,6 +879,7 @@ export async function startServer(config, configPath) {
         const cached = getCachedModels();
         res.json({
             models: cached.models,
+            codexModels: cached.codexModels,
             claudeVersion: cached.claudeVersion,
             refreshedAt: cached.refreshedAt,
             defaultModel: config.defaultModel ?? "",
@@ -844,6 +890,7 @@ export async function startServer(config, configPath) {
             const refreshed = await refreshModels();
             res.json({
                 models: refreshed.models,
+                codexModels: refreshed.codexModels,
                 claudeVersion: refreshed.claudeVersion,
                 refreshedAt: refreshed.refreshedAt,
                 defaultModel: config.defaultModel ?? "",
@@ -906,9 +953,33 @@ export async function startServer(config, configPath) {
             updateInFlight = false;
         }
     });
-    registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode);
+    registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode, config, (cwd) => {
+        recordRecentPath(storage, cwd);
+    });
     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 : "";
@@ -1063,18 +1134,12 @@ export async function startServer(config, configPath) {
             res.status(403).json({ error: "访问被拒绝：无法保存系统敏感目录。" });
             return;
         }
-        const stored = storage.getConfigValue("recent_paths");
-        let recent = parseStoredPathList(stored);
-        recent = recent.filter((r) => normalizeFolderPath(r.path) !== resolvedRecentPath);
-        const newRecent = {
+        recordRecentPath(storage, resolvedRecentPath);
+        res.json({
             path: resolvedRecentPath,
             name: path.basename(resolvedRecentPath),
             lastUsedAt: new Date().toISOString(),
-        };
-        recent.unshift(newRecent);
-        recent = recent.slice(0, MAX_RECENT_PATHS);
-        storage.setConfigValue("recent_paths", JSON.stringify(recent));
-        res.json(newRecent);
+        });
     });
     app.get("/api/validate-path", async (req, res) => {
         const inputPath = typeof req.query.path === "string" ? req.query.path : "";
@@ -1180,11 +1245,16 @@ export async function startServer(config, configPath) {
         try {
             const rawModel = typeof body.model === "string" ? body.model.trim() : "";
             const effectiveModel = rawModel || (config.defaultModel ?? "").trim() || undefined;
+            const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
+            const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
             const snapshot = processes.start(body.command, body.cwd, normalizeMode(body.mode, config.defaultMode), initialInput || undefined, {
                 worktreeEnabled: body.worktreeEnabled === true,
                 provider: body.provider,
                 model: effectiveModel,
+                cols: reqCols,
+                rows: reqRows,
             });
+            recordRecentPath(storage, body.cwd ?? snapshot.cwd);
             res.status(201).json(snapshot);
         }
         catch (error) {
@@ -1240,11 +1310,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) => {
@@ -1260,6 +1339,8 @@ export async function startServer(config, configPath) {
     }
     // Start configured background sessions after the server is already reachable.
     processes.runStartupCommands();
+    // Pre-warm model cache (probes claude --version + codex debug models).
+    refreshModels().catch(() => { });
     // ── Auto-update endpoints ──
     app.get("/api/auto-update", (_req, res) => {
         const web = storage.getConfigValue("autoUpdateWeb") === "true";
@@ -1336,4 +1417,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,
+    };
 }