@lightharu/krouter 1.8.0

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

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOCIAL_SIGN_IN_PROFILE_ARN = exports.BUILDER_ID_STREAMING_PROFILE_ARN = void 0;
+exports.normalizeProfileArn = normalizeProfileArn;
+exports.refreshTokenByMethod = refreshTokenByMethod;
+exports.listAvailableProfilesRest = listAvailableProfilesRest;
+exports.resolveStreamingProfileArn = resolveStreamingProfileArn;
+exports.refreshAccountToken = refreshAccountToken;
+exports.verifyAccountCredentials = verifyAccountCredentials;
+exports.checkAccountStatus = checkAccountStatus;
+const KIRO_AUTH_ENDPOINT = 'https://prod.us-east-1.auth.desktop.kiro.dev';
+const KIRO_VERSION = '0.6.18';
+exports.BUILDER_ID_STREAMING_PROFILE_ARN = 'arn:aws:codewhisperer:us-east-1:638616132270:profile/AAAACCCCXXXX';
+exports.SOCIAL_SIGN_IN_PROFILE_ARN = 'arn:aws:codewhisperer:us-east-1:699475941385:profile/EHGA3GRVQMUK';
+const KIRO_REST_API_ENDPOINTS = {
+    'us-east-1': 'https://q.us-east-1.amazonaws.com',
+    'eu-central-1': 'https://q.eu-central-1.amazonaws.com'
+};
+function normalizeProfileArn(profileArn) {
+    let value = profileArn?.trim();
+    if (!value || value === exports.BUILDER_ID_STREAMING_PROFILE_ARN)
+        return undefined;
+    if (!value.startsWith('arn:') && value.includes(':codewhisperer:'))
+        value = `arn:${value}`;
+    return value;
+}
+function fixedProfileArnForProvider(provider, authMethod, profileArn) {
+    const providerKey = (provider || '').trim().toLowerCase();
+    const authKey = (authMethod || '').trim().toLowerCase();
+    const explicit = normalizeProfileArn(profileArn);
+    if (authKey === 'social' && explicit)
+        return explicit;
+    if (providerKey === 'github' || providerKey === 'google')
+        return exports.SOCIAL_SIGN_IN_PROFILE_ARN;
+    if (providerKey === 'builderid' || providerKey === 'builder_id')
+        return exports.BUILDER_ID_STREAMING_PROFILE_ARN;
+    return undefined;
+}
+function getRestApiBase(ssoRegion) {
+    if (!ssoRegion)
+        return KIRO_REST_API_ENDPOINTS['us-east-1'];
+    if (KIRO_REST_API_ENDPOINTS[ssoRegion])
+        return KIRO_REST_API_ENDPOINTS[ssoRegion];
+    if (ssoRegion.startsWith('eu-'))
+        return KIRO_REST_API_ENDPOINTS['eu-central-1'];
+    return KIRO_REST_API_ENDPOINTS['us-east-1'];
+}
+function getFallbackRestApiBase(ssoRegion) {
+    const primary = getRestApiBase(ssoRegion);
+    return primary === KIRO_REST_API_ENDPOINTS['eu-central-1']
+        ? KIRO_REST_API_ENDPOINTS['us-east-1']
+        : KIRO_REST_API_ENDPOINTS['eu-central-1'];
+}
+function getKiroUserAgent(machineId) {
+    const suffix = machineId ? `KiroIDE-${KIRO_VERSION}-${machineId}` : `KiroIDE-${KIRO_VERSION}`;
+    return `aws-sdk-js/1.0.18 ua/2.1 os/linux lang/js md/nodejs#22 api/codewhispererstreaming#1.0.18 m/E ${suffix}`;
+}
+function getKiroAmzUserAgent(machineId) {
+    const suffix = machineId ? `KiroIDE ${KIRO_VERSION} ${machineId}` : `KiroIDE-${KIRO_VERSION}`;
+    return `aws-sdk-js/1.0.18 ${suffix}`;
+}
+function normalizeDate(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'number')
+        return new Date(value * 1000).toISOString();
+    return value;
+}
+function subscriptionTypeFromTitle(title) {
+    const upper = title.toUpperCase();
+    if (upper.includes('PRO+') || upper.includes('PRO_PLUS') || upper.includes('PROPLUS'))
+        return 'Pro_Plus';
+    if (upper.includes('POWER'))
+        return 'Enterprise';
+    if (upper.includes('PRO'))
+        return 'Pro';
+    if (upper.includes('ENTERPRISE'))
+        return 'Enterprise';
+    if (upper.includes('TEAMS'))
+        return 'Teams';
+    return 'Free';
+}
+async function refreshOidcToken(input) {
+    const response = await fetch(`https://oidc.${input.region}.amazonaws.com/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            clientId: input.clientId,
+            clientSecret: input.clientSecret,
+            refreshToken: input.refreshToken,
+            grantType: 'refresh_token'
+        })
+    });
+    if (!response.ok)
+        return { success: false, error: `HTTP ${response.status}: ${await response.text()}` };
+    const data = await response.json();
+    return {
+        success: Boolean(data.accessToken),
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken || input.refreshToken,
+        expiresIn: data.expiresIn || 3600
+    };
+}
+async function refreshSocialToken(refreshToken, machineId) {
+    const response = await fetch(`${KIRO_AUTH_ENDPOINT}/refreshToken`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': getKiroUserAgent(machineId)
+        },
+        body: JSON.stringify({ refreshToken })
+    });
+    if (!response.ok)
+        return { success: false, error: `HTTP ${response.status}: ${await response.text()}` };
+    const data = await response.json();
+    return {
+        success: Boolean(data.accessToken),
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken || refreshToken,
+        expiresIn: data.expiresIn || 3600
+    };
+}
+async function refreshTokenByMethod(input) {
+    const region = input.region || 'us-east-1';
+    if (!input.refreshToken)
+        return { success: false, error: 'Missing refresh token' };
+    if (input.authMethod === 'social')
+        return refreshSocialToken(input.refreshToken, input.machineId);
+    if (!input.clientId || !input.clientSecret)
+        return { success: false, error: 'Missing OIDC clientId/clientSecret' };
+    return refreshOidcToken({
+        refreshToken: input.refreshToken,
+        clientId: input.clientId,
+        clientSecret: input.clientSecret,
+        region
+    });
+}
+async function getUsageLimitsRest(input) {
+    const params = new URLSearchParams({
+        origin: 'AI_EDITOR',
+        resourceType: 'AGENTIC_REQUEST',
+        isEmailRequired: 'true'
+    });
+    const profileArn = normalizeProfileArn(input.profileArn);
+    if (profileArn)
+        params.set('profileArn', profileArn);
+    const path = `/getUsageLimits?${params.toString()}`;
+    const headers = {
+        Accept: 'application/json',
+        Authorization: `Bearer ${input.accessToken}`,
+        'User-Agent': getKiroUserAgent(input.machineId),
+        'x-amz-user-agent': getKiroAmzUserAgent(input.machineId)
+    };
+    let response = await fetch(`${getRestApiBase(input.region)}${path}`, { method: 'GET', headers });
+    if (response.status === 403) {
+        response = await fetch(`${getFallbackRestApiBase(input.region)}${path}`, { method: 'GET', headers });
+    }
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    return response.json();
+}
+function uniqueEndpoints(region) {
+    return Array.from(new Set([
+        getRestApiBase(region),
+        getFallbackRestApiBase(region)
+    ]));
+}
+async function postListAvailableProfiles(input) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.timeoutMs || 10000);
+    try {
+        const response = await fetch(`${input.endpoint}/ListAvailableProfiles`, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${input.accessToken}`,
+                'User-Agent': getKiroUserAgent(input.machineId),
+                'x-amz-user-agent': getKiroAmzUserAgent(input.machineId)
+            },
+            body: JSON.stringify(input.nextToken ? { nextToken: input.nextToken } : {})
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}: ${text}`);
+        return text ? JSON.parse(text) : {};
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function listAvailableProfilesRest(input) {
+    let lastError;
+    for (const endpoint of uniqueEndpoints(input.region || 'us-east-1')) {
+        try {
+            const profiles = [];
+            let nextToken;
+            let page = 0;
+            do {
+                const data = await postListAvailableProfiles({
+                    endpoint,
+                    accessToken: input.accessToken,
+                    machineId: input.machineId,
+                    nextToken,
+                    timeoutMs: input.timeoutMs
+                });
+                profiles.push(...(Array.isArray(data.profiles) ? data.profiles : []));
+                nextToken = data.nextToken;
+                page++;
+            } while (nextToken && page < 20);
+            if (profiles.length > 0)
+                return profiles;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    if (lastError)
+        throw lastError;
+    return [];
+}
+function getProfileArn(profile) {
+    return normalizeProfileArn(profile.arn || profile.profileArn || profile.profile_arn);
+}
+function chooseStreamingProfileArn(profiles) {
+    const candidates = profiles
+        .map((profile) => ({
+        arn: getProfileArn(profile),
+        name: String(profile.profileName || profile.name || '').toLowerCase(),
+        status: String(profile.status || '').toLowerCase()
+    }))
+        .filter((profile) => Boolean(profile.arn));
+    if (candidates.length === 0)
+        return undefined;
+    return (candidates.find((profile) => profile.status === 'active' && profile.name.includes('kiroprofile') && profile.arn.includes(':us-east-1:')) ||
+        candidates.find((profile) => profile.name.includes('kiroprofile') && profile.arn.includes(':us-east-1:')) ||
+        candidates.find((profile) => profile.status === 'active' && profile.arn.includes(':us-east-1:')) ||
+        candidates.find((profile) => profile.arn.includes(':us-east-1:')) ||
+        candidates.find((profile) => profile.status === 'active') ||
+        candidates[0]).arn;
+}
+async function resolveStreamingProfileArn(input) {
+    const explicit = normalizeProfileArn(input.profileArn);
+    if (explicit)
+        return explicit;
+    const fixedProfileArn = fixedProfileArnForProvider(input.provider, input.authMethod, input.profileArn);
+    if (fixedProfileArn)
+        return fixedProfileArn;
+    if (!input.accessToken)
+        return undefined;
+    const providerKey = (input.provider || '').trim().toLowerCase();
+    if (providerKey === 'builderid')
+        return undefined;
+    const profiles = await listAvailableProfilesRest({
+        accessToken: input.accessToken,
+        machineId: input.machineId,
+        region: input.region || 'us-east-1'
+    });
+    return chooseStreamingProfileArn(profiles);
+}
+function normalizeUsage(usage) {
+    const subscriptionTitle = usage.subscriptionInfo?.subscriptionTitle || usage.subscriptionInfo?.subscriptionName || 'Free';
+    const creditUsage = usage.usageBreakdownList?.find((item) => item.resourceType === 'CREDIT' || item.type === 'CREDIT');
+    const baseLimit = creditUsage?.usageLimitWithPrecision ?? creditUsage?.usageLimit ?? 0;
+    const baseCurrent = creditUsage?.currentUsageWithPrecision ?? creditUsage?.currentUsage ?? 0;
+    const trial = creditUsage?.freeTrialInfo || creditUsage?.freeTrialUsage;
+    const freeTrialActive = trial?.freeTrialStatus === 'ACTIVE';
+    const freeTrialLimit = freeTrialActive ? trial?.usageLimitWithPrecision ?? trial?.usageLimit ?? 0 : 0;
+    const freeTrialCurrent = freeTrialActive ? trial?.currentUsageWithPrecision ?? trial?.currentUsage ?? 0 : 0;
+    const bonuses = (creditUsage?.bonuses || [])
+        .filter((bonus) => !bonus.status || bonus.status === 'ACTIVE')
+        .map((bonus) => ({
+        code: bonus.bonusCode || '',
+        name: bonus.displayName || '',
+        current: bonus.currentUsageWithPrecision ?? bonus.currentUsage ?? 0,
+        limit: bonus.usageLimitWithPrecision ?? bonus.usageLimit ?? 0,
+        expiresAt: normalizeDate(bonus.expiresAt)
+    }));
+    const totalLimit = baseLimit + freeTrialLimit + bonuses.reduce((sum, bonus) => sum + bonus.limit, 0);
+    const totalCurrent = baseCurrent + freeTrialCurrent + bonuses.reduce((sum, bonus) => sum + bonus.current, 0);
+    const nextResetDate = normalizeDate(usage.nextDateReset);
+    const expiresAt = nextResetDate ? new Date(nextResetDate).getTime() : undefined;
+    return {
+        email: usage.userInfo?.email || '',
+        userId: usage.userInfo?.userId || '',
+        subscriptionType: subscriptionTypeFromTitle(subscriptionTitle),
+        subscriptionTitle,
+        subscription: {
+            rawType: usage.subscriptionInfo?.type || usage.subscriptionInfo?.subscriptionType,
+            managementTarget: usage.subscriptionInfo?.subscriptionManagementTarget,
+            upgradeCapability: usage.subscriptionInfo?.upgradeCapability,
+            overageCapability: usage.subscriptionInfo?.overageCapability
+        },
+        usage: {
+            current: totalCurrent,
+            limit: totalLimit,
+            baseLimit,
+            baseCurrent,
+            freeTrialLimit,
+            freeTrialCurrent,
+            freeTrialExpiry: normalizeDate(trial?.freeTrialExpiry),
+            bonuses,
+            nextResetDate,
+            resourceDetail: creditUsage ? {
+                displayName: creditUsage.displayName,
+                displayNamePlural: creditUsage.displayNamePlural,
+                resourceType: creditUsage.resourceType || creditUsage.type,
+                currency: creditUsage.currency,
+                unit: creditUsage.unit,
+                overageRate: creditUsage.overageRate,
+                overageCap: creditUsage.overageCap,
+                overageEnabled: usage.overageConfiguration?.overageStatus === 'ENABLED' || usage.overageConfiguration?.overageEnabled === true || usage.overageSettings?.overageStatus === 'ENABLED'
+            } : undefined
+        },
+        daysRemaining: expiresAt ? Math.max(0, Math.ceil((expiresAt - Date.now()) / 86400000)) : undefined,
+        expiresAt
+    };
+}
+async function refreshAccountToken(account) {
+    const credentials = account.credentials || {};
+    const result = await refreshTokenByMethod({
+        refreshToken: credentials.refreshToken || '',
+        clientId: credentials.clientId,
+        clientSecret: credentials.clientSecret,
+        region: credentials.region,
+        authMethod: credentials.authMethod,
+        machineId: account.machineId
+    });
+    if (!result.success || !result.accessToken) {
+        return { success: false, error: { message: result.error || 'Token refresh failed' } };
+    }
+    return {
+        success: true,
+        data: {
+            accessToken: result.accessToken,
+            refreshToken: result.refreshToken || credentials.refreshToken,
+            expiresIn: result.expiresIn || 3600
+        }
+    };
+}
+async function verifyAccountCredentials(credentials) {
+    const refresh = await refreshTokenByMethod(credentials);
+    if (!refresh.success || !refresh.accessToken) {
+        return { success: false, error: `Token refresh failed: ${refresh.error || 'unknown error'}` };
+    }
+    const profileArn = normalizeProfileArn(credentials.profileArn);
+    const usage = await getUsageLimitsRest({
+        accessToken: refresh.accessToken,
+        profileArn,
+        machineId: credentials.machineId,
+        region: credentials.region || 'us-east-1'
+    });
+    const resolvedProfileArn = profileArn || await resolveStreamingProfileArn({
+        accessToken: refresh.accessToken,
+        machineId: credentials.machineId,
+        region: credentials.region || 'us-east-1',
+        authMethod: credentials.authMethod,
+        provider: credentials.provider
+    }).catch(() => undefined);
+    return {
+        success: true,
+        data: {
+            ...normalizeUsage(usage),
+            accessToken: refresh.accessToken,
+            refreshToken: refresh.refreshToken || credentials.refreshToken,
+            expiresIn: refresh.expiresIn || 3600,
+            profileArn: resolvedProfileArn
+        }
+    };
+}
+async function checkAccountStatus(account) {
+    const credentials = account.credentials || {};
+    let accessToken = credentials.accessToken;
+    let refreshResult;
+    const expiresAt = credentials.expiresAt || 0;
+    if ((!accessToken || expiresAt < Date.now() + 300000) && credentials.refreshToken) {
+        refreshResult = await refreshAccountToken(account);
+        if (!refreshResult.success || !refreshResult.data?.accessToken)
+            return refreshResult;
+        accessToken = refreshResult.data.accessToken;
+    }
+    if (!accessToken)
+        return { success: false, error: { message: 'Missing access token' } };
+    const usage = await getUsageLimitsRest({
+        accessToken,
+        profileArn: account.profileArn,
+        machineId: account.machineId,
+        region: credentials.region || 'us-east-1'
+    });
+    const normalized = normalizeUsage(usage);
+    const resolvedProfileArn = await resolveStreamingProfileArn({
+        accessToken,
+        profileArn: account.profileArn,
+        machineId: account.machineId,
+        region: credentials.region || 'us-east-1',
+        authMethod: credentials.authMethod,
+        provider: credentials.provider || account.idp
+    }).catch(() => normalizeProfileArn(account.profileArn));
+    return {
+        success: true,
+        data: {
+            status: 'active',
+            email: normalized.email || account.email,
+            userId: normalized.userId,
+            idp: credentials.provider || account.idp,
+            subscriptionType: normalized.subscriptionType,
+            subscriptionTitle: normalized.subscriptionTitle,
+            subscription: {
+                ...normalized.subscription,
+                type: normalized.subscriptionType,
+                title: normalized.subscriptionTitle,
+                daysRemaining: normalized.daysRemaining,
+                expiresAt: normalized.expiresAt
+            },
+            daysRemaining: normalized.daysRemaining,
+            expiresAt: normalized.expiresAt,
+            profileArn: resolvedProfileArn,
+            usage: {
+                ...normalized.usage,
+                percentUsed: normalized.usage.limit ? (normalized.usage.current / normalized.usage.limit) * 100 : 0,
+                lastUpdated: Date.now()
+            },
+            newCredentials: refreshResult?.data ? {
+                accessToken: refreshResult.data.accessToken,
+                refreshToken: refreshResult.data.refreshToken,
+                expiresAt: Date.now() + refreshResult.data.expiresIn * 1000
+            } : undefined
+        }
+    };
+}

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

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKiroSettings = getKiroSettings;
+exports.saveKiroSettings = saveKiroSettings;
+exports.ensureKiroSettingsFile = ensureKiroSettingsFile;
+exports.ensureMcpConfig = ensureMcpConfig;
+exports.ensureSteeringFolder = ensureSteeringFolder;
+exports.createDefaultRules = createDefaultRules;
+exports.readSteeringFile = readSteeringFile;
+exports.saveSteeringFile = saveSteeringFile;
+exports.deleteSteeringFile = deleteSteeringFile;
+exports.saveMcpServer = saveMcpServer;
+exports.deleteMcpServer = deleteMcpServer;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function kiroRoot() {
+    return path_1.default.resolve(process.env.KIRO_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), '.kiro'));
+}
+function settingsPath() {
+    if (process.platform === 'win32' && !process.env.KIRO_CONFIG_HOME) {
+        return path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming', 'Kiro', 'User', 'settings.json');
+    }
+    return path_1.default.join(kiroRoot(), 'settings', 'settings.json');
+}
+function mcpPath(type) {
+    return type === 'workspace'
+        ? path_1.default.join(process.cwd(), '.kiro', 'settings', 'mcp.json')
+        : path_1.default.join(kiroRoot(), 'settings', 'mcp.json');
+}
+function steeringDir() {
+    return path_1.default.join(kiroRoot(), 'steering');
+}
+function steeringFilePath(filename) {
+    const safeName = path_1.default.basename(filename);
+    if (!safeName.endsWith('.md'))
+        throw new Error('Only markdown steering files are allowed');
+    return path_1.default.join(steeringDir(), safeName);
+}
+function parseJsonc(content) {
+    const cleaned = content
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/,(\s*[}\]])/g, '$1');
+    return JSON.parse(cleaned);
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        return parseJsonc(await fs_1.promises.readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return fallback;
+        throw error;
+    }
+}
+async function writeJsonFile(filePath, value) {
+    await fs_1.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+    await fs_1.promises.writeFile(filePath, JSON.stringify(value, null, 2), 'utf8');
+}
+function uiSettingsFromKiro(parsed) {
+    return {
+        modelSelection: parsed['kiroAgent.modelSelection'],
+        agentAutonomy: parsed['kiroAgent.agentAutonomy'],
+        enableDebugLogs: parsed['kiroAgent.enableDebugLogs'],
+        enableTabAutocomplete: parsed['kiroAgent.enableTabAutocomplete'],
+        enableCodebaseIndexing: parsed['kiroAgent.enableCodebaseIndexing'],
+        usageSummary: parsed['kiroAgent.usageSummary'],
+        codeReferences: parsed['kiroAgent.codeReferences.referenceTracker'],
+        configureMCP: parsed['kiroAgent.configureMCP'],
+        trustedCommands: parsed['kiroAgent.trustedCommands'],
+        trustedTools: parsed['kiroAgent.trustedTools'],
+        commandDenylist: parsed['kiroAgent.commandDenylist'],
+        ignoreFiles: parsed['kiroAgent.ignoreFiles'],
+        mcpApprovedEnvVars: parsed['kiroAgent.mcpApprovedEnvVars'],
+        notificationsActionRequired: parsed['kiroAgent.notifications.agent.actionRequired'],
+        notificationsFailure: parsed['kiroAgent.notifications.agent.failure'],
+        notificationsSuccess: parsed['kiroAgent.notifications.agent.success'],
+        notificationsBilling: parsed['kiroAgent.notifications.billing']
+    };
+}
+function kiroSettingsFromUi(existing, settings) {
+    return {
+        ...existing,
+        'kiroAgent.modelSelection': settings.modelSelection,
+        'kiroAgent.agentAutonomy': settings.agentAutonomy,
+        'kiroAgent.enableDebugLogs': settings.enableDebugLogs,
+        'kiroAgent.enableTabAutocomplete': settings.enableTabAutocomplete,
+        'kiroAgent.enableCodebaseIndexing': settings.enableCodebaseIndexing,
+        'kiroAgent.usageSummary': settings.usageSummary,
+        'kiroAgent.codeReferences.referenceTracker': settings.codeReferences,
+        'kiroAgent.configureMCP': settings.configureMCP,
+        'kiroAgent.trustedCommands': settings.trustedCommands,
+        'kiroAgent.trustedTools': settings.trustedTools,
+        'kiroAgent.commandDenylist': settings.commandDenylist,
+        'kiroAgent.ignoreFiles': settings.ignoreFiles,
+        'kiroAgent.mcpApprovedEnvVars': settings.mcpApprovedEnvVars,
+        'kiroAgent.notifications.agent.actionRequired': settings.notificationsActionRequired,
+        'kiroAgent.notifications.agent.failure': settings.notificationsFailure,
+        'kiroAgent.notifications.agent.success': settings.notificationsSuccess,
+        'kiroAgent.notifications.billing': settings.notificationsBilling
+    };
+}
+async function getKiroSettings() {
+    try {
+        const rawSettings = await readJsonFile(settingsPath(), {});
+        const mcpConfig = await readJsonFile(mcpPath('user'), { mcpServers: {} });
+        let steeringFiles = [];
+        try {
+            steeringFiles = (await fs_1.promises.readdir(steeringDir())).filter((file) => file.endsWith('.md'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        return {
+            settings: uiSettingsFromKiro(rawSettings),
+            mcpConfig,
+            steeringFiles,
+            paths: {
+                root: kiroRoot(),
+                settings: settingsPath(),
+                mcp: mcpPath('user'),
+                steering: steeringDir()
+            }
+        };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : 'Failed to get Kiro settings' };
+    }
+}
+async function saveKiroSettings(settings) {
+    try {
+        const existing = await readJsonFile(settingsPath(), {});
+        await writeJsonFile(settingsPath(), kiroSettingsFromUi(existing, settings));
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to save Kiro settings' };
+    }
+}
+async function ensureKiroSettingsFile() {
+    try {
+        const filePath = settingsPath();
+        try {
+            await fs_1.promises.access(filePath);
+        }
+        catch {
+            await writeJsonFile(filePath, {
+                'workbench.colorTheme': 'Kiro Light',
+                'kiroAgent.modelSelection': 'claude-haiku-4.5'
+            });
+        }
+        return { success: true, path: filePath };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to create settings file' };
+    }
+}
+async function ensureMcpConfig(type) {
+    try {
+        const filePath = mcpPath(type);
+        try {
+            await fs_1.promises.access(filePath);
+        }
+        catch {
+            await writeJsonFile(filePath, { mcpServers: {} });
+        }
+        return { success: true, path: filePath };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to create MCP config' };
+    }
+}
+async function ensureSteeringFolder() {
+    try {
+        await fs_1.promises.mkdir(steeringDir(), { recursive: true });
+        return { success: true, path: steeringDir() };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to create steering folder' };
+    }
+}
+async function createDefaultRules() {
+    try {
+        await fs_1.promises.mkdir(steeringDir(), { recursive: true });
+        const filePath = steeringFilePath('rules.md');
+        const content = [
+            '# Kiro Rules',
+            '',
+            '- Keep code modular and maintainable.',
+            '- Prefer clear, testable changes.',
+            '- Surface uncertainty instead of guessing.'
+        ].join('\n');
+        await fs_1.promises.writeFile(filePath, content, 'utf8');
+        return { success: true, path: filePath };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to create default rules' };
+    }
+}
+async function readSteeringFile(filename) {
+    try {
+        return { success: true, content: await fs_1.promises.readFile(steeringFilePath(filename), 'utf8') };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to read steering file' };
+    }
+}
+async function saveSteeringFile(filename, content) {
+    try {
+        await fs_1.promises.mkdir(steeringDir(), { recursive: true });
+        await fs_1.promises.writeFile(steeringFilePath(filename), content, 'utf8');
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to save steering file' };
+    }
+}
+async function deleteSteeringFile(filename) {
+    try {
+        await fs_1.promises.unlink(steeringFilePath(filename));
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to delete steering file' };
+    }
+}
+async function saveMcpServer(name, config, oldName) {
+    try {
+        const filePath = mcpPath('user');
+        const current = await readJsonFile(filePath, { mcpServers: {} });
+        current.mcpServers = current.mcpServers || {};
+        if (oldName && oldName !== name)
+            delete current.mcpServers[oldName];
+        current.mcpServers[name] = config;
+        await writeJsonFile(filePath, current);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to save MCP server' };
+    }
+}
+async function deleteMcpServer(name) {
+    try {
+        const filePath = mcpPath('user');
+        const current = await readJsonFile(filePath, { mcpServers: {} });
+        if (!current.mcpServers?.[name])
+            return { success: false, error: 'MCP server not found' };
+        delete current.mcpServers[name];
+        await writeJsonFile(filePath, current);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to delete MCP server' };
+    }
+}