@pompeii-labs/bridge 0.1.0

package/README.md

@@ -0,0 +1,97 @@
+# @pompeii-labs/bridge
+
+CLI for running a [Pompeii](https://pompeii.ai) agent bridge on your local machine. The bridge connects your local dev environment to Pompeii so AI agents can work on your codebase when @mentioned in conversations.
+
+## Install
+
+```
+npm i -g @pompeii-labs/bridge
+```
+
+Requires [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/) for the tunnel.
+
+```
+brew install cloudflared
+```
+
+## Quick start
+
+```
+pompeii bridge start
+```
+
+On first run this launches interactive setup, which asks for:
+
+1. **Pompeii API key** - from your workspace settings at pompeii.ai
+2. **Webhook secret** - from the agent config page
+3. **Repository paths** - local paths the agent can access
+4. **Backend** - Claude Code or OpenAI Codex
+
+Config is saved to `~/.pompeii/`. After setup, the bridge starts as a background daemon with a Cloudflare tunnel and automatically registers the webhook URL with Pompeii.
+
+## Commands
+
+```
+pompeii bridge setup    # interactive config
+pompeii bridge start    # start daemon + tunnel (runs setup if no config)
+pompeii bridge stop     # stop the daemon
+pompeii bridge status   # show PID, port, tunnel URL, active requests
+pompeii bridge logs     # tail ~/.pompeii/bridge.log
+```
+
+### Options
+
+```
+pompeii bridge start --port 3001    # custom port (default: 3001)
+pompeii bridge logs --lines 100     # number of lines to show (default: 50)
+```
+
+## Config
+
+All config lives in `~/.pompeii/`:
+
+| File | Contents |
+|------|----------|
+| `config.json` | repos, backend, port, tunnel settings |
+| `.env` | `POMPEII_API_KEY`, `WEBHOOK_SECRET` |
+| `daemon.json` | runtime state (PID, tunnel URL, start time) |
+| `bridge.log` | daemon stdout/stderr |
+
+Environment variables always take precedence over file config:
+
+```
+WEBHOOK_SECRET, POMPEII_API_KEY, REPOS, BACKEND, PORT,
+MAX_TURNS, MAX_CONCURRENT, ALLOWED_TOOLS, POMPEII_API_URL
+```
+
+## How it works
+
+1. `pompeii bridge start` spawns the bridge server as a detached background process
+2. The server starts a Cloudflare quick tunnel to get a public URL
+3. The tunnel URL is registered with the Pompeii API as your agent's webhook
+4. When someone @mentions your agent in Pompeii, the platform sends a webhook to the tunnel
+5. The bridge runs the request through Claude Code (or Codex) against your local repos
+6. Responses stream back to Pompeii via SSE
+
+## Development
+
+```
+cd bridge
+bun install
+bun run dev
+```
+
+For local dev without the daemon, set env vars directly:
+
+```
+WEBHOOK_SECRET=xxx POMPEII_API_KEY=xxx REPOS=/path/to/repo TUNNEL=1 bun run dev
+```
+
+## Publishing
+
+```
+cd bridge
+npm publish --access public
+```
+
+The `prepublishOnly` script runs `tsc` automatically before publish.

package/dist/src/claude-code.d.ts

@@ -0,0 +1,3 @@
+import type { ServerResponse } from "node:http";
+import type { Config } from "./config.js";
+export declare function runClaudeCode(prompt: string, res: ServerResponse, abort: AbortController, config: Config): Promise<void>;

package/dist/src/claude-code.js

@@ -0,0 +1,69 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import * as sse from "./sse.js";
+export async function runClaudeCode(prompt, res, abort, config) {
+    const toolNames = new Map();
+    for await (const message of query({
+        prompt,
+        options: {
+            cwd: config.repos[0],
+            additionalDirectories: config.repos.slice(1),
+            allowedTools: config.allowedTools,
+            maxTurns: config.maxTurns,
+            abortController: abort,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            includePartialMessages: true,
+        },
+    })) {
+        if (abort.signal.aborted)
+            break;
+        if (message.type === "stream_event") {
+            const event = message.event;
+            if (event.type === "content_block_start" &&
+                event.content_block.type === "tool_use") {
+                toolNames.set(event.content_block.id, event.content_block.name);
+                sse.activity(res, event.content_block.name, "running");
+            }
+            else if (event.type === "content_block_delta" &&
+                event.delta.type === "text_delta") {
+                sse.chunk(res, event.delta.text);
+            }
+        }
+        else if (message.type === "user") {
+            const blocks = message.message.content;
+            if (Array.isArray(blocks)) {
+                for (const block of blocks) {
+                    if (block.type === "tool_result") {
+                        const toolName = toolNames.get(block.tool_use_id) ?? "unknown";
+                        const isError = block.is_error === true;
+                        const resultText = typeof block.content === "string"
+                            ? block.content
+                            : Array.isArray(block.content)
+                                ? block.content
+                                    .filter((c) => c.type === "text" && c.text)
+                                    .map((c) => c.text)
+                                    .join("\n")
+                                : "";
+                        const preview = resultText.length > 500
+                            ? resultText.slice(0, 500) + "..."
+                            : resultText;
+                        sse.activity(res, toolName, isError ? "error" : "success", preview);
+                    }
+                }
+            }
+        }
+        else if (message.type === "result") {
+            if (message.subtype === "success") {
+                sse.done(res);
+            }
+            else {
+                const errors = "errors" in message ? message.errors.join("; ") : message.subtype;
+                sse.error(res, errors);
+            }
+            return;
+        }
+    }
+    if (!res.writableEnded && !abort.signal.aborted) {
+        sse.done(res);
+    }
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { runSetup } from "./commands/setup.js";
+import { startCommand } from "./commands/start.js";
+import { stopCommand } from "./commands/stop.js";
+import { statusCommand } from "./commands/status.js";
+import { logsCommand } from "./commands/logs.js";
+const program = new Command();
+program.name("pompeii").description("Pompeii CLI").version("0.1.0");
+const bridge = program
+    .command("bridge")
+    .description("Manage the Pompeii bridge daemon");
+bridge
+    .command("setup")
+    .description("Interactive configuration for the bridge")
+    .action(async () => {
+    await runSetup();
+});
+bridge
+    .command("start")
+    .description("Start the bridge daemon with tunnel")
+    .option("-p, --port <port>", "Port to listen on", "3001")
+    .action(async (opts) => {
+    await startCommand(parseInt(opts.port, 10));
+});
+bridge
+    .command("stop")
+    .description("Stop the bridge daemon")
+    .action(() => {
+    stopCommand();
+});
+bridge
+    .command("status")
+    .description("Show bridge daemon status")
+    .action(async () => {
+    await statusCommand();
+});
+bridge
+    .command("logs")
+    .description("Tail bridge daemon logs")
+    .option("-n, --lines <lines>", "Number of lines to show", "50")
+    .action((opts) => {
+    logsCommand(parseInt(opts.lines, 10));
+});
+program.parse();

package/dist/src/codex.d.ts

@@ -0,0 +1,3 @@
+import type { ServerResponse } from "node:http";
+import type { Config } from "./config.js";
+export declare function runCodex(prompt: string, res: ServerResponse, abort: AbortController, config: Config): Promise<void>;

package/dist/src/codex.js

@@ -0,0 +1,73 @@
+import { Codex } from "@openai/codex-sdk";
+import * as sse from "./sse.js";
+export async function runCodex(prompt, res, abort, config) {
+    const codex = new Codex();
+    const thread = codex.startThread({
+        workingDirectory: config.repos[0],
+        additionalDirectories: config.repos.slice(1),
+        skipGitRepoCheck: true,
+    });
+    const { events } = await thread.runStreamed(prompt, { signal: abort.signal });
+    for await (const event of events) {
+        if (abort.signal.aborted)
+            break;
+        switch (event.type) {
+            case "item.started": {
+                const item = event.item;
+                if (item.type === "command_execution") {
+                    sse.activity(res, "Bash", "running");
+                }
+                else if (item.type === "file_change") {
+                    sse.activity(res, "Edit", "running");
+                }
+                else if (item.type === "mcp_tool_call") {
+                    sse.activity(res, item.tool, "running");
+                }
+                break;
+            }
+            case "item.updated": {
+                const item = event.item;
+                if (item.type === "agent_message") {
+                    if (item.text)
+                        sse.chunk(res, item.text);
+                }
+                break;
+            }
+            case "item.completed": {
+                const item = event.item;
+                if (item.type === "command_execution") {
+                    const ok = item.exit_code === 0;
+                    const output = item.aggregated_output;
+                    const preview = output.length > 500 ? output.slice(0, 500) + "..." : output;
+                    sse.activity(res, "Bash", ok ? "success" : "error", preview);
+                }
+                else if (item.type === "file_change") {
+                    const ok = item.status === "completed";
+                    sse.activity(res, "Edit", ok ? "success" : "error");
+                }
+                else if (item.type === "agent_message") {
+                    if (item.text)
+                        sse.chunk(res, item.text);
+                }
+                break;
+            }
+            case "turn.completed": {
+                sse.done(res);
+                return;
+            }
+            case "turn.failed": {
+                const msg = event.error?.message ?? "Turn failed";
+                sse.error(res, msg);
+                return;
+            }
+            case "error": {
+                const msg = event.message ?? "Thread error";
+                sse.error(res, msg);
+                return;
+            }
+        }
+    }
+    if (!res.writableEnded && !abort.signal.aborted) {
+        sse.done(res);
+    }
+}

package/dist/src/commands/logs.d.ts

@@ -0,0 +1 @@
+export declare function logsCommand(lines: number): void;

package/dist/src/commands/logs.js

@@ -0,0 +1,16 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { LOG_FILE } from "../paths.js";
+export function logsCommand(lines) {
+    if (!existsSync(LOG_FILE)) {
+        console.log("No log file found. Start the bridge first.");
+        return;
+    }
+    const tail = spawn("tail", ["-n", String(lines), "-f", LOG_FILE], {
+        stdio: "inherit",
+    });
+    process.on("SIGINT", () => {
+        tail.kill();
+        process.exit(0);
+    });
+}

package/dist/src/commands/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetup(): Promise<boolean>;

package/dist/src/commands/setup.js

@@ -0,0 +1,107 @@
+import * as p from "@clack/prompts";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { POMPEII_DIR, CONFIG_FILE, ENV_FILE } from "../paths.js";
+function loadExisting() {
+    let config = {};
+    const env = {};
+    if (existsSync(CONFIG_FILE)) {
+        try {
+            config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+        }
+        catch { }
+    }
+    if (existsSync(ENV_FILE)) {
+        try {
+            const content = readFileSync(ENV_FILE, "utf-8");
+            for (const line of content.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);
+                }
+                env[key] = value;
+            }
+        }
+        catch { }
+    }
+    return { config, env };
+}
+export async function runSetup() {
+    p.intro("Pompeii Bridge Setup");
+    const { config: existing } = loadExisting();
+    const apiKey = await p.password({
+        message: "Pompeii API key",
+        validate: (v) => {
+            if (!v)
+                return "API key is required";
+        },
+    });
+    if (p.isCancel(apiKey)) {
+        p.cancel("Setup cancelled.");
+        return false;
+    }
+    const webhookSecret = await p.password({
+        message: "Webhook secret",
+        validate: (v) => {
+            if (!v)
+                return "Webhook secret is required";
+        },
+    });
+    if (p.isCancel(webhookSecret)) {
+        p.cancel("Setup cancelled.");
+        return false;
+    }
+    const reposInput = await p.text({
+        message: "Repository paths (comma-separated)",
+        placeholder: "/path/to/repo1, /path/to/repo2",
+        initialValue: existing.repos?.join(", ") ?? "",
+        validate: (v) => {
+            if (!v.trim())
+                return "At least one repo path is required";
+            const paths = v.split(",").map((s) => s.trim());
+            for (const p of paths) {
+                const resolved = resolve(p);
+                if (!existsSync(resolved))
+                    return `Path not found: ${resolved}`;
+            }
+        },
+    });
+    if (p.isCancel(reposInput)) {
+        p.cancel("Setup cancelled.");
+        return false;
+    }
+    const backend = await p.select({
+        message: "Agent backend",
+        initialValue: existing.backend ?? "claude-code",
+        options: [
+            { value: "claude-code", label: "Claude Code" },
+            { value: "codex", label: "OpenAI Codex" },
+        ],
+    });
+    if (p.isCancel(backend)) {
+        p.cancel("Setup cancelled.");
+        return false;
+    }
+    const repos = reposInput.split(",").map((s) => resolve(s.trim()));
+    const config = {
+        ...existing,
+        repos,
+        backend: backend,
+        tunnel: true,
+    };
+    mkdirSync(POMPEII_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+    writeFileSync(ENV_FILE, `POMPEII_API_KEY=${apiKey}\nWEBHOOK_SECRET=${webhookSecret}\n`, {
+        mode: 0o600,
+    });
+    p.outro("Config saved to ~/.pompeii/");
+    return true;
+}

package/dist/src/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(port: number): Promise<void>;

package/dist/src/commands/start.js

@@ -0,0 +1,63 @@
+import * as p from "@clack/prompts";
+import { hasConfig } from "../config.js";
+import { isDaemonRunning, spawnDaemon, healthCheck, readDaemonState, } from "../daemon.js";
+import { runSetup } from "./setup.js";
+import { LOG_FILE } from "../paths.js";
+const HEALTH_POLL_MS = 300;
+const HEALTH_TIMEOUT_MS = 15000;
+async function waitForHealth(port) {
+    const deadline = Date.now() + HEALTH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const { ok } = await healthCheck(port);
+        if (ok)
+            return true;
+        await new Promise((r) => setTimeout(r, HEALTH_POLL_MS));
+    }
+    return false;
+}
+async function waitForTunnel() {
+    const deadline = Date.now() + 20000;
+    while (Date.now() < deadline) {
+        const state = readDaemonState();
+        if (state?.tunnelUrl)
+            return state.tunnelUrl;
+        await new Promise((r) => setTimeout(r, HEALTH_POLL_MS));
+    }
+    return null;
+}
+export async function startCommand(port) {
+    const { running, state } = isDaemonRunning();
+    if (running && state) {
+        console.log(`Bridge already running (PID ${state.pid}, port ${state.port})`);
+        if (state.tunnelUrl) {
+            console.log(`Tunnel: ${state.tunnelUrl}`);
+        }
+        return;
+    }
+    if (!hasConfig()) {
+        console.log("No config found. Running setup...\n");
+        const ok = await runSetup();
+        if (!ok)
+            return;
+        console.log();
+    }
+    const spinner = p.spinner();
+    spinner.start("Starting bridge daemon...");
+    const daemon = spawnDaemon(port);
+    const healthy = await waitForHealth(daemon.port);
+    if (!healthy) {
+        spinner.stop("Failed to start bridge daemon.");
+        console.log(`Check logs: ${LOG_FILE}`);
+        return;
+    }
+    spinner.message("Waiting for tunnel...");
+    const tunnelUrl = await waitForTunnel();
+    if (tunnelUrl) {
+        spinner.stop(`Bridge running (PID ${daemon.pid})`);
+        console.log(`Tunnel: ${tunnelUrl}`);
+    }
+    else {
+        spinner.stop(`Bridge running (PID ${daemon.pid})`);
+        console.log("Tunnel URL not yet available. Check: pompeii bridge status");
+    }
+}

package/dist/src/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/src/commands/status.js

@@ -0,0 +1,23 @@
+import { isDaemonRunning, healthCheck } from "../daemon.js";
+export async function statusCommand() {
+    const { running, state } = isDaemonRunning();
+    if (!running) {
+        console.log("Bridge: stopped");
+        return;
+    }
+    console.log("Bridge: running");
+    console.log(`  PID:     ${state.pid}`);
+    console.log(`  Port:    ${state.port}`);
+    console.log(`  Started: ${state.startedAt}`);
+    if (state.tunnelUrl) {
+        console.log(`  Tunnel:  ${state.tunnelUrl}`);
+    }
+    const { ok, data } = await healthCheck(state.port);
+    if (ok && data) {
+        console.log(`  Backend: ${data.backend}`);
+        console.log(`  Active:  ${data.active}`);
+    }
+    else {
+        console.log("  Health:  unreachable");
+    }
+}

package/dist/src/commands/stop.d.ts

@@ -0,0 +1 @@
+export declare function stopCommand(): void;

package/dist/src/commands/stop.js

@@ -0,0 +1,11 @@
+import { isDaemonRunning, stopDaemon } from "../daemon.js";
+export function stopCommand() {
+    const { running, state } = isDaemonRunning();
+    if (!running) {
+        console.log("Bridge is not running.");
+        return;
+    }
+    console.log(`Stopping bridge (PID ${state.pid})...`);
+    stopDaemon();
+    console.log("Bridge stopped.");
+}

package/dist/src/config.d.ts

@@ -0,0 +1,27 @@
+export type Backend = "claude-code" | "codex";
+export interface Config {
+    webhookSecret: string;
+    repos: string[];
+    backend: Backend;
+    port: number;
+    maxTurns: number;
+    maxConcurrent: number;
+    allowedTools: string[];
+    heartbeatIntervalMs: number;
+    pompeiiApiKey: string | null;
+    pompeiiApiUrl: string;
+    tunnel: boolean;
+}
+export interface FileConfig {
+    repos?: string[];
+    backend?: Backend;
+    port?: number;
+    maxTurns?: number;
+    maxConcurrent?: number;
+    allowedTools?: string[];
+    heartbeatIntervalMs?: number;
+    pompeiiApiUrl?: string;
+    tunnel?: boolean;
+}
+export declare function hasConfig(): boolean;
+export declare function loadConfig(): Config;

package/dist/src/config.js

@@ -0,0 +1,98 @@
+import { readFileSync, existsSync } from "node:fs";
+import { CONFIG_FILE, ENV_FILE } from "./paths.js";
+function loadEnvFile() {
+    if (!existsSync(ENV_FILE))
+        return;
+    const content = readFileSync(ENV_FILE, "utf-8");
+    for (const line of content.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;
+        }
+    }
+}
+function loadFileConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function hasConfig() {
+    return existsSync(CONFIG_FILE) && existsSync(ENV_FILE);
+}
+export function loadConfig() {
+    const isDaemon = process.env.POMPEII_DAEMON === "1";
+    if (isDaemon) {
+        loadEnvFile();
+    }
+    const file = isDaemon ? loadFileConfig() : {};
+    const webhookSecret = process.env.WEBHOOK_SECRET ?? "";
+    if (!webhookSecret) {
+        console.error("Missing required: WEBHOOK_SECRET");
+        process.exit(1);
+    }
+    const reposRaw = process.env.REPOS ?? (file.repos ? file.repos.join(",") : "");
+    if (!reposRaw) {
+        console.error("Missing required: REPOS");
+        process.exit(1);
+    }
+    const repos = reposRaw.split(",").map((p) => p.trim());
+    const backend = (process.env.BACKEND ??
+        file.backend ??
+        "claude-code");
+    if (backend !== "claude-code" && backend !== "codex") {
+        console.error(`Invalid BACKEND: ${backend}. Must be "claude-code" or "codex"`);
+        process.exit(1);
+    }
+    const tunnel = process.env.TUNNEL === "1" ||
+        process.env.TUNNEL === "true" ||
+        (file.tunnel ?? isDaemon);
+    const pompeiiApiKey = process.env.POMPEII_API_KEY ?? null;
+    if (tunnel && !pompeiiApiKey) {
+        console.error("POMPEII_API_KEY is required when tunnel is enabled");
+        process.exit(1);
+    }
+    return {
+        webhookSecret,
+        repos,
+        backend,
+        port: parseInt(process.env.PORT ?? String(file.port ?? 3001), 10),
+        maxTurns: parseInt(process.env.MAX_TURNS ?? String(file.maxTurns ?? 25), 10),
+        maxConcurrent: parseInt(process.env.MAX_CONCURRENT ?? String(file.maxConcurrent ?? 3), 10),
+        allowedTools: process.env.ALLOWED_TOOLS
+            ? process.env.ALLOWED_TOOLS.split(",")
+            : (file.allowedTools ?? [
+                "Read",
+                "Edit",
+                "Bash",
+                "Glob",
+                "Grep",
+                "Write",
+                "Task",
+                "WebSearch",
+                "WebFetch",
+            ]),
+        heartbeatIntervalMs: parseInt(process.env.HEARTBEAT_INTERVAL_MS ??
+            String(file.heartbeatIntervalMs ?? 15000), 10),
+        pompeiiApiKey,
+        pompeiiApiUrl: process.env.POMPEII_API_URL ??
+            file.pompeiiApiUrl ??
+            "https://api.pompeii.ai",
+        tunnel,
+    };
+}

package/dist/src/daemon.d.ts

@@ -0,0 +1,17 @@
+export interface DaemonState {
+    pid: number;
+    port: number;
+    startedAt: string;
+    tunnelUrl?: string;
+}
+export declare function readDaemonState(): DaemonState | null;
+export declare function isDaemonRunning(): {
+    running: boolean;
+    state: DaemonState | null;
+};
+export declare function spawnDaemon(port: number): DaemonState;
+export declare function stopDaemon(): boolean;
+export declare function healthCheck(port: number): Promise<{
+    ok: boolean;
+    data?: any;
+}>;

package/dist/src/daemon.js

@@ -0,0 +1,83 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, createWriteStream, } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { POMPEII_DIR, DAEMON_FILE, LOG_FILE } from "./paths.js";
+export function readDaemonState() {
+    if (!existsSync(DAEMON_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(DAEMON_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isDaemonRunning() {
+    const state = readDaemonState();
+    if (!state)
+        return { running: false, state: null };
+    if (!isProcessAlive(state.pid))
+        return { running: false, state: null };
+    return { running: true, state };
+}
+export function spawnDaemon(port) {
+    mkdirSync(POMPEII_DIR, { recursive: true });
+    const entrypoint = fileURLToPath(new URL("./index.js", import.meta.url));
+    const logStream = createWriteStream(LOG_FILE, { flags: "a" });
+    const child = spawn(process.execPath, [entrypoint], {
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            POMPEII_DAEMON: "1",
+            PORT: String(port),
+        },
+    });
+    child.stdout?.pipe(logStream);
+    child.stderr?.pipe(logStream);
+    child.unref();
+    const state = {
+        pid: child.pid,
+        port,
+        startedAt: new Date().toISOString(),
+    };
+    writeFileSync(DAEMON_FILE, JSON.stringify(state, null, 2));
+    return state;
+}
+export function stopDaemon() {
+    const state = readDaemonState();
+    if (!state)
+        return false;
+    try {
+        process.kill(state.pid, "SIGTERM");
+    }
+    catch { }
+    try {
+        unlinkSync(DAEMON_FILE);
+    }
+    catch { }
+    return true;
+}
+export async function healthCheck(port) {
+    try {
+        const host = "localhost";
+        const res = await fetch(`http://${host}:${port}/health`);
+        if (res.ok) {
+            const data = await res.json();
+            return { ok: true, data };
+        }
+        return { ok: false };
+    }
+    catch {
+        return { ok: false };
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/index.js

@@ -0,0 +1,128 @@
+import { createServer } from "node:http";
+import { unlinkSync } from "node:fs";
+import { loadConfig } from "./config.js";
+import { verifySignature } from "./verify.js";
+import * as sse from "./sse.js";
+import { runClaudeCode } from "./claude-code.js";
+import { runCodex } from "./codex.js";
+import { startTunnel } from "./tunnel.js";
+import { DAEMON_FILE } from "./paths.js";
+const config = loadConfig();
+let activeRequests = 0;
+function buildPrompt(payload, repos) {
+    const parts = [];
+    parts.push("You have access to the following repositories:");
+    for (const repo of repos) {
+        parts.push(`  - ${repo}`);
+    }
+    parts.push("Determine which repository is relevant to the user's request and work in that directory.", "");
+    if (payload.context.length > 0) {
+        parts.push("Recent conversation context:");
+        for (const msg of payload.context) {
+            parts.push(`[${msg.user_name}]: ${msg.content}`);
+        }
+        parts.push("");
+    }
+    parts.push(`[${payload.message.user_name}]: ${payload.message.content}`);
+    return parts.join("\n");
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+        req.on("error", reject);
+    });
+}
+const server = createServer(async (req, res) => {
+    if (req.method === "GET" && req.url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            status: "ok",
+            backend: config.backend,
+            active: activeRequests,
+        }));
+        return;
+    }
+    if (req.method !== "POST" || req.url !== "/webhook") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+    }
+    if (activeRequests >= config.maxConcurrent) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Too many concurrent requests" }));
+        return;
+    }
+    const body = await readBody(req);
+    const signature = req.headers["x-webhook-signature"];
+    if (!signature || !verifySignature(body, signature, config.webhookSecret)) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid signature" }));
+        return;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+        return;
+    }
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
+    const heartbeatTimer = setInterval(() => sse.heartbeat(res), config.heartbeatIntervalMs);
+    const abort = new AbortController();
+    res.on("close", () => {
+        clearInterval(heartbeatTimer);
+        abort.abort();
+    });
+    activeRequests++;
+    const prompt = buildPrompt(payload, config.repos);
+    try {
+        const run = config.backend === "claude-code" ? runClaudeCode : runCodex;
+        await run(prompt, res, abort, config);
+    }
+    catch (err) {
+        if (!abort.signal.aborted) {
+            const msg = err instanceof Error ? err.message : "Unknown error";
+            sse.error(res, msg);
+        }
+    }
+    finally {
+        activeRequests--;
+        clearInterval(heartbeatTimer);
+        if (!res.writableEnded)
+            res.end();
+    }
+});
+function shutdown() {
+    console.log("Shutting down...");
+    server.close(() => {
+        try {
+            unlinkSync(DAEMON_FILE);
+        }
+        catch { }
+        process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 5000);
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+server.listen(config.port, async () => {
+    console.log(`Bridge running on :${config.port} [backend=${config.backend}]`);
+    if (config.tunnel && config.pompeiiApiKey) {
+        try {
+            const url = await startTunnel(config.port, config.pompeiiApiKey, config.pompeiiApiUrl);
+            console.log(`Tunnel: ${url}`);
+        }
+        catch (err) {
+            console.error(`Tunnel failed: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+    }
+});

package/dist/src/paths.d.ts

@@ -0,0 +1,6 @@
+export declare const POMPEII_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare const ENV_FILE: string;
+export declare const DAEMON_FILE: string;
+export declare const LOG_FILE: string;
+export declare const TUNNEL_LOG: string;

package/dist/src/paths.js

@@ -0,0 +1,8 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const POMPEII_DIR = join(homedir(), ".pompeii");
+export const CONFIG_FILE = join(POMPEII_DIR, "config.json");
+export const ENV_FILE = join(POMPEII_DIR, ".env");
+export const DAEMON_FILE = join(POMPEII_DIR, "daemon.json");
+export const LOG_FILE = join(POMPEII_DIR, "bridge.log");
+export const TUNNEL_LOG = join(POMPEII_DIR, "tunnel.log");

package/dist/src/sse.d.ts

@@ -0,0 +1,6 @@
+import type { ServerResponse } from "node:http";
+export declare function chunk(res: ServerResponse, content: string): void;
+export declare function activity(res: ServerResponse, tool: string, status: "running" | "success" | "error", result?: string): void;
+export declare function done(res: ServerResponse): void;
+export declare function error(res: ServerResponse, message: string): void;
+export declare function heartbeat(res: ServerResponse): void;

package/dist/src/sse.js

@@ -0,0 +1,23 @@
+function send(res, data) {
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+export function chunk(res, content) {
+    send(res, { type: "chunk", content });
+}
+export function activity(res, tool, status, result) {
+    const data = { type: "activity", tool, status };
+    if (result !== undefined)
+        data.result = result;
+    send(res, data);
+}
+export function done(res) {
+    send(res, { type: "done" });
+    res.end();
+}
+export function error(res, message) {
+    send(res, { type: "error", message });
+    res.end();
+}
+export function heartbeat(res) {
+    res.write(": heartbeat\n\n");
+}

package/dist/src/tunnel.d.ts

@@ -0,0 +1 @@
+export declare function startTunnel(port: number, apiKey: string, apiUrl: string): Promise<string>;

package/dist/src/tunnel.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { readFile, mkdir } from "node:fs/promises";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { POMPEII_DIR, TUNNEL_LOG, DAEMON_FILE } from "./paths.js";
+const CLOUDFLARED_URL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+const MAX_POLL_ATTEMPTS = 30;
+const POLL_INTERVAL_MS = 500;
+async function pollForUrl() {
+    for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+        try {
+            const log = await readFile(TUNNEL_LOG, "utf-8");
+            const match = log.match(CLOUDFLARED_URL_RE);
+            if (match)
+                return match[0];
+        }
+        catch { }
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+    throw new Error("Timed out waiting for tunnel URL");
+}
+async function updatePompeiiWebhook(tunnelUrl, apiKey, apiUrl) {
+    const webhookUrl = `${tunnelUrl}/webhook`;
+    const res = await fetch(`${apiUrl}/v1/bot`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+            "X-Agent-Key": apiKey,
+        },
+        body: JSON.stringify({ webhook_url: webhookUrl }),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        console.error(`Webhook update failed (${res.status}): ${body}`);
+    }
+    else {
+        console.log(`Webhook URL updated: ${webhookUrl}`);
+    }
+}
+function updateDaemonFile(tunnelUrl) {
+    if (!existsSync(DAEMON_FILE))
+        return;
+    try {
+        const daemon = JSON.parse(readFileSync(DAEMON_FILE, "utf-8"));
+        daemon.tunnelUrl = tunnelUrl;
+        writeFileSync(DAEMON_FILE, JSON.stringify(daemon, null, 2));
+    }
+    catch { }
+}
+export async function startTunnel(port, apiKey, apiUrl) {
+    await mkdir(POMPEII_DIR, { recursive: true });
+    const child = spawn("cloudflared", ["tunnel", "--url", `http://0.0.0.0:${port}`], {
+        detached: true,
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    const logStream = await import("node:fs").then((fs) => fs.createWriteStream(TUNNEL_LOG, { flags: "w" }));
+    child.stderr?.pipe(logStream);
+    child.unref();
+    const url = await pollForUrl();
+    updateDaemonFile(url);
+    await updatePompeiiWebhook(url, apiKey, apiUrl);
+    return url;
+}

package/dist/src/verify.d.ts

@@ -0,0 +1 @@
+export declare function verifySignature(payload: string, signature: string, secret: string): boolean;

package/dist/src/verify.js

@@ -0,0 +1,8 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+export function verifySignature(payload, signature, secret) {
+    const expected = createHmac("sha256", secret).update(payload).digest("hex");
+    const sig = signature.replace(/^sha256=/, "");
+    if (sig.length !== expected.length)
+        return false;
+    return timingSafeEqual(Buffer.from(sig, "hex"), Buffer.from(expected, "hex"));
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@pompeii-labs/bridge",
+    "version": "0.1.0",
+    "type": "module",
+    "bin": {
+        "pompeii": "dist/src/cli.js"
+    },
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "dev": "bun --watch src/index.ts",
+        "build": "tsc",
+        "start": "node dist/src/index.js",
+        "prepublishOnly": "tsc"
+    },
+    "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "latest",
+        "@clack/prompts": "^0.7.0",
+        "@openai/codex-sdk": "latest",
+        "commander": "^12.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.13.4",
+        "typescript": "^5.9.3"
+    }
+}