pi-feishu-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 yandy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# pi-feishu-cli
+
+在飞书中与 Pi 对话的 [pi package](https://pi.dev/docs/latest/packages)。包含 26 个飞书 CLI skills 和一个飞书 IM 守护进程。
+
+## 安装
+
+```bash
+pi install ./pi-feishu-cli
+```
+
+## 启动
+
+**方式一：Pi 内命令**
+
+```
+/feishu-im start    启动守护进程
+/feishu-im status   查看状态
+/feishu-im stop     停止守护进程
+/feishu-im restart  重启守护进程
+```
+
+**方式二：CLI flag**
+
+```bash
+pi --feishu-im
+```
+
+首次启动会自动检查 `lark-cli` 是否安装和配置，如未完成会给出引导提示。
+
+## 前置依赖
+
+- [lark-cli](https://github.com/larksuite/lark-cli) — 飞书 API 调用工具
+- 飞书机器人应用凭证（通过 `lark-cli config init` 配置）
+
+## 配置
+
+`~/.pi/agent/feishu-im/config.json`：
+
+```json
+{
+  "strategy": "mention",
+  "model": "anthropic/claude-sonnet-4-20250514",
+  "pollInterval": 5
+}
+```
+
+| 字段 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `strategy` | `"open"` \| `"mention"` | `"mention"` | 群聊策略：mention 仅回复 @机器人，open 回复全部 |
+| `model` | `string` | 空 | 新会话默认模型，不设置则用 Pi 默认 |
+| `pollInterval` | `number` | `5` | 长轮询间隔（秒） |
+
+## 架构
+
+```
+pi TUI → extension(/feishu-im start)
+                    │
+               spawn daemon
+                    │
+         ┌──────────▼──────────┐
+         │  守护进程 (Node.js)   │
+         │  ┌───────────────┐  │
+         │  │  长轮询事件     │  │
+         │  └───────┬───────┘  │
+         │          ▼          │
+         │  ┌───────────────┐  │
+         │  │  消息路由 Bot   │  │
+         │  │  命令/对话分发  │  │
+         │  └───────┬───────┘  │
+         │          ▼          │
+         │  ┌───────────────┐  │
+         │  │  Pi SDK Agent  │  │
+         │  │  处理消息回复   │  │
+         │  └───────────────┘  │
+         └─────────────────────┘
+```
+
+守护进程独立于 Pi TUI 运行，关闭 Pi 后仍可继续对话。
+
+## 飞书内命令
+
+| 命令 | 说明 |
+|------|------|
+| `/new [名称]` | 创建新会话 |
+| `/sessions` | 查看会话列表（卡片） |
+| `/switch <id>` | 切换会话 |
+| `/rm <id>` | 删除会话 |
+| `/model` | 切换模型（卡片） |
+
+## 数据目录
+
+```
+~/.pi/agent/
+├── feishu-im/
+│   ├── config.json         # 配置
+│   ├── daemon.pid          # PID
+│   └── registry.json       # 飞书↔Pi 会话映射
+└── sessions/               # Pi session 文件
+```
+
+## Skills
+
+包含 26 个飞书 CLI skills，覆盖 IM、日历、文档、表格、审批、OKR 等飞书服务。通过 Pi 的技能系统自动加载，对话中按需调用。
+
+## 开发
+
+```bash
+npm install
+npx vitest run        # 运行测试
+npx vitest            # 监听模式
+```

package/dist/src/bot.d.ts

@@ -0,0 +1,29 @@
+import { SessionRegistry } from "./session-registry.js";
+import type { FeishuEvent } from "./poller.js";
+import type { FeishuImConfig } from "./types.js";
+export interface RouteResultCommand {
+    type: "command";
+    command: string;
+    args: string;
+    chatId: string;
+    threadId?: string;
+}
+export interface RouteResultMessage {
+    type: "message";
+    text: string;
+    chatId: string;
+    threadId?: string;
+}
+export interface RouteResultSkip {
+    type: "skip";
+}
+export type RouteResult = RouteResultCommand | RouteResultMessage | RouteResultSkip;
+export declare class Bot {
+    private registry;
+    private strategy;
+    constructor(registry: SessionRegistry, strategy: FeishuImConfig["strategy"]);
+    route(event: FeishuEvent): RouteResult;
+    private isCommand;
+    private parseCommand;
+    private extractText;
+}

package/dist/src/bot.js

@@ -0,0 +1,75 @@
+const BOT_OPEN_ID = "__bot_open_id__";
+export class Bot {
+    registry;
+    strategy;
+    constructor(registry, strategy) {
+        this.registry = registry;
+        this.strategy = strategy;
+    }
+    route(event) {
+        const msg = event.event?.message;
+        if (!msg)
+            return { type: "skip" };
+        const chatId = msg.chat_id;
+        const text = this.extractText(msg.content, msg.message_type);
+        if (!text)
+            return { type: "skip" };
+        const mentions = msg.mentions ?? [];
+        const hasMentions = mentions.length > 0;
+        const isMentioned = mentions.some((m) => m.key === BOT_OPEN_ID);
+        if (this.strategy === "mention" && hasMentions && !isMentioned) {
+            if (!this.isCommand(text))
+                return { type: "skip" };
+        }
+        const commandResult = this.parseCommand(text);
+        if (commandResult) {
+            return {
+                type: "command",
+                command: commandResult.command,
+                args: commandResult.args,
+                chatId,
+                threadId: msg.parent_id,
+            };
+        }
+        return {
+            type: "message",
+            text,
+            chatId,
+            threadId: msg.parent_id,
+        };
+    }
+    isCommand(text) {
+        return ["/new", "/sessions", "/switch", "/rm", "/model"].some((cmd) => text.trim().startsWith(cmd));
+    }
+    parseCommand(text) {
+        const trimmed = text.trim();
+        if (trimmed === "/sessions" || trimmed === "/model") {
+            return { command: trimmed.slice(1), args: "" };
+        }
+        if (trimmed.startsWith("/new ")) {
+            return { command: "new", args: trimmed.slice(5).trim() || "默认会话" };
+        }
+        if (trimmed === "/new") {
+            return { command: "new", args: "默认会话" };
+        }
+        if (trimmed.startsWith("/switch ")) {
+            return { command: "switch", args: trimmed.slice(8).trim() };
+        }
+        if (trimmed.startsWith("/rm ")) {
+            return { command: "rm", args: trimmed.slice(4).trim() };
+        }
+        return null;
+    }
+    extractText(content, msgType) {
+        if (msgType === "text") {
+            try {
+                const parsed = JSON.parse(content);
+                return parsed.text ?? "";
+            }
+            catch {
+                return content;
+            }
+        }
+        return "";
+    }
+}

package/dist/src/cards.d.ts

@@ -0,0 +1,6 @@
+import type { SessionInfo } from "./types.js";
+export declare function buildSessionListCard(chatId: string, sessions: SessionInfo[], activeId: string | null): string;
+export declare function buildModelSelectCard(chatId: string, models: Array<{
+    id: string;
+    name: string;
+}>, current: string): string;

package/dist/src/cards.js

@@ -0,0 +1,87 @@
+export function buildSessionListCard(chatId, sessions, activeId) {
+    const header = {
+        title: { tag: "plain_text", content: "Pi 会话管理" },
+        template: "blue",
+    };
+    const elements = [];
+    if (sessions.length === 0) {
+        elements.push({
+            tag: "div",
+            text: { tag: "lark_md", content: "暂无会话" },
+        });
+    }
+    else {
+        for (const sess of sessions) {
+            const isActive = sess.id === activeId;
+            const prefix = isActive ? "▶ " : "";
+            elements.push({
+                tag: "div",
+                text: {
+                    tag: "lark_md",
+                    content: `${prefix}**${sess.name}**  \n\`${sess.id}\``,
+                },
+            });
+            elements.push({ tag: "hr" });
+        }
+        elements.pop(); // remove last hr
+    }
+    elements.push({
+        tag: "action",
+        actions: [
+            {
+                tag: "button",
+                text: { tag: "plain_text", content: "➕ 新建会话" },
+                type: "primary",
+                value: JSON.stringify({ action: "new_session", chat_id: chatId }),
+            },
+            {
+                tag: "button",
+                text: { tag: "plain_text", content: "🔄 切换模型" },
+                value: JSON.stringify({ action: "model_select", chat_id: chatId }),
+            },
+        ],
+    });
+    return JSON.stringify({
+        msg_type: "interactive",
+        card: { header, elements },
+    });
+}
+export function buildModelSelectCard(chatId, models, current) {
+    const header = {
+        title: { tag: "plain_text", content: "选择模型" },
+        template: "blue",
+    };
+    const elements = [];
+    elements.push({
+        tag: "div",
+        text: {
+            tag: "lark_md",
+            content: `当前: **${models.find((m) => m.id === current)?.name ?? current}**`,
+        },
+    });
+    elements.push({ tag: "hr" });
+    for (const model of models) {
+        elements.push({
+            tag: "action",
+            actions: [
+                {
+                    tag: "button",
+                    text: {
+                        tag: "plain_text",
+                        content: model.id === current ? `▶ ${model.name}` : model.name,
+                    },
+                    type: model.id === current ? "primary" : "default",
+                    value: JSON.stringify({
+                        action: "select_model",
+                        chat_id: chatId,
+                        model_id: model.id,
+                    }),
+                },
+            ],
+        });
+    }
+    return JSON.stringify({
+        msg_type: "interactive",
+        card: { header, elements },
+    });
+}

package/dist/src/config.d.ts

@@ -0,0 +1,3 @@
+import type { FeishuImConfig } from "./types.js";
+export declare const DEFAULT_CONFIG: Required<Omit<FeishuImConfig, "model">>;
+export declare function loadConfig(configDir: string): FeishuImConfig;

package/dist/src/config.js

@@ -0,0 +1,28 @@
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+export const DEFAULT_CONFIG = {
+    strategy: "mention",
+    pollInterval: 5,
+    autoStart: false,
+};
+export function loadConfig(configDir) {
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    const configPath = join(configDir, "config.json");
+    if (!existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        return {
+            strategy: raw.strategy ?? DEFAULT_CONFIG.strategy,
+            model: raw.model,
+            pollInterval: raw.pollInterval ?? DEFAULT_CONFIG.pollInterval,
+            autoStart: raw.autoStart ?? DEFAULT_CONFIG.autoStart,
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}

package/dist/src/daemon.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/daemon.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { writeFileSync } from "node:fs";
+import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessionFromServices, getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "./config.js";
+import { SessionRegistry } from "./session-registry.js";
+import { Bot } from "./bot.js";
+import { pollEvents, sendMessage, larkCliAvailable, larkCliConfigured } from "./poller.js";
+import { buildSessionListCard, buildModelSelectCard } from "./cards.js";
+const FEISHU_IM_DIR = join(homedir(), ".pi", "agent", "feishu-im");
+const PID_FILE = join(FEISHU_IM_DIR, "daemon.pid");
+function getAvailableModels() {
+    return [
+        { id: "anthropic/claude-opus-4-5", name: "Claude Opus 4.5" },
+        { id: "anthropic/claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
+        { id: "anthropic/claude-haiku-3-5", name: "Claude Haiku 3.5" },
+    ];
+}
+async function handleCommand(registry, command, args, chatId, currentModel) {
+    switch (command) {
+        case "new": {
+            const session = registry.createSession(chatId, args || "未命名会话");
+            await sendMessage(JSON.stringify({ text: `已创建会话: **${session.name}** (\`${session.id}\`)` }), chatId);
+            return;
+        }
+        case "sessions": {
+            const chat = registry.getChatSessions(chatId);
+            if (!chat) {
+                await sendMessage(JSON.stringify({ text: "暂无会话" }), chatId);
+                return;
+            }
+            const card = buildSessionListCard(chatId, chat.sessions, chat.active);
+            await sendMessage(card, chatId, "interactive");
+            return;
+        }
+        case "switch": {
+            const switched = registry.switchSession(chatId, args);
+            if (switched) {
+                const session = registry
+                    .getChatSessions(chatId)
+                    ?.sessions.find((s) => s.id === args);
+                await sendMessage(JSON.stringify({ text: `已切换到: **${session?.name ?? args}**` }), chatId);
+            }
+            else {
+                await sendMessage(JSON.stringify({ text: `未找到会话: \`${args}\`` }), chatId);
+            }
+            return;
+        }
+        case "rm": {
+            const deleted = registry.deleteSession(chatId, args);
+            if (deleted) {
+                await sendMessage(JSON.stringify({ text: `已删除会话: \`${args}\`` }), chatId);
+            }
+            else {
+                await sendMessage(JSON.stringify({ text: `删除失败，未找到会话: \`${args}\`` }), chatId);
+            }
+            return;
+        }
+        case "model": {
+            const models = getAvailableModels();
+            const card = buildModelSelectCard(chatId, models, currentModel);
+            await sendMessage(card, chatId, "interactive");
+            return;
+        }
+    }
+}
+async function runDaemon() {
+    if (!(await larkCliAvailable())) {
+        console.error("lark-cli 未安装。运行: npm i -g lark-cli");
+        process.exit(1);
+    }
+    if (!(await larkCliConfigured())) {
+        console.error("lark-cli 未配置。运行: lark-cli config init");
+        process.exit(1);
+    }
+    const config = loadConfig(FEISHU_IM_DIR);
+    const registry = new SessionRegistry(FEISHU_IM_DIR);
+    const bot = new Bot(registry, config.strategy);
+    writeFileSync(PID_FILE, String(process.pid));
+    const cwd = process.cwd();
+    const agentDir = getAgentDir();
+    const runtime = await createAgentSessionRuntime(async ({ cwd, sessionManager, sessionStartEvent }) => {
+        const services = await createAgentSessionServices({ cwd });
+        return {
+            ...(await createAgentSessionFromServices({
+                services,
+                sessionManager,
+                sessionStartEvent,
+            })),
+            services,
+            diagnostics: services.diagnostics,
+        };
+    }, {
+        cwd,
+        agentDir,
+        sessionManager: SessionManager.create(cwd),
+    });
+    console.log("[feishu-im] Daemon started, PID:", process.pid);
+    console.log("[feishu-im] Strategy:", config.strategy);
+    const pollIntervalMs = config.pollInterval * 1000;
+    while (true) {
+        try {
+            const result = await pollEvents();
+            if (result.error) {
+                console.error("[feishu-im] Poll error:", result.error);
+                await new Promise((r) => setTimeout(r, pollIntervalMs));
+                continue;
+            }
+            for (const event of result.events) {
+                const route = bot.route(event);
+                if (route.type === "skip")
+                    continue;
+                if (route.type === "command") {
+                    await handleCommand(registry, route.command, route.args, route.chatId, config.model ?? "claude-sonnet");
+                    continue;
+                }
+                const sessionInfo = registry.ensureSession(route.chatId);
+                const sessionPath = join(agentDir, "sessions", `${sessionInfo.id}.jsonl`);
+                try {
+                    const sessionManager = SessionManager.open(sessionPath);
+                    const { session: agentSession } = await createAgentSessionFromServices({
+                        services: runtime.services,
+                        sessionManager,
+                        sessionStartEvent: undefined,
+                    });
+                    agentSession.subscribe((agentEvent) => {
+                        if (agentEvent.type === "message_update" &&
+                            agentEvent.assistantMessageEvent.type === "text_delta") {
+                            // Streaming response handling — placeholder for future enhancement
+                        }
+                    });
+                    await agentSession.prompt(route.text);
+                    agentSession.dispose();
+                }
+                catch (err) {
+                    console.error("[feishu-im] Agent error:", err instanceof Error ? err.message : String(err));
+                    await sendMessage(JSON.stringify({ text: "处理消息时出错，请重试。" }), route.chatId);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[feishu-im] Loop error:", err);
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+}
+runDaemon().catch((err) => {
+    console.error("[feishu-im] Fatal error:", err);
+    process.exit(1);
+});

package/dist/src/extension.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function (pi: ExtensionAPI): void;

package/dist/src/extension.js

@@ -0,0 +1,124 @@
+import { spawn, execSync } from "node:child_process";
+import { readFileSync, unlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+const FEISHU_IM_DIR = join(homedir(), ".pi", "agent", "feishu-im");
+const PID_FILE = join(FEISHU_IM_DIR, "daemon.pid");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function isRunning() {
+    try {
+        const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim());
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function getPid() {
+    try {
+        return parseInt(readFileSync(PID_FILE, "utf-8").trim());
+    }
+    catch {
+        return null;
+    }
+}
+async function handleStart(ctx) {
+    if (isRunning()) {
+        ctx.ui.notify(`飞书 IM 守护进程已在运行 (PID: ${getPid()})`, "info");
+        return;
+    }
+    try {
+        execSync("which lark-cli", { stdio: "ignore" });
+    }
+    catch {
+        ctx.ui.notify("lark-cli 未安装。请运行: npm i -g lark-cli", "error");
+        return;
+    }
+    try {
+        execSync("lark-cli config show", { stdio: "pipe", timeout: 5000 });
+    }
+    catch {
+        ctx.ui.notify("lark-cli 未配置。请运行: lark-cli config init", "error");
+        return;
+    }
+    const daemonPath = join(__dirname, "daemon.ts");
+    const child = spawn("node", ["--import", "jiti/register", daemonPath], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, PI_FEISHU_IM: "1" },
+    });
+    child.unref();
+    await new Promise((r) => setTimeout(r, 2000));
+    if (isRunning()) {
+        ctx.ui.notify(`飞书 IM 守护进程已启动 (PID: ${getPid()})`, "info");
+    }
+    else {
+        ctx.ui.notify("飞书 IM 守护进程启动失败，请检查日志", "error");
+    }
+}
+function handleStop(ctx) {
+    const pid = getPid();
+    if (!pid || !isRunning()) {
+        ctx.ui.notify("飞书 IM 守护进程未在运行", "info");
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        try {
+            unlinkSync(PID_FILE);
+        }
+        catch { }
+        ctx.ui.notify("飞书 IM 守护进程已停止", "info");
+    }
+    catch {
+        ctx.ui.notify("停止守护进程失败", "error");
+    }
+}
+function handleStatus(ctx) {
+    if (isRunning()) {
+        ctx.ui.notify(`飞书 IM 守护进程运行中 (PID: ${getPid()})`, "info");
+    }
+    else {
+        ctx.ui.notify("飞书 IM 守护进程未在运行", "info");
+    }
+}
+export default function (pi) {
+    pi.registerCommand("feishu-im", {
+        description: "管理飞书 IM 守护进程 (start|stop|status|restart)",
+        handler: async (args, ctx) => {
+            const sub = args?.trim() || "start";
+            switch (sub) {
+                case "start":
+                    await handleStart(ctx);
+                    break;
+                case "stop":
+                    handleStop(ctx);
+                    break;
+                case "status":
+                    handleStatus(ctx);
+                    break;
+                case "restart":
+                    handleStop(ctx);
+                    await new Promise((r) => setTimeout(r, 1000));
+                    await handleStart(ctx);
+                    break;
+                default:
+                    ctx.ui.notify("用法: /feishu-im [start|stop|status|restart]", "error");
+            }
+        },
+    });
+    pi.registerFlag("feishu-im", {
+        description: "启动时自动启动飞书 IM 守护进程",
+        handler: async (ctx) => {
+            await handleStart(ctx);
+        },
+    });
+}

package/dist/src/poller.d.ts

@@ -0,0 +1,33 @@
+export interface FeishuEvent {
+    type: string;
+    event?: {
+        message?: {
+            chat_id: string;
+            message_id: string;
+            parent_id?: string;
+            message_type: string;
+            content: string;
+            mentions?: Array<{
+                key: string;
+                name: string;
+            }>;
+        };
+        sender?: {
+            sender_id: {
+                open_id: string;
+                user_id?: string;
+            };
+            sender_type: string;
+        };
+    };
+    raw: unknown;
+}
+export interface PollResult {
+    events: FeishuEvent[];
+    error: string | null;
+}
+export declare function pollEvents(): Promise<PollResult>;
+export declare function larkCliAvailable(): Promise<boolean>;
+export declare function larkCliConfigured(): Promise<boolean>;
+export declare function sendMessage(content: string, chatId: string, msgType?: "text" | "interactive"): Promise<boolean>;
+export declare function downloadResource(messageId: string, fileKey: string, fileType: string, outputPath: string): Promise<boolean>;