@pasko70/pibo 2.0.0 → 2.2.0

package/dist/agent-runtimes/omp/auth.js

@@ -0,0 +1,109 @@
+import { AgentRuntimeAuthError } from "../../agent-runtime/errors.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export const OMP_AUTH_METHODS = [
+    { id: "api_key", completion: "immediate" },
+];
+/**
+ * OMP auth status/surface.
+ *
+ * V1 truthfulness: OMP's RPC exposes `get_login_providers`/`login`. We declare
+ * `api_key` (immediate, env / models.yml configured keys) as the supported
+ * method. OAuth / device-code browser-step methods are surfaced only when the
+ * `open_url` extension_ui_request bridge is wired; until then they are not
+ * advertised.
+ */
+export class OmpAuthController {
+    client;
+    flowCounter = 0;
+    constructor(client) {
+        this.client = client;
+    }
+    async getStatus() {
+        try {
+            const result = await this.client.request({ type: "get_login_providers" }, "get_login_providers");
+            const data = result["data"];
+            if (!isRecord(data) || !Array.isArray(data.providers)) {
+                return [unknownOmpStatus()];
+            }
+            const statuses = [];
+            for (const provider of data.providers) {
+                if (!isRecord(provider) || typeof provider.id !== "string")
+                    continue;
+                const authenticated = provider.authenticated === true;
+                const available = provider.available === true;
+                statuses.push({
+                    id: provider.id,
+                    displayName: typeof provider.name === "string" ? provider.name : provider.id,
+                    state: ompAuthState(authenticated, available),
+                    configured: authenticated,
+                    methods: OMP_AUTH_METHODS,
+                    details: { accountType: authenticated ? "unknown" : "api_key" },
+                });
+            }
+            return statuses.length > 0 ? statuses : [unknownOmpStatus()];
+        }
+        catch {
+            return [unknownOmpStatus()];
+        }
+    }
+    async start(input) {
+        if (input.method === "api_key") {
+            // API-key auth is configured via provider config (env / models.yml);
+            // report as connected when a provider is selected.
+            return {
+                providerId: input.providerId,
+                state: "connected",
+                configured: true,
+                details: { accountType: "api_key" },
+            };
+        }
+        // OAuth/device-code: the browser step is surfaced via an open_url
+        // extension_ui_request only when the bridge is wired. Until then, report
+        // as unsupported rather than inventing support (truthful capability).
+        throw new AgentRuntimeAuthError("orp_auth_unsupported", `OMP OAuth/device-code authentication (${input.method}) is not wired in the OMP adapter; use an API key.`);
+    }
+    async complete(input) {
+        throw new AgentRuntimeAuthError("orp_auth_unsupported", "OMP API-key auth completes via provider configuration, not an RPC completion step.");
+    }
+    async cancel(input) {
+        return { providerId: input.providerId, state: "disconnected", configured: false, message: "Login canceled." };
+    }
+    async logout(input) {
+        // OMP persists credentials in its own store; Pibo reports the action
+        // without deleting user-global OMP state.
+        return { providerId: input.providerId, state: "disconnected", configured: false };
+    }
+    async dispose() {
+        // no owned resources
+    }
+}
+function ompAuthState(authenticated, available) {
+    if (authenticated)
+        return "connected";
+    if (!available)
+        return "unsupported";
+    return "disconnected";
+}
+function unknownOmpStatus() {
+    return {
+        id: "orp",
+        displayName: "OMP providers",
+        state: "unsupported",
+        configured: false,
+        methods: OMP_AUTH_METHODS,
+        details: { accountType: "api_key" },
+    };
+}
+/** Product-safe fallback status when the engine is unavailable. */
+export function unknownOmpStatusForAdapter() {
+    return {
+        id: "orp",
+        displayName: "OMP providers",
+        state: "unsupported",
+        configured: false,
+        methods: OMP_AUTH_METHODS,
+        details: { accountType: "api_key" },
+    };
+}

package/dist/agent-runtimes/omp/client.js

@@ -0,0 +1,460 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { OMP_RPC_CHUNK_PAYLOAD_BYTES, OMP_RPC_MAX_FRAME_BYTES, OMP_RPC_PROTOCOL_VERSION, } from "./protocol-types.js";
+const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 180_000;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 2_000;
+const DEFAULT_MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_PENDING_REQUESTS = 128;
+const DEFAULT_MAX_STDERR_BYTES = 256 * 1024;
+export class OmpRpcClientError extends Error {
+    code;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.code = code;
+        this.name = "OmpRpcClientError";
+    }
+}
+export class OmpRpcResponseError extends Error {
+    command;
+    error;
+    errorCode;
+    constructor(command, error, errorCode, options = {}) {
+        super(`OMP RPC command "${command}" failed: ${error}`, options);
+        this.command = command;
+        this.error = error;
+        this.errorCode = errorCode;
+        this.name = "OmpRpcResponseError";
+    }
+}
+function deferred() {
+    const d = {};
+    d.promise = new Promise((resolve, reject) => {
+        d.resolve = resolve;
+        d.reject = reject;
+    });
+    return d;
+}
+function isOmpRpcSideChannel(frame) {
+    const type = frame.type;
+    return type === "host_tool_result"
+        || type === "host_tool_update"
+        || type === "host_uri_result"
+        || type === "extension_ui_response";
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseReadyFrame(value) {
+    if (!isRecord(value) || value.type !== "ready") {
+        throw new OmpRpcClientError("protocol_error", "OMP child did not emit a ready frame on startup.");
+    }
+    return value;
+}
+export class OmpRpcClient {
+    options;
+    child;
+    stdoutBuffer = Buffer.alloc(0);
+    state = "starting";
+    protocolVersion = 1;
+    pending = new Map();
+    chunks = new Map();
+    frameListeners = new Set();
+    sideChannelListeners = new Set();
+    diagnosticListeners = new Set();
+    stderrBytes = 0;
+    startupTimeoutMs;
+    requestTimeoutMs;
+    shutdownTimeoutMs;
+    maxMessageBytes;
+    maxPendingRequests;
+    maxStderrBytes;
+    constructor(options = {}) {
+        this.options = options;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+        this.maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+        this.maxPendingRequests = options.maxPendingRequests ?? DEFAULT_MAX_PENDING_REQUESTS;
+        this.maxStderrBytes = options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES;
+    }
+    get snapshot() {
+        return {
+            state: this.state,
+            ready: this.state === "ready",
+            pendingRequests: this.pending.size,
+            protocolVersion: this.protocolVersion,
+        };
+    }
+    get process() {
+        return this.child;
+    }
+    get connected() {
+        return this.state === "ready";
+    }
+    subscribeFrames(listener) {
+        this.frameListeners.add(listener);
+        return () => this.frameListeners.delete(listener);
+    }
+    subscribeSideChannels(listener) {
+        this.sideChannelListeners.add(listener);
+        return () => this.sideChannelListeners.delete(listener);
+    }
+    subscribeDiagnostics(listener) {
+        this.diagnosticListeners.add(listener);
+        return () => this.diagnosticListeners.delete(listener);
+    }
+    /**
+     * Redact likely credential material before surfacing a diagnostic, so OMP
+     * stderr (which may echo prompts or provider keys) cannot leak secrets.
+     */
+    static redactDiagnostic(message) {
+        return message
+            .replace(/\b(?:sk|rk|pk|ghp|github_pat)[-_][A-Za-z0-9._~+/-]{8,}\b/g, "[redacted]")
+            .replace(/\bBearer\s+\S+/gi, "Bearer [redacted]")
+            .replace(/\b(?:api[_-]?key|secret|token|password)\b(?=[:=]\s*)\s*[^\s,;]+/gi, "$1 [redacted]");
+    }
+    emitDiagnostic(message) {
+        for (const listener of this.diagnosticListeners)
+            listener(OmpRpcClient.redactDiagnostic(message));
+    }
+    /**
+     * Spawn the OMP child in `--mode rpc` and wait for the `ready` frame, then
+     * negotiate protocol v2 (confirms frame encoder upgrade for large frames).
+     */
+    async connect(command, options) {
+        if (this.state === "ready")
+            return;
+        const ready = deferred();
+        let child;
+        try {
+            child = spawn(command[0], command.slice(1), {
+                cwd: options.cwd,
+                env: options.env,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            this.state = "failed";
+            throw new OmpRpcClientError("spawn_failed", `Failed to spawn OMP child: ${String(error)}`, { cause: error });
+        }
+        this.child = child;
+        let startupTimer;
+        child.stderr.on("data", (chunk) => {
+            this.stderrBytes += chunk.length;
+            if (this.stderrBytes <= this.maxStderrBytes) {
+                this.emitDiagnostic(chunk.toString("utf8"));
+            }
+        });
+        child.once("error", (error) => {
+            const code = error.code === "ENOENT" ? "spawn_failed" : "process_exited";
+            this.state = "failed";
+            ready.reject(new OmpRpcClientError(code, `OMP child process error: ${error.message}`, { cause: error }));
+        });
+        child.once("close", (code, signal) => {
+            this.state = "closed";
+            this.rejectAll(new OmpRpcClientError("process_exited", `OMP child process exited (code=${String(code)}, signal=${String(signal)})`));
+            ready.reject(new OmpRpcClientError("process_exited", "OMP child process exited before becoming ready."));
+        });
+        child.stdout.on("data", (chunk) => this.onStdoutData(Buffer.from(chunk)));
+        // Wait for ready frame.
+        const unsubscribe = this.subscribeFrames((frame) => {
+            if (frame.type === "ready") {
+                unsubscribe();
+                ready.resolve(frame);
+            }
+        });
+        startupTimer = setTimeout(() => {
+            ready.reject(new OmpRpcClientError("timeout", "Timed out waiting for the OMP ready frame."));
+        }, this.startupTimeoutMs);
+        this.state = "initializing";
+        let startup;
+        try {
+            startup = await ready.promise;
+        }
+        catch (error) {
+            this.state = "failed";
+            this.closeProcess();
+            throw error;
+        }
+        finally {
+            if (startupTimer)
+                clearTimeout(startupTimer);
+        }
+        // Mark ready before negotiation so the client can send the handshake.
+        this.state = "ready";
+        this.protocolVersion = startup.protocolVersion;
+        try {
+            await this.request({ type: "negotiate_protocol", protocolVersion: OMP_RPC_PROTOCOL_VERSION }, "negotiate_protocol");
+            this.protocolVersion = OMP_RPC_PROTOCOL_VERSION;
+        }
+        catch (error) {
+            this.state = "failed";
+            this.closeProcess();
+            throw new OmpRpcClientError("protocol_error", `OMP protocol negotiation failed: ${String(error)}`, { cause: error });
+        }
+    }
+    onStdoutData(chunk) {
+        this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+        let newlineIndex;
+        while ((newlineIndex = this.stdoutBuffer.indexOf(0x0a)) !== -1) {
+            const line = this.stdoutBuffer.subarray(0, newlineIndex).toString("utf8").trim();
+            this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
+            if (line.length === 0)
+                continue;
+            this.handleLine(line);
+        }
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.emitDiagnostic(`OMP emitted a malformed JSON line on stdout (ignored).`);
+            return;
+        }
+        if (!isRecord(parsed)) {
+            this.emitDiagnostic(`OMP emitted a non-object JSON line on stdout (ignored).`);
+            return;
+        }
+        // Reassemble oversized chunked frames first.
+        if (parsed.type === "rpc_chunk") {
+            const reassembled = this.consumeChunk(parsed);
+            if (reassembled === undefined)
+                return; // waiting for more chunks
+            try {
+                parsed = JSON.parse(reassembled);
+            }
+            catch {
+                this.emitDiagnostic(`OMP chunk reassembly produced invalid JSON (ignored).`);
+                return;
+            }
+        }
+        const frame = parsed;
+        for (const listener of this.frameListeners)
+            listener(frame);
+        if (isOmpRpcSideChannel(frame)) {
+            const sideChannel = frame;
+            for (const listener of this.sideChannelListeners)
+                listener(sideChannel);
+        }
+        if (this.isResponse(frame)) {
+            this.resolveResponse(frame);
+        }
+    }
+    isSideChannel(frame) {
+        const type = frame.type;
+        return (type === "host_tool_result" ||
+            type === "host_tool_update" ||
+            type === "host_uri_result" ||
+            type === "extension_ui_response");
+    }
+    isResponse(frame) {
+        return frame.type === "response";
+    }
+    consumeChunk(frame) {
+        // Validate frame bounds first so an out-of-range index can never create a
+        // sparse array that Buffer.concat later turns into an uncaught TypeError.
+        if (!Number.isSafeInteger(frame.index) || frame.index < 0 || frame.index >= frame.count) {
+            this.chunks.delete(frame.chunkId);
+            this.emitDiagnostic(`OMP chunk frame has an invalid index ${frame.index} (dropped).`);
+            return undefined;
+        }
+        let decoded;
+        try {
+            decoded = Buffer.from(frame.data, "base64");
+            // Reject invalid base64 (empty/garbage) before it becomes a hole.
+            if (frame.data.length === 0 && frame.byteLength > 0) {
+                this.chunks.delete(frame.chunkId);
+                this.emitDiagnostic(`OMP chunk frame carries empty base64 payload (dropped).`);
+                return undefined;
+            }
+        }
+        catch {
+            this.chunks.delete(frame.chunkId);
+            this.emitDiagnostic(`OMP chunk frame base64 decode failed (dropped).`);
+            return undefined;
+        }
+        const existing = this.chunks.get(frame.chunkId);
+        if (existing) {
+            if (existing.count !== frame.count || existing.byteLength !== frame.byteLength) {
+                this.chunks.delete(frame.chunkId);
+                this.emitDiagnostic(`OMP chunk frame metadata mismatch (dropped).`);
+                return undefined;
+            }
+            // Must be the next in-order chunk; reject duplicates/holes/out-of-order.
+            if (frame.index !== existing.parts.length) {
+                this.chunks.delete(frame.chunkId);
+                this.emitDiagnostic(`OMP chunk frame arrived out of order (expected index ${existing.parts.length}, got ${frame.index}); dropped.`);
+                return undefined;
+            }
+            existing.parts.push(decoded);
+        }
+        else {
+            if (frame.index !== 0) {
+                this.emitDiagnostic(`OMP chunk frame sequence did not start at index 0 (dropped).`);
+                return undefined;
+            }
+            this.chunks.set(frame.chunkId, { count: frame.count, byteLength: frame.byteLength, parts: [decoded] });
+        }
+        const acc = this.chunks.get(frame.chunkId);
+        if (acc.parts.length < acc.count)
+            return undefined;
+        this.chunks.delete(frame.chunkId);
+        const full = Buffer.concat(acc.parts);
+        if (full.length !== acc.byteLength) {
+            this.emitDiagnostic(`OMP chunk reassembly length mismatch (dropped).`);
+            return undefined;
+        }
+        return full.toString("utf8");
+    }
+    resolveResponse(response) {
+        const id = response.id;
+        if (id === undefined) {
+            // Responses without an id that still carry command info are protocol
+            // telemetry; emit as diagnostic rather than dropping silently.
+            this.emitDiagnostic(`OMP response without an id (command=${response.command}).`);
+            return;
+        }
+        const entry = this.pending.get(id);
+        if (!entry)
+            return; // late/superseded response
+        this.pending.delete(id);
+        clearTimeout(entry.timer);
+        entry.resolve(response);
+    }
+    rejectAll(error) {
+        for (const [id, entry] of Array.from(this.pending.entries())) {
+            this.pending.delete(id);
+            clearTimeout(entry.timer);
+            entry.reject(error);
+        }
+    }
+    /**
+     * Send a command and await its correlated response. Always matches on `id`
+     * (never queue order) — OMP dispatches `bash` concurrently and side-channel
+     * frames overtake the serial queue.
+     */
+    async request(command, label) {
+        if (this.state !== "ready") {
+            throw new OmpRpcClientError("closed", `Cannot send OMP command "${label}": client is not ready.`);
+        }
+        if (this.pending.size >= this.maxPendingRequests) {
+            throw new OmpRpcClientError("pending_limit", "Too many pending OMP RPC requests.");
+        }
+        const id = (command.id ?? randomUUID());
+        const withId = { ...command, id };
+        let serialized;
+        try {
+            serialized = JSON.stringify(withId);
+        }
+        catch (error) {
+            throw new OmpRpcClientError("serialization_error", `Failed to serialize OMP command "${label}": ${String(error)}`);
+        }
+        if (Buffer.byteLength(serialized, "utf8") > this.maxMessageBytes) {
+            throw new OmpRpcClientError("message_too_large", `OMP command "${label}" exceeds the message size limit.`);
+        }
+        const response = deferred();
+        const timer = setTimeout(() => {
+            this.pending.delete(id);
+            response.reject(new OmpRpcClientError("timeout", `OMP command "${label}" timed out.`));
+        }, this.requestTimeoutMs);
+        this.pending.set(id, {
+            command: command.type,
+            resolve: response.resolve,
+            reject: response.reject,
+            timer,
+        });
+        try {
+            await this.writeLine(serialized);
+        }
+        catch (error) {
+            this.pending.delete(id);
+            clearTimeout(timer);
+            response.reject(error);
+        }
+        const result = await response.promise;
+        if (result["success"] === false) {
+            const err = result;
+            throw new OmpRpcResponseError(label, err.error ?? "unknown error", err.code);
+        }
+        return result;
+    }
+    async writeLine(line) {
+        return await new Promise((resolveWrite, rejectWrite) => {
+            if (!this.child || this.child.stdin.destroyed) {
+                rejectWrite(new OmpRpcClientError("write_failed", "OMP child stdin is closed."));
+                return;
+            }
+            this.child.stdin.write(`${line}\n`, (error) => {
+                if (error)
+                    rejectWrite(new OmpRpcClientError("write_failed", `Failed to write to OMP child: ${error.message}`, { cause: error }));
+                else
+                    resolveWrite();
+            });
+        });
+    }
+    get stderr() {
+        return []; // diagnostics already streamed via listeners; retained for symmetry
+    }
+    /**
+         * Send a fire-and-forget side-channel frame to OMP (host_tool_result,
+         * host_tool_update, host_uri_result, extension_ui_response). These overtake
+         * the serial command queue and do not receive a correlated `response`.
+         */
+    async sendSideChannel(frame, label) {
+        if (this.state !== "ready") {
+            throw new OmpRpcClientError("closed", `Cannot send OMP side-channel frame "${label}": client is not ready.`);
+        }
+        let serialized;
+        try {
+            serialized = JSON.stringify(frame);
+        }
+        catch (error) {
+            throw new OmpRpcClientError("serialization_error", `Failed to serialize OMP frame "${label}": ${String(error)}`);
+        }
+        if (Buffer.byteLength(serialized, "utf8") > this.maxMessageBytes) {
+            throw new OmpRpcClientError("message_too_large", `OMP frame "${label}" exceeds the message size limit.`);
+        }
+        await this.writeLine(serialized);
+    }
+    async close() {
+        if (this.state === "ready") {
+            this.state = "closing";
+        }
+        this.closeProcess();
+    }
+    closeProcess() {
+        if (this.child && !this.child.killed) {
+            try {
+                this.child.kill("SIGTERM");
+            }
+            catch {
+                // ignore
+            }
+            const child = this.child;
+            // Ensure the child is reaped even on platforms where SIGTERM is
+            // ignored (freeing any cwd lock for temp cleanup).
+            const timer = setTimeout(() => {
+                if (child && !child.killed) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }, this.shutdownTimeoutMs);
+            timer.unref();
+        }
+        this.state = "closed";
+        this.rejectAll(new OmpRpcClientError("aborted", "OMP client closed."));
+    }
+    dispose() {
+        this.closeProcess();
+    }
+}
+/** Convenience for oversized-frames logic parity; retained as a documented limit. */
+export const OMP_MAX_CHUNK_PAYLOAD_BYTES = OMP_RPC_CHUNK_PAYLOAD_BYTES;
+export const OMP_DEFAULT_MAX_FRAME_BYTES = OMP_RPC_MAX_FRAME_BYTES;