devin-oauth-opencode 0.2.0

package/README.md

@@ -0,0 +1,12 @@
+# devin-oauth-opencode
+
+OpenCode plugin for Devin browser auth and cloud model access through a local OpenAI-compatible proxy.
+
+## Install
+
+```sh
+npx devin-oauth-opencode setup --global
+opencode auth login --provider devin
+```
+
+The setup command patches OpenCode config so the `devin` provider is visible. Login stores auth through OpenCode, and model requests are routed through a local proxy to Devin's cloud transport.

package/bin/setup.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+// bin/setup.ts
+import { realpathSync } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { applyEdits, format, modify, parse } from "jsonc-parser";
+var DEFAULT_PLUGIN_SPEC = "devin-oauth-opencode@latest";
+var PACKAGE_NAME = "devin-oauth-opencode";
+var SCHEMA = "https://opencode.ai/config.json";
+var PROVIDER_ID = "devin";
+var PROVIDER_API = "http://127.0.0.1:65534/v1";
+var PROVIDER_NPM = "@ai-sdk/openai-compatible";
+var DEVIN_MODELS = {
+  "glm-5-2": {
+    name: "GLM-5.2 High",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, input: 200000, output: 64000 }
+  },
+  "swe-1.6-fast": {
+    name: "SWE 1.6 Fast",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, input: 200000, output: 64000 }
+  },
+  "swe-1.6": {
+    name: "SWE 1.6",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, input: 200000, output: 64000 }
+  },
+  "swe-1.5-fast": {
+    name: "SWE 1.5 Fast",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, input: 200000, output: 64000 }
+  }
+};
+var GENERATED_MODEL_KEYS = new Set([
+  "name",
+  "reasoning",
+  "temperature",
+  "attachment",
+  "tool_call",
+  "limit"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeGeneratedModelOverride(override) {
+  if (!isRecord(override))
+    return {};
+  const sanitized = { ...override };
+  for (const key of GENERATED_MODEL_KEYS)
+    delete sanitized[key];
+  return sanitized;
+}
+function providerModelsWithRepairs(existingModels) {
+  const models = {};
+  for (const [id, model] of Object.entries(DEVIN_MODELS)) {
+    models[id] = {
+      ...model,
+      ...sanitizeGeneratedModelOverride(existingModels[id])
+    };
+  }
+  for (const [id, model] of Object.entries(existingModels)) {
+    if (id in DEVIN_MODELS)
+      continue;
+    models[id] = model;
+  }
+  return models;
+}
+function globalConfigPath() {
+  const configHome = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(configHome, "opencode", "opencode.json");
+}
+function projectConfigPath(cwd) {
+  return path.join(cwd, "opencode.json");
+}
+function targetPath(options) {
+  if (options.configPath)
+    return path.resolve(options.configPath);
+  if (options.mode === "project")
+    return projectConfigPath(options.cwd ?? process.cwd());
+  return globalConfigPath();
+}
+function applyJsonPatch(text, jsonPath, value) {
+  return applyEdits(text, modify(text, jsonPath, value, {
+    formattingOptions: { insertSpaces: true, tabSize: 2, eol: `
+` }
+  }));
+}
+function pluginPackageName(specifier) {
+  const normalized = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
+  if (normalized.startsWith("file://")) {
+    return path.basename(new URL(normalized).pathname).replace(/\.[cm]?[jt]s$/, "");
+  }
+  const lastAt = normalized.lastIndexOf("@");
+  return lastAt > 0 ? normalized.slice(0, lastAt) : normalized;
+}
+function patchConfigText(input, pluginSpec = DEFAULT_PLUGIN_SPEC) {
+  let text = input.trim() ? input : "{}";
+  const initial = parse(text) ?? {};
+  if (!initial.$schema)
+    text = applyJsonPatch(text, ["$schema"], SCHEMA);
+  const currentPlugins = (parse(text) ?? {}).plugin;
+  const plugins = Array.isArray(currentPlugins) ? [...currentPlugins] : [];
+  if (!plugins.some((plugin) => typeof plugin === "string" && pluginPackageName(plugin) === PACKAGE_NAME)) {
+    plugins.push(pluginSpec);
+  }
+  text = applyJsonPatch(text, ["plugin"], plugins);
+  const next = parse(text) ?? {};
+  const existingProvider = next.provider?.[PROVIDER_ID] ?? {};
+  const existingModels = existingProvider.models ?? {};
+  text = applyJsonPatch(text, ["provider", PROVIDER_ID], {
+    ...existingProvider,
+    name: existingProvider.name ?? "Devin",
+    npm: existingProvider.npm ?? PROVIDER_NPM,
+    api: existingProvider.api ?? PROVIDER_API,
+    models: providerModelsWithRepairs(existingModels)
+  });
+  return applyEdits(text, format(text, undefined, {
+    insertSpaces: true,
+    tabSize: 2,
+    eol: `
+`
+  }));
+}
+async function setupOpenCodeConfig(options = {}) {
+  const file = targetPath(options);
+  let existing = "";
+  try {
+    existing = await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw error;
+  }
+  const updated = patchConfigText(existing, options.pluginSpec ?? DEFAULT_PLUGIN_SPEC);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, updated.endsWith(`
+`) ? updated : `${updated}
+`, "utf8");
+  return file;
+}
+function parseArgs(argv) {
+  const options = { mode: "global" };
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "setup")
+      continue;
+    if (arg === "--project")
+      options.mode = "project";
+    else if (arg === "--global")
+      options.mode = "global";
+    else if (arg === "--path")
+      options.configPath = argv[++index];
+    else if (arg === "--plugin")
+      options.pluginSpec = argv[++index];
+    else if (arg === "--help" || arg === "-h") {
+      console.log("Usage: devin-oauth-opencode setup [--global|--project] [--path <opencode.json>] [--plugin <specifier>]");
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function isDirectExecution(moduleUrl = import.meta.url, argvPath = process.argv[1]) {
+  if (!argvPath)
+    return false;
+  const modulePath = fileURLToPath(moduleUrl);
+  try {
+    return realpathSync(modulePath) === realpathSync(argvPath);
+  } catch {
+    return path.resolve(modulePath) === path.resolve(argvPath);
+  }
+}
+if (isDirectExecution()) {
+  setupOpenCodeConfig(parseArgs(process.argv.slice(2))).then((file) => {
+    console.log(`Updated OpenCode config: ${file}`);
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  setupOpenCodeConfig,
+  patchConfigText,
+  isDirectExecution
+};

package/dist/auth.d.ts

@@ -0,0 +1,17 @@
+export declare enum DevinErrorCode {
+    ApiKeyMissing = "API_KEY_MISSING",
+    ConnectionFailed = "CONNECTION_FAILED",
+    StreamError = "STREAM_ERROR"
+}
+export declare class DevinError extends Error {
+    readonly code: DevinErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: DevinErrorCode, details?: unknown | undefined);
+}
+export declare function setDevinApiKeyForSession(apiKey?: string): void;
+export declare function getApiKey(): string;
+export declare function hasSessionOrEnvApiKey(): boolean;
+export declare function getDevinVersion(): string;
+export declare function getLatestDevinVersion(fetchImpl?: typeof fetch, options?: {
+    timeoutMs?: number;
+}): Promise<string>;

package/dist/auth.js

@@ -0,0 +1,88 @@
+export var DevinErrorCode;
+(function (DevinErrorCode) {
+    DevinErrorCode["ApiKeyMissing"] = "API_KEY_MISSING";
+    DevinErrorCode["ConnectionFailed"] = "CONNECTION_FAILED";
+    DevinErrorCode["StreamError"] = "STREAM_ERROR";
+})(DevinErrorCode || (DevinErrorCode = {}));
+export class DevinError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "DevinError";
+    }
+}
+const DEFAULT_DEVIN_VERSION = "3000.1.23";
+const DEVIN_CLI_MANIFEST_URL = "https://static.devin.ai/cli/current/manifest.json";
+let sessionApiKeyOverride;
+let cachedLatestDevinVersion;
+let latestVersionPromise;
+export function setDevinApiKeyForSession(apiKey) {
+    sessionApiKeyOverride = apiKey?.trim() || undefined;
+}
+export function getApiKey() {
+    if (sessionApiKeyOverride) {
+        return sessionApiKeyOverride;
+    }
+    if (process.env.DEVIN_API_KEY?.trim()) {
+        return process.env.DEVIN_API_KEY.trim();
+    }
+    throw new DevinError("Devin API key not found. Run `opencode auth login --provider devin` or set DEVIN_API_KEY.", DevinErrorCode.ApiKeyMissing);
+}
+export function hasSessionOrEnvApiKey() {
+    return Boolean(sessionApiKeyOverride || process.env.DEVIN_API_KEY?.trim());
+}
+export function getDevinVersion() {
+    return DEFAULT_DEVIN_VERSION;
+}
+function parseVersionFromManifest(value) {
+    try {
+        const version = JSON.parse(value).version;
+        return typeof version === "string" && /^\d+\.\d+\.\d+/.test(version.trim())
+            ? version.trim()
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function getLatestDevinVersion(fetchImpl = fetch, options = {}) {
+    const shouldCache = fetchImpl === fetch;
+    if (shouldCache && cachedLatestDevinVersion)
+        return cachedLatestDevinVersion;
+    if (fetchImpl === fetch && latestVersionPromise)
+        return latestVersionPromise;
+    const resolveVersion = async () => {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 1_500);
+        try {
+            const response = await fetchImpl(DEVIN_CLI_MANIFEST_URL, {
+                signal: controller.signal,
+            });
+            if (response.ok) {
+                const version = parseVersionFromManifest(await response.text());
+                if (version) {
+                    if (shouldCache)
+                        cachedLatestDevinVersion = version;
+                    return version;
+                }
+            }
+        }
+        catch {
+            // Use the known-compatible version if the manifest is unavailable.
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        return getDevinVersion();
+    };
+    if (fetchImpl !== fetch) {
+        return resolveVersion();
+    }
+    latestVersionPromise = resolveVersion().finally(() => {
+        latestVersionPromise = undefined;
+    });
+    return latestVersionPromise;
+}

package/dist/browser-auth.d.ts

@@ -0,0 +1,34 @@
+export interface DevinBrowserAuth {
+    apiKey: string;
+    name?: string;
+    email?: string;
+}
+export interface BrowserLoginOptions {
+    state?: string;
+    loginHint?: string;
+}
+export interface DevinLoopbackAuth {
+    url: string;
+    verifier: string;
+    state: string;
+    waitForCode(): Promise<string>;
+}
+type FetchLike = typeof fetch;
+export declare function createPkcePair(): {
+    verifier: string;
+    challenge: string;
+};
+export declare function buildDevinContinueUrl(options: BrowserLoginOptions & {
+    redirectUri: string;
+    challenge: string;
+    state: string;
+}): string;
+declare function extractCode(params: URLSearchParams): string;
+export declare function startDevinLoopbackAuth(options?: BrowserLoginOptions): DevinLoopbackAuth;
+export declare function exchangeDevinCode(code: string, verifier: string, fetchImpl?: FetchLike): Promise<DevinBrowserAuth>;
+export declare const __test: {
+    buildDevinContinueUrl: typeof buildDevinContinueUrl;
+    createPkcePair: typeof createPkcePair;
+    extractCode: typeof extractCode;
+};
+export {};

package/dist/browser-auth.js

@@ -0,0 +1,126 @@
+import crypto from "node:crypto";
+const DEVIN_CONTINUE_URL = "https://app.devin.ai/auth/cli/continue";
+const DEVIN_TOKEN_URL = "https://api.devin.ai/auth/cli/token";
+const DEVIN_SESSION_TOKEN_PREFIX = "devin-session-token$";
+const LOOPBACK_HOST = "127.0.0.1";
+const LOOPBACK_TIMEOUT_MS = 120_000;
+function base64Url(buffer) {
+    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+export function createPkcePair() {
+    const verifier = base64Url(crypto.randomBytes(32));
+    const challenge = base64Url(crypto.createHash("sha256").update(verifier).digest());
+    return { verifier, challenge };
+}
+export function buildDevinContinueUrl(options) {
+    const url = new URL(DEVIN_CONTINUE_URL);
+    url.searchParams.set("redirect_uri", options.redirectUri);
+    url.searchParams.set("state", options.state);
+    url.searchParams.set("prompt", "select_account");
+    url.searchParams.set("code_challenge", options.challenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("cli_pkce_marker", "1");
+    if (options.loginHint?.trim()) {
+        url.searchParams.set("login_hint", options.loginHint.trim());
+    }
+    return url.toString();
+}
+function extractCode(params) {
+    return (params.get("code") ?? params.get("authorization_code") ?? "").trim();
+}
+export function startDevinLoopbackAuth(options = {}) {
+    const { verifier, challenge } = createPkcePair();
+    const state = options.state ?? crypto.randomUUID();
+    let resolveCode;
+    let rejectCode;
+    let settled = false;
+    const codePromise = new Promise((resolve, reject) => {
+        resolveCode = resolve;
+        rejectCode = reject;
+    });
+    const server = Bun.serve({
+        hostname: LOOPBACK_HOST,
+        port: 0,
+        fetch(req) {
+            const url = new URL(req.url);
+            if (url.pathname === "/callback-token") {
+                const code = extractCode(url.searchParams);
+                if (!settled) {
+                    settled = true;
+                    if (code)
+                        resolveCode(code);
+                    else
+                        rejectCode(new Error("Devin callback did not include an authorization code"));
+                }
+                return new Response("OK", { headers: { "content-type": "text/plain" } });
+            }
+            if (url.pathname === "/callback") {
+                const code = extractCode(url.searchParams);
+                if (code) {
+                    if (!settled) {
+                        settled = true;
+                        resolveCode(code);
+                    }
+                    return new Response("Devin authentication complete. You can close this tab.", {
+                        headers: { "content-type": "text/plain" },
+                    });
+                }
+                return new Response(`<!doctype html>
+<html><body>
+<p>Devin authentication complete. You can close this tab.</p>
+<script>
+const params = new URLSearchParams(location.hash.slice(1));
+fetch('/callback-token?' + params.toString()).catch(() => {});
+</script>
+</body></html>`, { headers: { "content-type": "text/html" } });
+            }
+            return new Response("Not found", { status: 404 });
+        },
+    });
+    const timeout = setTimeout(() => {
+        if (!settled) {
+            settled = true;
+            rejectCode(new Error("Devin authentication timed out"));
+        }
+    }, LOOPBACK_TIMEOUT_MS);
+    const redirectUri = `http://${LOOPBACK_HOST}:${server.port}/callback`;
+    return {
+        url: buildDevinContinueUrl({ ...options, redirectUri, challenge, state }),
+        verifier,
+        state,
+        async waitForCode() {
+            try {
+                return await codePromise;
+            }
+            finally {
+                clearTimeout(timeout);
+                setTimeout(() => server.stop(true), 100);
+            }
+        },
+    };
+}
+export async function exchangeDevinCode(code, verifier, fetchImpl = fetch) {
+    const trimmedCode = code.trim();
+    if (!trimmedCode) {
+        throw new Error("Devin authorization code is required");
+    }
+    const response = await fetchImpl(DEVIN_TOKEN_URL, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ code: trimmedCode, code_verifier: verifier }),
+    });
+    if (!response.ok) {
+        throw new Error(`Devin token exchange failed with HTTP ${response.status}`);
+    }
+    const payload = (await response.json());
+    const token = payload.token?.trim();
+    if (!token) {
+        throw new Error("Devin token exchange response did not include a token");
+    }
+    return { apiKey: `${DEVIN_SESSION_TOKEN_PREFIX}${token}` };
+}
+export const __test = {
+    buildDevinContinueUrl,
+    createPkcePair,
+    extractCode,
+};

package/dist/cloud.d.ts

@@ -0,0 +1,21 @@
+import type { ChatCompletionRequest } from "./devin";
+declare function parseFields(buffer: Buffer): Array<{
+    fieldNum: number;
+    wireType: number;
+    value: bigint | Buffer;
+}>;
+declare function parseConnectEnvelopes(buffer: Buffer): Array<{
+    flags: number;
+    body: Buffer;
+}>;
+export declare function closeDevinCloudConnection(): void;
+export declare function warmDevinCloudConnection(): Promise<void>;
+declare function buildGetChatMessageRequest(request: ChatCompletionRequest, apiKey: string, version: string): Buffer;
+export declare function streamDevinCloudChat(request: ChatCompletionRequest): AsyncGenerator<string, void, unknown>;
+export declare function collectDevinCloudChat(request: ChatCompletionRequest): Promise<string>;
+export declare const __test: {
+    buildGetChatMessageRequest: typeof buildGetChatMessageRequest;
+    parseFields: typeof parseFields;
+    parseConnectEnvelopes: typeof parseConnectEnvelopes;
+};
+export {};