pikiclaw 0.2.64 → 0.2.66

package/README.md

@@ -98,10 +98,6 @@ npx pikiclaw@latest
 
 <img src="docs/promo-dashboard-config.png" alt="Config" width="700">
 
-**插件中心** — 浏览器操控、桌面自动化
-
-<img src="docs/promo-dashboard-extensions.png" alt="Extensions" width="700">
-
 **会话管理** — 按 Agent 分组的会话泳道
 
 <img src="docs/promo-dashboard-sessions.png" alt="Sessions" width="700">
@@ -162,7 +158,7 @@ npx pikiclaw@latest --doctor
 
 可选 GUI 能力：
 
-- 浏览器自动化：通过 `@playwright/mcp` 补充接入，默认支持 Chrome extension mode，也可切到 headless / isolated 模式
+- 浏览器自动化：通过 `@playwright/mcp` 管理一个专用的持久化 Chrome profile；第一次使用时在这个自动化浏览器里登录需要的网站，后续任务会复用同一个 profile
 - macOS 桌面自动化：通过 Appium Mac2 提供 `desktop_open_app`、`desktop_snapshot`、`desktop_click`、`desktop_type`、`desktop_screenshot` 等工具
 
 ---
@@ -196,17 +192,13 @@ npx pikiclaw@latest --doctor
 ## Config And Setup Notes
 
 - 持久化配置在 `~/.pikiclaw/setting.json`
-- Dashboard 是主配置入口，环境变量仍然可用
-- 浏览器 GUI 相关常用变量：
-  - `PIKICLAW_BROWSER_GUI`
-  - `PIKICLAW_BROWSER_USE_EXTENSION`
-  - `PIKICLAW_BROWSER_HEADLESS`
-  - `PIKICLAW_BROWSER_ISOLATED`
-  - `PLAYWRIGHT_MCP_EXTENSION_TOKEN`
+- Dashboard 是主配置入口，其他运行时配置仍然可用
 - 桌面 GUI 相关常用变量：
   - `PIKICLAW_DESKTOP_GUI`
   - `PIKICLAW_DESKTOP_APPIUM_URL`
 
+浏览器自动化由 dashboard 和本地运行时共同管理，会自动创建并复用专用的 Chrome profile 目录。你只需要在这个专用浏览器里登录需要自动化的网站账号一次。
+
 如果要启用 macOS 桌面自动化，需要先准备 Appium Mac2：
 
 ```bash

package/dist/bot-weixin.js

@@ -0,0 +1,268 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Bot, buildPrompt, fmtUptime, normalizeAgent, parseAllowedChatIds, } from './bot.js';
+import { BOT_SHUTDOWN_FORCE_EXIT_MS, buildSessionTaskId } from './bot-orchestration.js';
+import { shutdownAllDrivers } from './agent-driver.js';
+import { registerProcessRuntime } from './process-control.js';
+import { WeixinChannel } from './channel-weixin.js';
+import { getActiveUserConfig } from './user-config.js';
+const SHUTDOWN_EXIT_CODE = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown error');
+}
+export class WeixinBot extends Bot {
+    botToken;
+    accountId;
+    baseUrl;
+    channel;
+    nextTaskId = 1;
+    shutdownInFlight = false;
+    shutdownExitCode = null;
+    shutdownForceExitTimer = null;
+    signalHandlers = {};
+    processRuntimeCleanup = null;
+    constructor() {
+        super();
+        const config = getActiveUserConfig();
+        if (process.env.WEIXIN_ALLOWED_USER_IDS) {
+            for (const id of parseAllowedChatIds(process.env.WEIXIN_ALLOWED_USER_IDS))
+                this.allowedChatIds.add(id);
+        }
+        this.baseUrl = String(config.weixinBaseUrl || process.env.WEIXIN_BASE_URL || '').trim();
+        this.botToken = String(config.weixinBotToken || process.env.WEIXIN_BOT_TOKEN || '').trim();
+        this.accountId = String(config.weixinAccountId || process.env.WEIXIN_ACCOUNT_ID || '').trim();
+        if (!this.baseUrl || !this.botToken || !this.accountId) {
+            throw new Error('Missing Weixin credentials. Configure via dashboard QR login first.');
+        }
+    }
+    onManagedConfigChange(config, opts = {}) {
+        const nextBaseUrl = String(config.weixinBaseUrl || process.env.WEIXIN_BASE_URL || '').trim();
+        const nextBotToken = String(config.weixinBotToken || process.env.WEIXIN_BOT_TOKEN || '').trim();
+        const nextAccountId = String(config.weixinAccountId || process.env.WEIXIN_ACCOUNT_ID || '').trim();
+        if (nextBaseUrl && nextBaseUrl !== this.baseUrl) {
+            this.baseUrl = nextBaseUrl;
+            if (!opts.initial)
+                this.log('weixin baseUrl reloaded from setting.json');
+        }
+        if (nextBotToken && nextBotToken !== this.botToken) {
+            this.botToken = nextBotToken;
+            if (!opts.initial)
+                this.log('weixin botToken reloaded from setting.json');
+        }
+        if (nextAccountId && nextAccountId !== this.accountId) {
+            this.accountId = nextAccountId;
+            if (!opts.initial)
+                this.log('weixin accountId reloaded from setting.json');
+        }
+    }
+    installSignalHandlers() {
+        this.removeSignalHandlers();
+        const onSigint = () => this.beginShutdown('SIGINT');
+        const onSigterm = () => this.beginShutdown('SIGTERM');
+        this.signalHandlers = { SIGINT: onSigint, SIGTERM: onSigterm };
+        process.once('SIGINT', onSigint);
+        process.once('SIGTERM', onSigterm);
+    }
+    removeSignalHandlers() {
+        for (const signal of Object.keys(this.signalHandlers)) {
+            const handler = this.signalHandlers[signal];
+            if (handler)
+                process.off(signal, handler);
+        }
+        this.signalHandlers = {};
+    }
+    clearShutdownForceExitTimer() {
+        if (!this.shutdownForceExitTimer)
+            return;
+        clearTimeout(this.shutdownForceExitTimer);
+        this.shutdownForceExitTimer = null;
+    }
+    cleanupRuntimeForExit() {
+        try {
+            this.channel.disconnect();
+        }
+        catch { }
+        this.stopKeepAlive();
+        shutdownAllDrivers();
+    }
+    beginShutdown(signal) {
+        if (this.shutdownInFlight)
+            return;
+        this.shutdownInFlight = true;
+        this.shutdownExitCode = SHUTDOWN_EXIT_CODE[signal];
+        this.log(`${signal}, shutting down...`);
+        this.cleanupRuntimeForExit();
+        this.clearShutdownForceExitTimer();
+        this.shutdownForceExitTimer = setTimeout(() => {
+            this.log(`shutdown still pending after ${Math.floor(BOT_SHUTDOWN_FORCE_EXIT_MS / 1000)}s, forcing exit`);
+            process.exit(this.shutdownExitCode ?? 1);
+        }, BOT_SHUTDOWN_FORCE_EXIT_MS);
+        this.shutdownForceExitTimer.unref?.();
+    }
+    resolveSession(chatId, title, files) {
+        return this.ensureSessionForChat(chatId, title, files);
+    }
+    buildStatusText(chatId) {
+        const status = this.getStatusData(chatId);
+        return [
+            `Agent: ${status.agent}`,
+            `Model: ${status.model || '-'}`,
+            `Session: ${status.sessionId || 'new'}`,
+            `Tasks: ${status.activeTasksCount}`,
+            `Workdir: ${status.workdir}`,
+            `Uptime: ${fmtUptime(status.uptime)}`,
+        ].join('\n');
+    }
+    async handleCommand(text, ctx) {
+        const [rawCommand, ...rest] = text.trim().slice(1).split(/\s+/);
+        const command = rawCommand?.toLowerCase() || '';
+        const args = rest.join(' ').trim();
+        switch (command) {
+            case 'help':
+                await ctx.reply([
+                    '/help',
+                    '/new',
+                    '/status',
+                    '/agent codex|claude|gemini',
+                ].join('\n'));
+                return true;
+            case 'new':
+                this.resetConversationForChat(ctx.chatId);
+                await ctx.reply('Started a new session.');
+                return true;
+            case 'status':
+                await ctx.reply(this.buildStatusText(ctx.chatId));
+                return true;
+            case 'agent':
+                if (!args) {
+                    await ctx.reply('Usage: /agent codex|claude|gemini');
+                    return true;
+                }
+                try {
+                    const agent = normalizeAgent(args);
+                    this.switchAgentForChat(ctx.chatId, agent);
+                    await ctx.reply(`Agent switched to ${agent}.`);
+                }
+                catch {
+                    await ctx.reply('Usage: /agent codex|claude|gemini');
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    createMcpSendFile(chatId) {
+        return async (filePath) => {
+            try {
+                await this.channel.send(chatId, `Artifact ready: ${path.basename(filePath)}\n${filePath}`);
+                return { ok: true };
+            }
+            catch (error) {
+                return { ok: false, error: describeError(error) };
+            }
+        };
+    }
+    async sendResult(chatId, result) {
+        const text = result.ok
+            ? (result.message.trim() || 'Task finished.')
+            : ['Task failed.', result.error || result.message || 'Unknown error.'].filter(Boolean).join('\n');
+        await this.channel.send(chatId, text);
+    }
+    async handleMessage(msg, ctx) {
+        const text = msg.text.trim();
+        if (text.startsWith('/') && await this.handleCommand(text, ctx))
+            return;
+        if (!text && !msg.files.length) {
+            await ctx.reply('This Weixin channel currently supports text input only.');
+            return;
+        }
+        const session = this.resolveSession(ctx.chatId, text, msg.files);
+        const prompt = buildPrompt(text, msg.files);
+        const taskId = buildSessionTaskId(session, this.nextTaskId++);
+        this.beginTask({
+            taskId,
+            chatId: ctx.chatId,
+            agent: session.agent,
+            sessionKey: session.key,
+            prompt,
+            startedAt: Date.now(),
+            sourceMessageId: ctx.messageId,
+        });
+        void this.queueSessionTask(session, async () => {
+            const abortController = new AbortController();
+            const task = this.markTaskRunning(taskId, () => abortController.abort());
+            if (task?.cancelled) {
+                this.finishTask(taskId);
+                return;
+            }
+            let typingTimer = null;
+            try {
+                await ctx.sendTyping().catch(() => { });
+                typingTimer = setInterval(() => {
+                    void ctx.sendTyping().catch(() => { });
+                }, 4_000);
+                typingTimer.unref?.();
+                const result = await this.runStream(prompt, session, msg.files, () => { }, undefined, this.createMcpSendFile(ctx.chatId), abortController.signal);
+                await this.sendResult(ctx.chatId, result);
+            }
+            catch (error) {
+                await ctx.reply(`Error: ${describeError(error)}`);
+            }
+            finally {
+                if (typingTimer)
+                    clearInterval(typingTimer);
+                this.finishTask(taskId);
+                this.syncSelectedChats(session);
+            }
+        }).catch(error => {
+            this.finishTask(taskId);
+            this.log(`weixin queue execution failed: ${describeError(error)}`);
+        });
+    }
+    async run() {
+        const tmpDir = path.join(os.tmpdir(), 'pikiclaw');
+        fs.mkdirSync(tmpDir, { recursive: true });
+        this.channel = new WeixinChannel({
+            token: this.botToken,
+            accountId: this.accountId,
+            baseUrl: this.baseUrl,
+            allowedChatIds: this.allowedChatIds.size ? new Set([...this.allowedChatIds].map(value => String(value))) : undefined,
+        });
+        this.processRuntimeCleanup?.();
+        this.processRuntimeCleanup = registerProcessRuntime({
+            label: 'weixin',
+            getActiveTaskCount: () => this.activeTasks.size,
+            prepareForRestart: () => this.cleanupRuntimeForExit(),
+        });
+        this.installSignalHandlers();
+        try {
+            const bot = await this.channel.connect();
+            this.connected = true;
+            this.log(`bot: ${bot.displayName} (id=${bot.id})`);
+            for (const agent of this.fetchAgents().agents) {
+                this.log(`agent ${agent.agent}: ${agent.path || 'NOT FOUND'}`);
+            }
+            this.log(`config: agent=${this.defaultAgent} workdir=${this.workdir} timeout=${this.runTimeout}s`);
+            this.channel.onMessage((msg, ctx) => this.handleMessage(msg, ctx));
+            this.channel.onError(error => this.log(`error: ${describeError(error)}`));
+            this.startKeepAlive();
+            this.log('✓ Weixin connected, long-polling started — ready to receive messages');
+            await this.channel.listen();
+            this.stopKeepAlive();
+            this.log('stopped');
+        }
+        finally {
+            this.stopKeepAlive();
+            this.clearShutdownForceExitTimer();
+            this.removeSignalHandlers();
+            this.processRuntimeCleanup?.();
+            this.processRuntimeCleanup = null;
+            if (this.shutdownInFlight)
+                process.exit(this.shutdownExitCode ?? 1);
+        }
+    }
+}

package/dist/bot.js

@@ -10,6 +10,7 @@ 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, stageSessionFiles, isPendingSessionId, normalizeClaudeModelId, } from './code-agent.js';
 import { getDriver, hasDriver, allDriverIds } from './agent-driver.js';
+import { resolveGuiIntegrationConfig } from './mcp-bridge.js';
 import { terminateProcessTree } from './process-control.js';
 import { VERSION } from './version.js';
 import { buildHumanLoopResponse, createEmptyHumanLoopAnswer, currentHumanLoopQuestion, isHumanLoopAwaitingText, setHumanLoopOption, setHumanLoopText, skipHumanLoopQuestion, } from './human-loop.js';
@@ -221,6 +222,23 @@ function buildMcpDeliveryPrompt() {
         'This is an IM conversation, so pay attention to the IM tools.',
     ].join('\n');
 }
+function buildBrowserAutomationPrompt(browserEnabled) {
+    if (!browserEnabled) {
+        return [
+            '[Browser Automation]',
+            'Managed browser automation is disabled by default for this session.',
+            process.platform === 'darwin'
+                ? 'On macOS, operate your main browser directly with native commands such as open, osascript, and screencapture when needed.'
+                : 'Use native OS or browser commands directly when browser automation is not enabled.',
+        ].join('\n');
+    }
+    return [
+        '[Browser Automation]',
+        'A Playwright MCP browser server is already configured to use the local Chrome channel with a persistent profile.',
+        'Do not call browser_install unless a browser tool explicitly reports that Chrome or the browser is missing.',
+        'If you need a new tab, use browser_tabs with action="new".',
+    ].join('\n');
+}
 function configModelValue(config, agent) {
     switch (agent) {
         case 'claude': return normalizeClaudeModelId(config.claudeModel || process.env.CLAUDE_MODEL || 'claude-opus-4-6');
@@ -986,6 +1004,7 @@ export class Bot {
         const totalMem = os.totalmem(), freeMem = os.freemem();
         const memory = getHostMemoryUsageData(totalMem, freeMem);
         const cpuUsage = getHostCpuUsageData();
+        const [loadOne, loadFive, loadFifteen] = os.loadavg();
         let disk = null;
         const battery = getHostBatteryData();
         try {
@@ -1004,6 +1023,7 @@ export class Bot {
             hostName: getHostDisplayName(),
             cpuModel: cpus[0]?.model || 'unknown', cpuCount: cpus.length,
             cpuUsage,
+            loadAverage: { one: loadOne, five: loadFive, fifteen: loadFifteen },
             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,
@@ -1072,11 +1092,15 @@ export class Bot {
         const resolvedModel = cs.modelId || this.modelForAgent(cs.agent);
         const agentConfig = this.agentConfigs[cs.agent] || {};
         const extraArgs = agentConfig.extraArgs || [];
+        const browserEnabled = resolveGuiIntegrationConfig(getActiveUserConfig()).browserEnabled;
         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 isFirstTurnOfSession = !cs.sessionId || isPendingSessionId(cs.sessionId);
+        const mcpSystemPrompt = mcpSendFile
+            ? appendExtraPrompt(buildMcpDeliveryPrompt(), buildBrowserAutomationPrompt(browserEnabled))
+            : '';
         const effectiveSystemPrompt = isFirstTurnOfSession
-            ? (mcpSendFile ? appendExtraPrompt(systemPrompt, buildMcpDeliveryPrompt()) : systemPrompt)
+            ? appendExtraPrompt(systemPrompt, mcpSystemPrompt)
             : undefined;
         const opts = {
             agent: cs.agent, prompt, workdir: this.workdir, timeout: this.runTimeout,