devin-oauth-opencode 0.2.0

package/dist/proxy.js

@@ -0,0 +1,405 @@
+import crypto from "node:crypto";
+import { buildDevinProviderModels, getDevinModels } from "./models";
+import { streamDevinChat } from "./devin";
+const DEVIN_PROXY_HOST = "127.0.0.1";
+export const DEVIN_PROXY_DEFAULT_PORT = 65_534;
+const PROXY_PROTOCOL_VERSION = 3;
+const SSE_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+};
+let proxyServer;
+let proxyPort;
+let proxyStartPromise;
+let chatTransport = streamDevinChat;
+let customChatTransport = false;
+export function setChatTransportForTests(transport) {
+    chatTransport = transport ?? streamDevinChat;
+    customChatTransport = Boolean(transport);
+}
+export function getProxyPort() {
+    return proxyPort;
+}
+export function stopProxy() {
+    proxyServer?.stop(true);
+    proxyServer = undefined;
+    proxyPort = undefined;
+    proxyStartPromise = undefined;
+    setChatTransportForTests();
+}
+export async function startProxy(forceLocal = false) {
+    if (proxyServer && proxyPort)
+        return proxyPort;
+    if (proxyStartPromise)
+        return proxyStartPromise;
+    proxyStartPromise = startProxyInner(forceLocal).finally(() => {
+        proxyStartPromise = undefined;
+    });
+    return proxyStartPromise;
+}
+async function startProxyInner(forceLocal) {
+    if (!forceLocal && !customChatTransport) {
+        const existing = await fetch(`http://${DEVIN_PROXY_HOST}:${DEVIN_PROXY_DEFAULT_PORT}/health`).catch(() => null);
+        const health = existing?.ok ? await existing.json().catch(() => null) : null;
+        if (health?.proxyProtocolVersion === PROXY_PROTOCOL_VERSION) {
+            proxyPort = DEVIN_PROXY_DEFAULT_PORT;
+            return proxyPort;
+        }
+    }
+    const bind = (port) => Bun.serve({
+        hostname: DEVIN_PROXY_HOST,
+        port,
+        idleTimeout: 255,
+        fetch: handleProxyRequest,
+    });
+    try {
+        proxyServer = bind(DEVIN_PROXY_DEFAULT_PORT);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "EADDRINUSE"))
+            throw error;
+        proxyServer = bind(0);
+    }
+    proxyPort = proxyServer.port;
+    if (!proxyPort)
+        throw new Error("Failed to bind Devin proxy");
+    return proxyPort;
+}
+export function proxyBaseURL(port = proxyPort ?? DEVIN_PROXY_DEFAULT_PORT) {
+    return `http://${DEVIN_PROXY_HOST}:${port}/v1`;
+}
+async function handleProxyRequest(req) {
+    const url = new URL(req.url);
+    if (req.method === "GET" && url.pathname === "/health") {
+        return jsonResponse({
+            ok: true,
+            proxyProtocolVersion: PROXY_PROTOCOL_VERSION,
+        });
+    }
+    if (req.method === "GET" && (url.pathname === "/v1/models" || url.pathname === "/models")) {
+        return jsonResponse({
+            object: "list",
+            data: getDevinModels().map((model) => ({
+                id: model.id,
+                object: "model",
+                created: 0,
+                owned_by: "devin",
+            })),
+        });
+    }
+    if (req.method === "POST" && (url.pathname === "/v1/chat/completions" || url.pathname === "/chat/completions")) {
+        try {
+            const body = (await req.json());
+            if (!Array.isArray(body.messages)) {
+                return openAIError(400, "messages must be an array");
+            }
+            if (hasToolContext(body)) {
+                return await handleToolPlanning(body);
+            }
+            if (body.stream === false) {
+                return jsonResponse(await createNonStreamingCompletion(body));
+            }
+            return createStreamingCompletion(body);
+        }
+        catch (error) {
+            return openAIError(500, "Chat completion failed", error instanceof Error ? error.message : String(error));
+        }
+    }
+    return openAIError(404, `Unsupported path: ${url.pathname}`);
+}
+function jsonResponse(value, status = 200) {
+    return new Response(JSON.stringify(value), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function openAIError(status, message, details) {
+    return jsonResponse({
+        error: {
+            message: details ? `${message}\n${details}` : message,
+            type: "devin_error",
+            code: null,
+        },
+    }, status);
+}
+function completionId() {
+    return `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+}
+async function collectTransport(request) {
+    const result = await chatTransport(request);
+    if (typeof result === "string")
+        return result;
+    const chunks = [];
+    for await (const chunk of result) {
+        chunks.push(chunk);
+    }
+    return chunks.join("");
+}
+async function createNonStreamingCompletion(request) {
+    const content = await collectTransport(request);
+    return {
+        id: completionId(),
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: request.model ?? getDevinModels()[0].id,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content },
+                finish_reason: "stop",
+            },
+        ],
+    };
+}
+function createStreamingCompletion(request) {
+    const id = completionId();
+    const created = Math.floor(Date.now() / 1000);
+    const model = request.model ?? getDevinModels()[0].id;
+    return createStreamingResponse(id, created, model, async function* () {
+        const result = await chatTransport(request);
+        const iterable = typeof result === "string" ? [result] : result;
+        for await (const chunk of iterable) {
+            if (chunk)
+                yield { content: chunk };
+        }
+    });
+}
+function createStreamingResponse(id, created, model, chunks) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            const send = (value) => {
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(value)}\n\n`));
+            };
+            try {
+                send({
+                    id,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+                });
+                let finishReason = "stop";
+                for await (const chunk of chunks()) {
+                    if (chunk.finishReason)
+                        finishReason = chunk.finishReason;
+                    if (chunk.toolCalls) {
+                        send({
+                            id,
+                            object: "chat.completion.chunk",
+                            created,
+                            model,
+                            choices: [{ index: 0, delta: { tool_calls: chunk.toolCalls }, finish_reason: null }],
+                        });
+                    }
+                    if (!chunk.content)
+                        continue;
+                    send({
+                        id,
+                        object: "chat.completion.chunk",
+                        created,
+                        model,
+                        choices: [{ index: 0, delta: { content: chunk.content }, finish_reason: null }],
+                    });
+                }
+                send({
+                    id,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
+                });
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+            }
+            catch (error) {
+                send({ error: { message: error instanceof Error ? error.message : String(error) } });
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+            }
+        },
+    });
+    return new Response(stream, { headers: SSE_HEADERS });
+}
+function hasToolContext(request) {
+    return Boolean(request.tools?.length ||
+        request.messages.some((message) => message.role === "tool" || message.tool_calls?.length));
+}
+function textFromContent(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 buildToolPrompt(request) {
+    const tools = request.tools?.map((tool) => {
+        const fn = tool.function;
+        return `- ${fn?.name ?? "unknown"}${fn?.description ? `: ${fn.description}` : ""}\n${JSON.stringify(fn?.parameters ?? {}, null, 2)}`;
+    }).join("\n") || "(none)";
+    const conversation = request.messages.map((message) => {
+        if (message.role === "assistant" && message.tool_calls?.length) {
+            return `ASSISTANT TOOL_CALLS: ${JSON.stringify(message.tool_calls)}`;
+        }
+        if (message.role === "tool") {
+            return `TOOL RESULT${message.tool_call_id ? ` ${message.tool_call_id}` : ""}: ${textFromContent(message.content)}`;
+        }
+        return `${message.role.toUpperCase()}: ${textFromContent(message.content)}`;
+    }).join("\n\n");
+    return [
+        "You are running inside OpenCode and can either call tools or answer directly.",
+        "Return exactly one JSON object and no prose.",
+        "To call tools: {\"action\":\"tool_call\",\"tool_calls\":[{\"name\":\"tool_name\",\"arguments\":{}}]}",
+        "To answer: {\"action\":\"final\",\"content\":\"...\"}",
+        "",
+        "Available tools:",
+        tools,
+        "",
+        "Conversation:",
+        conversation,
+    ].join("\n");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function toolCallFromRecord(value) {
+    if (!isRecord(value) || typeof value.name !== "string")
+        return null;
+    return { name: value.name, arguments: value.arguments ?? {} };
+}
+function toolCallsFromArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map(toolCallFromRecord).filter((toolCall) => Boolean(toolCall));
+}
+function parseToolArguments(value) {
+    if (typeof value !== "string")
+        return value ?? {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function stringifyToolArguments(value) {
+    return typeof value === "string" ? value : JSON.stringify(value ?? {});
+}
+function parseToolPlan(output) {
+    const jsonLines = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("{") && line.endsWith("}"));
+    if (jsonLines.length > 1) {
+        const toolCalls = [];
+        for (const line of jsonLines) {
+            try {
+                const toolCall = toolCallFromRecord(JSON.parse(line));
+                if (toolCall)
+                    toolCalls.push({ name: toolCall.name, arguments: parseToolArguments(toolCall.arguments) });
+            }
+            catch {
+                return null;
+            }
+        }
+        if (toolCalls.length > 0)
+            return { action: "tool_call", tool_calls: toolCalls };
+    }
+    const start = output.indexOf("{");
+    const end = output.lastIndexOf("}");
+    if (start === -1 || end <= start)
+        return null;
+    try {
+        const parsed = JSON.parse(output.slice(start, end + 1));
+        if (isRecord(parsed) && parsed.action === "final" && typeof parsed.content === "string") {
+            return { action: "final", content: parsed.content };
+        }
+        const directToolCall = toolCallFromRecord(parsed);
+        if (directToolCall) {
+            return {
+                action: "tool_call",
+                tool_calls: [{ name: directToolCall.name, arguments: parseToolArguments(directToolCall.arguments) }],
+            };
+        }
+        if (isRecord(parsed) && Array.isArray(parsed.tool_calls)) {
+            const toolCalls = toolCallsFromArray(parsed.tool_calls)
+                .map((tool) => ({ name: tool.name, arguments: parseToolArguments(tool.arguments) }));
+            if (toolCalls.length > 0)
+                return { action: "tool_call", tool_calls: toolCalls };
+        }
+        if (isRecord(parsed) && parsed.action === "tool_call" && Array.isArray(parsed.tool_calls)) {
+            const toolCalls = toolCallsFromArray(parsed.tool_calls)
+                .map((tool) => ({ name: tool.name, arguments: parseToolArguments(tool.arguments) }));
+            if (toolCalls.length > 0)
+                return { action: "tool_call", tool_calls: toolCalls };
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+async function handleToolPlanning(request) {
+    const content = await collectTransport({
+        model: request.model,
+        messages: [{ role: "user", content: buildToolPrompt(request) }],
+        stream: false,
+    });
+    const plan = parseToolPlan(content);
+    const id = completionId();
+    const created = Math.floor(Date.now() / 1000);
+    const model = request.model ?? getDevinModels()[0].id;
+    if (plan?.action === "tool_call" && plan.tool_calls.length > 0) {
+        const toolCalls = plan.tool_calls.map((tool, index) => ({
+            id: `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}_${index}`,
+            type: "function",
+            function: {
+                name: tool.name,
+                arguments: stringifyToolArguments(tool.arguments),
+            },
+        }));
+        if (request.stream !== false) {
+            const streamToolCalls = toolCalls.map((toolCall, index) => ({ index, ...toolCall }));
+            return createStreamingResponse(id, created, model, async function* () {
+                yield { toolCalls: streamToolCalls, finishReason: "tool_calls" };
+            });
+        }
+        return jsonResponse({
+            id,
+            object: "chat.completion",
+            created,
+            model,
+            choices: [
+                {
+                    index: 0,
+                    message: { role: "assistant", content: "", tool_calls: toolCalls },
+                    finish_reason: "tool_calls",
+                },
+            ],
+        });
+    }
+    const finalContent = plan?.action === "final" ? plan.content : content;
+    if (request.stream !== false) {
+        return createStreamingResponse(id, created, model, async function* () {
+            yield { content: finalContent };
+        });
+    }
+    return jsonResponse({
+        id,
+        object: "chat.completion",
+        created,
+        model,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: finalContent },
+                finish_reason: "stop",
+            },
+        ],
+    });
+}
+export { buildDevinProviderModels };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "devin-oauth-opencode",
+  "version": "0.2.0",
+  "description": "OpenCode plugin for Devin browser auth and cloud model access.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "devin-oauth-opencode": "bin/setup.js"
+  },
+  "files": [
+    "dist",
+    "bin/setup.js",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && bun build ./bin/setup.ts --target=node --format=esm --outfile=bin/setup.js --external=jsonc-parser",
+    "bench": "bun scripts/bench.ts",
+    "test": "bun test/smoke.ts",
+    "test:live": "bun test/live.ts",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaredboynton/devin-oauth-opencode.git"
+  },
+  "homepage": "https://github.com/jaredboynton/devin-oauth-opencode#readme",
+  "bugs": {
+    "url": "https://github.com/jaredboynton/devin-oauth-opencode/issues"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "devin",
+    "oauth",
+    "openai-compatible"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.27",
+    "jsonc-parser": "^3.3.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "typescript": "^5.9.3"
+  }
+}