@zhafron/opencode-kiro-auth 1.6.6 → 1.8.0

package/dist/plugin/cli.js

@@ -1,103 +0,0 @@
-import { stdin as input, stdout as output } from 'node:process';
-import { createInterface } from 'node:readline/promises';
-export async function promptAddAnotherAccount(currentCount) {
-    const rl = createInterface({ input, output });
-    try {
-        const answer = await rl.question(`Add another account? (${currentCount} added) (y/n): `);
-        const normalized = answer.trim().toLowerCase();
-        return normalized === 'y' || normalized === 'yes';
-    }
-    finally {
-        rl.close();
-    }
-}
-export async function promptDeleteAccount(accounts) {
-    const rl = createInterface({ input, output });
-    try {
-        console.log(`\nSelect account(s) to delete:`);
-        for (const acc of accounts) {
-            const label = acc.email || `Account ${acc.index + 1}`;
-            console.log(`  ${acc.index + 1}. ${label}`);
-        }
-        console.log(`  0. Cancel`);
-        console.log('');
-        while (true) {
-            const answer = await rl.question('Enter account number(s) (e.g., 1,2,3 or 1): ');
-            const trimmed = answer.trim();
-            if (trimmed === '0') {
-                return null;
-            }
-            const parts = trimmed.split(',').map((s) => s.trim());
-            const numbers = [];
-            let invalid = false;
-            for (const part of parts) {
-                const num = parseInt(part, 10);
-                if (isNaN(num) || num < 1 || num > accounts.length) {
-                    invalid = true;
-                    break;
-                }
-                if (!numbers.includes(num)) {
-                    numbers.push(num);
-                }
-            }
-            if (invalid) {
-                console.log(`Please enter valid numbers between 1 and ${accounts.length}, separated by commas`);
-                continue;
-            }
-            if (numbers.length === 0) {
-                console.log(`Please enter at least one account number`);
-                continue;
-            }
-            const indices = numbers.map((n) => n - 1);
-            const selectedAccounts = indices
-                .map((i) => accounts[i])
-                .filter((acc) => acc !== undefined);
-            if (selectedAccounts.length === 0) {
-                console.log(`No valid accounts selected`);
-                continue;
-            }
-            console.log(`\nYou are about to delete ${selectedAccounts.length} account(s):`);
-            for (const acc of selectedAccounts) {
-                const label = acc.email || `Account ${acc.index + 1}`;
-                console.log(`  - ${label}`);
-            }
-            const confirm = await rl.question(`\nConfirm deletion? (y/n): `);
-            const normalized = confirm.trim().toLowerCase();
-            if (normalized === 'y' || normalized === 'yes') {
-                return selectedAccounts.map((acc) => acc.index);
-            }
-            return null;
-        }
-    }
-    finally {
-        rl.close();
-    }
-}
-export async function promptLoginMode(existingAccounts) {
-    const rl = createInterface({ input, output });
-    try {
-        console.log(`\n${existingAccounts.length} account(s) saved:`);
-        for (const acc of existingAccounts) {
-            const label = acc.email || `Account ${acc.index + 1}`;
-            console.log(`  ${acc.index + 1}. ${label}`);
-        }
-        console.log('');
-        while (true) {
-            const answer = await rl.question('(a)dd new account(s), (f)resh start, or (d)elete account? [a/f/d]: ');
-            const normalized = answer.trim().toLowerCase();
-            if (normalized === 'a' || normalized === 'add') {
-                return 'add';
-            }
-            if (normalized === 'f' || normalized === 'fresh') {
-                return 'fresh';
-            }
-            if (normalized === 'd' || normalized === 'delete') {
-                return 'delete';
-            }
-            console.log("Please enter 'a' to add accounts, 'f' to start fresh, or 'd' to delete account.");
-        }
-    }
-    finally {
-        rl.close();
-    }
-}

package/dist/plugin/server.d.ts

@@ -1,34 +0,0 @@
-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;
-    startUrl: string;
-}
-export declare function startIDCAuthServer(authData: IDCAuthData, startPort?: number, portRange?: number): Promise<{
-    url: string;
-    waitForAuth: () => Promise<KiroIDCTokenResult>;
-}>;
-/**
- * Starts a local auth server that first shows a Start URL input page.
- * After the user submits, it calls authorizeKiroIDC internally and transitions
- * to the verification code page — no need to call authorizeKiroIDC beforehand.
- */
-export declare function startIDCAuthServerWithInput(region: KiroRegion, defaultStartUrl: string | undefined, startPort?: number, portRange?: number): Promise<{
-    url: string;
-    waitForAuth: () => Promise<KiroIDCTokenResult>;
-}>;

package/dist/plugin/server.js

@@ -1,362 +0,0 @@
-import { createServer } from 'node:http';
-import { authorizeKiroIDC } from '../kiro/oauth-idc';
-import { getErrorHtml, getIDCAuthHtml, getStartUrlInputHtml, getSuccessHtml } from './auth-page';
-import * as logger from './logger';
-async function tryPort(port) {
-    return new Promise((resolve) => {
-        const testServer = createServer();
-        testServer.once('error', () => resolve(false));
-        testServer.once('listening', () => {
-            testServer.close();
-            resolve(true);
-        });
-        testServer.listen(port, '127.0.0.1');
-    });
-}
-async function findAvailablePort(startPort, range) {
-    for (let i = 0; i < range; i++) {
-        const port = startPort + i;
-        const available = await tryPort(port);
-        if (available)
-            return port;
-    }
-    throw new Error(`No available ports in range ${startPort}-${startPort + range - 1}. Please close other applications using these ports.`);
-}
-export async function startIDCAuthServer(authData, startPort = 19847, portRange = 10) {
-    return new Promise(async (resolve, reject) => {
-        let port;
-        try {
-            port = await findAvailablePort(startPort, portRange);
-            logger.log(`Auth server will use port ${port}`);
-        }
-        catch (error) {
-            logger.error('Failed to find available port', error);
-            reject(error);
-            return;
-        }
-        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 = {
-                    grantType: 'urn:ietf:params:oauth:grant-type:device_code',
-                    deviceCode: authData.deviceCode,
-                    clientId: authData.clientId,
-                    clientSecret: authData.clientSecret
-                };
-                const res = await fetch(`https://oidc.${authData.region}.amazonaws.com/token`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                });
-                const responseText = await res.text();
-                let d = {};
-                if (responseText) {
-                    try {
-                        d = JSON.parse(responseText);
-                    }
-                    catch (parseError) {
-                        logger.error(`Auth polling error: Failed to parse JSON (status ${res.status})`, parseError);
-                        throw parseError;
-                    }
-                }
-                if (res.ok) {
-                    const acc = d.access_token || d.accessToken, ref = d.refresh_token || d.refreshToken, exp = Date.now() + (d.expires_in || d.expiresIn || 0) * 1000;
-                    let email = 'builder-id@aws.amazon.com';
-                    try {
-                        // Derive user info URL from startUrl: replace /start with /api/user/info
-                        const userInfoUrl = authData.startUrl.replace(/\/start\/?$/, '/api/user/info');
-                        const infoRes = await fetch(userInfoUrl, {
-                            headers: { Authorization: `Bearer ${acc}` }
-                        });
-                        if (infoRes.ok) {
-                            const info = await infoRes.json();
-                            email = info.email || info.userName || email;
-                        }
-                        else {
-                            logger.warn(`User info request failed with status ${infoRes.status}; using fallback email`);
-                        }
-                    }
-                    catch (infoError) {
-                        logger.warn(`Failed to fetch user info; using fallback email: ${infoError?.message || infoError}`);
-                    }
-                    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;
-                    logger.error(`Auth polling failed a: ${status.error}`);
-                    if (rejector)
-                        rejector(new Error(status.error));
-                    setTimeout(cleanup, 2000);
-                }
-            }
-            catch (e) {
-                status.status = 'failed';
-                status.error = e.message;
-                logger.error(`Auth polling error b: ${e.message}`, e);
-                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) => {
-            logger.error(`Auth server error on port ${port}`, e);
-            cleanup();
-            reject(e);
-        });
-        server.listen(port, '127.0.0.1', () => {
-            timeoutId = setTimeout(() => {
-                status.status = 'timeout';
-                logger.warn('Auth timeout waiting for authorization');
-                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;
-                })
-            });
-        });
-    });
-}
-/**
- * Starts a local auth server that first shows a Start URL input page.
- * After the user submits, it calls authorizeKiroIDC internally and transitions
- * to the verification code page — no need to call authorizeKiroIDC beforehand.
- */
-export async function startIDCAuthServerWithInput(region, defaultStartUrl, startPort = 19847, portRange = 10) {
-    return new Promise(async (resolve, reject) => {
-        let port;
-        try {
-            port = await findAvailablePort(startPort, portRange);
-            logger.log(`Auth server (with input) will use port ${port}`);
-        }
-        catch (error) {
-            logger.error('Failed to find available port', error);
-            reject(error);
-            return;
-        }
-        let server = null;
-        let timeoutId = null;
-        let resolver = null;
-        let rejector = null;
-        const status = { status: 'pending' };
-        // authData is populated after the user submits the start URL form
-        let authData = null;
-        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 sendJson = (res, code, data) => {
-            res.writeHead(code, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(data));
-        };
-        const poll = async (data) => {
-            try {
-                const body = {
-                    grantType: 'urn:ietf:params:oauth:grant-type:device_code',
-                    deviceCode: data.deviceCode,
-                    clientId: data.clientId,
-                    clientSecret: data.clientSecret
-                };
-                const res = await fetch(`https://oidc.${data.region}.amazonaws.com/token`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                });
-                const responseText = await res.text();
-                let d = {};
-                if (responseText) {
-                    try {
-                        d = JSON.parse(responseText);
-                    }
-                    catch (parseError) {
-                        logger.error(`Auth polling error: Failed to parse JSON (status ${res.status})`, parseError);
-                        throw parseError;
-                    }
-                }
-                if (res.ok) {
-                    const acc = d.access_token || d.accessToken, ref = d.refresh_token || d.refreshToken, exp = Date.now() + (d.expires_in || d.expiresIn || 0) * 1000;
-                    let email = 'builder-id@aws.amazon.com';
-                    try {
-                        const userInfoUrl = data.startUrl.replace(/\/start\/?$/, '/api/user/info');
-                        const infoRes = await fetch(userInfoUrl, {
-                            headers: { Authorization: `Bearer ${acc}` }
-                        });
-                        if (infoRes.ok) {
-                            const info = await infoRes.json();
-                            email = info.email || info.userName || email;
-                        }
-                        else {
-                            logger.warn(`User info request failed with status ${infoRes.status}; using fallback email`);
-                        }
-                    }
-                    catch (infoError) {
-                        logger.warn(`Failed to fetch user info; using fallback email: ${infoError?.message || infoError}`);
-                    }
-                    status.status = 'success';
-                    if (resolver)
-                        resolver({
-                            email,
-                            accessToken: acc,
-                            refreshToken: ref,
-                            expiresAt: exp,
-                            clientId: data.clientId,
-                            clientSecret: data.clientSecret
-                        });
-                    setTimeout(cleanup, 2000);
-                }
-                else if (d.error === 'authorization_pending') {
-                    setTimeout(() => poll(data), data.interval * 1000);
-                }
-                else {
-                    status.status = 'failed';
-                    status.error = d.error_description || d.error;
-                    logger.error(`Auth polling failed: ${status.error}`);
-                    if (rejector)
-                        rejector(new Error(status.error));
-                    setTimeout(cleanup, 2000);
-                }
-            }
-            catch (e) {
-                status.status = 'failed';
-                status.error = e.message;
-                logger.error(`Auth polling error: ${e.message}`, e);
-                if (rejector)
-                    rejector(e);
-                setTimeout(cleanup, 2000);
-            }
-        };
-        server = createServer(async (req, res) => {
-            const u = req.url || '';
-            // Step 1: Show start URL input page
-            if (u === '/' || u === '') {
-                sendHtml(res, getStartUrlInputHtml(defaultStartUrl || '', `http://127.0.0.1:${port}/setup`));
-                return;
-            }
-            // Step 2: Receive start URL, call authorizeKiroIDC, return auth info to browser
-            if (u === '/setup' && req.method === 'POST') {
-                let body = '';
-                req.on('data', (chunk) => {
-                    body += chunk;
-                });
-                req.on('end', async () => {
-                    try {
-                        const { startUrl } = JSON.parse(body);
-                        const effectiveStartUrl = startUrl || undefined;
-                        const data = await authorizeKiroIDC(region, effectiveStartUrl);
-                        authData = data;
-                        // Start polling now that we have device code
-                        poll(authData);
-                        sendJson(res, 200, {
-                            userCode: data.userCode,
-                            verificationUriComplete: data.verificationUriComplete
-                        });
-                    }
-                    catch (e) {
-                        logger.error('authorizeKiroIDC failed', e);
-                        sendJson(res, 500, { error: e.message || 'Failed to initialize authentication' });
-                    }
-                });
-                return;
-            }
-            // Step 3: Show verification code page (browser redirects here after /setup)
-            if (u.startsWith('/auth')) {
-                const params = new URL(u, `http://127.0.0.1:${port}`).searchParams;
-                const code = params.get('code') || '';
-                const verUrl = params.get('url') || '';
-                sendHtml(res, getIDCAuthHtml(verUrl, code, `http://127.0.0.1:${port}/status`));
-                return;
-            }
-            if (u === '/status') {
-                sendJson(res, 200, status);
-                return;
-            }
-            if (u === '/success') {
-                sendHtml(res, getSuccessHtml());
-                return;
-            }
-            if (u.startsWith('/error')) {
-                sendHtml(res, getErrorHtml(status.error || 'Failed'));
-                return;
-            }
-            res.writeHead(404);
-            res.end();
-        });
-        server.on('error', (e) => {
-            logger.error(`Auth server error on port ${port}`, e);
-            cleanup();
-            reject(e);
-        });
-        server.listen(port, '127.0.0.1', () => {
-            timeoutId = setTimeout(() => {
-                status.status = 'timeout';
-                logger.warn('Auth timeout waiting for authorization');
-                if (rejector)
-                    rejector(new Error('Timeout'));
-                cleanup();
-            }, 900000);
-            resolve({
-                url: `http://127.0.0.1:${port}`,
-                waitForAuth: () => new Promise((rv, rj) => {
-                    resolver = rv;
-                    rejector = rj;
-                })
-            });
-        });
-    });
-}