pikiclaw 0.2.35

package/dist/bot.js

@@ -0,0 +1,897 @@
+/**
+ * bot.ts — shared bot logic: config, state, streaming bridge, helpers, keep-alive.
+ *
+ * Channel-agnostic. Subclass per IM (see bot-telegram.ts).
+ */
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync, spawn } from 'node:child_process';
+import { getActiveUserConfig, onUserConfigChange, resolveUserWorkdir, setUserWorkdir } from './user-config.js';
+import { doStream, getSessions, getSessionTail, getUsage, initializeProjectSkills, listAgents, listModels, listSkills, } from './code-agent.js';
+import { getDriver, hasDriver, allDriverIds } from './agent-driver.js';
+import { terminateProcessTree } from './process-control.js';
+export const VERSION = '0.2.35';
+const MACOS_USER_ACTIVITY_PULSE_INTERVAL_MS = 20_000;
+const MACOS_USER_ACTIVITY_PULSE_TIMEOUT_S = 30;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * If `dir` has a .gitignore, ensure runtime state is ignored while `.pikiclaw/skills`
+ * stays trackable as the canonical project skill location.
+ */
+function ensureGitignore(dir) {
+    try {
+        const gi = path.join(dir, '.gitignore');
+        if (!fs.existsSync(gi))
+            return;
+        const managedLines = [
+            '.pikiclaw/*',
+            '!.pikiclaw/skills/',
+            '!.pikiclaw/skills/**',
+            '.claude/skills/',
+            '.agents/skills/',
+        ];
+        const legacyLines = new Set(['.pikiclaw/']);
+        const rawLines = fs.readFileSync(gi, 'utf8').split(/\r?\n/);
+        const normalized = rawLines.filter(line => {
+            const trimmed = line.trim();
+            return trimmed && !managedLines.includes(trimmed) && !legacyLines.has(trimmed);
+        });
+        const next = [...normalized, ...managedLines, ''].join('\n');
+        const current = fs.readFileSync(gi, 'utf8');
+        if (current === next)
+            return;
+        fs.writeFileSync(gi, next);
+    }
+    catch { /* best-effort */ }
+}
+export function envBool(name, def) {
+    const raw = process.env[name];
+    if (raw == null)
+        return def;
+    return ['1', 'true', 'yes', 'on'].includes(raw.trim().toLowerCase());
+}
+export function envInt(name, def) {
+    const raw = process.env[name];
+    if (raw == null || raw.trim() === '')
+        return def;
+    const n = parseInt(raw, 10);
+    return Number.isNaN(n) ? def : n;
+}
+export function shellSplit(str) {
+    const args = [];
+    let cur = '', inS = false, inD = false;
+    for (const ch of str) {
+        if (ch === "'" && !inD) {
+            inS = !inS;
+            continue;
+        }
+        if (ch === '"' && !inS) {
+            inD = !inD;
+            continue;
+        }
+        if (ch === ' ' && !inS && !inD) {
+            if (cur) {
+                args.push(cur);
+                cur = '';
+            }
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur)
+        args.push(cur);
+    return args;
+}
+export function whichSync(cmd) {
+    try {
+        return execSync(`which ${cmd} 2>/dev/null`, { encoding: 'utf-8' }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function fmtTokens(n) {
+    if (n == null)
+        return '-';
+    return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
+export function fmtUptime(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ${m % 60}m`;
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h`;
+}
+export function fmtBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(0)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+    if (bytes < 1024 * 1024 * 1024 * 1024)
+        return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
+    return `${(bytes / 1024 / 1024 / 1024 / 1024).toFixed(1)}TB`;
+}
+export function parseAllowedChatIds(raw) {
+    const ids = new Set();
+    for (const t of raw.split(',')) {
+        const v = t.trim();
+        if (!v)
+            continue;
+        const n = parseInt(v, 10);
+        // If the string is purely numeric, store as number for backward compat (Telegram).
+        // Otherwise store as string (Feishu, Discord, etc.).
+        if (!Number.isNaN(n) && String(n) === v)
+            ids.add(n);
+        else if (v)
+            ids.add(v);
+    }
+    return ids;
+}
+export function normalizeAgent(raw) {
+    const v = raw.trim().toLowerCase();
+    if (!hasDriver(v))
+        throw new Error(`Invalid agent: ${v}. Use: ${allDriverIds().join(', ')}`);
+    return v;
+}
+export function listSubdirs(dirPath) {
+    try {
+        return fs.readdirSync(dirPath)
+            .filter(name => {
+            if (name.startsWith('.'))
+                return false;
+            try {
+                return fs.statSync(path.join(dirPath, name)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    }
+    catch {
+        return [];
+    }
+}
+export function thinkLabel(agent) {
+    try {
+        return getDriver(agent).thinkLabel;
+    }
+    catch {
+        return 'Thinking';
+    }
+}
+export function extractThinkingTail(text, maxLines = 3) {
+    const normalized = text.replace(/\r\n?/g, '\n').trim();
+    if (!normalized)
+        return '';
+    const blocks = normalized
+        .split(/\n\s*\n+/)
+        .map(block => block.trim())
+        .filter(Boolean);
+    if (blocks.length > 1)
+        return blocks[blocks.length - 1];
+    const lines = normalized
+        .split('\n')
+        .map(line => line.trimEnd())
+        .filter(line => line.trim());
+    if (lines.length > 1)
+        return lines.slice(-Math.min(maxLines, lines.length)).join('\n').trim();
+    return normalized;
+}
+export function formatThinkingForDisplay(text, maxChars = 800) {
+    let display = extractThinkingTail(text);
+    if (display.length > maxChars)
+        display = '...\n' + display.slice(-maxChars);
+    return display;
+}
+export function buildPrompt(text, files) {
+    if (!files.length)
+        return text;
+    return `${text || 'Please analyze this.'}\n\n[Files: ${files.map(f => path.basename(f)).join(', ')}]`;
+}
+function configModelValue(config, agent) {
+    switch (agent) {
+        case 'claude': return String(config.claudeModel || process.env.CLAUDE_MODEL || 'claude-opus-4-6').trim();
+        case 'codex': return String(config.codexModel || process.env.CODEX_MODEL || 'gpt-5.4').trim();
+        case 'gemini': return String(config.geminiModel || process.env.GEMINI_MODEL || 'gemini-3.1-pro-preview').trim();
+    }
+    return '';
+}
+function configReasoningEffortValue(config, agent) {
+    switch (agent) {
+        case 'claude': return String(config.claudeReasoningEffort || process.env.CLAUDE_REASONING_EFFORT || 'high').trim().toLowerCase() || 'high';
+        case 'codex': return String(config.codexReasoningEffort || process.env.CODEX_REASONING_EFFORT || 'xhigh').trim().toLowerCase() || 'xhigh';
+        case 'gemini': return null;
+    }
+    return null;
+}
+function normalizeBatteryState(raw) {
+    const state = (raw || '').trim().toLowerCase().replace(/\s+/g, ' ');
+    if (!state)
+        return 'unknown';
+    if (state === 'finishing charge')
+        return 'charging';
+    if (state === 'ac attached')
+        return 'plugged in';
+    return state;
+}
+function getMacBatteryData() {
+    try {
+        const output = execSync('pmset -g batt', { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (!output || /no batteries/i.test(output))
+            return null;
+        const line = output.split('\n').find(v => /\d+%/.test(v));
+        if (!line)
+            return null;
+        const percent = line.match(/(\d+)%/)?.[1];
+        if (!percent)
+            return null;
+        const states = line
+            .split(';')
+            .slice(1)
+            .map(segment => segment.replace(/\bpresent:\s*(true|false)\b/ig, '').trim())
+            .filter(Boolean);
+        const state = states.find(segment => /(charging|discharging|charged|not charging|finishing charge|full)/i.test(segment))
+            ?? states.find(segment => !/remaining/i.test(segment))
+            ?? 'unknown';
+        return { percent: `${percent}%`, state: normalizeBatteryState(state) };
+    }
+    catch {
+        return null;
+    }
+}
+function getLinuxBatteryData() {
+    try {
+        const powerDir = '/sys/class/power_supply';
+        const batteries = fs.readdirSync(powerDir).filter(name => /^BAT/i.test(name));
+        for (const battery of batteries) {
+            const batteryDir = path.join(powerDir, battery);
+            const capacityPath = path.join(batteryDir, 'capacity');
+            if (!fs.existsSync(capacityPath))
+                continue;
+            const capacity = fs.readFileSync(capacityPath, 'utf-8').trim();
+            if (!capacity)
+                continue;
+            const statusPath = path.join(batteryDir, 'status');
+            const state = fs.existsSync(statusPath) ? fs.readFileSync(statusPath, 'utf-8').trim() : 'unknown';
+            return {
+                percent: capacity.endsWith('%') ? capacity : `${capacity}%`,
+                state: normalizeBatteryState(state),
+            };
+        }
+    }
+    catch { }
+    try {
+        const output = execSync('upower -e | grep -m1 battery | xargs -I{} upower -i "{}"', { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (!output)
+            return null;
+        const percent = output.match(/percentage:\s*(\d+%)/i)?.[1];
+        if (!percent)
+            return null;
+        const state = output.match(/state:\s*([^\n]+)/i)?.[1];
+        return { percent, state: normalizeBatteryState(state) };
+    }
+    catch {
+        return null;
+    }
+}
+function getWindowsBatteryData() {
+    try {
+        const output = execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Battery | Select-Object -First 1 EstimatedChargeRemaining,BatteryStatus | ConvertTo-Json -Compress"', { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (!output || output === 'null')
+            return null;
+        const parsed = JSON.parse(output);
+        const percent = Number(parsed?.EstimatedChargeRemaining);
+        if (!Number.isFinite(percent))
+            return null;
+        const status = Number(parsed?.BatteryStatus);
+        const state = status === 6 ? 'charging'
+            : status === 3 ? 'charged'
+                : status === 2 ? 'plugged in'
+                    : status === 1 ? 'discharging'
+                        : 'unknown';
+        return { percent: `${percent}%`, state };
+    }
+    catch {
+        return null;
+    }
+}
+function getHostBatteryData() {
+    if (process.platform === 'darwin')
+        return getMacBatteryData();
+    if (process.platform === 'linux')
+        return getLinuxBatteryData();
+    if (process.platform === 'win32')
+        return getWindowsBatteryData();
+    return null;
+}
+function parsePercent(value) {
+    if (!value)
+        return null;
+    const n = Number.parseFloat(value.trim());
+    return Number.isFinite(n) ? n : null;
+}
+function getMacCpuUsageData() {
+    try {
+        const output = execSync('top -l 1 -n 0 | sed -n \'1,6p\'', { encoding: 'utf-8', timeout: 3000 });
+        const line = output.split('\n').find(entry => /^CPU usage:/i.test(entry.trim()));
+        if (!line)
+            return null;
+        const match = line.match(/CPU usage:\s*([\d.]+)% user,\s*([\d.]+)% sys,\s*([\d.]+)% idle/i);
+        if (!match)
+            return null;
+        const userPercent = parsePercent(match[1]);
+        const sysPercent = parsePercent(match[2]);
+        const idlePercent = parsePercent(match[3]);
+        if (userPercent == null || sysPercent == null || idlePercent == null)
+            return null;
+        return {
+            userPercent,
+            sysPercent,
+            idlePercent,
+            usedPercent: Math.max(0, userPercent + sysPercent),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function getMacMemoryUsageData(totalMem) {
+    try {
+        const output = execSync('vm_stat', { encoding: 'utf-8', timeout: 3000 });
+        const pageSize = Number.parseInt(output.match(/page size of (\d+) bytes/i)?.[1] || '', 10);
+        if (!Number.isFinite(pageSize) || pageSize <= 0)
+            return null;
+        const pages = new Map();
+        for (const line of output.split('\n')) {
+            const match = line.match(/^Pages ([^:]+):\s+(\d+)\./);
+            if (!match)
+                continue;
+            pages.set(match[1].trim().toLowerCase(), Number.parseInt(match[2], 10));
+        }
+        const reclaimablePages = (pages.get('free') || 0) +
+            (pages.get('inactive') || 0) +
+            (pages.get('speculative') || 0) +
+            (pages.get('purgeable') || 0);
+        const availableBytes = Math.max(0, reclaimablePages * pageSize);
+        const usedBytes = Math.max(0, Math.min(totalMem, totalMem - availableBytes));
+        const percent = totalMem > 0 ? (usedBytes / totalMem) * 100 : 0;
+        return { usedBytes, availableBytes, percent, source: 'vm_stat' };
+    }
+    catch {
+        return null;
+    }
+}
+function getHostCpuUsageData() {
+    if (process.platform === 'darwin')
+        return getMacCpuUsageData();
+    return null;
+}
+function getHostDisplayName() {
+    if (process.platform === 'darwin') {
+        try {
+            const name = execSync('scutil --get ComputerName', { encoding: 'utf-8', timeout: 3000 }).trim();
+            if (name)
+                return name;
+        }
+        catch { /* fall through */ }
+    }
+    return os.hostname();
+}
+function getHostMemoryUsageData(totalMem, freeMem) {
+    if (process.platform === 'darwin') {
+        const macData = getMacMemoryUsageData(totalMem);
+        if (macData)
+            return macData;
+    }
+    const usedBytes = Math.max(0, totalMem - freeMem);
+    const availableBytes = Math.max(0, freeMem);
+    const percent = totalMem > 0 ? (usedBytes / totalMem) * 100 : 0;
+    return { usedBytes, availableBytes, percent, source: 'os' };
+}
+// ---------------------------------------------------------------------------
+// Bot
+// ---------------------------------------------------------------------------
+export class Bot {
+    workdir;
+    defaultAgent;
+    runTimeout;
+    allowedChatIds;
+    // Per-agent config — keyed by agent id
+    agentConfigs = {};
+    // Convenience accessors (backward-compat)
+    get codexModel() { return this.agentConfigs.codex?.model || ''; }
+    set codexModel(v) { this.agentConfigs.codex.model = v; }
+    get codexReasoningEffort() { return this.agentConfigs.codex?.reasoningEffort || 'xhigh'; }
+    set codexReasoningEffort(v) { this.agentConfigs.codex.reasoningEffort = v; }
+    get codexFullAccess() { return this.agentConfigs.codex?.fullAccess ?? true; }
+    get codexExtraArgs() { return this.agentConfigs.codex?.extraArgs || []; }
+    get claudeModel() { return this.agentConfigs.claude?.model || ''; }
+    set claudeModel(v) { this.agentConfigs.claude.model = v; }
+    get claudePermissionMode() { return this.agentConfigs.claude?.permissionMode || 'bypassPermissions'; }
+    get claudeExtraArgs() { return this.agentConfigs.claude?.extraArgs || []; }
+    chats = new Map();
+    sessionStates = new Map();
+    activeTasks = new Map();
+    startedAt = Date.now();
+    connected = false;
+    stats = { totalTurns: 0, totalInputTokens: 0, totalOutputTokens: 0, totalCachedTokens: 0 };
+    keepAliveProc = null;
+    keepAlivePulseTimer = null;
+    sessionChains = new Map();
+    userConfigUnsubscribe = null;
+    constructor() {
+        this.workdir = resolveUserWorkdir();
+        ensureGitignore(this.workdir);
+        initializeProjectSkills(this.workdir);
+        const config = getActiveUserConfig();
+        // Initialize per-agent configs
+        this.agentConfigs = {
+            codex: {
+                model: configModelValue(config, 'codex'),
+                reasoningEffort: configReasoningEffortValue(config, 'codex') || 'xhigh',
+                fullAccess: envBool('CODEX_FULL_ACCESS', true),
+                extraArgs: shellSplit(process.env.CODEX_EXTRA_ARGS || ''),
+            },
+            claude: {
+                model: configModelValue(config, 'claude'),
+                reasoningEffort: configReasoningEffortValue(config, 'claude') || 'high',
+                permissionMode: (process.env.CLAUDE_PERMISSION_MODE || 'bypassPermissions').trim(),
+                extraArgs: shellSplit(process.env.CLAUDE_EXTRA_ARGS || ''),
+            },
+            gemini: {
+                model: configModelValue(config, 'gemini'),
+                extraArgs: shellSplit(process.env.GEMINI_EXTRA_ARGS || ''),
+            },
+        };
+        this.defaultAgent = normalizeAgent('codex');
+        this.runTimeout = envInt('PIKICLAW_TIMEOUT', 1800);
+        this.allowedChatIds = parseAllowedChatIds(process.env.PIKICLAW_ALLOWED_IDS || '');
+        this.refreshManagedConfig(getActiveUserConfig(), { initial: true });
+        this.userConfigUnsubscribe = onUserConfigChange(config => this.refreshManagedConfig(config));
+    }
+    log(msg) {
+        const ts = new Date().toTimeString().slice(0, 8);
+        process.stdout.write(`[pikiclaw ${ts}] ${msg}\n`);
+    }
+    chat(chatId) {
+        let s = this.chats.get(chatId);
+        if (!s) {
+            s = { agent: this.defaultAgent, sessionId: null, activeSessionKey: null, modelId: null };
+            this.chats.set(chatId, s);
+        }
+        return s;
+    }
+    sessionKey(agent, sessionId) {
+        return `${agent}:${sessionId}`;
+    }
+    getSessionRuntimeByKey(sessionKey, opts = {}) {
+        if (!sessionKey)
+            return null;
+        const runtime = this.sessionStates.get(sessionKey) || null;
+        if (!runtime)
+            return null;
+        if (!opts.allowAnyWorkdir && runtime.workdir !== this.workdir)
+            return null;
+        return runtime;
+    }
+    getSelectedSession(cs) {
+        return this.getSessionRuntimeByKey(cs.activeSessionKey);
+    }
+    upsertSessionRuntime(session) {
+        const workdir = path.resolve(session.workdir || this.workdir);
+        const key = this.sessionKey(session.agent, session.sessionId);
+        const existing = this.sessionStates.get(key);
+        if (existing) {
+            existing.workdir = workdir;
+            existing.agent = session.agent;
+            existing.sessionId = session.sessionId;
+            if (session.workspacePath !== undefined)
+                existing.workspacePath = session.workspacePath ?? null;
+            if (session.codexCumulative !== undefined)
+                existing.codexCumulative = session.codexCumulative;
+            if (session.modelId !== undefined)
+                existing.modelId = session.modelId ?? null;
+            return existing;
+        }
+        const runtime = {
+            key,
+            workdir,
+            agent: session.agent,
+            sessionId: session.sessionId,
+            workspacePath: session.workspacePath ?? null,
+            codexCumulative: session.codexCumulative,
+            modelId: session.modelId ?? null,
+            runningTaskIds: new Set(),
+        };
+        this.sessionStates.set(key, runtime);
+        return runtime;
+    }
+    applySessionSelection(cs, session) {
+        cs.activeSessionKey = session?.key ?? null;
+        if (session) {
+            cs.agent = session.agent;
+            cs.sessionId = session.sessionId;
+            cs.workspacePath = session.workspacePath;
+            cs.codexCumulative = session.codexCumulative;
+            cs.modelId = session.modelId ?? null;
+            return;
+        }
+        cs.sessionId = null;
+        cs.workspacePath = null;
+        cs.codexCumulative = undefined;
+        cs.modelId = null;
+    }
+    resetChatConversation(cs) {
+        this.applySessionSelection(cs, null);
+    }
+    adoptSession(cs, session) {
+        if (!session.sessionId) {
+            this.applySessionSelection(cs, null);
+            return;
+        }
+        const runtime = this.upsertSessionRuntime({
+            agent: session.agent,
+            sessionId: session.sessionId,
+            workspacePath: session.workspacePath ?? null,
+            modelId: session.model ?? null,
+        });
+        this.applySessionSelection(cs, runtime);
+    }
+    syncSelectedChats(session) {
+        for (const [, cs] of this.chats) {
+            if (cs.activeSessionKey !== session.key)
+                continue;
+            this.applySessionSelection(cs, session);
+        }
+    }
+    beginTask(task) {
+        this.activeTasks.set(task.taskId, task);
+        const session = this.getSessionRuntimeByKey(task.sessionKey, { allowAnyWorkdir: true });
+        session?.runningTaskIds.add(task.taskId);
+    }
+    finishTask(taskId) {
+        const task = this.activeTasks.get(taskId);
+        if (!task)
+            return;
+        this.activeTasks.delete(taskId);
+        const session = this.getSessionRuntimeByKey(task.sessionKey, { allowAnyWorkdir: true });
+        if (!session)
+            return;
+        session.runningTaskIds.delete(taskId);
+        if (!session.runningTaskIds.size && session.workdir !== this.workdir) {
+            this.sessionStates.delete(session.key);
+        }
+    }
+    runningTaskForSession(sessionKey) {
+        const session = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
+        if (!session || !session.runningTaskIds.size)
+            return null;
+        let running = null;
+        for (const taskId of session.runningTaskIds) {
+            const task = this.activeTasks.get(taskId);
+            if (!task)
+                continue;
+            if (!running || task.startedAt < running.startedAt)
+                running = task;
+        }
+        return running;
+    }
+    queueSessionTask(session, task) {
+        const prev = this.sessionChains.get(session.key) || Promise.resolve();
+        const current = prev.catch(() => { }).then(task);
+        const settled = current.then(() => { }, () => { });
+        const chained = settled.finally(() => {
+            if (this.sessionChains.get(session.key) === chained)
+                this.sessionChains.delete(session.key);
+        });
+        this.sessionChains.set(session.key, chained);
+        return current;
+    }
+    sessionHasPendingWork(session) {
+        return this.sessionChains.has(session.key);
+    }
+    selectedSession(chatId) {
+        return this.getSelectedSession(this.chat(chatId));
+    }
+    resetConversationForChat(chatId) {
+        this.resetChatConversation(this.chat(chatId));
+    }
+    adoptExistingSessionForChat(chatId, session) {
+        const cs = this.chat(chatId);
+        this.adoptSession(cs, session);
+        return this.getSelectedSession(cs);
+    }
+    switchAgentForChat(chatId, agent) {
+        const cs = this.chat(chatId);
+        if (cs.agent === agent)
+            return false;
+        cs.agent = agent;
+        this.resetChatConversation(cs);
+        this.log(`agent switched to ${agent} chat=${chatId}`);
+        return true;
+    }
+    switchModelForChat(chatId, modelId) {
+        const cs = this.chat(chatId);
+        this.setModelForAgent(cs.agent, modelId);
+        this.resetChatConversation(cs);
+        this.log(`model switched to ${modelId} for ${cs.agent} chat=${chatId}`);
+    }
+    switchEffortForChat(chatId, effort) {
+        const cs = this.chat(chatId);
+        this.setEffortForAgent(cs.agent, effort);
+        this.log(`effort switched to ${effort} for ${cs.agent} chat=${chatId}`);
+    }
+    modelForAgent(agent) {
+        return this.agentConfigs[agent]?.model || '';
+    }
+    fetchSessions(agent) {
+        return getSessions({ agent, workdir: this.workdir });
+    }
+    fetchSessionTail(agent, sessionId, limit) {
+        return getSessionTail({ agent, sessionId, workdir: this.workdir, limit });
+    }
+    fetchAgents(options = {}) {
+        return listAgents(options);
+    }
+    fetchSkills() {
+        initializeProjectSkills(this.workdir);
+        return listSkills(this.workdir);
+    }
+    fetchModels(agent) {
+        return listModels(agent, { workdir: this.workdir, currentModel: this.modelForAgent(agent) });
+    }
+    setDefaultAgent(agent) {
+        const next = normalizeAgent(agent);
+        const prev = this.defaultAgent;
+        this.defaultAgent = next;
+        for (const [, cs] of this.chats) {
+            if (cs.activeSessionKey || cs.sessionId)
+                continue;
+            if (cs.agent === prev)
+                cs.agent = next;
+        }
+        this.log(`default agent changed to ${next}`);
+    }
+    setModelForAgent(agent, modelId) {
+        const config = this.agentConfigs[agent];
+        if (config)
+            config.model = modelId;
+        this.log(`model for ${agent} changed to ${modelId}`);
+    }
+    effortForAgent(agent) {
+        if (agent === 'gemini')
+            return null;
+        return this.agentConfigs[agent]?.reasoningEffort || 'high';
+    }
+    setEffortForAgent(agent, effort) {
+        const config = this.agentConfigs[agent];
+        if (config)
+            config.reasoningEffort = effort;
+        this.log(`effort for ${agent} changed to ${effort}`);
+    }
+    getStatusData(chatId) {
+        const cs = this.chat(chatId);
+        const selectedSession = this.getSelectedSession(cs);
+        const selectedTask = this.runningTaskForSession(selectedSession?.key ?? null);
+        const fallbackTask = selectedTask || [...this.activeTasks.values()]
+            .sort((a, b) => a.startedAt - b.startedAt)[0] || null;
+        const model = selectedSession?.modelId || this.modelForAgent(cs.agent);
+        const mem = process.memoryUsage();
+        return {
+            version: VERSION, uptime: Date.now() - this.startedAt,
+            memRss: mem.rss, memHeap: mem.heapUsed, pid: process.pid,
+            workdir: this.workdir, agent: cs.agent, model, sessionId: cs.sessionId,
+            workspacePath: cs.workspacePath ?? null,
+            running: fallbackTask, activeTasksCount: this.activeTasks.size, stats: this.stats,
+            usage: getUsage({ agent: cs.agent, model }),
+        };
+    }
+    getHostData() {
+        const cpus = os.cpus();
+        const totalMem = os.totalmem(), freeMem = os.freemem();
+        const memory = getHostMemoryUsageData(totalMem, freeMem);
+        const cpuUsage = getHostCpuUsageData();
+        let disk = null;
+        const battery = getHostBatteryData();
+        try {
+            const df = execSync(`df -h "${this.workdir}" | tail -1`, { encoding: 'utf-8', timeout: 3000 }).trim().split(/\s+/);
+            if (df.length >= 5)
+                disk = { used: df[2], total: df[1], percent: df[4] };
+        }
+        catch { }
+        let topProcs = [];
+        try {
+            topProcs = execSync(`ps -eo pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null | head -6 || ps -eo pid,%cpu,%mem,comm -r 2>/dev/null | head -6`, { encoding: 'utf-8', timeout: 3000 }).trim().split('\n');
+        }
+        catch { }
+        const mem = process.memoryUsage();
+        return {
+            hostName: getHostDisplayName(),
+            cpuModel: cpus[0]?.model || 'unknown', cpuCount: cpus.length,
+            cpuUsage,
+            totalMem, freeMem, memoryUsed: memory.usedBytes, memoryAvailable: memory.availableBytes, memoryPercent: memory.percent, memorySource: memory.source,
+            disk, battery, topProcs,
+            selfPid: process.pid, selfRss: mem.rss, selfHeap: mem.heapUsed,
+        };
+    }
+    switchWorkdir(newPath, opts = {}) {
+        const old = this.workdir;
+        const resolvedPath = path.resolve(newPath.replace(/^~/, process.env.HOME || ''));
+        if (opts.persist !== false) {
+            setUserWorkdir(resolvedPath, { notify: false });
+        }
+        else {
+            process.env.PIKICLAW_WORKDIR = resolvedPath;
+        }
+        this.workdir = resolvedPath;
+        for (const [, cs] of this.chats) {
+            this.resetChatConversation(cs);
+        }
+        for (const [key, session] of this.sessionStates) {
+            if (session.workdir === old && !session.runningTaskIds.size)
+                this.sessionStates.delete(key);
+        }
+        ensureGitignore(resolvedPath);
+        initializeProjectSkills(resolvedPath);
+        this.log(`switch workdir: ${old} -> ${resolvedPath}`);
+        this.afterSwitchWorkdir(old, resolvedPath);
+        return old;
+    }
+    afterSwitchWorkdir(_oldPath, _newPath) { }
+    onManagedConfigChange(_config, _opts = {}) { }
+    refreshManagedConfig(config, opts = {}) {
+        const nextWorkdir = resolveUserWorkdir({ config });
+        if (opts.initial) {
+            this.workdir = nextWorkdir;
+            ensureGitignore(this.workdir);
+            initializeProjectSkills(this.workdir);
+        }
+        else if (nextWorkdir !== this.workdir) {
+            this.switchWorkdir(nextWorkdir, { persist: false });
+        }
+        const nextDefaultAgent = normalizeAgent(String(config.defaultAgent || 'codex').trim().toLowerCase() || 'codex');
+        if (opts.initial)
+            this.defaultAgent = nextDefaultAgent;
+        else if (nextDefaultAgent !== this.defaultAgent)
+            this.setDefaultAgent(nextDefaultAgent);
+        for (const agent of ['claude', 'codex', 'gemini']) {
+            const nextModel = configModelValue(config, agent);
+            if (nextModel && this.modelForAgent(agent) !== nextModel) {
+                if (opts.initial)
+                    this.agentConfigs[agent].model = nextModel;
+                else
+                    this.setModelForAgent(agent, nextModel);
+            }
+            const nextEffort = configReasoningEffortValue(config, agent);
+            if (nextEffort && agent !== 'gemini' && this.effortForAgent(agent) !== nextEffort) {
+                if (opts.initial)
+                    this.agentConfigs[agent].reasoningEffort = nextEffort;
+                else
+                    this.setEffortForAgent(agent, nextEffort);
+            }
+        }
+        if (!opts.initial)
+            this.onManagedConfigChange(config, opts);
+    }
+    async runStream(prompt, cs, attachments, onText, systemPrompt, mcpSendFile) {
+        const resolvedModel = cs.modelId || this.modelForAgent(cs.agent);
+        const agentConfig = this.agentConfigs[cs.agent] || {};
+        const extraArgs = agentConfig.extraArgs || [];
+        this.log(`[runStream] agent=${cs.agent} session=${cs.sessionId || '(new)'} workdir=${this.workdir} timeout=${this.runTimeout}s attachments=${attachments.length}`);
+        this.log(`[runStream] ${cs.agent} config: model=${resolvedModel} extraArgs=[${extraArgs.join(' ')}]`);
+        const opts = {
+            agent: cs.agent, prompt, workdir: this.workdir, timeout: this.runTimeout,
+            sessionId: cs.sessionId, model: null,
+            thinkingEffort: agentConfig.reasoningEffort || 'high', onText,
+            attachments: attachments.length ? attachments : undefined,
+            // codex-specific
+            codexModel: cs.agent === 'codex' ? resolvedModel : this.codexModel,
+            codexFullAccess: this.codexFullAccess,
+            codexDeveloperInstructions: systemPrompt || undefined,
+            codexExtraArgs: this.codexExtraArgs.length ? this.codexExtraArgs : undefined,
+            codexPrevCumulative: cs.codexCumulative,
+            // claude-specific
+            claudeModel: cs.agent === 'claude' ? resolvedModel : this.claudeModel,
+            claudePermissionMode: this.claudePermissionMode,
+            claudeAppendSystemPrompt: systemPrompt || undefined,
+            claudeExtraArgs: this.claudeExtraArgs.length ? this.claudeExtraArgs : undefined,
+            // gemini-specific
+            geminiModel: cs.agent === 'gemini' ? resolvedModel : (this.agentConfigs.gemini?.model || ''),
+            geminiExtraArgs: this.agentConfigs.gemini?.extraArgs?.length ? this.agentConfigs.gemini.extraArgs : undefined,
+            // MCP bridge
+            mcpSendFile,
+        };
+        const result = await doStream(opts);
+        this.stats.totalTurns++;
+        if (result.inputTokens)
+            this.stats.totalInputTokens += result.inputTokens;
+        if (result.outputTokens)
+            this.stats.totalOutputTokens += result.outputTokens;
+        if (result.cachedInputTokens)
+            this.stats.totalCachedTokens += result.cachedInputTokens;
+        if (result.codexCumulative)
+            cs.codexCumulative = result.codexCumulative;
+        if (result.sessionId)
+            cs.sessionId = result.sessionId;
+        if (result.workspacePath)
+            cs.workspacePath = result.workspacePath;
+        if (result.model)
+            cs.modelId = result.model;
+        if ('key' in cs && typeof cs.key === 'string') {
+            // If session was promoted from pending, update the runtime key
+            const runtime = this.getSessionRuntimeByKey(cs.key, { allowAnyWorkdir: true });
+            if (runtime && result.sessionId && runtime.sessionId !== result.sessionId) {
+                this.sessionStates.delete(runtime.key);
+                runtime.sessionId = result.sessionId;
+                runtime.key = this.sessionKey(runtime.agent, result.sessionId);
+                this.sessionStates.set(runtime.key, runtime);
+                // Update all chats pointing to the old key
+                for (const [, chatState] of this.chats) {
+                    if (chatState.activeSessionKey === cs.key)
+                        chatState.activeSessionKey = runtime.key;
+                }
+            }
+            if (runtime)
+                this.syncSelectedChats(runtime);
+        }
+        this.log(`[runStream] completed turn=${this.stats.totalTurns} cumulative: in=${fmtTokens(this.stats.totalInputTokens)} out=${fmtTokens(this.stats.totalOutputTokens)} cached=${fmtTokens(this.stats.totalCachedTokens)}`);
+        return result;
+    }
+    startKeepAlive() {
+        if (process.platform === 'darwin') {
+            if (this.keepAliveProc || this.keepAlivePulseTimer)
+                return;
+            const bin = whichSync('caffeinate');
+            if (bin) {
+                this.keepAliveProc = spawn('caffeinate', ['-dis'], { stdio: 'ignore', detached: true });
+                this.keepAliveProc.unref();
+                this.log(`keep-alive: caffeinate (PID ${this.keepAliveProc.pid})`);
+                const pulseUserActivity = () => {
+                    const pulse = spawn('caffeinate', ['-u', '-t', String(MACOS_USER_ACTIVITY_PULSE_TIMEOUT_S)], {
+                        stdio: 'ignore',
+                        detached: true,
+                    });
+                    pulse.unref();
+                };
+                pulseUserActivity();
+                this.keepAlivePulseTimer = setInterval(pulseUserActivity, MACOS_USER_ACTIVITY_PULSE_INTERVAL_MS);
+                this.keepAlivePulseTimer.unref?.();
+                this.log(`keep-alive: macOS user activity pulse every ${MACOS_USER_ACTIVITY_PULSE_INTERVAL_MS / 1000}s`);
+            }
+        }
+        else if (process.platform === 'linux') {
+            if (this.keepAliveProc)
+                return;
+            const bin = whichSync('systemd-inhibit');
+            if (bin) {
+                this.keepAliveProc = spawn('systemd-inhibit', [
+                    '--what=idle', '--who=pikiclaw', '--why=AI coding agent running', 'sleep', 'infinity',
+                ], { stdio: 'ignore', detached: true });
+                this.keepAliveProc.unref();
+                this.log(`keep-alive: systemd-inhibit (PID ${this.keepAliveProc.pid})`);
+            }
+        }
+    }
+    stopKeepAlive() {
+        if (this.keepAlivePulseTimer) {
+            clearInterval(this.keepAlivePulseTimer);
+            this.keepAlivePulseTimer = null;
+        }
+        if (this.keepAliveProc) {
+            terminateProcessTree(this.keepAliveProc, { signal: 'SIGTERM', forceSignal: 'SIGKILL', forceAfterMs: 2000 });
+            this.keepAliveProc = null;
+        }
+    }
+}