@myk-org/pi-sidecar 1.0.0-dev.1 → 1.0.0-dev.2

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { SessionStore, type CreateSessionOptions } from "./sessions.js";
+export { startWatchdog } from "./watchdog.js";
+import { type IncomingMessage } from "node:http";
+export declare function parseBody(req: IncomingMessage): Promise<any>;
+export declare function routeMatch(url: string, pattern: string): Record<string, string> | null;
+export interface SidecarHandle {
+    close(): Promise<void>;
+}
+export declare function startSidecar(options?: {
+    port?: number;
+    host?: string;
+    watchdogUrl?: string;
+}): SidecarHandle;

package/dist/index.js

@@ -0,0 +1,177 @@
+export { SessionStore } from "./sessions.js";
+export { startWatchdog } from "./watchdog.js";
+import { createServer } from "node:http";
+import { SessionStore } from "./sessions.js";
+import { startWatchdog } from "./watchdog.js";
+const MAX_BODY_SIZE = 1_048_576;
+// Simple JSON body parser
+export async function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        let bodySizeBytes = 0;
+        let rejected = false;
+        req.on("data", (chunk) => {
+            if (rejected)
+                return;
+            bodySizeBytes += chunk.length;
+            if (bodySizeBytes > MAX_BODY_SIZE) {
+                rejected = true;
+                req.resume();
+                reject(new Error("Payload too large"));
+                return;
+            }
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch (e) {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+export function routeMatch(url, pattern) {
+    const patternParts = pattern.split("/");
+    const urlParts = url.split("?")[0].split("/");
+    if (patternParts.length !== urlParts.length)
+        return null;
+    const params = {};
+    for (let i = 0; i < patternParts.length; i++) {
+        if (patternParts[i].startsWith(":")) {
+            params[patternParts[i].slice(1)] = urlParts[i];
+        }
+        else if (patternParts[i] !== urlParts[i]) {
+            return null;
+        }
+    }
+    return params;
+}
+export function startSidecar(options) {
+    const PORT = options?.port ?? parseInt(process.env.SIDECAR_PORT || "9100", 10);
+    const HOST = options?.host ?? (process.env.DEV_MODE === "true" ? "0.0.0.0" : "127.0.0.1");
+    const store = new SessionStore();
+    const server = createServer(async (req, res) => {
+        const method = req.method || "GET";
+        const url = req.url || "/";
+        try {
+            // GET /health
+            if (method === "GET" && url === "/health") {
+                if (!store.ready) {
+                    sendJson(res, 503, { status: "starting", message: "Model discovery in progress" });
+                    return;
+                }
+                sendJson(res, 200, { status: "ok", sessions: store.count() });
+                return;
+            }
+            // GET /models
+            if (method === "GET" && url === "/models") {
+                sendJson(res, 200, { models: store.getModels() });
+                return;
+            }
+            // POST /models/refresh
+            if (method === "POST" && url === "/models/refresh") {
+                const models = await store.refreshModels();
+                sendJson(res, 200, { models });
+                return;
+            }
+            // POST /sessions
+            if (method === "POST" && url === "/sessions") {
+                const body = await parseBody(req);
+                const { provider, model, system_prompt, cwd, custom_tools } = body;
+                if (!provider || !system_prompt) {
+                    sendJson(res, 400, { error: "provider and system_prompt are required" });
+                    return;
+                }
+                if (!model) {
+                    sendJson(res, 400, { error: "model is required. Use GET /models to list available models." });
+                    return;
+                }
+                const sessionId = await store.create({
+                    provider,
+                    model: model || "",
+                    systemPrompt: system_prompt,
+                    cwd: cwd || process.cwd(),
+                    customTools: custom_tools,
+                });
+                sendJson(res, 201, { session_id: sessionId });
+                return;
+            }
+            // POST /sessions/:id/prompt
+            let params = routeMatch(url, "/sessions/:id/prompt");
+            if (method === "POST" && params) {
+                const body = await parseBody(req);
+                if (!body.message) {
+                    sendJson(res, 400, { error: "message is required" });
+                    return;
+                }
+                const result = await store.prompt(params.id, body.message);
+                sendJson(res, 200, result);
+                return;
+            }
+            // POST /sessions/:id/abort
+            params = routeMatch(url, "/sessions/:id/abort");
+            if (method === "POST" && params) {
+                await store.abort(params.id);
+                sendJson(res, 200, { aborted: true });
+                return;
+            }
+            // DELETE /sessions/:id
+            params = routeMatch(url, "/sessions/:id");
+            if (method === "DELETE" && params) {
+                store.delete(params.id);
+                sendJson(res, 200, { deleted: true });
+                return;
+            }
+            sendJson(res, 404, { error: "Not found" });
+        }
+        catch (err) {
+            const message = err?.message || "Internal server error";
+            const status = message.includes("not found") ? 404 : message.includes("Payload too large") ? 413 : message.includes("Invalid JSON") ? 400 : message.includes("is busy") ? 409 : 500;
+            console.error(`[sidecar] ${method} ${url} error:`, message);
+            sendJson(res, status, { error: message });
+        }
+    });
+    // Stale session cleanup every 10 minutes
+    const cleanupInterval = setInterval(() => {
+        store.cleanupStale(60 * 60 * 1000); // 1 hour
+    }, 10 * 60 * 1000);
+    let stopWatchdog;
+    server.listen(PORT, HOST, () => {
+        console.log(`[sidecar] Pi SDK sidecar listening on http://${HOST}:${PORT}`);
+        const watchdogUrl = options?.watchdogUrl || process.env.SIDECAR_WATCHDOG_URL;
+        if (watchdogUrl) {
+            stopWatchdog = startWatchdog(watchdogUrl, () => {
+                console.log("[sidecar] Backend unresponsive, shutting down");
+                stopWatchdog?.();
+                clearInterval(cleanupInterval);
+                store.disposeAll();
+                server.close();
+            });
+        }
+        // Auto-discover models from extensions on startup
+        store.refreshModels().catch((err) => {
+            console.error("[sidecar] Model discovery failed:", err);
+        });
+    });
+    return {
+        close: () => new Promise((resolve, reject) => {
+            stopWatchdog?.();
+            clearInterval(cleanupInterval);
+            store.disposeAll();
+            server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+                console.log("[sidecar] Shut down");
+            });
+        }),
+    };
+}

package/dist/server.d.ts

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

package/dist/server.js

@@ -0,0 +1,2 @@
+import { startSidecar } from "./index.js";
+const handle = startSidecar();

package/dist/sessions.d.ts

@@ -0,0 +1,39 @@
+export interface CreateSessionOptions {
+    provider: string;
+    model: string;
+    systemPrompt: string;
+    cwd: string;
+    customTools?: any[];
+}
+export declare class SessionStore {
+    private sessions;
+    private authStorage;
+    private modelRegistry;
+    private _ready;
+    private acpxModels;
+    get ready(): boolean;
+    count(): number;
+    getModels(): Array<{
+        id: string;
+        name: string;
+        provider: string;
+    }>;
+    /**
+     * Discover models from all configured providers. Blocks until complete.
+     * Called on startup — /health returns ok only after this finishes.
+     */
+    refreshModels(): Promise<Array<{
+        id: string;
+        name: string;
+        provider: string;
+    }>>;
+    create(options: CreateSessionOptions): Promise<string>;
+    prompt(id: string, message: string): Promise<{
+        text: string;
+        usage: any;
+    }>;
+    abort(id: string): Promise<void>;
+    delete(id: string): void;
+    disposeAll(): void;
+    cleanupStale(maxAge: number): void;
+}

package/dist/sessions.js

@@ -0,0 +1,312 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { accessSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { getModel } from "@earendil-works/pi-ai";
+const require = createRequire(import.meta.url);
+function resolveExtensionPath(envVar, packageName, entryFile) {
+    const envPath = process.env[envVar];
+    if (envPath)
+        return envPath;
+    try {
+        // resolve() finds the package wherever npm installed it (hoisted or nested)
+        const pkgJson = require.resolve(`${packageName}/package.json`);
+        return join(dirname(pkgJson), entryFile);
+    }
+    catch (err) {
+        console.debug(`[sidecar] Could not resolve ${packageName}:`, err);
+        return "";
+    }
+}
+const ACPX_EXTENSION = resolveExtensionPath("SIDECAR_ACPX_EXTENSION_PATH", "pi-orchestrator-config", "extensions/acpx-provider/index.ts");
+const VERTEX_EXTENSION = resolveExtensionPath("SIDECAR_VERTEX_EXTENSION_PATH", "pi-vertex-claude", "index.ts");
+export class SessionStore {
+    sessions = new Map();
+    authStorage = AuthStorage.create();
+    modelRegistry = ModelRegistry.create(this.authStorage);
+    _ready = false;
+    acpxModels = [];
+    get ready() {
+        return this._ready;
+    }
+    count() {
+        return this.sessions.size;
+    }
+    getModels() {
+        // Providers that require browser OAuth and cannot work in a headless container
+        const HEADLESS_EXCLUDED_PROVIDERS = new Set(["github-copilot"]);
+        const builtinModels = this.modelRegistry.getAvailable()
+            .filter((m) => !HEADLESS_EXCLUDED_PROVIDERS.has(m.provider))
+            .map((m) => ({
+            id: m.id,
+            name: m.name,
+            provider: m.provider,
+        }));
+        return [...builtinModels, ...this.acpxModels];
+    }
+    /**
+     * Discover models from all configured providers. Blocks until complete.
+     * Called on startup — /health returns ok only after this finishes.
+     */
+    async refreshModels() {
+        // Create a bootstrap session to trigger extension loading.
+        // Extensions like vertex-claude register models synchronously on load.
+        // The session is kept alive (disposed at cleanup) to maintain extension state.
+        const bootstrapId = await this.create({
+            provider: "google",
+            model: "gemini-2.5-flash",
+            systemPrompt: "bootstrap",
+            cwd: "/tmp",
+        });
+        console.log(`[sidecar] Bootstrap session created for extension loading`);
+        // Discover acpx models for each agent in parallel (blocks until all complete)
+        const agents = (process.env.ACPX_AGENTS || "")
+            .split(",")
+            .map((a) => a.trim())
+            .filter((a) => a.length > 0);
+        if (agents.length > 0) {
+            console.log(`[sidecar] Discovering models for ACPX agents: ${agents.join(", ")}`);
+            const results = await Promise.allSettled(agents.map((agent) => discoverAcpxModels(agent)));
+            this.acpxModels = [];
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                const agent = agents[i];
+                if (result.status === "fulfilled" && result.value.length > 0) {
+                    this.acpxModels.push(...result.value);
+                    console.log(`[sidecar] acpx-${agent}: ${result.value.length} models discovered`);
+                }
+                else if (result.status === "rejected") {
+                    console.error(`[sidecar] acpx-${agent}: discovery failed:`, result.reason);
+                }
+                else {
+                    console.warn(`[sidecar] acpx-${agent}: no models discovered`);
+                }
+            }
+        }
+        // Clean up bootstrap session
+        this.delete(bootstrapId);
+        this._ready = true;
+        console.log(`[sidecar] Model discovery complete: ${this.getModels().length} models available`);
+        return this.getModels();
+    }
+    async create(options) {
+        const id = randomUUID();
+        if (!options.model) {
+            throw new Error(`Model is required. Use GET /models to list available models.`);
+        }
+        // Find the model
+        let model = this.modelRegistry.find(options.provider, options.model) || undefined;
+        if (!model) {
+            // Try built-in models
+            model = getModel(options.provider, options.model) || undefined;
+        }
+        if (!model) {
+            throw new Error(`Model '${options.model}' not found for provider '${options.provider}'. Use GET /models to list available models.`);
+        }
+        // Build extension paths (only include existing files)
+        const extensionPaths = [];
+        if (ACPX_EXTENSION) {
+            try {
+                accessSync(ACPX_EXTENSION);
+                extensionPaths.push(ACPX_EXTENSION);
+                console.log(`[sidecar] Extension found: ${ACPX_EXTENSION}`);
+            }
+            catch (err) {
+                console.warn(`[sidecar] ACPX extension not found at ${ACPX_EXTENSION}:`, err);
+            }
+        }
+        if (VERTEX_EXTENSION) {
+            try {
+                accessSync(VERTEX_EXTENSION);
+                extensionPaths.push(VERTEX_EXTENSION);
+                console.log(`[sidecar] Extension found: ${VERTEX_EXTENSION}`);
+            }
+            catch (err) {
+                console.warn(`[sidecar] Vertex extension not found at ${VERTEX_EXTENSION}:`, err);
+            }
+        }
+        console.log(`[sidecar] Loading ${extensionPaths.length} extensions`);
+        // Build custom tools from config
+        const customTools = options.customTools || [];
+        const settingsManager = SettingsManager.inMemory({
+            compaction: { enabled: false },
+        });
+        const loader = new DefaultResourceLoader({
+            cwd: options.cwd,
+            agentDir: "/tmp/pi-sidecar-agent",
+            settingsManager,
+            additionalExtensionPaths: extensionPaths,
+            systemPromptOverride: () => options.systemPrompt,
+        });
+        await loader.reload();
+        const { session } = await createAgentSession({
+            cwd: options.cwd,
+            model,
+            thinkingLevel: "off",
+            tools: ["read", "grep", "find", "ls", "bash"],
+            customTools,
+            resourceLoader: loader,
+            sessionManager: SessionManager.inMemory(),
+            settingsManager,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+        });
+        this.sessions.set(id, { session, lastActivity: Date.now(), inFlight: false });
+        console.log(`[sidecar] Session created: ${id} (provider=${options.provider}, model=${options.model})`);
+        return id;
+    }
+    async prompt(id, message) {
+        const entry = this.sessions.get(id);
+        if (!entry)
+            throw new Error(`Session ${id} not found`);
+        if (entry.inFlight) {
+            throw new Error(`Session ${id} is busy — concurrent prompts are not supported`);
+        }
+        entry.lastActivity = Date.now();
+        entry.inFlight = true;
+        let responseText = "";
+        const usage = { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0, cost_usd: null, duration_ms: 0 };
+        const startTime = Date.now();
+        const unsubscribe = entry.session.subscribe((event) => {
+            if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+                responseText += event.assistantMessageEvent.delta;
+            }
+            if (event.type === "agent_end" && event.messages) {
+                for (const msg of event.messages) {
+                    if (msg.role === "assistant" && msg.usage) {
+                        usage.input_tokens += msg.usage.input || 0;
+                        usage.output_tokens += msg.usage.output || 0;
+                        usage.cache_read_tokens += msg.usage.cacheRead || 0;
+                        usage.cache_write_tokens += msg.usage.cacheWrite || 0;
+                        if (msg.usage.cost?.total != null) {
+                            usage.cost_usd = (usage.cost_usd ?? 0) + msg.usage.cost.total;
+                        }
+                    }
+                }
+            }
+        });
+        try {
+            await entry.session.prompt(message);
+        }
+        finally {
+            unsubscribe();
+            entry.inFlight = false;
+            entry.lastActivity = Date.now();
+        }
+        usage.duration_ms = Date.now() - startTime;
+        return { text: responseText, usage };
+    }
+    async abort(id) {
+        const entry = this.sessions.get(id);
+        if (!entry)
+            throw new Error(`Session ${id} not found`);
+        await entry.session.abort();
+    }
+    delete(id) {
+        const entry = this.sessions.get(id);
+        if (entry) {
+            entry.session.dispose();
+            this.sessions.delete(id);
+            console.log(`[sidecar] Session deleted: ${id}`);
+        }
+    }
+    disposeAll() {
+        for (const [id, entry] of this.sessions) {
+            console.log(`[sidecar] Disposing session: ${id}`);
+            entry.session.dispose();
+        }
+        this.sessions.clear();
+    }
+    cleanupStale(maxAge) {
+        const now = Date.now();
+        for (const [id, entry] of this.sessions) {
+            if (entry.inFlight)
+                continue;
+            if (now - entry.lastActivity > maxAge) {
+                console.log(`[sidecar] Cleaning up stale session: ${id}`);
+                entry.session.dispose();
+                this.sessions.delete(id);
+            }
+        }
+    }
+}
+/**
+ * Discover models from an acpx agent by spawning `acpx --model __list__ <agent> exec x`.
+ * Blocks until the subprocess completes or times out (30s).
+ */
+function discoverAcpxModels(agent) {
+    return new Promise((resolve, reject) => {
+        const models = [];
+        let output = "";
+        let resolved = false;
+        const proc = spawn("acpx", ["--model", "__list__", agent, "exec", "x"], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                console.warn(`[sidecar] acpx discovery for ${agent} timed out after 30s`);
+                proc.kill("SIGTERM");
+                resolve(models);
+            }
+        }, 30000);
+        proc.stderr.on("data", (chunk) => { output += chunk.toString(); });
+        proc.stdout.on("data", (chunk) => { output += chunk.toString(); });
+        proc.on("close", () => {
+            if (resolved)
+                return;
+            resolved = true;
+            clearTimeout(timeout);
+            // Parse "Available models: modelId[opts], modelId2[opts], ..."
+            const match = output.match(/Available models:\s*(.+)/);
+            if (match) {
+                const modelList = match[1].trim().replace(/\.$/, "");
+                // Bracket-aware split: commas inside [] are part of the model ID
+                const entries = [];
+                let current = "";
+                let depth = 0;
+                for (const ch of modelList) {
+                    if (ch === "[")
+                        depth++;
+                    else if (ch === "]")
+                        depth = Math.max(0, depth - 1);
+                    if (ch === "," && depth === 0) {
+                        entries.push(current.trim());
+                        current = "";
+                    }
+                    else {
+                        current += ch;
+                    }
+                }
+                if (current.trim())
+                    entries.push(current.trim());
+                for (const entry of entries) {
+                    if (!entry)
+                        continue;
+                    const bracketIdx = entry.indexOf("[");
+                    const baseName = bracketIdx >= 0 ? entry.substring(0, bracketIdx) : entry;
+                    if (baseName) {
+                        const name = baseName
+                            .replace(/-/g, " ")
+                            .replace(/\b\w/g, (c) => c.toUpperCase());
+                        models.push({
+                            id: `${agent}:${entry}`,
+                            name: `${name} (${agent})`,
+                            provider: `acpx-${agent}`,
+                        });
+                    }
+                }
+            }
+            resolve(models);
+        });
+        proc.on("error", (err) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                reject(err);
+            }
+        });
+    });
+}

package/dist/watchdog.d.ts

@@ -0,0 +1 @@
+export declare function startWatchdog(healthUrl: string, onDead: () => void): () => void;

package/dist/watchdog.js

@@ -0,0 +1,52 @@
+const CHECK_INTERVAL = 10_000; // 10 seconds
+const MAX_FAILURES = 3; // 30 seconds of failures before shutdown
+export function startWatchdog(healthUrl, onDead) {
+    let consecutiveFailures = 0;
+    let stopped = false;
+    let dead = false;
+    let currentController;
+    let currentTimeout;
+    const intervalId = setInterval(async () => {
+        if (stopped)
+            return;
+        try {
+            currentController = new AbortController();
+            currentTimeout = setTimeout(() => currentController?.abort(), 5000);
+            const resp = await fetch(healthUrl, { signal: currentController.signal });
+            if (stopped)
+                return;
+            if (resp.ok) {
+                consecutiveFailures = 0;
+            }
+            else {
+                console.debug("[watchdog] Health check returned status:", resp.status);
+                consecutiveFailures++;
+            }
+        }
+        catch (err) {
+            if (stopped)
+                return;
+            console.debug("[watchdog] Health check failed:", err);
+            consecutiveFailures++;
+        }
+        finally {
+            if (currentTimeout)
+                clearTimeout(currentTimeout);
+            currentTimeout = undefined;
+            currentController = undefined;
+        }
+        if (consecutiveFailures >= MAX_FAILURES && !dead) {
+            dead = true;
+            onDead();
+        }
+    }, CHECK_INTERVAL);
+    return () => {
+        stopped = true;
+        clearInterval(intervalId);
+        if (currentTimeout)
+            clearTimeout(currentTimeout);
+        currentController?.abort();
+        currentTimeout = undefined;
+        currentController = undefined;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myk-org/pi-sidecar",
-  "version": "1.0.0-dev.1",
+  "version": "1.0.0-dev.2",
   "description": "Standalone HTTP sidecar wrapping the Pi coding agent SDK",
   "license": "Apache-2.0",
   "repository": {