@zhafron/opencode-iflow-auth 1.0.0

package/README.md

@@ -0,0 +1,231 @@
+# OpenCode iFlow Auth Plugin
+[![npm version](https://img.shields.io/npm/v/@zhafron/opencode-iflow-auth)](https://www.npmjs.com/package/@zhafron/opencode-iflow-auth)
+[![npm downloads](https://img.shields.io/npm/dm/@zhafron/opencode-iflow-auth)](https://www.npmjs.com/package/@zhafron/opencode-iflow-auth)
+[![license](https://img.shields.io/npm/l/@zhafron/opencode-iflow-auth)](https://www.npmjs.com/package/@zhafron/opencode-iflow-auth)
+
+OpenCode plugin for iFlow.cn providing access to Qwen, DeepSeek, Kimi, GLM, and iFlow ROME models with dual authentication support.
+
+## Features
+
+- Dual authentication: OAuth 2.0 (PKCE) and API Key support.
+- Multi-account rotation with sticky and round-robin strategies.
+- Automated token refresh and rate limit handling with exponential backoff.
+- Native thinking mode support for GLM-4.x models.
+- Configurable request timeout and iteration limits to prevent hangs.
+- Automatic port selection for OAuth callback server to avoid conflicts.
+
+## Installation
+
+Add the plugin to your `opencode.json` or `opencode.jsonc`:
+
+```json
+{
+  "plugin": ["@zhafron/opencode-iflow-auth"],
+  "provider": {
+    "iflow": {
+      "models": {
+        "iflow-rome-30ba3b": {
+          "name": "iFlow ROME 30B",
+          "limit": { "context": 256000, "output": 64000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "qwen3-coder-plus": {
+          "name": "Qwen3 Coder Plus",
+          "limit": { "context": 1000000, "output": 64000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "qwen3-max": {
+          "name": "Qwen3 Max",
+          "limit": { "context": 256000, "output": 32000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "qwen3-vl-plus": {
+          "name": "Qwen3 VL Plus",
+          "limit": { "context": 256000, "output": 32000 },
+          "modalities": { "input": ["text", "image"], "output": ["text"] }
+        },
+        "qwen3-235b-a22b-thinking-2507": {
+          "name": "Qwen3 235B Thinking",
+          "limit": { "context": 256000, "output": 64000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "kimi-k2": {
+          "name": "Kimi K2",
+          "limit": { "context": 128000, "output": 64000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "kimi-k2-0905": {
+          "name": "Kimi K2 0905",
+          "limit": { "context": 256000, "output": 64000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "glm-4.6": {
+          "name": "GLM-4.6 Thinking",
+          "limit": { "context": 200000, "output": 128000 },
+          "modalities": { "input": ["text", "image"], "output": ["text"] },
+          "variants": {
+            "low": { "thinkingConfig": { "thinkingBudget": 1024 } },
+            "medium": { "thinkingConfig": { "thinkingBudget": 8192 } },
+            "max": { "thinkingConfig": { "thinkingBudget": 32768 } }
+          }
+        },
+        "deepseek-v3": {
+          "name": "DeepSeek V3",
+          "limit": { "context": 128000, "output": 32000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "deepseek-v3.2": {
+          "name": "DeepSeek V3.2",
+          "limit": { "context": 128000, "output": 64000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        },
+        "deepseek-r1": {
+          "name": "DeepSeek R1",
+          "limit": { "context": 128000, "output": 32000 },
+          "modalities": { "input": ["text"], "output": ["text"] },
+          "variants": {
+            "low": { "thinkingConfig": { "thinkingBudget": 1024 } },
+            "medium": { "thinkingConfig": { "thinkingBudget": 8192 } },
+            "max": { "thinkingConfig": { "thinkingBudget": 32768 } }
+          }
+        },
+        "qwen3-32b": {
+          "name": "Qwen3 32B",
+          "limit": { "context": 128000, "output": 32000 },
+          "modalities": { "input": ["text"], "output": ["text"] }
+        }
+      }
+    }
+  }
+}
+```
+
+## Setup
+
+1. Run `opencode auth login`.
+2. Select `Other`, type `iflow`, and press enter.
+3. Choose authentication method:
+   - **OAuth 2.0**: Follow browser flow for secure token-based authentication.
+   - **API Key**: Enter your iFlow API key (starts with `sk-`).
+4. Configuration template will be automatically created at `~/.config/opencode/iflow.json` on first load.
+
+## Configuration
+
+The plugin supports extensive configuration options. Edit `~/.config/opencode/iflow.json`:
+
+```json
+{
+  "default_auth_method": "oauth",
+  "account_selection_strategy": "round-robin",
+  "auth_server_port_start": 8087,
+  "auth_server_port_range": 10,
+  "max_request_iterations": 50,
+  "request_timeout_ms": 300000,
+  "enable_log_api_request": false
+}
+```
+
+### Configuration Options
+
+- `default_auth_method`: Default authentication method (`oauth`, `apikey`)
+- `account_selection_strategy`: Account rotation strategy (`sticky`, `round-robin`)
+- `auth_server_port_start`: Starting port for OAuth callback server (1024-65535)
+- `auth_server_port_range`: Number of ports to try (1-100)
+- `max_request_iterations`: Maximum loop iterations to prevent hangs (10-1000)
+- `request_timeout_ms`: Request timeout in milliseconds (60000-600000ms)
+- `enable_log_api_request`: Enable API request/response logging (errors always logged)
+
+### Environment Variables
+
+All configuration options can be overridden via environment variables:
+
+- `IFLOW_DEFAULT_AUTH_METHOD`
+- `IFLOW_ACCOUNT_SELECTION_STRATEGY`
+- `IFLOW_AUTH_SERVER_PORT_START`
+- `IFLOW_AUTH_SERVER_PORT_RANGE`
+- `IFLOW_MAX_REQUEST_ITERATIONS`
+- `IFLOW_REQUEST_TIMEOUT_MS`
+- `IFLOW_ENABLE_LOG_API_REQUEST`
+
+## Storage
+
+**Linux/macOS:**
+- Credentials: `~/.config/opencode/iflow-accounts.json`
+- Plugin Config: `~/.config/opencode/iflow.json`
+
+**Windows:**
+- Credentials: `%APPDATA%\opencode\iflow-accounts.json`
+- Plugin Config: `%APPDATA%\opencode\iflow.json`
+
+## Thinking Models
+
+iFlow supports thinking models with customizable thinking budgets via variants:
+
+### GLM-4.6
+
+Automatically enables thinking mode with configurable budget:
+
+```json
+{
+  "variants": {
+    "low": { "thinkingConfig": { "thinkingBudget": 1024 } },
+    "medium": { "thinkingConfig": { "thinkingBudget": 8192 } },
+    "max": { "thinkingConfig": { "thinkingBudget": 32768 } }
+  }
+}
+```
+
+The plugin automatically transforms requests to:
+
+```typescript
+{
+  "chat_template_kwargs": {
+    "enable_thinking": true,
+    "clear_thinking": false
+  },
+  "thinking_budget": 8192  // from variant config
+}
+```
+
+### DeepSeek R1
+
+Supports thinking budget control via variants:
+
+```json
+{
+  "variants": {
+    "low": { "thinkingConfig": { "thinkingBudget": 1024 } },
+    "medium": { "thinkingConfig": { "thinkingBudget": 8192 } },
+    "max": { "thinkingConfig": { "thinkingBudget": 32768 } }
+  }
+}
+```
+
+The plugin automatically adds `thinking_budget` parameter to requests.
+
+### Response Format
+
+Both models return reasoning content in the response:
+
+```json
+{
+  "choices": [{
+    "message": {
+      "role": "assistant",
+      "content": "The answer is 4.",
+      "reasoning_content": "Let me think step by step..."
+    }
+  }],
+  "usage": {
+    "completion_tokens_details": {
+      "reasoning_tokens": 1094
+    }
+  }
+}
+```
+
+## Disclaimer
+
+This plugin is provided strictly for learning and educational purposes. It is an independent implementation and is not affiliated with, endorsed by, or supported by iFlow.cn. Use of this plugin is at your own risk.
+
+Feel free to open a PR to optimize this plugin further.

package/dist/constants.d.ts

@@ -0,0 +1,19 @@
+export type IFlowAuthMethod = 'oauth' | 'apikey';
+export declare function isValidAuthMethod(method: string): method is IFlowAuthMethod;
+export declare const IFLOW_CONSTANTS: {
+    BASE_URL: string;
+    OAUTH_TOKEN_URL: string;
+    OAUTH_AUTHORIZE_URL: string;
+    USER_INFO_URL: string;
+    SUCCESS_REDIRECT: string;
+    CLIENT_ID: string;
+    CLIENT_SECRET: string;
+    AXIOS_TIMEOUT: number;
+    USER_AGENT: string;
+    CALLBACK_PORT_START: number;
+    CALLBACK_PORT_RANGE: number;
+};
+export declare const SUPPORTED_MODELS: string[];
+export declare const THINKING_MODELS: string[];
+export declare function isThinkingModel(model: string): boolean;
+export declare function applyThinkingConfig(body: any, model: string): any;

package/dist/constants.js

@@ -0,0 +1,61 @@
+export function isValidAuthMethod(method) {
+    return method === 'oauth' || method === 'apikey';
+}
+export const IFLOW_CONSTANTS = {
+    BASE_URL: 'https://apis.iflow.cn/v1',
+    OAUTH_TOKEN_URL: 'https://iflow.cn/oauth/token',
+    OAUTH_AUTHORIZE_URL: 'https://iflow.cn/oauth',
+    USER_INFO_URL: 'https://iflow.cn/api/oauth/getUserInfo',
+    SUCCESS_REDIRECT: 'https://iflow.cn/oauth/success',
+    CLIENT_ID: '10009311001',
+    CLIENT_SECRET: '4Z3YjXycVsQvyGF1etiNlIBB4RsqSDtW',
+    AXIOS_TIMEOUT: 120000,
+    USER_AGENT: 'OpenCode-iFlow',
+    CALLBACK_PORT_START: 8087,
+    CALLBACK_PORT_RANGE: 10
+};
+export const SUPPORTED_MODELS = [
+    'iflow-rome-30ba3b',
+    'qwen3-coder-plus',
+    'qwen3-max',
+    'qwen3-vl-plus',
+    'qwen3-max-preview',
+    'qwen3-32b',
+    'qwen3-235b-a22b-thinking-2507',
+    'qwen3-235b-a22b-instruct',
+    'qwen3-235b',
+    'kimi-k2-0905',
+    'kimi-k2',
+    'glm-4.6',
+    'deepseek-v3.2',
+    'deepseek-r1',
+    'deepseek-v3'
+];
+export const THINKING_MODELS = ['glm-4.6', 'qwen3-235b-a22b-thinking-2507', 'deepseek-r1'];
+export function isThinkingModel(model) {
+    return THINKING_MODELS.some((m) => model.startsWith(m));
+}
+export function applyThinkingConfig(body, model) {
+    const thinkingBudget = body.providerOptions?.thinkingConfig?.thinkingBudget;
+    if (model.startsWith('glm-4')) {
+        const result = {
+            ...body,
+            chat_template_kwargs: {
+                enable_thinking: true,
+                clear_thinking: false
+            }
+        };
+        if (thinkingBudget) {
+            result.thinking_budget = thinkingBudget;
+        }
+        return result;
+    }
+    if (model.startsWith('deepseek-r1')) {
+        const result = { ...body };
+        if (thinkingBudget) {
+            result.thinking_budget = thinkingBudget;
+        }
+        return result;
+    }
+    return body;
+}

package/dist/iflow/apikey.d.ts

@@ -0,0 +1,6 @@
+export interface IFlowApiKeyResult {
+    apiKey: string;
+    email: string;
+    authMethod: 'apikey';
+}
+export declare function validateApiKey(apiKey: string): Promise<IFlowApiKeyResult>;

package/dist/iflow/apikey.js

@@ -0,0 +1,17 @@
+import { IFLOW_CONSTANTS } from '../constants';
+export async function validateApiKey(apiKey) {
+    const response = await fetch(`${IFLOW_CONSTANTS.BASE_URL}/models`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'User-Agent': IFLOW_CONSTANTS.USER_AGENT
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`API key validation failed: ${response.status}`);
+    }
+    return {
+        apiKey,
+        email: 'api-key-user',
+        authMethod: 'apikey'
+    };
+}

package/dist/iflow/oauth.d.ts

@@ -0,0 +1,20 @@
+export interface IFlowOAuthAuthorization {
+    authUrl: string;
+    state: string;
+    redirectUri: string;
+}
+export interface IFlowOAuthTokenResult {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    apiKey: string;
+    email: string;
+    authMethod: 'oauth';
+}
+export declare function authorizeIFlowOAuth(port: number): Promise<IFlowOAuthAuthorization>;
+export declare function exchangeOAuthCode(code: string, redirectUri: string): Promise<IFlowOAuthTokenResult>;
+export declare function refreshOAuthToken(refreshToken: string): Promise<IFlowOAuthTokenResult>;
+export declare function fetchUserInfo(accessToken: string): Promise<{
+    apiKey: string;
+    email: string;
+}>;

package/dist/iflow/oauth.js

@@ -0,0 +1,113 @@
+import { IFLOW_CONSTANTS } from '../constants';
+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/index.d.ts

@@ -0,0 +1,3 @@
+export { IFlowOAuthPlugin } from './plugin.js';
+export type { IFlowConfig } from './plugin/config/index.js';
+export type { IFlowAuthMethod, ManagedAccount } from './plugin/types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { IFlowOAuthPlugin } from './plugin.js';

package/dist/plugin/accounts.d.ts

@@ -0,0 +1,24 @@
+import type { ManagedAccount, AccountSelectionStrategy, IFlowAuthDetails, RefreshParts } from './types';
+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;
+}

package/dist/plugin/accounts.js

@@ -0,0 +1,147 @@
+import { randomBytes } from 'node:crypto';
+import { loadAccounts, saveAccounts } from './storage';
+export function generateAccountId() {
+    return randomBytes(16).toString('hex');
+}
+export function encodeRefreshToken(parts) {
+    return Buffer.from(JSON.stringify(parts)).toString('base64');
+}
+export function decodeRefreshToken(encoded) {
+    try {
+        return JSON.parse(Buffer.from(encoded, 'base64').toString('utf-8'));
+    }
+    catch {
+        return { authMethod: 'apikey' };
+    }
+}
+export class AccountManager {
+    accounts;
+    cursor;
+    strategy;
+    lastToastTime = 0;
+    constructor(accounts, strategy = 'sticky') {
+        this.accounts = accounts;
+        this.cursor = 0;
+        this.strategy = strategy;
+    }
+    static async loadFromDisk(strategy) {
+        const s = await loadAccounts();
+        return new AccountManager(s.accounts, strategy || 'sticky');
+    }
+    getAccountCount() {
+        return this.accounts.length;
+    }
+    getAccounts() {
+        return [...this.accounts];
+    }
+    shouldShowToast(debounce = 30000) {
+        if (Date.now() - this.lastToastTime < debounce)
+            return false;
+        this.lastToastTime = Date.now();
+        return true;
+    }
+    getMinWaitTime() {
+        const now = Date.now();
+        const waits = this.accounts.map((a) => (a.rateLimitResetTime || 0) - now).filter((t) => t > 0);
+        return waits.length > 0 ? Math.min(...waits) : 0;
+    }
+    getCurrentOrNext() {
+        const now = Date.now();
+        const available = this.accounts.filter((a) => {
+            if (!a.isHealthy) {
+                if (a.recoveryTime && now >= a.recoveryTime) {
+                    a.isHealthy = true;
+                    delete a.unhealthyReason;
+                    delete a.recoveryTime;
+                    return true;
+                }
+                return false;
+            }
+            return !(a.rateLimitResetTime && now < a.rateLimitResetTime);
+        });
+        if (available.length === 0)
+            return null;
+        let selected;
+        if (this.strategy === 'sticky') {
+            selected = available.find((_, i) => i === this.cursor) || available[0];
+        }
+        else if (this.strategy === 'round-robin') {
+            selected = available[this.cursor % available.length];
+            this.cursor = (this.cursor + 1) % available.length;
+        }
+        if (selected) {
+            selected.lastUsed = now;
+            this.cursor = this.accounts.indexOf(selected);
+            return selected;
+        }
+        return null;
+    }
+    addAccount(a) {
+        const i = this.accounts.findIndex((x) => x.id === a.id);
+        if (i === -1)
+            this.accounts.push(a);
+        else
+            this.accounts[i] = a;
+    }
+    removeAccount(a) {
+        const removedIndex = this.accounts.findIndex((x) => x.id === a.id);
+        if (removedIndex === -1)
+            return;
+        this.accounts = this.accounts.filter((x) => x.id !== a.id);
+        if (this.accounts.length === 0) {
+            this.cursor = 0;
+        }
+        else if (this.cursor >= this.accounts.length) {
+            this.cursor = this.accounts.length - 1;
+        }
+        else if (removedIndex <= this.cursor && this.cursor > 0) {
+            this.cursor--;
+        }
+    }
+    updateFromAuth(a, auth) {
+        const acc = this.accounts.find((x) => x.id === a.id);
+        if (acc) {
+            acc.apiKey = auth.apiKey;
+            if (auth.authMethod === 'oauth') {
+                acc.accessToken = auth.access;
+                acc.expiresAt = auth.expires;
+                const p = decodeRefreshToken(auth.refresh);
+                acc.refreshToken = p.refreshToken;
+            }
+            acc.lastUsed = Date.now();
+            if (auth.email)
+                acc.email = auth.email;
+        }
+    }
+    markRateLimited(a, ms) {
+        const acc = this.accounts.find((x) => x.id === a.id);
+        if (acc)
+            acc.rateLimitResetTime = Date.now() + ms;
+    }
+    markUnhealthy(a, reason, recovery) {
+        const acc = this.accounts.find((x) => x.id === a.id);
+        if (acc) {
+            acc.isHealthy = false;
+            acc.unhealthyReason = reason;
+            acc.recoveryTime = recovery;
+        }
+    }
+    async saveToDisk() {
+        const metadata = this.accounts.map(({ lastUsed, ...rest }) => rest);
+        await saveAccounts({ version: 1, accounts: metadata, activeIndex: this.cursor });
+    }
+    toAuthDetails(a) {
+        const p = {
+            refreshToken: a.refreshToken,
+            authMethod: a.authMethod
+        };
+        return {
+            refresh: encodeRefreshToken(p),
+            access: a.accessToken || '',
+            expires: a.expiresAt || 0,
+            authMethod: a.authMethod,
+            apiKey: a.apiKey,
+            email: a.email
+        };
+    }
+}

package/dist/plugin/auth-page.d.ts

@@ -0,0 +1,3 @@
+export declare function getIDCAuthHtml(verificationUrl: string, userCode: string, statusUrl: string): string;
+export declare function getSuccessHtml(): string;
+export declare function getErrorHtml(message: string): string;