glab-agent 0.2.12 → 0.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glab-agent",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "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

@@ -36,6 +36,8 @@ export interface AgentNotifications {
   feishu_app_secret_env?: string;
   /** Email domain for mapping GitLab username → Feishu email (e.g. "taou.com" → "{username}@taou.com") */
   feishu_email_domain?: string;
+  /** Feishu group chat_id — send updatable cards to team group instead of webhook */
+  feishu_group_chat_id?: string;
 }
 
 export interface AgentLabelConfig {
@@ -135,6 +137,7 @@ function parseNotifications(raw: unknown): AgentNotifications {
     feishu_app_id_env: typeof obj.feishu_app_id_env === "string" ? obj.feishu_app_id_env : undefined,
     feishu_app_secret_env: typeof obj.feishu_app_secret_env === "string" ? obj.feishu_app_secret_env : undefined,
     feishu_email_domain: typeof obj.feishu_email_domain === "string" ? obj.feishu_email_domain : undefined,
+    feishu_group_chat_id: typeof obj.feishu_group_chat_id === "string" ? obj.feishu_group_chat_id : undefined,
   };
 }
 

package/src/local-agent/watcher.ts

@@ -59,6 +59,7 @@ const spawnedRuns = new Map<number, { // keyed by issueIid
   startedAt: string;
   feishuMessageId?: string;
   feishuOpenId?: string;
+  feishuGroupMessageId?: string;
   progressLines?: string[];
 }>();
 
@@ -81,6 +82,7 @@ export interface LocalAgentConfig {
   feishuAppId?: string;
   feishuAppSecret?: string;
   feishuEmailDomain?: string;
+  feishuGroupChatId?: string;
 }
 
 export interface ConfigResolutionOptions {
@@ -396,6 +398,12 @@ export async function runWatcherCycle(
   const logger = dependencies.logger ?? console;
   const state = await dependencies.stateStore.load();
 
+  // Suppress group webhook when Feishu group card is configured (strict replacement).
+  // Personal cards alone don't suppress webhook — team still needs group visibility.
+  if (config.feishuGroupChatId && config.webhookUrl) {
+    config = { ...config, webhookUrl: undefined };
+  }
+
   if (state.activeRun && isPidAlive(state.activeRun.pid) && state.activeRun.pid !== pid) {
     logger.info(`Watcher is busy with issue #${state.activeRun.issueIid}.`);
     await updateAgentUserStatus(dependencies, "busy", `#${state.activeRun.issueIid}`);
@@ -766,6 +774,11 @@ export async function runConcurrentWatcherCycle(
   const state = await dependencies.stateStore.load();
   const concurrency = config.agentDefinition?.concurrency ?? 1;
 
+  // Suppress group webhook when Feishu group card is configured (strict replacement)
+  if (config.feishuGroupChatId && config.webhookUrl) {
+    config = { ...config, webhookUrl: undefined };
+  }
+
   // 1. Collect finished tasks
   for (const [issueIid, spawned] of spawnedRuns) {
     const result = await spawned.run.poll();
@@ -794,8 +807,8 @@ export async function runConcurrentWatcherCycle(
         } catch (e) { logger.warn(`Post-run cleanup failed: ${String(e).slice(0, 100)}`); }
       }
       await notifyFailed(config.agentDefinition?.name ?? "agent", issueIid, spawned.issue.title, result.summary, config.webhookUrl);
-      // Feishu: update card to failed state
-      if (dependencies.feishuClient && spawned.feishuMessageId) {
+      // Feishu: update cards to failed state
+      if (dependencies.feishuClient) {
         const card = buildProgressCard({
           agentName: config.agentDefinition?.name ?? "agent",
           issueIid,
@@ -806,7 +819,8 @@ export async function runConcurrentWatcherCycle(
           summary: result.summary.slice(0, 300),
           duration: `${durationSec}s`,
         });
-        dependencies.feishuClient.updateCard(spawned.feishuMessageId, card).catch(() => {});
+        if (spawned.feishuMessageId) dependencies.feishuClient.updateCard(spawned.feishuMessageId, card).catch(() => {});
+        if (spawned.feishuGroupMessageId) dependencies.feishuClient.updateCard(spawned.feishuGroupMessageId, card).catch(() => {});
       }
       await replaceReactionOnTodo(dependencies.gitlabClient, spawned.todo, "eyes", "x", logger);
       await finalizeTodo(config, dependencies, state, spawned.todo, spawned.issue, {
@@ -817,8 +831,8 @@ export async function runConcurrentWatcherCycle(
       logger.info(`Agent completed issue #${issueIid} in ${durationSec}s. Summary: ${result.summary.slice(0, 200)}`);
       const mr = spawned.issue.projectId ? await dependencies.gitlabClient.findMergeRequestByBranch(spawned.issue.projectId, spawned.worktree.branch).catch(() => undefined) : undefined;
       await notifyCompleted(config.agentDefinition?.name ?? "agent", issueIid, spawned.issue.title, mr?.webUrl || spawned.issue.webUrl || undefined, config.webhookUrl);
-      // Feishu: update card to completed state
-      if (dependencies.feishuClient && spawned.feishuMessageId) {
+      // Feishu: update cards to completed state
+      if (dependencies.feishuClient) {
         const card = buildProgressCard({
           agentName: config.agentDefinition?.name ?? "agent",
           issueIid,
@@ -830,7 +844,8 @@ export async function runConcurrentWatcherCycle(
           summary: result.summary.slice(0, 300),
           duration: `${durationSec}s`,
         });
-        dependencies.feishuClient.updateCard(spawned.feishuMessageId, card).catch(() => {});
+        if (spawned.feishuMessageId) dependencies.feishuClient.updateCard(spawned.feishuMessageId, card).catch(() => {});
+        if (spawned.feishuGroupMessageId) dependencies.feishuClient.updateCard(spawned.feishuGroupMessageId, card).catch(() => {});
       }
       await replaceReactionOnTodo(dependencies.gitlabClient, spawned.todo, "eyes", "white_check_mark", logger);
       await finalizeTodo(config, dependencies, state, spawned.todo, spawned.issue, {
@@ -965,7 +980,27 @@ export async function runConcurrentWatcherCycle(
       }
     }
 
-    // Set up progress callback for webhook and/or feishu card updates
+    // Feishu: send accepted card to group chat
+    if (dependencies.feishuClient && config.feishuGroupChatId) {
+      try {
+        const card = buildProgressCard({
+          agentName: config.agentDefinition?.name ?? "agent",
+          issueIid: issue.iid,
+          issueTitle: issue.title,
+          issueUrl: issue.webUrl || undefined,
+          status: "accepted",
+        });
+        const groupMsgId = await dependencies.feishuClient.sendCard(config.feishuGroupChatId, card);
+        const entry = spawnedRuns.get(issue.iid);
+        if (entry && groupMsgId) {
+          entry.feishuGroupMessageId = groupMsgId;
+        }
+      } catch (e) {
+        logger.info?.(`Feishu group card send skipped: ${String(e).slice(0, 100)}`);
+      }
+    }
+
+    // Set up progress callback for feishu card updates
     if (config.webhookUrl || dependencies.feishuClient) {
       const agentName = config.agentDefinition?.name ?? "agent";
       const issueRef = `#${issue.iid}`;
@@ -1024,14 +1059,13 @@ export async function runConcurrentWatcherCycle(
             duration: `${elapsedSec}s`,
           });
           dependencies.feishuClient.updateCard(spawnedEntry.feishuMessageId, card).catch(() => {});
-        } else if (config.webhookUrl) {
-          // Fallback to webhook when Feishu is not configured
-          sendWebhook(config.webhookUrl, {
-            title: `\u{1F527} ${agentName} ${issueRef}`,
-            message,
-            status: "accepted",
-          }).catch(() => {});
+          // Also update group card if present
+          if (spawnedEntry.feishuGroupMessageId) {
+            dependencies.feishuClient.updateCard(spawnedEntry.feishuGroupMessageId, card).catch(() => {});
+          }
         }
+        // Webhook does NOT receive progress updates — only lifecycle events
+        // (accepted/completed/failed) via notifyXxx functions. This prevents group flooding.
       };
     }
 
@@ -1741,6 +1775,7 @@ export function loadConfigFromAgentDefinition(
     feishuAppId: def.notifications?.feishu_app_id_env ? env[def.notifications.feishu_app_id_env]?.trim() : undefined,
     feishuAppSecret: def.notifications?.feishu_app_secret_env ? env[def.notifications.feishu_app_secret_env]?.trim() : undefined,
     feishuEmailDomain: def.notifications?.feishu_email_domain,
+    feishuGroupChatId: def.notifications?.feishu_group_chat_id,
   };
 }