@ai-ide-bridge/cli 1.0.5 → 1.1.1

package/dist/oauth/flow.d.ts

@@ -0,0 +1,11 @@
+import type { OAuthConfig, StoredToken, TokenStore } from './types.js';
+export declare class OAuthFlow {
+    private config;
+    private store;
+    private pkceState;
+    constructor(config: OAuthConfig, store: TokenStore);
+    start(): Promise<string>;
+    callback(code: string, state: string): Promise<StoredToken>;
+    private generateCodeVerifier;
+    private generateCodeChallenge;
+}

package/dist/oauth/flow.js

@@ -0,0 +1,75 @@
+import { randomBytes, createHash } from 'node:crypto';
+const DEFAULT_TOKEN_EXPIRY_MS = 3600000;
+export class OAuthFlow {
+    config;
+    store;
+    pkceState = null;
+    constructor(config, store) {
+        this.config = config;
+        this.store = store;
+    }
+    async start() {
+        const codeVerifier = this.generateCodeVerifier();
+        const codeChallenge = this.generateCodeChallenge(codeVerifier);
+        const state = randomBytes(16).toString('hex');
+        this.pkceState = { codeVerifier, codeChallenge, state };
+        const params = new URLSearchParams({
+            response_type: 'code',
+            client_id: this.config.provider.clientId,
+            scope: this.config.provider.scopes.join(' '),
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256',
+            state,
+        });
+        if (this.config.redirectUri) {
+            params.set('redirect_uri', this.config.redirectUri);
+        }
+        return `${this.config.provider.authUrl}?${params.toString()}`;
+    }
+    async callback(code, state) {
+        if (!this.pkceState) {
+            throw new Error('No pending PKCE state');
+        }
+        if (state !== this.pkceState.state) {
+            throw new Error('State mismatch');
+        }
+        const { codeVerifier } = this.pkceState;
+        this.pkceState = null;
+        const params = new URLSearchParams({
+            grant_type: 'authorization_code',
+            code,
+            code_verifier: codeVerifier,
+            client_id: this.config.provider.clientId,
+        });
+        if (this.config.redirectUri) {
+            params.set('redirect_uri', this.config.redirectUri);
+        }
+        const response = await fetch(this.config.provider.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Token exchange failed: ${response.status} ${body}`);
+        }
+        const data = (await response.json());
+        const newToken = {
+            version: 1,
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            expiresAt: data.expires_in
+                ? Date.now() + data.expires_in * 1000
+                : Date.now() + DEFAULT_TOKEN_EXPIRY_MS,
+            scopes: this.config.provider.scopes,
+        };
+        await this.store.set(this.config.provider.id, newToken);
+        return newToken;
+    }
+    generateCodeVerifier() {
+        return randomBytes(32).toString('base64url');
+    }
+    generateCodeChallenge(verifier) {
+        return createHash('sha256').update(verifier).digest('base64url');
+    }
+}

package/dist/oauth/index.d.ts

@@ -0,0 +1,6 @@
+export type { OAuthProvider, TokenStore, StoredToken, OAuthConfig } from './types.js';
+export { createTokenStore } from './storage.js';
+export { OAuthFlow } from './flow.js';
+export { DeviceFlow } from './device-flow.js';
+export { TokenLifecycle, type TokenLifecycleOptions } from './lifecycle.js';
+export { providers } from './providers.js';

package/dist/oauth/index.js

@@ -0,0 +1,5 @@
+export { createTokenStore } from './storage.js';
+export { OAuthFlow } from './flow.js';
+export { DeviceFlow } from './device-flow.js';
+export { TokenLifecycle } from './lifecycle.js';
+export { providers } from './providers.js';

package/dist/oauth/lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { OAuthConfig, StoredToken, TokenStore } from './types.js';
+export interface TokenLifecycleOptions {
+    gracePeriodMs?: number;
+    config?: OAuthConfig;
+}
+export declare class TokenLifecycle {
+    private store;
+    private gracePeriodMs;
+    private config?;
+    constructor(store: TokenStore, options?: TokenLifecycleOptions);
+    isValid(provider: string): Promise<boolean>;
+    refresh(provider: string): Promise<StoredToken>;
+}

package/dist/oauth/lifecycle.js

@@ -0,0 +1,56 @@
+export class TokenLifecycle {
+    store;
+    gracePeriodMs;
+    config;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.gracePeriodMs = options.gracePeriodMs ?? 0;
+        this.config = options.config;
+    }
+    async isValid(provider) {
+        const token = await this.store.get(provider);
+        if (!token)
+            return false;
+        const expiresAt = token.expiresAt - this.gracePeriodMs;
+        return Date.now() < expiresAt;
+    }
+    async refresh(provider) {
+        const token = await this.store.get(provider);
+        if (!token?.refreshToken) {
+            throw new Error('No refresh token available');
+        }
+        if (!this.config) {
+            throw new Error('OAuthConfig required for token refresh');
+        }
+        const params = new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: token.refreshToken,
+            client_id: this.config.provider.clientId,
+        });
+        const response = await fetch(this.config.provider.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Token refresh failed: ${response.status} ${body}`);
+        }
+        const data = (await response.json());
+        if (!data.access_token) {
+            throw new Error('Invalid token response: missing access_token');
+        }
+        const newToken = {
+            version: 1,
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token ?? token.refreshToken,
+            expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+            scopes: token.scopes,
+        };
+        await this.store.set(provider, newToken);
+        if (this.config.onRefresh) {
+            await this.config.onRefresh(newToken);
+        }
+        return newToken;
+    }
+}

package/dist/oauth/providers.d.ts

@@ -0,0 +1,2 @@
+import type { OAuthProvider } from './types.js';
+export declare const providers: Record<string, OAuthProvider>;

package/dist/oauth/providers.js

@@ -0,0 +1,19 @@
+export const providers = {
+    copilot: {
+        id: 'copilot',
+        name: 'GitHub Copilot',
+        authUrl: 'https://github.com/login/oauth/authorize',
+        tokenUrl: 'https://github.com/login/oauth/access_token',
+        scopes: ['read:user', 'copilot'],
+        clientId: 'Iv1.2a8e2d1e0e8b4f3a',
+        deviceFlow: true,
+    },
+    cursor: {
+        id: 'cursor',
+        name: 'Cursor',
+        authUrl: 'https://authenticator.cursor.sh/oauth/authorize',
+        tokenUrl: 'https://authenticator.cursor.sh/oauth/token',
+        scopes: ['openid', 'profile', 'email'],
+        clientId: 'cursor-oauth-client',
+    },
+};

package/dist/oauth/storage-file.d.ts

@@ -0,0 +1,2 @@
+import type { TokenStore } from './types.js';
+export declare function createFileStore(): TokenStore;

package/dist/oauth/storage-file.js

@@ -0,0 +1,68 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+const ALGORITHM = 'aes-256-cbc';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+function getEncryptionKey() {
+    const machineId = [process.platform, hostname(), homedir()].join(':');
+    return scryptSync(machineId, 'llm-bridge-oauth', KEY_LENGTH);
+}
+function getTokenFilePath() {
+    const dir = join(homedir(), '.config', 'llm-bridge');
+    mkdirSync(dir, { recursive: true });
+    return join(dir, 'tokens.enc');
+}
+function encrypt(data) {
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, getEncryptionKey(), iv);
+    let encrypted = cipher.update(data, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+}
+function decrypt(encryptedData) {
+    const [ivHex, encrypted] = encryptedData.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const decipher = createDecipheriv(ALGORITHM, getEncryptionKey(), iv);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+export function createFileStore() {
+    return {
+        async set(provider, token) {
+            const file = getTokenFilePath();
+            const existing = existsSync(file)
+                ? JSON.parse(decrypt(readFileSync(file, 'utf8')))
+                : {};
+            existing[provider] = token;
+            writeFileSync(file, encrypt(JSON.stringify(existing)));
+        },
+        async get(provider) {
+            const file = getTokenFilePath();
+            if (!existsSync(file))
+                return null;
+            try {
+                const existing = JSON.parse(decrypt(readFileSync(file, 'utf8')));
+                return existing[provider] ?? null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async delete(provider) {
+            const file = getTokenFilePath();
+            if (!existsSync(file))
+                return;
+            try {
+                const existing = JSON.parse(decrypt(readFileSync(file, 'utf8')));
+                delete existing[provider];
+                writeFileSync(file, encrypt(JSON.stringify(existing)));
+            }
+            catch {
+                // Ignore errors on delete
+            }
+        },
+    };
+}

package/dist/oauth/storage.d.ts

@@ -0,0 +1,2 @@
+import type { TokenStore } from './types.js';
+export declare function createTokenStore(): TokenStore;

package/dist/oauth/storage.js

@@ -0,0 +1,4 @@
+import { createFileStore } from './storage-file.js';
+export function createTokenStore() {
+    return createFileStore();
+}

package/dist/oauth/types.d.ts

@@ -0,0 +1,44 @@
+export interface OAuthProvider {
+    id: string;
+    name: string;
+    authUrl: string;
+    tokenUrl: string;
+    scopes: string[];
+    clientId: string;
+    deviceFlow?: boolean;
+}
+export interface StoredToken {
+    version: 1;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt: number;
+    scopes: string[];
+}
+export interface TokenStore {
+    set(provider: string, token: StoredToken): Promise<void>;
+    get(provider: string): Promise<StoredToken | null>;
+    delete(provider: string): Promise<void>;
+}
+export interface OAuthConfig {
+    provider: OAuthProvider;
+    store: TokenStore;
+    onRefresh?: (newToken: StoredToken) => Promise<void>;
+    redirectUri?: string;
+}
+export interface PKCEState {
+    codeVerifier: string;
+    codeChallenge: string;
+    state: string;
+}
+export interface DeviceCodeResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    expiresIn: number;
+    interval: number;
+}
+export interface RefreshQueueEntry {
+    promise: Promise<StoredToken>;
+    resolve: (token: StoredToken) => void;
+    reject: (error: Error) => void;
+}

package/dist/oauth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/copilot/auth.d.ts

@@ -0,0 +1,7 @@
+import type { CopilotConfig } from './types.js';
+export declare function validateToken(token: string): Promise<boolean>;
+export declare function getToken(config: CopilotConfig): Promise<string | null>;
+export declare function refreshOAuthToken(_refreshToken: string, _clientId: string, _clientSecret: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+} | null>;

package/dist/plugins/copilot/auth.js

@@ -0,0 +1,30 @@
+import { createTokenStore } from '../../oauth/index.js';
+const COPILOT_API_BASE = 'https://api.github.com';
+export async function validateToken(token) {
+    try {
+        const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/v2/token`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/json',
+            },
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getToken(config) {
+    if (config.COPILOT_TOKEN)
+        return config.COPILOT_TOKEN;
+    const store = createTokenStore();
+    const token = await store.get('copilot');
+    if (token && Date.now() < token.expiresAt) {
+        return token.accessToken;
+    }
+    return config.COPILOT_OAUTH_TOKEN ?? null;
+}
+export async function refreshOAuthToken(_refreshToken, _clientId, _clientSecret) {
+    return null;
+}

package/dist/plugins/copilot/index.d.ts

@@ -0,0 +1,5 @@
+export { CopilotBridgePlugin } from './plugin.js';
+export { CopilotBridgeSession } from './session.js';
+export type { CopilotModel, CopilotConfig } from './types.js';
+export { COPILOT_MODELS } from './types.js';
+export { validateToken, getToken } from './auth.js';

package/dist/plugins/copilot/index.js

@@ -0,0 +1,4 @@
+export { CopilotBridgePlugin } from './plugin.js';
+export { CopilotBridgeSession } from './session.js';
+export { COPILOT_MODELS } from './types.js';
+export { validateToken, getToken } from './auth.js';

package/dist/plugins/copilot/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { BridgePlugin, BridgeSession, ModelInfo } from '../../core/index.js';
+export declare class CopilotBridgePlugin implements BridgePlugin {
+    name: string;
+    version: string;
+    authenticate(config: Record<string, string>): Promise<boolean>;
+    listModels(config: Record<string, string>): Promise<ModelInfo[]>;
+    createSession(config: Record<string, string>, model: string): Promise<BridgeSession>;
+}

package/dist/plugins/copilot/plugin.js

@@ -0,0 +1,29 @@
+import { CopilotBridgeSession } from './session.js';
+import { COPILOT_MODELS } from './types.js';
+import { validateToken, getToken } from './auth.js';
+export class CopilotBridgePlugin {
+    name = 'copilot';
+    version = '2.0.0';
+    async authenticate(config) {
+        const token = await getToken(config);
+        if (!token)
+            return false;
+        return validateToken(token);
+    }
+    async listModels(config) {
+        const token = await getToken(config);
+        if (!token)
+            throw new Error('Missing COPILOT_TOKEN');
+        return COPILOT_MODELS.map((m) => ({
+            id: m.id,
+            name: m.name,
+            capabilities: m.capabilities,
+        }));
+    }
+    async createSession(config, model) {
+        const token = await getToken(config);
+        if (!token)
+            throw new Error('Missing COPILOT_TOKEN');
+        return new CopilotBridgeSession(token, model);
+    }
+}

package/dist/plugins/copilot/session.d.ts

@@ -0,0 +1,8 @@
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '../../core/index.js';
+export declare class CopilotBridgeSession implements BridgeSession {
+    private token;
+    private modelId;
+    constructor(token: string, modelId: string);
+    send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk>;
+    dispose(): Promise<void>;
+}

package/dist/plugins/copilot/session.js

@@ -0,0 +1,115 @@
+import { translateTools } from './tools.js';
+const COPILOT_API_BASE = 'https://api.github.com';
+export class CopilotBridgeSession {
+    token;
+    modelId;
+    constructor(token, modelId) {
+        this.token = token;
+        this.modelId = modelId;
+    }
+    async *send(messages, tools) {
+        const body = {
+            model: this.modelId,
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content ?? '',
+                ...(m.tool_calls && { tool_calls: m.tool_calls }),
+                ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+            })),
+            ...(tools && { tools: translateTools(tools) }),
+            stream: true,
+        };
+        try {
+            const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                yield {
+                    type: 'error',
+                    content: `Copilot API error: ${response.status} ${errorText}`,
+                    finishReason: 'error',
+                };
+                return;
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                yield { type: 'error', content: 'No response body', finishReason: 'error' };
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let finished = false;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data:'))
+                        continue;
+                    const data = trimmed.slice(5).trim();
+                    if (data === '[DONE]') {
+                        if (!finished) {
+                            yield { type: 'done', finishReason: 'stop' };
+                        }
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const delta = parsed.choices?.[0]?.delta;
+                        if (delta?.content) {
+                            yield { type: 'text', content: delta.content };
+                        }
+                        if (delta?.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                yield {
+                                    type: 'tool_call',
+                                    toolCall: {
+                                        id: tc.id ?? '',
+                                        name: tc.function?.name ?? '',
+                                        arguments: tc.function?.arguments ?? '',
+                                    },
+                                };
+                            }
+                        }
+                        if (parsed.choices?.[0]?.finish_reason && !finished) {
+                            const reason = parsed.choices[0].finish_reason;
+                            const finishReason = reason === 'stop'
+                                ? 'stop'
+                                : reason === 'tool_calls'
+                                    ? 'tool_calls'
+                                    : reason === 'length'
+                                        ? 'length'
+                                        : 'error';
+                            yield {
+                                type: 'done',
+                                finishReason,
+                            };
+                            finished = true;
+                        }
+                    }
+                    catch {
+                        // Skip malformed SSE data
+                    }
+                }
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            yield { type: 'error', content: msg, finishReason: 'error' };
+        }
+    }
+    async dispose() {
+        // No persistent connections to dispose
+    }
+}

package/dist/plugins/copilot/tools.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '../../core/index.js';
+export interface CopilotTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function translateTools(tools: ToolDefinition[]): CopilotTool[];

package/dist/plugins/copilot/tools.js

@@ -0,0 +1,10 @@
+export function translateTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+        },
+    }));
+}

package/dist/plugins/copilot/types.d.ts

@@ -0,0 +1,15 @@
+export interface CopilotModel {
+    id: string;
+    name: string;
+    capabilities: {
+        streaming: boolean;
+        tools: boolean;
+        vision?: boolean;
+    };
+}
+export declare const COPILOT_MODELS: CopilotModel[];
+export interface CopilotConfig {
+    COPILOT_TOKEN?: string;
+    COPILOT_OAUTH_TOKEN?: string;
+    COPILOT_OAUTH_REFRESH_TOKEN?: string;
+}

package/dist/plugins/copilot/types.js

@@ -0,0 +1,27 @@
+export const COPILOT_MODELS = [
+    {
+        id: 'gpt-4-copilot',
+        name: 'GPT-4 (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gpt-4o-copilot',
+        name: 'GPT-4o (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'claude-3.5-sonnet-copilot',
+        name: 'Claude 3.5 Sonnet (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'o1-copilot',
+        name: 'o1 (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'o1-mini-copilot',
+        name: 'o1-mini (Copilot)',
+        capabilities: { streaming: true, tools: false },
+    },
+];

package/dist/plugins/cursor/index.d.ts

@@ -0,0 +1,2 @@
+export { CursorBridgePlugin } from './plugin.js';
+export { CursorBridgeSession } from './session.js';

package/dist/plugins/cursor/index.js

@@ -0,0 +1,2 @@
+export { CursorBridgePlugin } from './plugin.js';
+export { CursorBridgeSession } from './session.js';

package/dist/plugins/cursor/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { BridgePlugin, BridgeSession, ModelInfo } from '../../core/index.js';
+export declare class CursorBridgePlugin implements BridgePlugin {
+    name: string;
+    version: string;
+    authenticate(config: Record<string, string>): Promise<boolean>;
+    listModels(config: Record<string, string>): Promise<ModelInfo[]>;
+    createSession(config: Record<string, string>, model: string): Promise<BridgeSession>;
+}