@lightharu/krouter 1.8.0

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountGetModels = accountGetModels;
+exports.accountGetSubscriptions = accountGetSubscriptions;
+exports.accountGetSubscriptionUrl = accountGetSubscriptionUrl;
+exports.accountSetOverage = accountSetOverage;
+const kiroApi_1 = require("../../main/proxy/kiroApi");
+const modelCatalog_1 = require("../../main/proxy/modelCatalog");
+function accountFromArgs(args, fallbackId) {
+    const [accessToken, , region, profileArn, machineId, provider, authMethod, accountId] = args;
+    if (!accessToken)
+        return null;
+    return {
+        id: accountId || fallbackId,
+        accessToken,
+        region: region || 'us-east-1',
+        profileArn,
+        machineId,
+        provider,
+        authMethod
+    };
+}
+async function accountGetModels(args) {
+    const account = accountFromArgs([args[0], undefined, args[1], args[2], args[3], args[4], args[5], args[6]], 'model-list-request');
+    if (!account)
+        return { success: false, error: 'Missing access token', models: [] };
+    try {
+        const models = await (0, kiroApi_1.fetchKiroModels)(account);
+        const output = models.map((model) => ({
+            id: model.modelId,
+            name: model.modelName,
+            description: model.description,
+            inputTypes: model.supportedInputTypes,
+            maxInputTokens: model.tokenLimits?.maxInputTokens,
+            maxOutputTokens: model.tokenLimits?.maxOutputTokens,
+            rateMultiplier: model.rateMultiplier,
+            rateUnit: model.rateUnit
+        }));
+        const seen = new Set(output.map((model) => String(model.id)));
+        for (const preset of modelCatalog_1.KIRO_PROXY_MODEL_PRESETS) {
+            if (!seen.has(preset.id)) {
+                seen.add(preset.id);
+                output.push({
+                    id: preset.id,
+                    name: preset.name,
+                    description: preset.description,
+                    inputTypes: preset.inputTypes,
+                    maxInputTokens: preset.maxInputTokens,
+                    maxOutputTokens: preset.maxOutputTokens,
+                    rateMultiplier: undefined,
+                    rateUnit: undefined
+                });
+            }
+        }
+        return {
+            success: true,
+            models: output
+        };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to get models', models: [] };
+    }
+}
+async function accountGetSubscriptions(args) {
+    const account = accountFromArgs(args, 'subscription-request');
+    if (!account)
+        return { success: false, error: 'Missing access token', plans: [] };
+    try {
+        const result = await (0, kiroApi_1.fetchAvailableSubscriptions)(account);
+        if (result.subscriptionPlans)
+            return { success: true, plans: result.subscriptionPlans, disclaimer: result.disclaimer };
+        return { success: false, error: 'No subscription plans returned', plans: [] };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to get subscriptions', plans: [] };
+    }
+}
+async function accountGetSubscriptionUrl(args) {
+    const account = accountFromArgs([args[0], undefined, args[2], args[3], args[4], args[5], args[6], args[7]], 'subscription-request');
+    if (!account)
+        return { success: false, error: 'Missing access token' };
+    try {
+        const result = await (0, kiroApi_1.fetchSubscriptionToken)(account, args[1]);
+        if (result.encodedVerificationUrl)
+            return { success: true, url: result.encodedVerificationUrl, status: result.status };
+        return { success: false, error: result.message || 'No subscription URL returned' };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to get subscription URL' };
+    }
+}
+async function accountSetOverage(args) {
+    const overageStatus = args[1];
+    if (overageStatus !== 'ENABLED' && overageStatus !== 'DISABLED')
+        return { success: false, error: 'Invalid overage status' };
+    const account = accountFromArgs([args[0], undefined, args[2], args[3], args[4], args[5], args[6], args[7]], 'subscription-request');
+    if (!account)
+        return { success: false, error: 'Missing access token' };
+    try {
+        return await (0, kiroApi_1.setUserPreference)(account, overageStatus);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to set overage' };
+    }
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateAccountDataProfileArns = hydrateAccountDataProfileArns;
+const kiroAccounts_1 = require("./kiroAccounts");
+function shouldResolveProfileArn(account) {
+    const credentials = account.credentials || {};
+    const provider = String(credentials.provider || account.idp || '').trim().toLowerCase();
+    const authMethod = String(credentials.authMethod || '').trim().toLowerCase();
+    if (provider === 'builderid' || provider === 'builder_id')
+        return true;
+    if (provider === 'github' || provider === 'google')
+        return true;
+    if (authMethod === 'social')
+        return true;
+    if (authMethod === 'idc' || authMethod === 'external_idp')
+        return true;
+    if (provider.includes('enterprise') || provider.includes('iam') || provider.includes('idc') || provider.includes('sso')) {
+        return true;
+    }
+    return false;
+}
+async function ensureAccessToken(account) {
+    const credentials = account.credentials || {};
+    let accessToken = credentials.accessToken;
+    let changed = false;
+    const expiresAt = Number(credentials.expiresAt || 0);
+    const needsRefresh = Boolean(credentials.refreshToken) && (!accessToken || expiresAt < Date.now() + 300000);
+    if (!needsRefresh)
+        return { accessToken, changed };
+    const refresh = await (0, kiroAccounts_1.refreshTokenByMethod)({
+        refreshToken: credentials.refreshToken || '',
+        clientId: credentials.clientId,
+        clientSecret: credentials.clientSecret,
+        region: credentials.region || 'us-east-1',
+        authMethod: credentials.authMethod,
+        provider: credentials.provider || account.idp,
+        machineId: account.machineId
+    }).catch(() => null);
+    if (refresh?.success && refresh.accessToken) {
+        accessToken = refresh.accessToken;
+        credentials.accessToken = refresh.accessToken;
+        credentials.refreshToken = refresh.refreshToken || credentials.refreshToken;
+        credentials.expiresAt = Date.now() + (refresh.expiresIn || 3600) * 1000;
+        changed = true;
+    }
+    return { accessToken, changed };
+}
+async function hydrateAccountDataProfileArns(rawData) {
+    const accountData = rawData;
+    const accounts = Object.values(accountData.accounts || {});
+    let changed = false;
+    let resolvedCount = 0;
+    for (const account of accounts) {
+        const normalized = (0, kiroAccounts_1.normalizeProfileArn)(account.profileArn || account.credentials?.profileArn);
+        if (normalized) {
+            if (account.profileArn !== normalized) {
+                account.profileArn = normalized;
+                changed = true;
+            }
+            continue;
+        }
+        if (account.status && account.status !== 'active')
+            continue;
+        if (!account.credentials || !shouldResolveProfileArn(account))
+            continue;
+        const token = await ensureAccessToken(account);
+        if (token.changed)
+            changed = true;
+        if (!token.accessToken)
+            continue;
+        const profileArn = await (0, kiroAccounts_1.resolveStreamingProfileArn)({
+            accessToken: token.accessToken,
+            machineId: account.machineId,
+            region: account.credentials.region || 'us-east-1',
+            authMethod: account.credentials.authMethod,
+            provider: account.credentials.provider || account.idp
+        }).catch(() => undefined);
+        if (!profileArn)
+            continue;
+        let accountChanged = false;
+        if (account.profileArn !== profileArn) {
+            account.profileArn = profileArn;
+            accountChanged = true;
+        }
+        if (account.credentials.profileArn !== profileArn) {
+            account.credentials.profileArn = profileArn;
+            accountChanged = true;
+        }
+        if (accountChanged) {
+            changed = true;
+            resolvedCount++;
+        }
+    }
+    return { data: rawData, changed, resolvedCount };
+}