devin-oauth-opencode 0.2.0

package/dist/cloud.js

@@ -0,0 +1,332 @@
+import crypto from "node:crypto";
+import http2 from "node:http2";
+import { getApiKey, getLatestDevinVersion, DevinError, DevinErrorCode } from "./auth";
+import { resolveDevinModel } from "./models";
+const CODEIUM_API_ORIGIN = "https://server.codeium.com";
+const GET_CHAT_MESSAGE_PATH = "/exa.api_server_pb.ApiServerService/GetChatMessage";
+const CLOUD_SESSION_IDLE_MS = 60_000;
+let cloudClient;
+let cloudConnectPromise;
+let cloudIdleTimer;
+function encodeVarint(value) {
+    const bytes = [];
+    let current = BigInt(value);
+    while (current > 127n) {
+        bytes.push(Number(current & 0x7fn) | 0x80);
+        current >>= 7n;
+    }
+    bytes.push(Number(current));
+    return bytes;
+}
+function encodeString(fieldNum, value) {
+    const bytes = Buffer.from(value, "utf8");
+    return Buffer.from([
+        ...encodeVarint((fieldNum << 3) | 2),
+        ...encodeVarint(bytes.length),
+        ...bytes,
+    ]);
+}
+function encodeMessage(fieldNum, value) {
+    return Buffer.from([
+        ...encodeVarint((fieldNum << 3) | 2),
+        ...encodeVarint(value.length),
+        ...value,
+    ]);
+}
+function encodeVarintField(fieldNum, value) {
+    return Buffer.from([...encodeVarint((fieldNum << 3) | 0), ...encodeVarint(value)]);
+}
+function connectEnvelope(payload) {
+    const frame = Buffer.alloc(5);
+    frame[0] = 0;
+    frame.writeUInt32BE(payload.length, 1);
+    return Buffer.concat([frame, payload]);
+}
+function readVarint(buffer, offset) {
+    let value = 0n;
+    let shift = 0n;
+    let next = offset;
+    while (next < buffer.length) {
+        const byte = buffer[next];
+        value |= BigInt(byte & 0x7f) << shift;
+        next++;
+        if (byte < 0x80)
+            return { value, next };
+        shift += 7n;
+    }
+    return null;
+}
+function parseFields(buffer) {
+    const fields = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        const key = readVarint(buffer, offset);
+        if (!key)
+            break;
+        offset = key.next;
+        const fieldNum = Number(key.value >> 3n);
+        const wireType = Number(key.value & 7n);
+        if (wireType === 0) {
+            const value = readVarint(buffer, offset);
+            if (!value)
+                break;
+            fields.push({ fieldNum, wireType, value: value.value });
+            offset = value.next;
+        }
+        else if (wireType === 2) {
+            const length = readVarint(buffer, offset);
+            if (!length)
+                break;
+            offset = length.next;
+            const end = offset + Number(length.value);
+            if (end > buffer.length)
+                break;
+            fields.push({ fieldNum, wireType, value: buffer.subarray(offset, end) });
+            offset = end;
+        }
+        else if (wireType === 5) {
+            offset += 4;
+        }
+        else if (wireType === 1) {
+            offset += 8;
+        }
+        else {
+            break;
+        }
+    }
+    return fields;
+}
+function parseConnectEnvelopes(buffer) {
+    const envelopes = [];
+    let offset = 0;
+    while (offset + 5 <= buffer.length) {
+        const flags = buffer[offset];
+        const length = buffer.readUInt32BE(offset + 1);
+        offset += 5;
+        const end = offset + length;
+        if (end > buffer.length)
+            break;
+        envelopes.push({ flags, body: buffer.subarray(offset, end) });
+        offset = end;
+    }
+    return envelopes;
+}
+function takeConnectEnvelopes(buffer) {
+    const envelopes = [];
+    let offset = 0;
+    while (offset + 5 <= buffer.length) {
+        const flags = buffer[offset];
+        const length = buffer.readUInt32BE(offset + 1);
+        const frameStart = offset + 5;
+        const frameEnd = frameStart + length;
+        if (frameEnd > buffer.length)
+            break;
+        envelopes.push({ flags, body: buffer.subarray(frameStart, frameEnd) });
+        offset = frameEnd;
+    }
+    return { envelopes, remaining: buffer.subarray(offset) };
+}
+function isCloudClientHealthy(client) {
+    return Boolean(client && !client.closed && !client.destroyed);
+}
+function clearCloudClient(client = cloudClient) {
+    if (client && cloudClient === client) {
+        cloudClient = undefined;
+    }
+}
+export function closeDevinCloudConnection() {
+    if (cloudIdleTimer)
+        clearTimeout(cloudIdleTimer);
+    cloudIdleTimer = undefined;
+    cloudConnectPromise = undefined;
+    const client = cloudClient;
+    cloudClient = undefined;
+    if (client && !client.destroyed) {
+        client.close();
+    }
+}
+function resetCloudIdleTimer() {
+    if (cloudIdleTimer)
+        clearTimeout(cloudIdleTimer);
+    cloudIdleTimer = setTimeout(() => {
+        closeDevinCloudConnection();
+    }, CLOUD_SESSION_IDLE_MS);
+}
+async function getCloudClient() {
+    if (isCloudClientHealthy(cloudClient)) {
+        resetCloudIdleTimer();
+        return cloudClient;
+    }
+    if (cloudConnectPromise)
+        return cloudConnectPromise;
+    cloudConnectPromise = new Promise((resolve, reject) => {
+        const client = http2.connect(CODEIUM_API_ORIGIN);
+        const cleanup = () => {
+            client.off("connect", onConnect);
+            client.off("error", onError);
+        };
+        const onConnect = () => {
+            cleanup();
+            cloudClient = client;
+            client.once("close", () => clearCloudClient(client));
+            client.once("error", () => {
+                clearCloudClient(client);
+                client.destroy();
+            });
+            client.once("goaway", () => clearCloudClient(client));
+            resetCloudIdleTimer();
+            resolve(client);
+        };
+        const onError = (error) => {
+            cleanup();
+            client.destroy();
+            reject(new DevinError(error.message, DevinErrorCode.ConnectionFailed));
+        };
+        client.once("connect", onConnect);
+        client.once("error", onError);
+    });
+    const connectPromise = cloudConnectPromise.finally(() => {
+        cloudConnectPromise = undefined;
+    });
+    cloudConnectPromise = connectPromise;
+    return connectPromise;
+}
+export async function warmDevinCloudConnection() {
+    await getCloudClient();
+}
+function textContent(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((part) => part.type === "text" && part.text)
+        .map((part) => part.text)
+        .join("\n");
+}
+function sourceForRole(role) {
+    if (role === "system")
+        return 5;
+    if (role === "tool")
+        return 4;
+    return 1;
+}
+function buildMetadata(apiKey, version) {
+    return Buffer.concat([
+        encodeString(3, apiKey),
+        encodeString(1, "devin"),
+        encodeString(7, version),
+        encodeString(2, version),
+        encodeString(12, "devin"),
+        encodeString(10, crypto.randomUUID()),
+        encodeString(4, "en-US"),
+        encodeString(28, "devin"),
+    ]);
+}
+function buildChatPrompt(message) {
+    let prompt = textContent(message.content).trim();
+    if (message.role === "assistant" && message.tool_calls?.length) {
+        prompt = `${prompt}\nASSISTANT TOOL_CALLS: ${JSON.stringify(message.tool_calls)}`.trim();
+    }
+    else if (message.role === "tool") {
+        prompt = `TOOL RESULT${message.tool_call_id ? ` ${message.tool_call_id}` : ""}: ${prompt}`;
+    }
+    return Buffer.concat([
+        encodeString(1, crypto.randomUUID()),
+        encodeVarintField(2, sourceForRole(message.role)),
+        encodeString(3, prompt),
+    ]);
+}
+function buildGetChatMessageRequest(request, apiKey, version) {
+    const model = resolveDevinModel(request.model);
+    const prompts = request.messages
+        .map((message) => ({ message, prompt: textContent(message.content).trim() }))
+        .filter(({ prompt, message }) => prompt || (message.role === "assistant" && message.tool_calls?.length))
+        .map(({ message }) => encodeMessage(3, buildChatPrompt(message)));
+    if (prompts.length === 0) {
+        throw new Error("No prompt text found in request messages");
+    }
+    return Buffer.concat([
+        encodeMessage(1, buildMetadata(apiKey, version)),
+        ...prompts,
+        encodeVarintField(7, 5),
+        encodeString(21, model.modelUid),
+    ]);
+}
+export async function* streamDevinCloudChat(request) {
+    const apiKey = getApiKey();
+    const body = connectEnvelope(buildGetChatMessageRequest(request, apiKey, await getLatestDevinVersion()));
+    const client = await getCloudClient();
+    const req = client.request({
+        ":method": "POST",
+        ":path": GET_CHAT_MESSAGE_PATH,
+        "content-type": "application/connect+proto",
+        "connect-protocol-version": "1",
+        accept: "application/connect+proto",
+    });
+    try {
+        req.end(body);
+        let buffered = Buffer.alloc(0);
+        const timeout = setTimeout(() => {
+            req.close(http2.constants.NGHTTP2_CANCEL);
+            client.destroy();
+        }, 120_000);
+        try {
+            for await (const chunk of req) {
+                buffered = Buffer.concat([buffered, Buffer.from(chunk)]);
+                const parsed = takeConnectEnvelopes(buffered);
+                buffered = parsed.remaining;
+                for (const envelope of parsed.envelopes) {
+                    if (envelope.flags === 2) {
+                        const trailer = envelope.body.toString("utf8");
+                        if (trailer.includes('"error"')) {
+                            throw new DevinError(trailer, DevinErrorCode.StreamError);
+                        }
+                        continue;
+                    }
+                    for (const field of parseFields(envelope.body)) {
+                        if (field.fieldNum === 3 && Buffer.isBuffer(field.value)) {
+                            yield field.value.toString("utf8");
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        const parsed = takeConnectEnvelopes(buffered);
+        for (const envelope of parsed.envelopes) {
+            if (envelope.flags === 2) {
+                const trailer = envelope.body.toString("utf8");
+                if (trailer.includes('"error"')) {
+                    throw new DevinError(trailer, DevinErrorCode.StreamError);
+                }
+                continue;
+            }
+            for (const field of parseFields(envelope.body)) {
+                if (field.fieldNum === 3 && Buffer.isBuffer(field.value)) {
+                    yield field.value.toString("utf8");
+                }
+            }
+        }
+        if (parsed.remaining.length > 0) {
+            throw new DevinError("Cloud chat response ended with an incomplete Connect frame", DevinErrorCode.StreamError);
+        }
+    }
+    finally {
+        resetCloudIdleTimer();
+    }
+}
+export async function collectDevinCloudChat(request) {
+    const chunks = [];
+    for await (const chunk of streamDevinCloudChat(request)) {
+        chunks.push(chunk);
+    }
+    return chunks.join("");
+}
+export const __test = {
+    buildGetChatMessageRequest,
+    parseFields,
+    parseConnectEnvelopes,
+};

package/dist/devin.d.ts

@@ -0,0 +1,34 @@
+export interface ContentPart {
+    type: string;
+    text?: string;
+}
+export interface OpenAIMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null | ContentPart[];
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+export interface ChatCompletionRequest {
+    model?: string;
+    messages: OpenAIMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    tools?: Array<{
+        type?: "function";
+        function?: {
+            name?: string;
+            description?: string;
+            parameters?: Record<string, unknown>;
+        };
+    }>;
+}
+export declare function streamDevinChat(request: ChatCompletionRequest): AsyncGenerator<string, void, unknown>;
+export declare function collectDevinChat(request: ChatCompletionRequest): Promise<string>;

package/dist/devin.js

@@ -0,0 +1,9 @@
+import { collectDevinCloudChat, streamDevinCloudChat } from "./cloud";
+export async function* streamDevinChat(request) {
+    for await (const chunk of streamDevinCloudChat(request)) {
+        yield chunk;
+    }
+}
+export async function collectDevinChat(request) {
+    return collectDevinCloudChat(request);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const DevinAuthPlugin: Plugin;
+export default DevinAuthPlugin;

package/dist/index.js

@@ -0,0 +1,108 @@
+import { buildDevinProviderModels, proxyBaseURL, startProxy, } from "./proxy";
+import { getDevinVersion, getLatestDevinVersion, setDevinApiKeyForSession } from "./auth";
+import { getCachedDevinModels, getDiscoveredDevinModels } from "./model-discovery";
+import { warmDevinCloudConnection } from "./cloud";
+import { DEVIN_PROVIDER_ID } from "./models";
+import { exchangeDevinCode, startDevinLoopbackAuth, } from "./browser-auth";
+export const DevinAuthPlugin = async (_input) => {
+    function refreshModelsInBackground(provider, port, apiKey) {
+        if (!apiKey || apiKey === "devin-local")
+            return;
+        void (async () => {
+            const version = await getLatestDevinVersion(fetch, { timeoutMs: 1_500 });
+            const models = await getDiscoveredDevinModels(apiKey, version, { timeoutMs: 2_000 });
+            if (provider) {
+                provider.models = buildDevinProviderModels(port, models);
+            }
+        })().catch(() => { });
+    }
+    async function ensureProxy(provider, apiKey) {
+        const port = await startProxy();
+        const models = getCachedDevinModels(apiKey, getDevinVersion());
+        if (provider) {
+            provider.models = buildDevinProviderModels(port, models);
+        }
+        refreshModelsInBackground(provider, port, apiKey);
+        if (apiKey && apiKey !== "devin-local") {
+            warmDevinCloudConnection().catch(() => { });
+        }
+        return {
+            baseURL: proxyBaseURL(port),
+            apiKey: "devin-local",
+            async fetch(requestInput, init) {
+                if (init?.headers) {
+                    if (init.headers instanceof Headers) {
+                        init.headers.delete("authorization");
+                    }
+                    else if (Array.isArray(init.headers)) {
+                        init.headers = init.headers.filter(([key]) => key.toLowerCase() !== "authorization");
+                    }
+                    else {
+                        delete init.headers.authorization;
+                        delete init.headers.Authorization;
+                    }
+                }
+                return fetch(requestInput, init);
+            },
+        };
+    }
+    return {
+        auth: {
+            provider: DEVIN_PROVIDER_ID,
+            async loader(getAuth, provider) {
+                const auth = await getAuth().catch(() => undefined);
+                if (auth?.type === "api" && auth.key !== "devin-local") {
+                    setDevinApiKeyForSession(auth.key);
+                }
+                return ensureProxy(provider, auth?.type === "api" ? auth.key : undefined);
+            },
+            methods: [
+                {
+                    type: "oauth",
+                    label: "Login with Devin",
+                    prompts: [
+                        {
+                            type: "text",
+                            key: "loginHint",
+                            message: "Devin email (optional)",
+                            placeholder: "you@example.com",
+                        },
+                    ],
+                    async authorize(inputs = {}) {
+                        const loopback = startDevinLoopbackAuth({ loginHint: inputs.loginHint });
+                        return {
+                            url: loopback.url,
+                            instructions: "Complete Devin login in your browser. This window will close automatically after the localhost callback completes.",
+                            method: "auto",
+                            async callback() {
+                                try {
+                                    const code = await loopback.waitForCode();
+                                    const auth = await exchangeDevinCode(code, loopback.verifier);
+                                    setDevinApiKeyForSession(auth.apiKey);
+                                    return {
+                                        type: "success",
+                                        key: auth.apiKey,
+                                    };
+                                }
+                                catch {
+                                    return {
+                                        type: "failed",
+                                    };
+                                }
+                            },
+                        };
+                    },
+                },
+            ],
+        },
+        async "chat.params"(input, output) {
+            if (input.model?.providerID !== DEVIN_PROVIDER_ID)
+                return;
+            const port = await startProxy();
+            output.options = output.options || {};
+            output.options.baseURL = proxyBaseURL(port);
+            output.options.apiKey = output.options.apiKey || "devin-local";
+        },
+    };
+};
+export default DevinAuthPlugin;

package/dist/model-discovery.d.ts

@@ -0,0 +1,37 @@
+import type { ModelCost, DevinModel } from "./models";
+export declare function getRequiredDevinModelIds(): readonly string[];
+type ProtobufValue = bigint | Buffer;
+interface ProtobufField {
+    fieldNum: number;
+    wireType: number;
+    value: ProtobufValue;
+}
+interface DevinModelConfig {
+    id: string;
+    modelUid: string;
+    name: string;
+    cost?: ModelCost;
+}
+declare function encodeString(fieldNum: number, value: string): Buffer;
+declare function connectEnvelope(payload: Buffer): Buffer;
+declare function parseFields(buffer: Buffer): ProtobufField[];
+declare function parseConnectEnvelopes(buffer: Buffer): Array<{
+    flags: number;
+    body: Buffer;
+}>;
+declare function parseModelConfigs(buffer: Buffer): DevinModelConfig[];
+export declare function getCachedDevinModels(apiKey?: string, version?: string): DevinModel[];
+export declare function getDiscoveredDevinModels(apiKey?: string, version?: string, options?: {
+    timeoutMs?: number;
+    allowStale?: boolean;
+}): Promise<DevinModel[]>;
+export declare function clearDiscoveredModelCache(): void;
+export declare const __test: {
+    clearDiscoveredModelCache: typeof clearDiscoveredModelCache;
+    connectEnvelope: typeof connectEnvelope;
+    encodeString: typeof encodeString;
+    parseConnectEnvelopes: typeof parseConnectEnvelopes;
+    parseFields: typeof parseFields;
+    parseModelConfigs: typeof parseModelConfigs;
+};
+export {};