glab-agent 0.1.0

package/src/local-agent/smoke-test.ts

@@ -0,0 +1,443 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import { readFileSync } from "node:fs";
+import { getAgentNotePrefixes } from "./agent-provider.js";
+import { loadAgentByName } from "./agent-config.js";
+import type { LocalAgentState } from "./state-store.js";
+import { loadConfigFromAgentDefinition } from "./watcher.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface SmokeTestOptions {
+  waitFinish: boolean;
+  pollIntervalSeconds: number;
+  acceptTimeoutSeconds: number;
+  finishTimeoutSeconds: number;
+  titlePrefix: string;
+}
+
+interface GitlabUser {
+  id: number;
+  username: string;
+  name: string;
+  bot?: boolean;
+}
+
+interface GitlabIssue {
+  id: number;
+  iid: number;
+  title: string;
+  description?: string;
+  labels: string[];
+  web_url: string;
+}
+
+interface GitlabTodo {
+  id: number;
+  action_name: string;
+  target_type: string;
+  state: string;
+  target?: {
+    iid?: number;
+  };
+}
+
+interface GitlabNote {
+  id: number;
+  body: string;
+}
+
+interface GitlabLabelEvent {
+  action: string;
+  label?: {
+    name?: string;
+  };
+}
+
+interface AcceptanceResult {
+  observedTodoAction?: string;
+  state: LocalAgentState;
+}
+
+interface ExecResult {
+  stdout: string;
+  stderr: string;
+}
+
+function printUsage(): void {
+  console.log(`Usage: pnpm smoke-test [--wait-finish] [--poll-interval-seconds=N] [--accept-timeout-seconds=N] [--finish-timeout-seconds=N] [--title-prefix=TEXT]
+
+Creates a real GitLab issue with the locally logged-in glab user, @mentions the bot user from .env,
+starts the watcher if needed, and verifies the acceptance path. Add --wait-finish to keep polling
+until the issue reaches In Review or a failure note is posted.`);
+}
+
+export function parseSmokeTestArgs(argv: string[]): SmokeTestOptions {
+  const options: SmokeTestOptions = {
+    waitFinish: false,
+    pollIntervalSeconds: 3,
+    acceptTimeoutSeconds: 180,
+    finishTimeoutSeconds: 900,
+    titlePrefix: "[smoke]"
+  };
+
+  for (const arg of argv) {
+    if (arg === "--") {
+      continue;
+    }
+
+    if (arg === "--help" || arg === "-h") {
+      printUsage();
+      process.exit(0);
+    }
+
+    if (arg === "--wait-finish") {
+      options.waitFinish = true;
+      continue;
+    }
+
+    if (arg.startsWith("--poll-interval-seconds=")) {
+      options.pollIntervalSeconds = parsePositiveInteger(arg, "--poll-interval-seconds");
+      continue;
+    }
+
+    if (arg.startsWith("--accept-timeout-seconds=")) {
+      options.acceptTimeoutSeconds = parsePositiveInteger(arg, "--accept-timeout-seconds");
+      continue;
+    }
+
+    if (arg.startsWith("--finish-timeout-seconds=")) {
+      options.finishTimeoutSeconds = parsePositiveInteger(arg, "--finish-timeout-seconds");
+      continue;
+    }
+
+    if (arg.startsWith("--title-prefix=")) {
+      options.titlePrefix = arg.slice("--title-prefix=".length).trim() || "[smoke]";
+      continue;
+    }
+
+    throw new Error(`Unsupported argument: ${arg}`);
+  }
+
+  return options;
+}
+
+function parsePositiveInteger(arg: string, flag: string): number {
+  const value = Number.parseInt(arg.slice(flag.length + 1), 10);
+
+  if (Number.isNaN(value) || value <= 0) {
+    throw new Error(`${flag} must be a positive integer.`);
+  }
+
+  return value;
+}
+
+export function buildSmokeIssueDescription(user: GitlabUser, bot: GitlabUser, runId: string): string {
+  return [
+    `Smoke test run: ${runId}`,
+    `Creator: @${user.username}`,
+    "",
+    "Please let the local GitLab To-Do watcher pick up this issue.",
+    "",
+    `@${bot.username}`
+  ].join("\n");
+}
+
+export function findTodoForIssue(todos: GitlabTodo[], issueIid: number): GitlabTodo | undefined {
+  return todos.find(
+    (todo) => todo.state === "pending" && todo.target_type === "Issue" && todo.target?.iid === issueIid
+  );
+}
+
+export function hasAddedLabelEvent(events: GitlabLabelEvent[], labelName: string): boolean {
+  return events.some((event) => event.action === "add" && event.label?.name === labelName);
+}
+
+function hasNote(notes: GitlabNote[], prefix: string): boolean {
+  return notes.some((note) => note.body.startsWith(prefix));
+}
+
+function getNote(notes: GitlabNote[], prefix: string): GitlabNote | undefined {
+  return notes.find((note) => note.body.startsWith(prefix));
+}
+
+async function execCommand(
+  file: string,
+  args: string[],
+  options: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+  } = {}
+): Promise<ExecResult> {
+  try {
+    const { stdout, stderr } = await execFileAsync(file, args, {
+      cwd: options.cwd,
+      env: options.env,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+
+    return {
+      stdout: stdout.trim(),
+      stderr: stderr.trim()
+    };
+  } catch (error) {
+    const execError = error as {
+      stdout?: string;
+      stderr?: string;
+      message?: string;
+    };
+    const output = [execError.stdout, execError.stderr, execError.message].filter(Boolean).join("\n");
+    throw new Error(`${file} ${args.join(" ")} failed.\n${output}`.trim());
+  }
+}
+
+async function glabApiJson<T>(
+  host: string,
+  endpoint: string,
+  env: NodeJS.ProcessEnv,
+  extraArgs: string[] = []
+): Promise<T> {
+  const result = await execCommand("glab", ["api", ...extraArgs, endpoint], { env: { ...env, GITLAB_HOST: host } });
+
+  try {
+    return JSON.parse(result.stdout) as T;
+  } catch {
+    const details = [result.stdout, result.stderr].filter(Boolean).join("\n");
+    throw new Error(`glab api ${endpoint} returned non-JSON output.\n${details}`.trim());
+  }
+}
+
+function buildUserEnv(host: string): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env, GITLAB_HOST: host };
+  delete env.GITLAB_TOKEN;
+  return env;
+}
+
+function buildBotEnv(host: string, token: string): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    GITLAB_HOST: host,
+    GITLAB_TOKEN: token
+  };
+}
+
+async function readState(statePath: string): Promise<LocalAgentState> {
+  try {
+    const content = await readFile(statePath, "utf8");
+    return JSON.parse(content) as LocalAgentState;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return {
+        processedTodoIds: [],
+        processedIssueIds: [],
+        notifiedBusyTodoIds: []
+      };
+    }
+
+    throw error;
+  }
+}
+
+async function sleep(milliseconds: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function loadDotenv(filePath: string): void {
+  try {
+    const content = readFileSync(filePath, "utf8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx <= 0) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      const value = trimmed.slice(eqIdx + 1).trim();
+      if (!(key in process.env)) {
+        process.env[key] = value;
+      }
+    }
+  } catch {
+    // ignore
+  }
+}
+
+async function waitForAcceptance(
+  host: string,
+  projectId: number,
+  issueIid: number,
+  statePath: string,
+  userEnv: NodeJS.ProcessEnv,
+  botEnv: NodeJS.ProcessEnv,
+  notePrefixes: ReturnType<typeof getAgentNotePrefixes>,
+  options: SmokeTestOptions
+): Promise<AcceptanceResult> {
+  const deadline = Date.now() + options.acceptTimeoutSeconds * 1000;
+  let observedTodoAction: string | undefined;
+
+  while (Date.now() <= deadline) {
+    const [issue, notes, events, state, todos] = await Promise.all([
+      glabApiJson<GitlabIssue>(host, `projects/${projectId}/issues/${issueIid}`, userEnv),
+      glabApiJson<GitlabNote[]>(host, `projects/${projectId}/issues/${issueIid}/notes?per_page=20`, userEnv),
+      glabApiJson<GitlabLabelEvent[]>(
+        host,
+        `projects/${projectId}/issues/${issueIid}/resource_label_events?per_page=20`,
+        userEnv
+      ),
+      readState(statePath),
+      glabApiJson<GitlabTodo[]>(host, "todos?state=pending&per_page=100", botEnv)
+    ]);
+
+    const todo = findTodoForIssue(todos, issueIid);
+    if (!observedTodoAction && todo) {
+      observedTodoAction = todo.action_name;
+    }
+
+    const accepted = hasNote(notes, notePrefixes.accepted);
+    const inProgress = issue.labels.includes("In Progress") || hasAddedLabelEvent(events, "In Progress");
+    const stateMatched =
+      state.activeRun?.issueIid === issueIid ||
+      state.lastRun?.issueIid === issueIid ||
+      hasNote(notes, notePrefixes.completed) ||
+      hasNote(notes, notePrefixes.failed);
+
+    if (accepted && inProgress && stateMatched) {
+      return { observedTodoAction, state };
+    }
+
+    await sleep(options.pollIntervalSeconds * 1000);
+  }
+
+  throw new Error(`Timed out waiting for issue #${issueIid} to be accepted by the watcher.`);
+}
+
+async function waitForFinish(
+  host: string,
+  projectId: number,
+  issueIid: number,
+  statePath: string,
+  userEnv: NodeJS.ProcessEnv,
+  notePrefixes: ReturnType<typeof getAgentNotePrefixes>,
+  options: SmokeTestOptions
+): Promise<void> {
+  const deadline = Date.now() + options.finishTimeoutSeconds * 1000;
+
+  while (Date.now() <= deadline) {
+    const [issue, notes, events, state] = await Promise.all([
+      glabApiJson<GitlabIssue>(host, `projects/${projectId}/issues/${issueIid}`, userEnv),
+      glabApiJson<GitlabNote[]>(host, `projects/${projectId}/issues/${issueIid}/notes?per_page=20`, userEnv),
+      glabApiJson<GitlabLabelEvent[]>(
+        host,
+        `projects/${projectId}/issues/${issueIid}/resource_label_events?per_page=20`,
+        userEnv
+      ),
+      readState(statePath)
+    ]);
+
+    const completedNote = getNote(notes, notePrefixes.completed);
+    const failedNote = getNote(notes, notePrefixes.failed);
+    const inReview = issue.labels.includes("In Review") || hasAddedLabelEvent(events, "In Review");
+    const activeRunCleared = state.activeRun?.issueIid !== issueIid;
+
+    if (completedNote && inReview && activeRunCleared) {
+      return;
+    }
+
+    if (failedNote && activeRunCleared) {
+      throw new Error(`Watcher picked up issue #${issueIid}, but agent execution failed.\n${failedNote.body}`);
+    }
+
+    await sleep(options.pollIntervalSeconds * 1000);
+  }
+
+  throw new Error(`Timed out waiting for issue #${issueIid} to reach In Review.`);
+}
+
+export async function main(argv: string[] = process.argv.slice(2)): Promise<void> {
+  const options = parseSmokeTestArgs(argv);
+  const repoRoot = path.resolve(path.join(path.dirname(new URL(import.meta.url).pathname), "../.."));
+
+  loadDotenv(path.join(repoRoot, ".env"));
+
+  // Find first available agent definition
+  const agentsDir = path.join(repoRoot, "agents");
+  const { discoverAgents } = await import("./agent-config.js");
+  const agents = await discoverAgents(agentsDir);
+  if (agents.length === 0) {
+    throw new Error("No agent definitions found in agents/*.yaml. Create one first.");
+  }
+  const agentDef = agents[0];
+  const config = loadConfigFromAgentDefinition(agentDef);
+  const notePrefixes = getAgentNotePrefixes(config.agentProvider);
+  const userEnv = buildUserEnv(config.gitlabHost);
+  const botEnv = buildBotEnv(config.gitlabHost, config.gitlabToken);
+
+  const [user, bot] = await Promise.all([
+    glabApiJson<GitlabUser>(config.gitlabHost, "user", userEnv),
+    glabApiJson<GitlabUser>(config.gitlabHost, "user", botEnv)
+  ]);
+
+  const existingState = await readState(config.statePath);
+  if (existingState.activeRun) {
+    throw new Error(
+      `Watcher is already busy with issue #${existingState.activeRun.issueIid}. Wait for it to finish before running smoke-test.`
+    );
+  }
+
+  const runId = new Date().toISOString().replace(/[:.]/g, "-");
+  const title = `${options.titlePrefix} watcher smoke ${runId}`;
+  const description = buildSmokeIssueDescription(user, bot, runId);
+
+  const issue = await glabApiJson<GitlabIssue>(config.gitlabHost, `projects/${config.gitlabProjectId}/issues`, userEnv, [
+    "--method",
+    "POST",
+    "--raw-field",
+    `title=${title}`,
+    "--raw-field",
+    `description=${description}`,
+    "--raw-field",
+    "labels=Backlog"
+  ]);
+
+  console.log(`Created issue #${issue.iid}: ${issue.web_url}`);
+  console.log(`User: @${user.username}`);
+  console.log(`Bot: @${bot.username}`);
+
+  const acceptance = await waitForAcceptance(
+    config.gitlabHost,
+    config.gitlabProjectId!,
+    issue.iid,
+    config.statePath,
+    userEnv,
+    botEnv,
+    notePrefixes,
+    options
+  );
+
+  console.log(`Accepted issue #${issue.iid}.`);
+  if (acceptance.observedTodoAction) {
+    console.log(`Observed bot todo action: ${acceptance.observedTodoAction}`);
+  }
+
+  if (options.waitFinish) {
+    await waitForFinish(
+      config.gitlabHost,
+      config.gitlabProjectId!,
+      issue.iid,
+      config.statePath,
+      userEnv,
+      notePrefixes,
+      options
+    );
+    console.log(`Issue #${issue.iid} reached In Review.`);
+  } else {
+    console.log("Acceptance path verified. Re-run with --wait-finish to verify the full loop.");
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  void main();
+}

package/src/local-agent/state-store.ts

@@ -0,0 +1,186 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export interface ActiveRunState {
+  pid: number;
+  todoId: number;
+  issueId: number;
+  issueIid: number;
+  projectId?: number;
+  worktreePath: string;
+  branch: string;
+  startedAt: string;
+}
+
+export interface LastRunState {
+  status: "idle" | "running" | "completed" | "failed" | "recovered";
+  at: string;
+  issueIid?: number;
+  summary?: string;
+  branch?: string;
+  worktreePath?: string;
+}
+
+export interface RunHistoryEntry {
+  issueIid: number;
+  issueTitle?: string;
+  status: "completed" | "failed";
+  startedAt: string;
+  finishedAt: string;
+  branch?: string;
+  mrUrl?: string;
+  summary?: string;
+}
+
+export interface LocalAgentState {
+  processedTodoIds: number[];
+  processedIssueIds: number[];
+  notifiedBusyTodoIds: number[];
+  activeRun?: ActiveRunState;
+  /** Multi-concurrency: tracks all active runs when concurrency > 1 */
+  activeRuns?: ActiveRunState[];
+  lastRun?: LastRunState;
+  runHistory?: RunHistoryEntry[];
+}
+
+export interface StateStore {
+  load(): Promise<LocalAgentState>;
+  save(state: LocalAgentState): Promise<void>;
+}
+
+const HISTORY_LIMIT = 200;
+const MAX_RUN_HISTORY = 100;
+
+export function appendRunHistory(state: LocalAgentState, entry: RunHistoryEntry): void {
+  if (!state.runHistory) state.runHistory = [];
+  state.runHistory.push(entry);
+  if (state.runHistory.length > MAX_RUN_HISTORY) {
+    state.runHistory = state.runHistory.slice(-MAX_RUN_HISTORY);
+  }
+}
+
+export function createEmptyState(): LocalAgentState {
+  return {
+    processedTodoIds: [],
+    processedIssueIds: [],
+    notifiedBusyTodoIds: []
+  };
+}
+
+/** Get all currently active runs (unified view across single/multi mode) */
+export function getActiveRuns(state: LocalAgentState): ActiveRunState[] {
+  if (state.activeRuns && state.activeRuns.length > 0) return state.activeRuns;
+  if (state.activeRun) return [state.activeRun];
+  return [];
+}
+
+/** Count active runs with live PIDs */
+export function countActiveRuns(state: LocalAgentState, isPidAlive: (pid: number) => boolean): number {
+  return getActiveRuns(state).filter(r => isPidAlive(r.pid)).length;
+}
+
+/** Add a run to activeRuns (multi-concurrency mode) */
+export function addActiveRun(state: LocalAgentState, run: ActiveRunState): void {
+  if (!state.activeRuns) state.activeRuns = [];
+  state.activeRuns.push(run);
+  // Keep activeRun in sync for backward compatibility (most recent)
+  state.activeRun = run;
+}
+
+/** Remove a run from activeRuns by issueIid */
+export function removeActiveRun(state: LocalAgentState, issueIid: number): ActiveRunState | undefined {
+  if (!state.activeRuns) {
+    if (state.activeRun?.issueIid === issueIid) {
+      const removed = state.activeRun;
+      state.activeRun = undefined;
+      return removed;
+    }
+    return undefined;
+  }
+  const idx = state.activeRuns.findIndex(r => r.issueIid === issueIid);
+  if (idx < 0) return undefined;
+  const [removed] = state.activeRuns.splice(idx, 1);
+  // Sync activeRun: set to most recent remaining, or undefined
+  state.activeRun = state.activeRuns.length > 0 ? state.activeRuns[state.activeRuns.length - 1] : undefined;
+  return removed;
+}
+
+export function rememberIds(ids: number[], nextId: number): number[] {
+  const unique = ids.filter((id) => id !== nextId);
+  unique.push(nextId);
+  return unique.slice(Math.max(0, unique.length - HISTORY_LIMIT));
+}
+
+export class FileStateStore implements StateStore {
+  private readonly filePath: string;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+  }
+
+  async load(): Promise<LocalAgentState> {
+    try {
+      const content = await readFile(this.filePath, "utf8");
+      return this.parseState(content);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return this.tryLoadBackup();
+      }
+      if (error instanceof SyntaxError) {
+        return this.tryLoadBackup();
+      }
+      throw error;
+    }
+  }
+
+  private parseState(content: string): LocalAgentState {
+    const parsed = JSON.parse(content) as Partial<LocalAgentState>;
+    return {
+      processedTodoIds: Array.isArray(parsed.processedTodoIds)
+        ? parsed.processedTodoIds.filter((item): item is number => typeof item === "number")
+        : [],
+      processedIssueIds: Array.isArray(parsed.processedIssueIds)
+        ? parsed.processedIssueIds.filter((item): item is number => typeof item === "number")
+        : [],
+      notifiedBusyTodoIds: Array.isArray(parsed.notifiedBusyTodoIds)
+        ? parsed.notifiedBusyTodoIds.filter((item): item is number => typeof item === "number")
+        : [],
+      activeRun: parsed.activeRun,
+      activeRuns: Array.isArray(parsed.activeRuns) ? parsed.activeRuns : undefined,
+      lastRun: parsed.lastRun,
+      runHistory: Array.isArray(parsed.runHistory) ? parsed.runHistory : undefined
+    };
+  }
+
+  private async tryLoadBackup(): Promise<LocalAgentState> {
+    const bakPath = this.filePath + ".bak";
+    try {
+      const content = await readFile(bakPath, "utf8");
+      console.warn(`[state-store] Primary state file corrupted or missing, recovered from backup: ${bakPath}`);
+      return this.parseState(content);
+    } catch {
+      console.error(`[state-store] Both primary and backup state files unavailable, starting fresh.`);
+      return createEmptyState();
+    }
+  }
+
+  async save(state: LocalAgentState): Promise<void> {
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    const content = JSON.stringify(state, null, 2);
+    const tmpPath = this.filePath + ".tmp";
+    const bakPath = this.filePath + ".bak";
+
+    // Write to temp file first
+    await writeFile(tmpPath, content, "utf8");
+
+    // Backup current file (ignore if not exists)
+    try {
+      await rename(this.filePath, bakPath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+
+    // Atomic rename temp → target
+    await rename(tmpPath, this.filePath);
+  }
+}

package/src/local-agent/token-check.ts

@@ -0,0 +1,37 @@
+import type { GitlabClient } from "./gitlab-glab-client.js";
+import type { Logger } from "./logger.js";
+
+export interface TokenCheckResult {
+  valid: boolean;
+  username?: string;
+  error?: string;
+}
+
+/**
+ * Validate a GitLab token by calling the /user endpoint.
+ */
+export async function validateToken(gitlabClient: GitlabClient): Promise<TokenCheckResult> {
+  try {
+    const user = await gitlabClient.getCurrentUser();
+    return { valid: true, username: user.username };
+  } catch (error) {
+    return { valid: false, error: String(error) };
+  }
+}
+
+/**
+ * Validate token and log result. Returns true if valid.
+ */
+export async function checkTokenWithLogging(
+  gitlabClient: GitlabClient,
+  agentName: string,
+  logger: Logger
+): Promise<boolean> {
+  const result = await validateToken(gitlabClient);
+  if (result.valid) {
+    logger.info(`[${agentName}] Token valid (authenticated as @${result.username})`);
+    return true;
+  }
+  logger.error(`[${agentName}] Token validation failed: ${result.error}`);
+  return false;
+}