npm - @ex-machina/opencode-anthropic-auth - Versions diffs - 0.2.0 → 1.0.0 - Mend

@ex-machina/opencode-anthropic-auth 0.2.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -14,7 +14,7 @@ Add the plugin to your OpenCode configuration:
 ```json
 {
-  "plugins": ["@ex-machina/opencode-anthropic-auth"]
+  "plugin": ["@ex-machina/opencode-anthropic-auth"]
 }
 ```

package/dist/auth.d.ts CHANGED Viewed

@@ -1,8 +1,8 @@
-type AuthorizationResult = {
+export type AuthorizationResult = {
     url: string;
     redirectUri: string;
     state: string;
-    callback: () => Promise<ExchangeResult>;
+    verifier: string;
 };
 export declare function authorize(mode: 'max' | 'console'): Promise<AuthorizationResult>;
 export type ExchangeResult = {
@@ -14,4 +14,3 @@ export type ExchangeResult = {
     type: 'failed';
 };
 export declare function exchange(input: string, verifier: string, redirectUri: string, expectedState?: string): Promise<ExchangeResult>;
-export {};

package/dist/auth.js CHANGED Viewed

@@ -1,26 +1,5 @@
-import { createServer } from 'node:http';
 import { generatePKCE } from '@openauthjs/openauth/pkce';
-import { AUTHORIZE_URLS, CLIENT_ID, OAUTH_SCOPES, TOKEN_URL } from './constants';
-const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
-async function listen(server) {
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => resolve());
-    });
-}
-async function close(server) {
-    if (!server.listening)
-        return;
-    await new Promise((resolve, reject) => {
-        server.close((error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
+import { AUTHORIZE_URLS, CLIENT_ID, CODE_CALLBACK_URL, OAUTH_SCOPES, TOKEN_URL, } from './constants';
 function generateState() {
     return crypto.randomUUID().replace(/-/g, '');
 }
@@ -49,19 +28,6 @@ function parseCallbackInput(input) {
     }
     return null;
 }
-function successPage() {
-    return `<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>Authorization complete</title>
-  </head>
-  <body>
-    <h1>Authorization complete</h1>
-    <p>You can close this window and return to OpenCode.</p>
-  </body>
-</html>`;
-}
 async function exchangeCode(callback, verifier, redirectUri) {
     const result = await fetch(TOKEN_URL, {
         method: 'POST',
@@ -92,98 +58,23 @@ async function exchangeCode(callback, verifier, redirectUri) {
         expires: Date.now() + json.expires_in * 1000,
     };
 }
-async function createCallbackServer(expectedState) {
-    let settled = false;
-    let cleanupTimer;
-    let resolveResult;
-    let rejectResult;
-    const server = createServer((req, res) => {
-        const requestUrl = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
-        if (requestUrl.pathname !== '/callback') {
-            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end('Not found');
-            return;
-        }
-        const code = requestUrl.searchParams.get('code');
-        const state = requestUrl.searchParams.get('state');
-        if (!code || !state) {
-            res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end('Missing code or state');
-            return;
-        }
-        if (state !== expectedState) {
-            res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end('Invalid state');
-            if (!settled) {
-                settled = true;
-                rejectResult?.(new Error('OAuth state mismatch'));
-            }
-            return;
-        }
-        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(successPage());
-        if (!settled) {
-            settled = true;
-            resolveResult?.(requestUrl.toString());
-        }
-    });
-    const callbackUrl = new Promise((resolve, reject) => {
-        resolveResult = resolve;
-        rejectResult = reject;
-    });
-    await listen(server);
-    cleanupTimer = setTimeout(() => {
-        if (settled)
-            return;
-        settled = true;
-        rejectResult?.(new Error('Timed out waiting for OAuth callback'));
-    }, CALLBACK_TIMEOUT_MS);
-    const address = server.address();
-    if (!address || typeof address === 'string') {
-        clearTimeout(cleanupTimer);
-        await close(server);
-        throw new Error('Failed to allocate localhost redirect port');
-    }
-    return {
-        redirectUri: `http://localhost:${address.port}/callback`,
-        waitForCallback: async () => {
-            try {
-                return await callbackUrl;
-            }
-            finally {
-                if (cleanupTimer)
-                    clearTimeout(cleanupTimer);
-                await close(server);
-            }
-        },
-    };
-}
 export async function authorize(mode) {
     const pkce = await generatePKCE();
     const state = generateState();
-    const callbackServer = await createCallbackServer(state);
     const url = new URL(AUTHORIZE_URLS[mode], import.meta.url);
     url.searchParams.set('code', 'true');
     url.searchParams.set('client_id', CLIENT_ID);
     url.searchParams.set('response_type', 'code');
-    url.searchParams.set('redirect_uri', callbackServer.redirectUri);
+    url.searchParams.set('redirect_uri', CODE_CALLBACK_URL);
     url.searchParams.set('scope', OAUTH_SCOPES.join(' '));
     url.searchParams.set('code_challenge', pkce.challenge);
     url.searchParams.set('code_challenge_method', 'S256');
     url.searchParams.set('state', state);
     return {
         url: url.toString(),
-        redirectUri: callbackServer.redirectUri,
+        redirectUri: CODE_CALLBACK_URL,
         state,
-        callback: async () => {
-            try {
-                const callbackUrl = await callbackServer.waitForCallback();
-                return await exchange(callbackUrl, pkce.verifier, callbackServer.redirectUri, state);
-            }
-            catch {
-                return { type: 'failed' };
-            }
-        },
+        verifier: pkce.verifier,
     };
 }
 export async function exchange(input, verifier, redirectUri, expectedState) {

package/dist/constants.d.ts CHANGED Viewed

@@ -3,6 +3,7 @@ export declare const AUTHORIZE_URLS: {
     readonly console: "https://platform.claude.com/oauth/authorize";
     readonly max: "https://claude.ai/oauth/authorize";
 };
+export declare const CODE_CALLBACK_URL = "https://platform.claude.com/oauth/code/callback";
 export declare const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
 export declare const OAUTH_SCOPES: string[];
 export declare const TOOL_PREFIX = "mcp_";

package/dist/constants.js CHANGED Viewed

@@ -3,6 +3,7 @@ export const AUTHORIZE_URLS = {
     console: 'https://platform.claude.com/oauth/authorize',
     max: 'https://claude.ai/oauth/authorize',
 };
+export const CODE_CALLBACK_URL = 'https://platform.claude.com/oauth/code/callback';
 export const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
 export const OAUTH_SCOPES = [
     'org:create_api_key',

package/dist/index.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { authorize } from './auth';
+import { authorize, exchange } from './auth';
 import { CLIENT_ID, TOKEN_URL } from './constants';
 import { createStrippedStream, mergeHeaders, prefixToolNames, rewriteUrl, setOAuthHeaders, } from './transform';
 export const AnthropicAuthPlugin = async ({ client }) => {
@@ -120,9 +120,11 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                         const result = await authorize('max');
                         return {
                             url: result.url,
-                            instructions: 'Complete authorization in the browser.',
-                            method: 'auto',
-                            callback: result.callback,
+                            instructions: 'Paste the authorization code here:',
+                            method: 'code',
+                            callback: async (code) => {
+                                return exchange(code, result.verifier, result.redirectUri, result.state);
+                            },
                         };
                     },
                 },
@@ -130,23 +132,23 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                     label: 'Create an API Key',
                     type: 'oauth',
                     authorize: async () => {
-                        const auth = await authorize('console');
+                        const result = await authorize('console');
                         return {
-                            url: auth.url,
-                            instructions: 'Complete authorization in the browser.',
-                            method: 'auto',
-                            callback: async () => {
-                                const credentials = await auth.callback();
+                            url: result.url,
+                            instructions: 'Paste the authorization code here:',
+                            method: 'code',
+                            callback: async (code) => {
+                                const credentials = await exchange(code, result.verifier, result.redirectUri, result.state);
                                 if (credentials.type === 'failed')
                                     return credentials;
-                                const result = await fetch(`https://api.anthropic.com/api/oauth/claude_cli/create_api_key`, {
+                                const apiKey = await fetch(`https://api.anthropic.com/api/oauth/claude_cli/create_api_key`, {
                                     method: 'POST',
                                     headers: {
                                         'Content-Type': 'application/json',
                                         authorization: `Bearer ${credentials.access}`,
                                     },
                                 }).then((r) => r.json());
-                                return { type: 'success', key: result.raw_key };
+                                return { type: 'success', key: apiKey.raw_key };
                             },
                         };
                     },

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ex-machina/opencode-anthropic-auth",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [