@quantiya/codevibe-core 1.0.0

package/dist/auth/auth-service.js

@@ -0,0 +1,310 @@
+"use strict";
+//
+// auth-service.ts
+// CodeVibe Core
+//
+// OAuth authentication service
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authService = exports.AuthService = void 0;
+const crypto = __importStar(require("crypto"));
+const http = __importStar(require("http"));
+const child_process_1 = require("child_process");
+const config_1 = require("../config");
+const keychain_1 = require("../keychain");
+const logger_1 = require("../logger");
+const CALLBACK_PORT = 8080;
+const CALLBACK_PATH = '/callback';
+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+/**
+ * Authentication service for OAuth flows
+ */
+class AuthService {
+    constructor() { }
+    static getInstance() {
+        if (!AuthService.instance) {
+            AuthService.instance = new AuthService();
+        }
+        return AuthService.instance;
+    }
+    /**
+     * Open URL in default browser
+     */
+    openBrowser(url) {
+        (0, child_process_1.spawn)('open', [url], { detached: true, stdio: 'ignore' }).unref();
+    }
+    /**
+     * Generate state for CSRF protection
+     */
+    generateState() {
+        return crypto.randomBytes(32).toString('hex');
+    }
+    /**
+     * Build authorization URL
+     */
+    buildAuthUrl(state) {
+        const config = (0, config_1.getConfig)();
+        const params = new URLSearchParams({
+            client_id: config.aws.cognitoClientId,
+            response_type: 'code',
+            scope: 'email openid profile',
+            redirect_uri: REDIRECT_URI,
+            state: state,
+        });
+        return `https://${config.aws.cognitoDomain}/oauth2/authorize?${params.toString()}`;
+    }
+    /**
+     * Exchange authorization code for tokens
+     */
+    async exchangeCodeForTokens(code) {
+        const config = (0, config_1.getConfig)();
+        const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;
+        const params = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: config.aws.cognitoClientId,
+            code: code,
+            redirect_uri: REDIRECT_URI,
+        });
+        const response = await fetch(tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
+        }
+        const data = await response.json();
+        return {
+            accessToken: data.access_token,
+            idToken: data.id_token,
+            refreshToken: data.refresh_token,
+            expiresIn: data.expires_in,
+        };
+    }
+    /**
+     * Decode JWT payload
+     */
+    decodeJwt(token) {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            throw new Error('Invalid JWT');
+        return JSON.parse(Buffer.from(parts[1], 'base64').toString('utf-8'));
+    }
+    /**
+     * Refresh tokens
+     */
+    async refreshTokens(refreshToken) {
+        const config = (0, config_1.getConfig)();
+        const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;
+        const params = new URLSearchParams({
+            grant_type: 'refresh_token',
+            client_id: config.aws.cognitoClientId,
+            refresh_token: refreshToken,
+        });
+        const response = await fetch(tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            throw new Error(`Token refresh failed: ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            accessToken: data.access_token,
+            idToken: data.id_token,
+            expiresIn: data.expires_in,
+        };
+    }
+    /**
+     * Login via OAuth browser flow
+     */
+    async login() {
+        // Check if already logged in
+        const existing = await keychain_1.keychainManager.getTokens((0, config_1.getEnvironment)());
+        if (existing && !keychain_1.keychainManager.isTokenExpired(existing)) {
+            return existing;
+        }
+        const state = this.generateState();
+        const authUrl = this.buildAuthUrl(state);
+        return new Promise((resolve, reject) => {
+            const server = http.createServer(async (req, res) => {
+                if (!req.url?.startsWith(CALLBACK_PATH)) {
+                    res.writeHead(404);
+                    res.end('Not found');
+                    return;
+                }
+                try {
+                    const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
+                    const code = url.searchParams.get('code');
+                    const returnedState = url.searchParams.get('state');
+                    const error = url.searchParams.get('error');
+                    if (error) {
+                        throw new Error(`OAuth error: ${error}`);
+                    }
+                    if (returnedState !== state) {
+                        throw new Error('State mismatch');
+                    }
+                    if (!code) {
+                        throw new Error('No authorization code');
+                    }
+                    const tokens = await this.exchangeCodeForTokens(code);
+                    const idPayload = this.decodeJwt(tokens.idToken);
+                    const tokenData = {
+                        accessToken: tokens.accessToken,
+                        idToken: tokens.idToken,
+                        refreshToken: tokens.refreshToken,
+                        expiresAt: Date.now() + (tokens.expiresIn * 1000),
+                        userId: idPayload.sub,
+                        email: idPayload.email || 'unknown',
+                    };
+                    await keychain_1.keychainManager.setTokens(tokenData, (0, config_1.getEnvironment)());
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(`
+            <!DOCTYPE html>
+            <html>
+            <head><title>Success</title></head>
+            <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;">
+              <h1 style="color: #22c55e;">&#10003; Authentication Successful</h1>
+              <p>You can close this window.</p>
+            </body>
+            </html>
+          `);
+                    setTimeout(() => {
+                        server.close(() => resolve(tokenData));
+                    }, 500);
+                }
+                catch (err) {
+                    res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(`
+            <!DOCTYPE html>
+            <html>
+            <head><title>Error</title></head>
+            <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;">
+              <h1 style="color: #ef4444;">&#10007; Authentication Failed</h1>
+              <p>${err.message}</p>
+            </body>
+            </html>
+          `);
+                    setTimeout(() => {
+                        server.close(() => reject(err));
+                    }, 500);
+                }
+            });
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${CALLBACK_PORT} is in use`));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            server.listen(CALLBACK_PORT, 'localhost', () => {
+                logger_1.logger.info('[AuthService] Callback server started');
+                this.openBrowser(authUrl);
+            });
+            // Timeout
+            setTimeout(() => {
+                server.close(() => reject(new Error('Login timeout')));
+            }, 2 * 60 * 1000);
+        });
+    }
+    /**
+     * Logout
+     */
+    async logout() {
+        const config = (0, config_1.getConfig)();
+        const deleted = await keychain_1.keychainManager.deleteTokens((0, config_1.getEnvironment)());
+        if (deleted) {
+            // Start temporary server to handle signout callback
+            return new Promise((resolve) => {
+                const server = http.createServer((req, res) => {
+                    if (req.url?.startsWith('/signout')) {
+                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(`
+              <!DOCTYPE html>
+              <html>
+              <head><title>Signed Out</title></head>
+              <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;">
+                <h1 style="color: #22c55e;">&#10003; Signed Out</h1>
+                <p>You can close this window.</p>
+              </body>
+              </html>
+            `);
+                        setTimeout(() => {
+                            server.close(() => resolve(true));
+                        }, 500);
+                    }
+                    else {
+                        res.writeHead(404);
+                        res.end('Not found');
+                    }
+                });
+                server.on('error', () => {
+                    resolve(true); // Still return true since tokens were deleted
+                });
+                server.listen(CALLBACK_PORT, 'localhost', () => {
+                    const logoutUrl = `https://${config.aws.cognitoDomain}/logout?` +
+                        `client_id=${config.aws.cognitoClientId}&` +
+                        `logout_uri=${encodeURIComponent(REDIRECT_URI.replace('/callback', '/signout'))}`;
+                    this.openBrowser(logoutUrl);
+                });
+                // Timeout after 30 seconds
+                setTimeout(() => {
+                    server.close(() => resolve(true));
+                }, 30 * 1000);
+            });
+        }
+        return deleted;
+    }
+    /**
+     * Get current auth status
+     */
+    async getStatus() {
+        const tokens = await keychain_1.keychainManager.getTokens((0, config_1.getEnvironment)());
+        if (!tokens) {
+            return { authenticated: false };
+        }
+        return {
+            authenticated: !keychain_1.keychainManager.isTokenExpired(tokens),
+            tokens,
+        };
+    }
+}
+exports.AuthService = AuthService;
+exports.authService = AuthService.getInstance();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-service.js","sourceRoot":"","sources":["../../src/auth/auth-service.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// auth-service.ts\n// CodeVibe Core\n//\n// OAuth authentication service\n//\n\nimport * as crypto from 'crypto';\nimport * as http from 'http';\nimport { spawn } from 'child_process';\nimport { getConfig, getEnvironment } from '../config';\nimport { keychainManager } from '../keychain';\nimport { logger } from '../logger';\nimport { TokenData } from '../types';\n\nconst CALLBACK_PORT = 8080;\nconst CALLBACK_PATH = '/callback';\nconst REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;\n\n/**\n * Authentication service for OAuth flows\n */\nexport class AuthService {\n  private static instance: AuthService;\n\n  private constructor() {}\n\n  static getInstance(): AuthService {\n    if (!AuthService.instance) {\n      AuthService.instance = new AuthService();\n    }\n    return AuthService.instance;\n  }\n\n  /**\n   * Open URL in default browser\n   */\n  private openBrowser(url: string): void {\n    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();\n  }\n\n  /**\n   * Generate state for CSRF protection\n   */\n  private generateState(): string {\n    return crypto.randomBytes(32).toString('hex');\n  }\n\n  /**\n   * Build authorization URL\n   */\n  private buildAuthUrl(state: string): string {\n    const config = getConfig();\n    const params = new URLSearchParams({\n      client_id: config.aws.cognitoClientId,\n      response_type: 'code',\n      scope: 'email openid profile',\n      redirect_uri: REDIRECT_URI,\n      state: state,\n    });\n\n    return `https://${config.aws.cognitoDomain}/oauth2/authorize?${params.toString()}`;\n  }\n\n  /**\n   * Exchange authorization code for tokens\n   */\n  private async exchangeCodeForTokens(code: string): Promise<{\n    accessToken: string;\n    idToken: string;\n    refreshToken: string;\n    expiresIn: number;\n  }> {\n    const config = getConfig();\n    const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n    const params = new URLSearchParams({\n      grant_type: 'authorization_code',\n      client_id: config.aws.cognitoClientId,\n      code: code,\n      redirect_uri: REDIRECT_URI,\n    });\n\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      body: params.toString(),\n    });\n\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`Token exchange failed: ${response.status} ${errorText}`);\n    }\n\n    const data = await response.json() as {\n      access_token: string;\n      id_token: string;\n      refresh_token: string;\n      expires_in: number;\n    };\n\n    return {\n      accessToken: data.access_token,\n      idToken: data.id_token,\n      refreshToken: data.refresh_token,\n      expiresIn: data.expires_in,\n    };\n  }\n\n  /**\n   * Decode JWT payload\n   */\n  private decodeJwt(token: string): any {\n    const parts = token.split('.');\n    if (parts.length !== 3) throw new Error('Invalid JWT');\n    return JSON.parse(Buffer.from(parts[1], 'base64').toString('utf-8'));\n  }\n\n  /**\n   * Refresh tokens\n   */\n  async refreshTokens(refreshToken: string): Promise<{\n    accessToken: string;\n    idToken: string;\n    expiresIn: number;\n  }> {\n    const config = getConfig();\n    const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n    const params = new URLSearchParams({\n      grant_type: 'refresh_token',\n      client_id: config.aws.cognitoClientId,\n      refresh_token: refreshToken,\n    });\n\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      body: params.toString(),\n    });\n\n    if (!response.ok) {\n      throw new Error(`Token refresh failed: ${response.status}`);\n    }\n\n    const data = await response.json() as {\n      access_token: string;\n      id_token: string;\n      expires_in: number;\n    };\n\n    return {\n      accessToken: data.access_token,\n      idToken: data.id_token,\n      expiresIn: data.expires_in,\n    };\n  }\n\n  /**\n   * Login via OAuth browser flow\n   */\n  async login(): Promise<TokenData | null> {\n    // Check if already logged in\n    const existing = await keychainManager.getTokens(getEnvironment());\n    if (existing && !keychainManager.isTokenExpired(existing)) {\n      return existing;\n    }\n\n    const state = this.generateState();\n    const authUrl = this.buildAuthUrl(state);\n\n    return new Promise((resolve, reject) => {\n      const server = http.createServer(async (req, res) => {\n        if (!req.url?.startsWith(CALLBACK_PATH)) {\n          res.writeHead(404);\n          res.end('Not found');\n          return;\n        }\n\n        try {\n          const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);\n          const code = url.searchParams.get('code');\n          const returnedState = url.searchParams.get('state');\n          const error = url.searchParams.get('error');\n\n          if (error) {\n            throw new Error(`OAuth error: ${error}`);\n          }\n\n          if (returnedState !== state) {\n            throw new Error('State mismatch');\n          }\n\n          if (!code) {\n            throw new Error('No authorization code');\n          }\n\n          const tokens = await this.exchangeCodeForTokens(code);\n          const idPayload = this.decodeJwt(tokens.idToken);\n\n          const tokenData: TokenData = {\n            accessToken: tokens.accessToken,\n            idToken: tokens.idToken,\n            refreshToken: tokens.refreshToken,\n            expiresAt: Date.now() + (tokens.expiresIn * 1000),\n            userId: idPayload.sub,\n            email: idPayload.email || 'unknown',\n          };\n\n          await keychainManager.setTokens(tokenData, getEnvironment());\n\n          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });\n          res.end(`\n            <!DOCTYPE html>\n            <html>\n            <head><title>Success</title></head>\n            <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n              <h1 style=\"color: #22c55e;\">&#10003; Authentication Successful</h1>\n              <p>You can close this window.</p>\n            </body>\n            </html>\n          `);\n\n          setTimeout(() => {\n            server.close(() => resolve(tokenData));\n          }, 500);\n        } catch (err: any) {\n          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });\n          res.end(`\n            <!DOCTYPE html>\n            <html>\n            <head><title>Error</title></head>\n            <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n              <h1 style=\"color: #ef4444;\">&#10007; Authentication Failed</h1>\n              <p>${err.message}</p>\n            </body>\n            </html>\n          `);\n\n          setTimeout(() => {\n            server.close(() => reject(err));\n          }, 500);\n        }\n      });\n\n      server.on('error', (err: any) => {\n        if (err.code === 'EADDRINUSE') {\n          reject(new Error(`Port ${CALLBACK_PORT} is in use`));\n        } else {\n          reject(err);\n        }\n      });\n\n      server.listen(CALLBACK_PORT, 'localhost', () => {\n        logger.info('[AuthService] Callback server started');\n        this.openBrowser(authUrl);\n      });\n\n      // Timeout\n      setTimeout(() => {\n        server.close(() => reject(new Error('Login timeout')));\n      }, 2 * 60 * 1000);\n    });\n  }\n\n  /**\n   * Logout\n   */\n  async logout(): Promise<boolean> {\n    const config = getConfig();\n    const deleted = await keychainManager.deleteTokens(getEnvironment());\n\n    if (deleted) {\n      // Start temporary server to handle signout callback\n      return new Promise((resolve) => {\n        const server = http.createServer((req, res) => {\n          if (req.url?.startsWith('/signout')) {\n            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });\n            res.end(`\n              <!DOCTYPE html>\n              <html>\n              <head><title>Signed Out</title></head>\n              <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n                <h1 style=\"color: #22c55e;\">&#10003; Signed Out</h1>\n                <p>You can close this window.</p>\n              </body>\n              </html>\n            `);\n\n            setTimeout(() => {\n              server.close(() => resolve(true));\n            }, 500);\n          } else {\n            res.writeHead(404);\n            res.end('Not found');\n          }\n        });\n\n        server.on('error', () => {\n          resolve(true); // Still return true since tokens were deleted\n        });\n\n        server.listen(CALLBACK_PORT, 'localhost', () => {\n          const logoutUrl = `https://${config.aws.cognitoDomain}/logout?` +\n            `client_id=${config.aws.cognitoClientId}&` +\n            `logout_uri=${encodeURIComponent(REDIRECT_URI.replace('/callback', '/signout'))}`;\n\n          this.openBrowser(logoutUrl);\n        });\n\n        // Timeout after 30 seconds\n        setTimeout(() => {\n          server.close(() => resolve(true));\n        }, 30 * 1000);\n      });\n    }\n\n    return deleted;\n  }\n\n  /**\n   * Get current auth status\n   */\n  async getStatus(): Promise<{ authenticated: boolean; tokens?: TokenData }> {\n    const tokens = await keychainManager.getTokens(getEnvironment());\n    if (!tokens) {\n      return { authenticated: false };\n    }\n\n    return {\n      authenticated: !keychainManager.isTokenExpired(tokens),\n      tokens,\n    };\n  }\n}\n\nexport const authService = AuthService.getInstance();\n"]}

package/dist/auth/index.d.ts

@@ -0,0 +1,2 @@
+export { AuthService, authService } from './auth-service';
+export { runAuthCli } from './auth-cli';

package/dist/auth/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuthCli = exports.authService = exports.AuthService = void 0;
+var auth_service_1 = require("./auth-service");
+Object.defineProperty(exports, "AuthService", { enumerable: true, get: function () { return auth_service_1.AuthService; } });
+Object.defineProperty(exports, "authService", { enumerable: true, get: function () { return auth_service_1.authService; } });
+var auth_cli_1 = require("./auth-cli");
+Object.defineProperty(exports, "runAuthCli", { enumerable: true, get: function () { return auth_cli_1.runAuthCli; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXV0aC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQ0FBMEQ7QUFBakQsMkdBQUEsV0FBVyxPQUFBO0FBQUUsMkdBQUEsV0FBVyxPQUFBO0FBQ2pDLHVDQUF3QztBQUEvQixzR0FBQSxVQUFVLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBBdXRoU2VydmljZSwgYXV0aFNlcnZpY2UgfSBmcm9tICcuL2F1dGgtc2VydmljZSc7XG5leHBvcnQgeyBydW5BdXRoQ2xpIH0gZnJvbSAnLi9hdXRoLWNsaSc7XG4iXX0=

package/dist/config/config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Environment type
+ */
+export type Environment = 'development' | 'production';
+/**
+ * Configuration interface
+ */
+export interface Config {
+    environment: Environment;
+    aws: {
+        region: string;
+        appsyncUrl: string;
+        cognitoUserPoolId: string;
+        cognitoClientId: string;
+        cognitoDomain: string;
+    };
+    keychain: {
+        serviceName: string;
+    };
+    server: {
+        port: number;
+        host: string;
+        dynamicPort: boolean;
+    };
+    claude: {
+        command: string;
+        defaultTimeout: number;
+    };
+    codex: {
+        command: string;
+        defaultTimeout: number;
+        sessionsDir: string;
+        approvalTimeoutMs: number;
+    };
+    gemini: {
+        command: string;
+        defaultTimeout: number;
+        transcriptDir: string;
+    };
+}
+/**
+ * Get environment from process.env.ENVIRONMENT, defaults to 'production'
+ */
+export declare function getEnvironment(): Environment;
+/**
+ * Load configuration for specific environment
+ * If no environment specified, uses process.env.ENVIRONMENT or defaults to 'production'
+ */
+export declare function loadConfig(environment?: Environment): Config;
+/**
+ * Get current configuration (auto-initializes if not already loaded)
+ */
+export declare function getConfig(): Config;

package/dist/config/config.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironment = getEnvironment;
+exports.loadConfig = loadConfig;
+exports.getConfig = getConfig;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+// Default configuration values
+const DEFAULT_CONFIG = {
+    development: {
+        environment: 'development',
+        aws: {
+            region: 'us-east-1',
+            appsyncUrl: 'https://te6rjr37sbfpjc4fiunmb2tgy4.appsync-api.us-east-1.amazonaws.com/graphql',
+            cognitoUserPoolId: 'us-east-1_yVwWDPvvJ',
+            cognitoClientId: 'e9r5apv6v5uui3l928r2ris0r',
+            cognitoDomain: 'codevibe-development.auth.us-east-1.amazoncognito.com',
+        },
+        keychain: {
+            serviceName: 'ai.quantiya.app.codevibe',
+        },
+        server: {
+            port: 3456,
+            host: '127.0.0.1',
+            dynamicPort: true,
+        },
+        claude: {
+            command: 'claude',
+            defaultTimeout: 60000,
+        },
+        codex: {
+            command: 'codex',
+            defaultTimeout: 60000,
+            sessionsDir: path_1.default.join(os_1.default.homedir(), '.codex', 'sessions'),
+            approvalTimeoutMs: 5000,
+        },
+        gemini: {
+            command: 'gemini',
+            defaultTimeout: 60000,
+            transcriptDir: path_1.default.join(os_1.default.homedir(), '.gemini', 'tmp'),
+        },
+    },
+    production: {
+        environment: 'production',
+        aws: {
+            region: 'us-east-1',
+            appsyncUrl: 'https://jwhyxq4sgrgcdosewp5k4ns5ca.appsync-api.us-east-1.amazonaws.com/graphql',
+            cognitoUserPoolId: 'us-east-1_mNRO0j5og',
+            cognitoClientId: '5p04dbc9ojptc5r8n7605fg78f',
+            cognitoDomain: 'codevibe-production.auth.us-east-1.amazoncognito.com',
+        },
+        keychain: {
+            serviceName: 'ai.quantiya.app.codevibe',
+        },
+        server: {
+            port: 3456,
+            host: '127.0.0.1',
+            dynamicPort: true,
+        },
+        claude: {
+            command: 'claude',
+            defaultTimeout: 60000,
+        },
+        codex: {
+            command: 'codex',
+            defaultTimeout: 60000,
+            sessionsDir: path_1.default.join(os_1.default.homedir(), '.codex', 'sessions'),
+            approvalTimeoutMs: 5000,
+        },
+        gemini: {
+            command: 'gemini',
+            defaultTimeout: 60000,
+            transcriptDir: path_1.default.join(os_1.default.homedir(), '.gemini', 'tmp'),
+        },
+    },
+};
+// Current configuration (mutable, lazy-initialized)
+let currentConfig = null;
+let configInitialized = false;
+/**
+ * Get environment from process.env.ENVIRONMENT, defaults to 'production'
+ */
+function getEnvironment() {
+    const env = process.env.ENVIRONMENT;
+    if (env === 'development' || env === 'production') {
+        return env;
+    }
+    return 'production';
+}
+/**
+ * Load configuration for specific environment
+ * If no environment specified, uses process.env.ENVIRONMENT or defaults to 'production'
+ */
+function loadConfig(environment) {
+    const env = environment || getEnvironment();
+    currentConfig = {
+        ...DEFAULT_CONFIG[env],
+        // Allow environment variable overrides
+        aws: {
+            ...DEFAULT_CONFIG[env].aws,
+            region: process.env.AWS_REGION || DEFAULT_CONFIG[env].aws.region,
+            appsyncUrl: process.env.APPSYNC_URL || DEFAULT_CONFIG[env].aws.appsyncUrl,
+            cognitoUserPoolId: process.env.COGNITO_USER_POOL_ID || DEFAULT_CONFIG[env].aws.cognitoUserPoolId,
+            cognitoClientId: process.env.COGNITO_CLIENT_ID || DEFAULT_CONFIG[env].aws.cognitoClientId,
+            cognitoDomain: process.env.COGNITO_DOMAIN || DEFAULT_CONFIG[env].aws.cognitoDomain,
+        },
+    };
+    configInitialized = true;
+    return currentConfig;
+}
+/**
+ * Get current configuration (auto-initializes if not already loaded)
+ */
+function getConfig() {
+    if (!configInitialized || !currentConfig) {
+        loadConfig();
+    }
+    return currentConfig;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"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","sourcesContent":["import os from 'os';\nimport path from 'path';\n\n/**\n * Environment type\n */\nexport type Environment = 'development' | 'production';\n\n/**\n * Configuration interface\n */\nexport interface Config {\n  environment: Environment;\n  aws: {\n    region: string;\n    appsyncUrl: string;\n    cognitoUserPoolId: string;\n    cognitoClientId: string;\n    cognitoDomain: string;\n  };\n  keychain: {\n    serviceName: string;\n  };\n  // Plugin-specific server configuration\n  server: {\n    port: number;\n    host: string;\n    dynamicPort: boolean;\n  };\n  // Claude-specific configuration\n  claude: {\n    command: string;\n    defaultTimeout: number;\n  };\n  // Codex-specific configuration\n  codex: {\n    command: string;\n    defaultTimeout: number;\n    sessionsDir: string;\n    approvalTimeoutMs: number;\n  };\n  // Gemini-specific configuration\n  gemini: {\n    command: string;\n    defaultTimeout: number;\n    transcriptDir: string;\n  };\n}\n\n// Default configuration values\nconst DEFAULT_CONFIG: Record<Environment, Config> = {\n  development: {\n    environment: 'development',\n    aws: {\n      region: 'us-east-1',\n      appsyncUrl: 'https://te6rjr37sbfpjc4fiunmb2tgy4.appsync-api.us-east-1.amazonaws.com/graphql',\n      cognitoUserPoolId: 'us-east-1_yVwWDPvvJ',\n      cognitoClientId: 'e9r5apv6v5uui3l928r2ris0r',\n      cognitoDomain: 'codevibe-development.auth.us-east-1.amazoncognito.com',\n    },\n    keychain: {\n      serviceName: 'ai.quantiya.app.codevibe',\n    },\n    server: {\n      port: 3456,\n      host: '127.0.0.1',\n      dynamicPort: true,\n    },\n    claude: {\n      command: 'claude',\n      defaultTimeout: 60000,\n    },\n    codex: {\n      command: 'codex',\n      defaultTimeout: 60000,\n      sessionsDir: path.join(os.homedir(), '.codex', 'sessions'),\n      approvalTimeoutMs: 5000,\n    },\n    gemini: {\n      command: 'gemini',\n      defaultTimeout: 60000,\n      transcriptDir: path.join(os.homedir(), '.gemini', 'tmp'),\n    },\n  },\n  production: {\n    environment: 'production',\n    aws: {\n      region: 'us-east-1',\n      appsyncUrl: 'https://jwhyxq4sgrgcdosewp5k4ns5ca.appsync-api.us-east-1.amazonaws.com/graphql',\n      cognitoUserPoolId: 'us-east-1_mNRO0j5og',\n      cognitoClientId: '5p04dbc9ojptc5r8n7605fg78f',\n      cognitoDomain: 'codevibe-production.auth.us-east-1.amazoncognito.com',\n    },\n    keychain: {\n      serviceName: 'ai.quantiya.app.codevibe',\n    },\n    server: {\n      port: 3456,\n      host: '127.0.0.1',\n      dynamicPort: true,\n    },\n    claude: {\n      command: 'claude',\n      defaultTimeout: 60000,\n    },\n    codex: {\n      command: 'codex',\n      defaultTimeout: 60000,\n      sessionsDir: path.join(os.homedir(), '.codex', 'sessions'),\n      approvalTimeoutMs: 5000,\n    },\n    gemini: {\n      command: 'gemini',\n      defaultTimeout: 60000,\n      transcriptDir: path.join(os.homedir(), '.gemini', 'tmp'),\n    },\n  },\n};\n\n// Current configuration (mutable, lazy-initialized)\nlet currentConfig: Config | null = null;\nlet configInitialized = false;\n\n/**\n * Get environment from process.env.ENVIRONMENT, defaults to 'production'\n */\nexport function getEnvironment(): Environment {\n  const env = process.env.ENVIRONMENT as Environment;\n  if (env === 'development' || env === 'production') {\n    return env;\n  }\n  return 'production';\n}\n\n/**\n * Load configuration for specific environment\n * If no environment specified, uses process.env.ENVIRONMENT or defaults to 'production'\n */\nexport function loadConfig(environment?: Environment): Config {\n  const env = environment || getEnvironment();\n  currentConfig = {\n    ...DEFAULT_CONFIG[env],\n    // Allow environment variable overrides\n    aws: {\n      ...DEFAULT_CONFIG[env].aws,\n      region: process.env.AWS_REGION || DEFAULT_CONFIG[env].aws.region,\n      appsyncUrl: process.env.APPSYNC_URL || DEFAULT_CONFIG[env].aws.appsyncUrl,\n      cognitoUserPoolId: process.env.COGNITO_USER_POOL_ID || DEFAULT_CONFIG[env].aws.cognitoUserPoolId,\n      cognitoClientId: process.env.COGNITO_CLIENT_ID || DEFAULT_CONFIG[env].aws.cognitoClientId,\n      cognitoDomain: process.env.COGNITO_DOMAIN || DEFAULT_CONFIG[env].aws.cognitoDomain,\n    },\n  };\n  configInitialized = true;\n  return currentConfig;\n}\n\n/**\n * Get current configuration (auto-initializes if not already loaded)\n */\nexport function getConfig(): Config {\n  if (!configInitialized || !currentConfig) {\n    loadConfig();\n  }\n  return currentConfig!;\n}\n"]}

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export { loadConfig, getConfig, getEnvironment } from './config';
+export type { Config, Environment } from './config';

package/dist/config/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironment = exports.getConfig = exports.loadConfig = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+Object.defineProperty(exports, "getEnvironment", { enumerable: true, get: function () { return config_1.getEnvironment; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQUFpRTtBQUF4RCxvR0FBQSxVQUFVLE9BQUE7QUFBRSxtR0FBQSxTQUFTLE9BQUE7QUFBRSx3R0FBQSxjQUFjLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBsb2FkQ29uZmlnLCBnZXRDb25maWcsIGdldEVudmlyb25tZW50IH0gZnJvbSAnLi9jb25maWcnO1xuZXhwb3J0IHR5cGUgeyBDb25maWcsIEVudmlyb25tZW50IH0gZnJvbSAnLi9jb25maWcnO1xuIl19