glab-agent 0.1.0

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

@@ -0,0 +1,722 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export interface GitlabTodoItem {
+  id: number;
+  issueIid: number;
+  issueId?: number;
+  projectId: number;
+  actionName: string;
+  targetType: string;
+  state: string;
+  targetUrl?: string;
+  createdAt?: string;
+  labels?: string[];
+  targetIid?: number;
+  body?: string;
+  sourceBranch?: string;
+}
+
+export interface GitlabIssue {
+  id: number;
+  iid: number;
+  projectId: number;
+  title: string;
+  description: string;
+  labels: string[];
+  webUrl: string;
+  state?: "opened" | "closed";
+  stateReason?: string | null;
+}
+
+export interface MergeRequestResult {
+  iid: number;
+  webUrl: string;
+}
+
+export interface GitlabNote {
+  id: number;
+  body: string;
+  system: boolean;
+  createdAt: string;
+}
+
+export interface GitlabLabel {
+  id: number;
+  name: string;
+}
+
+export interface GitlabBoard {
+  id: number;
+  name: string;
+}
+
+export interface GitlabUser {
+  id: number;
+  username: string;
+  name: string;
+}
+
+export interface GitlabClient {
+  getCurrentUser(): Promise<GitlabUser>;
+  listMentionedIssueTodos(projectId: number): Promise<GitlabTodoItem[]>;
+  getIssue(projectId: number, issueIid: number): Promise<GitlabIssue>;
+  updateIssueLabels(projectId: number, issueIid: number, labels: string[]): Promise<void>;
+  updateIssueDescription(projectId: number, issueIid: number, description: string): Promise<void>;
+  updateIssueTitle(projectId: number, issueIid: number, title: string): Promise<void>;
+  closeIssue(projectId: number, issueIid: number): Promise<void>;
+  addIssueNote(projectId: number, issueIid: number, body: string): Promise<void>;
+  getIssueNotes(projectId: number, issueIid: number): Promise<GitlabNote[]>;
+  markTodoDone(todoId: number): Promise<void>;
+  createMergeRequest(projectId: number, sourceBranch: string, targetBranch: string, title: string, description: string, issueIid: number): Promise<MergeRequestResult>;
+  createIssue(projectId: number, title: string, description: string, labels: string[]): Promise<{ iid: number }>;
+  listPendingTodos(projectId: number): Promise<GitlabTodoItem[]>;
+  addMergeRequestNote(projectId: number, mrIid: number, body: string): Promise<void>;
+  getMergeRequestNotes(projectId: number, mrIid: number): Promise<GitlabNote[]>;
+  searchIssuesByLabel(projectId: number, label: string): Promise<GitlabIssue[]>;
+  listClosedIssuesByLabel(projectId: number, label: string): Promise<GitlabIssue[]>;
+  listLabels(projectId: number): Promise<GitlabLabel[]>;
+  createLabel(projectId: number, name: string, color: string): Promise<GitlabLabel>;
+  listBoards(projectId: number): Promise<GitlabBoard[]>;
+  createBoard(projectId: number, name: string): Promise<GitlabBoard>;
+  createBoardList(projectId: number, boardId: number, labelId: number): Promise<{ id: number }>;
+  updateUserStatus(emoji: string, message: string, availability?: "busy" | "not_set"): Promise<void>;
+  updateUserBio(bio: string): Promise<void>;
+  listAllPendingTodos(): Promise<GitlabTodoItem[]>;
+}
+
+interface GitlabGlabClientOptions {
+  host: string;
+  token: string;
+  execFileImpl?: typeof execFileAsync;
+  retryCount?: number; // default 3
+}
+
+export function isRetryableError(errorMessage: string): boolean {
+  const retryablePatterns = [
+    /5\d{2}/,              // 5xx status codes
+    /ECONNRESET/,
+    /ECONNREFUSED/,
+    /ETIMEDOUT/,
+    /ENOTFOUND/,
+    /socket hang up/i,
+    /network/i,
+    /timeout/i
+  ];
+  return retryablePatterns.some(pattern => pattern.test(errorMessage));
+}
+
+export function retrySleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+type Payload = Record<string, unknown>;
+
+function parseInteger(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value;
+  }
+
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? undefined : parsed;
+  }
+
+  return undefined;
+}
+
+function parseIssueIid(payload: Payload): number | undefined {
+  const fromTarget = parseInteger((payload.target as Payload | undefined)?.iid);
+
+  if (fromTarget !== undefined) {
+    return fromTarget;
+  }
+
+  const targetUrl = typeof payload.target_url === "string" ? payload.target_url : "";
+  const matched = targetUrl.match(/\/issues\/(\d+)$/);
+  return matched ? parseInteger(matched[1]) : undefined;
+}
+
+// Bot mention todos may use either the mentioned or directly_addressed action.
+function parseTodo(payload: Payload): GitlabTodoItem | undefined {
+  const id = parseInteger(payload.id);
+  const projectId =
+    parseInteger(payload.project_id) ??
+    parseInteger((payload.project as Payload | undefined)?.id) ??
+    parseInteger((payload.target as Payload | undefined)?.project_id);
+  const issueIid = parseIssueIid(payload);
+
+  if (id === undefined || projectId === undefined || issueIid === undefined) {
+    return undefined;
+  }
+
+  const target = payload.target as Payload | undefined;
+
+  return {
+    id,
+    projectId,
+    issueIid,
+    issueId: parseInteger(target?.id),
+    actionName: typeof payload.action_name === "string" ? payload.action_name : "",
+    targetType: typeof payload.target_type === "string" ? payload.target_type : "",
+    state: typeof payload.state === "string" ? payload.state : "",
+    targetUrl: typeof payload.target_url === "string" ? payload.target_url : undefined,
+    createdAt: typeof payload.created_at === "string" ? payload.created_at : undefined,
+    labels: parseLabels(target)
+  };
+}
+
+export function parseTargetIid(payload: Payload): number | undefined {
+  const fromTarget = parseInteger((payload.target as Payload | undefined)?.iid);
+  if (fromTarget !== undefined) return fromTarget;
+
+  const targetUrl = typeof payload.target_url === "string" ? payload.target_url : "";
+  const matched = targetUrl.match(/\/(issues|merge_requests)\/(\d+)$/);
+  return matched ? parseInteger(matched[2]) : undefined;
+}
+
+function parseLabels(target: Payload | undefined): string[] | undefined {
+  const rawLabels = target?.labels;
+  if (!Array.isArray(rawLabels)) return undefined;
+  return rawLabels
+    .map((item: unknown) => {
+      if (typeof item === "string") return item;
+      if (typeof item === "object" && item !== null && "name" in item && typeof (item as Record<string, unknown>).name === "string") {
+        return (item as Record<string, unknown>).name as string;
+      }
+      return undefined;
+    })
+    .filter((item): item is string => item !== undefined);
+}
+
+export function parseTodoUniversal(payload: Payload): GitlabTodoItem | undefined {
+  const id = parseInteger(payload.id);
+  const projectId =
+    parseInteger(payload.project_id) ??
+    parseInteger((payload.project as Payload | undefined)?.id) ??
+    parseInteger((payload.target as Payload | undefined)?.project_id);
+  const targetIid = parseTargetIid(payload);
+
+  if (id === undefined || projectId === undefined || targetIid === undefined) {
+    return undefined;
+  }
+
+  const target = payload.target as Payload | undefined;
+  const targetType = typeof payload.target_type === "string" ? payload.target_type : "";
+  const issueIid = targetType === "Issue" ? targetIid : 0;
+  const sourceBranch = targetType === "MergeRequest" && typeof target?.source_branch === "string"
+    ? target.source_branch as string
+    : undefined;
+
+  return {
+    id,
+    projectId,
+    issueIid,
+    targetIid,
+    issueId: parseInteger(target?.id),
+    actionName: typeof payload.action_name === "string" ? payload.action_name : "",
+    targetType,
+    state: typeof payload.state === "string" ? payload.state : "",
+    targetUrl: typeof payload.target_url === "string" ? payload.target_url : undefined,
+    createdAt: typeof payload.created_at === "string" ? payload.created_at : undefined,
+    labels: parseLabels(target),
+    body: typeof payload.body === "string" ? payload.body : undefined,
+    sourceBranch
+  };
+}
+
+function parseIssue(payload: Payload): GitlabIssue {
+  const id = parseInteger(payload.id);
+  const iid = parseInteger(payload.iid);
+  const projectId = parseInteger(payload.project_id);
+
+  if (id === undefined || iid === undefined || projectId === undefined) {
+    throw new Error("GitLab issue payload is missing id/iid/project_id.");
+  }
+
+  return {
+    id,
+    iid,
+    projectId,
+    title: typeof payload.title === "string" ? payload.title : `Issue #${iid}`,
+    description: typeof payload.description === "string" ? payload.description : "",
+    labels: Array.isArray(payload.labels) ? payload.labels.filter((item): item is string => typeof item === "string") : [],
+    webUrl: typeof payload.web_url === "string" ? payload.web_url : "",
+    state: payload.state === "closed" ? "closed" : "opened",
+    stateReason: typeof payload.state_reason === "string" ? payload.state_reason : null
+  };
+}
+
+export class GitlabGlabClient implements GitlabClient {
+  private readonly host: string;
+
+  private readonly token: string;
+
+  private readonly execFileImpl: typeof execFileAsync;
+
+  private readonly retryCount: number;
+
+  constructor(options: GitlabGlabClientOptions) {
+    this.host = options.host.trim();
+    this.token = options.token.trim();
+    this.execFileImpl = options.execFileImpl ?? execFileAsync;
+    this.retryCount = options.retryCount ?? 3;
+  }
+
+  async getCurrentUser(): Promise<GitlabUser> {
+    const payload = (await this.readJson("user")) as Payload;
+    const id = parseInteger(payload.id);
+    const username = typeof payload.username === "string" ? payload.username : "";
+    const name = typeof payload.name === "string" ? payload.name : "";
+
+    if (!id || !username) {
+      throw new Error("Failed to parse current user from GitLab API.");
+    }
+
+    return { id, username, name: name || username };
+  }
+
+  async listMentionedIssueTodos(projectId: number): Promise<GitlabTodoItem[]> {
+    const endpoint = this.withQuery("todos", {
+      state: "pending",
+      type: "Issue",
+      project_id: String(projectId),
+      per_page: "100"
+    });
+    const payload = await this.readJson(endpoint);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => parseTodo((item ?? {}) as Payload))
+      .filter((item): item is GitlabTodoItem => Boolean(item))
+      .sort((left, right) => {
+        if (left.createdAt && right.createdAt) {
+          return left.createdAt.localeCompare(right.createdAt);
+        }
+
+        return left.id - right.id;
+      });
+  }
+
+  async getIssue(projectId: number, issueIid: number): Promise<GitlabIssue> {
+    const payload = await this.readJson(`projects/${projectId}/issues/${issueIid}`);
+    return parseIssue((payload ?? {}) as Payload);
+  }
+
+  async updateIssueLabels(projectId: number, issueIid: number, labels: string[]): Promise<void> {
+    await this.request(`projects/${projectId}/issues/${issueIid}`, {
+      method: "PUT",
+      fields: {
+        labels: labels.join(",")
+      }
+    });
+  }
+
+  async updateIssueDescription(projectId: number, issueIid: number, description: string): Promise<void> {
+    await this.request(`projects/${projectId}/issues/${issueIid}`, {
+      method: "PUT",
+      fields: { description }
+    });
+  }
+
+  async updateIssueTitle(projectId: number, issueIid: number, title: string): Promise<void> {
+    await this.request(`projects/${projectId}/issues/${issueIid}`, {
+      method: "PUT",
+      fields: { title }
+    });
+  }
+
+  async closeIssue(projectId: number, issueIid: number): Promise<void> {
+    await this.request(`projects/${projectId}/issues/${issueIid}`, {
+      method: "PUT",
+      fields: { state_event: "close" }
+    });
+  }
+
+  async addIssueNote(projectId: number, issueIid: number, body: string): Promise<void> {
+    await this.request(`projects/${projectId}/issues/${issueIid}/notes`, {
+      method: "POST",
+      fields: {
+        body
+      }
+    });
+  }
+
+  async getIssueNotes(projectId: number, issueIid: number): Promise<GitlabNote[]> {
+    const payload = await this.readJson(`projects/${projectId}/issues/${issueIid}/notes`);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => {
+        const p = (item ?? {}) as Payload;
+        const id = parseInteger(p.id);
+        if (id === undefined) return undefined;
+        return {
+          id,
+          body: typeof p.body === "string" ? p.body : "",
+          system: p.system === true,
+          createdAt: typeof p.created_at === "string" ? p.created_at : ""
+        } satisfies GitlabNote;
+      })
+      .filter((n): n is GitlabNote => n !== undefined);
+  }
+
+  async markTodoDone(todoId: number): Promise<void> {
+    await this.request(`todos/${todoId}/mark_as_done`, {
+      method: "POST"
+    });
+  }
+
+  async listPendingTodos(projectId: number): Promise<GitlabTodoItem[]> {
+    const endpoint = this.withQuery("todos", {
+      state: "pending",
+      project_id: String(projectId),
+      per_page: "100"
+    });
+    const payload = await this.readJson(endpoint);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => parseTodoUniversal((item ?? {}) as Payload))
+      .filter((item): item is GitlabTodoItem => Boolean(item))
+      .sort((left, right) => {
+        if (left.createdAt && right.createdAt) {
+          return left.createdAt.localeCompare(right.createdAt);
+        }
+        return left.id - right.id;
+      });
+  }
+
+  async addMergeRequestNote(projectId: number, mrIid: number, body: string): Promise<void> {
+    await this.request(`projects/${projectId}/merge_requests/${mrIid}/notes`, {
+      method: "POST",
+      fields: { body }
+    });
+  }
+
+  async getMergeRequestNotes(projectId: number, mrIid: number): Promise<GitlabNote[]> {
+    const payload = await this.readJson(`projects/${projectId}/merge_requests/${mrIid}/notes`);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => {
+        const p = (item ?? {}) as Payload;
+        const id = parseInteger(p.id);
+        if (id === undefined) return undefined;
+        return {
+          id,
+          body: typeof p.body === "string" ? p.body : "",
+          system: p.system === true,
+          createdAt: typeof p.created_at === "string" ? p.created_at : ""
+        } satisfies GitlabNote;
+      })
+      .filter((n): n is GitlabNote => n !== undefined);
+  }
+
+  async createMergeRequest(
+    projectId: number,
+    sourceBranch: string,
+    targetBranch: string,
+    title: string,
+    description: string,
+    issueIid: number
+  ): Promise<MergeRequestResult> {
+    const stdout = await this.request(`projects/${projectId}/merge_requests`, {
+      method: "POST",
+      fields: {
+        source_branch: sourceBranch,
+        target_branch: targetBranch,
+        title,
+        description: `${description}\n\nCloses #${issueIid}`,
+        remove_source_branch: "true"
+      }
+    });
+    const payload = JSON.parse(stdout) as Payload;
+    const iid = parseInteger(payload.iid);
+    const webUrl = typeof payload.web_url === "string" ? payload.web_url : "";
+    if (iid === undefined) {
+      throw new Error("Failed to create merge request: missing iid in response.");
+    }
+    return { iid, webUrl };
+  }
+
+  async createIssue(projectId: number, title: string, description: string, labels: string[]): Promise<{ iid: number }> {
+    const stdout = await this.request(`projects/${projectId}/issues`, {
+      method: "POST",
+      fields: {
+        title,
+        description,
+        labels: labels.join(",")
+      }
+    });
+    const payload = JSON.parse(stdout) as Payload;
+    const iid = parseInteger(payload.iid);
+    if (iid === undefined) {
+      throw new Error("Failed to create issue: missing iid in response.");
+    }
+    return { iid };
+  }
+
+  async searchIssuesByLabel(projectId: number, label: string): Promise<GitlabIssue[]> {
+    const endpoint = this.withQuery(`projects/${projectId}/issues`, {
+      labels: label,
+      state: "opened"
+    });
+    const payload = await this.readJson(endpoint);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => {
+        try {
+          return parseIssue((item ?? {}) as Payload);
+        } catch {
+          return undefined;
+        }
+      })
+      .filter((i): i is GitlabIssue => i !== undefined);
+  }
+
+  async listClosedIssuesByLabel(projectId: number, label: string): Promise<GitlabIssue[]> {
+    const endpoint = this.withQuery(`projects/${projectId}/issues`, {
+      labels: label,
+      state: "closed"
+    });
+    const payload = await this.readJson(endpoint);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => {
+        try {
+          return parseIssue((item ?? {}) as Payload);
+        } catch {
+          return undefined;
+        }
+      })
+      .filter((i): i is GitlabIssue => i !== undefined);
+  }
+
+  async listLabels(projectId: number): Promise<GitlabLabel[]> {
+    const payload = await this.readJson(`projects/${projectId}/labels`);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => {
+        const p = (item ?? {}) as Payload;
+        const id = parseInteger(p.id);
+        if (id === undefined) return undefined;
+        return { id, name: typeof p.name === "string" ? p.name : "" } satisfies GitlabLabel;
+      })
+      .filter((l): l is GitlabLabel => l !== undefined);
+  }
+
+  async createLabel(projectId: number, name: string, color: string): Promise<GitlabLabel> {
+    const stdout = await this.request(`projects/${projectId}/labels`, {
+      method: "POST",
+      fields: { name, color }
+    });
+    const payload = JSON.parse(stdout) as Payload;
+    const id = parseInteger(payload.id);
+    if (id === undefined) {
+      throw new Error(`Failed to create label "${name}": missing id in response.`);
+    }
+    return { id, name };
+  }
+
+  async listBoards(projectId: number): Promise<GitlabBoard[]> {
+    const payload = await this.readJson(`projects/${projectId}/boards`);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => {
+        const p = (item ?? {}) as Payload;
+        const id = parseInteger(p.id);
+        if (id === undefined) return undefined;
+        return { id, name: typeof p.name === "string" ? p.name : "" } satisfies GitlabBoard;
+      })
+      .filter((b): b is GitlabBoard => b !== undefined);
+  }
+
+  async createBoard(projectId: number, name: string): Promise<GitlabBoard> {
+    const stdout = await this.request(`projects/${projectId}/boards`, {
+      method: "POST",
+      fields: { name }
+    });
+    const payload = JSON.parse(stdout) as Payload;
+    const id = parseInteger(payload.id);
+    if (id === undefined) {
+      throw new Error(`Failed to create board "${name}": missing id in response.`);
+    }
+    return { id, name };
+  }
+
+  async createBoardList(projectId: number, boardId: number, labelId: number): Promise<{ id: number }> {
+    const stdout = await this.request(`projects/${projectId}/boards/${boardId}/lists`, {
+      method: "POST",
+      fields: { label_id: String(labelId) }
+    });
+    const payload = JSON.parse(stdout) as Payload;
+    const id = parseInteger(payload.id);
+    if (id === undefined) {
+      throw new Error(`Failed to create board list for labelId=${labelId}: missing id in response.`);
+    }
+    return { id };
+  }
+
+  async updateUserStatus(emoji: string, message: string, availability?: "busy" | "not_set"): Promise<void> {
+    const body: Record<string, string> = { emoji, message };
+    if (availability) {
+      body.availability = availability;
+    }
+    await this.fetchApi("user/status", "PUT", body);
+  }
+
+  async updateUserBio(bio: string): Promise<void> {
+    await this.fetchApi("user", "PUT", { bio });
+  }
+
+  async listAllPendingTodos(): Promise<GitlabTodoItem[]> {
+    const endpoint = this.withQuery("todos", {
+      state: "pending",
+      per_page: "100"
+    });
+    const payload = await this.readJson(endpoint);
+
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+
+    return payload
+      .map((item) => parseTodoUniversal((item ?? {}) as Payload))
+      .filter((item): item is GitlabTodoItem => Boolean(item))
+      .sort((left, right) => {
+        if (left.createdAt && right.createdAt) {
+          return left.createdAt.localeCompare(right.createdAt);
+        }
+        return left.id - right.id;
+      });
+  }
+
+  /**
+   * Direct HTTP call using Node's built-in fetch.
+   * Used for endpoints where glab CLI's response parsing has issues (e.g. PUT /user/status).
+   */
+  private async fetchApi(endpoint: string, method: string, body: Record<string, unknown>): Promise<void> {
+    const protocol = this.host.startsWith("localhost") || this.host.startsWith("127.") ? "http" : "https";
+    const url = `${protocol}://${this.host}/api/v4/${endpoint}`;
+    let lastError: Error | undefined;
+    for (let attempt = 0; attempt <= this.retryCount; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            "PRIVATE-TOKEN": this.token
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          const msg = `GitLab API ${method} ${endpoint} failed: ${response.status} ${response.statusText} ${text}`;
+          if (attempt < this.retryCount && response.status >= 500) {
+            lastError = new Error(msg);
+            await retrySleep(1000 * Math.pow(2, attempt));
+            continue;
+          }
+          throw new Error(msg);
+        }
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.retryCount && isRetryableError(String(error))) {
+          await retrySleep(1000 * Math.pow(2, attempt));
+          continue;
+        }
+        break;
+      }
+    }
+    throw lastError ?? new Error(`fetchApi failed for ${endpoint}`);
+  }
+
+  private async readJson(endpoint: string): Promise<unknown> {
+    const stdout = await this.request(endpoint);
+    return JSON.parse(stdout);
+  }
+
+  private async request(
+    endpoint: string,
+    options: {
+      method?: "GET" | "POST" | "PUT";
+      fields?: Record<string, string>;
+    } = {}
+  ): Promise<string> {
+    const args = ["api"];
+
+    if (options.method) {
+      args.push("--method", options.method);
+    }
+
+    for (const [key, value] of Object.entries(options.fields ?? {})) {
+      args.push("--raw-field", `${key}=${value}`);
+    }
+
+    args.push(endpoint);
+
+    let lastError: Error | undefined;
+    for (let attempt = 0; attempt <= this.retryCount; attempt++) {
+      try {
+        const { stdout } = await this.execFileImpl("glab", args, {
+          encoding: "utf8",
+          maxBuffer: 10 * 1024 * 1024,
+          env: {
+            ...process.env,
+            GITLAB_HOST: this.host,
+            GITLAB_TOKEN: this.token
+          }
+        });
+
+        return stdout;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+
+        if (attempt < this.retryCount && isRetryableError(String(error))) {
+          const delayMs = 1000 * Math.pow(2, attempt); // 1s, 2s, 4s
+          await retrySleep(delayMs);
+          continue;
+        }
+        break;
+      }
+    }
+    throw new Error(`glab api request failed for ${endpoint}: ${String(lastError)}`);
+  }
+
+  private withQuery(endpoint: string, query: Record<string, string>): string {
+    const params = new URLSearchParams(query);
+    return `${endpoint}?${params.toString()}`;
+  }
+}