@lightharu/krouter 1.8.0

package/out-server/server/services/proxyRuntime.js

@@ -0,0 +1,523 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyRuntime = void 0;
+exports.getProxyRuntime = getProxyRuntime;
+const crypto_1 = __importDefault(require("crypto"));
+const proxyServer_1 = require("../../main/proxy/proxyServer");
+const clientConfig_1 = require("../../main/proxy/clientConfig");
+const logger_1 = require("../../main/proxy/logger");
+const runtimePaths_1 = require("../../main/runtimePaths");
+const kiroApi_1 = require("../../main/proxy/kiroApi");
+const kiroAccounts_1 = require("./kiroAccounts");
+const accountProfileHydration_1 = require("./accountProfileHydration");
+const CLIENT_PROXY_API_KEY_NAME = 'OpenClaw - Krouter API Proxy';
+function defaultProxyConfig(saved) {
+    return normalizeProxyConfig({
+        enabled: false,
+        port: 5580,
+        host: '127.0.0.1',
+        enableMultiAccount: true,
+        selectedAccountIds: [],
+        logRequests: true,
+        maxConcurrent: 10,
+        maxRetries: 3,
+        retryDelayMs: 1000,
+        tokenRefreshBeforeExpiry: 300,
+        clientDrivenToolExecution: true,
+        accountSelectionStrategy: 'round-robin',
+        sessionAffinityEnabled: false,
+        ...saved
+    });
+}
+function normalizeProxyConfig(config) {
+    const strategy = config.accountSelectionStrategy || 'round-robin';
+    const normalized = {
+        ...config,
+        accountSelectionStrategy: strategy
+    };
+    if (normalized.enableMultiAccount && strategy !== 'sticky') {
+        normalized.sessionAffinityEnabled = false;
+    }
+    return normalized;
+}
+function serializeStats(stats) {
+    return {
+        ...stats,
+        accountStats: Object.fromEntries(stats.accountStats),
+        endpointStats: Object.fromEntries(stats.endpointStats),
+        modelStats: Object.fromEntries(stats.modelStats)
+    };
+}
+function normalizeProxyAccount(account) {
+    return {
+        ...account,
+        authMethod: account.authMethod === 'idc' ? 'IdC' : account.authMethod
+    };
+}
+function resolveProxyProfileArn(account) {
+    const credentials = account.credentials || {};
+    return (0, kiroApi_1.resolveProfileArn)({
+        profileArn: account.profileArn || credentials.profileArn,
+        authMethod: credentials.authMethod,
+        provider: credentials.provider || account.idp
+    });
+}
+function newApiKey(input) {
+    return {
+        id: crypto_1.default.randomUUID(),
+        name: input.name || 'API Key',
+        key: input.key || `sk-${crypto_1.default.randomBytes(24).toString('base64url')}`,
+        format: input.format || 'sk',
+        enabled: true,
+        createdAt: Date.now(),
+        creditsLimit: input.creditsLimit,
+        usage: {
+            totalRequests: 0,
+            totalCredits: 0,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            daily: {}
+        }
+    };
+}
+function detectApiKeyFormat(key) {
+    if (key.includes(':'))
+        return 'token';
+    if (key.startsWith('sk-'))
+        return 'sk';
+    return 'simple';
+}
+class ProxyRuntime {
+    store;
+    userId;
+    emit;
+    server = null;
+    autoStartInFlight = null;
+    constructor(store, userId, emit) {
+        this.store = store;
+        this.userId = userId;
+        this.emit = emit;
+        logger_1.proxyLogStore.initialize((0, runtimePaths_1.getRuntimeUserDataPath)());
+        (0, logger_1.interceptConsole)();
+    }
+    get savedConfig() {
+        return defaultProxyConfig(this.store.getUserSetting(this.userId, 'proxyConfig', {}));
+    }
+    async persistConfig() {
+        if (this.server) {
+            await this.store.setUserSetting(this.userId, 'proxyConfig', this.server.getConfig());
+        }
+    }
+    wantsRunning(config) {
+        const lastRunning = this.store.getUserSetting(this.userId, 'proxyRunning', false);
+        return Boolean(config.autoStart || config.enabled || lastRunning);
+    }
+    async ensureAutoStarted(reason = 'auto') {
+        const server = this.getOrCreateServer();
+        if (server.isRunning())
+            return { success: true, port: server.getConfig().port };
+        if (!this.wantsRunning(server.getConfig()))
+            return { success: true };
+        if (this.autoStartInFlight)
+            return this.autoStartInFlight;
+        this.autoStartInFlight = (async () => {
+            try {
+                console.log(`[ProxyRuntime] Auto-starting proxy for user=${this.userId} (${reason})`);
+                await this.syncAccountsFromStoreAsync();
+                server.updateConfig({ enabled: true });
+                await server.start();
+                await this.persistConfig();
+                await this.store.setUserSetting(this.userId, 'proxyRunning', true);
+                return { success: true, port: server.getConfig().port };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Failed to auto-start proxy server';
+                console.error('[ProxyRuntime] Auto-start failed:', message);
+                return { success: false, error: message };
+            }
+            finally {
+                this.autoStartInFlight = null;
+            }
+        })();
+        return this.autoStartInFlight;
+    }
+    getOrCreateServer() {
+        if (this.server)
+            return this.server;
+        this.server = new proxyServer_1.ProxyServer(this.savedConfig, {
+            onRequest: (info) => this.emit('proxy-request', info),
+            onResponse: (info) => this.emit('proxy-response', info),
+            onError: (error) => this.emit('proxy-error', error.message),
+            onStatusChange: (running, port) => this.emit('proxy-status-change', { running, port }),
+            onTokenRefresh: async (account) => {
+                const result = await (0, kiroAccounts_1.refreshTokenByMethod)({
+                    refreshToken: account.refreshToken || '',
+                    clientId: account.clientId,
+                    clientSecret: account.clientSecret,
+                    region: account.region || 'us-east-1',
+                    authMethod: account.authMethod,
+                    machineId: account.machineId
+                });
+                return {
+                    success: result.success,
+                    accessToken: result.accessToken,
+                    refreshToken: result.refreshToken,
+                    expiresAt: Date.now() + (result.expiresIn || 3600) * 1000,
+                    error: result.error
+                };
+            },
+            onAccountUpdate: (account) => {
+                this.emit('proxy-account-update', account);
+                void this.updatePersistedAccountCredentials(account);
+            },
+            onAccountSuspended: (info) => {
+                this.emit('proxy-account-suspended', {
+                    id: info.accountId,
+                    email: info.email,
+                    reason: info.reason,
+                    message: info.message,
+                    suspendedAt: Date.now()
+                });
+            },
+            onCreditsUpdate: (totalCredits) => void this.store.setUserSetting(this.userId, 'proxyTotalCredits', totalCredits),
+            onTokensUpdate: (inputTokens, outputTokens) => {
+                void this.store.setUserSetting(this.userId, 'proxyInputTokens', inputTokens);
+                void this.store.setUserSetting(this.userId, 'proxyOutputTokens', outputTokens);
+            },
+            onRequestStatsUpdate: (totalRequests, successRequests, failedRequests) => {
+                void this.store.setUserSetting(this.userId, 'proxyRequestStats', { totalRequests, successRequests, failedRequests });
+            },
+            onPoolEmpty: async () => {
+                await this.syncAccountsFromStoreAsync();
+            }
+        });
+        return this.server;
+    }
+    async updatePersistedAccountCredentials(account) {
+        const accountData = (this.store.getAccountData(this.userId) || {});
+        const existing = accountData.accounts?.[account.id];
+        if (!existing)
+            return;
+        existing.profileArn = account.profileArn || existing.profileArn;
+        existing.credentials = {
+            ...(existing.credentials || {}),
+            accessToken: account.accessToken,
+            refreshToken: account.refreshToken || existing.credentials?.refreshToken,
+            expiresAt: account.expiresAt
+        };
+        await this.store.setAccountData(this.userId, accountData);
+    }
+    syncAccountsFromStore() {
+        const server = this.getOrCreateServer();
+        const pool = server.getAccountPool();
+        const accountData = (this.store.getAccountData(this.userId) || {});
+        const accounts = Object.values(accountData.accounts || {});
+        const bindings = accountData.accountProxyBindings || {};
+        const proxyPool = accountData.proxyPool || {};
+        const proxyAccounts = [];
+        let skippedNoProfileArn = 0;
+        for (const account of accounts) {
+            if (account.status !== 'active' || !account.credentials?.accessToken)
+                continue;
+            const profileArn = resolveProxyProfileArn(account);
+            if (!profileArn) {
+                skippedNoProfileArn++;
+                continue;
+            }
+            const proxyId = bindings[account.id];
+            const boundProxy = proxyId ? proxyPool[proxyId] : undefined;
+            proxyAccounts.push(normalizeProxyAccount({
+                id: account.id,
+                email: account.email,
+                accessToken: account.credentials.accessToken,
+                refreshToken: account.credentials.refreshToken,
+                profileArn,
+                expiresAt: account.credentials.expiresAt,
+                clientId: account.credentials.clientId,
+                clientSecret: account.credentials.clientSecret,
+                region: account.credentials.region || 'us-east-1',
+                authMethod: account.credentials.authMethod,
+                provider: account.credentials.provider || account.idp,
+                machineId: account.machineId,
+                groupId: account.groupId,
+                proxyUrl: boundProxy?.enabled && boundProxy.status !== 'dead' ? boundProxy.url : undefined
+            }));
+        }
+        pool.replaceAccounts(proxyAccounts);
+        if (skippedNoProfileArn > 0) {
+            console.log(`[ProxyRuntime] Skipped ${skippedNoProfileArn} account(s) without profileArn`);
+        }
+        return { success: true, accountCount: pool.size };
+    }
+    async syncAccountsFromStoreAsync() {
+        const accountData = (this.store.getAccountData(this.userId) || {});
+        const hydrated = await (0, accountProfileHydration_1.hydrateAccountDataProfileArns)(accountData);
+        if (hydrated.changed) {
+            await this.store.setAccountData(this.userId, hydrated.data);
+        }
+        return this.syncAccountsFromStore();
+    }
+    async start(config) {
+        try {
+            const server = this.getOrCreateServer();
+            if (config)
+                server.updateConfig(config);
+            server.updateConfig({ enabled: true });
+            await this.syncAccountsFromStoreAsync();
+            await server.start();
+            await this.persistConfig();
+            await this.store.setUserSetting(this.userId, 'proxyRunning', true);
+            return { success: true, port: server.getConfig().port };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to start proxy server' };
+        }
+    }
+    async stop() {
+        try {
+            const server = this.getOrCreateServer();
+            if (server.isRunning())
+                await server.stop();
+            server.updateConfig({ enabled: false });
+            await this.persistConfig();
+            await this.store.setUserSetting(this.userId, 'proxyRunning', false);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to stop proxy server' };
+        }
+    }
+    async getStatus() {
+        await this.ensureAutoStarted('status');
+        const server = this.getOrCreateServer();
+        return {
+            running: server.isRunning(),
+            config: server.getConfig(),
+            stats: serializeStats(server.getStats()),
+            sessionStats: server.getSessionStats()
+        };
+    }
+    async updateConfig(config) {
+        try {
+            const server = this.getOrCreateServer();
+            server.updateConfig(config);
+            await this.persistConfig();
+            if (!server.isRunning() && (config.autoStart === true || config.enabled === true)) {
+                const started = await this.ensureAutoStarted('config-update');
+                if (!started.success) {
+                    return { success: false, config: server.getConfig(), error: started.error };
+                }
+            }
+            return { success: true, config: server.getConfig() };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to update proxy config' };
+        }
+    }
+    needsRestart() {
+        return { needsRestart: this.server?.needsRestart() || false };
+    }
+    async restart() {
+        try {
+            const server = this.getOrCreateServer();
+            await this.syncAccountsFromStoreAsync();
+            await server.restartServer();
+            await this.persistConfig();
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to restart proxy server' };
+        }
+    }
+    addAccount(account) {
+        try {
+            const pool = this.getOrCreateServer().getAccountPool();
+            pool.addAccount(normalizeProxyAccount(account));
+            return { success: true, accountCount: pool.size };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to add account' };
+        }
+    }
+    removeAccount(accountId) {
+        try {
+            const pool = this.getOrCreateServer().getAccountPool();
+            pool.removeAccount(accountId);
+            return { success: true, accountCount: pool.size };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to remove account' };
+        }
+    }
+    syncAccounts(accounts) {
+        try {
+            const pool = this.getOrCreateServer().getAccountPool();
+            pool.replaceAccounts(accounts.map(normalizeProxyAccount));
+            return { success: true, accountCount: pool.size };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to sync accounts' };
+        }
+    }
+    getAccounts() {
+        const pool = this.getOrCreateServer().getAccountPool();
+        return { accounts: pool.getAllAccounts(), availableCount: pool.availableCount };
+    }
+    resetPool() {
+        this.getOrCreateServer().getAccountPool().reset();
+        return { success: true };
+    }
+    clearAccountSuspended(accountId) {
+        this.getOrCreateServer().getAccountPool().clearSuspended(accountId);
+        return { success: true };
+    }
+    async getModels() {
+        try {
+            const result = await this.getOrCreateServer().getAvailableModels();
+            return { success: true, ...result };
+        }
+        catch (error) {
+            return { success: false, models: [], error: error instanceof Error ? error.message : 'Failed to get models' };
+        }
+    }
+    refreshModels() {
+        this.getOrCreateServer().clearModelCache();
+        return { success: true };
+    }
+    selfSignedCertInfo() {
+        const cert = this.getOrCreateServer().getSelfSignedCertInfo();
+        return cert ? { success: true, ...cert } : { success: false, error: 'Failed to generate certificate' };
+    }
+    selfSignedCertRegenerate() {
+        const cert = this.getOrCreateServer().regenerateSelfSignedCert();
+        return cert ? { success: true, ...cert } : { success: false, error: 'Failed to regenerate certificate' };
+    }
+    getLogs(count) {
+        return count ? logger_1.proxyLogStore.getLast(count) : logger_1.proxyLogStore.getAll();
+    }
+    clearLogs() {
+        logger_1.proxyLogStore.clear();
+        return { success: true };
+    }
+    getLogsCount() {
+        return logger_1.proxyLogStore.count();
+    }
+    resetCredits() {
+        this.getOrCreateServer().resetTotalCredits();
+        return { success: true };
+    }
+    resetTokens() {
+        this.getOrCreateServer().resetTotalTokens();
+        return { success: true };
+    }
+    resetRequestStats() {
+        this.getOrCreateServer().resetRequestStats();
+        return { success: true };
+    }
+    getApiKeys() {
+        return { success: true, apiKeys: this.getOrCreateServer().getConfig().apiKeys || [] };
+    }
+    async getOrCreateClientApiKey() {
+        const server = this.getOrCreateServer();
+        const config = server.getConfig();
+        const apiKeys = [...(config.apiKeys || [])];
+        let apiKey = apiKeys.find((item) => item.name === CLIENT_PROXY_API_KEY_NAME);
+        let changed = false;
+        if (!apiKey) {
+            const legacyKey = (config.apiKey || '').trim();
+            apiKey = newApiKey({
+                name: CLIENT_PROXY_API_KEY_NAME,
+                key: legacyKey || undefined,
+                format: legacyKey ? detectApiKeyFormat(legacyKey) : 'sk'
+            });
+            apiKeys.unshift(apiKey);
+            changed = true;
+        }
+        if (!apiKey.enabled) {
+            apiKey.enabled = true;
+            changed = true;
+        }
+        if (changed) {
+            server.updateConfig({ apiKeys });
+            await this.persistConfig();
+        }
+        return apiKey;
+    }
+    async addApiKey(input) {
+        const server = this.getOrCreateServer();
+        const apiKeys = [...(server.getConfig().apiKeys || []), newApiKey(input || {})];
+        server.updateConfig({ apiKeys });
+        await this.persistConfig();
+        return { success: true, apiKey: apiKeys[apiKeys.length - 1] };
+    }
+    async updateApiKey(id, updates) {
+        const server = this.getOrCreateServer();
+        const apiKeys = [...(server.getConfig().apiKeys || [])];
+        const apiKey = apiKeys.find((item) => item.id === id);
+        if (!apiKey)
+            return { success: false, error: 'API key not found' };
+        Object.assign(apiKey, updates);
+        if (updates.creditsLimit === null)
+            delete apiKey.creditsLimit;
+        server.updateConfig({ apiKeys });
+        await this.persistConfig();
+        return { success: true, apiKey };
+    }
+    async deleteApiKey(id) {
+        const server = this.getOrCreateServer();
+        const apiKeys = (server.getConfig().apiKeys || []).filter((item) => item.id !== id);
+        server.updateConfig({ apiKeys });
+        await this.persistConfig();
+        return { success: true };
+    }
+    async resetApiKeyUsage(id) {
+        const server = this.getOrCreateServer();
+        const apiKeys = [...(server.getConfig().apiKeys || [])];
+        const apiKey = apiKeys.find((item) => item.id === id);
+        if (!apiKey)
+            return { success: false, error: 'API key not found' };
+        apiKey.usage = { totalRequests: 0, totalCredits: 0, totalInputTokens: 0, totalOutputTokens: 0, daily: {} };
+        apiKey.usageHistory = [];
+        server.updateConfig({ apiKeys });
+        await this.persistConfig();
+        return { success: true };
+    }
+    auditLog() {
+        return { entries: [...this.getOrCreateServer().getAuditLog()] };
+    }
+    async configureClients(input) {
+        const config = this.getOrCreateServer().getConfig();
+        const apiKey = await this.getOrCreateClientApiKey();
+        const result = await (0, clientConfig_1.configureProxyClients)({
+            clients: input.clients,
+            host: config.host,
+            port: config.port,
+            tlsEnabled: config.tls?.enabled,
+            apiKey: apiKey.key,
+            modelId: input.modelId,
+            modelName: input.modelName,
+            models: input.models
+        });
+        return {
+            ...result,
+            apiKey: {
+                id: apiKey.id,
+                name: apiKey.name,
+                key: apiKey.key
+            }
+        };
+    }
+}
+exports.ProxyRuntime = ProxyRuntime;
+const runtimes = new Map();
+function getProxyRuntime(store, userId, emit) {
+    const existing = runtimes.get(userId);
+    if (existing)
+        return existing;
+    const runtime = new ProxyRuntime(store, userId, emit);
+    runtimes.set(userId, runtime);
+    return runtime;
+}

package/out-server/server/services/registrationRuntime.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registrationStartAuto = registrationStartAuto;
+exports.registrationManualPhase1 = registrationManualPhase1;
+exports.registrationManualPhase2 = registrationManualPhase2;
+exports.registrationManualPhase3 = registrationManualPhase3;
+exports.registrationCancel = registrationCancel;
+exports.registrationStatus = registrationStatus;
+exports.protonOpenLogin = protonOpenLogin;
+exports.protonLoginStatus = protonLoginStatus;
+exports.protonClose = protonClose;
+const config_1 = require("../../main/registration/config");
+const registrar_1 = require("../../main/registration/registrar");
+const protonBrowserRuntime_1 = require("./protonBrowserRuntime");
+const registrarPool = new Map();
+const MANUAL_KEY = '__manual__';
+function emitLog(emit, message, taskId) {
+    emit('registration-log', { message, taskId });
+}
+function emitStep(emit, event, taskId) {
+    emit('registration-step', { taskId, event });
+}
+async function registrationStartAuto(input, emit) {
+    const taskId = input.taskId || `auto-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const prefix = input.taskId ? `[#${input.taskId.slice(0, 12)}] ` : '';
+    const cfg = (0, config_1.newConfig)(input);
+    cfg.manualMode = false;
+    const registrar = new registrar_1.Registrar(cfg, (message) => emitLog(emit, `${prefix}${message}`, input.taskId), (event) => emitStep(emit, event, input.taskId));
+    registrarPool.set(taskId, registrar);
+    try {
+        const result = await registrar.run();
+        registrarPool.delete(taskId);
+        if (!input.taskId)
+            emit('registration-complete', result);
+        return { success: true, result };
+    }
+    catch (error) {
+        registrarPool.delete(taskId);
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function registrationManualPhase1(input, emit) {
+    if (registrarPool.has(MANUAL_KEY))
+        return { success: false, error: 'A manual registration flow is already in progress' };
+    const cfg = (0, config_1.newConfig)(input);
+    cfg.manualMode = true;
+    const registrar = new registrar_1.Registrar(cfg, (message) => emitLog(emit, message), (event) => emitStep(emit, event));
+    registrarPool.set(MANUAL_KEY, registrar);
+    const result = await registrar.runManualPhase1();
+    if (!result.success) {
+        await registrar.destroy();
+        registrarPool.delete(MANUAL_KEY);
+    }
+    return result;
+}
+async function registrationManualPhase2(email, fullName) {
+    const registrar = registrarPool.get(MANUAL_KEY);
+    if (!registrar)
+        return { success: false, error: 'No manual registration flow is in progress' };
+    const result = await registrar.runManualPhase2(email, fullName);
+    if (!result.success) {
+        await registrar.destroy();
+        registrarPool.delete(MANUAL_KEY);
+    }
+    return result;
+}
+async function registrationManualPhase3(otp) {
+    const registrar = registrarPool.get(MANUAL_KEY);
+    if (!registrar)
+        return { success: false, error: 'No manual registration flow is in progress' };
+    const result = await registrar.runManualPhase3(otp);
+    await registrar.destroy();
+    registrarPool.delete(MANUAL_KEY);
+    return { success: true, result };
+}
+async function registrationCancel(taskId) {
+    if (taskId) {
+        const registrar = registrarPool.get(taskId);
+        if (registrar) {
+            registrar.abort();
+            await registrar.destroy();
+            registrarPool.delete(taskId);
+        }
+        return { success: true };
+    }
+    const tasks = Array.from(registrarPool.entries());
+    for (const [id, registrar] of tasks) {
+        registrar.abort();
+        await registrar.destroy();
+        registrarPool.delete(id);
+    }
+    return { success: true };
+}
+function registrationStatus() {
+    return { inProgress: registrarPool.size > 0, count: registrarPool.size };
+}
+function protonOpenLogin() {
+    return (0, protonBrowserRuntime_1.openProtonLogin)();
+}
+function protonLoginStatus() {
+    return (0, protonBrowserRuntime_1.getProtonLoginStatus)();
+}
+async function protonClose() {
+    await (0, protonBrowserRuntime_1.closeProtonWindow)();
+    return { success: true };
+}