@asframe/opencode-iflow-auth 1.0.0

package/dist/iflow/oauth.js

@@ -0,0 +1,113 @@
+import { IFLOW_CONSTANTS } from '../constants.js';
+import { randomBytes } from 'node:crypto';
+function base64URLEncode(buffer) {
+    return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+function generateState() {
+    return base64URLEncode(randomBytes(16));
+}
+export async function authorizeIFlowOAuth(port) {
+    const state = generateState();
+    const redirectUri = `http://localhost:${port}/oauth2callback`;
+    const params = new URLSearchParams({
+        loginMethod: 'phone',
+        type: 'phone',
+        redirect: redirectUri,
+        state,
+        client_id: IFLOW_CONSTANTS.CLIENT_ID
+    });
+    const authUrl = `${IFLOW_CONSTANTS.OAUTH_AUTHORIZE_URL}?${params.toString()}`;
+    return { authUrl, state, redirectUri };
+}
+export async function exchangeOAuthCode(code, redirectUri) {
+    const params = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: redirectUri,
+        client_id: IFLOW_CONSTANTS.CLIENT_ID,
+        client_secret: IFLOW_CONSTANTS.CLIENT_SECRET
+    });
+    const basicAuth = Buffer.from(`${IFLOW_CONSTANTS.CLIENT_ID}:${IFLOW_CONSTANTS.CLIENT_SECRET}`).toString('base64');
+    const response = await fetch(IFLOW_CONSTANTS.OAUTH_TOKEN_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json',
+            Authorization: `Basic ${basicAuth}`
+        },
+        body: params.toString()
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    const userInfo = await fetchUserInfo(data.access_token);
+    const expiresIn = data.expires_in || 3600;
+    const expiresAt = Date.now() + expiresIn * 1000;
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        expiresAt,
+        apiKey: userInfo.apiKey,
+        email: userInfo.email,
+        authMethod: 'oauth'
+    };
+}
+export async function refreshOAuthToken(refreshToken) {
+    const params = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: IFLOW_CONSTANTS.CLIENT_ID,
+        client_secret: IFLOW_CONSTANTS.CLIENT_SECRET
+    });
+    const basicAuth = Buffer.from(`${IFLOW_CONSTANTS.CLIENT_ID}:${IFLOW_CONSTANTS.CLIENT_SECRET}`).toString('base64');
+    const response = await fetch(IFLOW_CONSTANTS.OAUTH_TOKEN_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json',
+            Authorization: `Basic ${basicAuth}`
+        },
+        body: params.toString()
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        throw new Error(`Token refresh failed: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    const userInfo = await fetchUserInfo(data.access_token);
+    const expiresIn = data.expires_in || 3600;
+    const expiresAt = Date.now() + expiresIn * 1000;
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token || refreshToken,
+        expiresAt,
+        apiKey: userInfo.apiKey,
+        email: userInfo.email,
+        authMethod: 'oauth'
+    };
+}
+export async function fetchUserInfo(accessToken) {
+    const response = await fetch(`${IFLOW_CONSTANTS.USER_INFO_URL}?accessToken=${encodeURIComponent(accessToken)}`, {
+        headers: {
+            Accept: 'application/json'
+        }
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        throw new Error(`User info fetch failed: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.success || !data.data) {
+        throw new Error('User info request not successful');
+    }
+    if (!data.data.apiKey) {
+        throw new Error('Missing apiKey in user info response');
+    }
+    const email = data.data.email || data.data.phone || 'oauth-user';
+    return {
+        apiKey: data.data.apiKey,
+        email
+    };
+}

package/dist/iflow/proxy.d.ts

@@ -0,0 +1,23 @@
+export declare class IFlowCLIProxy {
+    private server;
+    private port;
+    private host;
+    private cliAvailable;
+    private cliChecked;
+    constructor(port?: number, host?: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getBaseUrl(): string;
+    isCLIAvailable(): boolean;
+    private handleRequest;
+    private handleChatCompletions;
+    private handleDirectAPIRequest;
+    private handleCLINonStreamRequest;
+    private handleCLIStreamRequest;
+    private handleModels;
+    private callIFlowCLI;
+    private callIFlowCLIStream;
+    private buildPrompt;
+}
+export declare function getProxyInstance(): IFlowCLIProxy;
+export declare function startProxy(): Promise<IFlowCLIProxy>;

package/dist/iflow/proxy.js

@@ -0,0 +1,435 @@
+import { spawn, execSync } from 'child_process';
+import { createServer } from 'http';
+import { randomUUID } from 'crypto';
+const IFLOW_PROXY_PORT = 19998;
+const IFLOW_PROXY_HOST = '127.0.0.1';
+const IFLOW_API_BASE = 'https://apis.iflow.cn';
+const CLI_REQUIRED_MODELS = ['glm-5', 'glm-5-free', 'glm-5-thinking'];
+const DEBUG = process.env.IFLOW_PROXY_DEBUG === 'true';
+const AUTO_INSTALL_CLI = process.env.IFLOW_AUTO_INSTALL_CLI === 'true';
+function log(...args) {
+    if (DEBUG) {
+        console.error('[IFlowProxy]', ...args);
+    }
+}
+function requiresCLI(model) {
+    return CLI_REQUIRED_MODELS.some(m => model.includes(m));
+}
+function checkIFlowCLI() {
+    try {
+        const result = execSync('iflow --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const version = result.trim();
+        log('iflow CLI version:', version);
+        return { installed: true, version };
+    }
+    catch (error) {
+        const errorMsg = error.message || 'Unknown error';
+        log('iflow CLI check failed:', errorMsg);
+        return { installed: false, error: errorMsg };
+    }
+}
+async function installIFlowCLI() {
+    log('Attempting to install iflow CLI...');
+    console.error('[IFlowProxy] Installing iflow CLI...');
+    return new Promise((resolve) => {
+        try {
+            const npm = spawn('npm', ['install', '-g', 'iflow-cli'], {
+                shell: true,
+                stdio: 'inherit'
+            });
+            npm.on('error', (err) => {
+                console.error('[IFlowProxy] Failed to install iflow CLI:', err.message);
+                resolve({ success: false, error: err.message });
+            });
+            npm.on('close', (code) => {
+                if (code === 0) {
+                    console.error('[IFlowProxy] iflow CLI installed successfully!');
+                    console.error('[IFlowProxy] Please run: iflow login');
+                    resolve({ success: true });
+                }
+                else {
+                    console.error('[IFlowProxy] Installation failed with code:', code);
+                    resolve({ success: false, error: `npm install exited with code ${code}` });
+                }
+            });
+        }
+        catch (error) {
+            console.error('[IFlowProxy] Failed to start npm install:', error.message);
+            resolve({ success: false, error: error.message });
+        }
+    });
+}
+export class IFlowCLIProxy {
+    server = null;
+    port;
+    host;
+    cliAvailable = false;
+    cliChecked = false;
+    constructor(port = IFLOW_PROXY_PORT, host = IFLOW_PROXY_HOST) {
+        this.port = port;
+        this.host = host;
+    }
+    async start() {
+        if (this.server) {
+            return;
+        }
+        if (!this.cliChecked) {
+            let cliCheck = checkIFlowCLI();
+            if (!cliCheck.installed && AUTO_INSTALL_CLI) {
+                const installResult = await installIFlowCLI();
+                if (installResult.success) {
+                    cliCheck = checkIFlowCLI();
+                }
+            }
+            this.cliAvailable = cliCheck.installed;
+            this.cliChecked = true;
+            if (!cliCheck.installed) {
+                console.error('');
+                console.error('[IFlowProxy] ═══════════════════════════════════════════════════════════');
+                console.error('[IFlowProxy] WARNING: iflow CLI is not installed');
+                console.error('[IFlowProxy] ═══════════════════════════════════════════════════════════');
+                console.error('[IFlowProxy] To use GLM-5 models, please install iflow CLI:');
+                console.error('[IFlowProxy]');
+                console.error('[IFlowProxy]   npm install -g iflow-cli');
+                console.error('[IFlowProxy]   iflow login');
+                console.error('[IFlowProxy]');
+                console.error('[IFlowProxy] Or set IFLOW_AUTO_INSTALL_CLI=true to auto-install');
+                console.error('[IFlowProxy] ═══════════════════════════════════════════════════════════');
+                console.error('');
+            }
+            else {
+                log('iflow CLI is available:', cliCheck.version);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => {
+                this.handleRequest(req, res);
+            });
+            this.server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    log(`Port ${this.port} already in use, assuming server is running`);
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+            this.server.listen(this.port, this.host, () => {
+                log(`Smart proxy started on http://${this.host}:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.server) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.server = null;
+                log('Server stopped');
+                resolve();
+            });
+        });
+    }
+    getBaseUrl() {
+        return `http://${this.host}:${this.port}`;
+    }
+    isCLIAvailable() {
+        return this.cliAvailable;
+    }
+    async handleRequest(req, res) {
+        if (req.method !== 'POST') {
+            res.writeHead(405, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Method not allowed' }));
+            return;
+        }
+        const url = req.url || '';
+        if (url === '/v1/chat/completions') {
+            await this.handleChatCompletions(req, res);
+        }
+        else if (url === '/v1/models') {
+            this.handleModels(res);
+        }
+        else {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+        }
+    }
+    async handleChatCompletions(req, res) {
+        let body = '';
+        req.on('data', chunk => {
+            body += chunk.toString();
+        });
+        req.on('end', async () => {
+            try {
+                const request = JSON.parse(body);
+                const model = request.model;
+                const isStream = request.stream === true;
+                log(`Request for model: ${model}, requires CLI: ${requiresCLI(model)}`);
+                if (requiresCLI(model)) {
+                    if (!this.cliAvailable) {
+                        log(`CLI not available for model: ${model}`);
+                        res.writeHead(503, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            error: 'iflow CLI is not installed. Please install it with: npm install -g iflow-cli && iflow login',
+                            install_hint: 'npm install -g iflow-cli && iflow login'
+                        }));
+                        return;
+                    }
+                    log(`Using CLI for model: ${model}`);
+                    if (isStream) {
+                        await this.handleCLIStreamRequest(request, res);
+                    }
+                    else {
+                        await this.handleCLINonStreamRequest(request, res);
+                    }
+                }
+                else {
+                    log(`Using direct API for model: ${model}`);
+                    await this.handleDirectAPIRequest(request, res, isStream);
+                }
+            }
+            catch (error) {
+                log('Error parsing request:', error);
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid request body' }));
+            }
+        });
+    }
+    async handleDirectAPIRequest(request, res, isStream) {
+        try {
+            const https = await import('https');
+            const requestBody = JSON.stringify({
+                ...request,
+                model: request.model,
+            });
+            const options = {
+                hostname: 'apis.iflow.cn',
+                path: '/v1/chat/completions',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(requestBody)
+                }
+            };
+            const apiReq = https.request(options, (apiRes) => {
+                res.writeHead(apiRes.statusCode || 200, apiRes.headers);
+                apiRes.pipe(res);
+            });
+            apiReq.on('error', (err) => {
+                log('Direct API error:', err);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: err.message }));
+            });
+            apiReq.write(requestBody);
+            apiReq.end();
+        }
+        catch (error) {
+            log('Direct API error:', error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: error.message }));
+        }
+    }
+    async handleCLINonStreamRequest(request, res) {
+        try {
+            const result = await this.callIFlowCLI(request);
+            const response = {
+                id: `iflow-${randomUUID()}`,
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: request.model,
+                choices: [{
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: result.content
+                        },
+                        finish_reason: 'stop'
+                    }],
+                usage: {
+                    prompt_tokens: result.promptTokens || 0,
+                    completion_tokens: result.completionTokens || 0,
+                    total_tokens: (result.promptTokens || 0) + (result.completionTokens || 0)
+                }
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(response));
+        }
+        catch (error) {
+            log('Error calling iflow CLI:', error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: error.message || 'Internal server error' }));
+        }
+    }
+    async handleCLIStreamRequest(request, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        const chatId = `iflow-${randomUUID()}`;
+        const created = Math.floor(Date.now() / 1000);
+        try {
+            await this.callIFlowCLIStream(request, (content, done) => {
+                const chunk = {
+                    id: chatId,
+                    object: 'chat.completion.chunk',
+                    created: created,
+                    model: request.model,
+                    choices: [{
+                            index: 0,
+                            delta: done ? {} : { content },
+                            finish_reason: done ? 'stop' : null
+                        }]
+                };
+                res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+                if (done) {
+                    res.write('data: [DONE]\n\n');
+                    res.end();
+                }
+            });
+        }
+        catch (error) {
+            log('Error in stream:', error);
+            const errorChunk = {
+                id: chatId,
+                object: 'chat.completion.chunk',
+                created: created,
+                model: request.model,
+                choices: [{
+                        index: 0,
+                        delta: { content: `\n\n[Error: ${error.message}]` },
+                        finish_reason: 'stop'
+                    }]
+            };
+            res.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
+            res.write('data: [DONE]\n\n');
+            res.end();
+        }
+    }
+    handleModels(res) {
+        const models = [
+            { id: 'glm-5', object: 'model', created: 1700000000, owned_by: 'iflow' },
+            { id: 'glm-4.6', object: 'model', created: 1700000000, owned_by: 'iflow' },
+            { id: 'deepseek-v3.2', object: 'model', created: 1700000000, owned_by: 'iflow' },
+            { id: 'kimi-k2', object: 'model', created: 1700000000, owned_by: 'iflow' },
+        ];
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ object: 'list', data: models }));
+    }
+    async callIFlowCLI(request) {
+        return new Promise((resolve, reject) => {
+            const prompt = this.buildPrompt(request.messages);
+            const args = [
+                '-m', request.model,
+                '--no-stream'
+            ];
+            log(`Calling iflow with stdin, prompt length: ${prompt.length}`);
+            const iflow = spawn('iflow', args, {
+                shell: true,
+                windowsHide: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env }
+            });
+            let stdout = '';
+            let stderr = '';
+            iflow.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            iflow.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            iflow.on('error', (err) => {
+                log('Failed to start iflow:', err);
+                reject(new Error(`Failed to start iflow: ${err.message}`));
+            });
+            iflow.on('close', (code) => {
+                if (code !== 0) {
+                    log('iflow exited with code:', code, stderr);
+                    reject(new Error(`iflow exited with code ${code}`));
+                    return;
+                }
+                const content = stdout.trim();
+                log('iflow response length:', content.length);
+                resolve({
+                    content,
+                    promptTokens: 0,
+                    completionTokens: 0
+                });
+            });
+            iflow.stdin?.write(prompt);
+            iflow.stdin?.end();
+        });
+    }
+    async callIFlowCLIStream(request, onChunk) {
+        return new Promise((resolve, reject) => {
+            const prompt = this.buildPrompt(request.messages);
+            const args = [
+                '-m', request.model
+            ];
+            log(`Calling iflow (stream) with stdin, prompt length: ${prompt.length}`);
+            const iflow = spawn('iflow', args, {
+                shell: true,
+                windowsHide: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env }
+            });
+            let resolved = false;
+            iflow.stdout?.on('data', (data) => {
+                const chunk = data.toString();
+                onChunk(chunk, false);
+            });
+            iflow.stderr?.on('data', () => { });
+            iflow.on('error', (err) => {
+                log('Failed to start iflow:', err);
+                if (!resolved) {
+                    resolved = true;
+                    reject(new Error(`Failed to start iflow: ${err.message}`));
+                }
+            });
+            iflow.on('close', (code) => {
+                if (code !== 0 && !resolved) {
+                    log('iflow exited with code:', code);
+                    resolved = true;
+                    reject(new Error(`iflow exited with code ${code}`));
+                    return;
+                }
+                if (!resolved) {
+                    resolved = true;
+                    onChunk('', true);
+                    resolve();
+                }
+            });
+            iflow.stdin?.write(prompt);
+            iflow.stdin?.end();
+        });
+    }
+    buildPrompt(messages) {
+        const parts = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                parts.push(`System: ${msg.content}`);
+            }
+            else if (msg.role === 'user') {
+                parts.push(msg.content);
+            }
+            else if (msg.role === 'assistant') {
+                parts.push(`Assistant: ${msg.content}`);
+            }
+        }
+        return parts.join('\n\n');
+    }
+}
+let proxyInstance = null;
+export function getProxyInstance() {
+    if (!proxyInstance) {
+        proxyInstance = new IFlowCLIProxy();
+    }
+    return proxyInstance;
+}
+export async function startProxy() {
+    const proxy = getProxyInstance();
+    await proxy.start();
+    return proxy;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { IFlowPlugin } from './plugin-iflow.js';
+export { IFlowProxyPlugin } from './plugin-proxy.js';
+export type { IFlowConfig } from './plugin/config/index.js';
+export type { IFlowAuthMethod, ManagedAccount } from './plugin/types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { IFlowPlugin } from './plugin-iflow.js';
+export { IFlowProxyPlugin } from './plugin-proxy.js';

package/dist/plugin/accounts.d.ts

@@ -0,0 +1,24 @@
+import type { ManagedAccount, AccountSelectionStrategy, IFlowAuthDetails, RefreshParts } from './types.js';
+export declare function generateAccountId(): string;
+export declare function encodeRefreshToken(parts: RefreshParts): string;
+export declare function decodeRefreshToken(encoded: string): RefreshParts;
+export declare class AccountManager {
+    private accounts;
+    private cursor;
+    private strategy;
+    private lastToastTime;
+    constructor(accounts: ManagedAccount[], strategy?: AccountSelectionStrategy);
+    static loadFromDisk(strategy?: AccountSelectionStrategy): Promise<AccountManager>;
+    getAccountCount(): number;
+    getAccounts(): ManagedAccount[];
+    shouldShowToast(debounce?: number): boolean;
+    getMinWaitTime(): number;
+    getCurrentOrNext(): ManagedAccount | null;
+    addAccount(a: ManagedAccount): void;
+    removeAccount(a: ManagedAccount): void;
+    updateFromAuth(a: ManagedAccount, auth: IFlowAuthDetails): void;
+    markRateLimited(a: ManagedAccount, ms: number): void;
+    markUnhealthy(a: ManagedAccount, reason: string, recovery?: number): void;
+    saveToDisk(): Promise<void>;
+    toAuthDetails(a: ManagedAccount): IFlowAuthDetails;
+}