@zhafron/opencode-kiro-auth 1.0.0

package/dist/plugin/response.js

@@ -0,0 +1,246 @@
+export function parseEventStream(rawResponse) {
+    const parsedFromEvents = parseEventStreamChunk(rawResponse);
+    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) {
+    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 totalTokens = Math.round((200000 * 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
+    };
+}
+function parseAwsEventStreamBuffer(buffer) {
+    const events = [];
+    let remaining = buffer;
+    let searchStart = 0;
+    while (true) {
+        const contentStart = remaining.indexOf('{"content":', searchStart);
+        const nameStart = remaining.indexOf('{"name":', searchStart);
+        const followupStart = remaining.indexOf('{"followupPrompt":', searchStart);
+        const inputStart = remaining.indexOf('{"input":', searchStart);
+        const stopStart = remaining.indexOf('{"stop":', searchStart);
+        const contextUsageStart = remaining.indexOf('{"contextUsagePercentage":', searchStart);
+        const candidates = [contentStart, nameStart, followupStart, inputStart, stopStart, contextUsageStart].filter((pos) => pos >= 0);
+        if (candidates.length === 0)
+            break;
+        const jsonStart = Math.min(...candidates);
+        if (jsonStart < 0)
+            break;
+        let braceCount = 0;
+        let jsonEnd = -1;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = jsonStart; i < remaining.length; i++) {
+            const char = remaining[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (!inString) {
+                if (char === '{') {
+                    braceCount++;
+                }
+                else if (char === '}') {
+                    braceCount--;
+                    if (braceCount === 0) {
+                        jsonEnd = i;
+                        break;
+                    }
+                }
+            }
+        }
+        if (jsonEnd < 0) {
+            break;
+        }
+        const jsonStr = remaining.substring(jsonStart, jsonEnd + 1);
+        const parsed = parseEventLine(jsonStr);
+        if (parsed) {
+            if (parsed.content !== undefined && !parsed.followupPrompt) {
+                events.push({ type: 'content', data: parsed.content });
+            }
+            else if (parsed.name && parsed.toolUseId) {
+                events.push({
+                    type: 'toolUse',
+                    data: {
+                        name: parsed.name,
+                        toolUseId: parsed.toolUseId,
+                        input: parsed.input || '',
+                        stop: parsed.stop || false
+                    }
+                });
+            }
+            else if (parsed.input !== undefined && !parsed.name) {
+                events.push({
+                    type: 'toolUseInput',
+                    data: {
+                        input: parsed.input
+                    }
+                });
+            }
+            else if (parsed.stop !== undefined && parsed.contextUsagePercentage === undefined) {
+                events.push({
+                    type: 'toolUseStop',
+                    data: {
+                        stop: parsed.stop
+                    }
+                });
+            }
+            else if (parsed.contextUsagePercentage !== undefined) {
+                events.push({
+                    type: 'contextUsage',
+                    data: {
+                        contextUsagePercentage: parsed.contextUsagePercentage
+                    }
+                });
+            }
+        }
+        searchStart = jsonEnd + 1;
+        if (searchStart >= remaining.length) {
+            break;
+        }
+    }
+    return events;
+}
+export function parseEventLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (e) {
+        return null;
+    }
+}
+export function parseBracketToolCalls(text) {
+    const toolCalls = [];
+    const pattern = /\[Called\s+(\w+)\s+with\s+args:\s*(\{[^}]*(?:\{[^}]*\}[^}]*)*\})\]/gs;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        const funcName = match[1];
+        const argsStr = match[2];
+        if (!funcName || !argsStr)
+            continue;
+        try {
+            const args = JSON.parse(argsStr);
+            toolCalls.push({
+                toolUseId: `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                name: funcName,
+                input: args
+            });
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    return toolCalls;
+}
+export function deduplicateToolCalls(toolCalls) {
+    const seen = new Set();
+    const unique = [];
+    for (const tc of toolCalls) {
+        if (!seen.has(tc.toolUseId)) {
+            seen.add(tc.toolUseId);
+            unique.push(tc);
+        }
+    }
+    return unique;
+}
+export function cleanToolCallsFromText(text, toolCalls) {
+    let cleaned = text;
+    for (const tc of toolCalls) {
+        const funcName = tc.name;
+        const escapedName = funcName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = new RegExp(`\\[Called\\s+${escapedName}\\s+with\\s+args:\\s*\\{[^}]*(?:\\{[^}]*\\}[^}]*)*\\}\\]`, 'gs');
+        cleaned = cleaned.replace(pattern, '');
+    }
+    cleaned = cleaned.replace(/\s+/g, ' ').trim();
+    return cleaned;
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}

package/dist/plugin/server.d.ts

@@ -0,0 +1,24 @@
+import type { KiroRegion } from './types';
+export interface KiroIDCTokenResult {
+    email: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    clientId: string;
+    clientSecret: string;
+}
+export interface IDCAuthData {
+    verificationUrl: string;
+    verificationUriComplete: string;
+    userCode: string;
+    deviceCode: string;
+    clientId: string;
+    clientSecret: string;
+    interval: number;
+    expiresIn: number;
+    region: KiroRegion;
+}
+export declare function startIDCAuthServer(authData: IDCAuthData, port?: number): Promise<{
+    url: string;
+    waitForAuth: () => Promise<KiroIDCTokenResult>;
+}>;

package/dist/plugin/server.js

@@ -0,0 +1,96 @@
+import { createServer } from 'node:http';
+import { getIDCAuthHtml, getSuccessHtml, getErrorHtml } from './auth-page';
+export function startIDCAuthServer(authData, port = 19847) {
+    return new Promise((resolve, reject) => {
+        let server = null;
+        let timeoutId = null;
+        let resolver = null;
+        let rejector = null;
+        const status = { status: 'pending' };
+        const cleanup = () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (server)
+                server.close();
+        };
+        const sendHtml = (res, html) => {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(html);
+        };
+        const poll = async () => {
+            try {
+                const body = new URLSearchParams({
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    device_code: authData.deviceCode,
+                    client_id: authData.clientId,
+                    client_secret: authData.clientSecret
+                });
+                const res = await fetch(`https://oidc.${authData.region}.amazonaws.com/token`, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: body.toString() });
+                const d = await res.json();
+                if (res.ok) {
+                    const acc = d.access_token, ref = d.refresh_token, exp = Date.now() + d.expires_in * 1000;
+                    const infoRes = await fetch('https://view.awsapps.com/api/user/info', { headers: { Authorization: `Bearer ${acc}` } });
+                    const info = await infoRes.json();
+                    const email = info.email || info.userName || 'builder-id@aws.amazon.com';
+                    status.status = 'success';
+                    if (resolver)
+                        resolver({ email, accessToken: acc, refreshToken: ref, expiresAt: exp, clientId: authData.clientId, clientSecret: authData.clientSecret });
+                    setTimeout(cleanup, 2000);
+                }
+                else if (d.error === 'authorization_pending')
+                    setTimeout(poll, authData.interval * 1000);
+                else {
+                    status.status = 'failed';
+                    status.error = d.error_description || d.error;
+                    if (rejector)
+                        rejector(new Error(status.error));
+                    setTimeout(cleanup, 2000);
+                }
+            }
+            catch (e) {
+                status.status = 'failed';
+                status.error = e.message;
+                if (rejector)
+                    rejector(e);
+                setTimeout(cleanup, 2000);
+            }
+        };
+        server = createServer((req, res) => {
+            const u = req.url || '';
+            if (u === '/' || u.startsWith('/?'))
+                sendHtml(res, getIDCAuthHtml(authData.verificationUriComplete, authData.userCode, `http://127.0.0.1:${port}/status`));
+            else if (u === '/status') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(status));
+            }
+            else if (u === '/success')
+                sendHtml(res, getSuccessHtml());
+            else if (u === '/error')
+                sendHtml(res, getErrorHtml(status.error || 'Failed'));
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        server.on('error', (e) => {
+            cleanup();
+            reject(e);
+        });
+        server.listen(port, '127.0.0.1', () => {
+            timeoutId = setTimeout(() => {
+                status.status = 'timeout';
+                if (rejector)
+                    rejector(new Error('Timeout'));
+                cleanup();
+            }, 900000);
+            poll();
+            resolve({
+                url: `http://127.0.0.1:${port}`,
+                waitForAuth: () => new Promise((rv, rj) => {
+                    resolver = rv;
+                    rejector = rj;
+                })
+            });
+        });
+    });
+}

package/dist/plugin/storage.d.ts

@@ -0,0 +1,7 @@
+import type { AccountStorage, UsageStorage } from './types';
+export declare function getStoragePath(): string;
+export declare function getUsagePath(): string;
+export declare function loadAccounts(): Promise<AccountStorage>;
+export declare function saveAccounts(storage: AccountStorage): Promise<void>;
+export declare function loadUsage(): Promise<UsageStorage>;
+export declare function saveUsage(storage: UsageStorage): Promise<void>;

package/dist/plugin/storage.js

@@ -0,0 +1,75 @@
+import { promises as fs } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import lockfile from 'proper-lockfile';
+import { xdgConfig } from 'xdg-basedir';
+import * as logger from './logger';
+const LOCK_OPTIONS = {
+    stale: 10000,
+    retries: { retries: 5, minTimeout: 100, maxTimeout: 1000, factor: 2 }
+};
+function getBaseDir() {
+    return join(xdgConfig || join(process.env.HOME || '', '.config'), 'opencode');
+}
+export function getStoragePath() {
+    return join(getBaseDir(), 'kiro-accounts.json');
+}
+export function getUsagePath() {
+    return join(getBaseDir(), 'kiro-usage.json');
+}
+async function withLock(path, fn) {
+    await fs.mkdir(dirname(path), { recursive: true });
+    try {
+        await fs.access(path);
+    }
+    catch {
+        await fs.writeFile(path, '{}');
+    }
+    let release = null;
+    try {
+        release = await lockfile.lock(path, LOCK_OPTIONS);
+        return await fn();
+    }
+    catch (error) {
+        logger.error(`File lock failed for ${path}`, error);
+        throw error;
+    }
+    finally {
+        if (release)
+            await release();
+    }
+}
+export async function loadAccounts() {
+    try {
+        const content = await fs.readFile(getStoragePath(), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { version: 1, accounts: [], activeIndex: -1 };
+    }
+}
+export async function saveAccounts(storage) {
+    const path = getStoragePath();
+    await withLock(path, async () => {
+        const tmp = `${path}.${randomBytes(6).toString('hex')}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(storage, null, 2));
+        await fs.rename(tmp, path);
+    });
+}
+export async function loadUsage() {
+    try {
+        const content = await fs.readFile(getUsagePath(), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { version: 1, usage: {} };
+    }
+}
+export async function saveUsage(storage) {
+    const path = getUsagePath();
+    await withLock(path, async () => {
+        const tmp = `${path}.${randomBytes(6).toString('hex')}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(storage, null, 2));
+        await fs.rename(tmp, path);
+    });
+}

package/dist/plugin/streaming.d.ts

@@ -0,0 +1,3 @@
+export declare function transformKiroStream(response: Response, model: string, conversationId: string): AsyncGenerator<any>;
+export declare function findRealTag(buffer: string, tag: string): number;
+export declare function estimateTokens(text: string): number;