@glubean/port 0.1.0

package/dist/providers/codex.js

@@ -0,0 +1,300 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import process from "node:process";
+import { AsyncQueue } from "../async-queue.js";
+import { JsonRpcLineConnection } from "../json-rpc.js";
+import { providerRuntimeOptions, resolveRuntimeOptions } from "../options.js";
+import { createPortFromAdapter } from "../port.js";
+import { CodexEventNormalizer } from "./codex-normalizer.js";
+export const codexCapabilities = {
+    provider: "codex",
+    nativeRpc: true,
+    transport: "stdio",
+    sessions: {
+        create: true,
+        resume: true,
+        attach: true,
+        status: true,
+        list: true,
+        close: true,
+    },
+    turns: {
+        start: true,
+        submit: true,
+        status: true,
+        wait: true,
+        cancel: true,
+        steer: false,
+        outputSchema: true,
+    },
+    events: {
+        messageDelta: true,
+        reasoningDelta: true,
+        toolLifecycle: true,
+        tokenUsage: true,
+        planUpdates: true,
+        diffUpdates: true,
+    },
+    structuredOutput: {
+        jsonMode: true,
+        nativeJsonSchema: true,
+        localValidation: true,
+        retry: true,
+    },
+    lifecycle: {
+        localState: true,
+        eventReplay: "memory",
+        status: "local",
+    },
+};
+export async function createCodexPort(options) {
+    return createPortFromAdapter(await createCodexAdapter(options));
+}
+export async function createCodexAdapter(options) {
+    const runtime = new CodexRuntime(options);
+    await runtime.start();
+    return runtime.adapter;
+}
+class CodexRuntime {
+    #options;
+    #process;
+    #rpc;
+    #normalizer = new CodexEventNormalizer();
+    #events = new EventEmitter();
+    #closed = false;
+    constructor(options) {
+        this.#options = options;
+    }
+    get adapter() {
+        return {
+            id: "codex",
+            capabilities: codexCapabilities,
+            createSession: (input = {}) => this.#createOrResumeSession("thread/start", input),
+            resumeSession: (input) => this.#createOrResumeSession("thread/resume", input),
+            startTurn: (input) => this.#startTurn(input),
+            cancelTurn: (input) => this.#cancelTurn(input),
+            events: () => this.#allEvents(),
+            close: () => this.close(),
+        };
+    }
+    async start() {
+        if (this.#rpc)
+            return;
+        const command = this.#options.command ?? "codex";
+        const args = this.#options.args ?? ["app-server", "--listen", "stdio://"];
+        // Top-level codex flags (--disable / -c) must come before the subcommand,
+        // so prepend disableFeatures + webSearchMode as args even when the caller
+        // supplied a custom args array (they apply to whatever subcommand follows).
+        // Source of truth: spawnOptions (codex.ts adapter is per-process; spawn-
+        // only fields cannot be honored per-session or per-turn — see
+        // CodexSpawnOptions docstring in types.ts).
+        const spawnOpts = this.#options.spawnOptions;
+        const featureArgs = [];
+        for (const feature of spawnOpts?.disableFeatures ?? []) {
+            featureArgs.push("--disable", feature);
+        }
+        if (spawnOpts?.webSearchMode) {
+            featureArgs.push("-c", `web_search_mode=${spawnOpts.webSearchMode}`);
+        }
+        const finalArgs = featureArgs.length > 0 ? [...featureArgs, ...args] : args;
+        this.#process = spawn(command, finalArgs, {
+            cwd: this.#options.cwd ?? this.#options.options?.cwd ?? process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...this.#options.env, NO_COLOR: "1" },
+            shell: false,
+        });
+        this.#process.stderr.on("data", (chunk) => {
+            const message = chunk.toString("utf8").trim();
+            if (message)
+                this.#emit({ type: "error", message });
+        });
+        this.#process.on("exit", (code, signal) => {
+            if (!this.#closed) {
+                this.#emit({ type: "error", message: `Codex app-server exited: code=${code ?? "null"} signal=${signal ?? "null"}` });
+            }
+        });
+        this.#rpc = new JsonRpcLineConnection(this.#process.stdout, this.#process.stdin);
+        this.#rpc.onNotification((notification) => {
+            for (const event of this.#normalizer.normalize(notification)) {
+                this.#emit(event);
+            }
+        });
+        await this.#rpc.request("initialize", {
+            clientInfo: { name: "glubean-port", version: "0.0.0" },
+            capabilities: { experimentalApi: true },
+        });
+        this.#rpc.notify("initialized", {});
+    }
+    async close() {
+        this.#closed = true;
+        this.#rpc?.close();
+        this.#process?.kill();
+    }
+    async #createOrResumeSession(method, input) {
+        await this.start();
+        const rpc = this.#requireRpc();
+        const runtimeOptions = resolveRuntimeOptions(input, this.#options.options);
+        const codexOptions = providerRuntimeOptions(runtimeOptions);
+        const config = {
+            ...codexOptions?.config,
+            ...codexReasoningEffortConfig(toCodexReasoningEffort(codexOptions.effort)),
+        };
+        const params = createCodexThreadParams({
+            cwd: runtimeOptions.cwd ?? this.#options.cwd ?? this.#options.options?.cwd ?? process.cwd(),
+            model: runtimeOptions.model,
+            modelProvider: codexOptions?.modelProvider,
+            approvalPolicy: runtimeOptions.approvalPolicy,
+            sandbox: runtimeOptions.sandbox,
+            baseInstructions: codexOptions?.baseInstructions ?? runtimeOptions.instructions?.system,
+            developerInstructions: codexOptions?.developerInstructions ?? runtimeOptions.instructions?.append,
+            serviceTier: codexOptions?.serviceTier,
+            config,
+        });
+        if (method === "thread/resume")
+            params.threadId = input.id ?? "";
+        const result = asRecord(await rpc.request(method, params));
+        const thread = asRecord(result.thread);
+        const id = asString(thread.id) ?? input.id;
+        if (!id)
+            throw new Error(`Codex ${method} response did not include thread.id`);
+        return {
+            id,
+            provider: "codex",
+            native: { threadId: id },
+        };
+    }
+    async *#startTurn(input) {
+        await this.start();
+        const rpc = this.#requireRpc();
+        const queue = new AsyncQueue();
+        let expectedTurnId;
+        const unsubscribe = this.#subscribe((event) => {
+            if (!eventBelongsToSession(event, input.sessionId))
+                return;
+            const eventTurnId = "turnId" in event ? event.turnId : undefined;
+            if (expectedTurnId && eventTurnId && eventTurnId !== expectedTurnId)
+                return;
+            queue.push(event);
+            if (event.type === "turn.completed" && (!expectedTurnId || event.turnId === expectedTurnId)) {
+                queue.close();
+            }
+        });
+        try {
+            const runtimeOptions = resolveRuntimeOptions(input, this.#options.options);
+            const codexOptions = providerRuntimeOptions(runtimeOptions);
+            const effort = toCodexReasoningEffort(codexOptions.effort);
+            const result = asRecord(await rpc.request("turn/start", {
+                threadId: input.sessionId,
+                input: normalizeInput(input.input),
+                ...(runtimeOptions.cwd ? { cwd: runtimeOptions.cwd } : {}),
+                ...(runtimeOptions.model ? { model: runtimeOptions.model } : {}),
+                ...(runtimeOptions.approvalPolicy ? { approvalPolicy: runtimeOptions.approvalPolicy } : {}),
+                ...(runtimeOptions.sandbox ? { sandboxPolicy: toCodexSandboxPolicy(runtimeOptions.sandbox) } : {}),
+                ...(effort ? { effort } : {}),
+                ...(codexOptions?.reasoningSummary ? { summary: codexOptions.reasoningSummary } : {}),
+                ...(codexOptions?.serviceTier ? { serviceTier: codexOptions.serviceTier } : {}),
+                ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
+            }));
+            expectedTurnId = readTurnId(result);
+            for await (const event of queue) {
+                yield event;
+            }
+        }
+        finally {
+            unsubscribe();
+            queue.close();
+        }
+    }
+    async #cancelTurn(input) {
+        await this.start();
+        await this.#requireRpc().request("turn/interrupt", {
+            threadId: input.sessionId,
+            turnId: input.turnId,
+        });
+    }
+    #allEvents() {
+        const queue = new AsyncQueue();
+        const unsubscribe = this.#subscribe((event) => queue.push(event));
+        return {
+            [Symbol.asyncIterator]() {
+                const iterator = queue[Symbol.asyncIterator]();
+                return {
+                    next: () => iterator.next(),
+                    return: async () => {
+                        unsubscribe();
+                        queue.close();
+                        return { value: undefined, done: true };
+                    },
+                };
+            },
+        };
+    }
+    #subscribe(listener) {
+        this.#events.on("event", listener);
+        return () => this.#events.off("event", listener);
+    }
+    #emit(event) {
+        this.#events.emit("event", event);
+    }
+    #requireRpc() {
+        if (!this.#rpc)
+            throw new Error("Codex runtime is not started");
+        return this.#rpc;
+    }
+}
+function normalizeInput(input) {
+    return input.map((item) => {
+        if (item.type === "text")
+            return { type: "text", text: item.text, text_elements: [] };
+        return { type: "localImage", path: item.path };
+    });
+}
+function readTurnId(result) {
+    const turn = asRecord(result.turn);
+    return asString(turn.id) ?? asString(result.turnId);
+}
+function toCodexSandboxPolicy(sandbox) {
+    if (sandbox === "danger-full-access")
+        return { type: "dangerFullAccess" };
+    if (sandbox === "read-only")
+        return { type: "readOnly", networkAccess: false };
+    return {
+        type: "workspaceWrite",
+        writableRoots: [],
+        networkAccess: false,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false,
+    };
+}
+function eventBelongsToSession(event, sessionId) {
+    if ("sessionId" in event && event.sessionId)
+        return event.sessionId === sessionId;
+    return true;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function createCodexThreadParams(input) {
+    return {
+        cwd: input.cwd,
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.modelProvider ? { modelProvider: input.modelProvider } : {}),
+        ...(input.serviceTier ? { serviceTier: input.serviceTier } : {}),
+        ...(input.baseInstructions ? { baseInstructions: input.baseInstructions } : {}),
+        ...(input.developerInstructions ? { developerInstructions: input.developerInstructions } : {}),
+        ...(input.approvalPolicy ? { approvalPolicy: input.approvalPolicy } : {}),
+        ...(input.sandbox ? { sandbox: input.sandbox } : {}),
+        ...(input.config && Object.keys(input.config).length > 0 ? { config: input.config } : {}),
+    };
+}
+function toCodexReasoningEffort(effort) {
+    if (!effort)
+        return undefined;
+    return effort === "max" ? "xhigh" : effort;
+}
+function codexReasoningEffortConfig(effort) {
+    return effort ? { model_reasoning_effort: effort } : {};
+}

package/dist/providers/common.d.ts

@@ -0,0 +1,6 @@
+import type { AgentEvent, AgentInput, CapabilitySet, ProviderId, SessionRef } from "../types.ts";
+export declare function syntheticSession<P extends ProviderId>(provider: P, id?: string): SessionRef<P>;
+export declare function inputToPrompt(input: AgentInput[]): string;
+export declare function baseCapabilities<P extends ProviderId>(provider: P): CapabilitySet<P>;
+export declare function completedTurn(sessionId: string, turnId: string, status: "completed" | "failed" | "cancelled" | "timeout", error?: string): AgentEvent;
+//# sourceMappingURL=common.d.ts.map

package/dist/providers/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/providers/common.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEjG,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,GAAE,MAAqB,GAAG,UAAU,CAAC,CAAC,CAAC,CAM5G;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,CAKzD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,QAAQ,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CA0CpF;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,EACxD,KAAK,CAAC,EAAE,MAAM,GACb,UAAU,CAQZ"}

package/dist/providers/common.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+export function syntheticSession(provider, id = randomUUID()) {
+    return {
+        id,
+        provider,
+        native: { sessionId: id },
+    };
+}
+export function inputToPrompt(input) {
+    return input.map((item) => {
+        if (item.type === "text")
+            return item.text;
+        return `[local image: ${item.path}]`;
+    }).join("\n\n");
+}
+export function baseCapabilities(provider) {
+    return {
+        provider,
+        nativeRpc: false,
+        transport: "stdio",
+        sessions: {
+            create: true,
+            resume: true,
+            attach: true,
+            status: true,
+            list: true,
+            close: true,
+        },
+        turns: {
+            start: true,
+            submit: true,
+            status: true,
+            wait: true,
+            cancel: false,
+            steer: false,
+            outputSchema: false,
+        },
+        events: {
+            messageDelta: true,
+            reasoningDelta: false,
+            toolLifecycle: false,
+            tokenUsage: false,
+            planUpdates: false,
+            diffUpdates: false,
+        },
+        structuredOutput: {
+            jsonMode: true,
+            nativeJsonSchema: false,
+            localValidation: true,
+            retry: true,
+        },
+        lifecycle: {
+            localState: true,
+            eventReplay: "memory",
+            status: "local",
+        },
+    };
+}
+export function completedTurn(sessionId, turnId, status, error) {
+    return {
+        type: "turn.completed",
+        sessionId,
+        turnId,
+        status,
+        ...(error ? { error } : {}),
+    };
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,9 @@
+import type { CapabilitySet, CreatePortInputFor, Port, RuntimeOptions } from "../types.ts";
+import type { ProviderAdapter } from "./adapter.ts";
+type GeminiPortOptions = CreatePortInputFor<"gemini">;
+export declare const geminiCapabilities: CapabilitySet<"gemini">;
+export declare function createGeminiPort(options: GeminiPortOptions): Promise<Port<"gemini">>;
+export declare function createGeminiAdapter(options: GeminiPortOptions): Promise<ProviderAdapter<"gemini">>;
+export declare function buildGeminiArgs(options?: RuntimeOptions<"gemini">): string[];
+export {};
+//# sourceMappingURL=gemini.d.ts.map

package/dist/providers/gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../src/providers/gemini.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAIV,aAAa,EACb,kBAAkB,EAIlB,IAAI,EACJ,cAAc,EAGf,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,KAAK,iBAAiB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AAEtD,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,QAAQ,CAwCtD,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAE1F;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAIxG;AAwRD,wBAAgB,eAAe,CAAC,OAAO,GAAE,cAAc,CAAC,QAAQ,CAAkC,GAAG,MAAM,EAAE,CAQ5G"}