@sunerpy/opencode-kiro-auth 0.1.0

package/dist/plugin/logger.js

@@ -0,0 +1,84 @@
+import { Buffer } from 'node:buffer';
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const binaryToBase64Replacer = (_key, value) => {
+    if (value instanceof Uint8Array)
+        return Buffer.from(value).toString('base64');
+    return value;
+};
+const getLogDir = () => {
+    const platform = process.platform;
+    const base = platform === 'win32'
+        ? join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'opencode')
+        : join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'opencode');
+    return join(base, 'kiro-logs');
+};
+const writeToFile = (level, message, ...args) => {
+    try {
+        const dir = getLogDir();
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, 'plugin.log');
+        const timestamp = new Date().toISOString();
+        const content = `[${timestamp}] ${level}: ${message} ${args
+            .map((a) => {
+            if (a instanceof Error) {
+                return `${a.name}: ${a.message}${a.stack ? `\n${a.stack}` : ''}`;
+            }
+            if (typeof a === 'object') {
+                try {
+                    return JSON.stringify(a);
+                }
+                catch {
+                    return '[Unserializable object]';
+                }
+            }
+            return String(a);
+        })
+            .join(' ')}\n`;
+        appendFileSync(path, content);
+    }
+    catch (e) { }
+};
+const writeApiLog = (type, data, timestamp, isError = false) => {
+    try {
+        const dir = getLogDir();
+        mkdirSync(dir, { recursive: true });
+        const prefix = isError ? 'error_' : '';
+        const filename = `${prefix}${timestamp}_${type}.json`;
+        const path = join(dir, filename);
+        const content = JSON.stringify(data, binaryToBase64Replacer, 2);
+        writeFileSync(path, content);
+    }
+    catch (e) { }
+};
+export function log(message, ...args) {
+    writeToFile('INFO', message, ...args);
+}
+export function error(message, ...args) {
+    writeToFile('ERROR', message, ...args);
+}
+export function warn(message, ...args) {
+    writeToFile('WARN', message, ...args);
+}
+export function debug(message, ...args) {
+    if (process.env.DEBUG) {
+        writeToFile('DEBUG', message, ...args);
+    }
+}
+export function logApiRequest(data, timestamp) {
+    writeApiLog('request', data, timestamp);
+}
+export function logApiResponse(data, timestamp) {
+    writeApiLog('response', data, timestamp);
+}
+export function logApiError(requestData, responseData, timestamp) {
+    writeApiLog('request', requestData, timestamp, true);
+    writeApiLog('response', responseData, timestamp, true);
+    const errorType = responseData.status ? `HTTP ${responseData.status}` : 'Network Error';
+    const email = requestData.email || 'unknown';
+    error(`${errorType} on ${email} - See error_${timestamp}_request.json`);
+}
+export function getTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}

package/dist/plugin/models.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveKiroModel(model: string): string;
+export declare function getContextWindowSize(model: string): number;

package/dist/plugin/models.js

@@ -0,0 +1,11 @@
+import { MODEL_MAPPING, SUPPORTED_MODELS, isLongContextModel } from '../constants.js';
+export function resolveKiroModel(model) {
+    const resolved = MODEL_MAPPING[model];
+    if (!resolved) {
+        throw new Error(`Unsupported model: ${model}. Supported models: ${SUPPORTED_MODELS.join(', ')}`);
+    }
+    return resolved;
+}
+export function getContextWindowSize(model) {
+    return isLongContextModel(model) ? 1000000 : 200000;
+}

package/dist/plugin/request.d.ts

@@ -0,0 +1,9 @@
+import type { Effort, KiroAuthDetails, PreparedRequest, SdkPreparedRequest } from './types.js';
+interface EffortConfig {
+    effort?: Effort;
+    autoEffortMapping?: boolean;
+}
+type ToastFunction = (message: string, variant: 'info' | 'warning' | 'success' | 'error') => void;
+export declare function transformToCodeWhisperer(url: string, body: any, model: string, auth: KiroAuthDetails, think?: boolean, budget?: number): PreparedRequest;
+export declare function transformToSdkRequest(body: any, model: string, auth: KiroAuthDetails, think?: boolean, budget?: number, showToast?: ToastFunction, effortConfig?: EffortConfig): SdkPreparedRequest;
+export {};

package/dist/plugin/request.js

@@ -0,0 +1,287 @@
+import * as crypto from 'crypto';
+import * as os from 'os';
+import { KIRO_CONSTANTS, buildUrl, extractRegionFromArn } from '../constants.js';
+import { buildHistory, extractToolNamesFromHistory, historyHasToolCalling, injectSystemPrompt } from '../infrastructure/transformers/history-builder.js';
+import { findOriginalToolCall, getContentText, mergeAdjacentMessages } from '../infrastructure/transformers/message-transformer.js';
+import { convertToolsToCodeWhisperer, deduplicateToolResults } from '../infrastructure/transformers/tool-transformer.js';
+import { getEffectiveEffort } from './effort.js';
+import { convertImagesToKiroFormat, extractAllImages, extractTextFromParts } from './image-handler.js';
+import { resolveKiroModel } from './models.js';
+function buildCodeWhispererRequest(body, model, auth, think = false, budget = 20000, showToast) {
+    const req = typeof body === 'string' ? JSON.parse(body) : body;
+    const { messages, tools, system } = req;
+    const convId = crypto.randomUUID();
+    if (!messages || messages.length === 0)
+        throw new Error('No messages');
+    const resolved = resolveKiroModel(model);
+    const systemMsgs = messages.filter((m) => m.role === 'system');
+    const otherMsgs = messages.filter((m) => m.role !== 'system');
+    let sys = system || '';
+    if (systemMsgs.length > 0) {
+        const extractedSystem = systemMsgs.map((m) => getContentText(m)).join('\n\n');
+        sys = sys ? `${sys}\n\n${extractedSystem}` : extractedSystem;
+    }
+    if (think) {
+        const pfx = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>`;
+        sys = sys.includes('<thinking_mode>') ? sys : sys ? `${pfx}\n${sys}` : pfx;
+    }
+    const msgs = mergeAdjacentMessages([...otherMsgs]);
+    const lastMsg = msgs[msgs.length - 1];
+    if (lastMsg && lastMsg.role === 'assistant' && getContentText(lastMsg) === '{')
+        msgs.pop();
+    const cwTools = tools ? convertToolsToCodeWhisperer(tools) : [];
+    let history = buildHistory(msgs, resolved);
+    const curMsg = msgs[msgs.length - 1];
+    if (!curMsg)
+        throw new Error('Empty');
+    const isRealUserMsg = curMsg.role === 'user' &&
+        !(Array.isArray(curMsg.content) && curMsg.content.some((p) => p.type === 'tool_result'));
+    if (isRealUserMsg && msgs.length >= 2) {
+        const prevMsg = msgs[msgs.length - 2];
+        if (prevMsg?.role === 'assistant') {
+            const lastHistEntry = history[history.length - 1];
+            const historyEndsWithUser = lastHistEntry?.userInputMessage;
+            if (historyEndsWithUser) {
+                let prevText = '';
+                if (Array.isArray(prevMsg.content)) {
+                    for (const p of prevMsg.content) {
+                        if (p.type === 'text')
+                            prevText += p.text || '';
+                    }
+                }
+                else
+                    prevText = getContentText(prevMsg);
+                if (prevText) {
+                    history.push({ assistantResponseMessage: { content: prevText } });
+                }
+            }
+        }
+    }
+    history = injectSystemPrompt(history, sys, resolved);
+    let curContent = '';
+    const curTrs = [];
+    const curImgs = [];
+    if (curMsg.role === 'assistant') {
+        const arm = { content: '' };
+        let th = '';
+        if (Array.isArray(curMsg.content)) {
+            for (const p of curMsg.content) {
+                if (p.type === 'text')
+                    arm.content += p.text || '';
+                else if (p.type === 'thinking')
+                    th += p.thinking || p.text || '';
+                else if (p.type === 'tool_use') {
+                    if (!arm.toolUses)
+                        arm.toolUses = [];
+                    arm.toolUses.push({ input: p.input, name: p.name, toolUseId: p.id });
+                }
+            }
+        }
+        else
+            arm.content = getContentText(curMsg);
+        if (curMsg.tool_calls && Array.isArray(curMsg.tool_calls)) {
+            if (!arm.toolUses)
+                arm.toolUses = [];
+            for (const tc of curMsg.tool_calls) {
+                arm.toolUses.push({
+                    input: typeof tc.function?.arguments === 'string'
+                        ? JSON.parse(tc.function.arguments)
+                        : tc.function?.arguments,
+                    name: tc.function?.name,
+                    toolUseId: tc.id
+                });
+            }
+        }
+        if (th)
+            arm.content = arm.content
+                ? `<thinking>${th}</thinking>\n\n${arm.content}`
+                : `<thinking>${th}</thinking>`;
+        if (arm.content || arm.toolUses) {
+            history.push({ assistantResponseMessage: arm });
+        }
+        curContent = '[system: conversation continues]';
+    }
+    else {
+        const prev = history[history.length - 1];
+        if (prev && !prev.assistantResponseMessage)
+            history.push({ assistantResponseMessage: { content: '[system: conversation continues]' } });
+        if (curMsg.role === 'tool') {
+            if (curMsg.tool_results) {
+                for (const tr of curMsg.tool_results)
+                    curTrs.push({
+                        content: [{ text: getContentText(tr) }],
+                        status: 'success',
+                        toolUseId: tr.tool_call_id
+                    });
+            }
+            else {
+                curTrs.push({
+                    content: [{ text: getContentText(curMsg) }],
+                    status: 'success',
+                    toolUseId: curMsg.tool_call_id
+                });
+            }
+        }
+        else if (Array.isArray(curMsg.content)) {
+            curContent = extractTextFromParts(curMsg.content);
+            for (const p of curMsg.content) {
+                if (p.type === 'tool_result') {
+                    curTrs.push({
+                        content: [{ text: getContentText(p.content || p) }],
+                        status: 'success',
+                        toolUseId: p.tool_use_id
+                    });
+                }
+            }
+            const unifiedImages = extractAllImages(curMsg.content);
+            if (unifiedImages.length > 0) {
+                const { images, omitted } = convertImagesToKiroFormat(unifiedImages);
+                curImgs.push(...images);
+                if (omitted > 0) {
+                    curContent += `\n\n[${omitted} image(s) omitted due to API limits]`;
+                }
+            }
+        }
+        else
+            curContent = getContentText(curMsg);
+        if (!curContent)
+            curContent = curTrs.length ? 'Tool results provided.' : '[system: conversation continues]';
+    }
+    const request = {
+        conversationState: {
+            chatTriggerType: KIRO_CONSTANTS.CHAT_TRIGGER_TYPE_MANUAL,
+            conversationId: convId,
+            currentMessage: {
+                userInputMessage: {
+                    content: curContent,
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            }
+        }
+    };
+    if (auth.profileArn)
+        request.profileArn = auth.profileArn;
+    const toolUsesInHistory = history.flatMap((h) => h.assistantResponseMessage?.toolUses || []);
+    const allToolUseIdsInHistory = new Set(toolUsesInHistory.map((tu) => tu.toolUseId));
+    const finalCurTrs = [];
+    const orphanedTrs = [];
+    for (const tr of curTrs) {
+        if (allToolUseIdsInHistory.has(tr.toolUseId))
+            finalCurTrs.push(tr);
+        else {
+            const originalCall = findOriginalToolCall(messages, tr.toolUseId);
+            if (originalCall) {
+                orphanedTrs.push({
+                    call: {
+                        name: originalCall.name || originalCall.function?.name || 'tool',
+                        toolUseId: tr.toolUseId,
+                        input: originalCall.input ||
+                            (originalCall.function?.arguments ? JSON.parse(originalCall.function.arguments) : {})
+                    },
+                    result: tr
+                });
+            }
+            else {
+                curContent += `\n\n[Output for tool call ${tr.toolUseId}]:\n${tr.content?.[0]?.text || ''}`;
+            }
+        }
+    }
+    if (orphanedTrs.length > 0) {
+        const prev = history[history.length - 1];
+        if (!prev || prev.assistantResponseMessage) {
+            history.push({
+                userInputMessage: {
+                    content: 'Running tools...',
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            });
+        }
+        history.push({
+            assistantResponseMessage: {
+                content: 'I will execute the following tools.',
+                toolUses: orphanedTrs.map((o) => o.call)
+            }
+        });
+        finalCurTrs.push(...orphanedTrs.map((o) => o.result));
+    }
+    if (history.length > 0)
+        request.conversationState.history = history;
+    const uim = request.conversationState.currentMessage.userInputMessage;
+    if (uim) {
+        uim.content = curContent;
+        if (curImgs.length)
+            uim.images = curImgs;
+        const ctx = {};
+        if (finalCurTrs.length)
+            ctx.toolResults = deduplicateToolResults(finalCurTrs);
+        if (cwTools.length)
+            ctx.tools = cwTools;
+        if (Object.keys(ctx).length)
+            uim.userInputMessageContext = ctx;
+        const hasToolsInHistory = historyHasToolCalling(history);
+        if (hasToolsInHistory) {
+            const toolNamesInHistory = extractToolNamesFromHistory(history);
+            if (toolNamesInHistory.size > 0) {
+                const existingTools = uim.userInputMessageContext?.tools || [];
+                const existingToolNames = new Set(existingTools.map((t) => t.toolSpecification?.name).filter(Boolean));
+                const missingToolNames = Array.from(toolNamesInHistory).filter((name) => !existingToolNames.has(name));
+                if (missingToolNames.length > 0) {
+                    const placeholderTools = missingToolNames.map((name) => ({
+                        toolSpecification: {
+                            name,
+                            description: 'Tool',
+                            inputSchema: { json: { type: 'object', properties: {} } }
+                        }
+                    }));
+                    if (!uim.userInputMessageContext)
+                        uim.userInputMessageContext = {};
+                    uim.userInputMessageContext.tools = [...existingTools, ...placeholderTools];
+                }
+            }
+        }
+    }
+    return { request, resolved, convId };
+}
+export function transformToCodeWhisperer(url, body, model, auth, think = false, budget = 20000) {
+    const { request, resolved, convId } = buildCodeWhispererRequest(body, model, auth, think, budget);
+    const osP = os.platform(), osR = os.release(), nodeV = process.version.replace('v', '');
+    const osN = osP === 'win32' ? `windows#${osR}` : osP === 'darwin' ? `macos#${osR}` : `${osP}#${osR}`;
+    const ua = `aws-sdk-js/3.738.0 ua/2.1 os/${osN} lang/js md/nodejs#${nodeV} api/codewhisperer#3.738.0 m/E KiroIDE`;
+    return {
+        url: buildUrl(KIRO_CONSTANTS.BASE_URL, extractRegionFromArn(auth.profileArn) ?? auth.region),
+        init: {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                Authorization: `Bearer ${auth.access}`,
+                'amz-sdk-invocation-id': crypto.randomUUID(),
+                'amz-sdk-request': 'attempt=1; max=1',
+                'x-amzn-kiro-agent-mode': 'vibe',
+                'x-amz-user-agent': 'aws-sdk-js/3.738.0 KiroIDE',
+                'user-agent': ua,
+                Connection: 'close'
+            },
+            body: JSON.stringify(request)
+        },
+        streaming: true,
+        effectiveModel: resolved,
+        conversationId: convId
+    };
+}
+export function transformToSdkRequest(body, model, auth, think = false, budget = 20000, showToast, effortConfig) {
+    const { request, resolved, convId } = buildCodeWhispererRequest(body, model, auth, think, budget, showToast);
+    // Resolve effort level based on config and model capabilities
+    const effort = getEffectiveEffort(resolved, think, budget, effortConfig?.effort, effortConfig?.autoEffortMapping ?? true);
+    return {
+        conversationState: request.conversationState,
+        profileArn: request.profileArn,
+        streaming: true,
+        effectiveModel: resolved,
+        conversationId: convId,
+        region: extractRegionFromArn(auth.profileArn) ?? auth.region,
+        effort
+    };
+}

package/dist/plugin/response.d.ts

@@ -0,0 +1,3 @@
+import { ParsedResponse } from './types.js';
+export declare function parseEventStream(rawResponse: string, model?: string): ParsedResponse;
+export declare function estimateTokens(text: string): number;

package/dist/plugin/response.js

@@ -0,0 +1,97 @@
+import { parseAwsEventStreamBuffer } from '../infrastructure/transformers/event-stream-parser.js';
+import { cleanToolCallsFromText, deduplicateToolCalls, parseBracketToolCalls } from '../infrastructure/transformers/tool-call-parser.js';
+import { getContextWindowSize } from './models.js';
+export function parseEventStream(rawResponse, model) {
+    const parsedFromEvents = parseEventStreamChunk(rawResponse, model);
+    let fullResponseText = parsedFromEvents.content;
+    let allToolCalls = [...parsedFromEvents.toolCalls];
+    const rawBracketToolCalls = parseBracketToolCalls(rawResponse);
+    if (rawBracketToolCalls.length > 0) {
+        allToolCalls.push(...rawBracketToolCalls);
+    }
+    const uniqueToolCalls = deduplicateToolCalls(allToolCalls);
+    if (uniqueToolCalls.length > 0) {
+        fullResponseText = cleanToolCallsFromText(fullResponseText, uniqueToolCalls);
+    }
+    return {
+        content: fullResponseText,
+        toolCalls: uniqueToolCalls,
+        stopReason: parsedFromEvents.stopReason,
+        inputTokens: parsedFromEvents.inputTokens,
+        outputTokens: parsedFromEvents.outputTokens
+    };
+}
+function parseEventStreamChunk(rawText, model) {
+    const events = parseAwsEventStreamBuffer(rawText);
+    let content = '';
+    const toolCallsMap = new Map();
+    let stopReason;
+    let inputTokens;
+    let outputTokens;
+    let contextUsagePercentage;
+    for (const event of events) {
+        if (event.type === 'content' && event.data) {
+            content += event.data;
+        }
+        else if (event.type === 'toolUse') {
+            const { name, toolUseId, input } = event.data;
+            if (name && toolUseId) {
+                if (toolCallsMap.has(toolUseId)) {
+                    const existing = toolCallsMap.get(toolUseId);
+                    existing.input = existing.input + (input || '');
+                }
+                else {
+                    toolCallsMap.set(toolUseId, {
+                        toolUseId,
+                        name,
+                        input: input || ''
+                    });
+                }
+            }
+        }
+        else if (event.type === 'toolUseInput') {
+            const lastToolCall = Array.from(toolCallsMap.values()).pop();
+            if (lastToolCall) {
+                lastToolCall.input = lastToolCall.input + (event.data.input || '');
+            }
+        }
+        else if (event.type === 'toolUseStop') {
+            stopReason = 'tool_use';
+        }
+        else if (event.type === 'contextUsage') {
+            contextUsagePercentage = event.data.contextUsagePercentage;
+        }
+    }
+    const toolCalls = Array.from(toolCallsMap.values()).map((tc) => {
+        let parsedInput = tc.input;
+        if (typeof tc.input === 'string' && tc.input.trim()) {
+            try {
+                parsedInput = JSON.parse(tc.input);
+            }
+            catch (e) {
+                parsedInput = tc.input;
+            }
+        }
+        return {
+            toolUseId: tc.toolUseId,
+            name: tc.name,
+            input: parsedInput
+        };
+    });
+    if (contextUsagePercentage !== undefined) {
+        const contextWindow = getContextWindowSize(model || '');
+        const totalTokens = Math.round((contextWindow * contextUsagePercentage) / 100);
+        outputTokens = estimateTokens(content);
+        inputTokens = Math.max(0, totalTokens - outputTokens);
+    }
+    return {
+        content,
+        toolCalls,
+        stopReason: stopReason || (toolCalls.length > 0 ? 'tool_use' : 'end_turn'),
+        inputTokens,
+        outputTokens
+    };
+}
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}

package/dist/plugin/sdk-client.d.ts

@@ -0,0 +1,4 @@
+import { CodeWhispererStreamingClient } from '@aws/codewhisperer-streaming-client';
+import type { Effort, KiroAuthDetails } from './types.js';
+export declare function createSdkClient(auth: KiroAuthDetails, region: string, effort?: Effort): CodeWhispererStreamingClient;
+export declare function clearSdkClientCache(): void;

package/dist/plugin/sdk-client.js

@@ -0,0 +1,55 @@
+import { CodeWhispererStreamingClient } from '@aws/codewhisperer-streaming-client';
+import { KIRO_CONSTANTS } from '../constants.js';
+const clientCache = new Map();
+const KIRO_CLI_MAX_ATTEMPTS = 3;
+export function createSdkClient(auth, region, effort) {
+    const cacheKey = `${region}:${auth.email || 'default'}:${effort || 'none'}`;
+    const cached = clientCache.get(cacheKey);
+    if (cached && cached.token === auth.access && cached.effort === effort) {
+        return cached.client;
+    }
+    const token = auth.access;
+    const client = new CodeWhispererStreamingClient({
+        region,
+        endpoint: `https://q.${region}.amazonaws.com`,
+        token: () => Promise.resolve({ token }),
+        maxAttempts: KIRO_CLI_MAX_ATTEMPTS,
+        retryMode: 'standard',
+        customUserAgent: [[KIRO_CONSTANTS.USER_AGENT]]
+    });
+    // Add Kiro-specific headers
+    client.middlewareStack.add((next) => async (args) => {
+        args.request.headers['x-amzn-kiro-agent-mode'] = 'vibe';
+        return next(args);
+    }, { step: 'build', name: 'addKiroHeaders' });
+    // Inject additionalModelRequestFields for effort-based thinking control
+    if (effort) {
+        client.middlewareStack.add((next) => async (args) => {
+            // The SDK serializes input to args.input, we need to modify the body
+            // before it's sent. The body is in args.request.body as a string.
+            if (args.request?.body) {
+                try {
+                    const body = JSON.parse(args.request.body);
+                    body.additionalModelRequestFields = {
+                        output_config: {
+                            effort
+                        }
+                    };
+                    args.request.body = JSON.stringify(body);
+                }
+                catch {
+                    // If body parsing fails, continue without modification
+                }
+            }
+            return next(args);
+        }, { step: 'build', name: 'addEffortConfig', priority: 'high' });
+    }
+    clientCache.set(cacheKey, { client, token, effort });
+    return client;
+}
+export function clearSdkClientCache() {
+    for (const entry of clientCache.values()) {
+        entry.client.destroy();
+    }
+    clientCache.clear();
+}

package/dist/plugin/storage/locked-operations.d.ts

@@ -0,0 +1,5 @@
+import type { ManagedAccount } from '../types.js';
+export declare function withDatabaseLock<T>(dbPath: string, fn: () => Promise<T>): Promise<T>;
+export declare function createDeterministicId(email: string, authMethod: string, clientId?: string, profileArn?: string): string;
+export declare function mergeAccounts(existing: ManagedAccount[], incoming: ManagedAccount[]): ManagedAccount[];
+export declare function deduplicateAccounts(accounts: ManagedAccount[]): ManagedAccount[];

package/dist/plugin/storage/locked-operations.js

@@ -0,0 +1,103 @@
+import { createHash } from 'node:crypto';
+import { existsSync, promises as fs } from 'node:fs';
+import lockfile from 'proper-lockfile';
+import { isPermanentError } from '../health.js';
+const LOCK_OPTIONS = {
+    stale: 10000,
+    retries: {
+        retries: 5,
+        minTimeout: 100,
+        maxTimeout: 1000,
+        factor: 2
+    },
+    realpath: false
+};
+export async function withDatabaseLock(dbPath, fn) {
+    const lockPath = `${dbPath}.lock`;
+    if (!existsSync(dbPath)) {
+        const dir = dbPath.substring(0, dbPath.lastIndexOf('/'));
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(dbPath, '');
+    }
+    let release = null;
+    try {
+        release = await lockfile.lock(dbPath, LOCK_OPTIONS);
+        return await fn();
+    }
+    finally {
+        if (release) {
+            try {
+                await release();
+            }
+            catch (e) {
+                console.warn('Failed to release lock:', e);
+            }
+        }
+    }
+}
+export function createDeterministicId(email, authMethod, clientId, profileArn) {
+    const parts = [email, authMethod, clientId || '', profileArn || ''].join(':');
+    return createHash('sha256').update(parts).digest('hex');
+}
+export function mergeAccounts(existing, incoming) {
+    const accountMap = new Map();
+    for (const acc of existing) {
+        accountMap.set(acc.id, acc);
+    }
+    for (const acc of incoming) {
+        const existingAcc = accountMap.get(acc.id);
+        if (existingAcc) {
+            const incomingHasPermanentError = isPermanentError(acc.unhealthyReason);
+            const hasPermanentError = isPermanentError(existingAcc.unhealthyReason) || incomingHasPermanentError;
+            const incomingRecovered = acc.isHealthy && !incomingHasPermanentError;
+            accountMap.set(acc.id, {
+                ...existingAcc,
+                ...acc,
+                lastUsed: Math.max(existingAcc.lastUsed || 0, acc.lastUsed || 0),
+                usedCount: Math.max(existingAcc.usedCount || 0, acc.usedCount || 0),
+                limitCount: Math.max(existingAcc.limitCount || 0, acc.limitCount || 0),
+                rateLimitResetTime: Math.max(existingAcc.rateLimitResetTime || 0, acc.rateLimitResetTime || 0),
+                isHealthy: incomingRecovered
+                    ? true
+                    : hasPermanentError
+                        ? false
+                        : existingAcc.isHealthy || acc.isHealthy,
+                unhealthyReason: incomingRecovered
+                    ? undefined
+                    : acc.unhealthyReason || existingAcc.unhealthyReason,
+                recoveryTime: incomingRecovered ? undefined : acc.recoveryTime || existingAcc.recoveryTime,
+                failCount: incomingRecovered
+                    ? acc.failCount || 0
+                    : Math.max(existingAcc.failCount || 0, acc.failCount || 0),
+                lastSync: Math.max(existingAcc.lastSync || 0, acc.lastSync || 0)
+            });
+        }
+        else {
+            accountMap.set(acc.id, acc);
+        }
+    }
+    return Array.from(accountMap.values());
+}
+export function deduplicateAccounts(accounts) {
+    const accountMap = new Map();
+    for (const acc of accounts) {
+        const existing = accountMap.get(acc.id);
+        if (!existing) {
+            accountMap.set(acc.id, acc);
+            continue;
+        }
+        const currLastUsed = acc.lastUsed || 0;
+        const existLastUsed = existing.lastUsed || 0;
+        if (currLastUsed > existLastUsed) {
+            accountMap.set(acc.id, acc);
+        }
+        else if (currLastUsed === existLastUsed) {
+            const currAddedAt = acc.expiresAt || 0;
+            const existAddedAt = existing.expiresAt || 0;
+            if (currAddedAt > existAddedAt) {
+                accountMap.set(acc.id, acc);
+            }
+        }
+    }
+    return Array.from(accountMap.values());
+}

package/dist/plugin/storage/migrations.d.ts

@@ -0,0 +1,4 @@
+import type Libsql from 'libsql';
+type Database = Libsql.Database;
+export declare function runMigrations(db: Database): void;
+export {};