@velum-labs/routekit-gateway 0.9.0

package/dist/switching-proxy.js

@@ -0,0 +1,232 @@
+/**
+ * Stable data-plane front door whose internal router generation can be
+ * replaced atomically.
+ *
+ * A singleton daemon keeps this listener for its whole lifetime. Reload builds
+ * a complete router on an ephemeral loopback port, calls `swapTarget`, then
+ * drains the old router. Requests accepted before the swap stay attached to
+ * the old generation; later requests immediately use the new one.
+ */
+import { createServer } from "node:http";
+import { assertAuthenticatedBind, trimTrailingSlashes } from "@velum-labs/routekit-runtime";
+import { authorizedRequest } from "./auth.js";
+const MAX_BODY_BYTES = 16 * 1024 * 1024;
+const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade"
+]);
+function requestHeaders(headers) {
+    const result = new Headers();
+    for (const [name, value] of Object.entries(headers)) {
+        if (value === undefined || HOP_BY_HOP.has(name.toLowerCase()) || name === "host")
+            continue;
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                result.append(name, entry);
+        }
+        else {
+            result.set(name, value);
+        }
+    }
+    return result;
+}
+async function requestBody(req) {
+    if (req.method === "GET" || req.method === "HEAD")
+        return undefined;
+    const chunks = [];
+    let total = 0;
+    for await (const value of req) {
+        const chunk = value;
+        total += chunk.length;
+        if (total > MAX_BODY_BYTES)
+            throw new Error("proxy request body too large");
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+function writeJson(res, status, value) {
+    const payload = Buffer.from(JSON.stringify(value));
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json");
+    res.setHeader("content-length", String(payload.length));
+    res.end(payload);
+}
+async function pipe(res, upstream) {
+    res.statusCode = upstream.status;
+    for (const [name, value] of upstream.headers) {
+        if (!HOP_BY_HOP.has(name.toLowerCase()) && name.toLowerCase() !== "content-length") {
+            res.setHeader(name, value);
+        }
+    }
+    if (upstream.body === null) {
+        res.end();
+        return;
+    }
+    const reader = upstream.body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value !== undefined && !res.write(Buffer.from(value))) {
+                await Promise.race([
+                    new Promise((resolve) => res.once("drain", resolve)),
+                    new Promise((resolve) => res.once("close", resolve))
+                ]);
+                if (res.destroyed)
+                    break;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    res.end();
+}
+export async function startSwitchingGatewayProxy(input) {
+    const host = input.host ?? "127.0.0.1";
+    assertAuthenticatedBind(host, input.authToken);
+    let active = {
+        url: trimTrailingSlashes(input.target),
+        leases: 0,
+        waiters: new Set()
+    };
+    const generations = new Map([[active.url, active]]);
+    let draining = false;
+    let inflight = 0;
+    const server = createServer((req, res) => {
+        inflight += 1;
+        res.once("close", () => {
+            inflight -= 1;
+        });
+        void (async () => {
+            const path = req.url ?? "/";
+            if (path.split("?")[0] === "/health") {
+                writeJson(res, draining ? 503 : 200, {
+                    status: draining ? "draining" : "ok"
+                });
+                return;
+            }
+            if (draining) {
+                writeJson(res, 503, {
+                    error: { message: "gateway is draining", type: "unavailable" }
+                });
+                return;
+            }
+            if (input.authToken !== undefined && !authorizedRequest(req, input.authToken)) {
+                writeJson(res, 401, {
+                    error: { message: "unauthorized", type: "auth_error" }
+                });
+                return;
+            }
+            const selected = active;
+            selected.leases += 1;
+            const aborter = new AbortController();
+            const onClose = () => {
+                if (!res.writableEnded)
+                    aborter.abort(new Error("gateway client disconnected"));
+            };
+            res.once("close", onClose);
+            try {
+                const body = await requestBody(req);
+                const upstream = await fetch(`${selected.url}${path}`, {
+                    method: req.method ?? "GET",
+                    headers: requestHeaders(req.headers),
+                    ...(body !== undefined ? { body } : {}),
+                    signal: AbortSignal.any([
+                        aborter.signal,
+                        AbortSignal.timeout(10 * 60 * 1000)
+                    ])
+                });
+                await pipe(res, upstream);
+            }
+            catch {
+                if (!res.destroyed && !res.headersSent) {
+                    writeJson(res, 502, {
+                        error: { message: "router generation unavailable", type: "upstream_error" }
+                    });
+                }
+                else if (!res.writableEnded) {
+                    res.destroy();
+                }
+            }
+            finally {
+                res.off("close", onClose);
+                selected.leases -= 1;
+                if (selected.leases === 0) {
+                    for (const resolve of selected.waiters)
+                        resolve();
+                    selected.waiters.clear();
+                    if (selected !== active)
+                        generations.delete(selected.url);
+                }
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(input.port ?? 0, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address !== null ? address.port : input.port ?? 0;
+    let drainRun;
+    const drain = (graceMs = 0) => {
+        drainRun ??= (async () => {
+            draining = true;
+            server.closeIdleConnections();
+            const deadline = Date.now() + graceMs;
+            while (inflight > 0 && Date.now() < deadline) {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+            const closed = new Promise((resolve) => server.close(() => resolve()));
+            server.closeAllConnections();
+            await closed;
+        })();
+        return drainRun;
+    };
+    return {
+        url: () => `http://${host.includes(":") ? `[${host}]` : host}:${port}`,
+        port: () => port,
+        target: () => active.url,
+        swapTarget(next) {
+            const previous = active.url;
+            const url = trimTrailingSlashes(next);
+            active = generations.get(url) ?? { url, leases: 0, waiters: new Set() };
+            generations.set(url, active);
+            return previous;
+        },
+        async waitForTargetIdle(url, graceMs) {
+            const generation = generations.get(trimTrailingSlashes(url));
+            if (generation === undefined || generation.leases === 0)
+                return true;
+            let timer;
+            const idle = new Promise((resolve) => {
+                const done = () => {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    resolve(true);
+                };
+                generation.waiters.add(done);
+                timer = setTimeout(() => {
+                    generation.waiters.delete(done);
+                    resolve(false);
+                }, graceMs);
+            });
+            const result = await idle;
+            if (generation !== active && generation.leases === 0)
+                generations.delete(generation.url);
+            return result;
+        },
+        drain,
+        close: async () => await drain(0)
+    };
+}

package/dist/test/acp-agent.test.d.ts

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

package/dist/test/acp-agent.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { PassThrough } from "node:stream";
+import { test } from "node:test";
+import { runAcpAgent } from "../acp-agent.js";
+async function driveAgent(runner, requests) {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    let raw = "";
+    output.on("data", (chunk) => {
+        raw += chunk.toString("utf8");
+    });
+    const done = runAcpAgent({ runner, input, output });
+    for (const request of requests) {
+        input.write(`${JSON.stringify(request)}\n`);
+    }
+    input.end();
+    await done;
+    return raw
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+}
+test("acp agent completes initialize, session/new, and session/prompt", async () => {
+    const runner = async (input) => ({
+        finalOutput: `ROUTE_OK:${input.prompt}`,
+        runId: "run_acp_1",
+        status: "succeeded",
+        evidence: ["patch_artifact", "test_report"]
+    });
+    const messages = await driveAgent(runner, [
+        { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: 1 } },
+        { jsonrpc: "2.0", id: 2, method: "session/new", params: { cwd: "/tmp", mcpServers: [] } },
+        {
+            jsonrpc: "2.0",
+            id: 3,
+            method: "session/prompt",
+            params: { sessionId: "sess_1", prompt: [{ type: "text", text: "patch the bug" }] }
+        }
+    ]);
+    const initialize = messages.find((message) => message.id === 1);
+    assert.ok(initialize?.result);
+    assert.equal(initialize.result.protocolVersion, 1);
+    const sessionNew = messages.find((message) => message.id === 2);
+    assert.equal((sessionNew?.result).sessionId, "sess_1");
+    const update = messages.find((message) => message.method === "session/update");
+    assert.ok(update);
+    const updateParams = update.params;
+    assert.match(updateParams.update.content.text, /ROUTE_OK:patch the bug/);
+    const promptResult = messages.find((message) => message.id === 3);
+    const result = promptResult?.result;
+    assert.equal(result.stopReason, "end_turn");
+    assert.equal(result._meta.runId, "run_acp_1");
+});
+test("acp agent returns method-not-found for unknown methods", async () => {
+    const runner = async () => ({
+        finalOutput: "unused",
+        runId: "run",
+        status: "succeeded",
+        evidence: []
+    });
+    const messages = await driveAgent(runner, [
+        { jsonrpc: "2.0", id: 9, method: "nonsense/method", params: {} }
+    ]);
+    const error = messages.find((message) => message.id === 9);
+    assert.equal(error?.error?.code, -32601);
+});

package/dist/test/acp-registry.test.d.ts

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

package/dist/test/acp-registry.test.js

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { fetchAcpRegistry, installAcpAdapters } from "../acp-registry.js";
+const FAKE_REGISTRY = {
+    agents: [
+        {
+            id: "codex-cli",
+            name: "Codex CLI",
+            version: "0.16.0",
+            description: "ACP adapter for OpenAI's coding assistant",
+            distribution: { type: "npm", package: "@zed-industries/codex-acp" }
+        },
+        {
+            id: "claude-agent",
+            name: "Claude Agent",
+            version: "0.46.0",
+            description: "ACP wrapper for Anthropic's Claude",
+            distribution: { type: "npm", package: "@agentclientprotocol/claude-agent-acp" }
+        },
+        {
+            id: "no-distribution",
+            name: "Broken",
+            version: "1.0.0"
+        }
+    ]
+};
+function fakeFetcher(payload = FAKE_REGISTRY) {
+    return async () => payload;
+}
+test("fetchAcpRegistry normalizes agent metadata", async () => {
+    const registry = await fetchAcpRegistry(fakeFetcher());
+    const ids = registry.agents.map((agent) => agent.id);
+    assert.ok(ids.includes("codex-cli"));
+    assert.ok(ids.includes("claude-agent"));
+});
+test("installAcpAdapters writes metadata for known agents", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "acp-registry-"));
+    try {
+        const installed = await installAcpAdapters({
+            agentIds: ["codex-cli", "claude-agent"],
+            installDir: dir,
+            fetcher: fakeFetcher()
+        });
+        assert.equal(installed.length, 2);
+        const codex = JSON.parse(readFileSync(join(dir, "codex-cli.json"), "utf8"));
+        assert.equal(codex.id, "codex-cli");
+        assert.equal(codex.version, "0.16.0");
+        assert.equal(codex.distribution.package, "@zed-industries/codex-acp");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("installAcpAdapters rejects unknown ids and missing distribution", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "acp-registry-"));
+    try {
+        await assert.rejects(() => installAcpAdapters({ agentIds: ["missing"], installDir: dir, fetcher: fakeFetcher() }), /no agent with id "missing"/);
+        await assert.rejects(() => installAcpAdapters({
+            agentIds: ["no-distribution"],
+            installDir: dir,
+            fetcher: fakeFetcher()
+        }), /no distribution metadata/);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});

package/dist/test/anthropic.test.d.ts

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