npm - pikiclaw - Versions diffs - 0.2.41 → 0.2.43 - Mend

pikiclaw 0.2.41 → 0.2.43

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +129 -228
package/dist/bot-commands.js +8 -0
package/dist/bot-feishu-render.js +8 -0
package/dist/bot-feishu.js +2 -2
package/dist/bot-telegram.js +15 -11
package/dist/channel-feishu.js +44 -5
package/dist/cli.js +11 -3
package/dist/code-agent.js +7 -10
package/dist/config-validation.js +20 -3
package/dist/mcp-bridge.js +83 -10
package/dist/tools/workspace.js +44 -72
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -2,21 +2,19 @@
 # pikiclaw
-**One command. Turn any computer into a world-class productivity machine.**
+**Run Claude Code / Codex / Gemini on your own computer from Telegram or Feishu.**
-*一行命令，让你的老电脑变成世界顶级生产力。*
-*最好的 IM（Telegram / 飞书）× 最强的 Agent（Claude Code / Codex / Gemini CLI）× 你自己的电脑。*
+*把 IM 变成你电脑上的远程 Agent 控制台。*
 ```bash
 npx pikiclaw@latest
 ```
-[![npm](https://img.shields.io/npm/v/pikiclaw)](https://www.npmjs.com/package/pikiclaw)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![Node.js 18+](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org)
-<!-- TODO: 替换为实际 demo GIF -->
-<!-- ![demo](docs/assets/demo.gif) -->
+<p align="center">
+<a href="https://www.npmjs.com/package/pikiclaw"><img src="https://img.shields.io/npm/v/pikiclaw" alt="npm"></a>
+<a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a>
+<a href="https://nodejs.org"><img src="https://img.shields.io/badge/Node.js-18+-green.svg" alt="Node.js 18+"></a>
+</p>
 </div>
@@ -24,34 +22,32 @@ npx pikiclaw@latest
 ## Why pikiclaw?
-市面上有很多 IM-to-Agent 桥接方案。它们要么自己造引擎（质量不如官方），要么什么都接（质量参差不齐）。
+很多“IM 接 Agent”的方案，本质上还是在绕路：
-pikiclaw 的思路不同：**只挑最好的，然后把它们组合到极致。**
+- 要么自己造 Agent，效果不如官方 CLI
+- 要么跑在远端沙盒里，不是你的环境
+- 要么只能短对话，不适合长任务
-- **最好的 Agent** — Claude Code、Codex CLI、Gemini CLI，都是各家官方出品，不造轮子
-- **最好的 IM** — Telegram（全球）+ 飞书（国内），不追求数量，每个都打磨到位
-- **最好的执行环境** — 你自己的电脑，不是云端沙盒，什么都能干
+pikiclaw 的目标很直接：
-结果就是：你在手机上发一句话，你的电脑就开始干活——小到改一行代码，大到通宵重构整个项目、整理几十份文档、跑完所有测试。
+- 用官方 Agent CLI，而不是重新发明一套
+- 用你自己的电脑，而不是陌生沙盒
+- 用你已经在用的 IM，而不是再学一套远程控制方式
 ```
-  你（手机 IM）──→ pikiclaw ──→ 本地 Agent ──→ 你的电脑
-       ↑                                          │
-       └──────── 流式进度 / 文件 / 截图 ←──────────┘
+  你（Telegram / 飞书）
+          │
+          ▼
+       pikiclaw
+          │
+          ▼
+  Claude Code / Codex / Gemini
+          │
+          ▼
+       你的电脑
 ```
-pikiclaw 不是另一个终端包装器，也不是另一个云端 IDE。
-它更像一个让官方 coding agent 变得**可远程调度、可持续运行、可回传结果**的本地执行中枢。
-当你需要：
-- 在手机上发一句话就能派活
-- 任务必须跑在你自己的电脑、现有代码库和本地工具链里
-- 想在 Claude Code / Codex CLI / Gemini CLI 之间自由切换
-- 希望进度、截图、文件自动回到聊天
-pikiclaw 会比“守在终端里”“SSH + tmux”或“单厂商云端 agent”更顺。
+它适合的不是“演示一次 AI”，而是你离开电脑以后，Agent 还能继续在本机把事做完。
 ---
@@ -60,251 +56,142 @@ pikiclaw 会比“守在终端里”“SSH + tmux”或“单厂商云端 agent
 ### 准备
 - 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) 凭证
+- 本机已安装并登录任意一个 Agent CLI
+  - [`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 或飞书应用凭证
-### 一行启动
+### 启动
 ```bash
-cd your-workspace/
+cd your-workspace
 npx pikiclaw@latest
 ```
-启动后自动打开 **Web Dashboard**（`localhost:3939`），引导你完成全部配置。也可以用终端向导：
+默认会打开 Web Dashboard：`http://localhost:3939`
+你可以在 Dashboard 里完成：
+- 渠道配置
+- 默认 Agent / 模型设置
+- 工作目录切换
+- 会话和运行状态查看
+如果你更喜欢终端向导：
 ```bash
 npx pikiclaw@latest --setup
 ```
-### 开始派活
-给你的 bot 发消息：
+如果只是检查环境：
-> "把 docs/ 目录下所有零散文档整理汇总，提取核心指标，输出一份报告。"
-**就这样。你的电脑现在是一个随时待命的远程执行中枢。**
+```bash
+npx pikiclaw@latest --doctor
+```
 ---
-## Features
-### Agent Engines
+## What Exists Today
-| Agent | 特点 |
-|-------|------|
-| **Claude Code** | Anthropic 官方 CLI · Thinking 展示 · 多模态 · 缓存优化 |
-| **Codex CLI** | OpenAI 官方 CLI · Reasoning 展示 · 计划步骤追踪 · 实时用量 |
-| **Gemini CLI** | Google 官方 CLI · 工具调用 · 流式输出 |
+### Channels
-通过 `/agents` 随时切换引擎，`/models` 切换模型。
+- Telegram 已可用
+- 飞书已可用
+- 两个渠道可以同时启动
-### IM Channels
+### Agents
-| 渠道 | 消息编辑 | 文件收发 | 回调按钮 | 命令菜单 | 场景 |
-|------|---------|---------|---------|---------|------|
-| **Telegram** | ✅ | ✅ | ✅ | ✅ | 全球 / 个人 |
-| **飞书** | ✅ | ✅ | ✅ | ✅ | 国内 / 团队 |
+- Claude Code
+- Codex CLI
+- Gemini CLI
-两个渠道可以**同时启动**。
+Agent 通过 driver registry 接入，模型列表、会话列表、usage 展示都走统一接口。
-### Core Capabilities
+### Runtime
-| 能力 | 说明 |
-|------|------|
-| 实时流式输出 | Agent 工作时消息持续更新 |
-| Thinking / Reasoning / Plan | 实时查看 Agent 的思考、推理和计划步骤 |
-| Token 追踪 | 输入/输出/缓存统计，上下文使用率实时显示 |
-| 产物回传 | 截图、日志、生成文件自动发回聊天 |
-| 长程任务保障 | 系统级防休眠 + 守护进程 + 异常自愈 |
-| 长文本处理 | 超长输出自动拆分或打包为 `.md` |
-| 多会话管理 | 随时切换、恢复历史会话 |
-| 图片/文件输入 | 截图、PDF、文档直接发给 Agent |
-| 项目 Skills | `.pikiclaw/skills/` 自定义技能，兼容 `.claude/commands/` |
-| 安全模式 | 白名单访问控制，支持切换更安全的 agent 权限模式 |
-| Web Dashboard | 可视化配置、会话浏览、主机监控 |
+- 流式预览和持续消息更新
+- 会话切换、恢复和多轮续聊
+- 工作目录浏览与切换
+- 长任务防休眠
+- watchdog 守护和自动重启
+- 长文本自动拆分，文件和图片自动回传
----
+### Skills
-## Comparison
+- 支持项目级 `.pikiclaw/skills/*/SKILL.md`
+- 兼容 `.claude/commands/*.md`
+- IM 内可通过 `/skills` 和 `/sk_<name>` 触发
-### pikiclaw vs. 其他方案
+### MCP Session Bridge
-```
-          在你的环境里执行
-               │
-    终端 CLI   │   pikiclaw
-    (人要守着)  │   (人可以走)
-               │
-  ─────────────┼─────────────
-    不方便控制  │  随时随地控制
-               │
-    SSH+tmux   │   云端 Agent
-    (手机上很痛苦) │ (不是你的环境)
-               │
-          在沙盒/远端执行
-```
+每次 Agent stream 会启动一个会话级 MCP server，把 IM 能力暴露给 Agent。
-| | 终端直接跑 | SSH + tmux | 云端 Agent | **pikiclaw** |
-|---|---|---|---|---|
-| 执行环境 | ✅ 本地 | ✅ 本地 | ⚠️ 通常是远端或沙盒 | ✅ 本地 |
-| 走开后还能跑 | ❌ 合盖就断 | ⚠️ 要配 tmux | ✅ | ✅ 防休眠 + 守护进程 |
-| 手机可控 | ❌ | ⚠️ 打字痛苦 | ✅ | ✅ IM 原生 |
-| 实时看进度 | ✅ 终端 | ⚠️ 得连上去看 | ⚠️ 依平台而定 | ✅ 流式推到聊天 |
-| 结果自动回传 | ❌ | ❌ | ⚠️ 看平台 | ✅ 截图/文件/长文本 |
-| 配置门槛 | 无 | SSH/穿透/tmux | 注册并适应平台工作流 | `npx` 一行 |
-### pikiclaw vs. OpenClaw / 官方入口
-| 维度 | **pikiclaw** | OpenClaw | 官方入口（Claude / Codex / Gemini） |
-|---|---|---|---|
-| 产品层 | IM 驱动的本地 agent 控制平面 | 通用个人 AI 助手 / 多渠道生态 | 单一厂商的原生 agent 入口 |
-| Agent 策略 | 复用官方 CLI，吃到各家最新能力 | 自带 runtime / agent stack | 只服务自家模型 |
-| 执行环境 | 你的电脑 | 个人设备网络 / 本地节点 | 本地 CLI 或厂商云 |
-| 渠道策略 | Telegram + 飞书深度打磨 | 广覆盖 | Web / App / Slack / CLI 为主 |
-| 锁定程度 | 低，可随时切换引擎 | 中 | 高 |
-| 最强场景 | 远程 coding、长任务、本地自动化 | 全能个人助手 | 原生模型体验、企业集成 |
+当前已接入的工具：
----
+- `im_list_files`：列出 session workspace 文件
+- `im_send_file`：把文件实时发回 IM
+- `take_screenshot`：跨平台截图并返回路径
-## Use Cases
-pikiclaw 不限于编程。你的 Agent 能做什么，pikiclaw 就能远程调度什么。
-它尤其适合那些**必须在你自己的环境里执行**、同时又希望**进度和结果直接回到 IM** 的任务。
-**工程重构** — "把整个项目从 JS 迁移到 TS，跑测试直到全部通过。搞定告诉我。"
-**文档处理** — "把 docs/ 下所有零散文档整理汇总，提取核心指标，输出一份报告。"
-**研究分析** — "下载这 5 篇论文的 PDF，逐篇阅读，写一份 3000 字综述。"
-**批量任务** — "把 data/ 下所有旧版报表转换成新格式，汇总成一份，确认数据条数。"
-**巡检自愈** — "跑一下数据同步任务，把报错自动修好，直到全部通过。"
-**竞品分析** — "分析竞品网站的落地页，把我们的页面改成类似风格，改完截图发我。"
+当前 `guiTools` 模块已经预留，但点击、输入、窗口控制等顶级 GUI 工具还没接上。
 ---
 ## Commands
 | 命令 | 说明 |
-|------|------|
-| `/start` | 菜单、当前 Agent 和工作目录 |
+|---|---|
+| `/start` | 显示入口信息、当前 Agent、工作目录 |
+| `/sessions` | 查看、切换或新建会话 |
 | `/agents` | 切换 Agent |
-| `/models` | 查看并切换模型 |
-| `/sessions` | 查看并切换历史会话 |
+| `/models` | 查看并切换模型 / reasoning effort |
 | `/switch` | 浏览并切换工作目录 |
-| `/status` | 状态、会话信息、Token 统计 |
-| `/host` | 主机 CPU / 内存 / 磁盘 / 电量 |
+| `/status` | 查看运行状态、tokens、usage、会话信息 |
+| `/host` | 查看主机 CPU / 内存 / 磁盘 / 电量 |
 | `/skills` | 浏览项目 skills |
-| `/restart` | 拉取最新版本并重启 |
-| `/sk_<name>` | 执行项目技能 |
+| `/restart` | 重启并重新拉起 bot |
+| `/sk_<name>` | 运行项目 skill |
-> 普通文本直接发给当前 Agent。
+普通文本消息会直接转给当前 Agent。
 ---
-## Configuration
+## Skills And MCP
-### 常见用法
+项目里现在有两条能力扩展线：
-```bash
-npx pikiclaw@latest                       # 自动检测，打开 Dashboard
-npx pikiclaw@latest -a claude             # 指定 Agent
-npx pikiclaw@latest -a gemini             # 使用 Gemini
-npx pikiclaw@latest -w ~/workspace        # 指定工作目录
-npx pikiclaw@latest -m claude-sonnet-4-6  # 指定模型
-npx pikiclaw@latest --safe-mode           # 安全模式
-npx pikiclaw@latest --allowed-ids ID      # 白名单
-npx pikiclaw@latest --doctor              # 检查环境
-```
+- Skills：偏“高层工作流提示词”，来源于 `.pikiclaw/skills` 和 `.claude/commands`
+- MCP tools：偏“可执行工具能力”，目前是会话级 bridge，由 pikiclaw 在每次 stream 时注入
-### CLI 参数
-| 参数 | 默认值 | 说明 |
-|------|--------|------|
-| `-t, --token` | — | Bot Token |
-| `-a, --agent` | `codex` | 默认 Agent |
-| `-m, --model` | Agent 默认 | 覆盖模型 |
-| `-w, --workdir` | 已保存或当前目录 | 工作目录 |
-| `--safe-mode` | `false` | Agent 自身权限模型 |
-| `--full-access` | `true` | 无确认执行 |
-| `--allowed-ids` | — | 限制 chat/user ID |
-| `--timeout` | `1800` | 单次请求最大秒数 |
-| `--no-daemon` | — | 禁用守护进程 |
-| `--no-dashboard` | — | 不启动 Dashboard |
-| `--dashboard-port` | `3939` | Dashboard 端口 |
-| `--doctor` | — | 检查环境 |
-| `--setup` | — | Setup Wizard |
-<details>
-<summary>环境变量</summary>
-**通用：**
-| 变量 | 说明 |
-|------|------|
-| `DEFAULT_AGENT` | 默认 Agent |
-| `PIKICLAW_WORKDIR` | 默认工作目录 |
-| `PIKICLAW_TIMEOUT` | 请求超时（秒） |
-| `PIKICLAW_ALLOWED_IDS` | 白名单 |
-| `PIKICLAW_FULL_ACCESS` | 完全访问模式 |
-| `PIKICLAW_RESTART_CMD` | 自定义重启命令 |
-**Telegram：**
-| 变量 | 说明 |
-|------|------|
-| `TELEGRAM_BOT_TOKEN` | Bot Token |
-| `TELEGRAM_ALLOWED_CHAT_IDS` | 白名单 |
-**飞书：**
-| 变量 | 说明 |
-|------|------|
-| `FEISHU_APP_ID` | App ID |
-| `FEISHU_APP_SECRET` | App Secret |
-| `FEISHU_DOMAIN` | API 域名（默认 `https://open.feishu.cn`） |
-| `FEISHU_ALLOWED_CHAT_IDS` | 白名单 |
-**Claude：**
-| 变量 | 说明 |
-|------|------|
-| `CLAUDE_MODEL` | 模型 |
-| `CLAUDE_PERMISSION_MODE` | 权限模式 |
-| `CLAUDE_EXTRA_ARGS` | 额外参数 |
-**Codex：**
-| 变量 | 说明 |
-|------|------|
-| `CODEX_MODEL` | 模型 |
-| `CODEX_REASONING_EFFORT` | 推理强度 |
-| `CODEX_FULL_ACCESS` | 完全访问 |
-| `CODEX_EXTRA_ARGS` | 额外参数 |
-**Gemini：**
-| 变量 | 说明 |
-|------|------|
-| `GEMINI_MODEL` | 模型 |
-| `GEMINI_EXTRA_ARGS` | 额外参数 |
-</details>
+这两条线已经能工作，但都还是偏“session / project 内部接入”，还不是仓库级统一入口。
 ---
 ## Status
-| 维度 | 状态 |
-|------|------|
-| IM | Telegram ✅ · 飞书 ✅ · WhatsApp（规划中） |
-| Agent | Claude Code ✅ · Codex CLI ✅ · Gemini CLI ✅ |
-| 面板 | Web Dashboard ✅ |
-| 国际化 | 中文 ✅ · English ✅ |
-| 平台 | macOS ✅ · Linux ✅ |
+### 已完成
+| 项目 | 状态 |
+|---|---|
+| Telegram 渠道 | ✅ |
+| 飞书渠道 | ✅ |
+| Claude Code driver | ✅ |
+| Codex CLI driver | ✅ |
+| Gemini CLI driver | ✅ |
+| Web Dashboard | ✅ |
+| 项目级 Skills | ✅ |
+| 会话级 MCP bridge | ✅ |
+| 文件回传 / 截图回传 | ✅ |
+| 守护重启 / 防休眠 | ✅ |
+### 待办
+| 项目 | 说明 |
+|---|---|
+| 顶级 Skills 接入 | 把 skills 从当前项目级入口提升为更统一的顶级接入能力 |
+| 顶级 MCP 工具接入 | 把当前会话级 MCP bridge 扩展成更完整的顶级工具接入层 |
+| GUI 自动化工具补全 | 在 `src/tools/gui.ts` 上接入点击、输入、聚焦、窗口控制等工具 |
+| 更多渠道 | WhatsApp 仍在规划中 |
 ---
@@ -314,12 +201,26 @@ npx pikiclaw@latest --doctor              # 检查环境
 git clone https://github.com/xiaotonng/pikiclaw.git
 cd pikiclaw
 npm install
-echo "TELEGRAM_BOT_TOKEN=your_token" > .env
-set -a && source .env && npx tsx src/cli.ts
+npm run build
+npm test
+```
+常用命令：
+```bash
+npm run dev
+npm run build
 npm test
+npm run test:e2e
+npx vitest run test/channel-feishu.unit.test.ts
+npx pikiclaw@latest --doctor
 ```
-架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
+更多实现细节见：
+- [ARCHITECTURE.md](ARCHITECTURE.md)
+- [INTEGRATION.md](INTEGRATION.md)
+- [TESTING.md](TESTING.md)
 ---

package/dist/bot-commands.js CHANGED Viewed

@@ -23,10 +23,18 @@ export function getStartData(bot, chatId) {
     const installedCount = res.agents.filter(a => a.installed).length;
     const skillRes = bot.fetchSkills();
     const commands = buildDefaultMenuCommands(installedCount, skillRes.skills);
+    const agentDetails = res.agents
+        .filter(a => a.installed)
+        .map(a => ({
+        agent: a.agent,
+        model: bot.modelForAgent(a.agent) || '(default)',
+        effort: bot.effortForAgent(a.agent),
+    }));
     return {
         ...intro,
         agent: cs.agent,
         workdir: bot.workdir,
+        agentDetails,
         commands,
     };
 }

package/dist/bot-feishu-render.js CHANGED Viewed

@@ -262,6 +262,14 @@ export function renderStart(d) {
         `**Agent:** ${d.agent}`,
         `**Workdir:** \`${d.workdir}\``,
         '',
+        '**Agents**',
+        ...d.agentDetails.map(a => {
+            let line = `  **${a.agent}**: ${a.model}`;
+            if (a.effort)
+                line += ` (effort: ${a.effort})`;
+            return line;
+        }),
+        '',
         '**Commands**',
         ...d.commands.map(c => `/${c.command} — ${c.description}`),
     ];

package/dist/bot-feishu.js CHANGED Viewed

@@ -21,7 +21,6 @@ import { feishuPreviewRenderer, buildInitialPreviewMarkdown, buildFinalReplyRend
 import { FeishuChannel } from './channel-feishu.js';
 import { splitText, supportsChannelCapability } from './channel-base.js';
 import { getActiveUserConfig } from './user-config.js';
-import { VERSION } from './version.js';
 const SHUTDOWN_EXIT_CODE = {
     SIGINT: 130,
     SIGTERM: 143,
@@ -794,9 +793,10 @@ export class FeishuBot extends Bot {
             this.log('no known chats for startup notice');
             return;
         }
-        const text = `**${VERSION}** pikiclaw is online.\nSend /start to get started.`;
         for (const cid of targets) {
             try {
+                const d = getStartData(this, cid);
+                const text = renderStart(d);
                 await this.channel.send(cid, text);
                 this.log(`startup notice sent to chat=${cid}`);
             }

package/dist/bot-telegram.js CHANGED Viewed

@@ -12,7 +12,7 @@ import { spawn } from 'node:child_process';
 import { Bot, fmtTokens, fmtUptime, fmtBytes, buildPrompt, parseAllowedChatIds, } from './bot.js';
 import { stageSessionFiles, } from './code-agent.js';
 import { shutdownAllDrivers } from './agent-driver.js';
-import { buildDefaultMenuCommands, buildWelcomeIntro, SKILL_CMD_PREFIX, } from './bot-menu.js';
+import { buildDefaultMenuCommands, SKILL_CMD_PREFIX, } from './bot-menu.js';
 import { getStartData, getStatusDataAsync, getHostDataSync, getSessionTurnPreviewData, resolveSkillPrompt, summarizePromptForStatus, } from './bot-commands.js';
 import { buildAgentsCommandView, buildModelsCommandView, buildSessionsCommandView, buildSkillsCommandView, decodeCommandAction, executeCommandAction, } from './bot-command-ui.js';
 import { buildSwitchWorkdirView, resolveRegisteredPath } from './bot-telegram-directory.js';
@@ -22,7 +22,6 @@ import { buildInitialPreviewHtml, buildStreamPreviewHtml, buildFinalReplyRender,
 import { TelegramChannel } from './channel-telegram.js';
 import { splitText, supportsChannelCapability } from './channel-base.js';
 import { getActiveUserConfig } from './user-config.js';
-import { VERSION } from './version.js';
 /** Telegram HTML renderer for LivePreview. */
 const telegramPreviewRenderer = {
     renderInitial: buildInitialPreviewHtml,
@@ -164,13 +163,6 @@ export class TelegramBot extends Bot {
         const commands = buildDefaultMenuCommands(installedCount, skillRes.skills);
         return { commands, skillCount: skillRes.skills.length, skills: skillRes.skills };
     }
-    welcomeIntroLines() {
-        const intro = buildWelcomeIntro(VERSION);
-        return [
-            `<b>${escapeHtml(intro.title)}</b> v${escapeHtml(intro.version)}`,
-            escapeHtml(intro.subtitle),
-        ];
-    }
     createTaskId(session) {
         const seq = this.nextTaskId++;
         return `${session.key}:${Date.now().toString(36)}:${seq.toString(36)}`;
@@ -242,6 +234,9 @@ export class TelegramBot extends Bot {
     // ---- commands -------------------------------------------------------------
     async cmdStart(ctx) {
         const d = getStartData(this, ctx.chatId);
+        await ctx.reply(this.renderStartHtml(d), { parseMode: 'HTML' });
+    }
+    renderStartHtml(d) {
         const lines = [
             `<b>${escapeHtml(d.title)}</b> v${escapeHtml(d.version)}`,
             escapeHtml(d.subtitle),
@@ -249,10 +244,18 @@ export class TelegramBot extends Bot {
             `<b>Agent:</b> ${escapeHtml(d.agent)}`,
             `<b>Workdir:</b> <code>${escapeHtml(d.workdir)}</code>`,
             '',
+            '<b>Agents</b>',
+            ...d.agentDetails.map(a => {
+                const parts = [`  <b>${escapeHtml(a.agent)}</b>: ${escapeHtml(a.model)}`];
+                if (a.effort)
+                    parts[0] += ` (effort: ${escapeHtml(a.effort)})`;
+                return parts[0];
+            }),
+            '',
             '<b>Commands</b>',
             ...formatMenuLines(d.commands),
         ];
-        await ctx.reply(lines.join('\n'), { parseMode: 'HTML' });
+        return lines.join('\n');
     }
     async cmdSkills(ctx) {
         await this.sendCommandView(ctx, buildSkillsCommandView(this, ctx.chatId));
@@ -776,9 +779,10 @@ export class TelegramBot extends Bot {
             this.log('no known chats for startup notice');
             return;
         }
-        const text = this.welcomeIntroLines().join('\n');
         for (const cid of targets) {
             try {
+                const d = getStartData(this, cid);
+                const text = this.renderStartHtml(d);
                 await this.channel.send(cid, text, { parseMode: 'HTML' });
                 this.log(`startup notice sent to chat=${cid}`);
             }

package/dist/channel-feishu.js CHANGED Viewed

@@ -63,6 +63,22 @@ function isRetryableUploadError(err) {
         'gateway timeout',
     ].some(token => text.includes(token));
 }
+function requireMessageId(resp, action) {
+    const messageId = resp?.data?.message_id;
+    if (messageId)
+        return String(messageId);
+    const code = resp?.code;
+    const msg = resp?.msg || resp?.message || 'no message_id returned';
+    throw new Error(`${action} failed: code=${code ?? '?'} msg=${msg}`);
+}
+function buildPostContent(paragraphs, title = '') {
+    return JSON.stringify({
+        zh_cn: {
+            title,
+            content: paragraphs,
+        },
+    });
+}
 // ---------------------------------------------------------------------------
 // Card builder helper
 // ---------------------------------------------------------------------------
@@ -520,7 +536,7 @@ class FeishuChannel extends Channel {
                 content: JSON.stringify(card),
             },
         });
-        return resp?.data?.message_id ?? null;
+        return requireMessageId(resp, 'send interactive card');
     }
     async send(chatId, text, opts = {}) {
         const rows = keyboardToRows(opts.keyboard);
@@ -541,7 +557,7 @@ class FeishuChannel extends Channel {
                 content: JSON.stringify(card),
             },
         });
-        return resp?.data?.message_id ?? null;
+        return requireMessageId(resp, 'reply interactive card');
     }
     async editCard(chatId, msgId, view) {
         if (!view.markdown.trim())
@@ -730,7 +746,21 @@ class FeishuChannel extends Channel {
                 content: JSON.stringify({ text }),
             },
         });
-        return resp?.data?.message_id ?? null;
+        return requireMessageId(resp, 'send text');
+    }
+    async sendPost(chatId, content, opts = {}) {
+        const replyTo = opts.replyTo ? String(opts.replyTo) : undefined;
+        this._logOutgoing('sendPost', `${replyTo ? `reply_to=${replyTo}` : `chat=${chatId}`} chars=${content.length}`);
+        const resp = replyTo
+            ? await this.client.im.message.reply({
+                path: { message_id: replyTo },
+                data: { msg_type: 'post', content },
+            })
+            : await this.client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: { receive_id: chatId, msg_type: 'post', content },
+            });
+        return requireMessageId(resp, 'send post');
     }
     /** Upload an image and return the image_key. */
     async uploadImage(imageBuffer) {
@@ -772,15 +802,23 @@ class FeishuChannel extends Channel {
         const content = fs.readFileSync(filePath);
         const filename = path.basename(filePath);
         const isPhoto = opts.asPhoto ?? PHOTO_EXTS.has(path.extname(filename).toLowerCase());
+        const caption = typeof opts.caption === 'string' ? opts.caption.trim() : '';
         const replyTo = opts.replyTo ? String(opts.replyTo) : undefined;
         if (isPhoto) {
             try {
                 const imageKey = await this.uploadImage(content);
+                if (caption) {
+                    return await this.sendPost(String(chatId), buildPostContent([
+                        [{ tag: 'img', image_key: imageKey }],
+                        [{ tag: 'text', text: caption }],
+                    ]), { replyTo });
+                }
                 const msgContent = JSON.stringify({ image_key: imageKey });
+                this._logOutgoing('sendImage', `${replyTo ? `reply_to=${replyTo}` : `chat=${chatId}`} file=${filename}`);
                 const resp = replyTo
                     ? await this.client.im.message.reply({ path: { message_id: replyTo }, data: { msg_type: 'image', content: msgContent } })
                     : await this.client.im.message.create({ params: { receive_id_type: 'chat_id' }, data: { receive_id: String(chatId), msg_type: 'image', content: msgContent } });
-                return resp?.data?.message_id ?? null;
+                return requireMessageId(resp, 'send image');
             }
             catch (err) {
                 if (isRetryableUploadError(err))
@@ -790,10 +828,11 @@ class FeishuChannel extends Channel {
         }
         const fileKey = await this.uploadFile(content, filename);
         const msgContent = JSON.stringify({ file_key: fileKey });
+        this._logOutgoing('sendFile', `${replyTo ? `reply_to=${replyTo}` : `chat=${chatId}`} file=${filename}`);
         const resp = replyTo
             ? await this.client.im.message.reply({ path: { message_id: replyTo }, data: { msg_type: 'file', content: msgContent } })
             : await this.client.im.message.create({ params: { receive_id_type: 'chat_id' }, data: { receive_id: String(chatId), msg_type: 'file', content: msgContent } });
-        return resp?.data?.message_id ?? null;
+        return requireMessageId(resp, 'send file');
     }
     // ========================================================================
     // Download resources from received messages

package/dist/cli.js CHANGED Viewed

@@ -12,7 +12,7 @@ import { startDashboard } from './dashboard.js';
 import { buildSetupGuide, collectSetupState, hasReadyAgent, isSetupReady } from './onboarding.js';
 import { buildRestartCommand, clearRestartStateFile, consumeRestartStateFile, createRestartStateFilePath, PROCESS_RESTART_EXIT_CODE, requestProcessRestart, } from './process-control.js';
 import { runSetupWizard } from './setup-wizard.js';
-import { applyUserConfig, loadUserConfig, startUserConfigSync } from './user-config.js';
+import { applyUserConfig, loadUserConfig, startUserConfigSync, updateUserConfig } from './user-config.js';
 import { VERSION } from './version.js';
 /* ── Daemon (watchdog) mode ─────────────────────────────────────────── */
 const DAEMON_RESTART_DELAY_MS = 3_000;
@@ -191,6 +191,16 @@ export async function main() {
         process.stdout.write(`pikiclaw ${VERSION}\n`);
         process.exit(0);
     }
+    // Fresh CLI launch (not a daemon-managed child): persist the current working
+    // directory (or explicit -w) into setting.json so the bot session — and any
+    // subsequent daemon-managed restarts — starts in the right place.
+    if (!process.env.PIKICLAW_DAEMON_CHILD) {
+        const cliWorkdir = path.resolve(args.workdir || '.');
+        if (userConfig.workdir !== cliWorkdir) {
+            updateUserConfig({ workdir: cliWorkdir });
+            userConfig = loadUserConfig();
+        }
+    }
     // Daemon mode (default): become a watchdog that supervises the real bot process.
     // The child is spawned via `npx pikiclaw@latest` so restarts always pull latest code.
     // Use --no-daemon to disable.
@@ -212,8 +222,6 @@ export async function main() {
     const configOverrides = {};
     if (args.agent)
         configOverrides.defaultAgent = args.agent;
-    if (args.workdir)
-        process.env.PIKICLAW_WORKDIR = path.resolve(args.workdir);
     // Apply config early so managed env vars are populated from setting.json.
     applyUserConfig({ ...userConfig, ...configOverrides }, undefined, { overwrite: true, clearMissing: true });
     const effectiveConfig = () => ({ ...userConfig, ...configOverrides });

package/dist/code-agent.js CHANGED Viewed

@@ -802,12 +802,10 @@ export async function doStream(opts) {
     }
     // Start MCP bridge if sendFile callback is provided
     let bridge = null;
-    let mcpLogPath = null;
     if (opts.mcpSendFile) {
         try {
             const { startMcpBridge } = await import('./mcp-bridge.js');
             const sessionDir = path.dirname(session.workspacePath);
-            mcpLogPath = path.join(sessionDir, 'mcp-server.log');
             bridge = await startMcpBridge({
                 sessionDir,
                 workspacePath: session.workspacePath,
@@ -815,10 +813,13 @@ export async function doStream(opts) {
                 stagedFiles,
                 sendFile: opts.mcpSendFile,
                 agent: opts.agent,
+                onLog: (message) => agentLog(`[mcp] ${message}`),
             });
             prepared.mcpConfigPath = bridge.configPath;
-            agentLog(`[mcp] bridge started on ${bridge.configPath}`);
-            agentLog(`[mcp] server log file: ${mcpLogPath}`);
+            if (bridge.configPath)
+                agentLog(`[mcp] bridge started on ${bridge.configPath}`);
+            else
+                agentLog('[mcp] bridge registered with codex');
             try {
                 agentLog(`[mcp] config content:\n${fs.readFileSync(bridge.configPath, 'utf-8')}`);
             }
@@ -837,12 +838,8 @@ export async function doStream(opts) {
     finally {
         if (bridge) {
             await bridge.stop().catch(() => { });
-            if (mcpLogPath && fs.existsSync(mcpLogPath)) {
-                const tail = readTailLines(mcpLogPath, 16 * 1024).slice(-20).join('\n').trim();
-                if (tail)
-                    agentLog(`[mcp] server log tail:\n${tail}`);
-            }
-            agentLog('[mcp] bridge stopped');
+            if (bridge.hadActivity())
+                agentLog('[mcp] bridge stopped');
         }
     }
 }

package/dist/config-validation.js CHANGED Viewed

@@ -210,10 +210,27 @@ export async function validateFeishuConfig(appId, appSecret, options = {}) {
                 app: null,
             };
         }
-        const app = { appId: trimmedAppId, displayName: null };
-        feishuValidationLog(appLabel, `verified elapsedMs=${Date.now() - startedAt}`);
+        // Try to fetch bot display name using the tenant access token
+        let botDisplayName = null;
+        try {
+            const botResp = await withTimeout(fetch(`${apiDomain}/open-apis/bot/v3/info`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${parsed.tenant_access_token}` },
+            }).then(r => r.json()), 5_000, 'Feishu bot info');
+            if (botResp?.bot?.app_name) {
+                botDisplayName = botResp.bot.app_name;
+            }
+        }
+        catch {
+            // Non-critical — proceed without bot name
+        }
+        const app = { appId: trimmedAppId, displayName: botDisplayName };
+        const identity = botDisplayName
+            ? `${botDisplayName} (${appLabel})`
+            : `App ${appLabel} verified.`;
+        feishuValidationLog(appLabel, `verified botName=${botDisplayName ?? '(unknown)'} elapsedMs=${Date.now() - startedAt}`);
         return {
-            state: readyChannelState('feishu', `App ${trimmedAppId} verified.`),
+            state: readyChannelState('feishu', identity),
             app,
         };
     }

package/dist/mcp-bridge.js CHANGED Viewed

@@ -76,29 +76,86 @@ function isInsideAllowedRoot(realFile, allowedRoots) {
     }
     return false;
 }
-export function resolveSendFilePath(inputPath, workspacePath, workdir) {
+export function resolveSendFilePath(inputPath, workspacePath, stagedFiles = [], workdir) {
     const requested = String(inputPath || '').trim();
     if (!requested)
-        return null;
+        return { path: null, error: 'path is required' };
     if (path.isAbsolute(requested))
-        return requested;
+        return { path: requested };
+    const roots = {
+        workspace: path.resolve(workspacePath),
+        workdir: workdir ? path.resolve(workdir) : '',
+        tmp: path.resolve(os.tmpdir()),
+    };
+    const aliasPrefixes = [
+        { prefix: '@workspace/', root: roots.workspace },
+        { prefix: 'workspace:', root: roots.workspace },
+        { prefix: 'ws:', root: roots.workspace },
+        ...(roots.workdir ? [
+            { prefix: '@workdir/', root: roots.workdir },
+            { prefix: 'workdir:', root: roots.workdir },
+            { prefix: 'wd:', root: roots.workdir },
+        ] : []),
+        { prefix: '@tmp/', root: roots.tmp },
+        { prefix: 'tmp:', root: roots.tmp },
+    ];
+    for (const { prefix, root } of aliasPrefixes) {
+        if (!requested.startsWith(prefix))
+            continue;
+        const suffix = requested.slice(prefix.length).trim();
+        return { path: suffix ? path.resolve(root, suffix) : root };
+    }
     const candidates = [
-        path.resolve(workspacePath, requested),
-        ...(workdir ? [path.resolve(workdir, requested)] : []),
+        path.resolve(roots.workspace, requested),
+        ...(roots.workdir ? [path.resolve(roots.workdir, requested)] : []),
     ];
     for (const candidate of candidates) {
         try {
             fs.realpathSync(candidate);
-            return candidate;
+            return { path: candidate };
         }
         catch {
             // Try next candidate.
         }
     }
-    return candidates[0] || null;
+    if (!requested.includes('/') && !requested.includes(path.sep)) {
+        const basenameMatches = new Map();
+        const dedupedMatches = [];
+        const addMatch = (candidate) => {
+            const key = path.resolve(candidate);
+            if (basenameMatches.has(key))
+                return;
+            basenameMatches.set(key, key);
+            dedupedMatches.push(key);
+        };
+        try {
+            const tmpCandidate = path.join(roots.tmp, requested);
+            if (fs.existsSync(tmpCandidate))
+                addMatch(tmpCandidate);
+        }
+        catch { }
+        for (const relPath of stagedFiles) {
+            if (path.basename(relPath) !== requested)
+                continue;
+            addMatch(path.join(roots.workspace, relPath));
+        }
+        if (dedupedMatches.length === 1)
+            return { path: dedupedMatches[0] };
+        if (dedupedMatches.length > 1) {
+            return {
+                path: null,
+                error: `ambiguous file name "${requested}"; use @workspace/..., @workdir/..., or @tmp/...`,
+            };
+        }
+    }
+    return {
+        path: candidates[0] || null,
+        error: `file not found: ${requested}; try @workspace/..., @workdir/..., @tmp/..., or a unique filename`,
+    };
 }
 export async function startMcpBridge(opts) {
     const { sessionDir, workspacePath, stagedFiles, sendFile } = opts;
+    let hadActivity = false;
     // Build allowed roots: workspace + workdir + /tmp
     const allowedRoots = [workspacePath];
     if (opts.workdir)
@@ -106,7 +163,7 @@ export async function startMcpBridge(opts) {
     allowedRoots.push('/tmp', os.tmpdir());
     // ── HTTP callback server ──
     const server = http.createServer((req, res) => {
-        if (req.method !== 'POST' || req.url !== '/send-file') {
+        if (req.method !== 'POST' || (req.url !== '/send-file' && req.url !== '/log')) {
             res.writeHead(404);
             res.end();
             return;
@@ -120,6 +177,17 @@ export async function startMcpBridge(opts) {
         req.on('end', async () => {
             clearTimeout(bodyTimer);
             try {
+                if (req.url === '/log') {
+                    const data = JSON.parse(body || '{}');
+                    const message = typeof data.message === 'string' ? data.message.trim() : '';
+                    if (message) {
+                        hadActivity = true;
+                        opts.onLog?.(message);
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                    return;
+                }
                 const data = JSON.parse(body);
                 const relPath = String(data.path || '').trim();
                 if (!relPath) {
@@ -128,14 +196,15 @@ export async function startMcpBridge(opts) {
                     return;
                 }
                 // Resolve and validate path
-                const absPath = resolveSendFilePath(relPath, workspacePath, opts.workdir);
+                const resolved = resolveSendFilePath(relPath, workspacePath, stagedFiles, opts.workdir);
+                const absPath = resolved.path;
                 let realFile;
                 try {
                     realFile = fs.realpathSync(String(absPath || ''));
                 }
                 catch {
                     res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: `file not found: ${relPath}` }));
+                    res.end(JSON.stringify({ ok: false, error: resolved.error || `file not found: ${relPath}` }));
                     return;
                 }
                 if (!isInsideAllowedRoot(realFile, allowedRoots)) {
@@ -161,6 +230,7 @@ export async function startMcpBridge(opts) {
                         : isPhotoFile(realFile) ? 'photo'
                             : 'document';
                 const caption = typeof data.caption === 'string' ? data.caption.trim().slice(0, 1024) || undefined : undefined;
+                hadActivity = true;
                 const result = await Promise.race([
                     sendFile(realFile, { caption, kind }),
                     new Promise((_, reject) => setTimeout(() => reject(new Error(`sendFile timed out after ${SEND_FILE_TIMEOUT_MS / 1000}s`)), SEND_FILE_TIMEOUT_MS)),
@@ -186,8 +256,10 @@ export async function startMcpBridge(opts) {
     const { command, args } = resolveMcpServerCommand();
     const envVars = {
         MCP_WORKSPACE_PATH: workspacePath,
+        MCP_WORKDIR: opts.workdir || '',
         MCP_STAGED_FILES: JSON.stringify(stagedFiles),
         MCP_CALLBACK_URL: `http://127.0.0.1:${port}`,
+        MCP_LOG_URL: `http://127.0.0.1:${port}/log`,
     };
     let configPath = '';
     let codexRegistered = false;
@@ -224,6 +296,7 @@ export async function startMcpBridge(opts) {
     }
     return {
         configPath,
+        hadActivity: () => hadActivity,
         stop: async () => {
             await new Promise(resolve => server.close(() => resolve()));
             if (codexRegistered) {

package/dist/tools/workspace.js CHANGED Viewed

@@ -7,6 +7,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import http from 'node:http';
+import os from 'node:os';
 import { toolResult, toolLog } from './types.js';
 // ---------------------------------------------------------------------------
 // Tool definitions
@@ -33,11 +34,11 @@ const tools = [
             properties: {
                 path: {
                     type: 'string',
-                    description: 'Absolute, workspace-relative, or workdir-relative path.',
+                    description: 'Path to send. Supports absolute paths, @workspace/..., @workdir/..., @tmp/..., workspace-relative paths, and unique bare filenames.',
                 },
                 caption: {
                     type: 'string',
-                    description: 'Optional caption.',
+                    description: 'Caption.',
                 },
                 kind: {
                     type: 'string',
@@ -45,7 +46,7 @@ const tools = [
                     description: 'Optional file kind.',
                 },
             },
-            required: ['path'],
+            required: ['path', 'caption'],
         },
     },
 ];
@@ -65,8 +66,14 @@ function handleListFiles(args, ctx) {
     }
     try {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const workspaceRelDir = path.relative(ctx.workspace, dir);
         const files = entries.map(e => {
             const entry = { name: e.name, type: e.isDirectory() ? 'directory' : 'file' };
+            const relPath = workspaceRelDir && workspaceRelDir !== '' && workspaceRelDir !== '.'
+                ? path.posix.join(toPosix(workspaceRelDir), e.name)
+                : e.name;
+            entry.path = relPath;
+            entry.alias = `@workspace/${relPath}`;
             if (e.isFile()) {
                 try {
                     entry.size = fs.statSync(path.join(dir, e.name)).size;
@@ -78,7 +85,24 @@ function handleListFiles(args, ctx) {
         toolLog('im_list_files', `OK ${files.length} entries`);
         return toolResult(JSON.stringify({
             workspacePath: ctx.workspace,
-            stagedFiles: ctx.stagedFiles,
+            workdirPath: ctx.workdir || null,
+            tempPath: os.tmpdir(),
+            pathAliases: {
+                workspaceRoot: '@workspace',
+                workdirRoot: ctx.workdir ? '@workdir' : null,
+                tempRoot: '@tmp',
+                notes: [
+                    'Use @workspace/... for files in the session workspace.',
+                    ctx.workdir ? 'Use @workdir/... for files in the agent workdir.' : null,
+                    'Use @tmp/... for screenshots and other temp files.',
+                    'A bare filename also works if it uniquely matches a staged file or /tmp file.',
+                ].filter(Boolean),
+            },
+            stagedFiles: ctx.stagedFiles.map(relPath => ({
+                path: relPath,
+                alias: `@workspace/${toPosix(relPath)}`,
+                basename: path.basename(relPath),
+            })),
             files,
         }, null, 2));
     }
@@ -89,20 +113,24 @@ function handleListFiles(args, ctx) {
 }
 async function handleSendFile(args, ctx) {
     const filePath = typeof args?.path === 'string' ? args.path.trim() : '';
+    const caption = typeof args?.caption === 'string' ? args.caption.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);
     }
+    if (!caption) {
+        toolLog('im_send_file', 'ERROR missing caption');
+        return toolResult('Error: "caption" is required', true);
+    }
     if (!ctx.callbackUrl) {
         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,
+            caption,
             kind,
         });
         if (result.ok) {
@@ -110,15 +138,13 @@ async function handleSendFile(args, ctx) {
             return toolResult(`File sent successfully: ${filePath}`);
         }
         else {
-            const detail = formatSendFileFailure(result);
-            toolLog('im_send_file', `FAILED ${detail}`);
-            return toolResult(`Failed to send file: ${detail}`, true);
+            toolLog('im_send_file', `FAILED ${result.error || 'unknown error'}`);
+            return toolResult(`Failed to send file: ${result.error || 'unknown error'}`, true);
         }
     }
     catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        toolLog('im_send_file', `ERROR callback=${callbackTarget} ${message}`);
-        return toolResult(`Error sending file: ${message}`, true);
+        toolLog('im_send_file', `ERROR ${e.message}`);
+        return toolResult(`Error sending file: ${e.message}`, true);
     }
 }
 // ---------------------------------------------------------------------------
@@ -135,45 +161,14 @@ 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 {
-                    parsed = data ? JSON.parse(data) : null;
-                }
-                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;
+                    resolve(JSON.parse(data));
                 }
-                if (parsed && typeof parsed.ok === 'boolean') {
-                    resolve({
-                        ok: parsed.ok,
-                        error: typeof parsed.error === 'string' ? parsed.error : undefined,
-                        statusCode,
-                        statusMessage,
-                        bodyPreview,
-                    });
-                    return;
+                catch {
+                    resolve({ ok: false, error: 'invalid callback response' });
                 }
-                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();
@@ -190,31 +185,8 @@ 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;
+function toPosix(p) {
+    return p.split(path.sep).join(path.posix.sep);
 }
 // ---------------------------------------------------------------------------
 // Module export

package/package.json CHANGED Viewed

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