@velum-labs/routekit-daemon 0.9.0

package/dist/cliproxy-sidecar.js

@@ -0,0 +1,148 @@
+import { CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, CLIPROXY_PINNED_VERSION, cliproxyApiKey, cliproxyBaseUrl, cliproxyBinaryPath, spawnCliproxy } from "@velum-labs/routekit-accounts";
+const RESPAWN_DELAY_MS = 2_000;
+const READY_TIMEOUT_MS = 8_000;
+const READY_POLL_MS = 250;
+const STOP_GRACE_MS = 5_000;
+/** The sidecar is managed here unless an external proxy URL is configured. */
+export function cliproxyManagedLocally(env) {
+    return (env[CLIPROXY_BASE_URL_ENV] ?? "").length === 0;
+}
+export function createCliproxySidecar(input) {
+    const env = input.env;
+    const log = input.log ?? ((line) => void process.stderr.write(`${line}\n`));
+    let child;
+    let wanted = false;
+    let closed = false;
+    let stopping = false;
+    let respawnTimer;
+    const reachable = async (timeoutMs = 1_500) => {
+        const key = env[CLIPROXY_API_KEY_ENV] ?? cliproxyApiKey(env) ?? "";
+        try {
+            // Any HTTP answer (including 401/403) proves the listener is up.
+            await fetch(`${cliproxyBaseUrl(env)}/v1/models`, {
+                headers: { authorization: `Bearer ${key}` },
+                signal: AbortSignal.timeout(timeoutMs)
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    function scheduleRespawn() {
+        if (closed || !wanted || stopping || respawnTimer !== undefined)
+            return;
+        respawnTimer = setTimeout(() => {
+            respawnTimer = undefined;
+            spawnOnce();
+        }, RESPAWN_DELAY_MS);
+        respawnTimer.unref();
+    }
+    function spawnOnce() {
+        if (closed || !wanted || child !== undefined)
+            return;
+        let spawned;
+        try {
+            spawned = spawnCliproxy(env, { stdio: "ignore" });
+        }
+        catch (error) {
+            log(`routekit cliproxy sidecar failed to start: ${error instanceof Error ? error.message : String(error)}`);
+            scheduleRespawn();
+            return;
+        }
+        child = spawned;
+        spawned.once("error", (error) => {
+            if (child === spawned)
+                child = undefined;
+            log(`routekit cliproxy sidecar error: ${error.message}`);
+            scheduleRespawn();
+        });
+        spawned.once("exit", (code, signal) => {
+            if (child === spawned)
+                child = undefined;
+            if (closed || !wanted || stopping)
+                return;
+            log(`routekit cliproxy sidecar exited (${signal ?? `code ${code ?? "unknown"}`}); restarting`);
+            scheduleRespawn();
+        });
+    }
+    const stop = async () => {
+        if (respawnTimer !== undefined) {
+            clearTimeout(respawnTimer);
+            respawnTimer = undefined;
+        }
+        const current = child;
+        if (current === undefined)
+            return;
+        child = undefined;
+        stopping = true;
+        try {
+            await new Promise((resolve) => {
+                const killTimer = setTimeout(() => {
+                    current.kill("SIGKILL");
+                }, STOP_GRACE_MS);
+                killTimer.unref();
+                current.once("exit", () => {
+                    clearTimeout(killTimer);
+                    resolve();
+                });
+                if (!current.kill("SIGTERM")) {
+                    clearTimeout(killTimer);
+                    resolve();
+                }
+            });
+        }
+        finally {
+            stopping = false;
+        }
+    };
+    const waitUntilReady = async () => {
+        const deadline = Date.now() + READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (await reachable(READY_POLL_MS * 2))
+                return;
+            await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
+        }
+        // Force an unhealthy child through the normal crash-recovery path. Spawn
+        // failures already leave a retry timer armed.
+        child?.kill("SIGKILL");
+        throw new Error("routekit cliproxy sidecar did not answer within its readiness window");
+    };
+    return {
+        reconcile: async (next) => {
+            if (closed)
+                return;
+            const installable = cliproxyManagedLocally(env) &&
+                cliproxyBinaryPath(CLIPROXY_PINNED_VERSION, env) !== undefined;
+            wanted = next && installable;
+            if (!wanted) {
+                await stop();
+                return;
+            }
+            if (child === undefined)
+                spawnOnce();
+            // Always wait for readiness — including after a crash respawn left a
+            // child handle before the listener was accepting connections.
+            await waitUntilReady();
+        },
+        refresh: async () => {
+            if (closed ||
+                !wanted ||
+                !cliproxyManagedLocally(env) ||
+                cliproxyBinaryPath(CLIPROXY_PINNED_VERSION, env) === undefined) {
+                return;
+            }
+            await stop();
+            spawnOnce();
+            await waitUntilReady();
+        },
+        running: () => child !== undefined,
+        managed: () => cliproxyManagedLocally(env),
+        reachable,
+        close: async () => {
+            closed = true;
+            wanted = false;
+            await stop();
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import type { ServiceRecord } from "@velum-labs/routekit-runtime";
+export declare const ROUTEKIT_DAEMON_KIND = "daemon";
+export declare const ROUTEKIT_PRODUCT = "routekit";
+export type RouteKitDaemonOptions = {
+    packageVersion: string;
+    env?: NodeJS.ProcessEnv;
+    stateHome?: string;
+    configPath?: string;
+    host?: string;
+    port?: number;
+    authToken?: string;
+    authTokenFile?: string;
+    portless?: boolean;
+    drainGraceMs?: number;
+    onShutdownRequested?: (reason: "stop" | "restart" | "upgrade") => void;
+    /** Test seam used by child-process interruption coverage. */
+    onAccountTransactionPhase?: (phase: "prepared" | "credentials-written" | "router-swapped" | "committed") => void;
+};
+export type RunningRouteKitDaemon = {
+    record: ServiceRecord;
+    dataUrl: string;
+    controlUrl: string;
+    close(): Promise<void>;
+    reload(): Promise<void>;
+};
+export declare function startRouteKitDaemon(options: RouteKitDaemonOptions): Promise<RunningRouteKitDaemon>;