@launchchair/agent 0.4.0

package/local-bridge.mjs

@@ -0,0 +1,540 @@
+#!/usr/bin/env node
+
+/**
+ * LaunchChair local bridge.
+ *
+ * Supports:
+ * - mode-based runner routing (gpt vs codex)
+ * - target-based routing (chatgpt, claude, codex, claude_code)
+ * - queue claim/complete loop for Run with Agent
+ */
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { buildRunnerCommand, parseRunnerCommand } from "./runner-command.mjs";
+
+const VERSION = "0.4.0";
+const CLIENT_TYPES = ["codex", "chatgpt", "claude", "claude_code", "other"];
+const AGENT_SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+function nodeScriptCommand(scriptName) {
+  return `${JSON.stringify(process.execPath)} ${JSON.stringify(path.join(AGENT_SCRIPT_DIR, scriptName))}`;
+}
+
+function toInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function env(name, fallback = "") {
+  const value = process.env[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+function hasArg(name) {
+  return process.argv.includes(name);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function trimToBytes(input, maxBytes) {
+  const text = String(input ?? "");
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  const prefix = text.slice(0, Math.floor(text.length * 0.45));
+  const suffix = text.slice(Math.floor(text.length * 0.85));
+  const marker = "\n\n...[truncated by local bridge]...\n\n";
+  let result = `${prefix}${marker}${suffix}`;
+  while (Buffer.byteLength(result, "utf8") > maxBytes && result.length > 64) {
+    result = result.slice(0, Math.floor(result.length * 0.9));
+  }
+  return result;
+}
+
+function normalizeTarget(value, fallback = "other") {
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, "_");
+  if (CLIENT_TYPES.includes(normalized)) return normalized;
+  return fallback;
+}
+
+function hasOpenAiKey() {
+  return String(process.env.OPENAI_API_KEY ?? "").trim().length > 0;
+}
+
+function hasAnthropicKey() {
+  return String(process.env.ANTHROPIC_API_KEY ?? "").trim().length > 0;
+}
+
+function builtInRunnerCommand(target) {
+  if (target === "codex") {
+    return nodeScriptCommand("codex-runner.mjs");
+  }
+  if (target === "claude_code") {
+    return nodeScriptCommand("claude-code-runner.mjs");
+  }
+  if (target === "chatgpt" && hasOpenAiKey()) {
+    return nodeScriptCommand("chatgpt-runner.mjs");
+  }
+  if (target === "claude" && hasAnthropicKey()) {
+    return nodeScriptCommand("claude-runner.mjs");
+  }
+  return "";
+}
+
+function printHelp() {
+  // eslint-disable-next-line no-console
+  console.log(`
+LaunchChair local bridge v${VERSION}
+
+Required env:
+  LAUNCHCHAIR_AGENT_TOKEN
+
+Optional env:
+  LAUNCHCHAIR_BASE_URL           Default: http://localhost:3000
+  LAUNCHCHAIR_PROJECT_ID         Restrict heartbeat/claim to one project (UUID)
+  LC_AGENT_CLIENT_NAME           Default: Local Bridge
+  LC_AGENT_CLIENT_TYPE           codex|chatgpt|claude|claude_code|other|auto (default: auto)
+  LC_AGENT_CLIENT_VERSION        Default: ${VERSION}
+  LC_AGENT_POLL_MS               Default: 2500
+  LC_AGENT_HEARTBEAT_MS          Default: 15000
+  AGENT_MOCK_RESPONSE            If set, skips runner command and returns this payload
+  OPENAI_API_KEY                 Enables built-in ChatGPT runner fallback
+  ANTHROPIC_API_KEY              Enables built-in Claude runner fallback
+  LC_AGENT_CODEX_CWD             Folder codex-runner should build in (default: bridge cwd)
+  LC_AGENT_CODEX_SANDBOX         read-only|workspace-write|danger-full-access (default: workspace-write)
+  LC_AGENT_CODEX_MODEL           Optional Codex model override
+  LC_AGENT_CLAUDE_CODE_CWD       Folder claude-code-runner should build in (default: bridge cwd)
+  LC_AGENT_CLAUDE_CODE_MODEL     Optional Claude Code model override
+  LC_AGENT_CLAUDE_CODE_ALLOWED_TOOLS
+                                 Optional Claude Code allowedTools list
+  LC_AGENT_CLAUDE_CODE_PERMISSION_MODE
+                                 Optional Claude Code permission mode
+  LC_AGENT_OPENAI_MODEL          Optional model override for chatgpt-runner
+  LC_AGENT_ANTHROPIC_MODEL       Optional model override for claude-runner
+
+Mode router env:
+  LC_AGENT_ROUTER_GPT_TARGET     codex|chatgpt|claude|claude_code|other (default: codex)
+  LC_AGENT_ROUTER_CODEX_TARGET   codex|claude_code|other (default: codex)
+
+Runner command env (priority order by mode + target):
+  LC_AGENT_RUNNER_CMD_CHATGPT
+  LC_AGENT_RUNNER_CMD_CLAUDE
+  LC_AGENT_RUNNER_CMD_CODEX
+  LC_AGENT_RUNNER_CMD_CLAUDE_CODE
+  LC_AGENT_RUNNER_CMD_GPT
+  LC_AGENT_RUNNER_CMD_CODEX
+  LC_AGENT_RUNNER_CMD
+
+Built-in fallback runners (if no explicit LC_AGENT_RUNNER_CMD* set):
+  gpt->codex uses node ./scripts/agent/codex-runner.mjs (reuses Codex CLI auth)
+  codex->codex uses node ./scripts/agent/codex-runner.mjs (reuses Codex CLI auth)
+  gpt->claude_code uses node ./scripts/agent/claude-code-runner.mjs (reuses Claude Code auth)
+  codex->claude_code uses node ./scripts/agent/claude-code-runner.mjs (reuses Claude Code auth)
+  gpt->chatgpt uses node ./scripts/agent/chatgpt-runner.mjs (requires OPENAI_API_KEY)
+  gpt->claude uses node ./scripts/agent/claude-runner.mjs (requires ANTHROPIC_API_KEY)
+
+CLI flags:
+  --once
+  --verbose
+  --help
+
+Runner placeholders:
+  {{PROMPT}}      JSON-quoted prompt token
+  {{PROMPT_B64}}  base64 prompt
+  {{RUN_ID}}      agent run id
+  {{PROJECT_ID}}  project id
+`);
+}
+
+const config = {
+  baseUrl: env("LAUNCHCHAIR_BASE_URL", "http://localhost:3000").replace(/\/+$/, ""),
+  token: env("LAUNCHCHAIR_AGENT_TOKEN", env("LAUNCHCHAIR_API_KEY")),
+  projectId: env("LAUNCHCHAIR_PROJECT_ID") || null,
+  clientName: env("LC_AGENT_CLIENT_NAME", "Local Bridge"),
+  clientType: env("LC_AGENT_CLIENT_TYPE", "auto"),
+  clientVersion: env("LC_AGENT_CLIENT_VERSION", VERSION),
+  pollMs: toInt(process.env.LC_AGENT_POLL_MS, 2500),
+  heartbeatMs: toInt(process.env.LC_AGENT_HEARTBEAT_MS, 15000),
+  maxPayloadBytes: 850 * 1024,
+  mockResponse: process.env.AGENT_MOCK_RESPONSE ?? "",
+  once: hasArg("--once"),
+  verbose: hasArg("--verbose"),
+  modeTargets: {
+    gpt: normalizeTarget(env("LC_AGENT_ROUTER_GPT_TARGET", "codex"), "codex"),
+    codex: normalizeTarget(env("LC_AGENT_ROUTER_CODEX_TARGET", "codex"), "codex"),
+  },
+  runnerCommands: {
+    generic: env("LC_AGENT_RUNNER_CMD"),
+    gpt: env("LC_AGENT_RUNNER_CMD_GPT"),
+    codex: env("LC_AGENT_RUNNER_CMD_CODEX"),
+    chatgpt: env("LC_AGENT_RUNNER_CMD_CHATGPT", builtInRunnerCommand("chatgpt")),
+    claude: env("LC_AGENT_RUNNER_CMD_CLAUDE", builtInRunnerCommand("claude")),
+    codexTarget: env("LC_AGENT_RUNNER_CMD_CODEX", builtInRunnerCommand("codex")),
+    claudeCode: env("LC_AGENT_RUNNER_CMD_CLAUDE_CODE", builtInRunnerCommand("claude_code")),
+  },
+};
+
+if (hasArg("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
+if (!config.token) {
+  // eslint-disable-next-line no-console
+  console.error("Missing LAUNCHCHAIR_AGENT_TOKEN. LAUNCHCHAIR_API_KEY is also supported as an alias.");
+  printHelp();
+  process.exit(1);
+}
+
+function hasAnyRunnerCommand() {
+  if (config.mockResponse) return true;
+  const values = [
+    config.runnerCommands.generic,
+    config.runnerCommands.gpt,
+    config.runnerCommands.codex,
+    config.runnerCommands.chatgpt,
+    config.runnerCommands.claude,
+    config.runnerCommands.codexTarget,
+    config.runnerCommands.claudeCode,
+  ];
+  return values.some((value) => String(value ?? "").trim().length > 0);
+}
+
+if (!hasAnyRunnerCommand()) {
+  // eslint-disable-next-line no-console
+  console.error(
+    "No runner command configured. Set AGENT_MOCK_RESPONSE, LC_AGENT_RUNNER_CMD*, or use the built-in Codex/Claude Code runners; ChatGPT/Claude API fallbacks require provider API keys.",
+  );
+  printHelp();
+  process.exit(1);
+}
+
+function log(...args) {
+  // eslint-disable-next-line no-console
+  console.log("[agent-bridge]", ...args);
+}
+
+function logVerbose(...args) {
+  if (!config.verbose) return;
+  // eslint-disable-next-line no-console
+  console.log("[agent-bridge:verbose]", ...args);
+}
+
+async function api(path, { method = "GET", body } = {}) {
+  const response = await fetch(`${config.baseUrl}${path}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${config.token}`,
+      "Content-Type": "application/json",
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+
+  let payload = null;
+  try {
+    payload = await response.json();
+  } catch (_error) {
+    payload = null;
+  }
+
+  if (!response.ok) {
+    const err = new Error(`HTTP ${response.status}: ${String(payload?.error ?? response.statusText ?? "Request failed")}`);
+    err.status = response.status;
+    err.payload = payload;
+    err.retryAfterSeconds = Number.parseInt(response.headers.get("retry-after") ?? "", 10) || null;
+    throw err;
+  }
+  return payload;
+}
+
+function getTargetForRun(run) {
+  const mode = String(run?.promptMode ?? "").trim().toLowerCase();
+  if (mode === "gpt") return config.modeTargets.gpt;
+  if (mode === "codex") return config.modeTargets.codex;
+  return "other";
+}
+
+function getCommandForRun(run) {
+  const mode = String(run?.promptMode ?? "").trim().toLowerCase();
+  const target = getTargetForRun(run);
+
+  if (mode === "gpt") {
+    if (target === "codex" && config.runnerCommands.codexTarget) return config.runnerCommands.codexTarget;
+    if (target === "claude_code" && config.runnerCommands.claudeCode) return config.runnerCommands.claudeCode;
+    if (target === "chatgpt" && config.runnerCommands.chatgpt) return config.runnerCommands.chatgpt;
+    if (target === "claude" && config.runnerCommands.claude) return config.runnerCommands.claude;
+    if (config.runnerCommands.gpt) return config.runnerCommands.gpt;
+    if (config.runnerCommands.generic) return config.runnerCommands.generic;
+    return "";
+  }
+
+  if (mode === "codex") {
+    if (target === "codex" && config.runnerCommands.codexTarget) return config.runnerCommands.codexTarget;
+    if (target === "claude_code" && config.runnerCommands.claudeCode) return config.runnerCommands.claudeCode;
+    if (config.runnerCommands.codex) return config.runnerCommands.codex;
+    if (config.runnerCommands.generic) return config.runnerCommands.generic;
+    return "";
+  }
+
+  if (config.runnerCommands.generic) return config.runnerCommands.generic;
+  return "";
+}
+
+function getClientTypeForRun(run) {
+  const configured = String(config.clientType ?? "").trim().toLowerCase();
+  if (configured && configured !== "auto") {
+    return normalizeTarget(configured, "other");
+  }
+  return getTargetForRun(run);
+}
+
+async function sendHeartbeat(lastAction = "heartbeat", run = null) {
+  return api("/api/agent/v1/heartbeat", {
+    method: "POST",
+    body: {
+      projectId: config.projectId,
+      clientName: config.clientName,
+      clientType: getClientTypeForRun(run),
+      clientVersion: config.clientVersion,
+      lastAction,
+      lastActionAt: new Date().toISOString(),
+    },
+  });
+}
+
+async function claimNextRun() {
+  const payload = await api("/api/agent/v1/runs/next", {
+    method: "POST",
+    body: {
+      projectId: config.projectId,
+      clientName: config.clientName,
+      clientType: normalizeTarget(config.clientType === "auto" ? "other" : config.clientType, "other"),
+      clientVersion: config.clientVersion,
+    },
+  });
+  return payload?.run ?? null;
+}
+
+async function executeRunner(run) {
+  if (config.mockResponse) {
+    return {
+      stdout: String(config.mockResponse),
+      stderr: "",
+      exitCode: 0,
+      durationMs: 0,
+      usedMock: true,
+      target: getTargetForRun(run),
+    };
+  }
+
+  const commandTemplate = getCommandForRun(run);
+  if (!commandTemplate) {
+    throw new Error(
+      `No runner command configured for promptMode=${String(run?.promptMode ?? "unknown")} target=${getTargetForRun(run)}.`,
+    );
+  }
+  const command = buildRunnerCommand(commandTemplate, run);
+  const parsedCommand = parseRunnerCommand(command);
+
+  const startedAt = Date.now();
+  return new Promise((resolve, reject) => {
+    const child = spawn(parsedCommand.file, parsedCommand.args, {
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        LC_AGENT_RUN_ID: String(run.id ?? ""),
+        LC_AGENT_PROJECT_ID: String(run.projectId ?? ""),
+        LC_AGENT_PHASE_KEY: String(run.phaseKey ?? ""),
+        LC_AGENT_BUCKET_KEY: String(run.bucketKey ?? ""),
+        LC_AGENT_CARD_ID: String(run.cardId ?? ""),
+        LC_AGENT_PROMPT_MODE: String(run.promptMode ?? ""),
+        LC_AGENT_RUN_TYPE: String(run.runType ?? ""),
+      },
+    });
+
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      const durationMs = Date.now() - startedAt;
+      if ((code ?? 1) !== 0) {
+        const message = `Runner exited with code ${String(code ?? 1)}${stderr ? `: ${stderr.trim()}` : ""}`;
+        const error = new Error(message);
+        error.code = code ?? 1;
+        error.stdout = stdout;
+        error.stderr = stderr;
+        error.durationMs = durationMs;
+        reject(error);
+        return;
+      }
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 0,
+        durationMs,
+        usedMock: false,
+        target: getTargetForRun(run),
+      });
+    });
+
+    child.stdin.write(String(run.prompt ?? ""));
+    child.stdin.end();
+  });
+}
+
+async function completeRun(run, completion) {
+  const status = completion.status === "failed" ? "failed" : "completed";
+  const resultRaw = trimToBytes(completion.resultRaw ?? "", config.maxPayloadBytes);
+  const resultJsonPayload = trimToBytes(completion.resultJsonPayload ?? "", config.maxPayloadBytes);
+  return api(`/api/agent/v1/runs/${encodeURIComponent(String(run.id))}/complete`, {
+    method: "POST",
+    body: {
+      status,
+      resultRaw,
+      resultJsonPayload,
+      resultMeta: completion.resultMeta ?? {},
+      error: completion.error ?? null,
+      clientName: config.clientName,
+      clientType: getClientTypeForRun(run),
+      clientVersion: config.clientVersion,
+    },
+  });
+}
+
+let shuttingDown = false;
+process.on("SIGINT", () => {
+  shuttingDown = true;
+  log("Stopping bridge (SIGINT)...");
+});
+process.on("SIGTERM", () => {
+  shuttingDown = true;
+  log("Stopping bridge (SIGTERM)...");
+});
+
+async function runOnce() {
+  const run = await claimNextRun();
+  if (!run) {
+    logVerbose("No queued run.");
+    return false;
+  }
+
+  const target = getTargetForRun(run);
+  log(`Claimed run ${run.id} (${run.runType}/${run.promptMode} -> ${target})`);
+
+  try {
+    const execution = await executeRunner(run);
+    const stdout = String(execution.stdout ?? "").trim();
+    const stderr = String(execution.stderr ?? "").trim();
+    const output = stdout || stderr;
+    await completeRun(run, {
+      status: "completed",
+      resultRaw: output,
+      resultJsonPayload: output,
+      resultMeta: {
+        exitCode: execution.exitCode ?? 0,
+        durationMs: execution.durationMs ?? 0,
+        usedMock: execution.usedMock === true,
+        target,
+        autoApplyRequested: run.autoApply === true,
+        runIntent: run.runIntent ?? "initial",
+        attemptNumber: run.attemptNumber ?? 1,
+        maxAttempts: run.maxAttempts ?? 1,
+      },
+      error: null,
+    });
+    log(`Completed run ${run.id}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "Runner failed");
+    const stdout = typeof error?.stdout === "string" ? error.stdout : "";
+    const stderr = typeof error?.stderr === "string" ? error.stderr : "";
+    const durationMs = typeof error?.durationMs === "number" ? error.durationMs : null;
+    await completeRun(run, {
+      status: "failed",
+      resultRaw: `${stdout}\n${stderr}`.trim() || message,
+      resultJsonPayload: "",
+      resultMeta: {
+        exitCode: typeof error?.code === "number" ? error.code : null,
+        durationMs,
+        target,
+      },
+      error: message,
+    });
+    log(`Failed run ${run.id}: ${message}`);
+  }
+
+  return true;
+}
+
+async function main() {
+  log(
+    `Starting bridge -> ${config.baseUrl} | client=${config.clientName} (${config.clientType}) | gpt=${config.modeTargets.gpt} codex=${config.modeTargets.codex} | project=${config.projectId ?? "all"}`,
+  );
+
+  let lastHeartbeat = 0;
+  while (!shuttingDown) {
+    const now = Date.now();
+    if (now - lastHeartbeat >= config.heartbeatMs) {
+      try {
+        await sendHeartbeat("heartbeat", null);
+        lastHeartbeat = now;
+        logVerbose("Heartbeat sent.");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error ?? "Heartbeat failed");
+        const status = typeof error?.status === "number" ? error.status : 0;
+        log(`Heartbeat failed: ${message}`);
+        if (status === 401 || status === 403) {
+          process.exitCode = 1;
+          return;
+        }
+        if (status === 429) {
+          const retryMs = Math.max(config.pollMs, (Number(error?.retryAfterSeconds) || 30) * 1000);
+          log(`Rate limited; pausing heartbeat for ${Math.round(retryMs / 1000)}s.`);
+          await sleep(retryMs);
+        }
+      }
+    }
+
+    try {
+      const processed = await runOnce();
+      if (config.once) return;
+      if (!processed) await sleep(config.pollMs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error ?? "Bridge loop failure");
+      const status = typeof error?.status === "number" ? error.status : 0;
+      log(`Loop error: ${message}`);
+      if (status === 401 || status === 403) {
+        process.exitCode = 1;
+        return;
+      }
+      if (status === 429) {
+        const retryMs = Math.max(config.pollMs, (Number(error?.retryAfterSeconds) || 30) * 1000);
+        log(`Rate limited; pausing run polling for ${Math.round(retryMs / 1000)}s.`);
+        await sleep(retryMs);
+        continue;
+      }
+      await sleep(Math.max(config.pollMs, 2000));
+    }
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  // eslint-disable-next-line no-console
+  console.error(message);
+  process.exit(1);
+});