glab-agent 0.2.11 → 0.2.13

package/package.json

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

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

@@ -24,6 +24,10 @@ export interface AgentRunContext {
   signal?: AbortSignal;
   /** Hint when issue labels don't match trigger config. Passed to agent prompt. */
   labelMismatchHint?: string;
+  /** Path to the target project's repo (cached bare clone). Used by runners for git operations. */
+  targetRepoPath?: string;
+  /** Override gitlabProjectId for the prompt (target project, not agents repo) */
+  gitlabProjectId?: number;
 }
 
 export interface SpawnedRunResult {
@@ -230,7 +234,8 @@ export function buildBasePrompt(ctx: AgentPromptContext): string {
     "",
     "## 当前环境",
     `- 分支: ${ctx.branch}`,
-    "- 工作目录: 项目的独立工作副本",
+    "- 工作目录: issue 对应项目的独立工作副本",
+    "- 如果任务涉及其他仓库，可以用 git clone 拉取（GITLAB_TOKEN 已配置，支持认证）",
     ctx.labelMismatchHint ? `\n## 注意\n${ctx.labelMismatchHint}` : "",
     "",
     "## 最终输出",

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

@@ -67,7 +67,7 @@ export class ClaudeRunner implements AgentRunner {
       issueIid: issue.iid,
       issueTitle: issue.title,
       gitlabHost: this.gitlabHost,
-      gitlabProjectId: this.gitlabProjectId,
+      gitlabProjectId: context?.gitlabProjectId ?? this.gitlabProjectId,
       worktreePath: worktree.worktreePath,
       branch: worktree.branch,
       provider: "claude",
@@ -151,7 +151,7 @@ export class ClaudeRunner implements AgentRunner {
       issueIid: issue.iid,
       issueTitle: issue.title,
       gitlabHost: this.gitlabHost,
-      gitlabProjectId: this.gitlabProjectId,
+      gitlabProjectId: context?.gitlabProjectId ?? this.gitlabProjectId,
       worktreePath: worktree.worktreePath,
       branch: worktree.branch,
       provider: "claude",

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

@@ -67,7 +67,7 @@ export class CodexRunner implements AgentRunner {
       issueIid: issue.iid,
       issueTitle: issue.title,
       gitlabHost: this.gitlabHost,
-      gitlabProjectId: this.gitlabProjectId,
+      gitlabProjectId: context?.gitlabProjectId ?? this.gitlabProjectId,
       worktreePath: worktree.worktreePath,
       branch: worktree.branch,
       provider: "codex",
@@ -154,7 +154,7 @@ export class CodexRunner implements AgentRunner {
       issueIid: issue.iid,
       issueTitle: issue.title,
       gitlabHost: this.gitlabHost,
-      gitlabProjectId: this.gitlabProjectId,
+      gitlabProjectId: context?.gitlabProjectId ?? this.gitlabProjectId,
       worktreePath: worktree.worktreePath,
       branch: worktree.branch,
       provider: "codex",

package/src/local-agent/gitlab-glab-client.ts

@@ -101,7 +101,7 @@ export interface GitlabClient {
   getWikiPage(projectId: number | string, slug: string): Promise<WikiPage>;
   createWikiPage(projectId: number | string, title: string, content: string): Promise<WikiPage>;
   updateWikiPage(projectId: number | string, slug: string, title: string, content: string): Promise<WikiPage>;
-  getProject(projectIdOrPath: number | string): Promise<{ id: number } | undefined>;
+  getProject(projectIdOrPath: number | string): Promise<{ id: number; httpUrlToRepo?: string; pathWithNamespace?: string } | undefined>;
   createProject(name: string, options?: { visibility?: string; initializeWithReadme?: boolean }): Promise<{ id: number }>;
   getRepositoryFile(projectId: number | string, filePath: string, ref?: string): Promise<{ content: string } | undefined>;
   createOrUpdateRepositoryFile(projectId: number | string, filePath: string, content: string, commitMessage: string, options?: { create?: boolean }): Promise<void>;
@@ -723,13 +723,18 @@ export class GitlabGlabClient implements GitlabClient {
     };
   }
 
-  async getProject(projectIdOrPath: number | string): Promise<{ id: number } | undefined> {
+  async getProject(projectIdOrPath: number | string): Promise<{ id: number; httpUrlToRepo?: string; pathWithNamespace?: string } | undefined> {
     try {
       const encoded = typeof projectIdOrPath === "string" ? encodeURIComponent(projectIdOrPath) : projectIdOrPath;
       const payload = await this.readJson(`projects/${encoded}`);
       const p = (payload ?? {}) as Payload;
       const id = Number(p.id);
-      return Number.isNaN(id) ? undefined : { id };
+      if (Number.isNaN(id)) return undefined;
+      return {
+        id,
+        httpUrlToRepo: typeof p.http_url_to_repo === "string" ? p.http_url_to_repo as string : undefined,
+        pathWithNamespace: typeof p.path_with_namespace === "string" ? p.path_with_namespace as string : undefined,
+      };
     } catch {
       return undefined;
     }

package/src/local-agent/repo-cache.ts

@@ -122,6 +122,21 @@ export class RepoCache {
     return true;
   }
 
+  /**
+   * Build a git clone URL with embedded token for authentication.
+   * e.g., https://oauth2:TOKEN@gitlab.example.com/group/project.git
+   */
+  static authenticatedUrl(httpUrl: string, token: string): string {
+    try {
+      const url = new URL(httpUrl);
+      url.username = "oauth2";
+      url.password = token;
+      return url.toString();
+    } catch {
+      return httpUrl;
+    }
+  }
+
   /**
    * Get the cache directory path for a given repo URL.
    * Uses SHA-256 hash of the URL for the directory name.

package/src/local-agent/watcher.ts

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
 import path from "node:path";
 
 import { AgentRunnerError, type AgentRunner, type SpawnedRun } from "./agent-runner.js";
@@ -33,6 +34,7 @@ import { rotateIfNeeded } from "./log-rotate.js";
 import { validateToken } from "./token-check.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import type { WorktreeInfo } from "./worktree-manager.js";
+import { RepoCache } from "./repo-cache.js";
 import { injectSkillFiles } from "./skill-inject.js";
 import { startHealthServer } from "./health-server.js";
 import type { HealthStatus } from "./health-server.js";
@@ -103,6 +105,8 @@ export interface WatcherDependencies {
   issueCloseCheckIntervalMs?: number;
   /** Feishu app client for targeted personal notifications */
   feishuClient?: import("./feishu-client.js").FeishuClient;
+  /** Cache for bare clones of target project repos */
+  repoCache?: RepoCache;
 }
 
 export interface WatcherCycleResult {
@@ -338,6 +342,52 @@ async function replaceReactionOnTodo(
   }
 }
 
+/**
+ * Resolve the target project's repo and create a worktree for the given issue/MR.
+ * Uses RepoCache to clone/fetch the target project, then creates a worktree from it.
+ * Falls back to the agents repo worktree if the target project can't be resolved.
+ */
+async function resolveTargetWorktree(
+  projectId: number,
+  iid: number,
+  title: string,
+  config: LocalAgentConfig,
+  dependencies: WatcherDependencies,
+  logger: Logger | typeof console
+): Promise<{ worktree: WorktreeInfo }> {
+  if (dependencies.repoCache) {
+    try {
+      const project = await dependencies.gitlabClient.getProject(projectId);
+      if (project?.httpUrlToRepo) {
+        const authedUrl = RepoCache.authenticatedUrl(project.httpUrlToRepo, config.gitlabToken);
+        const cachedRepoPath = await dependencies.repoCache.ensureRepo(authedUrl);
+
+        const agentName = config.agentDefinition?.name;
+        const worktreeRoot = path.join(config.agentRepoPath, ".glab-agent", "worktrees", agentName ?? "agent");
+
+        await mkdir(worktreeRoot, { recursive: true });
+
+        // Use a WorktreeManager pointing at the cached bare repo
+        const targetWtm = new WorktreeManager({
+          repoPath: cachedRepoPath,
+          worktreeRoot,
+          agentName,
+        });
+        const worktree = await targetWtm.ensureWorktree(iid, title);
+
+        (logger as Logger | undefined)?.info?.(`Target repo resolved: ${project.pathWithNamespace ?? projectId} → ${cachedRepoPath}`);
+        return { worktree };
+      }
+    } catch (err) {
+      (logger as Logger | undefined)?.warn?.(`Failed to resolve target repo for project ${projectId}, falling back to agents repo: ${String(err).slice(0, 150)}`);
+    }
+  }
+
+  // Fallback: use agents repo worktree (original behavior)
+  const worktree = await dependencies.worktreeManager.ensureWorktree(iid, title);
+  return { worktree };
+}
+
 export async function runWatcherCycle(
   config: LocalAgentConfig,
   dependencies: WatcherDependencies
@@ -346,6 +396,13 @@ export async function runWatcherCycle(
   const logger = dependencies.logger ?? console;
   const state = await dependencies.stateStore.load();
 
+  // When Feishu app client is configured, suppress group webhook notifications —
+  // personal Feishu cards already cover the full lifecycle (accepted/running/completed/failed).
+  // Mutate a local copy so the original config is untouched.
+  if (dependencies.feishuClient && 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}`);
@@ -429,7 +486,9 @@ export async function runWatcherCycle(
       webUrl: ""
     };
 
-    const worktree = await dependencies.worktreeManager.ensureWorktree(targetIid, `mr-${targetIid}`);
+    const { worktree } = await resolveTargetWorktree(
+      candidate.projectId, targetIid, `mr-${targetIid}`, config, dependencies, logger
+    );
     state.activeRun = {
       pid,
       todoId: candidate.id,
@@ -456,7 +515,7 @@ export async function runWatcherCycle(
     logger.info(`Starting agent for MR !${targetIid} branch=${worktree.branch}`);
 
     try {
-      const result = await dependencies.agentRunner.run(issue, worktree, { todoId: candidate.id });
+      const result = await dependencies.agentRunner.run(issue, worktree, { todoId: candidate.id, gitlabProjectId: candidate.projectId });
       logger.info(`Agent completed MR !${targetIid}. Summary: ${result.summary.slice(0, 200)}`);
     } catch (error) {
       const summary = error instanceof AgentRunnerError ? error.summary : String(error);
@@ -486,7 +545,9 @@ export async function runWatcherCycle(
     logger.info(`Issue #${issue.iid}: label mismatch, passing hint to agent`);
   }
 
-  const worktree = await dependencies.worktreeManager.ensureWorktree(issue.iid, issue.title);
+  const { worktree } = await resolveTargetWorktree(
+    issue.projectId, issue.iid, issue.title, config, dependencies, logger
+  );
 
   state.activeRun = {
     pid,
@@ -566,7 +627,7 @@ export async function runWatcherCycle(
 
   try {
     const raceResult = await Promise.race([
-      dependencies.agentRunner.run(issue, worktree, { todoId: candidate.id, signal: abortController.signal, labelMismatchHint }).then(r => ({ type: "completed" as const, result: r })),
+      dependencies.agentRunner.run(issue, worktree, { todoId: candidate.id, signal: abortController.signal, labelMismatchHint, gitlabProjectId: issue.projectId }).then(r => ({ type: "completed" as const, result: r })),
       closeDetection.then(() => ({ type: "closed" as const }))
     ]);
 
@@ -712,6 +773,11 @@ export async function runConcurrentWatcherCycle(
   const state = await dependencies.stateStore.load();
   const concurrency = config.agentDefinition?.concurrency ?? 1;
 
+  // Suppress group webhook when Feishu personal cards are active
+  if (dependencies.feishuClient && config.webhookUrl) {
+    config = { ...config, webhookUrl: undefined };
+  }
+
   // 1. Collect finished tasks
   for (const [issueIid, spawned] of spawnedRuns) {
     const result = await spawned.run.poll();
@@ -860,7 +926,10 @@ export async function runConcurrentWatcherCycle(
 
     // Prepare and spawn
     const worktreeTitle = isIssueTodo ? issue.title : `mr-${targetIid}`;
-    const worktree = await dependencies.worktreeManager.ensureWorktree(targetIid, worktreeTitle);
+    const { worktree } = await resolveTargetWorktree(
+      isIssueTodo ? issue.projectId : candidate.projectId,
+      targetIid, worktreeTitle, config, dependencies, logger
+    );
 
     const skills = config.agentDefinition?.skills ?? [];
     if (skills.length > 0) {
@@ -870,7 +939,7 @@ export async function runConcurrentWatcherCycle(
       } catch (err) { logger.warn(`Failed to inject skill files: ${String(err)}`); }
     }
 
-    const spawnedRun = await dependencies.agentRunner.spawn(issue, worktree, { todoId: candidate.id, labelMismatchHint });
+    const spawnedRun = await dependencies.agentRunner.spawn(issue, worktree, { todoId: candidate.id, labelMismatchHint, gitlabProjectId: isIssueTodo ? issue.projectId : candidate.projectId });
     const now = new Date().toISOString();
 
     spawnedRuns.set(issue.iid, {
@@ -1602,6 +1671,9 @@ function createDependencies(config: LocalAgentConfig, logger?: Logger): WatcherD
       agentName: config.agentDefinition?.name
     }),
     agentRunner,
+    repoCache: new RepoCache({
+      cacheDir: path.join(config.agentRepoPath, ".glab-agent", "repo-cache")
+    }),
     logger
   };
 }
@@ -1805,9 +1877,8 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
     config.botName = botUser.name;
     logger.info(`Token validated. Bot identity: @${botUser.username} (${botUser.name})`);
 
-    // Update GitLab user bio with agent profile (P1: Agent = 员工)
+    // Update GitLab user profile (P1: Agent = 员工)
     await updateAgentUserBio(config, dependencies);
-    await publishAgentProfileWiki(config, dependencies);
     await publishProfileReadme(config, dependencies);
     await updateAgentUserStatus(dependencies, "idle", undefined, config);
   } catch (error) {