cli-link 0.0.1

package/dist/server/index.js

@@ -0,0 +1,2097 @@
+import { createServer as createHttpServer } from 'http';
+import { createServer as createHttpsServer } from 'https';
+import { WebSocketServer, WebSocket } from 'ws';
+import { CLIManager } from './cli-manager.js';
+import { renderTerminalQr } from './terminal-qr.js';
+import * as store from './store.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { timingSafeEqual } from 'crypto';
+import { execFileSync } from 'child_process';
+import { fileURLToPath } from 'url';
+const PORT = parseInt(process.env.PORT || '3101', 10);
+const HOST = process.env.HOST || '0.0.0.0';
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const STATIC_DIR = resolveStaticDir();
+const IS_NPX_ENTRY = process.env.AGENTPILOT_NPX === '1';
+const AUTH_COOKIE_NAME = 'agentpilot_token';
+const AUTH_TOKEN = (process.env.AGENTPILOT_AUTH_TOKEN || '').trim();
+const AUTH_ENABLED = AUTH_TOKEN.length > 0;
+function resolveEnvPath(value) {
+    if (value === '~')
+        return os.homedir();
+    if (value.startsWith('~/'))
+        return path.join(os.homedir(), value.slice(2));
+    return path.resolve(value);
+}
+function loadHttpsOptions() {
+    const keyPath = process.env.AGENTPILOT_HTTPS_KEY || process.env.HTTPS_KEY;
+    const certPath = process.env.AGENTPILOT_HTTPS_CERT || process.env.HTTPS_CERT;
+    if (!keyPath && !certPath)
+        return null;
+    if (!keyPath || !certPath) {
+        throw new Error('Both AGENTPILOT_HTTPS_KEY and AGENTPILOT_HTTPS_CERT are required to enable HTTPS.');
+    }
+    return {
+        key: fs.readFileSync(resolveEnvPath(keyPath)),
+        cert: fs.readFileSync(resolveEnvPath(certPath)),
+    };
+}
+function resolveStaticDir() {
+    const configured = process.env.AGENTPILOT_STATIC_DIR;
+    const candidates = [
+        configured ? resolveEnvPath(configured) : '',
+        path.resolve(MODULE_DIR, '..', 'client'),
+        path.resolve(MODULE_DIR, '..', 'dist', 'client'),
+        path.resolve(process.cwd(), 'dist', 'client'),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        try {
+            const stat = fs.statSync(path.join(candidate, 'index.html'));
+            if (stat.isFile())
+                return candidate;
+        }
+        catch { }
+    }
+    if (configured) {
+        console.warn(`[AgentPilot] Static client not found at ${resolveEnvPath(configured)}`);
+    }
+    return null;
+}
+function readStartupConfig() {
+    const config = {};
+    const workDir = process.env.AGENTPILOT_WORKDIR;
+    const cliType = process.env.AGENTPILOT_CLI_TYPE;
+    const cliCommand = process.env.AGENTPILOT_CLI_COMMAND;
+    if (workDir)
+        config.workDir = resolveEnvPath(workDir);
+    if (cliType === 'codex' || cliType === 'claude')
+        config.cliType = cliType;
+    if (cliCommand)
+        config.cliCommand = cliCommand;
+    return config;
+}
+// Initialize database
+store.initDb();
+const httpsOptions = loadHttpsOptions();
+const server = httpsOptions ? createHttpsServer(httpsOptions, requestListener) : createHttpServer(requestListener);
+const httpScheme = httpsOptions ? 'https' : 'http';
+const wsScheme = httpsOptions ? 'wss' : 'ws';
+function requestListener(req, res) {
+    handleHttpRequest(req, res).catch((err) => {
+        console.error('[HTTP] request failed:', err);
+        sendJson(res, 500, { error: err?.message || '服务端错误' });
+    });
+}
+const wss = new WebSocketServer({ noServer: true });
+server.on('upgrade', (req, socket, head) => {
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    if (!isRequestAuthorized(req, url)) {
+        socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\nContent-Length: 0\r\n\r\n');
+        socket.destroy();
+        return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit('connection', ws, req);
+    });
+});
+const cliManager = new CLIManager();
+const clients = new Set();
+function unquoteMetaValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function readSkillMeta(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (!match)
+            return {};
+        const meta = {};
+        for (const line of match[1].split('\n')) {
+            const idx = line.indexOf(':');
+            if (idx <= 0)
+                continue;
+            const key = line.slice(0, idx).trim();
+            const value = unquoteMetaValue(line.slice(idx + 1));
+            if (key === 'name')
+                meta.name = value;
+            if (key === 'description')
+                meta.description = value;
+        }
+        return meta;
+    }
+    catch {
+        return {};
+    }
+}
+function collectSkillFiles(root, maxDepth) {
+    const result = [];
+    const resolved = root.startsWith('~') ? root.replace('~', os.homedir()) : root;
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isFile() && entry.name === 'SKILL.md') {
+                result.push(entryPath);
+            }
+            else if (entry.isDirectory()) {
+                walk(entryPath, depth + 1);
+            }
+        }
+    }
+    walk(resolved, 0);
+    return result;
+}
+function getSkillSource(filePath) {
+    const home = os.homedir();
+    if (filePath.startsWith(path.join(home, '.agents', 'skills')))
+        return 'Agents';
+    if (filePath.startsWith(path.join(home, '.codex', 'skills')))
+        return 'Codex';
+    if (filePath.startsWith(path.join(home, '.claude', 'skills')))
+        return 'Claude';
+    if (filePath.includes(`${path.sep}.codex${path.sep}plugins${path.sep}cache${path.sep}`))
+        return 'Plugin';
+    return 'Workspace';
+}
+function discoverSkills(workDir) {
+    const home = os.homedir();
+    const resolvedWorkDir = workDir?.startsWith('~') ? workDir.replace('~', home) : workDir;
+    const roots = [
+        { dir: path.join(home, '.agents', 'skills'), depth: 3 },
+        { dir: path.join(home, '.codex', 'skills'), depth: 4 },
+        { dir: path.join(home, '.claude', 'skills'), depth: 4 },
+        { dir: path.join(home, '.codex', 'plugins', 'cache'), depth: 8 },
+        ...(resolvedWorkDir ? [
+            { dir: path.join(resolvedWorkDir, '.agents', 'skills'), depth: 4 },
+            { dir: path.join(resolvedWorkDir, '.codex', 'skills'), depth: 4 },
+            { dir: path.join(resolvedWorkDir, '.claude', 'skills'), depth: 4 },
+        ] : []),
+    ];
+    const byName = new Map();
+    for (const root of roots) {
+        for (const skillPath of collectSkillFiles(root.dir, root.depth)) {
+            const meta = readSkillMeta(skillPath);
+            const fallbackName = path.basename(path.dirname(skillPath));
+            const name = (meta.name || fallbackName).trim();
+            if (!name || byName.has(name))
+                continue;
+            byName.set(name, {
+                name,
+                command: `/${name}`,
+                description: meta.description || 'Skill',
+                path: skillPath,
+                source: getSkillSource(skillPath),
+            });
+        }
+    }
+    return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+// Map server event types to client-side MessageType values.
+// Returns null for non-displayable types (status, confirm_mode_changed).
+function mapMessageType(eventType) {
+    const mapping = {
+        'user_message': 'user',
+        'ai_message': 'ai',
+        'thinking_message': 'thinking',
+        'tool_call': 'tool',
+        'confirm_request': 'confirm',
+        'confirm_result': 'confirm',
+        'ask_question': 'question',
+        'ask_question_result': 'question',
+        'system': 'system',
+        'error': 'error',
+        'status': null,
+        'confirm_mode_changed': null,
+    };
+    if (eventType in mapping)
+        return mapping[eventType];
+    return eventType;
+}
+function parseJsonField(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSessionConfig(session) {
+    const parsed = parseJsonField(session?.cli_config);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+}
+function getCliSessionIdFromMessages(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const details = parseJsonField(messages[i].details);
+        const sessionId = details?.session_id;
+        if (typeof sessionId === 'string' && sessionId.length > 8) {
+            return sessionId;
+        }
+    }
+    return undefined;
+}
+function getRestorableCliSessionId(sessionId, messages) {
+    if (!sessionId)
+        return undefined;
+    const session = store.getSessionById(sessionId);
+    const config = getSessionConfig(session);
+    if (typeof config.cliSessionId === 'string' && config.cliSessionId.length > 8) {
+        return config.cliSessionId;
+    }
+    if (messages) {
+        return getCliSessionIdFromMessages(messages);
+    }
+    return store.getLatestCliSessionIdFromMessages(sessionId);
+}
+function toClientMessage(m) {
+    const mappedType = mapMessageType(m.type);
+    if (mappedType === null)
+        return null;
+    const parsedDetails = parseJsonField(m.details);
+    const isQuestion = mappedType === 'question' && m.type === 'ask_question';
+    return {
+        seq: m.seq,
+        id: m.id,
+        type: mappedType,
+        content: m.content,
+        time: m.time,
+        status: m.status || undefined,
+        toolName: m.toolName || undefined,
+        toolDetails: m.toolDetails || undefined,
+        toolUseId: m.toolUseId || undefined,
+        toolResult: m.toolResult || undefined,
+        permission: parseJsonField(m.permission),
+        details: parsedDetails,
+        question: isQuestion && parsedDetails ? { questions: parsedDetails.questions || [], toolUseId: parsedDetails.toolUseId } : undefined,
+    };
+}
+function toClientMessages(messages) {
+    return messages.map(toClientMessage).filter((m) => m !== null);
+}
+function readPositiveInt(value, fallback = 0) {
+    const parsed = Number(value || 0);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return fallback;
+    return Math.floor(parsed);
+}
+function calculateSessionTokenUsage(sessionId) {
+    return store.getSessionDetails(sessionId).reduce((usage, rawDetails) => {
+        const details = parseJsonField(rawDetails);
+        if (!details || details.subtype !== 'result')
+            return usage;
+        return {
+            inputTokens: usage.inputTokens + Number(details.inputTokens || 0),
+            outputTokens: usage.outputTokens + Number(details.outputTokens || 0),
+            cacheReadTokens: usage.cacheReadTokens + Number(details.cacheReadTokens || 0),
+            cacheCreationTokens: usage.cacheCreationTokens + Number(details.cacheCreationTokens || 0),
+            costUsd: usage.costUsd + Number(details.costUsd || 0),
+        };
+    }, { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0 });
+}
+function buildSessionData(sessionId, options = {}) {
+    const afterSeq = readPositiveInt(options.afterSeq);
+    const beforeSeq = readPositiveInt(options.beforeSeq);
+    const limit = readPositiveInt(options.limit);
+    let messages;
+    if (afterSeq > 0) {
+        messages = store.getSessionMessages(sessionId, afterSeq);
+    }
+    else if (beforeSeq > 0 && limit > 0) {
+        messages = store.getSessionMessagesBefore(sessionId, beforeSeq, limit);
+    }
+    else if (limit > 0) {
+        messages = store.getRecentSessionMessages(sessionId, limit);
+    }
+    else {
+        messages = store.getSessionMessages(sessionId);
+    }
+    const firstSeq = messages[0]?.seq || 0;
+    return {
+        sessionId,
+        messages: toClientMessages(messages),
+        lastSeq: store.getLastSeq(sessionId),
+        firstSeq,
+        hasMoreBefore: firstSeq > 0 ? store.hasSessionMessagesBefore(sessionId, firstSeq) : false,
+        tokenUsage: calculateSessionTokenUsage(sessionId),
+    };
+}
+function buildEditPrompt(prefixMessages, editedContent) {
+    const entries = [];
+    const pushEntry = (label, content) => {
+        const last = entries[entries.length - 1];
+        if (last && last.label === label && label === '助手') {
+            last.content += content;
+            return;
+        }
+        entries.push({ label, content });
+    };
+    for (const message of prefixMessages) {
+        const content = (message.content || '').trim();
+        if (!content)
+            continue;
+        if (message.type === 'user_message' || message.type === 'user') {
+            pushEntry('用户', content);
+        }
+        else if (message.type === 'ai_message' || message.type === 'ai') {
+            pushEntry('助手', content);
+        }
+        else if (message.type === 'tool_call' || message.type === 'tool') {
+            const parts = [content];
+            if (message.toolDetails)
+                parts.push(`输入: ${message.toolDetails}`);
+            if (message.toolResult)
+                parts.push(`输出: ${message.toolResult}`);
+            pushEntry('工具调用', parts.join('\n'));
+        }
+        else if (message.type === 'ask_question' || message.type === 'ask_question_result') {
+            pushEntry('澄清问题', content);
+        }
+        else if (message.type === 'confirm_request' || message.type === 'confirm_result') {
+            pushEntry('确认记录', content);
+        }
+    }
+    if (entries.length === 0)
+        return editedContent;
+    return [
+        '你正在一个新会话中接续一段用户已编辑的对话。',
+        '下面是编辑点之前保留的对话记录，仅作为上下文；不要复述这段记录，直接回应最后的用户消息。',
+        '',
+        '<conversation_history>',
+        entries.map(entry => `${entry.label}: ${entry.content}`).join('\n\n'),
+        '</conversation_history>',
+        '',
+        '<edited_user_message>',
+        editedContent,
+        '</edited_user_message>',
+    ].join('\n');
+}
+function toClientHistoryTask(t, includeMessages = false) {
+    const cliSessionId = getRestorableCliSessionId(t.session_id, t.messages);
+    const response = {
+        id: t.id,
+        workDir: t.work_dir || undefined,
+        status: t.status,
+        title: t.title,
+        confirmCount: t.confirm_count,
+        toolCount: t.tool_count,
+        duration: t.duration || undefined,
+        startTime: t.start_time,
+        endTime: t.end_time,
+        canResume: !!cliSessionId,
+    };
+    if (includeMessages) {
+        response.messages = toClientMessages(t.messages || []);
+    }
+    return response;
+}
+function toClientWorkDir(item) {
+    return {
+        path: item.path,
+        name: item.name,
+        lastUsedAt: item.last_used_at,
+        createdAt: item.created_at,
+    };
+}
+function getCurrentWorkDir() {
+    return cliManager.getConfig().workDir;
+}
+function recordCurrentWorkDir() {
+    return store.recordWorkDir(getCurrentWorkDir());
+}
+const WORKSPACE_SKIP_NAMES = new Set([
+    '.git',
+    '.DS_Store',
+    '.cache',
+    '.pnpm-store',
+    '.venv',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.turbo',
+    '.vite',
+]);
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_DIFF_BYTES = 1024 * 1024;
+const MAX_COMMIT_CONTEXT_BYTES = 160 * 1024;
+const PREVIEW_IMAGE_MIME_BY_EXTENSION = {
+    '.avif': 'image/avif',
+    '.bmp': 'image/bmp',
+    '.gif': 'image/gif',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+};
+function decodeGitOctalPath(raw) {
+    return raw.replace(/(?:\\[0-7]{3})+/g, (sequence) => {
+        const bytes = sequence.match(/\\([0-7]{3})/g)?.map(item => parseInt(item.slice(1), 8)) || [];
+        return Buffer.from(bytes).toString('utf8');
+    });
+}
+function normalizeWorkspacePath(raw) {
+    if (typeof raw !== 'string')
+        return '';
+    return decodeGitOctalPath(raw).replace(/\\/g, '/').replace(/^\/+/, '').split('/').filter(Boolean).join('/');
+}
+function toClientWorkspacePath(root, absolutePath) {
+    const rel = path.relative(root, absolutePath).split(path.sep).join('/');
+    return rel === '' ? '' : rel;
+}
+function resolveWorkspacePath(rawPath, mustExist = true) {
+    const root = path.resolve(getCurrentWorkDir());
+    const realRoot = fs.realpathSync(root);
+    const relativePath = normalizeWorkspacePath(rawPath);
+    const target = path.resolve(root, relativePath);
+    if (target !== root && !target.startsWith(`${root}${path.sep}`)) {
+        throw new Error('路径不在当前工作目录内');
+    }
+    if (mustExist) {
+        const realTarget = fs.realpathSync(target);
+        if (realTarget !== realRoot && !realTarget.startsWith(`${realRoot}${path.sep}`)) {
+            throw new Error('路径不在当前工作目录内');
+        }
+    }
+    return { root, target, relativePath };
+}
+function isLikelyBinary(buffer) {
+    const length = Math.min(buffer.length, 4096);
+    for (let i = 0; i < length; i += 1) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+function getPreviewImageMime(filename) {
+    return PREVIEW_IMAGE_MIME_BY_EXTENSION[path.extname(filename).toLowerCase()];
+}
+function listWorkspaceDir(rawPath) {
+    const { root, target } = resolveWorkspacePath(rawPath);
+    const realRoot = fs.realpathSync(root);
+    const stat = fs.statSync(target);
+    if (!stat.isDirectory()) {
+        throw new Error('目标不是目录');
+    }
+    const entries = fs.readdirSync(target, { withFileTypes: true });
+    const dirs = [];
+    const files = [];
+    for (const entry of entries) {
+        if (WORKSPACE_SKIP_NAMES.has(entry.name))
+            continue;
+        const entryPath = path.join(target, entry.name);
+        try {
+            const entryStat = fs.statSync(entryPath);
+            const realEntry = fs.realpathSync(entryPath);
+            if (realEntry !== realRoot && !realEntry.startsWith(`${realRoot}${path.sep}`))
+                continue;
+            if (entryStat.isDirectory()) {
+                dirs.push({
+                    name: entry.name,
+                    path: toClientWorkspacePath(root, entryPath),
+                    mtime: entryStat.mtimeMs,
+                });
+            }
+            else if (entryStat.isFile()) {
+                files.push({
+                    name: entry.name,
+                    path: toClientWorkspacePath(root, entryPath),
+                    ext: path.extname(entry.name).toLowerCase(),
+                    size: entryStat.size,
+                    mtime: entryStat.mtimeMs,
+                });
+            }
+        }
+        catch {
+            // Skip unreadable or invalid symlink entries.
+        }
+    }
+    dirs.sort((a, b) => a.name.localeCompare(b.name));
+    files.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        workDir: root,
+        path: toClientWorkspacePath(root, target),
+        parent: target === root ? '' : toClientWorkspacePath(root, path.dirname(target)),
+        isRoot: target === root,
+        dirs,
+        files,
+    };
+}
+function readWorkspaceFile(rawPath) {
+    const { root, target } = resolveWorkspacePath(rawPath);
+    const stat = fs.statSync(target);
+    if (!stat.isFile()) {
+        throw new Error('目标不是文件');
+    }
+    if (stat.size > MAX_FILE_BYTES) {
+        const mimeType = getPreviewImageMime(target);
+        return {
+            workDir: root,
+            path: toClientWorkspacePath(root, target),
+            name: path.basename(target),
+            size: stat.size,
+            mtime: stat.mtimeMs,
+            content: '',
+            tooLarge: true,
+            isBinary: false,
+            mimeType,
+            isImage: Boolean(mimeType),
+        };
+    }
+    const buffer = fs.readFileSync(target);
+    const mimeType = getPreviewImageMime(target);
+    const isImage = Boolean(mimeType);
+    const isBinary = !isImage && isLikelyBinary(buffer);
+    return {
+        workDir: root,
+        path: toClientWorkspacePath(root, target),
+        name: path.basename(target),
+        size: stat.size,
+        mtime: stat.mtimeMs,
+        content: isBinary || isImage ? '' : buffer.toString('utf8'),
+        tooLarge: false,
+        isBinary,
+        mimeType,
+        isImage,
+        dataUrl: isImage ? `data:${mimeType};base64,${buffer.toString('base64')}` : undefined,
+    };
+}
+function runGit(args, allowExitCodes = [0]) {
+    try {
+        return execFileSync('git', args, {
+            cwd: getCurrentWorkDir(),
+            encoding: 'utf8',
+            maxBuffer: MAX_DIFF_BYTES * 5,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        if (typeof err?.status === 'number' && allowExitCodes.includes(err.status)) {
+            return typeof err.stdout === 'string' ? err.stdout : '';
+        }
+        const stderr = typeof err?.stderr === 'string' ? err.stderr.trim() : '';
+        throw new Error(stderr || err?.message || 'Git 命令执行失败');
+    }
+}
+function unquoteGitPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('"') || !trimmed.endsWith('"'))
+        return trimmed;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return decodeGitOctalPath(trimmed.slice(1, -1));
+    }
+}
+function describeGitStatus(indexStatus, worktreeStatus) {
+    const pair = `${indexStatus}${worktreeStatus}`;
+    if (pair === '??')
+        return '未跟踪';
+    if (pair === '!!')
+        return '已忽略';
+    if (indexStatus === 'A' || worktreeStatus === 'A')
+        return '新增';
+    if (indexStatus === 'D' || worktreeStatus === 'D')
+        return '删除';
+    if (indexStatus === 'R' || worktreeStatus === 'R')
+        return '重命名';
+    if (indexStatus === 'C' || worktreeStatus === 'C')
+        return '复制';
+    if (indexStatus === 'M' || worktreeStatus === 'M')
+        return '修改';
+    if (indexStatus === 'U' || worktreeStatus === 'U')
+        return '冲突';
+    return '变更';
+}
+function parseGitStatus(output, nulTerminated = false) {
+    if (nulTerminated) {
+        const records = output.split('\0').filter(Boolean);
+        const files = [];
+        for (let index = 0; index < records.length; index += 1) {
+            const line = records[index];
+            if (!line.trim())
+                continue;
+            const indexStatus = line[0] || ' ';
+            const worktreeStatus = line[1] || ' ';
+            const filePath = line.slice(3);
+            files.push({
+                path: filePath,
+                name: path.basename(filePath),
+                status: `${indexStatus}${worktreeStatus}`,
+                indexStatus,
+                worktreeStatus,
+                label: describeGitStatus(indexStatus, worktreeStatus),
+            });
+            if (indexStatus === 'R' || indexStatus === 'C' || worktreeStatus === 'R' || worktreeStatus === 'C') {
+                index += 1;
+            }
+        }
+        return files;
+    }
+    return output.split('\n').map(line => {
+        if (!line.trim())
+            return null;
+        const indexStatus = line[0] || ' ';
+        const worktreeStatus = line[1] || ' ';
+        const rawPath = line.slice(3);
+        const displayPath = rawPath.includes(' -> ') ? rawPath.split(' -> ').pop() || rawPath : rawPath;
+        const filePath = unquoteGitPath(displayPath);
+        return {
+            path: filePath,
+            name: path.basename(filePath),
+            status: `${indexStatus}${worktreeStatus}`,
+            indexStatus,
+            worktreeStatus,
+            label: describeGitStatus(indexStatus, worktreeStatus),
+        };
+    }).filter((item) => item !== null);
+}
+function truncateText(text, maxBytes) {
+    const buffer = Buffer.from(text, 'utf8');
+    if (buffer.length <= maxBytes) {
+        return { text, truncated: false };
+    }
+    return {
+        text: buffer.subarray(0, maxBytes).toString('utf8') + '\n\n... diff 内容过长，已截断 ...',
+        truncated: true,
+    };
+}
+function getWorkspaceChanges(rawPath) {
+    resolveWorkspacePath('', true);
+    try {
+        runGit(['rev-parse', '--is-inside-work-tree']);
+    }
+    catch {
+        return {
+            workDir: path.resolve(getCurrentWorkDir()),
+            isGitRepo: false,
+            branch: '',
+            files: [],
+            diff: '',
+            truncated: false,
+        };
+    }
+    const selectedPath = normalizeWorkspacePath(rawPath);
+    if (selectedPath) {
+        resolveWorkspacePath(selectedPath, false);
+    }
+    const branch = runGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.']);
+    const files = parseGitStatus(statusOutput, true);
+    const diffTarget = selectedPath || '.';
+    const staged = runGit(['diff', '--cached', '--', diffTarget]);
+    const unstaged = runGit(['diff', '--', diffTarget]);
+    const parts = [];
+    if (staged.trim())
+        parts.push(`--- 已暂存变更 ---\n${staged}`);
+    if (unstaged.trim())
+        parts.push(`--- 未暂存变更 ---\n${unstaged}`);
+    if (selectedPath && parts.length === 0) {
+        const selected = files.find(file => file.path === selectedPath);
+        if (selected?.status === '??') {
+            const { target } = resolveWorkspacePath(selectedPath, true);
+            const stat = fs.statSync(target);
+            if (stat.isFile() && stat.size <= MAX_FILE_BYTES) {
+                const untrackedDiff = runGit(['diff', '--no-index', '--', '/dev/null', target], [0, 1]);
+                if (untrackedDiff.trim())
+                    parts.push(untrackedDiff);
+            }
+        }
+    }
+    const diffResult = truncateText(parts.join('\n'), MAX_DIFF_BYTES);
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        isGitRepo: true,
+        branch,
+        files,
+        diff: diffResult.text,
+        diffPath: selectedPath || undefined,
+        truncated: diffResult.truncated,
+    };
+}
+function trackWorkspaceFile(rawPath) {
+    resolveWorkspacePath('', true);
+    try {
+        runGit(['rev-parse', '--is-inside-work-tree']);
+    }
+    catch {
+        throw new Error('当前工作目录不是 Git 仓库');
+    }
+    const selectedPath = normalizeWorkspacePath(rawPath);
+    if (!selectedPath) {
+        throw new Error('请选择要追踪的文件');
+    }
+    const { target } = resolveWorkspacePath(selectedPath, true);
+    const stat = fs.statSync(target);
+    if (!stat.isFile()) {
+        throw new Error('只能追踪文件');
+    }
+    const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', selectedPath]);
+    const status = parseGitStatus(statusOutput, true).find(file => file.path === selectedPath);
+    if (!status || status.status !== '??') {
+        throw new Error('文件不是未跟踪状态');
+    }
+    runGit(['add', '--', selectedPath]);
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        path: selectedPath,
+        tracked: true,
+    };
+}
+function stageWorkspacePath(rawPath) {
+    ensureWorkspaceGitRepo();
+    const selectedPath = normalizeWorkspacePath(rawPath);
+    if (!selectedPath) {
+        runGit(['add', '--all', '--', '.']);
+        return {
+            workDir: path.resolve(getCurrentWorkDir()),
+            staged: true,
+        };
+    }
+    resolveWorkspacePath(selectedPath, false);
+    const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', selectedPath]);
+    const status = parseGitStatus(statusOutput, true).find(file => file.path === selectedPath);
+    if (!status) {
+        throw new Error('文件没有可暂存的变更');
+    }
+    runGit(['add', '--', selectedPath]);
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        path: selectedPath,
+        staged: true,
+    };
+}
+function unstageWorkspacePath(rawPath) {
+    ensureWorkspaceGitRepo();
+    const selectedPath = normalizeWorkspacePath(rawPath);
+    if (!selectedPath) {
+        runGit(['restore', '--staged', '--', '.']);
+        return {
+            workDir: path.resolve(getCurrentWorkDir()),
+            unstaged: true,
+        };
+    }
+    resolveWorkspacePath(selectedPath, false);
+    const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', selectedPath]);
+    const status = parseGitStatus(statusOutput, true).find(file => file.path === selectedPath);
+    if (!status || status.indexStatus === ' ' || status.indexStatus === '?') {
+        throw new Error('文件没有已暂存的变更');
+    }
+    runGit(['restore', '--staged', '--', selectedPath]);
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        path: selectedPath,
+        unstaged: true,
+    };
+}
+function ensureWorkspaceGitRepo() {
+    resolveWorkspacePath('', true);
+    try {
+        runGit(['rev-parse', '--is-inside-work-tree']);
+    }
+    catch {
+        throw new Error('当前工作目录不是 Git 仓库');
+    }
+}
+function normalizeCommitMessage(rawMessage) {
+    if (typeof rawMessage !== 'string')
+        return '';
+    return rawMessage.replace(/\r\n/g, '\n').replace(/\0/g, '').trim();
+}
+function normalizeAICommitMessage(rawMessage) {
+    let message = normalizeCommitMessage(rawMessage);
+    message = message.replace(/^```(?:\w+)?\n?/, '').replace(/\n?```$/, '').trim();
+    message = message.replace(/^commit message\s*:\s*/i, '').trim();
+    message = message.replace(/^["'“”‘’]+|["'“”‘’]+$/g, '').trim();
+    return message.split('\n').map(line => line.replace(/^\s*[-*]\s+/, '').trimEnd()).join('\n').trim();
+}
+function buildCommitMessagePrompt() {
+    ensureWorkspaceGitRepo();
+    const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.']);
+    const files = parseGitStatus(statusOutput, true);
+    const statusText = files.map(file => `${file.status} ${file.path}`).join('\n');
+    if (files.length === 0) {
+        throw new Error('没有可提交的代码变更');
+    }
+    const stagedFiles = runGit(['diff', '--cached', '--name-only']);
+    if (!stagedFiles.trim()) {
+        throw new Error('没有已暂存的代码变更，请先暂存要提交的文件');
+    }
+    const recentCommits = runGit(['log', '--oneline', '-8'], [0, 128]).trim();
+    const stagedStat = runGit(['diff', '--cached', '--stat']);
+    const stagedDiff = runGit(['diff', '--cached']);
+    const context = truncateText([
+        `当前分支：${runGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim()}`,
+        recentCommits ? `最近提交：\n${recentCommits}` : '',
+        `状态：\n${statusText}`,
+        stagedStat.trim() ? `已暂存统计：\n${stagedStat.trim()}` : '',
+        stagedDiff.trim() ? `已暂存 diff：\n${stagedDiff}` : '',
+    ].filter(Boolean).join('\n\n'), MAX_COMMIT_CONTEXT_BYTES);
+    return [
+        '请基于下面的 Git 变更生成一条提交信息。',
+        '要求：',
+        '- 只输出 commit message，不要解释，不要 Markdown 代码块。',
+        '- 使用 Conventional Commits：<type>(<scope>): <subject> 或 <type>: <subject>。',
+        '- type 优先使用 feat/fix/docs/refactor/test/chore/style/build/ci/perf。',
+        '- subject 简短、具体、动词开头，使用英文小写；必要时可以补充简短 body。',
+        '- 不要提到 AI、不要提到你无法验证的内容。',
+        '',
+        context.truncated ? '注意：变更上下文已截断。' : '',
+        '已暂存 Git 变更上下文：',
+        context.text,
+    ].filter(Boolean).join('\n');
+}
+async function generateWorkspaceCommitMessage() {
+    const prompt = buildCommitMessagePrompt();
+    const output = await cliManager.runOneShot(prompt, 120000);
+    const message = normalizeAICommitMessage(output);
+    if (!message) {
+        throw new Error('AI 未生成有效提交信息');
+    }
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        message,
+    };
+}
+function commitWorkspaceChanges(rawMessage) {
+    ensureWorkspaceGitRepo();
+    const message = normalizeCommitMessage(rawMessage);
+    if (!message) {
+        throw new Error('提交信息不能为空');
+    }
+    const statusOutput = runGit(['status', '--porcelain=v1', '--untracked-files=all', '--', '.']);
+    if (!statusOutput.trim()) {
+        throw new Error('没有可提交的代码变更');
+    }
+    const stagedFiles = runGit(['diff', '--cached', '--name-only']);
+    if (!stagedFiles.trim()) {
+        throw new Error('没有已暂存的代码变更，请先暂存要提交的文件');
+    }
+    runGit(['commit', '-m', message]);
+    const commitHash = runGit(['rev-parse', '--short', 'HEAD']).trim();
+    const branch = runGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        branch,
+        commitHash,
+        message,
+    };
+}
+function setCorsHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET,POST,DELETE,OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-AgentPilot-Token');
+}
+function getHeaderValue(value) {
+    if (Array.isArray(value))
+        return value[0] || '';
+    return value || '';
+}
+function parseCookieHeader(header) {
+    const cookies = {};
+    for (const part of header.split(';')) {
+        const [rawName, ...rawValue] = part.trim().split('=');
+        if (!rawName || rawValue.length === 0)
+            continue;
+        try {
+            cookies[rawName] = decodeURIComponent(rawValue.join('='));
+        }
+        catch {
+            cookies[rawName] = rawValue.join('=');
+        }
+    }
+    return cookies;
+}
+function safeTokenEquals(candidate) {
+    if (!AUTH_ENABLED)
+        return true;
+    const actual = Buffer.from(AUTH_TOKEN);
+    const provided = Buffer.from(candidate);
+    if (provided.length !== actual.length)
+        return false;
+    return timingSafeEqual(provided, actual);
+}
+function readRequestTokens(req, url) {
+    const tokens = [];
+    const auth = getHeaderValue(req.headers.authorization);
+    const bearerMatch = auth.match(/^Bearer\s+(.+)$/i);
+    if (bearerMatch?.[1]?.trim())
+        tokens.push(bearerMatch[1].trim());
+    const headerToken = getHeaderValue(req.headers['x-agentpilot-token']).trim();
+    if (headerToken)
+        tokens.push(headerToken);
+    const queryToken = (url.searchParams.get('token') || url.searchParams.get('agentpilot_token') || '').trim();
+    if (queryToken)
+        tokens.push(queryToken);
+    const cookies = parseCookieHeader(getHeaderValue(req.headers.cookie));
+    const cookieToken = (cookies[AUTH_COOKIE_NAME] || '').trim();
+    if (cookieToken)
+        tokens.push(cookieToken);
+    return tokens;
+}
+function isRequestAuthorized(req, url) {
+    if (!AUTH_ENABLED)
+        return true;
+    return readRequestTokens(req, url).some(safeTokenEquals);
+}
+function appendSetCookie(res, cookie) {
+    const existing = res.getHeader('Set-Cookie');
+    if (!existing) {
+        res.setHeader('Set-Cookie', cookie);
+        return;
+    }
+    res.setHeader('Set-Cookie', Array.isArray(existing) ? [...existing, cookie] : [String(existing), cookie]);
+}
+function maybeSetAuthCookie(req, res, url) {
+    if (!AUTH_ENABLED)
+        return;
+    const hasTokenParam = url.searchParams.has('token') || url.searchParams.has('agentpilot_token');
+    if (!hasTokenParam && parseCookieHeader(getHeaderValue(req.headers.cookie))[AUTH_COOKIE_NAME])
+        return;
+    const secure = httpsOptions ? '; Secure' : '';
+    appendSetCookie(res, `${AUTH_COOKIE_NAME}=${encodeURIComponent(AUTH_TOKEN)}; Path=/; HttpOnly; SameSite=Strict; Max-Age=86400${secure}`);
+}
+function sendAuthRequired(res) {
+    sendJson(res, 401, {
+        error: '访问 token 缺失或无效，请使用启动终端打印的链接重新打开。',
+        authRequired: true,
+    });
+}
+function sendJson(res, status, payload) {
+    if (res.writableEnded)
+        return;
+    setCorsHeaders(res);
+    res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(payload));
+}
+function sendText(res, status, text) {
+    if (res.writableEnded)
+        return;
+    setCorsHeaders(res);
+    res.writeHead(status, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end(text);
+}
+const STATIC_MIME_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.webmanifest': 'application/manifest+json; charset=utf-8',
+};
+function getStaticContentType(filePath) {
+    return STATIC_MIME_TYPES[path.extname(filePath).toLowerCase()] || 'application/octet-stream';
+}
+function sendStaticFile(req, res, filePath) {
+    if (res.writableEnded)
+        return;
+    setCorsHeaders(res);
+    const ext = path.extname(filePath).toLowerCase();
+    const headers = {
+        'Content-Type': getStaticContentType(filePath),
+    };
+    if (path.basename(filePath) === 'index.html' || path.basename(filePath) === 'sw.js') {
+        headers['Cache-Control'] = 'no-cache';
+    }
+    else if (filePath.includes(`${path.sep}assets${path.sep}`)) {
+        headers['Cache-Control'] = 'public, max-age=31536000, immutable';
+    }
+    else if (ext) {
+        headers['Cache-Control'] = 'public, max-age=3600';
+    }
+    res.writeHead(200, headers);
+    if (req.method === 'HEAD') {
+        res.end();
+        return;
+    }
+    fs.createReadStream(filePath).pipe(res);
+}
+function serveStaticClient(req, res, pathname) {
+    if (!STATIC_DIR || (req.method !== 'GET' && req.method !== 'HEAD'))
+        return false;
+    let decodedPath;
+    try {
+        decodedPath = decodeURIComponent(pathname);
+    }
+    catch {
+        sendJson(res, 400, { error: 'Bad request' });
+        return true;
+    }
+    const normalizedPath = path.normalize(decodedPath).replace(/^(\.\.[/\\])+/, '');
+    const relativePath = normalizedPath === path.sep ? 'index.html' : normalizedPath.replace(/^[/\\]+/, '');
+    let target = path.resolve(STATIC_DIR, relativePath);
+    if (target !== STATIC_DIR && !target.startsWith(`${STATIC_DIR}${path.sep}`)) {
+        sendJson(res, 403, { error: 'Forbidden' });
+        return true;
+    }
+    try {
+        const stat = fs.statSync(target);
+        if (stat.isDirectory()) {
+            target = path.join(target, 'index.html');
+        }
+        if (fs.statSync(target).isFile()) {
+            sendStaticFile(req, res, target);
+            return true;
+        }
+    }
+    catch { }
+    const accept = req.headers.accept || '';
+    if (req.method === 'GET' && accept.includes('text/html')) {
+        sendStaticFile(req, res, path.join(STATIC_DIR, 'index.html'));
+        return true;
+    }
+    sendJson(res, 404, { error: 'Not found' });
+    return true;
+}
+function readJsonBody(req, maxBytes = 25 * 1024 * 1024) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        req.on('data', (chunk) => {
+            if (settled)
+                return;
+            body += chunk.toString('utf8');
+            if (Buffer.byteLength(body, 'utf8') > maxBytes) {
+                fail(new Error('请求体过大'));
+                req.destroy();
+            }
+        });
+        req.on('end', () => {
+            if (settled)
+                return;
+            settled = true;
+            if (!body.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(body));
+            }
+            catch {
+                reject(new Error('无效的 JSON 请求体'));
+            }
+        });
+        req.on('error', fail);
+    });
+}
+function getHistoryIdFromPath(pathname) {
+    const match = pathname.match(/^\/api\/history\/([^/]+)$/);
+    return match ? decodeURIComponent(match[1]) : null;
+}
+function listSystemDir(rawDir, includeFiles) {
+    const baseDir = typeof rawDir === 'string' && rawDir ? rawDir : '~';
+    const dir = baseDir.startsWith('~') ? baseDir.replace('~', os.homedir()) : baseDir;
+    const resolved = path.resolve(dir);
+    const entries = fs.readdirSync(resolved, { withFileTypes: true });
+    const dirs = entries
+        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+        .map(e => ({
+        name: e.name,
+        path: path.join(resolved, e.name),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    let files = [];
+    if (includeFiles) {
+        files = entries
+            .filter(e => e.isFile() && !e.name.startsWith('.'))
+            .map(e => ({
+            name: e.name,
+            path: path.join(resolved, e.name),
+            ext: path.extname(e.name).toLowerCase(),
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    const homeDir = os.homedir();
+    const quickAccess = [
+        { name: '主目录', path: homeDir, icon: 'home' },
+        { name: '桌面', path: path.join(homeDir, 'Desktop'), icon: 'desktop' },
+        { name: '文档', path: path.join(homeDir, 'Documents'), icon: 'documents' },
+        { name: '下载', path: path.join(homeDir, 'Downloads'), icon: 'downloads' },
+    ].filter(item => {
+        try {
+            return fs.statSync(item.path).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    return {
+        dir: resolved,
+        parent: path.dirname(resolved),
+        dirs,
+        files,
+        quickAccess,
+        isRoot: resolved === path.dirname(resolved),
+    };
+}
+async function handleHttpRequest(req, res) {
+    setCorsHeaders(res);
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    if (!isRequestAuthorized(req, url)) {
+        sendAuthRequired(res);
+        return;
+    }
+    maybeSetAuthCookie(req, res, url);
+    const pathname = url.pathname;
+    if (pathname === '/health') {
+        sendText(res, 200, 'AgentPilot Server');
+        return;
+    }
+    if (!pathname.startsWith('/api/') && serveStaticClient(req, res, pathname)) {
+        return;
+    }
+    if (pathname === '/') {
+        sendText(res, 200, 'AgentPilot Server');
+        return;
+    }
+    if (!pathname.startsWith('/api/')) {
+        sendJson(res, 404, { error: 'Not found' });
+        return;
+    }
+    try {
+        if (req.method === 'GET' && pathname === '/api/config') {
+            sendJson(res, 200, {
+                config: cliManager.getConfig(),
+                status: cliManager.status,
+                sessionId: currentSessionId,
+                time: now(),
+            });
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/skills') {
+            const config = cliManager.getConfig();
+            sendJson(res, 200, { skills: discoverSkills(config.workDir) });
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/workdirs') {
+            recordCurrentWorkDir();
+            sendJson(res, 200, {
+                current: getCurrentWorkDir(),
+                workdirs: store.getRecentWorkDirs().map(toClientWorkDir),
+            });
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/session') {
+            if (!currentSessionId) {
+                sendJson(res, 200, {
+                    sessionId: null,
+                    messages: [],
+                    lastSeq: 0,
+                    firstSeq: 0,
+                    hasMoreBefore: false,
+                    tokenUsage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0 },
+                });
+                return;
+            }
+            sendJson(res, 200, buildSessionData(currentSessionId, {
+                afterSeq: url.searchParams.get('afterSeq') || undefined,
+                beforeSeq: url.searchParams.get('beforeSeq') || undefined,
+                limit: url.searchParams.get('limit') || undefined,
+            }));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/history') {
+            const tasks = store.getHistoryTasks({ workDir: getCurrentWorkDir() });
+            sendJson(res, 200, { tasks: tasks.map(task => toClientHistoryTask(task)) });
+            return;
+        }
+        const historyId = getHistoryIdFromPath(pathname);
+        if (historyId && req.method === 'GET') {
+            const task = store.getHistoryTask(historyId, getCurrentWorkDir());
+            sendJson(res, 200, { task: task ? toClientHistoryTask(task, true) : null });
+            return;
+        }
+        if (historyId && req.method === 'DELETE') {
+            store.deleteHistoryTask(historyId, getCurrentWorkDir());
+            sendJson(res, 200, { id: historyId });
+            broadcast({ type: 'history_changed', time: now() });
+            return;
+        }
+        if (req.method === 'DELETE' && pathname === '/api/history') {
+            store.clearHistory(getCurrentWorkDir());
+            sendJson(res, 200, { success: true });
+            broadcast({ type: 'history_changed', time: now() });
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/migrate-local-data') {
+            const body = await readJsonBody(req);
+            store.importLocalData(body.messages || [], body.historyTasks || [], getCurrentWorkDir());
+            sendJson(res, 200, { success: true });
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/dir') {
+            const includeFiles = url.searchParams.get('includeFiles') === 'true';
+            sendJson(res, 200, listSystemDir(url.searchParams.get('dir'), includeFiles));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/workdir/tree') {
+            sendJson(res, 200, listWorkspaceDir(url.searchParams.get('path') || ''));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/workdir/file') {
+            sendJson(res, 200, readWorkspaceFile(url.searchParams.get('path') || ''));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/api/workdir/changes') {
+            sendJson(res, 200, getWorkspaceChanges(url.searchParams.get('path') || undefined));
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/workdir/track') {
+            const body = await readJsonBody(req);
+            sendJson(res, 200, trackWorkspaceFile(body.path));
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/workdir/stage') {
+            const body = await readJsonBody(req);
+            sendJson(res, 200, stageWorkspacePath(body.path));
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/workdir/unstage') {
+            const body = await readJsonBody(req);
+            sendJson(res, 200, unstageWorkspacePath(body.path));
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/workdir/commit-message') {
+            sendJson(res, 200, await generateWorkspaceCommitMessage());
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/workdir/commit') {
+            const body = await readJsonBody(req);
+            const result = commitWorkspaceChanges(body.message);
+            sendJson(res, 200, result);
+            broadcast({ type: 'history_changed', time: now() });
+            return;
+        }
+        sendJson(res, 404, { error: 'Not found' });
+    }
+    catch (err) {
+        sendJson(res, 400, { error: err?.message || '请求处理失败' });
+    }
+}
+// Current active session ID
+let currentSessionId = null;
+// Restore or create session on startup
+const existingSession = store.getCurrentSession();
+if (existingSession) {
+    currentSessionId = existingSession.id;
+    console.log(`[Store] Restored session: ${currentSessionId}`);
+    // Restore CLI config from the active session so refreshes keep the last used CLI.
+    try {
+        const config = existingSession.cli_config ? JSON.parse(existingSession.cli_config) : {};
+        cliManager.restoreConfig(config);
+        if (config.cliSessionId) {
+            cliManager.restoreSessionId(config.cliSessionId);
+            console.log(`[Store] Restored CLI session: ${config.cliSessionId.slice(0, 8)}...`);
+        }
+        if (config.workDir) {
+            cliManager.restoreWorkDir(config.workDir);
+        }
+    }
+    catch { }
+}
+else {
+    currentSessionId = store.createSession();
+    console.log(`[Store] Created new session: ${currentSessionId}`);
+}
+const startupConfig = readStartupConfig();
+if (Object.keys(startupConfig).length > 0) {
+    // Startup config is the server-process default. Frontend workdir switches update
+    // the active session for this process, but a server restart should start from
+    // the directory where the NPX command is run again.
+    const previousSession = store.getCurrentSession();
+    const previousConfig = getSessionConfig(previousSession);
+    const previousWorkDir = typeof previousConfig.workDir === 'string'
+        ? path.resolve(previousConfig.workDir)
+        : '';
+    cliManager.restoreConfig(startupConfig);
+    if (startupConfig.workDir) {
+        cliManager.restoreWorkDir(startupConfig.workDir);
+    }
+    const nextWorkDir = path.resolve(cliManager.getConfig().workDir);
+    const shouldStartFreshSession = IS_NPX_ENTRY &&
+        currentSessionId &&
+        previousWorkDir &&
+        previousWorkDir !== nextWorkDir &&
+        store.getLastSeq(currentSessionId) > 0;
+    if (shouldStartFreshSession && currentSessionId) {
+        store.archiveSession(currentSessionId, 'completed');
+        currentSessionId = store.createSession({ ...cliManager.getConfig() });
+        store.updateSessionStatus(currentSessionId, 'idle');
+    }
+    else if (currentSessionId) {
+        store.updateSessionConfig(currentSessionId, { ...cliManager.getConfig() });
+    }
+}
+store.backfillUnscopedHistoryWorkDir(cliManager.getConfig().workDir);
+recordCurrentWorkDir();
+// Message types that should be persisted
+const PERSISTABLE_TYPES = new Set([
+    'user_message',
+    'ai_message',
+    'thinking_message',
+    'tool_call',
+    'confirm_request',
+    'confirm_result',
+    'confirm_mode_changed',
+    'ask_question',
+    'ask_question_result',
+    'system',
+    'error',
+    'status',
+]);
+function broadcast(event) {
+    // Persist CLI session ID when we get it from system init or result
+    if (currentSessionId && event.type === 'system' && event.details?.session_id) {
+        try {
+            const config = store.getCurrentSession()?.cli_config;
+            const parsed = config ? JSON.parse(config) : {};
+            parsed.cliSessionId = event.details.session_id;
+            store.updateSessionConfig(currentSessionId, parsed);
+        }
+        catch { }
+    }
+    if (currentSessionId && event.type === 'system' && event.details?.subtype === 'result' && event.details?.session_id) {
+        try {
+            const config = store.getCurrentSession()?.cli_config;
+            const parsed = config ? JSON.parse(config) : {};
+            parsed.cliSessionId = event.details.session_id;
+            store.updateSessionConfig(currentSessionId, parsed);
+        }
+        catch { }
+    }
+    // Persist to store before broadcasting
+    if (currentSessionId && PERSISTABLE_TYPES.has(event.type)) {
+        try {
+            let persisted;
+            // For tool_call events, 'details' maps to toolDetails (tool input)
+            // For system events, 'details' maps to details (structured metadata)
+            // For ask_question events, store questions data in 'details'
+            const isToolCall = event.type === 'tool_call';
+            const isAskQuestion = event.type === 'ask_question';
+            const isAskQuestionResult = event.type === 'ask_question_result';
+            const isToolResult = isToolCall && (event.status === 'success' || event.status === 'failed');
+            const toolUseId = event.toolUseId || undefined;
+            // Build details field: for ask_question, include questions data
+            let detailsData = !isToolCall && event.details ? event.details : undefined;
+            if (isAskQuestion && event.questions) {
+                detailsData = { questions: event.questions, toolUseId: event.toolUseId };
+            }
+            if (isAskQuestionResult) {
+                detailsData = { answered: true, answer: event.answer, toolUseId: event.toolUseId };
+            }
+            // If this is a tool result with a toolUseId, update the existing tool_call message
+            if (isToolResult && toolUseId) {
+                const updated = store.updateToolCallResult(currentSessionId, toolUseId, event.status, event.details || '');
+                if (updated) {
+                    // Successfully updated existing message, skip appending a new row
+                }
+                else {
+                    // No matching tool_call found (edge case), append as new message
+                    persisted = store.appendMessage(currentSessionId, {
+                        id: event.id || undefined,
+                        type: event.type,
+                        content: event.content || '',
+                        time: event.time || now(),
+                        status: event.status || undefined,
+                        toolName: event.toolName || undefined,
+                        toolDetails: isToolCall ? (event.details || event.toolDetails) : event.toolDetails || undefined,
+                        toolUseId,
+                        toolResult: event.details || '',
+                        permission: event.permission || undefined,
+                        details: detailsData,
+                    });
+                }
+            }
+            else {
+                persisted = store.appendMessage(currentSessionId, {
+                    id: event.id || undefined,
+                    type: event.type,
+                    content: event.content || '',
+                    time: event.time || now(),
+                    status: event.status || undefined,
+                    toolName: event.toolName || undefined,
+                    toolDetails: isToolCall ? (event.details || event.toolDetails) : event.toolDetails || undefined,
+                    toolUseId,
+                    permission: event.permission || undefined,
+                    details: detailsData,
+                });
+            }
+            if (persisted) {
+                if (!event.id)
+                    event.id = persisted.id;
+                event.seq = persisted.seq;
+            }
+        }
+        catch (err) {
+            console.error('[Store] Failed to persist message:', err);
+        }
+    }
+    // Broadcast to all clients
+    const data = JSON.stringify(event);
+    for (const ws of clients) {
+        if (ws.readyState === WebSocket.OPEN) {
+            try {
+                ws.send(data);
+            }
+            catch { }
+        }
+    }
+}
+cliManager.setEventHandler(broadcast);
+wss.on('connection', (ws) => {
+    clients.add(ws);
+    console.log(`[WS] Client connected (total: ${clients.size})`);
+    ws.send(JSON.stringify({
+        type: 'connected',
+        config: cliManager.getConfig(),
+        status: cliManager.status,
+        sessionId: currentSessionId,
+    }));
+    ws.on('message', (data) => {
+        let msg;
+        try {
+            msg = JSON.parse(data.toString());
+        }
+        catch (e) {
+            ws.send(JSON.stringify({ type: 'error', content: '无效的消息格式', time: now() }));
+            return;
+        }
+        try {
+            handleMessage(ws, msg);
+        }
+        catch (e) {
+            console.error('[WS] handleMessage error:', e);
+            ws.send(JSON.stringify({ type: 'error', content: `处理消息失败: ${e.message || '未知错误'}`, time: now() }));
+        }
+    });
+    ws.on('close', () => {
+        clients.delete(ws);
+        console.log(`[WS] Client disconnected (total: ${clients.size})`);
+    });
+    ws.on('error', (err) => {
+        console.error('[WS] Error:', err.message);
+        clients.delete(ws);
+    });
+});
+function handleMessage(ws, msg) {
+    switch (msg.type) {
+        case 'start_cli': {
+            // Archive current session
+            if (currentSessionId) {
+                store.archiveSession(currentSessionId, 'completed');
+            }
+            // Start CLI first so config is updated
+            cliManager.start({
+                cliType: msg.cliType,
+                cliCommand: msg.cliCommand,
+                workDir: msg.workDir,
+                confirmMode: msg.confirmMode,
+                cliArgs: msg.cliArgs,
+            }, broadcast);
+            recordCurrentWorkDir();
+            // Create new session after CLI is configured
+            currentSessionId = store.createSession({
+                ...cliManager.getConfig(),
+            });
+            store.updateSessionStatus(currentSessionId, 'idle');
+            store.updateSessionConfig(currentSessionId, { ...cliManager.getConfig() });
+            // Broadcast session change with updated config
+            broadcast({
+                type: 'session_reset',
+                sessionId: currentSessionId,
+                config: cliManager.getConfig(),
+                time: now(),
+            });
+            broadcast({ type: 'history_changed', time: now() });
+            broadcast({ type: 'workdirs_changed', current: getCurrentWorkDir(), time: now() });
+            break;
+        }
+        case 'send_message':
+            cliManager.sendInput(msg.content);
+            broadcast({
+                type: 'user_message',
+                content: msg.content,
+                time: now(),
+            });
+            break;
+        case 'confirm_response':
+            cliManager.confirmResponse(msg.approved);
+            break;
+        case 'question_response':
+            cliManager.questionResponse(msg.answer, msg.toolUseId);
+            break;
+        case 'interrupt':
+            cliManager.interrupt();
+            break;
+        case 'restart_cli': {
+            // Archive current session before restarting
+            if (currentSessionId) {
+                const taskStatus = cliManager.status === 'running' || cliManager.status === 'confirm' ? 'running' :
+                    cliManager.status === 'disconnected' ? 'failed' : 'completed';
+                store.archiveSession(currentSessionId, taskStatus);
+            }
+            // Create new session
+            currentSessionId = store.createSession({ ...cliManager.getConfig() });
+            store.updateSessionStatus(currentSessionId, 'idle');
+            // Broadcast session change
+            broadcast({
+                type: 'session_reset',
+                sessionId: currentSessionId,
+                config: cliManager.getConfig(),
+                time: now(),
+            });
+            broadcast({ type: 'history_changed', time: now() });
+            cliManager.restart();
+            break;
+        }
+        case 'set_confirm_mode':
+            cliManager.setConfirmMode(msg.mode);
+            broadcast({
+                type: 'confirm_mode_changed',
+                mode: msg.mode,
+                time: now(),
+            });
+            break;
+        case 'get_config':
+            ws.send(JSON.stringify({
+                type: 'config',
+                config: cliManager.getConfig(),
+                status: cliManager.status,
+                sessionId: currentSessionId,
+                time: now(),
+            }));
+            break;
+        case 'get_skills': {
+            const config = cliManager.getConfig();
+            ws.send(JSON.stringify({
+                type: 'skills_data',
+                requestId: msg.requestId,
+                skills: discoverSkills(config.workDir),
+            }));
+            break;
+        }
+        // --- New protocol: Session data ---
+        case 'get_session': {
+            if (!currentSessionId) {
+                ws.send(JSON.stringify({
+                    type: 'session_data',
+                    requestId: msg.requestId,
+                    sessionId: null,
+                    messages: [],
+                    lastSeq: 0,
+                    firstSeq: 0,
+                    hasMoreBefore: false,
+                    tokenUsage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0 },
+                }));
+                break;
+            }
+            ws.send(JSON.stringify({
+                type: 'session_data',
+                requestId: msg.requestId,
+                ...buildSessionData(currentSessionId, {
+                    afterSeq: msg.afterSeq,
+                    beforeSeq: msg.beforeSeq,
+                    limit: msg.limit,
+                }),
+            }));
+            break;
+        }
+        // --- New protocol: History ---
+        case 'get_history': {
+            const tasks = store.getHistoryTasks({ workDir: getCurrentWorkDir() });
+            ws.send(JSON.stringify({
+                type: 'history_data',
+                requestId: msg.requestId,
+                tasks: tasks.map(task => toClientHistoryTask(task)),
+            }));
+            break;
+        }
+        case 'get_history_task': {
+            const task = store.getHistoryTask(msg.id, getCurrentWorkDir());
+            ws.send(JSON.stringify({
+                type: 'history_task_data',
+                requestId: msg.requestId,
+                task: task ? toClientHistoryTask(task, true) : null,
+            }));
+            break;
+        }
+        case 'resume_history': {
+            if (cliManager.status === 'running' || cliManager.status === 'confirm' || cliManager.status === 'question') {
+                ws.send(JSON.stringify({
+                    type: 'history_resumed',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: '当前会话正在响应中，请等待完成后再继续该会话',
+                }));
+                break;
+            }
+            const task = store.getHistoryTask(msg.id, getCurrentWorkDir());
+            const cliSessionId = task ? getRestorableCliSessionId(task.session_id, task.messages) : undefined;
+            if (!task || !task.session_id || !cliSessionId) {
+                ws.send(JSON.stringify({
+                    type: 'history_resumed',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: '该会话记录缺少可恢复的 CLI 会话 ID，无法继续追问',
+                }));
+                break;
+            }
+            const restored = store.resumeHistoryTask(msg.id, currentSessionId, getCurrentWorkDir());
+            if (!restored) {
+                ws.send(JSON.stringify({
+                    type: 'history_resumed',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: '恢复会话记录失败',
+                }));
+                break;
+            }
+            currentSessionId = restored.session.id;
+            const restoredConfig = {
+                ...getSessionConfig(restored.session),
+                cliSessionId,
+            };
+            cliManager.restoreConfig(restoredConfig);
+            cliManager.restoreSessionId(cliSessionId);
+            if (typeof restoredConfig.workDir === 'string') {
+                cliManager.restoreWorkDir(restoredConfig.workDir);
+            }
+            recordCurrentWorkDir();
+            store.updateSessionConfig(currentSessionId, {
+                ...cliManager.getConfig(),
+                cliSessionId,
+            });
+            const sessionMessages = toClientMessages(restored.messages);
+            const lastSeq = store.getLastSeq(currentSessionId);
+            broadcast({
+                type: 'session_restored',
+                sessionId: currentSessionId,
+                config: cliManager.getConfig(),
+                status: cliManager.status,
+                messages: sessionMessages,
+                lastSeq,
+                time: now(),
+            });
+            broadcast({ type: 'history_changed', time: now() });
+            broadcast({ type: 'workdirs_changed', current: getCurrentWorkDir(), time: now() });
+            const followUp = typeof msg.content === 'string' ? msg.content.trim() : '';
+            if (followUp) {
+                cliManager.sendInput(followUp);
+                broadcast({
+                    type: 'user_message',
+                    content: followUp,
+                    time: now(),
+                });
+            }
+            ws.send(JSON.stringify({
+                type: 'history_resumed',
+                requestId: msg.requestId,
+                success: true,
+                sessionId: currentSessionId,
+                config: cliManager.getConfig(),
+                messages: sessionMessages,
+                lastSeq,
+                sent: !!followUp,
+            }));
+            break;
+        }
+        case 'edit_user_message': {
+            if (cliManager.status === 'running' || cliManager.status === 'confirm' || cliManager.status === 'question') {
+                ws.send(JSON.stringify({
+                    type: 'user_message_edited',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: '当前会话正在响应中，请等待完成后再编辑消息',
+                }));
+                break;
+            }
+            const messageId = typeof msg.messageId === 'string' ? msg.messageId : '';
+            const editedContent = typeof msg.content === 'string' ? msg.content : '';
+            if (!currentSessionId || !messageId || !editedContent.trim()) {
+                ws.send(JSON.stringify({
+                    type: 'user_message_edited',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: '编辑消息参数无效',
+                }));
+                break;
+            }
+            const sourceSessionId = currentSessionId;
+            const targetMessage = store.getSessionMessageById(sourceSessionId, messageId);
+            if (!targetMessage || !['user_message', 'user'].includes(targetMessage.type)) {
+                ws.send(JSON.stringify({
+                    type: 'user_message_edited',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: '未找到可编辑的用户消息',
+                }));
+                break;
+            }
+            const baseConfig = { ...cliManager.getConfig() };
+            currentSessionId = store.createSession(baseConfig);
+            store.copySessionMessagesBeforeSeq(sourceSessionId, currentSessionId, targetMessage.seq);
+            const prefixMessages = store.getSessionMessages(currentSessionId);
+            const branchConfig = { ...baseConfig };
+            delete branchConfig.cliSessionId;
+            cliManager.restoreConfig(branchConfig);
+            cliManager.clearSessionId();
+            if (typeof branchConfig.workDir === 'string') {
+                cliManager.restoreWorkDir(branchConfig.workDir);
+            }
+            store.updateSessionConfig(currentSessionId, branchConfig);
+            const sessionMessages = toClientMessages(prefixMessages);
+            const lastSeq = store.getLastSeq(currentSessionId);
+            broadcast({
+                type: 'session_restored',
+                sessionId: currentSessionId,
+                config: cliManager.getConfig(),
+                status: cliManager.status,
+                messages: sessionMessages,
+                lastSeq,
+                time: now(),
+            });
+            broadcast({ type: 'history_changed', time: now() });
+            cliManager.sendInput(buildEditPrompt(prefixMessages, editedContent));
+            broadcast({
+                type: 'user_message',
+                content: editedContent,
+                time: now(),
+            });
+            ws.send(JSON.stringify({
+                type: 'user_message_edited',
+                requestId: msg.requestId,
+                success: true,
+                sessionId: currentSessionId,
+            }));
+            break;
+        }
+        case 'delete_history': {
+            store.deleteHistoryTask(msg.id, getCurrentWorkDir());
+            ws.send(JSON.stringify({
+                type: 'history_deleted',
+                requestId: msg.requestId,
+                id: msg.id,
+            }));
+            // Notify all clients
+            broadcast({ type: 'history_changed', time: now() });
+            break;
+        }
+        case 'clear_history': {
+            store.clearHistory(getCurrentWorkDir());
+            ws.send(JSON.stringify({
+                type: 'history_cleared',
+                requestId: msg.requestId,
+            }));
+            // Notify all clients
+            broadcast({ type: 'history_changed', time: now() });
+            break;
+        }
+        // --- New protocol: Migration from localStorage ---
+        case 'migrate_local_data': {
+            try {
+                store.importLocalData(msg.messages || [], msg.historyTasks || [], getCurrentWorkDir());
+                ws.send(JSON.stringify({
+                    type: 'migration_done',
+                    requestId: msg.requestId,
+                    success: true,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'migration_done',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err.message,
+                }));
+            }
+            break;
+        }
+        case 'list_workdir': {
+            try {
+                const result = listWorkspaceDir(msg.path || '');
+                ws.send(JSON.stringify({
+                    type: 'workdir_tree',
+                    requestId: msg.requestId,
+                    ...result,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'workdir_tree',
+                    requestId: msg.requestId,
+                    error: err.message || '读取工作目录失败',
+                }));
+            }
+            break;
+        }
+        case 'read_workdir_file': {
+            try {
+                const result = readWorkspaceFile(msg.path || '');
+                ws.send(JSON.stringify({
+                    type: 'workdir_file',
+                    requestId: msg.requestId,
+                    ...result,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'workdir_file',
+                    requestId: msg.requestId,
+                    error: err.message || '读取文件失败',
+                }));
+            }
+            break;
+        }
+        case 'get_workdir_changes': {
+            try {
+                const result = getWorkspaceChanges(msg.path);
+                ws.send(JSON.stringify({
+                    type: 'workdir_changes',
+                    requestId: msg.requestId,
+                    ...result,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'workdir_changes',
+                    requestId: msg.requestId,
+                    error: err.message || '读取变更失败',
+                }));
+            }
+            break;
+        }
+        case 'track_workdir_file': {
+            try {
+                const result = trackWorkspaceFile(msg.path);
+                ws.send(JSON.stringify({
+                    type: 'workdir_file_tracked',
+                    requestId: msg.requestId,
+                    ...result,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'workdir_file_tracked',
+                    requestId: msg.requestId,
+                    error: err.message || '追踪文件失败',
+                }));
+            }
+            break;
+        }
+        case 'generate_workdir_commit_message': {
+            generateWorkspaceCommitMessage()
+                .then((result) => {
+                ws.send(JSON.stringify({
+                    type: 'workdir_commit_message',
+                    requestId: msg.requestId,
+                    ...result,
+                }));
+            })
+                .catch((err) => {
+                ws.send(JSON.stringify({
+                    type: 'workdir_commit_message',
+                    requestId: msg.requestId,
+                    error: err.message || '生成提交信息失败',
+                }));
+            });
+            break;
+        }
+        case 'commit_workdir_changes': {
+            try {
+                const result = commitWorkspaceChanges(msg.message);
+                ws.send(JSON.stringify({
+                    type: 'workdir_committed',
+                    requestId: msg.requestId,
+                    ...result,
+                }));
+                broadcast({ type: 'history_changed', time: now() });
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'workdir_committed',
+                    requestId: msg.requestId,
+                    error: err.message || '提交失败',
+                }));
+            }
+            break;
+        }
+        case 'list_dir': {
+            try {
+                ws.send(JSON.stringify({
+                    type: 'dir_list',
+                    requestId: msg.requestId,
+                    ...listSystemDir(msg.dir, !!msg.includeFiles),
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'dir_list',
+                    requestId: msg.requestId,
+                    dir: msg.dir,
+                    error: err.message,
+                }));
+            }
+            break;
+        }
+        default:
+            ws.send(JSON.stringify({ type: 'error', content: `未知消息类型: ${msg.type}`, time: now() }));
+    }
+}
+function now() {
+    return new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+function formatHostForUrl(host) {
+    return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+}
+function withStartupToken(url) {
+    if (!AUTH_ENABLED)
+        return url;
+    const parsed = new URL(url);
+    parsed.searchParams.set('token', AUTH_TOKEN);
+    return parsed.toString();
+}
+function getNetworkUrls() {
+    const urls = [];
+    const interfaces = os.networkInterfaces();
+    for (const items of Object.values(interfaces)) {
+        for (const item of items || []) {
+            if (item.family !== 'IPv4' || item.internal)
+                continue;
+            urls.push(withStartupToken(`${httpScheme}://${item.address}:${PORT}`));
+        }
+    }
+    return Array.from(new Set(urls));
+}
+function shouldUseColor() {
+    return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+const terminalStyle = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m',
+};
+function colorize(text, ...codes) {
+    if (!shouldUseColor())
+        return text;
+    return `${codes.join('')}${text}${terminalStyle.reset}`;
+}
+function printLine(label, value, emphasis = false) {
+    const labelText = colorize(label.padEnd(8), terminalStyle.dim);
+    const valueText = emphasis ? colorize(value, terminalStyle.bold, terminalStyle.cyan) : value;
+    console.log(`  ${labelText} ${valueText}`);
+}
+function printSection(title) {
+    console.log(colorize(title.toUpperCase(), terminalStyle.bold, terminalStyle.dim));
+}
+function printMacSleepHint() {
+    if (process.platform !== 'darwin')
+        return;
+    printSection('macOS long tasks');
+    console.log(`  ${colorize('手机长时间遥控任务前，建议先开启 Mac 防休眠，避免息屏后任务中断。', terminalStyle.yellow)}`);
+    console.log('  System Settings > Battery > Options >');
+    console.log('  开启“使用电源适配器供电且显示器关闭时，防止自动进入睡眠”。');
+    console.log('');
+}
+function printStartupInfo() {
+    if (!IS_NPX_ENTRY) {
+        console.log(`[AgentPilot] Server running on ${withStartupToken(`${httpScheme}://${HOST}:${PORT}`)}`);
+        console.log(`[AgentPilot] WebSocket ready on ${wsScheme}://${HOST}:${PORT}`);
+        if (AUTH_ENABLED)
+            console.log('[AgentPilot] Access token checks are enabled.');
+        return;
+    }
+    const localHost = HOST === '0.0.0.0' || HOST === '::' ? 'localhost' : HOST;
+    const localUrl = withStartupToken(`${httpScheme}://${formatHostForUrl(localHost)}:${PORT}`);
+    const networkUrls = HOST === '0.0.0.0' || HOST === '::' ? getNetworkUrls() : [];
+    const config = cliManager.getConfig();
+    const tokenStatus = AUTH_ENABLED ? 'enabled, required for browser/API/WebSocket access' : 'disabled';
+    console.log('');
+    console.log(colorize('AgentPilot', terminalStyle.bold, terminalStyle.cyan), colorize('READY', terminalStyle.bold, terminalStyle.green));
+    console.log(colorize('Mobile-first remote console for your local agent', terminalStyle.dim));
+    console.log('');
+    if (networkUrls[0]) {
+        printSection('open on mobile');
+        printLine('Mobile', networkUrls[0], true);
+        printLine('Scan', 'use the QR code below');
+        const qr = renderTerminalQr(networkUrls[0], { color: shouldUseColor() });
+        if (qr) {
+            console.log('');
+            console.log(colorize('QR CODE', terminalStyle.bold, terminalStyle.dim));
+            console.log(qr);
+            console.log('');
+        }
+        else {
+            printLine('QR', 'mobile URL is too long to render in the terminal');
+        }
+        for (const url of networkUrls.slice(1, 3)) {
+            printLine('Alt', url);
+        }
+    }
+    else {
+        printSection('open on mobile');
+        printLine('Mobile', 'no LAN address detected; check VPN/network or use --host 0.0.0.0');
+    }
+    console.log('');
+    printSection('local access');
+    printLine('Local', localUrl, true);
+    printLine('Token', tokenStatus, AUTH_ENABLED);
+    console.log('');
+    printSection('runtime');
+    printLine('Workdir', config.workDir);
+    printLine('CLI', `${config.cliCommand} (${config.cliType})`);
+    console.log('');
+    printMacSleepHint();
+}
+// Graceful shutdown
+process.on('SIGINT', () => {
+    console.log('[AgentPilot] Shutting down...');
+    store.closeDb();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.log('[AgentPilot] Shutting down...');
+    store.closeDb();
+    process.exit(0);
+});
+server.listen(PORT, HOST, () => {
+    printStartupInfo();
+});