glab-agent 0.1.0

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

@@ -0,0 +1,153 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import type { GitlabIssue } from "./gitlab-glab-client.js";
+import type { WorktreeInfo } from "./worktree-manager.js";
+import {
+  AgentRunnerError,
+  type AgentRunContext,
+  type AgentRunResult,
+  type AgentRunner,
+  type AgentRunnerOptions,
+  buildAgentPrompt,
+  createOutputPath,
+  isSmokeIssue,
+  readSummary,
+  runSmokeTestChecks
+} from "./agent-runner.js";
+import { createLogger, type Logger } from "./logger.js";
+
+const execFileAsync = promisify(execFile);
+
+export class CodexRunner implements AgentRunner {
+  private readonly execFileImpl: typeof execFileAsync;
+
+  private readonly env: NodeJS.ProcessEnv;
+
+  private readonly repoPath?: string;
+
+  private readonly gitlabHost: string;
+
+  private readonly gitlabProjectId: number;
+
+  private readonly agentDefinition?: import("./agent-config.js").AgentDefinition;
+
+  private readonly logger: Logger;
+
+  private readonly timeoutSeconds?: number;
+
+  constructor(options: AgentRunnerOptions = {}) {
+    this.execFileImpl = options.execFileImpl ?? execFileAsync;
+    this.env = options.env ?? process.env;
+    this.repoPath = options.repoPath;
+    this.gitlabHost = options.gitlabHost ?? "";
+    this.gitlabProjectId = options.gitlabProjectId ?? 0;
+    this.agentDefinition = options.agentDefinition;
+    this.logger = options.logger ?? createLogger("runner", options.agentDefinition?.name);
+    this.timeoutSeconds = options.timeoutSeconds ?? options.agentDefinition?.timeout_seconds;
+  }
+
+  async run(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<AgentRunResult> {
+    const signal = context?.signal;
+    const outputPath = await createOutputPath("codex", issue.iid);
+
+    if (isSmokeIssue(issue)) {
+      return runSmokeTestChecks(issue, worktree, outputPath, this.execFileImpl, this.env, this.repoPath);
+    }
+
+    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,
+      // skills injected via .agent_context/skills/*.md files, not in prompt
+    });
+    const codexCommand = resolveCodexCommand(this.env);
+
+    this.logger.info(`Executing: ${codexCommand} exec --full-auto -C ${worktree.worktreePath}`);
+    this.logger.info(`Prompt (${prompt.length} chars): issue #${issue.iid} "${issue.title}"`);
+
+    const codexLogPath = outputPath.replace("last-message.txt", "codex-output.log");
+    const timeoutMs = this.timeoutSeconds ? this.timeoutSeconds * 1000 : 0;
+    if (this.timeoutSeconds) {
+      this.logger.info(`Timeout: ${this.timeoutSeconds}s`);
+    }
+
+    try {
+      const codexArgs = ["exec", "--full-auto", "-C", worktree.worktreePath, "--output-last-message", outputPath];
+      if (this.agentDefinition?.model) {
+        codexArgs.push("--model", this.agentDefinition.model);
+      }
+      codexArgs.push(prompt);
+
+      const { stdout, stderr } = await this.execFileImpl(
+        codexCommand,
+        codexArgs,
+        {
+          encoding: "utf8",
+          maxBuffer: 10 * 1024 * 1024,
+          env: this.env,
+          ...(timeoutMs > 0 ? { timeout: timeoutMs, killSignal: "SIGTERM" } : {}),
+          ...(signal ? { signal } : {})
+        }
+      );
+
+      const output = [stdout, stderr].filter(Boolean).join("\n--- stderr ---\n");
+      await writeFile(codexLogPath, output || "(no output)", "utf8");
+      if (output) {
+        this.logger.info(`Codex output (last 300): ${output.slice(-300)}`);
+      }
+    } catch (error) {
+      const execError = error as { stdout?: string; stderr?: string; killed?: boolean };
+      const isTimeout = execError.killed === true && timeoutMs > 0;
+      const output = [execError.stdout, execError.stderr].filter(Boolean).join("\n--- stderr ---\n");
+      await writeFile(codexLogPath, output || String(error), "utf8").catch(() => undefined);
+      if (isTimeout) {
+        this.logger.error(`Timed out after ${this.timeoutSeconds}s.`);
+        throw new AgentRunnerError(
+          `Codex timed out after ${this.timeoutSeconds}s.`,
+          `Timed out after ${this.timeoutSeconds}s`,
+          outputPath
+        );
+      }
+      if (execError.stderr) {
+        this.logger.error(`Stderr: ${execError.stderr.slice(0, 500)}`);
+      }
+      this.logger.error(`Failed: ${String(error).slice(0, 300)}`);
+      const summary = await readSummary(outputPath, `Codex execution failed: ${String(error)}`);
+      throw new AgentRunnerError("Codex execution failed.", summary, outputPath);
+    }
+
+    this.logger.info(`Finished. Output: ${outputPath} | Log: ${codexLogPath}`);
+
+    return {
+      summary: await readSummary(outputPath, "Codex finished without a final summary."),
+      outputPath
+    };
+  }
+}
+
+export function resolveCodexCommand(env: NodeJS.ProcessEnv = process.env): string {
+  const explicit = env.CODEX_BIN?.trim();
+
+  if (explicit) {
+    return explicit;
+  }
+
+  const homeCodex = path.join(homedir(), ".local", "bin", "codex");
+  if (existsSync(homeCodex)) {
+    return homeCodex;
+  }
+
+  return "codex";
+}