@codemieai/code 0.0.2 → 0.0.4

package/bin/codemie-claude.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+/**
+ * CodeMie Claude Direct Agent
+ * Direct executable for the claude agent (bypasses registry)
+ */
+
+import { ClaudeCodeAdapter } from '../dist/agents/adapters/claude-code.js';
+import { ConfigLoader } from '../dist/utils/config-loader.js';
+import { logger } from '../dist/utils/logger.js';
+import { validateProviderCompatibility, validateModelCompatibility, displayCompatibilityError } from '../dist/utils/agent-compatibility.js';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getDirname } from '../dist/utils/dirname.js';
+
+const program = new Command();
+
+// Read version from package.json
+let version = '1.0.0';
+try {
+  const packageJsonPath = join(getDirname(import.meta.url), '../package.json');
+  const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
+  const packageJson = JSON.parse(packageJsonContent);
+  version = packageJson.version;
+} catch {
+  // Use default version if unable to read
+}
+
+program
+  .name('codemie-claude')
+  .description('CodeMie Claude - Direct access to Claude Code agent')
+  .version(version)
+  .option('-m, --model <model>', 'Override model')
+  .option('-p, --provider <provider>', 'Override provider')
+  .option('--api-key <key>', 'Override API key')
+  .option('--base-url <url>', 'Override base URL')
+  .option('--timeout <seconds>', 'Override timeout (in seconds)', parseInt)
+  .allowUnknownOption() // Allow passing unknown options to Claude
+  .passThroughOptions() // Pass through options to Claude
+  .argument('[args...]', 'Arguments to pass to Claude Code')
+  .action(async (args, options) => {
+    try {
+      const adapter = new ClaudeCodeAdapter();
+
+      // Check if Claude Code is installed
+      if (!(await adapter.isInstalled())) {
+        logger.error('Claude Code is not installed. Install it first with: codemie install claude');
+        process.exit(1);
+      }
+
+      // Load configuration with CLI overrides
+      const config = await ConfigLoader.load(process.cwd(), {
+        model: options.model,
+        provider: options.provider,
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+        timeout: options.timeout
+      });
+
+      // Handle SSO provider detection
+      if (config.provider === 'ai-run-sso' || (config.baseUrl && config.baseUrl.includes('codemie'))) {
+        // Update provider to ai-run-sso if detected from baseUrl
+        if (config.provider !== 'ai-run-sso') {
+          config.provider = 'ai-run-sso';
+        }
+      }
+
+      // Validate essential configuration
+      if (!config.baseUrl || !config.apiKey || !config.model) {
+        logger.error('Configuration incomplete. Run: codemie setup');
+        process.exit(1);
+      }
+
+      // Validate provider compatibility
+      const providerResult = validateProviderCompatibility('claude', config);
+      if (!providerResult.valid) {
+        displayCompatibilityError(providerResult, logger);
+        process.exit(1);
+      }
+
+      // Validate model compatibility
+      const modelResult = validateModelCompatibility('claude', config);
+      if (!modelResult.valid) {
+        displayCompatibilityError(modelResult, logger);
+        process.exit(1);
+      }
+
+      // Export provider-specific environment variables
+      const providerEnv = ConfigLoader.exportProviderEnvVars(config);
+
+      // Collect all arguments to pass to Claude
+      const claudeArgs = [...args];
+
+      // Add back unknown options that were parsed
+      const knownOptions = ['model', 'provider', 'apiKey', 'baseUrl', 'timeout'];
+      for (const [key, value] of Object.entries(options)) {
+        if (knownOptions.includes(key)) continue;
+
+        if (key.length === 1) {
+          claudeArgs.push(`-${key}`);
+        } else {
+          claudeArgs.push(`--${key}`);
+        }
+
+        if (value !== true && value !== undefined) {
+          claudeArgs.push(String(value));
+        }
+      }
+
+      // Run Claude Code directly
+      logger.info(`Starting Claude Code with model ${config.model}...`);
+      await adapter.run(claudeArgs, providerEnv);
+    } catch (error) {
+      logger.error('Failed to run Claude Code:', error);
+      process.exit(1);
+    }
+  });
+
+// Add health check command
+program
+  .command('health')
+  .description('Check Claude Code health and installation')
+  .action(async () => {
+    try {
+      const adapter = new ClaudeCodeAdapter();
+
+      if (await adapter.isInstalled()) {
+        const version = await adapter.getVersion();
+        logger.success('Claude Code is installed and ready');
+        if (version) {
+          console.log(`Version: ${version}`);
+        }
+      } else {
+        logger.error('Claude Code is not installed');
+        console.log('Install with: codemie install claude');
+        process.exit(1);
+      }
+    } catch (error) {
+      logger.error('Health check failed:', error);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/bin/codemie-code.js

@@ -1,23 +1,136 @@
 #!/usr/bin/env node
 
 /**
- * CodeMie Code - AI Coding Assistant
- * Entry point for the codemie-code executable
+ * CodeMie Native Agent
+ * Direct executable for the codemie-code agent
  */
 
-const { runCLI } = require('../dist/cli/cli.js');
-const { logger } = require('../dist/utils/logger.js');
+import { CodeMieCode } from '../dist/agents/codemie-code/index.js';
+import { loadCodeMieConfig } from '../dist/agents/codemie-code/config.js';
+import { logger } from '../dist/utils/logger.js';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getDirname } from '../dist/utils/dirname.js';
+import chalk from 'chalk';
 
-async function main() {
-  try {
-    await runCLI();
-  } catch (error) {
-    logger.error('Failed to run CodeMie Code:', error);
-    process.exit(1);
-  }
+const program = new Command();
+
+// Read version from package.json
+let version = '1.0.0';
+try {
+  const packageJsonPath = join(getDirname(import.meta.url), '../package.json');
+  const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
+  const packageJson = JSON.parse(packageJsonContent);
+  version = packageJson.version;
+} catch {
+  // Use default version if unable to read
 }
 
-main().catch((error) => {
-  console.error('Unhandled error:', error);
-  process.exit(1);
-});
+program
+  .name('codemie-code')
+  .description('CodeMie Native Agent - Built-in LangGraph-based coding assistant')
+  .version(version)
+  .option('--task <task>', 'Execute a single task and exit')
+  .option('--debug', 'Enable debug logging')
+  .option('--plan', 'Enable structured planning mode with visual todo tracking')
+  .option('--plan-only', 'Generate plan without execution (planning phase only)')
+  .argument('[message...]', 'Initial message or conversation starter')
+  .action(async (message, options) => {
+    try {
+      const workingDir = process.cwd();
+
+      // Initialize the agent with debug flag
+      const codeMie = new CodeMieCode(workingDir);
+
+      try {
+        await codeMie.initialize({ debug: options.debug });
+      } catch (error) {
+        logger.error('CodeMie configuration required. Please run: codemie setup');
+        process.exit(1);
+      }
+
+      if (options.task) {
+        // Single task execution with modern UI
+        const planOptions = {
+          planMode: options.plan || options.planOnly,
+          planOnly: options.planOnly
+        };
+        const result = await codeMie.executeTaskWithUI(options.task, planOptions);
+        console.log(result);
+      } else if (message.length > 0) {
+        // Execute initial message then continue interactively
+        const initialMessage = message.join(' ');
+        console.log(`> ${initialMessage}`);
+
+        const planOptions = {
+          planMode: options.plan || options.planOnly,
+          planOnly: options.planOnly
+        };
+        await codeMie.executeTaskWithUI(initialMessage, planOptions);
+        console.log(''); // Add spacing
+
+        // Start interactive session (with plan mode if enabled)
+        if (options.plan && !options.planOnly) {
+          // Enable plan mode for interactive session
+          const agent = codeMie.getAgent();
+          if (agent) {
+            const { CodeMieTerminalUI } = await import('../dist/agents/codemie-code/ui.js');
+            const ui = new CodeMieTerminalUI(agent);
+            ui.enablePlanMode();
+            await ui.startInteractive();
+            ui.dispose();
+          } else {
+            await codeMie.startInteractive();
+          }
+        } else if (!options.planOnly) {
+          await codeMie.startInteractive();
+        }
+      } else {
+        // Pure interactive mode
+        if (options.plan) {
+          // Enable plan mode for interactive session (no extra console message)
+          const agent = codeMie.getAgent();
+          if (agent) {
+            const { CodeMieTerminalUI } = await import('../dist/agents/codemie-code/ui.js');
+            const ui = new CodeMieTerminalUI(agent);
+            ui.enablePlanMode();
+            await ui.startInteractive();
+            ui.dispose();
+          } else {
+            await codeMie.startInteractive();
+          }
+        } else {
+          await codeMie.startInteractive();
+        }
+      }
+    } catch (error) {
+      logger.error('Failed to run CodeMie Native:', error);
+      process.exit(1);
+    }
+  });
+
+// Add health check command
+program
+  .command('health')
+  .description('Check CodeMie Native health and configuration')
+  .action(async () => {
+    try {
+      const result = await CodeMieCode.testConnection(process.cwd());
+
+      if (result.success) {
+        logger.success('CodeMie Native is healthy');
+        console.log(`Provider: ${result.provider}`);
+        console.log(`Model: ${result.model}`);
+      } else {
+        logger.error('CodeMie Native health check failed:');
+        console.log(result.error);
+        process.exit(1);
+      }
+    } catch (error) {
+      logger.error('Health check failed:', error);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/bin/codemie-codex.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * CodeMie Codex Direct Agent
+ * Direct executable for the codex agent (bypasses registry)
+ */
+
+import { CodexAdapter } from '../dist/agents/adapters/codex.js';
+import { ConfigLoader } from '../dist/utils/config-loader.js';
+import { logger } from '../dist/utils/logger.js';
+import { validateProviderCompatibility, validateModelCompatibility, displayCompatibilityError } from '../dist/utils/agent-compatibility.js';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getDirname } from '../dist/utils/dirname.js';
+
+const program = new Command();
+
+// Read version from package.json
+let version = '1.0.0';
+try {
+  const packageJsonPath = join(getDirname(import.meta.url), '../package.json');
+  const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
+  const packageJson = JSON.parse(packageJsonContent);
+  version = packageJson.version;
+} catch {
+  // Use default version if unable to read
+}
+
+program
+  .name('codemie-codex')
+  .description('CodeMie Codex - Direct access to OpenAI Codex agent')
+  .version(version)
+  .option('-m, --model <model>', 'Override model (must be OpenAI-compatible)')
+  .option('-p, --provider <provider>', 'Override provider')
+  .option('--api-key <key>', 'Override API key')
+  .option('--base-url <url>', 'Override base URL')
+  .option('--timeout <seconds>', 'Override timeout (in seconds)', parseInt)
+  .allowUnknownOption() // Allow passing unknown options to Codex
+  .passThroughOptions() // Pass through options to Codex
+  .argument('[args...]', 'Arguments to pass to Codex')
+  .action(async (args, options) => {
+    try {
+      const adapter = new CodexAdapter();
+
+      // Check if Codex is installed
+      if (!(await adapter.isInstalled())) {
+        logger.error('Codex is not installed. Install it first with: codemie install codex');
+        process.exit(1);
+      }
+
+      // Load configuration with CLI overrides
+      const config = await ConfigLoader.load(process.cwd(), {
+        model: options.model,
+        provider: options.provider,
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+        timeout: options.timeout
+      });
+
+      // Validate essential configuration
+      if (!config.baseUrl || !config.apiKey || !config.model) {
+        logger.error('Configuration incomplete. Run: codemie setup');
+        process.exit(1);
+      }
+
+      // Validate provider compatibility
+      const providerResult = validateProviderCompatibility('codex', config);
+      if (!providerResult.valid) {
+        displayCompatibilityError(providerResult, logger);
+        process.exit(1);
+      }
+
+      // Validate model compatibility
+      const modelResult = validateModelCompatibility('codex', config);
+      if (!modelResult.valid) {
+        displayCompatibilityError(modelResult, logger);
+        process.exit(1);
+      }
+
+      // Export provider-specific environment variables
+      const providerEnv = ConfigLoader.exportProviderEnvVars(config);
+
+      // Collect all arguments to pass to Codex
+      const codexArgs = [...args];
+
+      // Add back unknown options that were parsed
+      const knownOptions = ['model', 'provider', 'apiKey', 'baseUrl', 'timeout'];
+      for (const [key, value] of Object.entries(options)) {
+        if (knownOptions.includes(key)) continue;
+
+        if (key.length === 1) {
+          codexArgs.push(`-${key}`);
+        } else {
+          codexArgs.push(`--${key}`);
+        }
+
+        if (value !== true && value !== undefined) {
+          codexArgs.push(String(value));
+        }
+      }
+
+      // Run Codex directly
+      logger.info(`Starting Codex with model ${config.model}...`);
+      await adapter.run(codexArgs, providerEnv);
+    } catch (error) {
+      logger.error('Failed to run Codex:', error);
+      process.exit(1);
+    }
+  });
+
+// Add health check command
+program
+  .command('health')
+  .description('Check Codex health and installation')
+  .action(async () => {
+    try {
+      const adapter = new CodexAdapter();
+
+      if (await adapter.isInstalled()) {
+        const version = await adapter.getVersion();
+        logger.success('Codex is installed and ready');
+        if (version) {
+          console.log(`Version: ${version}`);
+        }
+      } else {
+        logger.error('Codex is not installed');
+        console.log('Install with: codemie install codex');
+        process.exit(1);
+      }
+    } catch (error) {
+      logger.error('Health check failed:', error);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/bin/codemie.js

@@ -5,4 +5,4 @@
  * Entry point for the codemie executable
  */
 
-require('../dist/cli/index.js');
+import '../dist/cli/index.js';

package/dist/agents/adapters/claude-code.d.ts

@@ -1,12 +1,17 @@
-import { AgentAdapter } from '../registry';
+import { AgentAdapter } from '../registry.js';
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     name: string;
     displayName: string;
     description: string;
+    private ssoGateway;
     install(): Promise<void>;
     uninstall(): Promise<void>;
     isInstalled(): Promise<boolean>;
-    run(args: string[]): Promise<void>;
+    run(args: string[], envOverrides?: Record<string, string>): Promise<void>;
     getVersion(): Promise<string | null>;
+    /**
+     * Setup SSO authentication via local gateway if required
+     */
+    private setupSSOGateway;
 }
 //# sourceMappingURL=claude-code.d.ts.map

package/dist/agents/adapters/claude-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/claude-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,qBAAa,iBAAkB,YAAW,YAAY;IACpD,IAAI,SAAY;IAChB,WAAW,SAAiB;IAC5B,WAAW,SAA+C;IAEpD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAYxB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAW1B,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAS/B,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgDlC,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAQ3C"}
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/claude-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAM9C,qBAAa,iBAAkB,YAAW,YAAY;IACpD,IAAI,SAAY;IAChB,WAAW,SAAiB;IAC5B,WAAW,SAA+C;IAC1D,OAAO,CAAC,UAAU,CAA2B;IAEvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAYxB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAW1B,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAS/B,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgDzE,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAS1C;;OAEG;YACW,eAAe;CA4C9B"}

package/dist/agents/adapters/claude-code.js

@@ -1,19 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeCodeAdapter = void 0;
-const exec_1 = require("../../utils/exec");
-const logger_1 = require("../../utils/logger");
-const child_process_1 = require("child_process");
-class ClaudeCodeAdapter {
+import { exec } from '../../utils/exec.js';
+import { logger } from '../../utils/logger.js';
+import { spawn } from 'child_process';
+import { SSOGateway } from '../../utils/sso-gateway.js';
+export class ClaudeCodeAdapter {
     name = 'claude';
     displayName = 'Claude Code';
-    description = 'Anthropic Claude Code - official CLI tool';
+    description = 'Claude Code - official Anthropic CLI tool';
+    ssoGateway = null;
     async install() {
-        logger_1.logger.info('Installing Claude Code...');
+        logger.info('Installing Claude Code...');
         try {
             // Install via npm
-            await (0, exec_1.exec)('npm', ['install', '-g', '@anthropic-ai/claude-code'], { timeout: 120000 });
-            logger_1.logger.success('Claude Code installed successfully');
+            await exec('npm', ['install', '-g', '@anthropic-ai/claude-code'], { timeout: 120000 });
+            logger.success('Claude Code installed successfully');
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -21,10 +20,10 @@ class ClaudeCodeAdapter {
         }
     }
     async uninstall() {
-        logger_1.logger.info('Uninstalling Claude Code...');
+        logger.info('Uninstalling Claude Code...');
         try {
-            await (0, exec_1.exec)('npm', ['uninstall', '-g', '@anthropic-ai/claude-code']);
-            logger_1.logger.success('Claude Code uninstalled successfully');
+            await exec('npm', ['uninstall', '-g', '@anthropic-ai/claude-code']);
+            logger.success('Claude Code uninstalled successfully');
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -33,66 +32,103 @@ class ClaudeCodeAdapter {
     }
     async isInstalled() {
         try {
-            const result = await (0, exec_1.exec)('which', ['claude']);
+            const result = await exec('which', ['claude']);
             return result.code === 0;
         }
         catch {
             return false;
         }
     }
-    async run(args) {
-        logger_1.logger.info('Starting Claude Code...');
-        // Prepare environment variables
-        // Convert generic CODEMIE_* config to ANTHROPIC_* that Claude Code expects
-        const env = { ...process.env };
-        // Map our generic env vars to Anthropic-specific ones
-        if (!env.ANTHROPIC_BASE_URL && env.CODEMIE_BASE_URL) {
-            env.ANTHROPIC_BASE_URL = env.CODEMIE_BASE_URL;
-        }
-        if (!env.ANTHROPIC_AUTH_TOKEN && env.CODEMIE_AUTH_TOKEN) {
-            env.ANTHROPIC_AUTH_TOKEN = env.CODEMIE_AUTH_TOKEN;
-        }
-        if (!env.ANTHROPIC_API_KEY && env.CODEMIE_AUTH_TOKEN) {
-            env.ANTHROPIC_API_KEY = env.CODEMIE_AUTH_TOKEN;
-        }
-        if (!env.ANTHROPIC_MODEL && env.CODEMIE_MODEL) {
-            env.ANTHROPIC_MODEL = env.CODEMIE_MODEL;
-        }
-        // Set subagent model to match the main model
-        if (!env.CLAUDE_CODE_SUBAGENT_MODEL && env.CODEMIE_MODEL) {
-            env.CLAUDE_CODE_SUBAGENT_MODEL = env.CODEMIE_MODEL;
-        }
-        else if (!env.CLAUDE_CODE_SUBAGENT_MODEL && env.ANTHROPIC_MODEL) {
-            env.CLAUDE_CODE_SUBAGENT_MODEL = env.ANTHROPIC_MODEL;
-        }
-        // Spawn Claude Code
-        const child = (0, child_process_1.spawn)('claude', args, {
-            stdio: 'inherit',
-            env
-        });
-        return new Promise((resolve, reject) => {
-            child.on('error', (error) => {
-                reject(new Error(`Failed to start Claude Code: ${error.message}`));
+    async run(args, envOverrides) {
+        logger.info('Starting Claude Code...');
+        // Merge environment variables: process.env < envOverrides
+        let env = {
+            ...process.env,
+            ...envOverrides
+        };
+        // Handle SSO authentication via local gateway if configured
+        await this.setupSSOGateway(env);
+        try {
+            // Spawn Claude Code
+            const child = spawn('claude', args, {
+                stdio: 'inherit',
+                env
             });
-            child.on('exit', (code) => {
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Claude Code exited with code ${code}`));
-                }
+            return new Promise((resolve, reject) => {
+                child.on('error', (error) => {
+                    reject(new Error(`Failed to start Claude Code: ${error.message}`));
+                });
+                child.on('exit', async (code) => {
+                    // Clean up gateway when claude exits
+                    if (this.ssoGateway) {
+                        await this.ssoGateway.stop();
+                        this.ssoGateway = null;
+                    }
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Claude Code exited with code ${code}`));
+                    }
+                });
             });
-        });
+        }
+        catch (error) {
+            // Clean up gateway on error
+            if (this.ssoGateway) {
+                await this.ssoGateway.stop();
+                this.ssoGateway = null;
+            }
+            throw error;
+        }
     }
     async getVersion() {
         try {
-            const result = await (0, exec_1.exec)('claude', ['--version']);
+            const result = await exec('claude', ['--version']);
             return result.stdout.trim();
         }
         catch {
             return null;
         }
     }
+    /**
+     * Setup SSO authentication via local gateway if required
+     */
+    async setupSSOGateway(env) {
+        // Check if we're using SSO provider
+        const isSSOProvider = env.CODEMIE_PROVIDER === 'ai-run-sso' ||
+            (env.CODEMIE_BASE_URL?.includes('codemie')) ||
+            (env.OPENAI_BASE_URL?.includes('codemie'));
+        if (!isSSOProvider) {
+            return null; // No SSO, use regular authentication
+        }
+        try {
+            // Get the target API URL from environment
+            const targetApiUrl = env.CODEMIE_BASE_URL || env.OPENAI_BASE_URL;
+            if (!targetApiUrl) {
+                throw new Error('No API URL found for SSO authentication');
+            }
+            // Create and start the SSO gateway
+            this.ssoGateway = new SSOGateway({
+                targetApiUrl,
+                debug: !!(env.DEBUG || env.CODEMIE_DEBUG),
+                clientType: 'codemie-claude'
+            });
+            const { port, url } = await this.ssoGateway.start();
+            // Point claude to use our local gateway
+            env.ANTHROPIC_BASE_URL = url;
+            env.ANTHROPIC_AUTH_TOKEN = 'gateway-handled'; // Placeholder since gateway handles auth
+            if (env.DEBUG || env.CODEMIE_DEBUG) {
+                logger.info('[DEBUG] SSO Gateway started for Claude Code');
+                logger.info(`[DEBUG] Gateway URL: ${url}`);
+                logger.info(`[DEBUG] Target API: ${targetApiUrl}`);
+            }
+            return { gatewayUrl: url, port };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`SSO gateway setup failed: ${errorMessage}`);
+        }
+    }
 }
-exports.ClaudeCodeAdapter = ClaudeCodeAdapter;
 //# sourceMappingURL=claude-code.js.map