@groupchatai/claude-runner 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# @groupchatai/claude-runner
+
+Run [GroupChat AI](https://groupchat.ai) agent tasks locally with [Claude Code](https://docs.anthropic.com/en/docs/claude-code).
+
+Polls for pending runs assigned to your agent, spawns `claude -p` for each, and reports results back through the REST API. Supports both WebSocket (real-time) and HTTP polling modes.
+
+## Prerequisites
+
+- Node.js ≥ 20
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated
+- A GroupChat AI agent token (`GCA_TOKEN`)
+
+## Quick Start
+
+```bash
+# From your repo directory:
+npx @groupchatai/claude-runner --token gca_your_token_here
+```
+
+Or set the token in `.env.local`:
+
+```env
+GCA_TOKEN=gca_your_token_here
+```
+
+Then just run:
+
+```bash
+npx @groupchatai/claude-runner
+```
+
+## Options
+
+| Flag                   | Description                                      | Default |
+| ---------------------- | ------------------------------------------------ | ------- |
+| `--token <token>`      | Agent token (overrides `GCA_TOKEN` env var)      | —       |
+| `--work-dir <path>`    | Repo directory for Claude Code to work in        | `cwd`   |
+| `--poll`               | Use HTTP polling instead of WebSocket            | `false` |
+| `--poll-interval <ms>` | Polling interval in milliseconds (with `--poll`) | `5000`  |
+| `--max-concurrent <n>` | Max concurrent runs                              | `1`     |
+| `--model <model>`      | Claude model to use                              | —       |
+| `--dry-run`            | Poll and log runs without executing Claude Code  | `false` |
+| `--once`               | Process one batch of pending runs and exit       | `false` |
+| `--verbose`            | Stream Claude Code activity with pid             | `false` |
+
+## WebSocket vs Polling
+
+By default, the runner uses a WebSocket connection for real-time task delivery (requires the `convex` package). If `convex` is not installed, it falls back to HTTP polling automatically.
+
+To force polling mode, use `--poll`.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,633 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+var API_URL = "https://groupchat.ai";
+var CONVEX_URL = "https://fantastic-jay-464.convex.cloud";
+var GroupChatAgentClient = class {
+  baseUrl;
+  token;
+  constructor(apiUrl, token) {
+    this.baseUrl = `${apiUrl.replace(/\/$/, "")}/api/v1/agent`;
+    this.token = token;
+  }
+  async request(method, endpoint, body) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0,
+      redirect: "follow"
+    });
+    if (res.status === 401 && res.redirected) {
+      const retry = await fetch(res.url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (!retry.ok) {
+        const text = await retry.text().catch(() => "");
+        throw new Error(`API ${method} ${endpoint} \u2192 ${retry.status}: ${text}`);
+      }
+      return await retry.json();
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`API ${method} ${endpoint} \u2192 ${res.status}: ${text}`);
+    }
+    return await res.json();
+  }
+  async getMe() {
+    return this.request("GET", "/me");
+  }
+  async listPendingRuns() {
+    const data = await this.request("GET", "/runs?status=PENDING");
+    return data.runs;
+  }
+  async getRunDetail(runId) {
+    return this.request("GET", `/runs/${runId}`);
+  }
+  async startRun(runId, body) {
+    return this.request("POST", `/runs/${runId}/start`, { body });
+  }
+  async completeRun(runId, body, opts) {
+    return this.request("POST", `/runs/${runId}/complete`, { body, ...opts });
+  }
+  async errorRun(runId, body, opts) {
+    return this.request("POST", `/runs/${runId}/error`, { body, ...opts });
+  }
+  async postComment(runId, body) {
+    return this.request("POST", `/runs/${runId}/comment`, { body });
+  }
+};
+function buildClaudePrompt(detail) {
+  const parts = [];
+  parts.push(`# Task: ${detail.task.title}`);
+  if (detail.task.description) {
+    parts.push(`
+## Description
+${detail.task.description}`);
+  }
+  if (detail.prompt && detail.prompt !== detail.task.title) {
+    parts.push(`
+## Instructions
+${detail.prompt}`);
+  }
+  if (detail.task.images.length > 0) {
+    parts.push(`
+## Attached Images`);
+    for (const url of detail.task.images) {
+      parts.push(`- ${url}`);
+    }
+  }
+  const comments = detail.activity.filter(
+    (a) => a.type === "comment" && a.body && a.body.trim().length > 0
+  );
+  if (comments.length > 0) {
+    parts.push(`
+## Conversation History`);
+    for (const comment of comments) {
+      const author = comment.userName ?? "Someone";
+      parts.push(
+        `
+**${author}** (${new Date(comment.createdAt).toLocaleString()}):
+${comment.body}`
+      );
+    }
+  }
+  if (detail.task.dueDate) {
+    parts.push(`
+Due: ${new Date(detail.task.dueDate).toLocaleDateString()}`);
+  }
+  parts.push(
+    [
+      "\n---",
+      "RULES:",
+      "- You may create PRs with `gh pr create`. You may push branches and contribute to existing PRs.",
+      "- NEVER run `gh pr merge`. Do NOT merge any PR.",
+      "- NEVER run `gh pr close`. Do NOT close any PR.",
+      "- NEVER run `git push --force` or `git push -f`. No force pushes.",
+      "- When you are done, provide a clear summary of what you accomplished. If you created a PR or made commits, include the PR URL and branch name."
+    ].join("\n")
+  );
+  return parts.join("\n");
+}
+function formatStreamEvent(event, pid) {
+  const prefix = `  [pid ${pid}]`;
+  switch (event.type) {
+    case "system":
+      if (event.subtype === "init") {
+        let line = `${prefix} session started`;
+        if (event.session_id) line += ` (${event.session_id})`;
+        return line;
+      }
+      return null;
+    case "assistant": {
+      const blocks = event.message?.content;
+      if (!blocks || blocks.length === 0) return null;
+      const parts = [];
+      for (const block of blocks) {
+        if (block.type === "text" && block.text) {
+          for (const line of block.text.split("\n")) {
+            if (line.trim()) parts.push(`${prefix} \u{1F4AC} ${line}`);
+          }
+        } else if (block.type === "tool_use" && block.name) {
+          let detail = block.name;
+          const input = block.input;
+          if (input) {
+            if (typeof input.file_path === "string") {
+              detail += ` \u2192 ${input.file_path}`;
+            } else if (typeof input.command === "string") {
+              const cmd = input.command.length > 80 ? input.command.slice(0, 77) + "\u2026" : input.command;
+              detail += ` \u2192 ${cmd}`;
+            }
+          }
+          parts.push(`${prefix} \u{1F527} ${detail}`);
+        }
+      }
+      return parts.length > 0 ? parts.join("\n") : null;
+    }
+    case "tool_result":
+      return null;
+    case "result": {
+      const lines = [];
+      if (event.cost_usd !== void 0 || event.total_cost_usd !== void 0) {
+        const cost = event.cost_usd ?? event.total_cost_usd;
+        lines.push(`${prefix} \u{1F4B0} cost: $${cost?.toFixed(4)}`);
+      }
+      if (event.result) {
+        const preview = event.result.length > 120 ? event.result.slice(0, 117) + "\u2026" : event.result;
+        lines.push(`${prefix} \u2705 ${preview}`);
+      }
+      return lines.length > 0 ? lines.join("\n") : null;
+    }
+    default:
+      return null;
+  }
+}
+var ALLOWED_TOOLS = [
+  "Bash(git:*)",
+  "Bash(gh:*)",
+  "Bash(npm:*)",
+  "Bash(npx:*)",
+  "Bash(pnpm:*)",
+  "Bash(yarn:*)",
+  "Bash(node:*)",
+  "Bash(cat:*)",
+  "Bash(ls:*)",
+  "Bash(find:*)",
+  "Bash(grep:*)",
+  "Bash(head:*)",
+  "Bash(tail:*)",
+  "Bash(wc:*)",
+  "Bash(sort:*)",
+  "Bash(uniq:*)",
+  "Bash(diff:*)",
+  "Bash(echo:*)",
+  "Bash(mkdir:*)",
+  "Bash(cp:*)",
+  "Bash(mv:*)",
+  "Bash(rm:*)",
+  "Bash(touch:*)",
+  "Bash(sed:*)",
+  "Bash(awk:*)",
+  "Bash(curl:*)",
+  "Bash(pwd:*)",
+  "Bash(env:*)",
+  "Bash(which:*)",
+  "Read",
+  "Edit",
+  "Write",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "WebSearch",
+  "TodoWrite",
+  "NotebookEdit"
+];
+function spawnClaudeCode(prompt, config, runOptions) {
+  const format = config.verbose ? "stream-json" : "json";
+  const args = [
+    "-p",
+    prompt,
+    "--output-format",
+    format,
+    "--verbose",
+    "--permission-mode",
+    "default",
+    "--allowedTools",
+    ...ALLOWED_TOOLS
+  ];
+  const model = runOptions?.model ?? config.model;
+  if (model) {
+    args.push("--model", model);
+  }
+  const child = spawn("claude", args, {
+    cwd: config.workDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env }
+  });
+  const pid = child.pid ?? 0;
+  const output = new Promise(
+    (resolve, reject) => {
+      const chunks = [];
+      const errChunks = [];
+      let lineBuf = "";
+      let lastResultJson = "";
+      child.stdout?.on("data", (data) => {
+        chunks.push(data);
+        if (!config.verbose) return;
+        lineBuf += data.toString("utf-8");
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const event = JSON.parse(trimmed);
+            if (event.type === "result") lastResultJson = trimmed;
+            const formatted = formatStreamEvent(event, pid);
+            if (formatted) console.log(formatted);
+          } catch {
+            console.log(`  [pid ${pid}] ${trimmed}`);
+          }
+        }
+      });
+      child.stderr?.on("data", (data) => {
+        errChunks.push(data);
+        if (config.verbose) {
+          const text = data.toString("utf-8").trimEnd();
+          if (text) console.error(`  [pid ${pid}] ${text}`);
+        }
+      });
+      child.on("error", (err) => reject(new Error(`Failed to spawn claude: ${err.message}`)));
+      child.on("close", (code) => {
+        if (config.verbose && lineBuf.trim()) {
+          try {
+            const event = JSON.parse(lineBuf.trim());
+            if (event.type === "result") lastResultJson = lineBuf.trim();
+            const formatted = formatStreamEvent(event, pid);
+            if (formatted) console.log(formatted);
+          } catch {
+            console.log(`  [pid ${pid}] ${lineBuf.trim()}`);
+          }
+        }
+        const rawOutput = Buffer.concat(chunks).toString("utf-8");
+        const stdout = config.verbose ? lastResultJson || rawOutput : rawOutput;
+        const stderr = Buffer.concat(errChunks).toString("utf-8");
+        if (code !== 0 && stdout.trim().length === 0) {
+          reject(new Error(`claude exited with code ${code}: ${stderr}`));
+        } else {
+          resolve({ stdout, rawOutput, exitCode: code ?? 0 });
+        }
+      });
+    }
+  );
+  return { process: child, output };
+}
+function findResultEvent(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (Array.isArray(parsed)) {
+      for (let i = parsed.length - 1; i >= 0; i--) {
+        const item = parsed[i];
+        if (item && item.type === "result") return item;
+      }
+      return null;
+    }
+    const single = parsed;
+    if (single.type === "result" || single.result !== void 0) return single;
+  } catch {
+  }
+  const lines = stdout.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === "result") return event;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function extractResultText(stdout) {
+  const event = findResultEvent(stdout);
+  if (!event) return stdout;
+  if (typeof event.result === "string") return event.result;
+  if (typeof event.text === "string") return event.text;
+  return stdout;
+}
+function extractCost(stdout) {
+  const event = findResultEvent(stdout);
+  if (!event) return void 0;
+  const cost = typeof event.cost_usd === "number" ? event.cost_usd : typeof event.total_cost_usd === "number" ? event.total_cost_usd : void 0;
+  if (cost !== void 0 && cost > 0) {
+    return { stepCostUsd: cost };
+  }
+  return void 0;
+}
+var GITHUB_PR_URL_RE = /https:\/\/github\.com\/[^\s"'<>]+\/pull\/\d+/g;
+function extractPullRequestUrl(stdout) {
+  const event = findResultEvent(stdout);
+  if (event) {
+    const text = typeof event.result === "string" ? event.result : typeof event.text === "string" ? event.text : "";
+    const match2 = text.match(GITHUB_PR_URL_RE);
+    if (match2) return match2[match2.length - 1];
+  }
+  const match = stdout.match(GITHUB_PR_URL_RE);
+  if (match) return match[match.length - 1];
+  return void 0;
+}
+async function processRun(client, run, config) {
+  const log = (msg) => console.log(`  [${run.id.slice(-8)}] ${msg}`);
+  const detail = await client.getRunDetail(run.id);
+  const ownerName = run.owner?.name ?? detail.owner?.name ?? "unknown";
+  log(`\u{1F4CB} "${run.taskTitle}" \u2014 delegated by ${ownerName}`);
+  if (detail.status !== "PENDING") {
+    log(`\u23ED  Run is no longer PENDING (now ${detail.status}), skipping.`);
+    return;
+  }
+  const prompt = buildClaudePrompt(detail);
+  if (config.dryRun) {
+    log("\u{1F3DC}  DRY RUN \u2014 would execute Claude Code with prompt:");
+    console.log("---");
+    console.log(prompt.slice(0, 500) + (prompt.length > 500 ? "\n..." : ""));
+    console.log("---");
+    return;
+  }
+  const runOptions = detail.providerOptions ?? {};
+  const effectiveModel = runOptions.model ?? config.model;
+  const startMsg = effectiveModel ? `Starting work with Claude Code (${effectiveModel})\u2026` : "Starting work with Claude Code\u2026";
+  try {
+    await client.startRun(run.id, startMsg);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("not pending") || msg.includes("not PENDING") || msg.includes("400")) {
+      log(`\u23ED  Run was already claimed, skipping.`);
+      return;
+    }
+    throw err;
+  }
+  log("\u25B6  Run started");
+  try {
+    if (runOptions.branch) {
+      log(`\u{1F33F} Checking out branch: ${runOptions.branch}`);
+      const git = spawn("git", ["checkout", runOptions.branch], {
+        cwd: config.workDir,
+        stdio: "pipe"
+      });
+      await new Promise((resolve) => git.on("close", () => resolve()));
+    }
+    if (config.verbose) {
+      log(`\u{1F4DD} Prompt (${prompt.length} chars)`);
+      if (effectiveModel) log(`\u{1F9E0} Model: ${effectiveModel}`);
+    }
+    const { process: child, output } = spawnClaudeCode(prompt, config, runOptions);
+    log(`\u{1F916} Claude Code spawned (pid ${child.pid})`);
+    const { stdout, rawOutput, exitCode } = await output;
+    const pullRequestUrl = extractPullRequestUrl(stdout) ?? extractPullRequestUrl(rawOutput);
+    if (exitCode !== 0) {
+      const errorMsg = `Claude Code exited with code ${exitCode}:
+\`\`\`
+${stdout.slice(0, 2e3)}
+\`\`\``;
+      await client.errorRun(run.id, errorMsg, { pullRequestUrl });
+      log(`\u274C Run errored (exit code ${exitCode})`);
+      return;
+    }
+    const resultText = extractResultText(stdout);
+    const cost = extractCost(stdout);
+    const summary = resultText;
+    await client.completeRun(run.id, summary, { ...cost, pullRequestUrl });
+    if (pullRequestUrl) log(`\u{1F517} PR: ${pullRequestUrl}`);
+    log(`\u2705 Run completed`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const errorBody = `Claude Code runner error:
+\`\`\`
+${message.slice(0, 2e3)}
+\`\`\``;
+    try {
+      await client.errorRun(run.id, errorBody);
+    } catch {
+      log(`\u26A0  Failed to report error to API`);
+    }
+    log(`\u274C Error: ${message}`);
+  }
+}
+function loadEnvFile() {
+  const candidates = [".env.local", ".env"];
+  for (const file of candidates) {
+    try {
+      const contents = readFileSync(path.resolve(file), "utf-8");
+      for (const line of contents.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let value = trimmed.slice(eqIdx + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        if (!process.env[key]) {
+          process.env[key] = value;
+        }
+      }
+      break;
+    } catch {
+    }
+  }
+}
+function parseArgs() {
+  loadEnvFile();
+  const args = process.argv.slice(2);
+  const config = {
+    token: process.env.GCA_TOKEN ?? "",
+    apiUrl: process.env.GCA_API_URL ?? API_URL,
+    convexUrl: process.env.GCA_CONVEX_URL ?? CONVEX_URL,
+    workDir: process.cwd(),
+    pollInterval: 5e3,
+    maxConcurrent: 1,
+    poll: false,
+    dryRun: false,
+    once: false,
+    verbose: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--work-dir":
+        config.workDir = path.resolve(args[++i] ?? ".");
+        break;
+      case "--poll-interval":
+        config.pollInterval = parseInt(args[++i] ?? "5000", 10);
+        break;
+      case "--max-concurrent":
+        config.maxConcurrent = parseInt(args[++i] ?? "1", 10);
+        break;
+      case "--model":
+        config.model = args[++i];
+        break;
+      case "--poll":
+        config.poll = true;
+        break;
+      case "--dry-run":
+        config.dryRun = true;
+        break;
+      case "--once":
+        config.once = true;
+        break;
+      case "--verbose":
+        config.verbose = true;
+        break;
+      case "--token":
+        config.token = args[++i] ?? "";
+        break;
+      default:
+        console.error(`Unknown argument: ${arg}`);
+        process.exit(1);
+    }
+  }
+  if (!config.token) {
+    console.error("Error: No agent token found.");
+    console.error("  Add GCA_TOKEN=gca_... to .env.local, or pass --token gca_...");
+    process.exit(1);
+  }
+  if (!config.token.startsWith("gca_")) {
+    console.error(`Error: Token must start with gca_ (got "${config.token.slice(0, 8)}\u2026")`);
+    process.exit(1);
+  }
+  return config;
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function handlePendingRuns(runs, activeRuns, client, config) {
+  if (runs.length > 0 && config.verbose) {
+    console.log(`\u{1F4EC} ${runs.length} pending run(s)`);
+  }
+  for (const run of runs) {
+    if (activeRuns.has(run.id)) continue;
+    if (activeRuns.size >= config.maxConcurrent) {
+      if (config.verbose) {
+        console.log(`\u23F8  At concurrency limit (${config.maxConcurrent}), waiting\u2026`);
+      }
+      break;
+    }
+    activeRuns.add(run.id);
+    processRun(client, run, config).catch((err) => console.error(`Unhandled error processing run ${run.id}:`, err)).finally(() => activeRuns.delete(run.id));
+  }
+}
+async function runWithWebSocket(client, config, activeRuns) {
+  let ConvexClient;
+  let anyApi;
+  try {
+    ({ ConvexClient } = await import("convex/browser"));
+    ({ anyApi } = await import("convex/server"));
+  } catch {
+    console.warn("\u26A0  convex package not found \u2014 falling back to HTTP polling.");
+    console.warn("   Install convex for WebSocket mode: npm i convex\n");
+    await runWithPolling(client, config, activeRuns);
+    return;
+  }
+  const convex = new ConvexClient(config.convexUrl);
+  console.log("\u26A1 Connected via WebSocket \u2014 listening for tasks\u2026\n");
+  convex.onUpdate(
+    anyApi.agentWebSocket.pendingRuns,
+    { token: config.token },
+    (runs) => {
+      if (!runs || runs.length === 0) return;
+      handlePendingRuns(runs, activeRuns, client, config);
+    }
+  );
+  await new Promise((resolve) => {
+    const shutdown = () => {
+      console.log("\n\u{1F6D1} Shutting down\u2026");
+      void convex.close();
+      resolve();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+}
+async function runWithPolling(client, config, activeRuns) {
+  console.log(`\u{1F4E1} Polling every ${config.pollInterval}ms \u2014 listening for tasks\u2026
+`);
+  let running = true;
+  const shutdown = () => {
+    console.log("\n\u{1F6D1} Shutting down\u2026");
+    running = false;
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  if (config.once) {
+    try {
+      const pending = await client.listPendingRuns();
+      handlePendingRuns(pending, activeRuns, client, config);
+    } catch (err) {
+      console.error(`Poll error: ${err instanceof Error ? err.message : err}`);
+    }
+    while (activeRuns.size > 0) await sleep(1e3);
+    return;
+  }
+  while (running) {
+    try {
+      const pending = await client.listPendingRuns();
+      handlePendingRuns(pending, activeRuns, client, config);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (config.verbose || !msg.includes("fetch")) {
+        console.error(`Poll error: ${msg}`);
+      }
+    }
+    await sleep(config.pollInterval);
+  }
+}
+async function main() {
+  const config = parseArgs();
+  const client = new GroupChatAgentClient(config.apiUrl, config.token);
+  let me;
+  try {
+    me = await client.getMe();
+  } catch (err) {
+    console.error("Failed to authenticate:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F916} Agent Runner \u2014 ${me.name}`);
+  console.log(`   Owner: ${me.ownerName}`);
+  console.log(`   Work:  ${config.workDir}`);
+  console.log(`   Mode:  ${config.poll ? "polling" : "websocket"}`);
+  if (config.apiUrl !== API_URL) console.log(`   API:   ${config.apiUrl}`);
+  if (config.model) console.log(`   Model: ${config.model}`);
+  if (config.dryRun) console.log(`   Mode:  DRY RUN`);
+  console.log();
+  const activeRuns = /* @__PURE__ */ new Set();
+  if (config.poll || config.once) {
+    await runWithPolling(client, config, activeRuns);
+  } else {
+    await runWithWebSocket(client, config, activeRuns);
+  }
+  if (activeRuns.size > 0) {
+    console.log(`\u23F3 Waiting for ${activeRuns.size} in-flight run(s)\u2026`);
+    while (activeRuns.size > 0) {
+      await sleep(1e3);
+    }
+  }
+  console.log("\u{1F44B} Goodbye.");
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@groupchatai/claude-runner",
+  "version": "0.1.0",
+  "description": "Run GroupChat AI agent tasks locally with Claude Code",
+  "type": "module",
+  "bin": {
+    "claude-runner": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/la-agency/groupchat.git",
+    "directory": "packages/claude-runner"
+  },
+  "homepage": "https://groupchat.ai",
+  "bugs": {
+    "url": "https://github.com/la-agency/groupchat/issues"
+  },
+  "optionalDependencies": {
+    "convex": "^1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "keywords": [
+    "groupchat",
+    "groupchatai",
+    "agent",
+    "claude-runner",
+    "claude",
+    "claude-code",
+    "ai"
+  ]
+}