glab-agent 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glab-agent",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "description": "Multi-agent GitLab To-Do watcher with YAML-defined agents, skills, and GitLab registry.",
   "license": "MIT",

package/src/local-agent/agent-config.ts

@@ -31,6 +31,10 @@ export interface AgentGitlabConfig {
 
 export interface AgentNotifications {
   webhook_url?: string;
+  feishu_app_id?: string;
+  feishu_app_secret?: string;
+  /** Email domain for mapping GitLab username → Feishu email (e.g. "taou.com" → "{username}@taou.com") */
+  feishu_email_domain?: string;
 }
 
 export interface AgentLabelConfig {
@@ -126,7 +130,10 @@ function parseNotifications(raw: unknown): AgentNotifications {
   if (typeof raw !== "object" || raw === null) return {};
   const obj = raw as RawValue;
   return {
-    webhook_url: typeof obj.webhook_url === "string" ? obj.webhook_url : undefined
+    webhook_url: typeof obj.webhook_url === "string" ? obj.webhook_url : undefined,
+    feishu_app_id: typeof obj.feishu_app_id === "string" ? obj.feishu_app_id : undefined,
+    feishu_app_secret: typeof obj.feishu_app_secret === "string" ? obj.feishu_app_secret : undefined,
+    feishu_email_domain: typeof obj.feishu_email_domain === "string" ? obj.feishu_email_domain : undefined,
   };
 }
 

package/src/local-agent/agent-runner.ts

@@ -24,10 +24,54 @@ export interface AgentRunContext {
   signal?: AbortSignal;
 }
 
+export interface SpawnedRunResult {
+  exitCode: number | null;
+  summary: string;
+  outputPath: string;
+  /** Set if non-zero exit */
+  error?: string;
+}
+
+export interface AgentProgressEvent {
+  type: "tool_use" | "tool_result" | "text" | "status";
+  tool?: string;        // Read, Edit, Write, Bash, Grep, Glob, etc.
+  detail?: string;      // file path, command, text snippet
+  timestamp: string;
+}
+
+export type ProgressCallback = (event: AgentProgressEvent) => void;
+
+export interface SpawnedRun {
+  pid: number;
+  outputPath: string;
+  /** Called to check if process has exited. Returns result if done, undefined if still running. */
+  poll(): Promise<SpawnedRunResult | undefined>;
+  /** Kill the process */
+  kill(): void;
+  /** Set a callback to receive real-time progress events (stream-json mode) */
+  onProgress?: ProgressCallback;
+}
+
 export interface AgentRunner {
   run(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<AgentRunResult>;
   /** Run a lightweight contextual reply — no worktree, read-only. Optional: falls back to full_work if absent. */
   runContextual?(issue: GitlabIssue, todoBody: string, context?: AgentRunContext): Promise<AgentRunResult>;
+  /** Start the agent process without waiting for it to finish. Returns a handle for polling. */
+  spawn?(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<SpawnedRun>;
+}
+
+/**
+ * Wrap a completed run() result as a SpawnedRun (for smoke tests or fallback).
+ */
+export function createCompletedSpawnedRun(result: AgentRunResult): SpawnedRun {
+  return {
+    pid: process.pid,
+    outputPath: result.outputPath ?? "",
+    async poll(): Promise<SpawnedRunResult> {
+      return { exitCode: 0, summary: result.summary, outputPath: result.outputPath ?? "" };
+    },
+    kill() { /* no-op, already completed */ }
+  };
 }
 
 export interface AgentRunnerOptions {

package/src/local-agent/claude-runner.ts

@@ -1,5 +1,7 @@
-import { execFile } from "node:child_process";
-import { writeFile } from "node:fs/promises";
+import { execFile, spawn as spawnChild } from "node:child_process";
+import { createInterface } from "node:readline";
+import { createWriteStream } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { promisify } from "node:util";
 
 import { compactText, truncate } from "../text.js";
@@ -11,8 +13,12 @@ import {
   type AgentRunResult,
   type AgentRunner,
   type AgentRunnerOptions,
+  type ProgressCallback,
+  type SpawnedRun,
+  type SpawnedRunResult,
   buildAgentPrompt,
   buildContextualPrompt,
+  createCompletedSpawnedRun,
   createOutputPath,
   isSmokeIssue,
   runSmokeTestChecks
@@ -132,6 +138,187 @@ export class ClaudeRunner implements AgentRunner {
     }
   }
 
+  async spawn(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<SpawnedRun> {
+    const outputPath = await createOutputPath("claude", issue.iid);
+
+    if (isSmokeIssue(issue)) {
+      const result = await this.run(issue, worktree, context);
+      return createCompletedSpawnedRun(result);
+    }
+
+    const prompt = buildAgentPrompt({
+      issueIid: issue.iid,
+      issueTitle: issue.title,
+      gitlabHost: this.gitlabHost,
+      gitlabProjectId: this.gitlabProjectId,
+      worktreePath: worktree.worktreePath,
+      branch: worktree.branch,
+      provider: "claude",
+      todoId: context?.todoId,
+      preamble: this.agentDefinition?.prompt.preamble,
+      append: this.agentDefinition?.prompt.append,
+      labels: this.agentDefinition?.labels,
+    });
+    const claudeCommand = resolveClaudeCommand(this.env);
+
+    const args = ["-p", "--output-format", "stream-json", "--verbose", "--permission-mode", "bypassPermissions"];
+    if (this.agentDefinition?.model) {
+      args.push("--model", this.agentDefinition.model);
+    }
+    args.push(prompt);
+
+    this.logger.info(`Spawning: ${claudeCommand} -p ... cwd=${worktree.worktreePath}`);
+    this.logger.info(`Prompt (${prompt.length} chars): issue #${issue.iid} "${issue.title}"`);
+
+    const outStream = createWriteStream(outputPath);
+    const child = spawnChild(claudeCommand, args, {
+      cwd: worktree.worktreePath,
+      env: this.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+    });
+
+    let progressCallback: ProgressCallback | undefined;
+    let lastResult = "";  // capture the final result text
+
+    const rl = createInterface({ input: child.stdout!, crlfDelay: Infinity });
+
+    rl.on("line", (line: string) => {
+      // Write raw line to output file for debugging
+      outStream.write(line + "\n");
+
+      try {
+        const event = JSON.parse(line) as Record<string, unknown>;
+
+        // Extract final result
+        if (event.type === "result" && typeof event.result === "string") {
+          lastResult = event.result;
+        }
+
+        // Parse progress events
+        if (event.type === "assistant" && progressCallback) {
+          const message = event.message as Record<string, unknown> | undefined;
+          const content = message?.content as Array<Record<string, unknown>> | undefined;
+          if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.type === "tool_use") {
+                const toolName = String(block.name ?? "");
+                const input = block.input as Record<string, unknown> | undefined;
+                let detail = "";
+
+                if (toolName === "Read" || toolName === "Edit" || toolName === "Write") {
+                  detail = String(input?.file_path ?? "").split("/").pop() ?? "";
+                } else if (toolName === "Bash") {
+                  const cmd = String(input?.command ?? "").slice(0, 80);
+                  detail = cmd;
+                } else if (toolName === "Grep" || toolName === "Glob") {
+                  detail = String(input?.pattern ?? input?.glob ?? "");
+                }
+
+                progressCallback({
+                  type: "tool_use",
+                  tool: toolName,
+                  detail,
+                  timestamp: new Date().toISOString()
+                });
+              } else if (block.type === "text" && typeof block.text === "string") {
+                progressCallback({
+                  type: "text",
+                  detail: block.text.slice(0, 200),
+                  timestamp: new Date().toISOString()
+                });
+              }
+            }
+          }
+        }
+      } catch {
+        // Not JSON — write as-is (shouldn't happen with stream-json)
+      }
+    });
+
+    let stderrBuf = "";
+    child.stderr?.on("data", (chunk: Buffer) => { stderrBuf += chunk.toString(); });
+
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    if (this.timeoutSeconds) {
+      timeoutHandle = setTimeout(() => {
+        this.logger.error(`Spawn timed out after ${this.timeoutSeconds}s, killing PID ${child.pid}`);
+        child.kill("SIGTERM");
+      }, this.timeoutSeconds * 1000);
+    }
+
+    let exitCode: number | null | undefined;
+    let exited = false;
+
+    child.on("exit", (code) => {
+      exitCode = code;
+      exited = true;
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      outStream.end();
+    });
+
+    if (child.pid === undefined) {
+      outStream.end();
+      throw new AgentRunnerError("Failed to spawn Claude Code process.", "Spawn failed: no PID", outputPath);
+    }
+
+    const pid = child.pid;
+    const logger = this.logger;
+
+    const spawnedRun: SpawnedRun = {
+      pid,
+      outputPath,
+      set onProgress(cb: ProgressCallback | undefined) {
+        progressCallback = cb;
+      },
+      async poll(): Promise<SpawnedRunResult | undefined> {
+        if (!exited) return undefined;
+
+        // Use the parsed result text, fall back to reading file
+        let summary = lastResult.trim();
+        if (!summary) {
+          try {
+            const raw = await readFile(outputPath, "utf8");
+            // Try to extract result from the last line of stream-json
+            const lines = raw.trim().split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+              try {
+                const parsed = JSON.parse(lines[i]) as Record<string, unknown>;
+                if (parsed.type === "result" && typeof parsed.result === "string") {
+                  summary = parsed.result;
+                  break;
+                }
+              } catch { continue; }
+            }
+            if (!summary) summary = "Claude Code finished without output.";
+          } catch {
+            summary = stderrBuf.trim() || "No output captured.";
+          }
+        }
+
+        if (summary.length > 600) summary = summary.slice(0, 600);
+
+        // exitCode is set by the 'exit' event (number | null); undefined means not yet exited
+        const resolvedCode: number | null = exitCode ?? null;
+        if (resolvedCode === 0 || resolvedCode === null) {
+          logger.info(`Spawned process exited. PID=${pid} exitCode=${resolvedCode} output=${outputPath}`);
+          return { exitCode: resolvedCode, summary, outputPath };
+        } else {
+          const errorMsg = stderrBuf.slice(0, 300) || `Exit code ${resolvedCode}`;
+          logger.error(`Spawned process failed. PID=${pid} exitCode=${resolvedCode} stderr=${stderrBuf.slice(0, 200)}`);
+          return { exitCode: resolvedCode, summary, outputPath, error: errorMsg };
+        }
+      },
+      kill() {
+        if (!exited) {
+          child.kill("SIGTERM");
+        }
+      }
+    };
+
+    return spawnedRun;
+  }
+
   async runContextual(issue: GitlabIssue, todoBody: string, context?: AgentRunContext): Promise<AgentRunResult> {
     const signal = context?.signal;
     const outputPath = await createOutputPath("claude-contextual", issue.iid);

package/src/local-agent/codex-runner.ts

@@ -1,6 +1,6 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn as spawnChild } from "node:child_process";
 import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -13,8 +13,11 @@ import {
   type AgentRunResult,
   type AgentRunner,
   type AgentRunnerOptions,
+  type SpawnedRun,
+  type SpawnedRunResult,
   buildAgentPrompt,
   buildContextualPrompt,
+  createCompletedSpawnedRun,
   createOutputPath,
   isSmokeIssue,
   readSummary,
@@ -138,6 +141,108 @@ export class CodexRunner implements AgentRunner {
     };
   }
 
+  async spawn(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<SpawnedRun> {
+    const outputPath = await createOutputPath("codex", issue.iid);
+
+    if (isSmokeIssue(issue)) {
+      const result = await this.run(issue, worktree, context);
+      return createCompletedSpawnedRun(result);
+    }
+
+    const prompt = buildAgentPrompt({
+      issueIid: issue.iid,
+      issueTitle: issue.title,
+      gitlabHost: this.gitlabHost,
+      gitlabProjectId: this.gitlabProjectId,
+      worktreePath: worktree.worktreePath,
+      branch: worktree.branch,
+      provider: "codex",
+      todoId: context?.todoId,
+      preamble: this.agentDefinition?.prompt.preamble,
+      append: this.agentDefinition?.prompt.append,
+      labels: this.agentDefinition?.labels,
+    });
+    const codexCommand = resolveCodexCommand(this.env);
+
+    const args = ["exec", "--full-auto", "-C", worktree.worktreePath, "--output-last-message", outputPath];
+    if (this.agentDefinition?.model) {
+      args.push("--model", this.agentDefinition.model);
+    }
+    args.push(prompt);
+
+    this.logger.info(`Spawning: ${codexCommand} exec --full-auto -C ${worktree.worktreePath}`);
+    this.logger.info(`Prompt (${prompt.length} chars): issue #${issue.iid} "${issue.title}"`);
+
+    const child = spawnChild(codexCommand, args, {
+      env: this.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+    });
+
+    let stderrBuf = "";
+    child.stdout?.on("data", (chunk: Buffer) => { stderrBuf += chunk.toString(); /* discard stdout, codex writes to --output-last-message */ });
+    child.stderr?.on("data", (chunk: Buffer) => { stderrBuf += chunk.toString(); });
+
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    if (this.timeoutSeconds) {
+      timeoutHandle = setTimeout(() => {
+        this.logger.error(`Spawn timed out after ${this.timeoutSeconds}s, killing PID ${child.pid}`);
+        child.kill("SIGTERM");
+      }, this.timeoutSeconds * 1000);
+    }
+
+    let exitCode: number | null | undefined;
+    let exited = false;
+
+    child.on("exit", (code) => {
+      exitCode = code;
+      exited = true;
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+    });
+
+    if (child.pid === undefined) {
+      throw new AgentRunnerError("Failed to spawn Codex process.", "Spawn failed: no PID", outputPath);
+    }
+
+    const pid = child.pid;
+    const timeoutSec = this.timeoutSeconds;
+    const logger = this.logger;
+
+    return {
+      pid,
+      outputPath,
+      async poll(): Promise<SpawnedRunResult | undefined> {
+        if (!exited) return undefined;
+
+        let summary: string;
+        try {
+          const raw = await readFile(outputPath, "utf8");
+          summary = raw.trim() || "Codex finished without output.";
+        } catch {
+          summary = stderrBuf.trim() || "No output captured.";
+        }
+
+        if (summary.length > 600) summary = summary.slice(0, 600);
+
+        // exitCode is set by the 'exit' event (number | null); undefined means not yet exited
+        const resolvedCode: number | null = exitCode ?? null;
+        if (resolvedCode === 0 || resolvedCode === null) {
+          logger.info(`Spawned process exited. PID=${pid} exitCode=${resolvedCode} output=${outputPath}`);
+          return { exitCode: resolvedCode, summary, outputPath };
+        } else {
+          const errorMsg = stderrBuf.slice(0, 300) || `Exit code ${resolvedCode}`;
+          logger.error(`Spawned process failed. PID=${pid} exitCode=${resolvedCode} stderr=${stderrBuf.slice(0, 200)}`);
+          return { exitCode: resolvedCode, summary, outputPath, error: errorMsg };
+        }
+      },
+      kill() {
+        if (!exited) {
+          child.kill("SIGTERM");
+        }
+      }
+    };
+  }
+
   async runContextual(issue: GitlabIssue, todoBody: string, context?: AgentRunContext): Promise<AgentRunResult> {
     const signal = context?.signal;
     const outputPath = await createOutputPath("codex-contextual", issue.iid);

package/src/local-agent/feishu-client.ts

@@ -0,0 +1,226 @@
+// ──────────────────────────────────────────────────────────────────────────────
+// Feishu (Lark) App Client — send & update interactive cards to specific users
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface FeishuClientOptions {
+  appId: string;
+  appSecret: string;
+  /** Override base URL for testing. Default: https://open.feishu.cn */
+  baseUrl?: string;
+}
+
+export interface FeishuCard {
+  header: {
+    title: { tag: "plain_text"; content: string };
+    template: "blue" | "green" | "red" | "orange" | "purple";
+  };
+  elements: unknown[];
+}
+
+export class FeishuClient {
+  private readonly appId: string;
+  private readonly appSecret: string;
+  private readonly baseUrl: string;
+
+  // Token cache
+  private accessToken?: string;
+  private tokenExpiresAt = 0;
+
+  // User ID cache: email → open_id
+  private userCache = new Map<string, string>();
+
+  constructor(options: FeishuClientOptions) {
+    this.appId = options.appId;
+    this.appSecret = options.appSecret;
+    this.baseUrl = options.baseUrl ?? "https://open.feishu.cn";
+  }
+
+  /** Get or refresh app access token */
+  private async getToken(): Promise<string> {
+    if (this.accessToken && Date.now() < this.tokenExpiresAt) {
+      return this.accessToken;
+    }
+
+    const response = await fetch(`${this.baseUrl}/open-apis/auth/v3/app_access_token/internal`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ app_id: this.appId, app_secret: this.appSecret }),
+      signal: AbortSignal.timeout(10_000)
+    });
+
+    const data = await response.json() as { code: number; app_access_token?: string; expire?: number; msg?: string };
+    if (data.code !== 0 || !data.app_access_token) {
+      throw new Error(`Feishu token error: ${data.msg ?? `code ${data.code}`}`);
+    }
+
+    this.accessToken = data.app_access_token;
+    // Refresh 5 minutes before expiry
+    this.tokenExpiresAt = Date.now() + ((data.expire ?? 7200) - 300) * 1000;
+    return this.accessToken;
+  }
+
+  /** Look up Feishu open_id by email */
+  async getUserByEmail(email: string): Promise<string | undefined> {
+    const cached = this.userCache.get(email);
+    if (cached) return cached;
+
+    const token = await this.getToken();
+    const response = await fetch(`${this.baseUrl}/open-apis/contact/v3/users/batch_get_id?user_id_type=open_id`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ emails: [email] }),
+      signal: AbortSignal.timeout(10_000)
+    });
+
+    const data = await response.json() as {
+      code: number;
+      data?: { user_list?: Array<{ email?: string; user_id?: string }> };
+    };
+
+    if (data.code !== 0) return undefined;
+
+    const user = data.data?.user_list?.find(u => u.email === email);
+    if (user?.user_id) {
+      this.userCache.set(email, user.user_id);
+      return user.user_id;
+    }
+    return undefined;
+  }
+
+  /** Send an interactive card to a user, returns message_id for later updates */
+  async sendCard(openId: string, card: FeishuCard): Promise<string | undefined> {
+    const token = await this.getToken();
+    const response = await fetch(`${this.baseUrl}/open-apis/im/v1/messages?receive_id_type=open_id`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        receive_id: openId,
+        msg_type: "interactive",
+        content: JSON.stringify(card)
+      }),
+      signal: AbortSignal.timeout(10_000)
+    });
+
+    const data = await response.json() as {
+      code: number;
+      data?: { message_id?: string };
+      msg?: string;
+    };
+
+    if (data.code !== 0) {
+      throw new Error(`Feishu send failed: ${data.msg ?? `code ${data.code}`}`);
+    }
+
+    return data.data?.message_id;
+  }
+
+  /** Update an existing card message */
+  async updateCard(messageId: string, card: FeishuCard): Promise<void> {
+    const token = await this.getToken();
+    const response = await fetch(`${this.baseUrl}/open-apis/im/v1/messages/${messageId}`, {
+      method: "PATCH",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        content: JSON.stringify(card)
+      }),
+      signal: AbortSignal.timeout(10_000)
+    });
+
+    const data = await response.json() as { code: number; msg?: string };
+    if (data.code !== 0) {
+      throw new Error(`Feishu update failed: ${data.msg ?? `code ${data.code}`}`);
+    }
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Card builder helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+export function buildProgressCard(options: {
+  agentName: string;
+  issueIid: number;
+  issueTitle: string;
+  issueUrl?: string;
+  mrUrl?: string;
+  status: "accepted" | "running" | "completed" | "failed" | "queued";
+  progressLines?: string[];  // e.g. ["📖 阅读 README.md", "✏️ 编辑 utils.js"]
+  duration?: string;         // e.g. "2m 30s"
+  summary?: string;          // final summary on completion/failure
+}): FeishuCard {
+  const statusConfig: Record<string, { color: FeishuCard["header"]["template"]; emoji: string }> = {
+    accepted: { color: "blue", emoji: "🤖" },
+    running: { color: "blue", emoji: "🔧" },
+    completed: { color: "green", emoji: "✅" },
+    failed: { color: "red", emoji: "❌" },
+    queued: { color: "orange", emoji: "⏳" },
+  };
+
+  const cfg = statusConfig[options.status] ?? statusConfig.accepted;
+  const title = `${cfg.emoji} ${options.agentName} · #${options.issueIid} ${options.issueTitle}`;
+
+  const elements: unknown[] = [];
+
+  // Progress lines
+  if (options.progressLines && options.progressLines.length > 0) {
+    elements.push({
+      tag: "div",
+      text: { tag: "lark_md", content: options.progressLines.join("\n") }
+    });
+  }
+
+  // Summary (for completed/failed)
+  if (options.summary) {
+    elements.push({
+      tag: "div",
+      text: { tag: "lark_md", content: options.summary.slice(0, 500) }
+    });
+  }
+
+  // Duration
+  if (options.duration) {
+    elements.push({
+      tag: "div",
+      text: { tag: "lark_md", content: `⏱ ${options.duration}` }
+    });
+  }
+
+  // Action buttons
+  const actions: unknown[] = [];
+  if (options.issueUrl) {
+    actions.push({
+      tag: "button",
+      text: { tag: "plain_text", content: "查看 Issue" },
+      type: "default",
+      url: options.issueUrl
+    });
+  }
+  if (options.mrUrl) {
+    actions.push({
+      tag: "button",
+      text: { tag: "plain_text", content: "查看 MR" },
+      type: "primary",
+      url: options.mrUrl
+    });
+  }
+  if (actions.length > 0) {
+    elements.push({ tag: "action", actions });
+  }
+
+  return {
+    header: {
+      title: { tag: "plain_text", content: title.slice(0, 100) },
+      template: cfg.color
+    },
+    elements
+  };
+}