pi-feishu-cli 0.1.0

package/src/daemon.ts

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { writeFileSync } from "node:fs";
+import {
+  AuthStorage,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  createAgentSessionFromServices,
+  getAgentDir,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+  DefaultResourceLoader,
+  type CreateAgentSessionRuntimeFactory,
+} 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";
+import type { FeishuImConfig } from "./types.js";
+
+const FEISHU_IM_DIR = join(homedir(), ".pi", "agent", "feishu-im");
+const PID_FILE = join(FEISHU_IM_DIR, "daemon.pid");
+
+function getAvailableModels(): Array<{ id: string; name: string }> {
+  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: SessionRegistry,
+  command: string,
+  args: string,
+  chatId: string,
+  currentModel: string
+): Promise<void> {
+  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: FeishuImConfig = 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/src/extension.ts

@@ -0,0 +1,132 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+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(): boolean {
+  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(): number | null {
+  try {
+    return parseInt(readFileSync(PID_FILE, "utf-8").trim());
+  } catch {
+    return null;
+  }
+}
+
+async function handleStart(ctx: { ui: { notify: (msg: string, type: string) => void } }): Promise<void> {
+  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: { ui: { notify: (msg: string, type: string) => void } }): void {
+  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: { ui: { notify: (msg: string, type: string) => void } }): void {
+  if (isRunning()) {
+    ctx.ui.notify(`飞书 IM 守护进程运行中 (PID: ${getPid()})`, "info");
+  } else {
+    ctx.ui.notify("飞书 IM 守护进程未在运行", "info");
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  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/src/poller.ts

@@ -0,0 +1,135 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+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 async function pollEvents(): Promise<PollResult> {
+  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: FeishuEvent[] = [];
+
+    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: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { events: [], error: message };
+  }
+}
+
+export async function larkCliAvailable(): Promise<boolean> {
+  try {
+    await execFileAsync("lark-cli", ["--help"], { timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function larkCliConfigured(): Promise<boolean> {
+  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: string,
+  chatId: string,
+  msgType: "text" | "interactive" = "text"
+): Promise<boolean> {
+  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: string,
+  fileKey: string,
+  fileType: string,
+  outputPath: string
+): Promise<boolean> {
+  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/src/renderer.ts

@@ -0,0 +1,47 @@
+export const MESSAGE_MAX_LENGTH = 30_000;
+
+export interface FeishuTextMessage {
+  type: "text";
+  text: string;
+}
+
+export function renderText(text: string): FeishuTextMessage[] {
+  const parts = splitLongMessage(text);
+  return parts.map((part) => ({ type: "text", text: part }));
+}
+
+export function renderCodeBlock(
+  code: string,
+  lang?: string
+): FeishuTextMessage[] {
+  const header = lang ? `\`\`\`${lang}\n` : "```\n";
+  const text = header + code + "\n```";
+  return renderText(text);
+}
+
+export function splitLongMessage(text: string): string[] {
+  if (text.length <= MESSAGE_MAX_LENGTH) {
+    return [text];
+  }
+
+  const parts: string[] = [];
+  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/src/session-registry.ts

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { Registry, ChatSessions, SessionInfo } from "./types.js";
+
+const REGISTRY_FILE = "registry.json";
+
+export class SessionRegistry {
+  private registry: Registry;
+  private registryPath: string;
+
+  constructor(registryDir: string) {
+    this.registryPath = join(registryDir, REGISTRY_FILE);
+    this.registry = this.load();
+  }
+
+  private load(): Registry {
+    if (!existsSync(this.registryPath)) return {};
+    try {
+      return JSON.parse(readFileSync(this.registryPath, "utf-8"));
+    } catch {
+      return {};
+    }
+  }
+
+  flush(): void {
+    const dir = this.registryPath.replace(/\/[^/]+$/, "");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(this.registryPath, JSON.stringify(this.registry, null, 2));
+  }
+
+  private getOrCreateChat(chatId: string): ChatSessions {
+    if (!this.registry[chatId]) {
+      this.registry[chatId] = { sessions: [], active: null };
+    }
+    return this.registry[chatId];
+  }
+
+  getChatSessions(chatId: string): ChatSessions | null {
+    return this.registry[chatId] ?? null;
+  }
+
+  getActiveSessionId(chatId: string): string | null {
+    return this.registry[chatId]?.active ?? null;
+  }
+
+  ensureSession(chatId: string): SessionInfo {
+    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: string, name: string): SessionInfo {
+    const chat = this.getOrCreateChat(chatId);
+    const session: SessionInfo = {
+      id: randomUUID(),
+      name,
+      createdAt: Date.now(),
+    };
+    chat.sessions.push(session);
+    chat.active = session.id;
+    this.flush();
+    return session;
+  }
+
+  switchSession(chatId: string, sessionId: string): boolean {
+    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: string, sessionId: string): boolean {
+    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/src/types.ts

@@ -0,0 +1,29 @@
+export interface FeishuImConfig {
+  strategy: "open" | "mention";
+  model?: string;
+  pollInterval: number;
+  autoStart?: boolean;
+}
+
+export interface SessionInfo {
+  id: string;
+  name: string;
+  createdAt: number; // unix ms timestamp
+}
+
+export interface ChatSessions {
+  sessions: SessionInfo[];
+  active: string | null; // session id, or null if none active
+}
+
+export interface Registry {
+  [chatId: string]: ChatSessions;
+}
+
+export interface DaemonStatus {
+  running: boolean;
+  pid: number | null;
+  uptime: number | null; // seconds
+  sessionCount: number;
+  chatCount: number;
+}