@launchchair/agent 0.4.0

package/claude-code-runner.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+/**
+ * LaunchChair runner for Claude Code CLI.
+ *
+ * Reads one LaunchChair prompt from stdin, sends it to `claude -p`, and writes
+ * Claude's final response to stdout. This is separate from claude-runner.mjs,
+ * which calls the Anthropic Messages API and requires ANTHROPIC_API_KEY.
+ */
+
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+function env(name, fallback = "") {
+  const value = process.env[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    process.stdin.on("end", () => resolve(buffer));
+    process.stdin.on("error", (error) => reject(error));
+  });
+}
+
+function buildClaudeArgs(config) {
+  const args = ["-p"];
+
+  if (config.outputFormat && config.outputFormat !== "text") {
+    args.push("--output-format", config.outputFormat);
+  }
+  if (config.model) {
+    args.push("--model", config.model);
+  }
+  if (config.allowedTools) {
+    args.push("--allowedTools", config.allowedTools);
+  }
+  if (config.permissionMode) {
+    args.push("--permission-mode", config.permissionMode);
+  }
+  if (config.appendSystemPrompt) {
+    args.push("--append-system-prompt", config.appendSystemPrompt);
+  }
+
+  return args;
+}
+
+function extractClaudeOutput(stdout, outputFormat) {
+  const text = String(stdout ?? "").trim();
+  if (outputFormat !== "json") {
+    return text;
+  }
+
+  try {
+    const payload = JSON.parse(text);
+    if (typeof payload?.structured_output !== "undefined") {
+      return JSON.stringify(payload.structured_output, null, 2);
+    }
+    if (typeof payload?.result === "string") {
+      return payload.result.trim();
+    }
+  } catch {
+    return text;
+  }
+
+  return text;
+}
+
+async function runClaude(prompt, config) {
+  const args = buildClaudeArgs(config);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(config.bin, args, {
+      cwd: config.cwd,
+      env: process.env,
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    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) => {
+      if ((code ?? 1) !== 0) {
+        const error = new Error(`Claude Code exited with code ${String(code ?? 1)}${stderr ? `: ${stderr.trim()}` : ""}`);
+        error.code = code ?? 1;
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr, code: code ?? 0 });
+    });
+
+    child.stdin.write(prompt);
+    child.stdin.end();
+  });
+}
+
+async function main() {
+  const config = {
+    bin: env("LC_AGENT_CLAUDE_CODE_BIN", "claude"),
+    cwd: env("LC_AGENT_CLAUDE_CODE_CWD", process.cwd()),
+    model: env("LC_AGENT_CLAUDE_CODE_MODEL"),
+    outputFormat: env("LC_AGENT_CLAUDE_CODE_OUTPUT_FORMAT", "text"),
+    allowedTools: env("LC_AGENT_CLAUDE_CODE_ALLOWED_TOOLS"),
+    permissionMode: env("LC_AGENT_CLAUDE_CODE_PERMISSION_MODE"),
+    appendSystemPrompt: env("LC_AGENT_CLAUDE_CODE_APPEND_SYSTEM_PROMPT"),
+  };
+
+  const prompt = String(await readStdin()).trim();
+  if (!prompt) {
+    throw new Error("Runner received an empty prompt.");
+  }
+
+  const result = await runClaude(prompt, config);
+  const output = extractClaudeOutput(result.stdout, config.outputFormat).trim();
+  if (!output) {
+    throw new Error("Claude Code completed without returning output.");
+  }
+
+  process.stdout.write(`${output}\n`);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error ?? "claude-code-runner failed");
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});

package/claude-runner.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+
+function env(name, fallback = "") {
+  const value = process.env[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+function toInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function toFloat(value, fallback) {
+  const parsed = Number.parseFloat(String(value ?? ""));
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function stripCodeFence(text) {
+  const trimmed = String(text ?? "").trim();
+  if (!trimmed.startsWith("```")) {
+    return trimmed;
+  }
+  const lines = trimmed.split("\n");
+  if (lines.length < 3) {
+    return trimmed;
+  }
+  const first = lines[0].trim();
+  const last = lines[lines.length - 1].trim();
+  if (!first.startsWith("```") || last !== "```") {
+    return trimmed;
+  }
+  return lines.slice(1, -1).join("\n").trim();
+}
+
+function tryJsonParse(candidate) {
+  try {
+    return { ok: true, value: JSON.parse(candidate) };
+  } catch {
+    return { ok: false, value: null };
+  }
+}
+
+function extractFirstJsonValue(text) {
+  const raw = String(text ?? "");
+  const direct = tryJsonParse(raw.trim());
+  if (direct.ok) {
+    return direct.value;
+  }
+
+  const unfenced = stripCodeFence(raw);
+  const fromFence = tryJsonParse(unfenced);
+  if (fromFence.ok) {
+    return fromFence.value;
+  }
+
+  for (let start = 0; start < unfenced.length; start += 1) {
+    const open = unfenced[start];
+    if (open !== "{" && open !== "[") {
+      continue;
+    }
+    const close = open === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+
+    for (let i = start; i < unfenced.length; i += 1) {
+      const char = unfenced[i];
+
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === "\"") {
+          inString = false;
+        }
+        continue;
+      }
+
+      if (char === "\"") {
+        inString = true;
+        continue;
+      }
+      if (char === open) {
+        depth += 1;
+        continue;
+      }
+      if (char === close) {
+        depth -= 1;
+        if (depth === 0) {
+          const candidate = unfenced.slice(start, i + 1).trim();
+          const parsed = tryJsonParse(candidate);
+          if (parsed.ok) {
+            return parsed.value;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    process.stdin.on("end", () => resolve(buffer));
+    process.stdin.on("error", (error) => reject(error));
+  });
+}
+
+function extractClaudeText(payload) {
+  const content = Array.isArray(payload?.content) ? payload.content : [];
+  const merged = content
+    .map((part) => (typeof part?.text === "string" ? part.text : ""))
+    .join("\n")
+    .trim();
+  if (!merged) {
+    throw new Error("Anthropic response did not include assistant text.");
+  }
+  return merged;
+}
+
+async function callClaude(input, config) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), config.timeoutMs);
+
+  try {
+    const response = await fetch(`${config.baseUrl}/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": config.apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        model: config.model,
+        temperature: config.temperature,
+        max_tokens: config.maxTokens,
+        system: "Return exactly one valid JSON value (object or array) and nothing else. No markdown, no prose.",
+        messages: [
+          {
+            role: "user",
+            content: input,
+          },
+        ],
+      }),
+      signal: controller.signal,
+    });
+
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const detail = String(payload?.error?.message ?? payload?.error?.type ?? response.statusText ?? "Request failed");
+      throw new Error(`Anthropic request failed (${response.status}): ${detail}`);
+    }
+
+    return extractClaudeText(payload);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function main() {
+  const config = {
+    apiKey: env("ANTHROPIC_API_KEY"),
+    baseUrl: env("ANTHROPIC_BASE_URL", "https://api.anthropic.com/v1").replace(/\/+$/, ""),
+    model: env("LC_AGENT_ANTHROPIC_MODEL", env("ANTHROPIC_MODEL", "claude-3-7-sonnet-latest")),
+    temperature: toFloat(process.env.LC_AGENT_ANTHROPIC_TEMPERATURE, 0),
+    maxTokens: toInt(process.env.LC_AGENT_ANTHROPIC_MAX_TOKENS, 12000),
+    timeoutMs: toInt(process.env.LC_AGENT_ANTHROPIC_TIMEOUT_MS, 180000),
+    maxAttempts: toInt(process.env.LC_AGENT_JSON_MAX_ATTEMPTS, 3),
+  };
+
+  if (!config.apiKey) {
+    throw new Error("Missing ANTHROPIC_API_KEY for claude-runner.");
+  }
+
+  const prompt = String(await readStdin()).trim();
+  if (!prompt) {
+    throw new Error("Runner received an empty prompt.");
+  }
+
+  let lastRaw = "";
+  for (let attempt = 1; attempt <= config.maxAttempts; attempt += 1) {
+    const input =
+      attempt === 1
+        ? prompt
+        : [
+            "Repair this to strict valid JSON only.",
+            "Do not add explanations, markdown, or code fences.",
+            "Return exactly one JSON value.",
+            "",
+            lastRaw,
+          ].join("\n");
+
+    lastRaw = await callClaude(input, config);
+    const parsed = extractFirstJsonValue(lastRaw);
+    if (parsed !== null) {
+      process.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
+      return;
+    }
+  }
+
+  throw new Error("Model did not return valid JSON after retry attempts.");
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error ?? "claude-runner failed");
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});

package/codex-runner.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+/**
+ * LaunchChair Codex runner.
+ *
+ * Reads a LaunchChair queued prompt from stdin, runs it through `codex exec`,
+ * and prints only Codex's final message to stdout so the Agent API can parse it.
+ *
+ * Auth:
+ * - Reuses local Codex CLI auth by default, including ChatGPT sign-in.
+ * - Does not require OPENAI_API_KEY unless the user's Codex CLI is configured that way.
+ */
+
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+function env(name, fallback = "") {
+  const value = process.env[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+
+function buildArgs(outputPath) {
+  const cwd = env("LC_AGENT_CODEX_CWD", process.cwd());
+  const sandbox = env("LC_AGENT_CODEX_SANDBOX", "workspace-write");
+  const model = env("LC_AGENT_CODEX_MODEL");
+  const profile = env("LC_AGENT_CODEX_PROFILE");
+  const ephemeral = env("LC_AGENT_CODEX_EPHEMERAL", "1") !== "0";
+  const skipGitRepoCheck = env("LC_AGENT_CODEX_SKIP_GIT_CHECK", "0") === "1";
+
+  const args = ["exec", "--cd", cwd, "--sandbox", sandbox, "--output-last-message", outputPath];
+  if (ephemeral) {
+    args.push("--ephemeral");
+  }
+  if (skipGitRepoCheck) {
+    args.push("--skip-git-repo-check");
+  }
+  if (model) {
+    args.push("--model", model);
+  }
+  if (profile) {
+    args.push("--profile", profile);
+  }
+  args.push("-");
+  return args;
+}
+
+async function main() {
+  const prompt = await readStdin();
+  if (!prompt) {
+    console.error("codex-runner: empty prompt.");
+    process.exit(1);
+  }
+
+  const tempDir = await mkdtemp(path.join(tmpdir(), "launchchair-codex-runner-"));
+  const outputPath = path.join(tempDir, "last-message.txt");
+  const codexBin = env("LC_AGENT_CODEX_BIN", "codex");
+  const args = buildArgs(outputPath);
+
+  try {
+    const result = await new Promise((resolve, reject) => {
+      const child = spawn(codexBin, args, {
+        cwd: process.cwd(),
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: process.env,
+      });
+
+      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) => {
+        resolve({
+          code: code ?? 1,
+          stdout,
+          stderr,
+        });
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+    });
+
+    if (result.code !== 0) {
+      if (result.stdout.trim()) {
+        console.error(result.stdout.trim());
+      }
+      if (result.stderr.trim()) {
+        console.error(result.stderr.trim());
+      }
+      process.exit(result.code);
+    }
+
+    const finalMessage = (await readFile(outputPath, "utf8")).trim();
+    if (!finalMessage) {
+      console.error("codex-runner: Codex completed but returned an empty final message.");
+      process.exit(1);
+    }
+    process.stdout.write(finalMessage);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});