@asframe/opencode-iflow-auth 1.0.0

package/dist/plugin-iflow.js

@@ -0,0 +1,141 @@
+import { loadConfig } from "./plugin/config/index.js";
+import { AccountManager, generateAccountId } from "./plugin/accounts.js";
+import { authorizeIFlowOAuth } from "./iflow/oauth.js";
+import { validateApiKey } from "./iflow/apikey.js";
+import { startOAuthServer } from "./plugin/server.js";
+import { promptApiKey, promptEmail, } from "./plugin/cli.js";
+import { IFLOW_CONSTANTS, registerIFlowModels } from "./constants.js";
+const DEBUG = process.env.IFLOW_AUTH_DEBUG === 'true';
+function log(...args) {
+    if (DEBUG) {
+        console.error('[iflow-auth]', ...args);
+    }
+}
+const openBrowser = (url) => {
+    const platform = process.platform;
+    if (platform === "win32") {
+        import("node:child_process").then(({ exec }) => {
+            exec(`cmd /c start "" "${url}"`);
+        });
+    }
+};
+export const IFlowPlugin = async (input) => {
+    const config = loadConfig();
+    const showToast = (message, variant) => {
+        input.client.tui.showToast({ body: { message, variant } }).catch(() => { });
+    };
+    return {
+        auth: {
+            provider: "iflow",
+            loader: async (getAuth, provider) => {
+                log('loader called');
+                const auth = await getAuth();
+                log('auth result:', auth ? 'found' : 'not found');
+                const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                log('account count:', am.getAccountCount());
+                registerIFlowModels(provider);
+                const accountCount = am.getAccountCount();
+                if (accountCount === 0) {
+                    log('No accounts found in loader');
+                    return {};
+                }
+                const firstAccount = am.getCurrentOrNext();
+                if (!firstAccount) {
+                    log('No available account');
+                    return {};
+                }
+                log('Using account:', firstAccount.email, 'apiKey:', firstAccount.apiKey.substring(0, 10) + '...');
+                return {
+                    apiKey: firstAccount.apiKey,
+                    baseURL: IFLOW_CONSTANTS.BASE_URL,
+                };
+            },
+            methods: [
+                {
+                    label: "iFlow OAuth 2.0",
+                    type: "oauth",
+                    authorize: async (inputs) => new Promise(async (resolve) => {
+                        try {
+                            const authData = await authorizeIFlowOAuth(config.auth_server_port_start);
+                            const { url, waitForAuth } = await startOAuthServer(authData.authUrl, authData.state, authData.redirectUri, config.auth_server_port_start, config.auth_server_port_range);
+                            openBrowser(url);
+                            resolve({
+                                url,
+                                instructions: `Open this URL to continue: ${url}`,
+                                method: "auto",
+                                callback: async () => {
+                                    try {
+                                        const res = await waitForAuth();
+                                        const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                        const acc = {
+                                            id: generateAccountId(),
+                                            email: res.email,
+                                            authMethod: "oauth",
+                                            refreshToken: res.refreshToken,
+                                            accessToken: res.accessToken,
+                                            expiresAt: res.expiresAt,
+                                            apiKey: res.apiKey,
+                                            rateLimitResetTime: 0,
+                                            isHealthy: true,
+                                        };
+                                        am.addAccount(acc);
+                                        await am.saveToDisk();
+                                        showToast(`Successfully logged in as ${res.email}`, "success");
+                                        return { type: "success", key: res.apiKey };
+                                    }
+                                    catch (e) {
+                                        showToast(`Login failed: ${e.message}`, "error");
+                                        return { type: "failed" };
+                                    }
+                                },
+                            });
+                        }
+                        catch (e) {
+                            resolve({
+                                url: "",
+                                instructions: "Authorization failed",
+                                method: "auto",
+                                callback: async () => ({ type: "failed" }),
+                            });
+                        }
+                    }),
+                },
+                {
+                    label: "iFlow API Key",
+                    type: "api",
+                    authorize: async (inputs) => {
+                        if (!inputs) {
+                            return { type: "failed" };
+                        }
+                        const apiKey = await promptApiKey();
+                        if (!apiKey) {
+                            return { type: "failed" };
+                        }
+                        try {
+                            await validateApiKey(apiKey);
+                            const email = await promptEmail();
+                            const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                            const acc = {
+                                id: generateAccountId(),
+                                email,
+                                authMethod: "apikey",
+                                apiKey,
+                                rateLimitResetTime: 0,
+                                isHealthy: true,
+                            };
+                            am.addAccount(acc);
+                            await am.saveToDisk();
+                            return { type: "success", key: apiKey };
+                        }
+                        catch (error) {
+                            return { type: "failed" };
+                        }
+                    },
+                },
+            ],
+        },
+        "chat.headers": async (input, output) => {
+            output.headers["User-Agent"] = `${IFLOW_CONSTANTS.USER_AGENT}/2.0`;
+        },
+    };
+};

package/dist/plugin-proxy.d.ts

@@ -0,0 +1,2 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+export declare const IFlowProxyPlugin: (input: PluginInput) => Promise<Hooks>;

package/dist/plugin-proxy.js

@@ -0,0 +1,155 @@
+import { loadConfig } from "./plugin/config/index.js";
+import { AccountManager, generateAccountId } from "./plugin/accounts.js";
+import { authorizeIFlowOAuth } from "./iflow/oauth.js";
+import { validateApiKey } from "./iflow/apikey.js";
+import { startOAuthServer } from "./plugin/server.js";
+import { startProxy } from "./iflow/proxy.js";
+import { promptApiKey, promptEmail, } from "./plugin/cli.js";
+import { IFLOW_CONSTANTS, registerIFlowModels } from "./constants.js";
+const DEBUG = process.env.IFLOW_PROXY_DEBUG === 'true';
+function log(...args) {
+    if (DEBUG) {
+        console.error('[iflow-proxy]', ...args);
+    }
+}
+const openBrowser = (url) => {
+    const platform = process.platform;
+    if (platform === "win32") {
+        import("node:child_process").then(({ exec }) => {
+            exec(`cmd /c start "" "${url}"`);
+        });
+    }
+};
+export const IFlowProxyPlugin = async (input) => {
+    const config = loadConfig();
+    const showToast = (message, variant) => {
+        input.client.tui.showToast({ body: { message, variant } }).catch(() => { });
+    };
+    return {
+        auth: {
+            provider: "iflow-proxy",
+            loader: async (getAuth, provider) => {
+                log('loader called');
+                const auth = await getAuth();
+                log('auth result:', auth ? 'found' : 'not found');
+                const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                log('account count:', am.getAccountCount());
+                registerIFlowModels(provider);
+                const accountCount = am.getAccountCount();
+                if (accountCount === 0) {
+                    log('No accounts found in loader');
+                    return {};
+                }
+                const firstAccount = am.getCurrentOrNext();
+                if (!firstAccount) {
+                    log('No available account');
+                    return {};
+                }
+                log('Using account:', firstAccount.email, 'apiKey:', firstAccount.apiKey.substring(0, 10) + '...');
+                try {
+                    log('Starting CLI proxy...');
+                    const proxy = await startProxy();
+                    const proxyUrl = proxy.getBaseUrl();
+                    log('CLI proxy started at:', proxyUrl);
+                    return {
+                        apiKey: firstAccount.apiKey,
+                        baseURL: proxyUrl,
+                    };
+                }
+                catch (err) {
+                    log('Failed to start proxy, using direct API:', err.message);
+                    return {
+                        apiKey: firstAccount.apiKey,
+                        baseURL: IFLOW_CONSTANTS.BASE_URL,
+                    };
+                }
+            },
+            methods: [
+                {
+                    label: "iFlow OAuth 2.0",
+                    type: "oauth",
+                    authorize: async (inputs) => new Promise(async (resolve) => {
+                        try {
+                            const authData = await authorizeIFlowOAuth(config.auth_server_port_start);
+                            const { url, waitForAuth } = await startOAuthServer(authData.authUrl, authData.state, authData.redirectUri, config.auth_server_port_start, config.auth_server_port_range);
+                            openBrowser(url);
+                            resolve({
+                                url,
+                                instructions: `Open this URL to continue: ${url}`,
+                                method: "auto",
+                                callback: async () => {
+                                    try {
+                                        const res = await waitForAuth();
+                                        const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                        const acc = {
+                                            id: generateAccountId(),
+                                            email: res.email,
+                                            authMethod: "oauth",
+                                            refreshToken: res.refreshToken,
+                                            accessToken: res.accessToken,
+                                            expiresAt: res.expiresAt,
+                                            apiKey: res.apiKey,
+                                            rateLimitResetTime: 0,
+                                            isHealthy: true,
+                                        };
+                                        am.addAccount(acc);
+                                        await am.saveToDisk();
+                                        showToast(`Successfully logged in as ${res.email}`, "success");
+                                        return { type: "success", key: res.apiKey };
+                                    }
+                                    catch (e) {
+                                        showToast(`Login failed: ${e.message}`, "error");
+                                        return { type: "failed" };
+                                    }
+                                },
+                            });
+                        }
+                        catch (e) {
+                            resolve({
+                                url: "",
+                                instructions: "Authorization failed",
+                                method: "auto",
+                                callback: async () => ({ type: "failed" }),
+                            });
+                        }
+                    }),
+                },
+                {
+                    label: "iFlow API Key",
+                    type: "api",
+                    authorize: async (inputs) => {
+                        if (!inputs) {
+                            return { type: "failed" };
+                        }
+                        const apiKey = await promptApiKey();
+                        if (!apiKey) {
+                            return { type: "failed" };
+                        }
+                        try {
+                            await validateApiKey(apiKey);
+                            const email = await promptEmail();
+                            const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                            const acc = {
+                                id: generateAccountId(),
+                                email,
+                                authMethod: "apikey",
+                                apiKey,
+                                rateLimitResetTime: 0,
+                                isHealthy: true,
+                            };
+                            am.addAccount(acc);
+                            await am.saveToDisk();
+                            return { type: "success", key: apiKey };
+                        }
+                        catch (error) {
+                            return { type: "failed" };
+                        }
+                    },
+                },
+            ],
+        },
+        "chat.headers": async (input, output) => {
+            output.headers["User-Agent"] = `${IFLOW_CONSTANTS.USER_AGENT}/2.0`;
+        },
+    };
+};

package/dist/plugin.d.ts

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

package/dist/plugin.js

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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@asframe/opencode-iflow-auth",
+  "version": "1.0.0",
+  "description": "OpenCode plugin for iFlow.cn - Access Qwen, DeepSeek, Kimi, GLM-5 models with OAuth 2.0, API Key, and CLI Proxy support",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "format": "prettier --write --no-config --no-semi --single-quote --trailing-comma none --print-width 100 'src/**/*.ts'",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "iflow",
+    "glm-5",
+    "qwen",
+    "deepseek",
+    "kimi",
+    "ai",
+    "auth",
+    "oauth",
+    "apikey",
+    "cli-proxy"
+  ],
+  "author": "asframe",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asframe/opencode-iflow-auth.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.6",
+    "proper-lockfile": "^4.1.2",
+    "tiktoken": "^1.0.17",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "prettier": "^3.4.2",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "typescript": "^5.7.3"
+  },
+  "opencode": {
+    "type": "plugin",
+    "hooks": [
+      "auth",
+      "event",
+      "chat.headers"
+    ]
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ]
+}