pi-feishu-cli 0.1.0

package/dist/src/poller.js

@@ -0,0 +1,94 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function pollEvents() {
+    try {
+        const { stdout } = await execFileAsync("lark-cli", [
+            "im",
+            "+events-poll",
+            "--as",
+            "bot",
+        ], { timeout: 30_000 });
+        const lines = stdout.trim().split("\n").filter(Boolean);
+        const events = [];
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                events.push({
+                    type: raw.type ?? "unknown",
+                    event: raw.event,
+                    raw,
+                });
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return { events, error: null };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { events: [], error: message };
+    }
+}
+export async function larkCliAvailable() {
+    try {
+        await execFileAsync("lark-cli", ["--help"], { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function larkCliConfigured() {
+    try {
+        const { stdout } = await execFileAsync("lark-cli", [
+            "config",
+            "show",
+        ], { timeout: 5000 });
+        const config = JSON.parse(stdout);
+        return !!(config.appId && config.appSecret);
+    }
+    catch {
+        return false;
+    }
+}
+export async function sendMessage(content, chatId, msgType = "text") {
+    try {
+        const body = JSON.stringify({
+            receive_id: chatId,
+            msg_type: msgType,
+            content,
+        });
+        await execFileAsync("lark-cli", [
+            "im",
+            "messages",
+            "create",
+            "--data",
+            body,
+            "--as",
+            "bot",
+        ], { timeout: 10_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function downloadResource(messageId, fileKey, fileType, outputPath) {
+    try {
+        await execFileAsync("lark-cli", [
+            "im",
+            "+messages-resources-download",
+            "--message-id", messageId,
+            "--file-key", fileKey,
+            "--file-type", fileType,
+            "--output", outputPath,
+            "--as", "bot",
+        ], { timeout: 30_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/renderer.d.ts

@@ -0,0 +1,8 @@
+export declare const MESSAGE_MAX_LENGTH = 30000;
+export interface FeishuTextMessage {
+    type: "text";
+    text: string;
+}
+export declare function renderText(text: string): FeishuTextMessage[];
+export declare function renderCodeBlock(code: string, lang?: string): FeishuTextMessage[];
+export declare function splitLongMessage(text: string): string[];

package/dist/src/renderer.js

@@ -0,0 +1,31 @@
+export const MESSAGE_MAX_LENGTH = 30_000;
+export function renderText(text) {
+    const parts = splitLongMessage(text);
+    return parts.map((part) => ({ type: "text", text: part }));
+}
+export function renderCodeBlock(code, lang) {
+    const header = lang ? `\`\`\`${lang}\n` : "```\n";
+    const text = header + code + "\n```";
+    return renderText(text);
+}
+export function splitLongMessage(text) {
+    if (text.length <= MESSAGE_MAX_LENGTH) {
+        return [text];
+    }
+    const parts = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= MESSAGE_MAX_LENGTH) {
+            parts.push(remaining);
+            break;
+        }
+        let cutPoint = MESSAGE_MAX_LENGTH;
+        const newlineIdx = remaining.lastIndexOf("\n", MESSAGE_MAX_LENGTH);
+        if (newlineIdx > MESSAGE_MAX_LENGTH * 0.5) {
+            cutPoint = newlineIdx;
+        }
+        parts.push(remaining.slice(0, cutPoint));
+        remaining = remaining.slice(cutPoint);
+    }
+    return parts;
+}

package/dist/src/session-registry.d.ts

@@ -0,0 +1,15 @@
+import type { ChatSessions, SessionInfo } from "./types.js";
+export declare class SessionRegistry {
+    private registry;
+    private registryPath;
+    constructor(registryDir: string);
+    private load;
+    flush(): void;
+    private getOrCreateChat;
+    getChatSessions(chatId: string): ChatSessions | null;
+    getActiveSessionId(chatId: string): string | null;
+    ensureSession(chatId: string): SessionInfo;
+    createSession(chatId: string, name: string): SessionInfo;
+    switchSession(chatId: string, sessionId: string): boolean;
+    deleteSession(chatId: string, sessionId: string): boolean;
+}

package/dist/src/session-registry.js

@@ -0,0 +1,82 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+const REGISTRY_FILE = "registry.json";
+export class SessionRegistry {
+    registry;
+    registryPath;
+    constructor(registryDir) {
+        this.registryPath = join(registryDir, REGISTRY_FILE);
+        this.registry = this.load();
+    }
+    load() {
+        if (!existsSync(this.registryPath))
+            return {};
+        try {
+            return JSON.parse(readFileSync(this.registryPath, "utf-8"));
+        }
+        catch {
+            return {};
+        }
+    }
+    flush() {
+        const dir = this.registryPath.replace(/\/[^/]+$/, "");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(this.registryPath, JSON.stringify(this.registry, null, 2));
+    }
+    getOrCreateChat(chatId) {
+        if (!this.registry[chatId]) {
+            this.registry[chatId] = { sessions: [], active: null };
+        }
+        return this.registry[chatId];
+    }
+    getChatSessions(chatId) {
+        return this.registry[chatId] ?? null;
+    }
+    getActiveSessionId(chatId) {
+        return this.registry[chatId]?.active ?? null;
+    }
+    ensureSession(chatId) {
+        const chat = this.getOrCreateChat(chatId);
+        if (chat.active && chat.sessions.find((s) => s.id === chat.active)) {
+            return chat.sessions.find((s) => s.id === chat.active);
+        }
+        return this.createSession(chatId, "默认会话");
+    }
+    createSession(chatId, name) {
+        const chat = this.getOrCreateChat(chatId);
+        const session = {
+            id: randomUUID(),
+            name,
+            createdAt: Date.now(),
+        };
+        chat.sessions.push(session);
+        chat.active = session.id;
+        this.flush();
+        return session;
+    }
+    switchSession(chatId, sessionId) {
+        const chat = this.registry[chatId];
+        if (!chat || !chat.sessions.find((s) => s.id === sessionId)) {
+            return false;
+        }
+        chat.active = sessionId;
+        this.flush();
+        return true;
+    }
+    deleteSession(chatId, sessionId) {
+        const chat = this.registry[chatId];
+        if (!chat)
+            return false;
+        const idx = chat.sessions.findIndex((s) => s.id === sessionId);
+        if (idx === -1)
+            return false;
+        chat.sessions.splice(idx, 1);
+        if (chat.active === sessionId) {
+            chat.active = chat.sessions.length > 0 ? chat.sessions[0].id : null;
+        }
+        this.flush();
+        return true;
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,25 @@
+export interface FeishuImConfig {
+    strategy: "open" | "mention";
+    model?: string;
+    pollInterval: number;
+    autoStart?: boolean;
+}
+export interface SessionInfo {
+    id: string;
+    name: string;
+    createdAt: number;
+}
+export interface ChatSessions {
+    sessions: SessionInfo[];
+    active: string | null;
+}
+export interface Registry {
+    [chatId: string]: ChatSessions;
+}
+export interface DaemonStatus {
+    running: boolean;
+    pid: number | null;
+    uptime: number | null;
+    sessionCount: number;
+    chatCount: number;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tests/bot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/bot.test.js

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { Bot } from "../src/bot.js";
+import { SessionRegistry } from "../src/session-registry.js";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+function makeMsgEvent(chatId, text, mentions, threadId) {
+    return {
+        type: "im.message.receive_v1",
+        event: {
+            message: {
+                chat_id: chatId,
+                message_id: "om_" + Math.random().toString(36).slice(2),
+                parent_id: threadId,
+                message_type: "text",
+                content: JSON.stringify({ text }),
+                mentions,
+            },
+            sender: {
+                sender_id: { open_id: "ou_test" },
+                sender_type: "user",
+            },
+        },
+        raw: {},
+    };
+}
+describe("Bot routing", () => {
+    let tmpDir;
+    let registry;
+    let bot;
+    beforeEach(() => {
+        tmpDir = join(tmpdir(), "pi-feishu-cli-test-bot-" + Date.now());
+        if (!existsSync(tmpDir))
+            mkdirSync(tmpDir, { recursive: true });
+        registry = new SessionRegistry(tmpDir);
+        bot = new Bot(registry, "mention");
+    });
+    it("detects /new command", () => {
+        const event = makeMsgEvent("oc_chat1", "/new 我的新会话");
+        const result = bot.route(event);
+        expect(result.type).toBe("command");
+        if (result.type === "command") {
+            expect(result.command).toBe("new");
+        }
+    });
+    it("detects /sessions command", () => {
+        const event = makeMsgEvent("oc_chat1", "/sessions");
+        const result = bot.route(event);
+        expect(result.type).toBe("command");
+        if (result.type === "command") {
+            expect(result.command).toBe("sessions");
+        }
+    });
+    it("detects /switch command", () => {
+        const event = makeMsgEvent("oc_chat1", "/switch sess_123");
+        const result = bot.route(event);
+        expect(result.type).toBe("command");
+        if (result.type === "command") {
+            expect(result.command).toBe("switch");
+        }
+    });
+    it("detects /rm command", () => {
+        const event = makeMsgEvent("oc_chat1", "/rm sess_123");
+        const result = bot.route(event);
+        expect(result.type).toBe("command");
+        if (result.type === "command") {
+            expect(result.command).toBe("rm");
+        }
+    });
+    it("detects /model command", () => {
+        const event = makeMsgEvent("oc_chat1", "/model");
+        const result = bot.route(event);
+        expect(result.type).toBe("command");
+        if (result.type === "command") {
+            expect(result.command).toBe("model");
+        }
+    });
+    it("routes regular text as message in mention mode", () => {
+        const event = makeMsgEvent("oc_chat1", "你好");
+        const result = bot.route(event);
+        expect(result.type).toBe("message");
+    });
+    it("routes all messages in open mode", () => {
+        const openBot = new Bot(registry, "open");
+        const event = makeMsgEvent("oc_chat1", "你好");
+        const result = openBot.route(event);
+        expect(result.type).toBe("message");
+    });
+});

package/dist/tests/cards.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cards.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { buildSessionListCard, buildModelSelectCard, } from "../src/cards.js";
+describe("buildSessionListCard", () => {
+    const sessions = [
+        { id: "abc", name: "修 bug", createdAt: 1700000000 },
+        { id: "def", name: "新功能", createdAt: 1700000100 },
+    ];
+    it("builds card with session entries", () => {
+        const card = buildSessionListCard("oc_chat1", sessions, "abc");
+        const json = JSON.parse(card);
+        expect(json.card.header).toBeDefined();
+        expect(json.card.elements).toBeDefined();
+        expect(JSON.stringify(json).length).toBeGreaterThan(100);
+    });
+    it("shows empty state when no sessions", () => {
+        const card = buildSessionListCard("oc_chat1", [], null);
+        const json = JSON.parse(card);
+        expect(JSON.stringify(json)).toContain("暂无会话");
+    });
+    it("marks active session", () => {
+        const card = buildSessionListCard("oc_chat1", sessions, "def");
+        const json = JSON.parse(card);
+        const str = JSON.stringify(json);
+        expect(str).toContain("def");
+    });
+});
+describe("buildModelSelectCard", () => {
+    it("builds card with model options", () => {
+        const models = [
+            { id: "claude-sonnet", name: "Claude Sonnet" },
+            { id: "gpt-4o", name: "GPT-4o" },
+        ];
+        const card = buildModelSelectCard("oc_chat1", models, "claude-sonnet");
+        const json = JSON.parse(card);
+        expect(json.card.header).toBeDefined();
+        expect(JSON.stringify(json)).toContain("Claude Sonnet");
+        expect(JSON.stringify(json)).toContain("GPT-4o");
+    });
+});

package/dist/tests/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/config.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { writeFileSync, unlinkSync, existsSync, mkdirSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { loadConfig, DEFAULT_CONFIG } from "../src/config.js";
+describe("loadConfig", () => {
+    const tmpDir = join(tmpdir(), "pi-feishu-cli-test-config");
+    const configPath = join(tmpDir, "config.json");
+    beforeEach(() => {
+        if (!existsSync(tmpDir))
+            mkdirSync(tmpDir, { recursive: true });
+    });
+    afterEach(() => {
+        try {
+            unlinkSync(configPath);
+        }
+        catch { }
+        try {
+            rmdirSync(tmpDir);
+        }
+        catch { }
+    });
+    it("returns defaults when no config file exists", () => {
+        const config = loadConfig(tmpDir);
+        expect(config.strategy).toBe(DEFAULT_CONFIG.strategy);
+        expect(config.pollInterval).toBe(DEFAULT_CONFIG.pollInterval);
+        expect(config.model).toBeUndefined();
+        expect(config.autoStart).toBe(DEFAULT_CONFIG.autoStart);
+    });
+    it("loads and merges partial config", () => {
+        writeFileSync(configPath, JSON.stringify({ strategy: "open", pollInterval: 10 }));
+        const config = loadConfig(tmpDir);
+        expect(config.strategy).toBe("open");
+        expect(config.pollInterval).toBe(10);
+    });
+    it("loads full config", () => {
+        writeFileSync(configPath, JSON.stringify({
+            strategy: "mention",
+            model: "anthropic/claude-sonnet",
+            pollInterval: 3,
+            autoStart: true,
+        }));
+        const config = loadConfig(tmpDir);
+        expect(config.strategy).toBe("mention");
+        expect(config.model).toBe("anthropic/claude-sonnet");
+        expect(config.pollInterval).toBe(3);
+        expect(config.autoStart).toBe(true);
+    });
+    it("ignores extra unknown fields", () => {
+        writeFileSync(configPath, JSON.stringify({
+            strategy: "open",
+            pollInterval: 5,
+            unknownField: "should be ignored",
+        }));
+        const config = loadConfig(tmpDir);
+        expect(config.strategy).toBe("open");
+        expect(config.unknownField).toBeUndefined();
+    });
+});

package/dist/tests/renderer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/renderer.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import { renderText, renderCodeBlock, splitLongMessage, MESSAGE_MAX_LENGTH, } from "../src/renderer.js";
+describe("renderText", () => {
+    it("returns plain text unchanged", () => {
+        const result = renderText("hello world");
+        expect(result).toEqual([{ type: "text", text: "hello world" }]);
+    });
+    it("splits on large text", () => {
+        const long = "x".repeat(MESSAGE_MAX_LENGTH + 100);
+        const result = renderText(long);
+        expect(result.length).toBe(2);
+        expect(result[0].type).toBe("text");
+        expect(result[1].type).toBe("text");
+    });
+    it("handles empty text", () => {
+        const result = renderText("");
+        expect(result).toEqual([{ type: "text", text: "" }]);
+    });
+});
+describe("renderCodeBlock", () => {
+    it("wraps code in code block markers", () => {
+        const result = renderCodeBlock("console.log(1)", "javascript");
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "```javascript\nconsole.log(1)\n```",
+            },
+        ]);
+    });
+    it("uses no language when lang not provided", () => {
+        const result = renderCodeBlock("print(1)");
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "```\nprint(1)\n```",
+            },
+        ]);
+    });
+});
+describe("splitLongMessage", () => {
+    it("does not split short message", () => {
+        const result = splitLongMessage("short text");
+        expect(result).toEqual(["short text"]);
+    });
+    it("splits long message at newlines", () => {
+        const part1 = "a".repeat(Math.floor(MESSAGE_MAX_LENGTH * 0.6));
+        const part2 = "b".repeat(Math.floor(MESSAGE_MAX_LENGTH * 0.6));
+        const text = part1 + "\n" + part2;
+        const result = splitLongMessage(text);
+        expect(result.length).toBeGreaterThanOrEqual(2);
+        const combined = result.join("");
+        expect(combined).toBe(text);
+    });
+    it("splits uniformly when no newlines", () => {
+        const long = "x".repeat(MESSAGE_MAX_LENGTH + 500);
+        const result = splitLongMessage(long);
+        expect(result.length).toBeGreaterThanOrEqual(2);
+        const combined = result.join("");
+        expect(combined).toBe(long);
+    });
+});

package/dist/tests/session-registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/session-registry.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, mkdirSync, unlinkSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { SessionRegistry } from "../src/session-registry.js";
+describe("SessionRegistry", () => {
+    const tmpDir = join(tmpdir(), "pi-feishu-cli-test-registry");
+    const registryDir = join(tmpDir, "feishu-im");
+    beforeEach(() => {
+        if (!existsSync(registryDir))
+            mkdirSync(registryDir, { recursive: true });
+    });
+    afterEach(() => {
+        try {
+            unlinkSync(join(registryDir, "registry.json"));
+        }
+        catch { }
+        try {
+            rmdirSync(registryDir);
+        }
+        catch { }
+        try {
+            rmdirSync(tmpDir);
+        }
+        catch { }
+    });
+    it("creates a new session for a new chat", () => {
+        const reg = new SessionRegistry(registryDir);
+        const session = reg.ensureSession("oc_chat1");
+        expect(session.name).toBe("默认会话");
+        expect(session.id).toBeDefined();
+        const data = reg.getChatSessions("oc_chat1");
+        expect(data.sessions).toHaveLength(1);
+        expect(data.active).toBe(session.id);
+    });
+    it("reuses active session on subsequent calls", () => {
+        const reg = new SessionRegistry(registryDir);
+        const s1 = reg.ensureSession("oc_chat1");
+        const s2 = reg.ensureSession("oc_chat1");
+        expect(s2.id).toBe(s1.id);
+        const data = reg.getChatSessions("oc_chat1");
+        expect(data.sessions).toHaveLength(1);
+    });
+    it("creates a new session via command", () => {
+        const reg = new SessionRegistry(registryDir);
+        reg.ensureSession("oc_chat1");
+        const s2 = reg.createSession("oc_chat1", "新功能开发");
+        expect(s2.name).toBe("新功能开发");
+        const data = reg.getChatSessions("oc_chat1");
+        expect(data.sessions).toHaveLength(2);
+        expect(data.active).toBe(s2.id);
+    });
+    it("switches active session", () => {
+        const reg = new SessionRegistry(registryDir);
+        const s1 = reg.ensureSession("oc_chat1");
+        const s2 = reg.createSession("oc_chat1", "test2");
+        expect(reg.getActiveSessionId("oc_chat1")).toBe(s2.id);
+        reg.switchSession("oc_chat1", s1.id);
+        expect(reg.getActiveSessionId("oc_chat1")).toBe(s1.id);
+    });
+    it("deletes a session", () => {
+        const reg = new SessionRegistry(registryDir);
+        const s1 = reg.ensureSession("oc_chat1");
+        const s2 = reg.createSession("oc_chat1", "to-delete");
+        reg.deleteSession("oc_chat1", s2.id);
+        const data = reg.getChatSessions("oc_chat1");
+        expect(data.sessions).toHaveLength(1);
+        expect(data.sessions[0].id).toBe(s1.id);
+    });
+    it("deleting active session switches to another", () => {
+        const reg = new SessionRegistry(registryDir);
+        const s1 = reg.ensureSession("oc_chat1");
+        reg.createSession("oc_chat1", "test2");
+        reg.deleteSession("oc_chat1", reg.getActiveSessionId("oc_chat1"));
+        expect(reg.getActiveSessionId("oc_chat1")).toBe(s1.id);
+    });
+    it("persists and loads registry", () => {
+        const reg1 = new SessionRegistry(registryDir);
+        const s1 = reg1.ensureSession("oc_chat1");
+        reg1.createSession("oc_chat1", "second");
+        reg1.flush();
+        const reg2 = new SessionRegistry(registryDir);
+        const data = reg2.getChatSessions("oc_chat1");
+        expect(data.sessions).toHaveLength(2);
+        expect(data.active).toBeDefined();
+    });
+    it("returns null for unknown chat", () => {
+        const reg = new SessionRegistry(registryDir);
+        expect(reg.getChatSessions("nonexistent")).toBeNull();
+        expect(reg.getActiveSessionId("nonexistent")).toBeNull();
+    });
+});

package/dist/tests/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/types.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+describe("type definitions", () => {
+    it("Registry shape", () => {
+        const registry = {
+            "oc_xxx": {
+                sessions: [
+                    { id: "sess_1", name: "修 bug", createdAt: 1700000000 },
+                ],
+                active: "sess_1",
+            },
+        };
+        expect(registry["oc_xxx"].sessions).toHaveLength(1);
+        expect(registry["oc_xxx"].active).toBe("sess_1");
+    });
+    it("FeishuImConfig defaults", () => {
+        const config = { strategy: "mention", pollInterval: 5 };
+        expect(config.strategy).toBe("mention");
+        expect(config.autoStart).toBeUndefined();
+    });
+    it("SessionInfo fields", () => {
+        const info = { id: "abc", name: "test", createdAt: 123 };
+        expect(info.id).toBe("abc");
+        expect(info.name).toBe("test");
+        expect(info.createdAt).toBe(123);
+    });
+    it("ChatSessions active can be null", () => {
+        const cs = { sessions: [], active: null };
+        expect(cs.active).toBeNull();
+    });
+});