opencode-cmd-provider 0.1.0

package/dist/src/provider/redact.js

@@ -0,0 +1,59 @@
+// src/provider/redact.ts — credential redaction (PLAN #3 Part B)
+//
+// Port of pi-commandcode-provider/src/overflow.ts, keeping only the
+// redaction functions. Overflow-normalization functions and the
+// CommandCodeMessageLike type are dropped: opencode has its own
+// context-overflow handling; if a context-overflow error surfaces it
+// arrives as a plain AI SDK error and opencode's own compaction handles it.
+// Applied to every error surfaced to opencode — AI SDK errors must never
+// leak credentials (DESIGN §6.6).
+const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi;
+const CREDENTIAL_PATTERN = /\b(?:api[-_ ]?key|apikey|access[-_ ]?token|refresh[-_ ]?token|token|secret|password|authorization)\s*[=:]\s*[^\s,;)]+/gi;
+const USER_TOKEN_PATTERN = /\b(?:user|cc)_[A-Za-z0-9_-]{8,}\b/gi;
+const QUERY_SECRET_PATTERN = /([?&](?:api[-_ ]?key|apikey|access_token|refresh_token|token|secret|password)=)[^&#\s]+/gi;
+const STANDALONE_SECRET_PATTERN = /\b(?:sk|rk|ghp|github_pat|xox[baprs])[-_A-Za-z0-9]{16,}\b|\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\b/g;
+export function redactCommandCodeErrorText(value) {
+    return value
+        .replace(BEARER_PATTERN, "Bearer [redacted]")
+        .replace(CREDENTIAL_PATTERN, (match) => {
+        const separatorIndex = match.search(/[=:]/);
+        return separatorIndex < 0 ? "[redacted]" : `${match.slice(0, separatorIndex + 1)}[redacted]`;
+    })
+        .replace(USER_TOKEN_PATTERN, "[redacted]")
+        .replace(QUERY_SECRET_PATTERN, "$1[redacted]")
+        .replace(STANDALONE_SECRET_PATTERN, "[redacted]");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function commandCodeErrorMessage(value) {
+    if (typeof value === "string")
+        return value;
+    if (!isRecord(value))
+        return undefined;
+    const record = value;
+    const parts = [];
+    for (const key of [
+        "message",
+        "errorMessage",
+        "error",
+        "detail",
+        "details",
+        "code",
+        "type",
+        "reason",
+    ]) {
+        const part = commandCodeErrorMessage(record[key]);
+        if (part && !parts.includes(part))
+            parts.push(part);
+    }
+    for (const key of ["status", "statusCode", "httpStatus"]) {
+        const status = record[key];
+        if (typeof status === "string" || typeof status === "number") {
+            const statusPart = `status: ${status}`;
+            if (!parts.includes(statusPart))
+                parts.push(statusPart);
+        }
+    }
+    return parts.length > 0 ? redactCommandCodeErrorText(parts.join(": ")) : undefined;
+}

package/dist/src/provider/retry.d.ts

@@ -0,0 +1,8 @@
+export declare function isRetryableStatus(status: number): boolean;
+export declare function parseRetryAfterSeconds(value: string | null): number | undefined;
+export declare function retryDelayMs(attempt: number, retryAfterHeader: string | null, maxDelayMs: number): number;
+export declare function abortError(message?: string): DOMException;
+export declare function timeoutError(timeoutMs: number | undefined): Error;
+export declare function raceAbort<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function raceAbortWithTimeout<T>(promise: Promise<T>, controller: AbortController, timeoutMs: number | undefined): Promise<T>;
+export declare function delay(ms: number, signal: AbortSignal): Promise<void>;

package/dist/src/provider/retry.js

@@ -0,0 +1,83 @@
+// src/provider/retry.ts — retry, abort and timeout helpers (PLAN #4, port of
+// pi's core.ts retry math + abort races + signal-aware delay)
+export function isRetryableStatus(status) {
+    return status === 429 || (status >= 500 && status < 600);
+}
+export function parseRetryAfterSeconds(value) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds;
+    const date = Date.parse(value);
+    if (!Number.isNaN(date))
+        return Math.max(0, (date - Date.now()) / 1000);
+    return undefined;
+}
+const BASE_RETRY_DELAY_MS = 500;
+export function retryDelayMs(attempt, retryAfterHeader, maxDelayMs) {
+    const retryAfterMs = parseRetryAfterSeconds(retryAfterHeader);
+    if (retryAfterMs !== undefined) {
+        if (retryAfterMs * 1000 > maxDelayMs)
+            return -1;
+        return retryAfterMs * 1000;
+    }
+    const exponential = BASE_RETRY_DELAY_MS * 2 ** attempt;
+    const jitter = exponential * 0.2 * Math.random();
+    return Math.min(exponential + jitter, maxDelayMs);
+}
+export function abortError(message = "The operation was aborted") {
+    return new DOMException(message, "AbortError");
+}
+export function timeoutError(timeoutMs) {
+    return new Error(timeoutMs === undefined
+        ? "Command Code API request timed out"
+        : `Command Code API request timed out after ${timeoutMs}ms`);
+}
+export function raceAbort(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+export function raceAbortWithTimeout(promise, controller, timeoutMs) {
+    if (timeoutMs === undefined)
+        return raceAbort(promise, controller.signal);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            controller.abort();
+            reject(timeoutError(timeoutMs));
+        }, timeoutMs);
+        raceAbort(promise, controller.signal).then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+export function delay(ms, signal) {
+    if (signal.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(id);
+            reject(abortError());
+        };
+        const id = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/src/provider/stream.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageModelV3StreamPart, LanguageModelV3Usage, LanguageModelV3FinishReason } from "@ai-sdk/provider";
+export declare function parseStreamEventLine(line: string): unknown | undefined;
+export declare function mapFinishReason(reason: unknown): LanguageModelV3FinishReason;
+export declare function ccUsageToAiSdkUsage(event: Record<string, unknown>): LanguageModelV3Usage | undefined;
+export declare function ccEventToStreamPart(event: unknown): LanguageModelV3StreamPart[];

package/dist/src/provider/stream.js

@@ -0,0 +1,105 @@
+import { isRecord, stringValue, numberValue, recordOrEmpty } from "./converters.js";
+import { commandCodeErrorMessage } from "./redact.js";
+export function parseStreamEventLine(line) {
+    let trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith(":") || trimmed.startsWith("event:"))
+        return undefined;
+    if (trimmed.startsWith("data:"))
+        trimmed = trimmed.slice(5).trim();
+    if (!trimmed || trimmed === "[DONE]")
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function mapFinishReason(reason) {
+    const raw = stringValue(reason) ?? "unknown";
+    if (raw === "tool_use" || raw === "tool-calls")
+        return { unified: "tool-calls", raw };
+    if (raw === "length" ||
+        raw === "max_tokens" ||
+        raw === "max-tokens" ||
+        raw === "max_output_tokens") {
+        return { unified: "length", raw };
+    }
+    if (raw === "stop")
+        return { unified: "stop", raw };
+    if (raw === "error")
+        return { unified: "error", raw };
+    if (raw === "content-filter")
+        return { unified: "content-filter", raw };
+    return { unified: "other", raw };
+}
+export function ccUsageToAiSdkUsage(event) {
+    const usage = event.totalUsage;
+    if (!isRecord(usage))
+        return undefined;
+    const details = isRecord(usage.inputTokenDetails) ? usage.inputTokenDetails : undefined;
+    const totalInput = numberValue(usage.inputTokens) ?? 0;
+    const noCache = numberValue(details?.noCacheTokens);
+    const cacheRead = numberValue(details?.cacheReadTokens) ?? 0;
+    const cacheWrite = numberValue(details?.cacheWriteTokens) ?? 0;
+    const inputTotal = noCache ?? Math.max(0, totalInput - cacheRead - cacheWrite);
+    const outputTokens = numberValue(usage.outputTokens) ?? 0;
+    return {
+        inputTokens: { total: inputTotal, noCache: inputTotal, cacheRead, cacheWrite },
+        outputTokens: { total: outputTokens, text: outputTokens, reasoning: 0 },
+    };
+}
+function toolCallIdOf(event) {
+    return stringValue(event.toolCallId) ?? stringValue(event.id) ?? "";
+}
+export function ccEventToStreamPart(event) {
+    if (!isRecord(event))
+        return [];
+    switch (event.type) {
+        case "text-delta": {
+            const id = toolCallIdOf(event) || "text";
+            return [{ type: "text-delta", id, delta: stringValue(event.text) ?? "" }];
+        }
+        case "reasoning-delta": {
+            const id = toolCallIdOf(event) || "reasoning";
+            return [{ type: "reasoning-delta", id, delta: stringValue(event.text) ?? "" }];
+        }
+        case "reasoning-start":
+        case "reasoning-end":
+        case "tool-result":
+            return [];
+        case "tool-call": {
+            const id = toolCallIdOf(event);
+            const toolName = stringValue(event.toolName) ?? "";
+            const args = recordOrEmpty(event.input ?? event.args ?? event.arguments);
+            const argsTextDelta = JSON.stringify(args);
+            return [
+                { type: "tool-input-start", id, toolName },
+                { type: "tool-input-delta", id, delta: argsTextDelta },
+                { type: "tool-input-end", id },
+                { type: "tool-call", toolCallId: id, toolName, input: argsTextDelta },
+            ];
+        }
+        case "finish": {
+            const usage = ccUsageToAiSdkUsage(event);
+            return [
+                {
+                    type: "finish",
+                    finishReason: mapFinishReason(event.finishReason),
+                    usage: usage ?? {
+                        inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+                        outputTokens: { total: 0, text: 0, reasoning: 0 },
+                    },
+                },
+            ];
+        }
+        case "error": {
+            const message = commandCodeErrorMessage(event.error) ??
+                commandCodeErrorMessage(event.message) ??
+                "Command Code stream error";
+            throw new Error(message);
+        }
+        default:
+            return [];
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "opencode-cmd-provider",
+  "version": "0.1.0",
+  "description": "Command Code provider + plugin for opencode",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./server": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run typecheck && npm run test:unit && npm run test:integration && npm run test:contract && npm run format:check",
+    "test:unit": "tsx tests/env.test.ts && tsx tests/auth-key.test.ts && tsx tests/converters.test.ts && tsx tests/stream.test.ts && tsx tests/redact.test.ts && tsx tests/cost.test.ts && tsx tests/retry.test.ts && tsx tests/reasoning.test.ts && tsx tests/modalities.test.ts && tsx tests/models.test.ts && tsx tests/oauth.test.ts && tsx tests/plugin-models.test.ts",
+    "test:integration": "tsx tests/integration-do-stream.test.ts && tsx tests/integration-do-generate.test.ts",
+    "test:contract": "tsx tests/contract.test.ts",
+    "test:e2e": "node tests/e2e-opencode.mjs",
+    "format": "prettier --write '**/*.{ts,mjs,json,md}'",
+    "format:check": "prettier --check '**/*.{ts,mjs,json,md}'"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "commandcode",
+    "provider",
+    "ai-sdk"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rashidrazak/opencode-cmd-provider.git"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^3.0.8"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "*",
+    "@types/node": "^25.9.5",
+    "prettier": "^3.9.6",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    }
+  }
+}