pikiclaw 0.2.35

package/dist/dashboard.js

@@ -0,0 +1,840 @@
+/**
+ * dashboard.ts — Web dashboard server for pikiclaw configuration and monitoring.
+ *
+ * All config is read from / written to ~/.pikiclaw/setting.json (no env vars).
+ */
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { exec, execFileSync, execSync } from 'node:child_process';
+import { collectSetupState, isSetupReady } from './onboarding.js';
+import { loadUserConfig, saveUserConfig, applyUserConfig, resolveUserWorkdir, setUserWorkdir, hasUserConfigFile } from './user-config.js';
+import { listAgents, getSessionTail, getSessions, listModels } from './code-agent.js';
+import { getDriver } from './agent-driver.js';
+import { VERSION } from './bot.js';
+import { validateFeishuConfig, validateTelegramConfig } from './config-validation.js';
+import { getDashboardHtml } from './dashboard-ui.js';
+import { shouldCacheChannelStates } from './channel-states.js';
+import { formatActiveTaskRestartError, getActiveTaskCount, registerProcessRuntime, requestProcessRestart, } from './process-control.js';
+import { getSessionStatusForBot } from './session-status.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+// Codex model discovery has to cold-start the app-server on some machines.
+// If we fall back too quickly the dashboard only shows the current model.
+const AGENT_STATUS_MODELS_TIMEOUT_MS = 4_000;
+const AGENT_STATUS_USAGE_TIMEOUT_MS = 1_500;
+const CHANNEL_STATUS_VALIDATION_TIMEOUT_MS = 3_000;
+const CHANNEL_STATUS_CACHE_TTL_MS = 20_000;
+const DEFAULT_SESSION_PAGE_SIZE = 6;
+const MAX_SESSION_PAGE_SIZE = 30;
+function buildLocalChannelStates(config) {
+    const telegramConfigured = !!String(config.telegramBotToken || '').trim();
+    const feishuAppId = String(config.feishuAppId || '').trim();
+    const feishuSecret = String(config.feishuAppSecret || '').trim();
+    const feishuConfigured = !!(feishuAppId || feishuSecret);
+    const feishuReady = !!(feishuAppId && feishuSecret);
+    return [
+        {
+            channel: 'telegram',
+            configured: telegramConfigured,
+            ready: false,
+            validated: false,
+            status: telegramConfigured ? 'checking' : 'missing',
+            detail: telegramConfigured ? 'Validating Telegram credentials…' : 'Telegram is not configured.',
+        },
+        {
+            channel: 'feishu',
+            configured: feishuConfigured,
+            ready: false,
+            validated: false,
+            status: !feishuConfigured ? 'missing' : feishuReady ? 'checking' : 'invalid',
+            detail: !feishuConfigured
+                ? 'Feishu credentials are not configured.'
+                : feishuReady
+                    ? 'Validating Feishu credentials…'
+                    : 'Both App ID and App Secret are required.',
+        },
+    ];
+}
+function getSetupState(config = loadUserConfig(), agentOptions = {}) {
+    const agents = listAgents(agentOptions).agents;
+    const channels = buildLocalChannelStates(config);
+    const readyChannel = channels.find(channel => channel.ready)?.channel;
+    const configuredChannel = channels.find(channel => channel.configured)?.channel;
+    return collectSetupState({
+        agents,
+        channel: readyChannel || configuredChannel || 'telegram',
+        tokenProvided: channels.some(channel => channel.configured),
+        channels,
+    });
+}
+function withTimeoutFallback(promise, timeoutMs, fallback) {
+    return new Promise(resolve => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(fallback);
+        }, timeoutMs);
+        promise
+            .then(result => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        })
+            .catch(() => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(fallback);
+        });
+    });
+}
+function parsePageNumber(value, fallback = 0) {
+    const parsed = Number.parseInt(value || '', 10);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return fallback;
+    return parsed;
+}
+function parsePageSize(value, fallback = DEFAULT_SESSION_PAGE_SIZE) {
+    const parsed = Number.parseInt(value || '', 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return fallback;
+    return Math.min(parsed, MAX_SESSION_PAGE_SIZE);
+}
+function paginateSessionResult(result, page, limit) {
+    const sessions = Array.isArray(result.sessions) ? result.sessions : [];
+    const total = sessions.length;
+    const totalPages = Math.max(1, Math.ceil(total / limit));
+    const safePage = Math.min(page, totalPages - 1);
+    const start = safePage * limit;
+    return {
+        ok: result.ok,
+        error: result.error,
+        sessions: sessions.slice(start, start + limit),
+        page: safePage,
+        limit,
+        total,
+        totalPages,
+        hasMore: safePage + 1 < totalPages,
+    };
+}
+function enrichSessionResultWithRuntimeStatus(result, bot) {
+    return {
+        ...result,
+        sessions: result.sessions.map(session => {
+            const status = bot ? getSessionStatusForBot(bot, session) : { isCurrent: false, isRunning: !!session.running };
+            return {
+                ...session,
+                running: status.isRunning,
+                isCurrent: status.isCurrent,
+            };
+        }),
+    };
+}
+function dedupeModels(models) {
+    const seen = new Set();
+    const deduped = [];
+    for (const model of models) {
+        const id = String(model?.id || '').trim();
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        deduped.push({ id, alias: model.alias?.trim() || null });
+    }
+    return deduped;
+}
+const permissionPaneUrls = {
+    accessibility: 'x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility',
+    screenRecording: 'x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture',
+    fullDiskAccess: 'x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles',
+};
+function runJxa(script, timeout = 5_000) {
+    try {
+        return String(execFileSync('osascript', ['-l', 'JavaScript', '-e', script], { encoding: 'utf8', timeout })).trim().toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function checkAccessibilityPermission() {
+    try {
+        execFileSync('osascript', ['-e', 'tell application "System Events" to keystroke ""'], { stdio: 'ignore', timeout: 4_000 });
+        return true;
+    }
+    catch { }
+    const output = runJxa('ObjC.bindFunction("CGPreflightPostEventAccess", ["bool", []]); console.log($.CGPreflightPostEventAccess());', 4_000);
+    if (output == null)
+        return null;
+    return output === 'true';
+}
+function requestAccessibilityPermission() {
+    return runJxa('ObjC.bindFunction("CGRequestPostEventAccess", ["bool", []]); console.log($.CGRequestPostEventAccess());', 6_000) !== null;
+}
+function checkScreenRecordingPermission() {
+    const screenshotPath = path.join(os.tmpdir(), `.pikiclaw_perm_test_${process.pid}_${Date.now()}.png`);
+    try {
+        execFileSync('screencapture', ['-x', screenshotPath], { stdio: 'ignore', timeout: 5_000 });
+        return true;
+    }
+    catch { }
+    finally {
+        try {
+            fs.rmSync(screenshotPath, { force: true });
+        }
+        catch { }
+    }
+    const output = runJxa('ObjC.bindFunction("CGPreflightScreenCaptureAccess", ["bool", []]); console.log($.CGPreflightScreenCaptureAccess());', 4_000);
+    if (output == null)
+        return null;
+    return output === 'true';
+}
+function requestScreenRecordingPermission() {
+    return runJxa('ObjC.bindFunction("CGRequestScreenCaptureAccess", ["bool", []]); console.log($.CGRequestScreenCaptureAccess());', 6_000) !== null;
+}
+function openPermissionSettings(permission) {
+    const pane = permissionPaneUrls[permission];
+    if (!pane)
+        return false;
+    try {
+        execFileSync('open', [pane], { stdio: 'ignore', timeout: 3_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function checkPermissions() {
+    const r = {};
+    if (process.platform !== 'darwin') {
+        r.accessibility = { granted: true, checkable: false, detail: 'N/A' };
+        r.screenRecording = { granted: true, checkable: false, detail: 'N/A' };
+        r.fullDiskAccess = { granted: true, checkable: false, detail: 'N/A' };
+        return r;
+    }
+    const accessibilityGranted = checkAccessibilityPermission();
+    r.accessibility = {
+        granted: accessibilityGranted === true,
+        checkable: true,
+        detail: accessibilityGranted === true ? '已授权' : '未授权',
+    };
+    const screenRecordingGranted = checkScreenRecordingPermission();
+    r.screenRecording = {
+        granted: screenRecordingGranted === true,
+        checkable: true,
+        detail: screenRecordingGranted === true ? '已授权' : '未授权',
+    };
+    try {
+        execSync(`ls "${os.homedir()}/Library/Mail" 2>/dev/null`, { timeout: 3000 });
+        r.fullDiskAccess = { granted: true, checkable: true, detail: '已授权' };
+    }
+    catch {
+        r.fullDiskAccess = { granted: false, checkable: true, detail: '未授权' };
+    }
+    return r;
+}
+function requestPermission(permission) {
+    if (process.platform !== 'darwin') {
+        return {
+            ok: false,
+            action: 'unsupported',
+            granted: true,
+            requiresManualGrant: false,
+            error: 'Permission requests are only supported on macOS.',
+        };
+    }
+    const current = checkPermissions()[permission];
+    if (current?.granted) {
+        return {
+            ok: true,
+            action: 'already_granted',
+            granted: true,
+            requiresManualGrant: false,
+        };
+    }
+    if (permission === 'accessibility') {
+        const prompted = requestAccessibilityPermission();
+        if (!prompted) {
+            const openedSettings = openPermissionSettings(permission);
+            return openedSettings
+                ? { ok: true, action: 'opened_settings', granted: false, requiresManualGrant: true }
+                : { ok: false, action: 'unsupported', granted: false, requiresManualGrant: true, error: 'Failed to trigger Accessibility permission request.' };
+        }
+        return {
+            ok: true,
+            action: 'prompted',
+            granted: !!checkPermissions().accessibility?.granted,
+            requiresManualGrant: true,
+        };
+    }
+    if (permission === 'screenRecording') {
+        const prompted = requestScreenRecordingPermission();
+        if (!prompted) {
+            const openedSettings = openPermissionSettings(permission);
+            return openedSettings
+                ? { ok: true, action: 'opened_settings', granted: false, requiresManualGrant: true }
+                : { ok: false, action: 'unsupported', granted: false, requiresManualGrant: true, error: 'Failed to trigger Screen Recording permission request.' };
+        }
+        return {
+            ok: true,
+            action: 'prompted',
+            granted: !!checkPermissions().screenRecording?.granted,
+            requiresManualGrant: true,
+        };
+    }
+    if (permission === 'fullDiskAccess') {
+        const openedSettings = openPermissionSettings(permission);
+        return openedSettings
+            ? { ok: true, action: 'opened_settings', granted: false, requiresManualGrant: true }
+            : { ok: false, action: 'unsupported', granted: false, requiresManualGrant: true, error: 'Failed to open Full Disk Access settings.' };
+    }
+    return { ok: false, action: 'unsupported', granted: false, requiresManualGrant: true, error: 'Unknown permission.' };
+}
+async function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => { try {
+            resolve(JSON.parse(Buffer.concat(chunks).toString()));
+        }
+        catch {
+            reject(new Error('Invalid JSON'));
+        } });
+        req.on('error', reject);
+    });
+}
+function json(res, data, status = 200) {
+    res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(data));
+}
+function dashboardLog(message) {
+    const ts = new Date().toTimeString().slice(0, 8);
+    process.stdout.write(`[dashboard ${ts}] ${message}\n`);
+}
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+export async function startDashboard(opts = {}) {
+    const preferredPort = opts.port || 3939;
+    let botRef = opts.bot || null;
+    const htmlContent = getDashboardHtml({ version: VERSION });
+    const runtimePrefs = {
+        models: {},
+        efforts: {},
+    };
+    let channelStateCache = null;
+    const knownAgents = new Set(['claude', 'codex', 'gemini']);
+    const defaultModels = {
+        claude: 'claude-opus-4-6',
+        codex: 'gpt-5.4',
+        gemini: 'gemini-3.1-pro-preview',
+    };
+    const defaultEfforts = {
+        claude: 'high',
+        codex: 'xhigh',
+    };
+    function isAgent(value) {
+        return typeof value === 'string' && knownAgents.has(value);
+    }
+    function emptyUsage(agent, error) {
+        return { ok: false, agent, source: null, capturedAt: null, status: null, windows: [], error };
+    }
+    function channelStateCacheKey(config) {
+        return JSON.stringify({
+            telegramBotToken: String(config.telegramBotToken || '').trim(),
+            telegramAllowedChatIds: String(config.telegramAllowedChatIds || '').trim(),
+            feishuAppId: String(config.feishuAppId || '').trim(),
+            feishuAppSecret: String(config.feishuAppSecret || '').trim(),
+        });
+    }
+    async function resolveChannelStates(config) {
+        const key = channelStateCacheKey(config);
+        const now = Date.now();
+        if (channelStateCache && channelStateCache.key === key && channelStateCache.expiresAt > now) {
+            return channelStateCache.channels;
+        }
+        const fallback = buildLocalChannelStates(config);
+        const [telegram, feishu] = await Promise.all([
+            withTimeoutFallback(validateTelegramConfig(config.telegramBotToken, config.telegramAllowedChatIds).then(result => result.state), CHANNEL_STATUS_VALIDATION_TIMEOUT_MS, fallback[0]),
+            withTimeoutFallback(validateFeishuConfig(config.feishuAppId, config.feishuAppSecret).then(result => result.state), CHANNEL_STATUS_VALIDATION_TIMEOUT_MS, fallback[1]),
+        ]);
+        const channels = [telegram, feishu];
+        if (shouldCacheChannelStates(channels)) {
+            channelStateCache = {
+                key,
+                expiresAt: now + CHANNEL_STATUS_CACHE_TTL_MS,
+                channels,
+            };
+        }
+        return channels;
+    }
+    async function buildValidatedSetupState(config = loadUserConfig(), agentOptions = {}) {
+        const agents = listAgents(agentOptions).agents;
+        const channels = await resolveChannelStates(config);
+        const readyChannel = channels.find(channel => channel.ready)?.channel;
+        const configuredChannel = channels.find(channel => channel.configured)?.channel;
+        return collectSetupState({
+            agents,
+            channel: readyChannel || configuredChannel || 'telegram',
+            tokenProvided: channels.some(channel => channel.configured),
+            channels,
+        });
+    }
+    function modelEnv(agent) {
+        switch (agent) {
+            case 'claude': return process.env.CLAUDE_MODEL;
+            case 'codex': return process.env.CODEX_MODEL;
+            case 'gemini': return process.env.GEMINI_MODEL;
+        }
+    }
+    function effortEnv(agent) {
+        switch (agent) {
+            case 'claude': return process.env.CLAUDE_REASONING_EFFORT;
+            case 'codex': return process.env.CODEX_REASONING_EFFORT;
+            case 'gemini': return undefined;
+        }
+    }
+    function configModel(config, agent) {
+        switch (agent) {
+            case 'claude': return String(config.claudeModel || '').trim() || undefined;
+            case 'codex': return String(config.codexModel || '').trim() || undefined;
+            case 'gemini': return String(config.geminiModel || '').trim() || undefined;
+        }
+    }
+    function configEffort(config, agent) {
+        switch (agent) {
+            case 'claude': return String(config.claudeReasoningEffort || '').trim().toLowerCase() || undefined;
+            case 'codex': return String(config.codexReasoningEffort || '').trim().toLowerCase() || undefined;
+            case 'gemini': return undefined;
+        }
+    }
+    function setModelEnv(agent, value) {
+        switch (agent) {
+            case 'claude':
+                process.env.CLAUDE_MODEL = value;
+                break;
+            case 'codex':
+                process.env.CODEX_MODEL = value;
+                break;
+            case 'gemini':
+                process.env.GEMINI_MODEL = value;
+                break;
+        }
+    }
+    function setEffortEnv(agent, value) {
+        switch (agent) {
+            case 'claude':
+                process.env.CLAUDE_REASONING_EFFORT = value;
+                break;
+            case 'codex':
+                process.env.CODEX_REASONING_EFFORT = value;
+                break;
+            case 'gemini': break;
+        }
+    }
+    function getRuntimeDefaultAgent(config) {
+        if (botRef)
+            return botRef.defaultAgent;
+        const raw = String(runtimePrefs.defaultAgent || config.defaultAgent || 'codex').trim().toLowerCase();
+        return isAgent(raw) ? raw : 'codex';
+    }
+    function getRuntimeWorkdir(config) {
+        return botRef?.workdir || resolveUserWorkdir({ config });
+    }
+    function getRequestWorkdir(config = loadUserConfig()) {
+        return getRuntimeWorkdir(config);
+    }
+    function getRuntimeModel(agent, config = loadUserConfig()) {
+        if (botRef)
+            return botRef.modelForAgent(agent) || defaultModels[agent];
+        return String(runtimePrefs.models[agent] || configModel(config, agent) || modelEnv(agent) || defaultModels[agent]).trim();
+    }
+    function getRuntimeEffort(agent, config = loadUserConfig()) {
+        if (agent === 'gemini')
+            return null;
+        if (botRef)
+            return botRef.effortForAgent(agent);
+        const value = String(runtimePrefs.efforts[agent] || configEffort(config, agent) || effortEnv(agent) || defaultEfforts[agent] || '').trim().toLowerCase();
+        return value || null;
+    }
+    async function buildAgentStatusResponse(config = loadUserConfig()) {
+        const setupState = getSetupState(config, { includeVersion: true });
+        const workdir = getRuntimeWorkdir(config);
+        const defaultAgent = getRuntimeDefaultAgent(config);
+        const agents = await Promise.all(setupState.agents.map(async (agentState) => {
+            const agentId = isAgent(agentState.agent) ? agentState.agent : null;
+            if (!agentId) {
+                return {
+                    ...agentState,
+                    selectedModel: null,
+                    selectedEffort: null,
+                    isDefault: false,
+                    models: [],
+                    usage: null,
+                };
+            }
+            const selectedModel = getRuntimeModel(agentId, config);
+            const selectedEffort = getRuntimeEffort(agentId, config);
+            let models = [];
+            let usage = emptyUsage(agentId, 'Agent not installed.');
+            if (agentState.installed) {
+                const modelFallback = selectedModel ? [{ id: selectedModel, alias: null }] : [];
+                try {
+                    const driver = getDriver(agentId);
+                    const cachedUsage = driver.getUsage({ agent: agentId, model: selectedModel });
+                    const [resolvedModels, resolvedUsage] = await Promise.all([
+                        withTimeoutFallback(listModels(agentId, { workdir, currentModel: selectedModel }).then(result => dedupeModels([
+                            ...modelFallback,
+                            ...result.models,
+                        ])), AGENT_STATUS_MODELS_TIMEOUT_MS, modelFallback),
+                        driver.getUsageLive
+                            ? withTimeoutFallback(driver.getUsageLive({ agent: agentId, model: selectedModel }), AGENT_STATUS_USAGE_TIMEOUT_MS, cachedUsage)
+                            : Promise.resolve(cachedUsage),
+                    ]);
+                    models = resolvedModels;
+                    usage = resolvedUsage;
+                }
+                catch (err) {
+                    const detail = err instanceof Error ? err.message : String(err);
+                    usage = emptyUsage(agentId, detail || 'Usage query failed.');
+                }
+            }
+            return {
+                ...agentState,
+                selectedModel,
+                selectedEffort,
+                isDefault: agentId === defaultAgent,
+                models,
+                usage,
+            };
+        }));
+        return { defaultAgent, workdir, agents };
+    }
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url || '/', 'http://localhost');
+        const method = req.method?.toUpperCase() || 'GET';
+        try {
+            if (url.pathname === '/' && method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                return res.end(htmlContent);
+            }
+            // Full state (config from file only)
+            if (url.pathname === '/api/state' && method === 'GET') {
+                const config = loadUserConfig();
+                const setupState = await buildValidatedSetupState(config);
+                const permissions = checkPermissions();
+                return json(res, {
+                    version: VERSION,
+                    ready: isSetupReady(setupState),
+                    configExists: hasUserConfigFile(),
+                    config,
+                    runtimeWorkdir: getRuntimeWorkdir(config),
+                    setupState,
+                    permissions,
+                    platform: process.platform,
+                    pid: process.pid,
+                    nodeVersion: process.versions.node,
+                    bot: botRef ? {
+                        workdir: botRef.workdir,
+                        defaultAgent: botRef.defaultAgent,
+                        uptime: Date.now() - botRef.startedAt,
+                        connected: botRef.connected,
+                        stats: botRef.stats,
+                        activeTasks: botRef.activeTasks.size,
+                        sessions: botRef.sessionStates.size,
+                    } : null,
+                });
+            }
+            if (url.pathname === '/api/agent-status' && method === 'GET') {
+                return json(res, await buildAgentStatusResponse());
+            }
+            // Host info
+            if (url.pathname === '/api/host' && method === 'GET') {
+                if (botRef)
+                    return json(res, botRef.getHostData());
+                const cpus = os.cpus();
+                return json(res, {
+                    hostName: os.hostname(), cpuModel: cpus[0]?.model || 'unknown',
+                    cpuCount: cpus.length, totalMem: os.totalmem(), freeMem: os.freemem(),
+                    platform: process.platform, arch: os.arch(),
+                });
+            }
+            // Agents
+            if (url.pathname === '/api/agents' && method === 'GET') {
+                return json(res, { agents: getSetupState(loadUserConfig(), { includeVersion: true }).agents });
+            }
+            // Sessions (per agent)
+            if (url.pathname.match(/^\/api\/sessions\/[^/]+$/) && method === 'GET') {
+                const agent = url.pathname.split('/')[3];
+                const config = loadUserConfig();
+                const workdir = getRequestWorkdir(config);
+                const page = parsePageNumber(url.searchParams.get('page'));
+                const limit = parsePageSize(url.searchParams.get('limit'));
+                dashboardLog(`[sessions] endpoint=single agent=${agent} resolvedWorkdir=${workdir} exists=${fs.existsSync(workdir)} ` +
+                    `configWorkdir=${String(config.workdir || '(none)')} botWorkdir=${botRef?.workdir || '(none)'} ` +
+                    `page=${page} limit=${limit}`);
+                const result = await getSessions({ agent, workdir });
+                const paged = paginateSessionResult(enrichSessionResultWithRuntimeStatus(result, botRef), page, limit);
+                dashboardLog(`[sessions] endpoint=single agent=${agent} ok=${paged.ok} total=${paged.total} ` +
+                    `returned=${paged.sessions.length} error=${paged.error || '(none)'}`);
+                return json(res, paged);
+            }
+            // All sessions (all agents, for swim lane view)
+            if (url.pathname === '/api/sessions' && method === 'GET') {
+                const config = loadUserConfig();
+                const workdir = getRequestWorkdir(config);
+                const page = parsePageNumber(url.searchParams.get('page'));
+                const limit = parsePageSize(url.searchParams.get('limit'));
+                dashboardLog(`[sessions] endpoint=all resolvedWorkdir=${workdir} exists=${fs.existsSync(workdir)} ` +
+                    `configWorkdir=${String(config.workdir || '(none)')} botWorkdir=${botRef?.workdir || '(none)'} ` +
+                    `page=${page} limit=${limit}`);
+                const agents = listAgents().agents.filter(a => a.installed);
+                const result = {};
+                await Promise.all(agents.map(async (a) => {
+                    const agentResult = await getSessions({ agent: a.agent, workdir });
+                    result[a.agent] = paginateSessionResult(enrichSessionResultWithRuntimeStatus(agentResult, botRef), page, limit);
+                    const paged = result[a.agent];
+                    dashboardLog(`[sessions] endpoint=all agent=${a.agent} ok=${!!paged?.ok} total=${paged?.total ?? 0} ` +
+                        `returned=${Array.isArray(paged?.sessions) ? paged.sessions.length : 0} error=${paged?.error || '(none)'}`);
+                }));
+                return json(res, result);
+            }
+            // Session detail (tail messages)
+            if (url.pathname.match(/^\/api\/session-detail\/[^/]+\/[^/]+$/) && method === 'GET') {
+                const parts = url.pathname.split('/');
+                const agent = parts[3];
+                const sessionId = decodeURIComponent(parts[4]);
+                const config = loadUserConfig();
+                const workdir = getRequestWorkdir(config);
+                const limit = parseInt(url.searchParams.get('limit') || '6', 10);
+                dashboardLog(`[sessions] endpoint=detail agent=${agent} session=${sessionId} limit=${limit} resolvedWorkdir=${workdir} ` +
+                    `exists=${fs.existsSync(workdir)} configWorkdir=${String(config.workdir || '(none)')} botWorkdir=${botRef?.workdir || '(none)'}`);
+                const tail = await getSessionTail({ agent, sessionId, workdir, limit });
+                dashboardLog(`[sessions] endpoint=detail agent=${agent} session=${sessionId} ok=${tail.ok} messages=${tail.messages.length} error=${tail.error || '(none)'}`);
+                return json(res, tail);
+            }
+            // Permissions
+            if (url.pathname === '/api/permissions' && method === 'GET') {
+                return json(res, checkPermissions());
+            }
+            // Save config (to ~/.pikiclaw/setting.json)
+            if (url.pathname === '/api/config' && method === 'POST') {
+                const body = await parseJsonBody(req);
+                const merged = { ...loadUserConfig(), ...body };
+                const configPath = saveUserConfig(merged);
+                applyUserConfig(loadUserConfig());
+                return json(res, { ok: true, configPath });
+            }
+            if (url.pathname === '/api/runtime-agent' && method === 'POST') {
+                const body = await parseJsonBody(req);
+                const config = loadUserConfig();
+                const nextConfig = { ...config };
+                const defaultAgent = body?.defaultAgent;
+                const targetAgent = body?.agent;
+                const model = typeof body?.model === 'string' ? body.model.trim() : '';
+                const effort = typeof body?.effort === 'string' ? body.effort.trim().toLowerCase() : '';
+                if (defaultAgent != null) {
+                    if (!isAgent(defaultAgent))
+                        return json(res, { ok: false, error: 'Invalid defaultAgent' }, 400);
+                    runtimePrefs.defaultAgent = defaultAgent;
+                    process.env.DEFAULT_AGENT = defaultAgent;
+                    nextConfig.defaultAgent = defaultAgent;
+                    if (botRef)
+                        botRef.setDefaultAgent(defaultAgent);
+                }
+                if (model || effort) {
+                    if (!isAgent(targetAgent))
+                        return json(res, { ok: false, error: 'Invalid agent' }, 400);
+                    if (model) {
+                        runtimePrefs.models[targetAgent] = model;
+                        setModelEnv(targetAgent, model);
+                        if (targetAgent === 'claude')
+                            nextConfig.claudeModel = model;
+                        if (targetAgent === 'codex')
+                            nextConfig.codexModel = model;
+                        if (targetAgent === 'gemini')
+                            nextConfig.geminiModel = model;
+                        if (botRef)
+                            botRef.setModelForAgent(targetAgent, model);
+                    }
+                    if (effort && targetAgent !== 'gemini') {
+                        runtimePrefs.efforts[targetAgent] = effort;
+                        setEffortEnv(targetAgent, effort);
+                        if (targetAgent === 'claude')
+                            nextConfig.claudeReasoningEffort = effort;
+                        if (targetAgent === 'codex')
+                            nextConfig.codexReasoningEffort = effort;
+                        if (botRef)
+                            botRef.setEffortForAgent(targetAgent, effort);
+                    }
+                }
+                saveUserConfig(nextConfig);
+                applyUserConfig(nextConfig);
+                return json(res, { ok: true, ...(await buildAgentStatusResponse(nextConfig)) });
+            }
+            // Validate Telegram token
+            if (url.pathname === '/api/validate-telegram-token' && method === 'POST') {
+                const body = await parseJsonBody(req);
+                const result = await validateTelegramConfig(body.token || '', body.allowedChatIds || '');
+                return json(res, {
+                    ok: result.state.ready,
+                    error: result.state.ready ? null : result.state.detail,
+                    bot: result.bot,
+                    normalizedAllowedChatIds: result.normalizedAllowedChatIds,
+                });
+            }
+            // Validate Feishu credentials
+            if (url.pathname === '/api/validate-feishu-config' && method === 'POST') {
+                const body = await parseJsonBody(req);
+                const startedAt = Date.now();
+                const rawAppId = String(body.appId || '').trim();
+                const maskedAppId = !rawAppId
+                    ? '(missing)'
+                    : rawAppId.length <= 10
+                        ? rawAppId
+                        : `${rawAppId.slice(0, 6)}...${rawAppId.slice(-4)}`;
+                const ts = new Date().toISOString().slice(11, 19);
+                process.stdout.write(`[dashboard ${ts}] [feishu-config] request app=${maskedAppId}\n`);
+                const result = await validateFeishuConfig(body.appId || '', body.appSecret || '');
+                process.stdout.write(`[dashboard ${ts}] [feishu-config] result app=${maskedAppId} ok=${result.state.ready} status=${result.state.status} elapsedMs=${Date.now() - startedAt}\n`);
+                return json(res, {
+                    ok: result.state.ready,
+                    error: result.state.ready ? null : result.state.detail,
+                    app: result.app,
+                });
+            }
+            // Open macOS preferences
+            if (url.pathname === '/api/open-preferences' && method === 'POST') {
+                const body = await parseJsonBody(req);
+                const permission = String(body.permission || '');
+                if (!permissionPaneUrls[permission]) {
+                    return json(res, {
+                        ok: false,
+                        action: 'unsupported',
+                        granted: false,
+                        requiresManualGrant: false,
+                        error: 'Invalid permission.',
+                    }, 400);
+                }
+                const result = requestPermission(permission);
+                dashboardLog(`[permissions] permission=${permission} action=${result.action} granted=${result.granted} manual=${result.requiresManualGrant} ok=${result.ok}`);
+                return json(res, result, result.ok ? 200 : 500);
+            }
+            // Restart process
+            if (url.pathname === '/api/restart' && method === 'POST') {
+                const activeTasks = getActiveTaskCount();
+                if (activeTasks > 0) {
+                    return json(res, { ok: false, error: formatActiveTaskRestartError(activeTasks) }, 409);
+                }
+                json(res, { ok: true });
+                setTimeout(() => {
+                    void requestProcessRestart({ log: message => dashboardLog(message) });
+                }, 50);
+                return;
+            }
+            // Switch workdir
+            if (url.pathname === '/api/switch-workdir' && method === 'POST') {
+                const body = await parseJsonBody(req);
+                const newPath = body.path;
+                if (!newPath)
+                    return json(res, { ok: false, error: 'Missing path' }, 400);
+                const resolvedPath = path.resolve(String(newPath).replace(/^~/, process.env.HOME || ''));
+                if (botRef) {
+                    botRef.switchWorkdir(resolvedPath);
+                    return json(res, { ok: true, workdir: botRef.workdir });
+                }
+                const saved = setUserWorkdir(resolvedPath);
+                return json(res, { ok: true, workdir: saved.workdir });
+            }
+            // List directory entries for tree browser
+            if (url.pathname === '/api/ls-dir' && method === 'GET') {
+                const dir = url.searchParams.get('path') || os.homedir();
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    const dirs = entries
+                        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+                        .map(e => ({ name: e.name, path: path.join(dir, e.name) }))
+                        .sort((a, b) => a.name.localeCompare(b.name));
+                    const isGit = fs.existsSync(path.join(dir, '.git'));
+                    return json(res, { ok: true, path: dir, parent: path.dirname(dir), dirs, isGit });
+                }
+                catch (err) {
+                    return json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 400);
+                }
+            }
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+        catch (err) {
+            json(res, { error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    const unregisterProcessRuntime = registerProcessRuntime({
+        label: 'dashboard',
+        prepareForRestart: () => new Promise(resolve => {
+            if (!server.listening) {
+                resolve();
+                return;
+            }
+            server.close(() => resolve());
+        }),
+    });
+    return new Promise((resolve, reject) => {
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE')
+                server.listen(preferredPort + 1, onListening);
+            else
+                reject(err);
+        });
+        server.on('close', () => {
+            unregisterProcessRuntime();
+        });
+        function onListening() {
+            const addr = server.address();
+            const actualPort = typeof addr === 'object' && addr ? addr.port : preferredPort;
+            const dashUrl = `http://localhost:${actualPort}`;
+            const ts = new Date().toTimeString().slice(0, 8);
+            process.stdout.write(`[pikiclaw ${ts}] dashboard: ${dashUrl}\n`);
+            if (opts.open !== false) {
+                const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+                exec(`${cmd} ${dashUrl}`);
+            }
+            resolve({
+                port: actualPort, url: dashUrl, server,
+                attachBot(bot) {
+                    botRef = bot;
+                    if (runtimePrefs.defaultAgent)
+                        bot.setDefaultAgent(runtimePrefs.defaultAgent);
+                    for (const [agent, model] of Object.entries(runtimePrefs.models)) {
+                        if (isAgent(agent) && typeof model === 'string' && model.trim())
+                            bot.setModelForAgent(agent, model);
+                    }
+                    for (const [agent, effort] of Object.entries(runtimePrefs.efforts)) {
+                        if (isAgent(agent) && agent !== 'gemini' && typeof effort === 'string' && effort.trim())
+                            bot.setEffortForAgent(agent, effort);
+                    }
+                },
+                close() {
+                    return new Promise(resolveClose => {
+                        if (!server.listening) {
+                            unregisterProcessRuntime();
+                            resolveClose();
+                            return;
+                        }
+                        server.close(() => {
+                            unregisterProcessRuntime();
+                            resolveClose();
+                        });
+                    });
+                },
+            });
+        }
+        server.listen(preferredPort, onListening);
+    });
+}