@zhafron/opencode-kiro-auth 1.0.0

package/dist/plugin/config/loader.js

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { AccountSelectionStrategySchema, KiroConfigSchema, RegionSchema, DEFAULT_CONFIG } from './schema';
+import * as logger from '../logger';
+function getConfigDir() {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'opencode');
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+    return join(xdgConfig, 'opencode');
+}
+export function getUserConfigPath() {
+    return join(getConfigDir(), 'kiro.json');
+}
+function ensureUserConfigTemplate() {
+    const path = getUserConfigPath();
+    if (!existsSync(path)) {
+        try {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+            logger.log(`Created default config template at ${path}`);
+        }
+        catch (error) {
+            logger.warn(`Failed to create config template at ${path}: ${String(error)}`);
+        }
+    }
+}
+export function getProjectConfigPath(directory) {
+    return join(directory, '.opencode', 'kiro.json');
+}
+function loadConfigFile(path) {
+    try {
+        if (!existsSync(path)) {
+            return null;
+        }
+        const content = readFileSync(path, 'utf-8');
+        const rawConfig = JSON.parse(content);
+        const result = KiroConfigSchema.partial().safeParse(rawConfig);
+        if (!result.success) {
+            const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ');
+            logger.warn(`Config validation error at ${path}: ${issues}`);
+            return null;
+        }
+        return result.data;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            logger.warn(`Invalid JSON in config file ${path}: ${error.message}`);
+        }
+        else {
+            logger.warn(`Failed to load config file ${path}: ${String(error)}`);
+        }
+        return null;
+    }
+}
+function mergeConfigs(base, override) {
+    return {
+        ...base,
+        ...override
+    };
+}
+function parseBooleanEnv(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (value === '1' || value === 'true') {
+        return true;
+    }
+    if (value === '0' || value === 'false') {
+        return false;
+    }
+    return fallback;
+}
+function parseNumberEnv(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (isNaN(parsed)) {
+        return fallback;
+    }
+    return parsed;
+}
+function applyEnvOverrides(config) {
+    const env = process.env;
+    return {
+        ...config,
+        session_recovery: parseBooleanEnv(env.KIRO_SESSION_RECOVERY, config.session_recovery),
+        auto_resume: parseBooleanEnv(env.KIRO_AUTO_RESUME, config.auto_resume),
+        proactive_token_refresh: parseBooleanEnv(env.KIRO_PROACTIVE_TOKEN_REFRESH, config.proactive_token_refresh),
+        token_refresh_interval_seconds: parseNumberEnv(env.KIRO_TOKEN_REFRESH_INTERVAL_SECONDS, config.token_refresh_interval_seconds),
+        token_refresh_buffer_seconds: parseNumberEnv(env.KIRO_TOKEN_REFRESH_BUFFER_SECONDS, config.token_refresh_buffer_seconds),
+        account_selection_strategy: env.KIRO_ACCOUNT_SELECTION_STRATEGY
+            ? AccountSelectionStrategySchema.catch('lowest-usage').parse(env.KIRO_ACCOUNT_SELECTION_STRATEGY)
+            : config.account_selection_strategy,
+        default_region: env.KIRO_DEFAULT_REGION ? RegionSchema.catch('us-east-1').parse(env.KIRO_DEFAULT_REGION) : config.default_region,
+        rate_limit_retry_delay_ms: parseNumberEnv(env.KIRO_RATE_LIMIT_RETRY_DELAY_MS, config.rate_limit_retry_delay_ms),
+        rate_limit_max_retries: parseNumberEnv(env.KIRO_RATE_LIMIT_MAX_RETRIES, config.rate_limit_max_retries),
+        usage_tracking_enabled: parseBooleanEnv(env.KIRO_USAGE_TRACKING_ENABLED, config.usage_tracking_enabled)
+    };
+}
+export function loadConfig(directory) {
+    ensureUserConfigTemplate();
+    let config = { ...DEFAULT_CONFIG };
+    const userConfigPath = getUserConfigPath();
+    const userConfig = loadConfigFile(userConfigPath);
+    if (userConfig) {
+        config = mergeConfigs(config, userConfig);
+    }
+    const projectConfigPath = getProjectConfigPath(directory);
+    const projectConfig = loadConfigFile(projectConfigPath);
+    if (projectConfig) {
+        config = mergeConfigs(config, projectConfig);
+    }
+    config = applyEnvOverrides(config);
+    return config;
+}
+export function configExists(path) {
+    return existsSync(path);
+}
+export function getDefaultLogsDir() {
+    return join(getConfigDir(), 'kiro-logs');
+}

package/dist/plugin/config/schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const AccountSelectionStrategySchema: z.ZodEnum<["sticky", "round-robin", "lowest-usage"]>;
+export type AccountSelectionStrategy = z.infer<typeof AccountSelectionStrategySchema>;
+export declare const RegionSchema: z.ZodEnum<["us-east-1", "us-west-2"]>;
+export type Region = z.infer<typeof RegionSchema>;
+export declare const KiroConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    session_recovery: z.ZodDefault<z.ZodBoolean>;
+    auto_resume: z.ZodDefault<z.ZodBoolean>;
+    proactive_token_refresh: z.ZodDefault<z.ZodBoolean>;
+    token_refresh_interval_seconds: z.ZodDefault<z.ZodNumber>;
+    token_refresh_buffer_seconds: z.ZodDefault<z.ZodNumber>;
+    account_selection_strategy: z.ZodDefault<z.ZodEnum<["sticky", "round-robin", "lowest-usage"]>>;
+    default_region: z.ZodDefault<z.ZodEnum<["us-east-1", "us-west-2"]>>;
+    rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
+    rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
+    usage_tracking_enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    session_recovery: boolean;
+    auto_resume: boolean;
+    proactive_token_refresh: boolean;
+    token_refresh_interval_seconds: number;
+    token_refresh_buffer_seconds: number;
+    account_selection_strategy: "sticky" | "round-robin" | "lowest-usage";
+    default_region: "us-east-1" | "us-west-2";
+    rate_limit_retry_delay_ms: number;
+    rate_limit_max_retries: number;
+    usage_tracking_enabled: boolean;
+    $schema?: string | undefined;
+}, {
+    $schema?: string | undefined;
+    session_recovery?: boolean | undefined;
+    auto_resume?: boolean | undefined;
+    proactive_token_refresh?: boolean | undefined;
+    token_refresh_interval_seconds?: number | undefined;
+    token_refresh_buffer_seconds?: number | undefined;
+    account_selection_strategy?: "sticky" | "round-robin" | "lowest-usage" | undefined;
+    default_region?: "us-east-1" | "us-west-2" | undefined;
+    rate_limit_retry_delay_ms?: number | undefined;
+    rate_limit_max_retries?: number | undefined;
+    usage_tracking_enabled?: boolean | undefined;
+}>;
+export type KiroConfig = z.infer<typeof KiroConfigSchema>;
+export declare const DEFAULT_CONFIG: KiroConfig;

package/dist/plugin/config/schema.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const AccountSelectionStrategySchema = z.enum(['sticky', 'round-robin', 'lowest-usage']);
+export const RegionSchema = z.enum(['us-east-1', 'us-west-2']);
+export const KiroConfigSchema = z.object({
+    $schema: z.string().optional(),
+    session_recovery: z.boolean().default(true),
+    auto_resume: z.boolean().default(true),
+    proactive_token_refresh: z.boolean().default(true),
+    token_refresh_interval_seconds: z.number().min(60).max(3600).default(300),
+    token_refresh_buffer_seconds: z.number().min(60).max(1800).default(600),
+    account_selection_strategy: AccountSelectionStrategySchema.default('lowest-usage'),
+    default_region: RegionSchema.default('us-east-1'),
+    rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
+    rate_limit_max_retries: z.number().min(0).max(10).default(3),
+    usage_tracking_enabled: z.boolean().default(true)
+});
+export const DEFAULT_CONFIG = {
+    session_recovery: true,
+    auto_resume: true,
+    proactive_token_refresh: true,
+    token_refresh_interval_seconds: 300,
+    token_refresh_buffer_seconds: 600,
+    account_selection_strategy: 'lowest-usage',
+    default_region: 'us-east-1',
+    rate_limit_retry_delay_ms: 5000,
+    rate_limit_max_retries: 3,
+    usage_tracking_enabled: true
+};

package/dist/plugin/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function isDebugEnabled(): boolean;
+export declare function debugLog(context: string, message: string, data?: unknown): void;

package/dist/plugin/debug.js

@@ -0,0 +1,9 @@
+export function isDebugEnabled() {
+    return !!process.env.DEBUG;
+}
+export function debugLog(context, message, data) {
+    if (isDebugEnabled()) {
+        const formattedData = data !== undefined ? ` ${JSON.stringify(data)}` : '';
+        console.debug(`[${context}] ${message}${formattedData}`);
+    }
+}

package/dist/plugin/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class KiroTokenRefreshError extends Error {
+    code?: string;
+    originalError?: Error;
+    constructor(message: string, code?: string, originalError?: Error);
+}
+export declare class KiroQuotaExhaustedError extends Error {
+    recoveryTime?: number;
+    constructor(message: string, recoveryTime?: number);
+}
+export declare class KiroRateLimitError extends Error {
+    retryAfter?: number;
+    constructor(message: string, retryAfter?: number);
+}
+export declare class KiroAuthError extends Error {
+    statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}

package/dist/plugin/errors.js

@@ -0,0 +1,34 @@
+export class KiroTokenRefreshError extends Error {
+    code;
+    originalError;
+    constructor(message, code, originalError) {
+        super(message);
+        this.name = 'KiroTokenRefreshError';
+        this.code = code;
+        this.originalError = originalError;
+    }
+}
+export class KiroQuotaExhaustedError extends Error {
+    recoveryTime;
+    constructor(message, recoveryTime) {
+        super(message);
+        this.name = 'KiroQuotaExhaustedError';
+        this.recoveryTime = recoveryTime;
+    }
+}
+export class KiroRateLimitError extends Error {
+    retryAfter;
+    constructor(message, retryAfter) {
+        super(message);
+        this.name = 'KiroRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+export class KiroAuthError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.name = 'KiroAuthError';
+        this.statusCode = statusCode;
+    }
+}

package/dist/plugin/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function log(message: string, ...args: unknown[]): void;
+export declare function error(message: string, ...args: unknown[]): void;
+export declare function warn(message: string, ...args: unknown[]): void;
+export declare function debug(message: string, ...args: unknown[]): void;

package/dist/plugin/logger.js

@@ -0,0 +1,37 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+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) => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ')}\n`;
+        appendFileSync(path, content);
+    }
+    catch (e) { }
+};
+export function log(message, ...args) {
+    console.log(`[${new Date().toISOString()}] ${message}`, ...args);
+    writeToFile('INFO', message, ...args);
+}
+export function error(message, ...args) {
+    console.error(`[${new Date().toISOString()}] ERROR: ${message}`, ...args);
+    writeToFile('ERROR', message, ...args);
+}
+export function warn(message, ...args) {
+    console.warn(`[${new Date().toISOString()}] WARN: ${message}`, ...args);
+    writeToFile('WARN', message, ...args);
+}
+export function debug(message, ...args) {
+    if (process.env.DEBUG) {
+        console.debug(`[${new Date().toISOString()}] DEBUG: ${message}`, ...args);
+        writeToFile('DEBUG', message, ...args);
+    }
+}

package/dist/plugin/models.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveKiroModel(model: string): string;
+export declare function getSupportedModels(): string[];
+export declare function isModelSupported(model: string): boolean;

package/dist/plugin/models.js

@@ -0,0 +1,14 @@
+import { MODEL_MAPPING, SUPPORTED_MODELS } from '../constants';
+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 getSupportedModels() {
+    return SUPPORTED_MODELS;
+}
+export function isModelSupported(model) {
+    return SUPPORTED_MODELS.includes(model);
+}

package/dist/plugin/oauth-parser.d.ts

@@ -0,0 +1,5 @@
+export interface ParsedOAuthCallback {
+    code: string;
+    state: string;
+}
+export declare function parseOAuthCallbackInput(input: string): ParsedOAuthCallback;

package/dist/plugin/oauth-parser.js

@@ -0,0 +1,23 @@
+export function parseOAuthCallbackInput(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const code = url.searchParams.get('code');
+        const state = url.searchParams.get('state');
+        if (!code || !state) {
+            throw new Error('Missing code or state in URL');
+        }
+        return { code, state };
+    }
+    catch {
+        const codeMatch = trimmed.match(/code=([^&\s]+)/);
+        const stateMatch = trimmed.match(/state=([^&\s]+)/);
+        if (codeMatch?.[1] && stateMatch?.[1]) {
+            return {
+                code: decodeURIComponent(codeMatch[1]),
+                state: decodeURIComponent(stateMatch[1]),
+            };
+        }
+        throw new Error('Invalid OAuth callback format. Expected full URL or query string with code and state parameters.');
+    }
+}

package/dist/plugin/quota.d.ts

@@ -0,0 +1,15 @@
+import { ManagedAccount } from './types';
+export type QuotaStatus = 'healthy' | 'warning' | 'exhausted';
+export interface QuotaInfo {
+    status: QuotaStatus;
+    used: number;
+    limit: number;
+    remaining: number;
+    percentage: number;
+    recoveryTime?: number;
+}
+export declare function checkQuotaStatus(account: ManagedAccount): QuotaStatus;
+export declare function updateAccountQuota(account: ManagedAccount, usage: any, accountManager?: any): void;
+export declare function sortAccountsByQuota(accounts: ManagedAccount[]): ManagedAccount[];
+export declare function filterHealthyAccounts(accounts: ManagedAccount[]): ManagedAccount[];
+export declare function getAccountWithMostQuota(accounts: ManagedAccount[]): ManagedAccount | null;

package/dist/plugin/quota.js

@@ -0,0 +1,68 @@
+import { calculateUsagePercentage, isQuotaExhausted, getRemainingCount } from './usage';
+const WARNING_THRESHOLD_PERCENT = 80;
+export function checkQuotaStatus(account) {
+    if (!account.usedCount || !account.limitCount) {
+        return 'healthy';
+    }
+    const usage = {
+        usedCount: account.usedCount,
+        limitCount: account.limitCount,
+    };
+    if (isQuotaExhausted(usage)) {
+        return 'exhausted';
+    }
+    const percentage = calculateUsagePercentage(usage);
+    if (percentage >= WARNING_THRESHOLD_PERCENT) {
+        return 'warning';
+    }
+    return 'healthy';
+}
+export function updateAccountQuota(account, usage, accountManager) {
+    const metadata = {
+        usedCount: typeof usage.usedCount === 'number' ? usage.usedCount : 0,
+        limitCount: typeof usage.limitCount === 'number' ? usage.limitCount : 0,
+        realEmail: usage.email
+    };
+    account.usedCount = metadata.usedCount;
+    account.limitCount = metadata.limitCount;
+    if (metadata.realEmail) {
+        account.realEmail = metadata.realEmail;
+    }
+    if (accountManager) {
+        accountManager.updateUsage(account.id, metadata);
+    }
+}
+export function sortAccountsByQuota(accounts) {
+    return [...accounts].sort((a, b) => {
+        const aRemaining = getRemainingQuota(a);
+        const bRemaining = getRemainingQuota(b);
+        return bRemaining - aRemaining;
+    });
+}
+function getRemainingQuota(account) {
+    if (!account.usedCount || !account.limitCount) {
+        return Infinity;
+    }
+    const usage = {
+        usedCount: account.usedCount,
+        limitCount: account.limitCount,
+    };
+    return getRemainingCount(usage);
+}
+export function filterHealthyAccounts(accounts) {
+    return accounts.filter(account => {
+        if (!account.isHealthy) {
+            return false;
+        }
+        const status = checkQuotaStatus(account);
+        return status !== 'exhausted';
+    });
+}
+export function getAccountWithMostQuota(accounts) {
+    const healthyAccounts = filterHealthyAccounts(accounts);
+    if (healthyAccounts.length === 0) {
+        return null;
+    }
+    const sorted = sortAccountsByQuota(healthyAccounts);
+    return sorted[0] || null;
+}

package/dist/plugin/recovery.d.ts

@@ -0,0 +1,19 @@
+export interface RecoveryState {
+    sessionId: string;
+    conversationId: string;
+    model: string;
+    lastMessageIndex: number;
+    errorCount: number;
+    lastError?: string;
+    timestamp: number;
+}
+export interface RecoveryStorage {
+    version: 1;
+    sessions: Record<string, RecoveryState>;
+}
+export interface SessionRecoveryHook {
+    handleSessionError(error: any, sessionId: string): Promise<boolean>;
+    isRecoverableError(error: any): boolean;
+    clearSession(sessionId: string): Promise<void>;
+}
+export declare function createSessionRecoveryHook(enabled: boolean, autoResume: boolean): SessionRecoveryHook;