opencode-ext-connector 0.3.0

package/dist/providers/claude/sse.js

@@ -0,0 +1,123 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { convertEventToPart } from "./sse-convert";
+function isAnthropicSseEvent(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typeValue = Reflect.get(value, "type");
+    if (typeof typeValue !== "string") {
+        return false;
+    }
+    const validTypes = [
+        "message_start",
+        "content_block_start",
+        "content_block_delta",
+        "content_block_stop",
+        "message_delta",
+        "message_stop",
+        "error",
+    ];
+    return validTypes.includes(typeValue);
+}
+function parseSseLine(line) {
+    if (line.length === 0) {
+        return null;
+    }
+    if (line.startsWith(":")) {
+        return null;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+        return { event: line };
+    }
+    const field = line.slice(0, colonIndex);
+    const value = line.slice(colonIndex + 1).trimStart();
+    if (field === "event") {
+        return { event: value };
+    }
+    if (field === "data") {
+        return { data: value };
+    }
+    return null;
+}
+function parseEventType(event) {
+    const validEvents = {
+        message_start: "message_start",
+        content_block_start: "content_block_start",
+        content_block_delta: "content_block_delta",
+        content_block_stop: "content_block_stop",
+        message_delta: "message_delta",
+        message_stop: "message_stop",
+        error: "error",
+    };
+    return validEvents[event] ?? null;
+}
+export function createSseParseState() {
+    return { buffer: "", event: null };
+}
+export function parseAnthropicSse(chunk, state) {
+    const text = new TextDecoder().decode(chunk);
+    const combined = state.buffer + text;
+    const lines = combined.split("\n");
+    const newBuffer = lines.pop() ?? "";
+    const events = [];
+    let currentEvent = state.event ?? undefined;
+    let currentData;
+    for (const line of lines) {
+        const parsed = parseSseLine(line);
+        if (parsed === null) {
+            continue;
+        }
+        if ("event" in parsed) {
+            currentEvent = parsed.event;
+            currentData = undefined;
+            continue;
+        }
+        if ("data" in parsed) {
+            currentData = parsed.data;
+            if (currentEvent === undefined) {
+                continue;
+            }
+            const eventType = parseEventType(currentEvent);
+            if (eventType === null) {
+                currentEvent = undefined;
+                currentData = undefined;
+                continue;
+            }
+            let event;
+            try {
+                const parsed = JSON.parse(currentData);
+                if (isAnthropicSseEvent(parsed)) {
+                    event = parsed;
+                }
+                else {
+                    currentEvent = undefined;
+                    currentData = undefined;
+                    continue;
+                }
+            }
+            catch {
+                currentEvent = undefined;
+                currentData = undefined;
+                continue;
+            }
+            if (event.type !== eventType) {
+                currentEvent = undefined;
+                currentData = undefined;
+                continue;
+            }
+            const result = convertEventToPart(event);
+            if (result !== null) {
+                events.push(result);
+            }
+            currentEvent = undefined;
+            currentData = undefined;
+        }
+    }
+    return {
+        events,
+        state: { buffer: newBuffer, event: currentEvent ?? null },
+    };
+}
+export { convertEventToPart, mapStopReason } from "./sse-convert";

package/dist/providers/claude/transform.d.ts

@@ -0,0 +1,32 @@
+export type ToolUseBlock = {
+    readonly type: "tool_use";
+    readonly id: string;
+    readonly name: string;
+    readonly input: Record<string, unknown>;
+};
+export type ToolResultBlock = {
+    readonly type: "tool_result";
+    readonly tool_use_id: string;
+    readonly content: string;
+    readonly is_error: true;
+};
+export type ContentBlock = ToolUseBlock | ToolResultBlock | {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: string;
+    readonly [key: string]: unknown;
+};
+export type Message = {
+    readonly role: "user" | "assistant" | "system";
+    readonly content: string | readonly ContentBlock[];
+};
+export type RequestBody = {
+    readonly model: string;
+    readonly max_tokens: number;
+    readonly system?: string;
+    readonly messages: readonly Message[];
+    readonly stream?: boolean;
+    readonly [key: string]: unknown;
+};
+export declare function repairOrphanToolUses(body: RequestBody): RequestBody;

package/dist/providers/claude/transform.js

@@ -0,0 +1,52 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+function isToolUseBlock(block) {
+    return block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string";
+}
+function isToolResultBlock(block) {
+    return block.type === "tool_result" && typeof block.tool_use_id === "string";
+}
+function findOrphanToolUses(content) {
+    const toolUseIds = new Set();
+    const toolResultIds = new Set();
+    for (const block of content) {
+        if (isToolUseBlock(block)) {
+            toolUseIds.add(block.id);
+        }
+        if (isToolResultBlock(block)) {
+            toolResultIds.add(block.tool_use_id);
+        }
+    }
+    const orphans = [];
+    for (const block of content) {
+        if (isToolUseBlock(block) && !toolResultIds.has(block.id)) {
+            orphans.push(block);
+        }
+    }
+    return orphans;
+}
+function createPlaceholderToolResult(toolUse) {
+    return {
+        type: "tool_result",
+        tool_use_id: toolUse.id,
+        content: `Tool ${toolUse.name} was called but no result was provided.`,
+        is_error: true,
+    };
+}
+export function repairOrphanToolUses(body) {
+    const messages = body.messages.map((message) => {
+        if (message.role !== "assistant" || typeof message.content === "string") {
+            return message;
+        }
+        const orphans = findOrphanToolUses(message.content);
+        if (orphans.length === 0) {
+            return message;
+        }
+        const newContent = [...message.content];
+        for (const orphan of orphans) {
+            newContent.push(createPlaceholderToolResult(orphan));
+        }
+        return { ...message, content: newContent };
+    });
+    return { ...body, messages };
+}

package/dist/providers/claude/writeback.d.ts

@@ -0,0 +1,18 @@
+import type { ClaudeCredentials } from "./credentials";
+export type ClaudeWriteBackHooks = {
+    readonly writeFile?: (path: string, body: string) => Promise<void>;
+    readonly readFile?: (path: string) => Promise<string | null>;
+    readonly writeKeychain?: (args: readonly string[]) => Promise<void>;
+    readonly readKeychainDump?: () => Promise<string | null>;
+    readonly platform?: string;
+    readonly expectedPriorAccessToken?: string;
+    readonly source?: "file" | "keychain";
+};
+export declare function claudeCredentialPath(env: Readonly<Record<string, string | undefined>>): string;
+export declare function claudeWindowsCredentialPaths(env: Readonly<Record<string, string | undefined>>): readonly string[];
+export declare function claudeCredentialsFileBody(credentials: ClaudeCredentials): string;
+export declare function updateClaudeCredentialBlob(raw: string, credentials: ClaudeCredentials, expectedPriorAccessToken?: string): string | null;
+export declare function claudeKeychainWriteArgs(credentials: ClaudeCredentials, account?: string): readonly string[];
+export declare function resolveKeychainAccount(readDump?: () => Promise<string | null>): Promise<string>;
+export declare function writeClaudeCredentials(env: Readonly<Record<string, string | undefined>>, credentials: ClaudeCredentials, hooks?: ClaudeWriteBackHooks): Promise<void>;
+export declare function writeClaudeCredentialsFile(env: Readonly<Record<string, string | undefined>>, credentials: ClaudeCredentials): Promise<void>;

package/dist/providers/claude/writeback.js

@@ -0,0 +1,140 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { opencodeAuthJsonPaths } from "../../opencode/auth-store";
+import { writeClaudePrivateFile } from "./atomic-private-file";
+import { mergeOpencodeAuthJson } from "./auth-json";
+import { parseKeychainAccount } from "./keychain-account";
+const execFileAsync = promisify(execFile);
+const CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+const CLAUDE_KEYCHAIN_ACCOUNT = "Claude Code";
+export function claudeCredentialPath(env) {
+    const configDir = env["CLAUDE_CONFIG_DIR"] ?? join(homedir(), ".claude");
+    return join(configDir, ".credentials.json");
+}
+export function claudeWindowsCredentialPaths(env) {
+    const appdata = env["APPDATA"];
+    if (appdata === undefined || appdata.length === 0) {
+        return [];
+    }
+    return [join(appdata, "Claude", ".credentials.json")];
+}
+export function claudeCredentialsFileBody(credentials) {
+    return `${JSON.stringify({
+        claudeAiOauth: {
+            accessToken: credentials.accessToken,
+            refreshToken: credentials.refreshToken,
+            expiresAt: credentials.expiresAtMs,
+        },
+    }, null, 2)}\n`;
+}
+export function updateClaudeCredentialBlob(raw, credentials, expectedPriorAccessToken) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const wrapped = "claudeAiOauth" in parsed ? Reflect.get(parsed, "claudeAiOauth") : parsed;
+    if (typeof wrapped !== "object" || wrapped === null || Array.isArray(wrapped)) {
+        return null;
+    }
+    const current = "accessToken" in wrapped ? Reflect.get(wrapped, "accessToken") : undefined;
+    if (expectedPriorAccessToken !== undefined && current !== expectedPriorAccessToken) {
+        return null;
+    }
+    Reflect.set(wrapped, "accessToken", credentials.accessToken);
+    Reflect.set(wrapped, "refreshToken", credentials.refreshToken);
+    Reflect.set(wrapped, "expiresAt", credentials.expiresAtMs);
+    return `${JSON.stringify(parsed, null, 2)}\n`;
+}
+export function claudeKeychainWriteArgs(credentials, account = CLAUDE_KEYCHAIN_ACCOUNT) {
+    return [
+        "add-generic-password",
+        "-U",
+        "-s",
+        CLAUDE_KEYCHAIN_SERVICE,
+        "-a",
+        account,
+        "-w",
+        claudeCredentialsFileBody(credentials).trim(),
+    ];
+}
+async function defaultReadFile(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultWriteFile(path, body) {
+    await writeClaudePrivateFile(path, body);
+}
+async function defaultWriteKeychain(args) {
+    await execFileAsync("security", [...args], { timeout: 2_000 });
+}
+async function defaultReadKeychainDump() {
+    try {
+        const result = await execFileAsync("security", ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE], { timeout: 2_000 });
+        return result.stdout;
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveKeychainAccount(readDump = defaultReadKeychainDump) {
+    const dump = await readDump();
+    if (dump === null) {
+        return CLAUDE_KEYCHAIN_ACCOUNT;
+    }
+    return parseKeychainAccount(dump) ?? CLAUDE_KEYCHAIN_ACCOUNT;
+}
+export async function writeClaudeCredentials(env, credentials, hooks = {}) {
+    const write = hooks.writeFile ?? defaultWriteFile;
+    const body = claudeCredentialsFileBody(credentials);
+    const paths = [claudeCredentialPath(env)];
+    const platform = hooks.platform ?? process.platform;
+    if (platform === "win32") {
+        paths.push(...claudeWindowsCredentialPaths(env));
+    }
+    const readExisting = hooks.readFile ?? defaultReadFile;
+    if (hooks.source !== "keychain") {
+        for (const path of paths) {
+            const existing = await readExisting(path);
+            const next = existing === null
+                ? body
+                : updateClaudeCredentialBlob(existing, credentials, hooks.expectedPriorAccessToken);
+            if (next !== null) {
+                await write(path, next);
+            }
+        }
+    }
+    for (const path of opencodeAuthJsonPaths(env, platform)) {
+        const raw = await readExisting(path);
+        let existing = {};
+        if (raw !== null) {
+            try {
+                existing = JSON.parse(raw);
+            }
+            catch {
+                existing = {};
+            }
+        }
+        await write(path, mergeOpencodeAuthJson(existing, credentials));
+    }
+    if (platform === "darwin" && hooks.source !== "file") {
+        const writeKeychain = hooks.writeKeychain ?? defaultWriteKeychain;
+        const account = await resolveKeychainAccount(hooks.readKeychainDump ?? defaultReadKeychainDump);
+        await writeKeychain(claudeKeychainWriteArgs(credentials, account));
+    }
+}
+export async function writeClaudeCredentialsFile(env, credentials) {
+    await writeClaudeCredentials(env, credentials);
+}

package/dist/providers/command-code/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderAdapter } from "../../core/adapter";
+import type { AdapterModel } from "../../core/models";
+export type CommandCodeAdapterOptions = {
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly listModels: (token: string, signal: AbortSignal) => Promise<readonly AdapterModel[]>;
+};
+export declare function createCommandCodeAdapter(options: CommandCodeAdapterOptions): ProviderAdapter;

package/dist/providers/command-code/adapter.js

@@ -0,0 +1,37 @@
+import { OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { createAsyncDisposable } from "../../core/lifecycle";
+export function createCommandCodeAdapter(options) {
+    const providerId = parseProviderId("command-code");
+    const disposal = createAsyncDisposable(() => undefined);
+    let lastModels = null;
+    return {
+        providerId,
+        snapshot: async (signal) => {
+            if (signal.aborted) {
+                throw new OperationCancelledError("command-code-snapshot");
+            }
+            const token = await options.readAccessToken(signal);
+            if (token === null) {
+                return { status: "unavailable", providerId, reason: "invalid-data" };
+            }
+            try {
+                const models = await options.listModels(token, signal);
+                if (models.length === 0) {
+                    return lastModels === null
+                        ? { status: "unavailable", providerId, reason: "invalid-data" }
+                        : { status: "stale", providerId, models: lastModels, reason: "invalid-data" };
+                }
+                lastModels = models;
+                return { status: "ready", providerId, models };
+            }
+            catch {
+                return lastModels === null
+                    ? { status: "unavailable", providerId, reason: "transport-error" }
+                    : { status: "stale", providerId, models: lastModels, reason: "transport-error" };
+            }
+        },
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+    };
+}

package/dist/providers/command-code/auth.d.ts

@@ -0,0 +1,5 @@
+export type CommandCodeAuthLookup = {
+    readonly homeDir?: string;
+};
+export declare function commandCodeCredentialPaths(homeDir: string, env: Readonly<Record<string, string | undefined>>): readonly string[];
+export declare function readCommandCodeAccessToken(env: Readonly<Record<string, string | undefined>>, signal: AbortSignal, lookup?: CommandCodeAuthLookup): Promise<string | null>;

package/dist/providers/command-code/auth.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { OperationCancelledError } from "../../core/errors";
+const credentialSchema = z
+    .object({
+    apiKey: z.string().optional(),
+    accessToken: z.string().optional(),
+    token: z.string().optional(),
+    commandcode: z
+        .union([z.string(), z.object({ type: z.literal("oauth"), access: z.string() })])
+        .optional(),
+})
+    .passthrough();
+function tokenFromUnknown(value, allowsGenericToken) {
+    const parsed = credentialSchema.safeParse(value);
+    if (!parsed.success) {
+        return null;
+    }
+    if (allowsGenericToken) {
+        for (const key of ["apiKey", "accessToken", "token"]) {
+            const token = parsed.data[key];
+            if (token !== undefined && token.length > 0) {
+                return token;
+            }
+        }
+    }
+    const commandCode = parsed.data.commandcode;
+    if (typeof commandCode === "string" && commandCode.length > 0) {
+        return commandCode;
+    }
+    if (typeof commandCode === "object" && commandCode.access.length > 0) {
+        return commandCode.access;
+    }
+    return null;
+}
+export function commandCodeCredentialPaths(homeDir, env) {
+    const xdg = env["XDG_CONFIG_HOME"];
+    const paths = [
+        join(homeDir, ".commandcode", "auth.json"),
+        join(homeDir, ".commandcode", "cli-config.json"),
+        join(homeDir, ".pi", "agent", "auth.json"),
+        join(homeDir, ".config", "commandcode", "auth.json"),
+        join(homeDir, ".config", "commandcode", "cli-config.json"),
+        join(homeDir, ".config", "command-code", "auth.json"),
+    ];
+    if (xdg !== undefined && xdg.length > 0) {
+        return [
+            join(xdg, "commandcode", "auth.json"),
+            join(xdg, "commandcode", "cli-config.json"),
+            ...paths,
+        ];
+    }
+    return paths;
+}
+export async function readCommandCodeAccessToken(env, signal, lookup = {}) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("command-code-read-credentials");
+    }
+    const envToken = env["COMMAND_CODE_API_KEY"] ?? env["COMMANDCODE_API_KEY"] ?? env["CC_API_KEY"];
+    if (envToken !== undefined && envToken.length > 0) {
+        return envToken;
+    }
+    const home = lookup.homeDir ?? env["HOME"] ?? homedir();
+    const candidates = commandCodeCredentialPaths(home, env);
+    const sharedPiPath = join(home, ".pi", "agent", "auth.json");
+    const ownedCandidates = candidates.map((path) => ({
+        path,
+        allowsGenericToken: path !== sharedPiPath,
+    }));
+    for (const candidate of ownedCandidates) {
+        try {
+            const parsed = JSON.parse(await readFile(candidate.path, "utf8"));
+            const token = tokenFromUnknown(parsed, candidate.allowsGenericToken);
+            if (token !== null) {
+                return token;
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    return null;
+}

package/dist/providers/command-code/cli-version.d.ts

@@ -0,0 +1,10 @@
+import type { HttpTransport } from "../../core/http";
+export type CommandCodeVersionResolver = (signal: AbortSignal) => Promise<string | null>;
+export type CommandCodeVersionResolverOptions = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly transport: HttpTransport;
+    readonly readInstalledVersion?: () => string | null;
+};
+export declare function parseCommandCodeCliVersion(stdout: string): string | null;
+export declare function readInstalledCommandCodeVersion(env: Readonly<Record<string, string | undefined>>): string | null;
+export declare function createCommandCodeVersionResolver(options: CommandCodeVersionResolverOptions): CommandCodeVersionResolver;

package/dist/providers/command-code/cli-version.js

@@ -0,0 +1,36 @@
+import { spawnSync } from "node:child_process";
+import { createPackageVersionResolver } from "../../http/package-version";
+const COMMAND_CODE_PACKAGE = "command-code";
+export function parseCommandCodeCliVersion(stdout) {
+    const match = /(\d+\.\d+\.\d+)/.exec(stdout);
+    return match?.[1] ?? null;
+}
+export function readInstalledCommandCodeVersion(env) {
+    const result = spawnSync("command-code", ["--version"], {
+        encoding: "utf8",
+        timeout: 3_000,
+        env: { ...env },
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        return null;
+    }
+    return parseCommandCodeCliVersion(result.stdout);
+}
+export function createCommandCodeVersionResolver(options) {
+    const readInstalled = options.readInstalledVersion ?? (() => readInstalledCommandCodeVersion(options.env));
+    const readPublished = createPackageVersionResolver({
+        transport: options.transport,
+        packageName: COMMAND_CODE_PACKAGE,
+    });
+    let local;
+    return async (signal) => {
+        if (local === undefined) {
+            const override = options.env["COMMAND_CODE_CLI_VERSION"]?.trim();
+            local =
+                override !== undefined && override.length > 0
+                    ? parseCommandCodeCliVersion(override)
+                    : readInstalled();
+        }
+        return local ?? readPublished(signal);
+    };
+}

package/dist/providers/command-code/emit-stream.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export declare function emitCommandCodeChunks(chunks: AsyncIterable<Uint8Array>, controller: ReadableStreamDefaultController<LanguageModelV3StreamPart>): Promise<void>;