光有心法不够，工作流得先能自己跑起来

// feishu-grok-bridge.ts
// 通过 ACP 协议的 stdio 通道，把飞书消息转发给 Grok agent，再把结果推回飞书

import { spawn, ChildProcessWithoutNullStreams } from 'node:child_process';
import { createInterface } from 'node:readline';

interface FeishuMessage {
  chatId: string;
  userId: string;
  content: string;
}

interface AcpResponse {
  type: 'partial' | 'final' | 'error';
  content: string;
}

class GrokFeishuBridge {
  private agentProcess: ChildProcessWithoutNullStreams | null = null;
  private readonly agentCommand = 'grok';
  private readonly agentArgs = ['agent', '--acp'];

  private startAgentProcess(): ChildProcessWithoutNullStreams {
    const proc = spawn(this.agentCommand, this.agentArgs, {
      stdio: ['pipe', 'pipe', 'pipe'],
    });

    // agent 进程的错误日志单独收集，方便排查连不上的问题
    proc.stderr.on('data', (chunk: Buffer) => {
      console.error(`[grok-agent stderr] ${chunk.toString()}`);
    });

    // 进程意外退出时清空引用，下次消息来了会重新拉起一个新进程
    proc.on('exit', (code, signal) => {
      console.warn(`grok agent 进程退出，code=${code} signal=${signal}`);
      this.agentProcess = null;
    });

    return proc;
  }

  async handleFeishuMessage(message: FeishuMessage): Promise<string> {
    if (!message.content?.trim()) {
      throw new Error('收到空消息，已忽略');
    }

    if (!this.agentProcess) {
      this.agentProcess = this.startAgentProcess();
    }

    const proc = this.agentProcess;
    const rl = createInterface({ input: proc.stdout });

    return new Promise((resolve, reject) => {
      // agent 偶尔会卡住不返回，必须有超时兜底，否则整条链路会一直挂着
      const timeout = setTimeout(() => {
        rl.close();
        reject(new Error('等待 agent 响应超时，任务已终止'));
      }, 120_000);

      let finalText = '';

      rl.on('line', (line: string) => {
        try {
          const response: AcpResponse = JSON.parse(line);
          if (response.type === 'partial') {
            finalText += response.content;
          } else if (response.type === 'final') {
            clearTimeout(timeout);
            rl.close();
            resolve(finalText + response.content);
          } else if (response.type === 'error') {
            clearTimeout(timeout);
            rl.close();
            reject(new Error(`agent 返回错误：${response.content}`));
          }
        } catch {
          // 输出里偶尔夹杂非 JSON 的调试信息，跳过即可，不能让一行脏数据打断整个会话
          console.warn('无法解析的一行输出，已跳过');
        }
      });

      const payload = JSON.stringify({
        chatId: message.chatId,
        userId: message.userId,
        text: message.content,
      });

      proc.stdin.write(`${payload}\n`, (err) => {
        if (err) {
          clearTimeout(timeout);
          reject(new Error(`写入 agent 失败：${err.message}`));
        }
      });
    });
  }
}

export const bridge = new GrokFeishuBridge();