@glubean/port 0.1.0

package/dist/providers/claude.js

@@ -0,0 +1,300 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import process from "node:process";
+import { createPortFromAdapter } from "../port.js";
+import { providerRuntimeOptions, resolveRuntimeOptions } from "../options.js";
+import { normalizeTokenUsage } from "../token-usage.js";
+import { completedTurn, inputToPrompt, syntheticSession } from "./common.js";
+export const claudeCapabilities = {
+    provider: "claude",
+    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: true,
+        steer: false,
+        outputSchema: true,
+    },
+    events: {
+        messageDelta: true,
+        reasoningDelta: true,
+        toolLifecycle: true,
+        tokenUsage: true,
+        planUpdates: false,
+        diffUpdates: false,
+    },
+    structuredOutput: {
+        jsonMode: true,
+        nativeJsonSchema: true,
+        localValidation: true,
+        retry: true,
+    },
+    lifecycle: {
+        localState: true,
+        eventReplay: "memory",
+        status: "local",
+    },
+};
+export async function createClaudePort(options) {
+    return createPortFromAdapter(await createClaudeAdapter(options));
+}
+export async function createClaudeAdapter(options) {
+    const runtime = new ClaudeRuntime(options);
+    return runtime.adapter;
+}
+class ClaudeRuntime {
+    #options;
+    #events = new EventEmitter();
+    #processes = new Map();
+    constructor(options) {
+        this.#options = options;
+    }
+    get adapter() {
+        return {
+            id: "claude",
+            capabilities: claudeCapabilities,
+            createSession: (input = {}) => this.#createSession(input),
+            resumeSession: (input) => this.#resumeSession(input),
+            startTurn: (input) => this.#startTurn(input),
+            cancelTurn: (input) => this.#cancelTurn(input),
+            events: () => this.#allEvents(),
+            close: () => this.close(),
+        };
+    }
+    async #createSession(input) {
+        return syntheticSession("claude", input.id ?? randomUUID());
+    }
+    async #resumeSession(input) {
+        return syntheticSession("claude", input.id);
+    }
+    async *#startTurn(input) {
+        const turnId = randomUUID();
+        yield { type: "turn.started", sessionId: input.sessionId, turnId };
+        const command = this.#options.command ?? "claude";
+        const runtimeOptions = resolveRuntimeOptions(input, this.#options.options);
+        const args = buildClaudeArgs(input, this.#options.options);
+        const child = spawn(command, args, {
+            cwd: runtimeOptions.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.#processes.set(turnId, child);
+        child.stdin.end(inputToPrompt(input.input));
+        let buffered = "";
+        let sawMessage = false;
+        const stderr = [];
+        const events = [];
+        const push = (event) => {
+            events.push(event);
+            this.#events.emit("event", event);
+        };
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            buffered += chunk;
+            while (true) {
+                const newlineIndex = buffered.indexOf("\n");
+                if (newlineIndex === -1)
+                    break;
+                const line = buffered.slice(0, newlineIndex).trim();
+                buffered = buffered.slice(newlineIndex + 1);
+                if (!line)
+                    continue;
+                for (const event of normalizeClaudeLine(line, input.sessionId, turnId, sawMessage)) {
+                    if (event.type === "message.delta")
+                        sawMessage = true;
+                    push(event);
+                }
+            }
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        const exit = await waitForExit(child);
+        this.#processes.delete(turnId);
+        const trailing = buffered.trim();
+        if (trailing) {
+            for (const event of normalizeClaudeLine(trailing, input.sessionId, turnId, sawMessage)) {
+                if (event.type === "message.delta")
+                    sawMessage = true;
+                push(event);
+            }
+        }
+        for (const event of events)
+            yield event;
+        if (exit.code === 0) {
+            yield completedTurn(input.sessionId, turnId, "completed");
+            return;
+        }
+        const message = stderr.join("").trim() || `Claude Code exited with code ${exit.code ?? "null"} signal=${exit.signal ?? "null"}`;
+        yield { type: "error", sessionId: input.sessionId, turnId, message };
+        yield completedTurn(input.sessionId, turnId, "failed", message);
+    }
+    async #cancelTurn(input) {
+        this.#processes.get(input.turnId)?.kill();
+    }
+    async close() {
+        for (const child of this.#processes.values())
+            child.kill();
+        this.#processes.clear();
+    }
+    #allEvents() {
+        const events = this.#events;
+        return {
+            [Symbol.asyncIterator]() {
+                const queue = [];
+                let waiter;
+                const listener = (event) => {
+                    if (waiter) {
+                        waiter({ value: event, done: false });
+                        waiter = undefined;
+                        return;
+                    }
+                    queue.push(event);
+                };
+                events.on("event", listener);
+                return {
+                    next: () => {
+                        const event = queue.shift();
+                        if (event)
+                            return Promise.resolve({ value: event, done: false });
+                        return new Promise((resolve) => {
+                            waiter = resolve;
+                        });
+                    },
+                    return: async () => {
+                        events.off("event", listener);
+                        return { value: undefined, done: true };
+                    },
+                };
+            },
+        };
+    }
+}
+export function buildClaudeArgs(input, defaults) {
+    const runtimeOptions = resolveRuntimeOptions(input, defaults);
+    const claudeOptions = providerRuntimeOptions(runtimeOptions);
+    const args = ["-p", "--verbose", "--output-format", "stream-json", "--include-partial-messages", "--session-id", input.sessionId];
+    if (runtimeOptions.model)
+        args.push("--model", runtimeOptions.model);
+    if (input.outputSchema)
+        args.push("--json-schema", JSON.stringify(input.outputSchema));
+    const systemPrompt = claudeOptions.systemPrompt ?? runtimeOptions.instructions?.system;
+    const appendSystemPrompt = claudeOptions.appendSystemPrompt ?? runtimeOptions.instructions?.append;
+    if (systemPrompt)
+        args.push("--system-prompt", systemPrompt);
+    if (appendSystemPrompt)
+        args.push("--append-system-prompt", appendSystemPrompt);
+    if (claudeOptions.effort)
+        args.push("--effort", claudeOptions.effort);
+    appendClaudeThinkingArgs(args, claudeOptions.thinking);
+    const permissionMode = claudeOptions.permissionMode ?? toClaudePermissionMode(runtimeOptions);
+    if (permissionMode)
+        args.push("--permission-mode", permissionMode);
+    return args;
+}
+function appendClaudeThinkingArgs(args, thinking) {
+    if (!thinking)
+        return;
+    if (thinking.type === "disabled") {
+        args.push("--thinking", "disabled");
+        return;
+    }
+    args.push("--thinking", thinking.type);
+    if (thinking.type === "enabled" && typeof thinking.budgetTokens === "number") {
+        args.push("--max-thinking-tokens", String(thinking.budgetTokens));
+    }
+    if (thinking.display)
+        args.push("--thinking-display", thinking.display);
+}
+function toClaudePermissionMode(options) {
+    if (options.sandbox === "read-only")
+        return "plan";
+    if (options.approvalPolicy === "never")
+        return "dontAsk";
+    return undefined;
+}
+function normalizeClaudeLine(line, sessionId, turnId, sawMessage) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return [{ type: "message.delta", sessionId, turnId, role: "assistant", text: line }];
+    }
+    const record = asRecord(value);
+    const type = asString(record.type);
+    if (type === "assistant") {
+        const message = asRecord(record.message);
+        return [
+            ...textFromClaudeMessage(message).map((text) => ({ type: "message.delta", sessionId, turnId, role: "assistant", text })),
+            ...tokenUsageEvents(message.usage, sessionId, turnId),
+        ];
+    }
+    if (type === "result") {
+        const usageEvents = tokenUsageEvents(record.usage ?? record.usageMetadata, sessionId, turnId);
+        if (record.is_error === true) {
+            return [
+                ...usageEvents,
+                { type: "error", sessionId, turnId, message: asString(record.result) ?? "Claude Code result error", native: toJsonValue(record) },
+            ];
+        }
+        const structured = record.structured_output ?? record.structuredOutput;
+        if (structured !== undefined && !sawMessage) {
+            return [
+                { type: "message.delta", sessionId, turnId, role: "assistant", text: JSON.stringify(structured) },
+                ...usageEvents,
+            ];
+        }
+        const result = asString(record.result);
+        return [
+            ...(result && !sawMessage ? [{ type: "message.delta", sessionId, turnId, role: "assistant", text: result }] : []),
+            ...usageEvents,
+        ];
+    }
+    if (type === "system" || type === "user")
+        return [];
+    return [];
+}
+function tokenUsageEvents(value, sessionId, turnId) {
+    const usage = normalizeTokenUsage(value);
+    return usage ? [{ type: "token.usage", sessionId, turnId, usage, native: toJsonValue(value) }] : [];
+}
+function textFromClaudeMessage(value) {
+    const message = asRecord(value);
+    const content = message.content;
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((item) => {
+        const record = asRecord(item);
+        if (asString(record.type) !== "text")
+            return [];
+        const text = asString(record.text);
+        return text ? [text] : [];
+    });
+}
+function waitForExit(child) {
+    return new Promise((resolve) => child.on("exit", (code, signal) => resolve({ code, signal })));
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function toJsonValue(value) {
+    if (value === undefined)
+        return undefined;
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/providers/codex-normalizer.d.ts

@@ -0,0 +1,7 @@
+import type { AgentEvent } from "../types.ts";
+import type { JsonRpcNotification } from "../json-rpc.ts";
+export declare class CodexEventNormalizer {
+    #private;
+    normalize(notification: JsonRpcNotification): AgentEvent[];
+}
+//# sourceMappingURL=codex-normalizer.d.ts.map

package/dist/providers/codex-normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-normalizer.d.ts","sourceRoot":"","sources":["../../src/providers/codex-normalizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAuB1D,qBAAa,oBAAoB;;IAK/B,SAAS,CAAC,YAAY,EAAE,mBAAmB,GAAG,UAAU,EAAE;CAyO3D"}

package/dist/providers/codex-normalizer.js

@@ -0,0 +1,287 @@
+import { normalizeTokenUsage } from "../token-usage.js";
+export class CodexEventNormalizer {
+    #provider = "codex";
+    #streamedMessageIds = new Set();
+    #streamedReasoningIds = new Set();
+    normalize(notification) {
+        const params = asRecord(notification.params);
+        switch (notification.method) {
+            case "thread/started": {
+                const thread = asRecord(params.thread);
+                const sessionId = asString(thread.id);
+                if (!sessionId)
+                    return [];
+                return [
+                    {
+                        type: "session.started",
+                        provider: this.#provider,
+                        sessionId,
+                        native: { threadId: sessionId },
+                    },
+                ];
+            }
+            case "turn/started": {
+                const turn = asRecord(params.turn);
+                const turnId = asString(turn.id);
+                const sessionId = asString(params.threadId);
+                if (!sessionId || !turnId)
+                    return [];
+                return [{ type: "turn.started", sessionId, turnId }];
+            }
+            case "item/agentMessage/delta": {
+                const itemId = asString(params.itemId);
+                const delta = asString(params.delta);
+                if (itemId)
+                    this.#streamedMessageIds.add(itemId);
+                if (!delta)
+                    return [];
+                return [
+                    {
+                        type: "message.delta",
+                        role: "assistant",
+                        sessionId: asString(params.threadId),
+                        turnId: asString(params.turnId),
+                        text: delta,
+                    },
+                ];
+            }
+            case "item/reasoning/summaryTextDelta":
+            case "item/reasoning/textDelta": {
+                const itemId = asString(params.itemId);
+                const delta = asString(params.delta);
+                if (itemId)
+                    this.#streamedReasoningIds.add(itemId);
+                if (!delta)
+                    return [];
+                return [
+                    {
+                        type: "reasoning.delta",
+                        sessionId: asString(params.threadId),
+                        turnId: asString(params.turnId),
+                        text: delta,
+                    },
+                ];
+            }
+            case "turn/plan/updated": {
+                const sessionId = asString(params.threadId);
+                const turnId = asString(params.turnId);
+                if (!sessionId || !turnId)
+                    return [];
+                return [
+                    {
+                        type: "plan.updated",
+                        sessionId,
+                        turnId,
+                        explanation: asString(params.explanation),
+                        steps: normalizePlan(params.plan),
+                    },
+                ];
+            }
+            case "turn/diff/updated": {
+                const sessionId = asString(params.threadId);
+                const turnId = asString(params.turnId);
+                const diff = asString(params.diff);
+                if (!sessionId || !turnId || diff === undefined)
+                    return [];
+                return [{ type: "diff.updated", sessionId, turnId, diff }];
+            }
+            case "thread/tokenUsage/updated": {
+                const sessionId = asString(params.threadId);
+                const turnId = asString(params.turnId);
+                const tokenUsage = asRecord(params.tokenUsage);
+                const usage = normalizeTokenUsage(tokenUsage.last);
+                const totalUsage = normalizeTokenUsage(tokenUsage.total);
+                if (!sessionId || !turnId || (!usage && !totalUsage))
+                    return [];
+                const contextWindow = asNullableNumber(tokenUsage.modelContextWindow);
+                return [
+                    {
+                        type: "token.usage",
+                        sessionId,
+                        turnId,
+                        usage: usage ?? totalUsage ?? {},
+                        ...(totalUsage ? { totalUsage } : {}),
+                        ...(contextWindow !== undefined ? { contextWindow } : {}),
+                        native: toJsonValue(params),
+                    },
+                ];
+            }
+            case "item/started":
+            case "item/completed": {
+                const item = asRecord(params.item);
+                return this.#normalizeItem(notification.method, params, item);
+            }
+            case "turn/completed": {
+                const sessionId = asString(params.threadId);
+                const turn = asRecord(params.turn);
+                const turnId = asString(turn.id);
+                if (!sessionId || !turnId)
+                    return [];
+                this.#streamedMessageIds.clear();
+                this.#streamedReasoningIds.clear();
+                const status = normalizeTurnStatus(asString(turn.status));
+                const error = asString(asRecord(turn.error).message);
+                return [
+                    {
+                        type: "turn.completed",
+                        sessionId,
+                        turnId,
+                        status,
+                        ...(error ? { error } : {}),
+                    },
+                ];
+            }
+            case "error":
+                return [
+                    {
+                        type: "error",
+                        message: readErrorMessage(params),
+                        native: toJsonValue(params),
+                    },
+                ];
+            default:
+                return [];
+        }
+    }
+    #normalizeItem(method, params, item) {
+        const isStarted = method === "item/started";
+        const isCompleted = method === "item/completed";
+        const itemType = asString(item.type);
+        const itemId = asString(item.id);
+        const sessionId = asString(params.threadId);
+        const turnId = asString(params.turnId);
+        if (!itemType || !itemId)
+            return [];
+        if (itemType === "agentMessage" && isCompleted) {
+            if (this.#streamedMessageIds.has(itemId)) {
+                this.#streamedMessageIds.delete(itemId);
+                return [];
+            }
+            const text = asString(item.text);
+            return text ? [{ type: "message.delta", role: "assistant", sessionId, turnId, text }] : [];
+        }
+        if (itemType === "reasoning" && isCompleted) {
+            if (this.#streamedReasoningIds.has(itemId)) {
+                this.#streamedReasoningIds.delete(itemId);
+                return [];
+            }
+            const text = [...asStringArray(item.summary), ...asStringArray(item.content)].join("\n").trim();
+            return text ? [{ type: "reasoning.delta", sessionId, turnId, text }] : [];
+        }
+        if (itemType === "commandExecution") {
+            if (isStarted) {
+                const command = asString(item.command);
+                return command
+                    ? [{ type: "tool.started", sessionId, turnId, toolCall: { id: itemId, name: "shell", input: { command } } }]
+                    : [];
+            }
+            if (isCompleted) {
+                return [{ type: "tool.completed", sessionId, turnId, toolCallId: itemId, name: "shell" }];
+            }
+        }
+        if (itemType === "fileChange") {
+            if (isStarted) {
+                const changes = toJsonValue(item.changes);
+                return [
+                    {
+                        type: "tool.started",
+                        sessionId,
+                        turnId,
+                        toolCall: {
+                            id: itemId,
+                            name: "file_change",
+                            ...(changes === undefined ? {} : { input: { changes } }),
+                        },
+                    },
+                ];
+            }
+            if (isCompleted) {
+                return [{ type: "tool.completed", sessionId, turnId, toolCallId: itemId, name: "file_change" }];
+            }
+        }
+        if (itemType === "mcpToolCall") {
+            const server = asString(item.server);
+            const tool = asString(item.tool);
+            const name = server && tool ? `mcp.${server}.${tool}` : "mcp";
+            if (isStarted) {
+                return [
+                    {
+                        type: "tool.started",
+                        sessionId,
+                        turnId,
+                        toolCall: { id: itemId, name, input: toJsonValue(item.arguments) },
+                    },
+                ];
+            }
+            if (isCompleted) {
+                return [
+                    {
+                        type: "tool.completed",
+                        sessionId,
+                        turnId,
+                        toolCallId: itemId,
+                        name,
+                        result: toJsonValue(item.result),
+                    },
+                ];
+            }
+        }
+        if (itemType === "webSearch" && isStarted) {
+            return [
+                {
+                    type: "tool.started",
+                    sessionId,
+                    turnId,
+                    toolCall: { id: itemId, name: "web_search" },
+                },
+            ];
+        }
+        return [];
+    }
+}
+function normalizePlan(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const record = asRecord(entry);
+        const step = asString(record.step) ?? asString(record.text) ?? asString(record.description);
+        const status = normalizePlanStatus(asString(record.status));
+        return step ? [{ step, status }] : [];
+    });
+}
+function normalizePlanStatus(value) {
+    if (value === "in_progress" || value === "completed")
+        return value;
+    return "pending";
+}
+function normalizeTurnStatus(value) {
+    if (value === "failed")
+        return "failed";
+    if (value === "cancelled" || value === "canceled")
+        return "cancelled";
+    return "completed";
+}
+function readErrorMessage(params) {
+    return (asString(params.message) ??
+        asString(asRecord(params.error).message) ??
+        "Codex app-server error");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNullableNumber(value) {
+    if (value === null)
+        return null;
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function toJsonValue(value) {
+    if (value === undefined)
+        return undefined;
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/providers/codex.d.ts

@@ -0,0 +1,19 @@
+import type { ApprovalPolicy, CapabilitySet, CreatePortInputFor, JsonValue, Port, SandboxMode } from "../types.ts";
+import type { ProviderAdapter } from "./adapter.ts";
+type CodexPortOptions = CreatePortInputFor<"codex">;
+export declare const codexCapabilities: CapabilitySet<"codex">;
+export declare function createCodexPort(options: CodexPortOptions): Promise<Port<"codex">>;
+export declare function createCodexAdapter(options: CodexPortOptions): Promise<ProviderAdapter<"codex">>;
+export declare function createCodexThreadParams(input: {
+    cwd: string;
+    model?: string;
+    modelProvider?: string;
+    approvalPolicy?: ApprovalPolicy;
+    sandbox?: SandboxMode;
+    baseInstructions?: string;
+    developerInstructions?: string;
+    serviceTier?: string;
+    config?: Record<string, JsonValue>;
+}): JsonValue;
+export {};
+//# sourceMappingURL=codex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/providers/codex.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,cAAc,EAEd,aAAa,EAEb,kBAAkB,EAElB,SAAS,EACT,IAAI,EACJ,WAAW,EAGZ,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,KAAK,gBAAgB,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;AAEpD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,OAAO,CAwCpD,CAAC;AAEF,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAEvF;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAIrG;AAiPD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACpC,GAAG,SAAS,CAYZ"}