pikiclaw 0.2.36 → 0.2.37

package/README.md

@@ -40,6 +40,19 @@ pikiclaw 的思路不同：**只挑最好的，然后把它们组合到极致。
        └──────── 流式进度 / 文件 / 截图 ←──────────┘
 ```
 
+pikiclaw 不是另一个终端包装器，也不是另一个云端 IDE。
+
+它更像一个让官方 coding agent 变得**可远程调度、可持续运行、可回传结果**的本地执行中枢。
+
+当你需要：
+
+- 在手机上发一句话就能派活
+- 任务必须跑在你自己的电脑、现有代码库和本地工具链里
+- 想在 Claude Code / Codex CLI / Gemini CLI 之间自由切换
+- 希望进度、截图、文件自动回到聊天
+
+pikiclaw 会比“守在终端里”“SSH + tmux”或“单厂商云端 agent”更顺。
+
 ---
 
 ## Quick Start
@@ -48,7 +61,7 @@ pikiclaw 的思路不同：**只挑最好的，然后把它们组合到极致。
 
 - Node.js 18+
 - 本机已安装 [`claude`](https://docs.anthropic.com/en/docs/claude-code)、[`codex`](https://github.com/openai/codex) 或 [`gemini`](https://github.com/google-gemini/gemini-cli) 中的任意一个
-- 一个 [Telegram Bot Token](https://t.me/BotFather) 或[飞书应用](https://open.feishu.cn)凭证
+- 一个 [Telegram Bot Token](https://t.me/BotFather) 或 [飞书应用](https://open.feishu.cn) 凭证
 
 ### 一行启动
 
@@ -87,10 +100,10 @@ npx pikiclaw@latest --setup
 
 ### IM Channels
 
-| 渠道 | 消息编辑 | 文件上传 | 回调按钮 | 表情回应 | 消息线程 |
-|------|---------|---------|---------|---------|---------|
-| **Telegram** | ✅ | ✅ | ✅ | — | — |
-| **飞书** | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 渠道 | 消息编辑 | 文件收发 | 回调按钮 | 命令菜单 | 场景 |
+|------|---------|---------|---------|---------|------|
+| **Telegram** | ✅ | ✅ | ✅ | ✅ | 全球 / 个人 |
+| **飞书** | ✅ | ✅ | ✅ | ✅ | 国内 / 团队 |
 
 两个渠道可以**同时启动**。
 
@@ -99,16 +112,15 @@ npx pikiclaw@latest --setup
 | 能力 | 说明 |
 |------|------|
 | 实时流式输出 | Agent 工作时消息持续更新 |
-| Thinking / Reasoning | 实时查看 Agent 的思考和推理过程 |
+| Thinking / Reasoning / Plan | 实时查看 Agent 的思考、推理和计划步骤 |
 | Token 追踪 | 输入/输出/缓存统计，上下文使用率实时显示 |
-| 产物回传 | 截图、日志、生成文件自动发回 |
-| 长程防休眠 | 系统级防休眠，小时级任务不中断 |
-| 守护进程 | 崩溃自动重启，指数退避（3s → 60s） |
+| 产物回传 | 截图、日志、生成文件自动发回聊天 |
+| 长程任务保障 | 系统级防休眠 + 守护进程 + 异常自愈 |
 | 长文本处理 | 超长输出自动拆分或打包为 `.md` |
 | 多会话管理 | 随时切换、恢复历史会话 |
 | 图片/文件输入 | 截图、PDF、文档直接发给 Agent |
 | 项目 Skills | `.pikiclaw/skills/` 自定义技能，兼容 `.claude/commands/` |
-| 安全模式 | 危险操作推送确认卡片，白名单访问控制 |
+| 安全模式 | 白名单访问控制，支持切换更安全的 agent 权限模式 |
 | Web Dashboard | 可视化配置、会话浏览、主机监控 |
 
 ---
@@ -134,24 +146,23 @@ npx pikiclaw@latest --setup
 
 | | 终端直接跑 | SSH + tmux | 云端 Agent | **pikiclaw** |
 |---|---|---|---|---|
-| 执行环境 | ✅ 本地 | ✅ 本地 | ❌ 沙盒 | ✅ 本地 |
+| 执行环境 | ✅ 本地 | ✅ 本地 | ⚠️ 通常是远端或沙盒 | ✅ 本地 |
 | 走开后还能跑 | ❌ 合盖就断 | ⚠️ 要配 tmux | ✅ | ✅ 防休眠 + 守护进程 |
 | 手机可控 | ❌ | ⚠️ 打字痛苦 | ✅ | ✅ IM 原生 |
-| 实时看进度 | ✅ 终端 | ⚠️ 得连上去看 | ❌ 多数是黑盒 | ✅ 流式推到聊天 |
+| 实时看进度 | ✅ 终端 | ⚠️ 得连上去看 | ⚠️ 依平台而定 | ✅ 流式推到聊天 |
 | 结果自动回传 | ❌ | ❌ | ⚠️ 看平台 | ✅ 截图/文件/长文本 |
-| 配置门槛 | 无 | SSH/穿透/tmux | 注册/付费 | `npx` 一行 |
+| 配置门槛 | 无 | SSH/穿透/tmux | 注册并适应平台工作流 | `npx` 一行 |
 
-### pikiclaw vs. 同类项目
+### pikiclaw vs. OpenClaw / 官方入口
 
-| | **pikiclaw** | OpenClaw | cc-connect |
+| 维度 | **pikiclaw** | OpenClaw | 官方入口（Claude / Codex / Gemini） |
 |---|---|---|---|
-| **理念** | **精选最好的工具，组合到极致** | 开源自主 AI 智能体生态 | 多渠道多端连接器 |
-| **Agent** | Claude Code / Codex / Gemini CLI（官方出品） | 内置 Agent（自接模型） | 多种本地 CLI |
-| **IM** | Telegram + 飞书（深度打磨） | Web / 移动端 | Slack / Discord / LINE 等 |
-| **长程任务** | ✅ 防休眠 · 守护进程 · 异常自愈 | ❌ 偏即时任务 | ❌ 偏短对话 |
-| **产物回传** | ✅ 截图 · 文件 · 长文本打包 | ⚠️ 依赖客户端 | ⚠️ 基础附件 |
-| **流式体验** | ✅ IM 内实时流式 | ✅ | ⚠️ 看桥接能力 |
-| **上手成本** | **一行 `npx`** | 需部署后端 | 需安装服务端 |
+| 产品层 | IM 驱动的本地 agent 控制平面 | 通用个人 AI 助手 / 多渠道生态 | 单一厂商的原生 agent 入口 |
+| Agent 策略 | 复用官方 CLI，吃到各家最新能力 | 自带 runtime / agent stack | 只服务自家模型 |
+| 执行环境 | 你的电脑 | 个人设备网络 / 本地节点 | 本地 CLI 或厂商云 |
+| 渠道策略 | Telegram + 飞书深度打磨 | 广覆盖 | Web / App / Slack / CLI 为主 |
+| 锁定程度 | 低，可随时切换引擎 | 中 | 高 |
+| 最强场景 | 远程 coding、长任务、本地自动化 | 全能个人助手 | 原生模型体验、企业集成 |
 
 ---
 
@@ -159,6 +170,8 @@ npx pikiclaw@latest --setup
 
 pikiclaw 不限于编程。你的 Agent 能做什么，pikiclaw 就能远程调度什么。
 
+它尤其适合那些**必须在你自己的环境里执行**、同时又希望**进度和结果直接回到 IM** 的任务。
+
 **工程重构** — "把整个项目从 JS 迁移到 TS，跑测试直到全部通过。搞定告诉我。"
 
 **文档处理** — "把 docs/ 下所有零散文档整理汇总，提取核心指标，输出一份报告。"
@@ -298,7 +311,7 @@ npx pikiclaw@latest --doctor              # 检查环境
 ## Development
 
 ```bash
-git clone https://github.com/nicepkg/pikiclaw.git
+git clone https://github.com/xiaotonng/pikiclaw.git
 cd pikiclaw
 npm install
 echo "TELEGRAM_BOT_TOKEN=your_token" > .env

package/dist/bot.js

@@ -11,26 +11,28 @@ import { getActiveUserConfig, onUserConfigChange, resolveUserWorkdir, setUserWor
 import { doStream, getSessions, getSessionTail, getUsage, initializeProjectSkills, listAgents, listModels, listSkills, isPendingSessionId, } from './code-agent.js';
 import { getDriver, hasDriver, allDriverIds } from './agent-driver.js';
 import { terminateProcessTree } from './process-control.js';
-export const VERSION = '0.2.36';
+export const VERSION = '0.2.37';
 const MACOS_USER_ACTIVITY_PULSE_INTERVAL_MS = 20_000;
 const MACOS_USER_ACTIVITY_PULSE_TIMEOUT_S = 30;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * If `dir` has a .gitignore, ensure `.pikiclaw/` is ignored so it doesn't
- * pollute the project. Never modify .claude or .agents gitignore entries.
+ * If `dir` has a .gitignore, ignore managed `.pikiclaw` state without hiding
+ * `.pikiclaw/skills`, which may be committed as project skills.
  */
-function ensureGitignore(dir) {
+export function ensureGitignore(dir) {
     try {
         const gi = path.join(dir, '.gitignore');
         if (!fs.existsSync(gi))
             return;
-        const managedLines = ['.pikiclaw/'];
-        const legacyLines = new Set([
+        const managedLines = [
             '.pikiclaw/*',
             '!.pikiclaw/skills/',
             '!.pikiclaw/skills/**',
+        ];
+        const legacyLines = new Set([
+            '.pikiclaw/',
             '.claude/skills/',
             '.agents/skills/',
         ]);

package/dist/code-agent.js

@@ -947,24 +947,55 @@ function ensureDirSymlink(linkPath, targetDir) {
     fs.mkdirSync(path.dirname(linkPath), { recursive: true });
     fs.symlinkSync(desiredTarget, linkPath, 'dir');
 }
+function resetDir(dirPath) {
+    try {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+    catch { }
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+function copyMergedTree(sourceRoot, targetRoot, opts = {}) {
+    for (const relPath of listRelativeFiles(sourceRoot)) {
+        const sourcePath = path.join(sourceRoot, relPath);
+        const targetPath = path.join(targetRoot, relPath);
+        if (hasFile(targetPath)) {
+            opts.log?.(`skills merge skipped existing file: ${relPath}`);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+}
 export function initializeProjectSkills(workdir, opts = {}) {
     const canonicalRoot = path.join(workdir, '.pikiclaw', 'skills');
     const claudeRoot = path.join(workdir, '.claude', 'skills');
-    // Only create .pikiclaw/skills → .claude/skills symlink.
-    // Never modify files under .claude or .agents.
-    if (hasDir(claudeRoot)) {
-        ensureDirSymlink(canonicalRoot, claudeRoot);
-        opts.log?.(`skills linked: .pikiclaw/skills → .claude/skills workdir=${workdir}`);
+    const agentsRoot = path.join(workdir, '.agents', 'skills');
+    const mergeRoot = path.join(workdir, '.pikiclaw', '.skills-merge-tmp');
+    const sourceRoots = [canonicalRoot, claudeRoot, agentsRoot];
+    const seenSourceReals = new Set();
+    resetDir(mergeRoot);
+    // Merge order defines precedence: existing canonical content wins first,
+    // then legacy Claude skills, then legacy agents skills.
+    for (const sourceRoot of sourceRoots) {
+        if (!hasDir(sourceRoot))
+            continue;
+        const realSource = realPathOrNull(sourceRoot);
+        if (realSource && seenSourceReals.has(realSource))
+            continue;
+        if (realSource)
+            seenSourceReals.add(realSource);
+        copyMergedTree(sourceRoot, mergeRoot, opts);
     }
-    else {
-        // Remove stale symlink before creating real directory
-        try {
-            if (fs.lstatSync(canonicalRoot).isSymbolicLink())
-                fs.unlinkSync(canonicalRoot);
-        }
-        catch { }
-        fs.mkdirSync(canonicalRoot, { recursive: true });
+    resetDir(canonicalRoot);
+    copyMergedTree(mergeRoot, canonicalRoot, opts);
+    try {
+        fs.rmSync(mergeRoot, { recursive: true, force: true });
+    }
+    catch { }
+    for (const linkRoot of [claudeRoot, agentsRoot]) {
+        ensureDirSymlink(linkRoot, canonicalRoot);
     }
+    opts.log?.(`skills merged into .pikiclaw/skills and linked to .claude/.agents workdir=${workdir}`);
 }
 export function getProjectSkillPaths(workdir, skillName) {
     const sharedSkillFile = path.join(workdir, '.pikiclaw', 'skills', skillName, 'SKILL.md');

package/dist/mcp-session-server.js

@@ -18,7 +18,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { workspaceTools } from './tools/workspace.js';
-import { captureTools } from './tools/capture.js';
 import { guiTools } from './tools/gui.js';
 // ---------------------------------------------------------------------------
 // Logging — writes to stderr + file so it doesn't interfere with stdio MCP transport
@@ -65,7 +64,7 @@ log(`started workspace=${ctx.workspace} stagedFiles=${ctx.stagedFiles.length} ca
 // ---------------------------------------------------------------------------
 // Tool registry — collect all tool modules
 // ---------------------------------------------------------------------------
-const TOOL_MODULES = [workspaceTools, captureTools, guiTools];
+const TOOL_MODULES = [workspaceTools, guiTools];
 const ALL_TOOLS = TOOL_MODULES.flatMap(m => m.tools);
 /** Lookup: tool name → module that handles it. */
 const TOOL_HANDLERS = new Map();

package/dist/run.js

@@ -7,7 +7,7 @@
  *   npm run command -- claude-models
  *   npm run command -- codex-models
  */
-import { formatThinkingForDisplay } from './bot.js';
+import { ensureGitignore, formatThinkingForDisplay } from './bot.js';
 import { initializeProjectSkills, listAgents, listModels, listSkills, getUsage, doStream, getSessions, getSessionTail } from './code-agent.js';
 import { loadUserConfig, resolveUserWorkdir } from './user-config.js';
 function parseArgs(argv) {
@@ -98,6 +98,7 @@ async function main() {
     const args = parseArgs(process.argv.slice(2));
     const userConfig = loadUserConfig();
     const workdir = resolveUserWorkdir({ workdir: args.workdir, config: userConfig });
+    ensureGitignore(workdir);
     initializeProjectSkills(workdir);
     if (args.help || !args.command) {
         process.stdout.write(HELP);

package/dist/tools/workspace.js

@@ -90,7 +90,6 @@ function handleListFiles(args, ctx) {
 async function handleSendFile(args, ctx) {
     const filePath = typeof args?.path === 'string' ? args.path.trim() : '';
     const kind = typeof args?.kind === 'string' ? args.kind : undefined;
-    toolLog('im_send_file', `path=${filePath} kind=${kind || 'auto'}`);
     if (!filePath) {
         toolLog('im_send_file', 'ERROR missing path');
         return toolResult('Error: "path" is required', true);
@@ -99,6 +98,8 @@ async function handleSendFile(args, ctx) {
         toolLog('im_send_file', 'ERROR no callback URL');
         return toolResult('Error: MCP callback URL is not configured', true);
     }
+    const callbackTarget = describeSendFileTarget(ctx.callbackUrl);
+    toolLog('im_send_file', `path=${filePath} kind=${kind || 'auto'} callback=${callbackTarget}`);
     try {
         const result = await callbackSendFile(ctx.callbackUrl, filePath, {
             caption: typeof args?.caption === 'string' ? args.caption : undefined,
@@ -109,13 +110,15 @@ async function handleSendFile(args, ctx) {
             return toolResult(`File sent successfully: ${filePath}`);
         }
         else {
-            toolLog('im_send_file', `FAILED ${result.error || 'unknown error'}`);
-            return toolResult(`Failed to send file: ${result.error || 'unknown error'}`, true);
+            const detail = formatSendFileFailure(result);
+            toolLog('im_send_file', `FAILED ${detail}`);
+            return toolResult(`Failed to send file: ${detail}`, true);
         }
     }
     catch (e) {
-        toolLog('im_send_file', `ERROR ${e.message}`);
-        return toolResult(`Error sending file: ${e.message}`, true);
+        const message = e instanceof Error ? e.message : String(e);
+        toolLog('im_send_file', `ERROR callback=${callbackTarget} ${message}`);
+        return toolResult(`Error sending file: ${message}`, true);
     }
 }
 // ---------------------------------------------------------------------------
@@ -132,14 +135,45 @@ function callbackSendFile(callbackUrl, filePath, opts) {
             let data = '';
             res.on('data', (chunk) => { data += chunk; });
             res.on('end', () => {
+                const statusCode = res.statusCode;
+                const statusMessage = res.statusMessage || undefined;
+                const bodyPreview = data ? previewText(data) : undefined;
+                let parsed = null;
                 try {
-                    resolve(JSON.parse(data));
+                    parsed = data ? JSON.parse(data) : null;
                 }
-                catch {
-                    resolve({ ok: false, error: 'invalid callback response' });
+                catch { }
+                if (statusCode && statusCode >= 400) {
+                    const parsedError = typeof parsed?.error === 'string' ? parsed.error : null;
+                    resolve({
+                        ok: false,
+                        error: parsedError || describeHttpFailure(statusCode, statusMessage, bodyPreview),
+                        statusCode,
+                        statusMessage,
+                        bodyPreview,
+                    });
+                    return;
+                }
+                if (parsed && typeof parsed.ok === 'boolean') {
+                    resolve({
+                        ok: parsed.ok,
+                        error: typeof parsed.error === 'string' ? parsed.error : undefined,
+                        statusCode,
+                        statusMessage,
+                        bodyPreview,
+                    });
+                    return;
                 }
+                resolve({
+                    ok: false,
+                    error: describeHttpFailure(statusCode, statusMessage, bodyPreview, 'invalid callback response'),
+                    statusCode,
+                    statusMessage,
+                    bodyPreview,
+                });
             });
         });
+        req.setTimeout(30_000, () => req.destroy(new Error('send-file callback timed out after 30s')));
         req.on('error', e => reject(e));
         req.write(body);
         req.end();
@@ -156,6 +190,32 @@ function safeRealpath(p) {
         return null;
     }
 }
+function previewText(text, max = 400) {
+    const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return '';
+    return normalized.length <= max ? normalized : `${normalized.slice(0, Math.max(0, max - 3)).trimEnd()}...`;
+}
+function describeSendFileTarget(callbackUrl) {
+    try {
+        const url = new URL('/send-file', callbackUrl);
+        return `${url.origin}${url.pathname}`;
+    }
+    catch {
+        return callbackUrl;
+    }
+}
+function describeHttpFailure(statusCode, statusMessage, bodyPreview, fallback = 'callback request failed') {
+    const status = statusCode ? `HTTP ${statusCode}${statusMessage ? ` ${statusMessage}` : ''}` : fallback;
+    return bodyPreview ? `${status}; body=${bodyPreview}` : status;
+}
+function formatSendFileFailure(result) {
+    const base = result.error?.trim() || describeHttpFailure(result.statusCode, result.statusMessage, result.bodyPreview, 'unknown error');
+    if (result.bodyPreview && !base.includes(result.bodyPreview)) {
+        return `${base}; body=${result.bodyPreview}`;
+    }
+    return base;
+}
 // ---------------------------------------------------------------------------
 // Module export
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "description": "The best IM-driven remote coding experience. Bridge AI coding agents to any IM.",
   "type": "module",
   "bin": {

package/dist/tools/capture.js

@@ -1,260 +0,0 @@
-/**
- * tools/capture.ts — Screen capture tool.
- *
- *   take_screenshot — captures a screenshot (full screen, region, or window), cross-platform
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { execFile } from 'node:child_process';
-import { toolResult, toolLog } from './types.js';
-// ---------------------------------------------------------------------------
-// Tool definitions
-// ---------------------------------------------------------------------------
-const tools = [
-    {
-        name: 'take_screenshot',
-        description: 'Take a screenshot and return the saved PNG path.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                display_number: {
-                    type: 'number',
-                    description: 'Optional display number.',
-                },
-                window_title: {
-                    type: 'string',
-                    description: 'Optional window title.',
-                },
-                region: {
-                    type: 'object',
-                    description: 'Optional capture region.',
-                    properties: {
-                        x: { type: 'number', description: 'Left.' },
-                        y: { type: 'number', description: 'Top.' },
-                        width: { type: 'number', description: 'Width.' },
-                        height: { type: 'number', description: 'Height.' },
-                    },
-                    required: ['x', 'y', 'width', 'height'],
-                },
-            },
-        },
-    },
-];
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-async function handleTakeScreenshot(args) {
-    const displayNumber = typeof args?.display_number === 'number' ? args.display_number : undefined;
-    const windowTitle = typeof args?.window_title === 'string' ? args.window_title.trim() : undefined;
-    const regionRaw = args?.region;
-    let region;
-    toolLog('take_screenshot', `display=${displayNumber ?? 'default'} window=${windowTitle || 'none'} region=${regionRaw ? 'yes' : 'none'}`);
-    if (regionRaw && typeof regionRaw === 'object') {
-        const x = Number(regionRaw.x);
-        const y = Number(regionRaw.y);
-        const w = Number(regionRaw.width);
-        const h = Number(regionRaw.height);
-        if ([x, y, w, h].some(v => !Number.isFinite(v) || v < 0) || w === 0 || h === 0) {
-            toolLog('take_screenshot', 'ERROR invalid region params');
-            return toolResult('Error: region requires finite non-negative x, y, width, height (width/height > 0)', true);
-        }
-        region = { x, y, width: w, height: h };
-    }
-    try {
-        const filePath = await captureScreenshot({ displayNumber, region, windowTitle });
-        const size = fs.statSync(filePath).size;
-        toolLog('take_screenshot', `OK saved ${filePath} (${Math.round(size / 1024)} KB)`);
-        return toolResult(`Screenshot saved: ${filePath} (${Math.round(size / 1024)} KB)`);
-    }
-    catch (e) {
-        toolLog('take_screenshot', `ERROR ${e.message}`);
-        return toolResult(`Screenshot failed: ${e.message}`, true);
-    }
-}
-// ---------------------------------------------------------------------------
-// Shell exec helper
-// ---------------------------------------------------------------------------
-function execAsync(cmd, args) {
-    return new Promise((resolve, reject) => {
-        execFile(cmd, args, { timeout: 15_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-            if (err)
-                reject(err);
-            else
-                resolve({ stdout, stderr });
-        });
-    });
-}
-// ---------------------------------------------------------------------------
-// Window ID lookup — cross-platform
-// ---------------------------------------------------------------------------
-/** macOS: use JXA to find CGWindowID by title substring. */
-async function findWindowIdDarwin(title) {
-    const jxa = `
-    ObjC.import('CoreGraphics');
-    const list = $.CGWindowListCopyWindowInfo($.kCGWindowListOptionOnScreenOnly, 0);
-    const count = ObjC.unwrap(list).length;
-    const needle = ${JSON.stringify(title.toLowerCase())};
-    for (let i = 0; i < count; i++) {
-      const entry = ObjC.unwrap(list)[i];
-      const name = ObjC.unwrap(entry.kCGWindowName || '') || '';
-      const owner = ObjC.unwrap(entry.kCGWindowOwnerName || '') || '';
-      if (name.toLowerCase().includes(needle) || owner.toLowerCase().includes(needle)) {
-        const wid = ObjC.unwrap(entry.kCGWindowNumber);
-        if (wid) { console.log(wid); $.exit(0); }
-      }
-    }
-    console.log(''); $.exit(1);
-  `.trim();
-    const { stdout } = await execAsync('osascript', ['-l', 'JavaScript', '-e', jxa]);
-    const wid = stdout.trim();
-    if (!wid)
-        throw new Error(`No window found matching "${title}" on macOS`);
-    return wid;
-}
-/** Linux: use xdotool to find window ID by title substring. */
-async function findWindowIdLinux(title) {
-    const { stdout } = await execAsync('xdotool', ['search', '--name', title]);
-    const wid = stdout.trim().split('\n')[0];
-    if (!wid)
-        throw new Error(`No window found matching "${title}" on Linux (via xdotool)`);
-    return wid;
-}
-/** Windows: find window handle by title substring, return bounding rect. */
-async function findWindowRectWindows(title) {
-    const psScript = [
-        'Add-Type @"',
-        'using System; using System.Runtime.InteropServices;',
-        'public class Win32 {',
-        '  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);',
-        '  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left, Top, Right, Bottom; }',
-        '}',
-        '"@',
-        `$procs = Get-Process | Where-Object { $_.MainWindowTitle -like '*${title.replace(/'/g, "''")}*' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1`,
-        'if (-not $procs) { Write-Error "No window found"; exit 1 }',
-        '$rect = New-Object Win32+RECT',
-        '[Win32]::GetWindowRect($procs.MainWindowHandle, [ref]$rect) | Out-Null',
-        '$obj = @{ x=$rect.Left; y=$rect.Top; width=$rect.Right-$rect.Left; height=$rect.Bottom-$rect.Top }',
-        '$obj | ConvertTo-Json -Compress',
-    ].join('\n');
-    const { stdout } = await execAsync('powershell', ['-NoProfile', '-Command', psScript]);
-    const rect = JSON.parse(stdout.trim());
-    if (!rect || rect.width <= 0 || rect.height <= 0)
-        throw new Error(`No window found matching "${title}" on Windows`);
-    return rect;
-}
-// ---------------------------------------------------------------------------
-// Screenshot capture — cross-platform
-// ---------------------------------------------------------------------------
-async function captureScreenshot(opts) {
-    const { displayNumber, region, windowTitle } = opts;
-    const outFile = path.join(os.tmpdir(), `pikiclaw_screenshot_${process.pid}_${Date.now()}.png`);
-    const platform = process.platform;
-    if (platform === 'darwin') {
-        const args = ['-x'];
-        if (windowTitle) {
-            const wid = await findWindowIdDarwin(windowTitle);
-            args.push('-l', wid);
-        }
-        else {
-            if (displayNumber != null)
-                args.push('-D', String(displayNumber));
-            if (region)
-                args.push('-R', `${region.x},${region.y},${region.width},${region.height}`);
-        }
-        args.push(outFile);
-        await execAsync('screencapture', args);
-    }
-    else if (platform === 'win32') {
-        let bounds;
-        if (windowTitle) {
-            const rect = await findWindowRectWindows(windowTitle);
-            bounds = `$bounds = New-Object System.Drawing.Rectangle(${rect.x},${rect.y},${rect.width},${rect.height})`;
-        }
-        else if (region) {
-            bounds = `$bounds = New-Object System.Drawing.Rectangle(${region.x},${region.y},${region.width},${region.height})`;
-        }
-        else if (displayNumber != null) {
-            bounds = `$screen = [System.Windows.Forms.Screen]::AllScreens[${displayNumber}]; $bounds = $screen.Bounds`;
-        }
-        else {
-            bounds = `$screen = [System.Windows.Forms.Screen]::PrimaryScreen; $bounds = $screen.Bounds`;
-        }
-        const psScript = [
-            'Add-Type -AssemblyName System.Windows.Forms',
-            'Add-Type -AssemblyName System.Drawing',
-            bounds,
-            '$bmp = New-Object System.Drawing.Bitmap($bounds.Width, $bounds.Height)',
-            '$g = [System.Drawing.Graphics]::FromImage($bmp)',
-            '$g.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)',
-            '$g.Dispose()',
-            `$bmp.Save('${outFile.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)`,
-            '$bmp.Dispose()',
-        ].join('; ');
-        await execAsync('powershell', ['-NoProfile', '-Command', psScript]);
-    }
-    else {
-        let windowId;
-        if (windowTitle)
-            windowId = await findWindowIdLinux(windowTitle);
-        const captured = await captureLinux(outFile, { region, windowId });
-        if (!captured)
-            throw new Error('No screenshot tool found. Install one of: maim, scrot, gnome-screenshot, or import (ImageMagick).');
-    }
-    if (!fs.existsSync(outFile))
-        throw new Error('Screenshot command succeeded but no file was produced.');
-    return outFile;
-}
-async function captureLinux(tmpFile, opts) {
-    const { region, windowId } = opts;
-    // maim — best window/region support
-    try {
-        const args = [];
-        if (windowId)
-            args.push('-i', windowId);
-        else if (region)
-            args.push('-g', `${region.width}x${region.height}+${region.x}+${region.y}`);
-        args.push(tmpFile);
-        await execAsync('maim', args);
-        return true;
-    }
-    catch { }
-    // scrot
-    try {
-        const args = [];
-        if (region)
-            args.push('-a', `${region.x},${region.y},${region.width},${region.height}`);
-        args.push(tmpFile);
-        await execAsync('scrot', args);
-        return true;
-    }
-    catch { }
-    // gnome-screenshot
-    try {
-        await execAsync('gnome-screenshot', ['-f', tmpFile]);
-        return true;
-    }
-    catch { }
-    // import (ImageMagick)
-    try {
-        const win = windowId || 'root';
-        const geometry = region ? `${region.width}x${region.height}+${region.x}+${region.y}` : undefined;
-        const args = geometry ? ['-window', win, '-crop', geometry, tmpFile] : ['-window', win, tmpFile];
-        await execAsync('import', args);
-        return true;
-    }
-    catch { }
-    return false;
-}
-// ---------------------------------------------------------------------------
-// Module export
-// ---------------------------------------------------------------------------
-export const captureTools = {
-    tools,
-    handle(name, args) {
-        switch (name) {
-            case 'take_screenshot': return handleTakeScreenshot(args);
-            default: return toolResult(`Unknown capture tool: ${name}`, true);
-        }
-    },
-};