@cyanautomation/kaseki-agent 1.4.1

package/src/cli/commands/RunCommand.ts

@@ -0,0 +1,218 @@
+/**
+ * Run Command
+ * Execute kaseki agent on target repository
+ */
+
+import { BaseCommand } from '../BaseCommand';
+import { DockerManager } from '../../docker/DockerManager';
+import { InstanceManager } from '../../instance/InstanceManager';
+import { DoctorCommand } from './DoctorCommand';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('run-cmd');
+
+export class RunCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { positional } = this.parseArgs(args);
+
+      // Parse arguments
+      const repoUrl = positional[0] || this.configManager.get('repo.url');
+      const gitRef = positional[1] || this.configManager.get('repo.ref');
+      const taskPrompt = positional[2] || this.configManager.get('repo.task_prompt', '');
+
+      if (!repoUrl || !gitRef) {
+        console.error('Usage: kaseki-agent run <REPO_URL> [GIT_REF] [TASK_PROMPT]');
+        console.error('Example: kaseki-agent run https://github.com/org/repo main');
+        return 1;
+      }
+
+      console.log('🚀 Kaseki Agent Runner\n');
+      console.log(`Repository: ${repoUrl}`);
+      console.log(`Branch: ${gitRef}\n`);
+
+      // Load configuration
+      await this.configManager.load();
+
+      // Step 1: Pre-flight checks
+      console.log('Step 1/6: Running pre-flight checks...');
+      const doctorCmd = new DoctorCommand(this.configManager);
+      const doctorResult = await doctorCmd.execute(['--json']);
+      if (doctorResult !== 0) {
+        console.error('❌ Pre-flight checks failed');
+        return 1;
+      }
+      console.log('✓ Pre-flight checks passed\n');
+
+      // Step 2: Pull Docker image
+      console.log('Step 2/6: Preparing Docker image...');
+      const image = this.configManager.get('docker.image');
+      const autoPull = this.configManager.get('docker.auto_pull', true);
+
+      if (!DockerManager.imageExists(image)) {
+        if (!autoPull) {
+          console.error(`❌ Docker image not found: ${image}`);
+          console.error('Enable auto-pull or pull manually: docker pull ' + image);
+          return 1;
+        }
+
+        console.log('Image not found locally, pulling from registry...');
+        if (!DockerManager.pullImage(image)) {
+          console.error(`❌ Failed to pull Docker image: ${image}`);
+          return 1;
+        }
+      }
+      console.log(`✓ Docker image ready: ${image}\n`);
+
+      // Step 3: Create instance
+      console.log('Step 3/6: Creating instance...');
+      const kasekiRoot = this.configManager.get('directories.root');
+      const instanceManager = new InstanceManager(kasekiRoot);
+      const instanceId = await instanceManager.getOrCreateInstanceId();
+
+      const { workspace, results } = await instanceManager.createDirectories();
+      console.log(`✓ Instance created: ${instanceId}`);
+      console.log(`  Workspace: ${workspace}`);
+      console.log(`  Results: ${results}\n`);
+
+      // Initialize metadata
+      await instanceManager.initializeMetadata({
+        repoUrl,
+        gitRef,
+        model: this.configManager.get('agent.model'),
+        provider: this.configManager.get('agent.provider'),
+      });
+
+      // Step 4: Prepare environment
+      console.log('Step 4/6: Preparing environment...');
+      const environment = this.buildEnvironment(repoUrl, gitRef, taskPrompt);
+      const apiKeyFile = this.configManager.get('auth.openrouter_api_key_file');
+      console.log('✓ Environment prepared\n');
+
+      // Step 5: Run agent in Docker
+      console.log('Step 5/6: Running kaseki agent in Docker...\n');
+      const timeout = this.configManager.get('agent.timeout_seconds', 1200);
+
+      const stageStart = new Date();
+      const containerResult = await DockerManager.runContainer({
+        image,
+        name: instanceId,
+        workspaceDir: workspace,
+        resultsDir: results,
+        cacheDir: this.configManager.get('directories.cache_dir'),
+        apiKeyFile,
+        environment,
+        timeout,
+        entrypoint: '/agents/kaseki-agent.sh',
+        command: [],
+      });
+
+      const stageEnd = new Date();
+      await instanceManager.recordStage('agent-run', containerResult.exitCode, stageStart, stageEnd);
+
+      console.log('\n✓ Agent execution completed\n');
+
+      // Step 6: Finalize
+      console.log('Step 6/6: Finalizing...');
+      await instanceManager.finalize(containerResult.exitCode);
+
+      // Report summary
+      const metadata = await instanceManager.getMetadata();
+      if (metadata) {
+        console.log('\n📊 Run Summary');
+        console.log(`Instance: ${instanceId}`);
+        console.log(`Status: ${metadata.status}`);
+        console.log(`Duration: ${metadata.stages?.['agent-run']?.duration?.toFixed(1)}s`);
+
+        if (containerResult.exitCode === 0) {
+          console.log('\n✅ Run completed successfully');
+          console.log(`View results: kaseki-agent report ${instanceId}`);
+        } else {
+          console.log(`\n❌ Run failed with exit code ${containerResult.exitCode}`);
+          console.log(`View logs: kaseki-agent report ${instanceId}`);
+        }
+      }
+
+      return containerResult.exitCode;
+    } catch (error) {
+      logger.error(`Run failed: ${error}`);
+      return 1;
+    }
+  }
+
+  /**
+   * Build environment variables for container
+   */
+  private buildEnvironment(repoUrl: string, gitRef: string, taskPrompt: string): Record<string, string> {
+    const env: Record<string, string> = {};
+
+    // Repo configuration
+    env.REPO_URL = repoUrl;
+    env.GIT_REF = gitRef;
+
+    // Agent configuration
+    const model = this.configManager.get('agent.model');
+    if (model) env.KASEKI_MODEL = model;
+
+    const provider = this.configManager.get('agent.provider');
+    if (provider) env.KASEKI_PROVIDER = provider;
+
+    const timeout = this.configManager.get('agent.timeout_seconds');
+    if (timeout) env.KASEKI_AGENT_TIMEOUT_SECONDS = String(timeout);
+
+    // Task prompt
+    if (taskPrompt) {
+      env.TASK_PROMPT = taskPrompt;
+    }
+
+    // Validation
+    const validationCommands = this.configManager.get('validation.commands', []);
+    if (validationCommands.length > 0) {
+      env.KASEKI_VALIDATION_COMMANDS = validationCommands.join(';');
+    }
+
+    const skipMissingScripts = this.configManager.get('validation.skip_missing_npm_scripts');
+    if (skipMissingScripts) env.KASEKI_SKIP_MISSING_NPM_SCRIPTS = '1';
+
+    const failFast = this.configManager.get('validation.fail_fast');
+    if (failFast !== undefined) env.KASEKI_VALIDATION_FAIL_FAST = failFast ? '1' : '0';
+
+    // Allowlist
+    const allowlist = this.configManager.get('validation.allowlist', []);
+    if (allowlist.length > 0) {
+      env.KASEKI_CHANGED_FILES_ALLOWLIST = allowlist.join(' ');
+    }
+
+    const maxDiffBytes = this.configManager.get('validation.max_diff_bytes');
+    if (maxDiffBytes) env.KASEKI_MAX_DIFF_BYTES = String(maxDiffBytes);
+
+    // Caching
+    const cacheMode = this.configManager.get('caching.dependency_restore_mode');
+    if (cacheMode) env.KASEKI_DEPENDENCY_RESTORE_MODE = cacheMode;
+
+    // GitHub integration
+    const ghAppId = this.configManager.get('auth.github_app_id_file');
+    if (ghAppId) env.GITHUB_APP_ID_FILE = ghAppId;
+
+    const ghClientId = this.configManager.get('auth.github_app_client_id_file');
+    if (ghClientId) env.GITHUB_APP_CLIENT_ID_FILE = ghClientId;
+
+    const ghPrivateKey = this.configManager.get('auth.github_app_private_key_file');
+    if (ghPrivateKey) env.GITHUB_APP_PRIVATE_KEY_FILE = ghPrivateKey;
+
+    // API key file (never inline)
+    const apiKeyFile = this.configManager.get('auth.openrouter_api_key_file');
+    if (apiKeyFile) {
+      env.OPENROUTER_API_KEY_FILE = '/run/secrets/openrouter_api_key';
+    }
+
+    // Debug flags
+    const streamProgress = this.configManager.get('debug.stream_progress');
+    if (streamProgress !== undefined) env.KASEKI_STREAM_PROGRESS = streamProgress ? '1' : '0';
+
+    const keepWorkspace = this.configManager.get('debug.keep_workspace');
+    if (keepWorkspace !== undefined) env.KASEKI_KEEP_WORKSPACE = keepWorkspace ? '1' : '0';
+
+    return env;
+  }
+}

package/src/cli/commands/SecretsCommand.ts

@@ -0,0 +1,120 @@
+/**
+ * Secrets Command
+ * Manage secrets (API keys, credentials)
+ */
+
+import { BaseCommand } from '../BaseCommand';
+import { SecretsManager } from '../../secrets/SecretsManager';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('secrets-cmd');
+
+export class SecretsCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { positional, flags } = this.parseArgs(args);
+      const subcommand = positional[0];
+      const secretKey = positional[1];
+      const secretValue = positional[2];
+
+      const secretsManager = new SecretsManager();
+
+      switch (subcommand) {
+      case 'init': {
+        console.log('🔐 Initializing secrets store...\n');
+        await secretsManager.initializeKeyring();
+        console.log('✓ Secrets store initialized');
+        return 0;
+      }
+
+      case 'set': {
+        if (!secretKey || !secretValue) {
+          console.error('Usage: kaseki-agent secrets set <KEY> <VALUE>');
+          console.error('Example: kaseki-agent secrets set openrouter-api-key sk-or-...');
+          return 1;
+        }
+
+        await secretsManager.store(secretKey, secretValue);
+        console.log(`✓ Stored secret: ${secretKey}`);
+        return 0;
+      }
+
+      case 'get': {
+        if (!secretKey) {
+          console.error('Usage: kaseki-agent secrets get <KEY>');
+          return 1;
+        }
+
+        const value = await secretsManager.retrieve(secretKey);
+        if (value) {
+          // Only show if explicitly requested with --show
+          if (flags.has('show')) {
+            console.log(value);
+          } else {
+            console.log(`✓ Secret exists: ${secretKey}`);
+            console.log('(Use --show to display the value)');
+          }
+        } else {
+          console.log(`Secret not found: ${secretKey}`);
+          return 1;
+        }
+        return 0;
+      }
+
+      case 'delete': {
+        if (!secretKey) {
+          console.error('Usage: kaseki-agent secrets delete <KEY>');
+          return 1;
+        }
+
+        await secretsManager.delete(secretKey);
+        console.log(`✓ Deleted secret: ${secretKey}`);
+        return 0;
+      }
+
+      case 'list': {
+        const secrets = await secretsManager.list();
+        if (secrets.size === 0) {
+          console.log('No secrets stored');
+          return 0;
+        }
+
+        console.log('📋 Stored Secrets\n');
+        for (const key of secrets.keys()) {
+          console.log(`  • ${key}`);
+        }
+        console.log(`\nTotal: ${secrets.size} secret(s)`);
+        return 0;
+      }
+
+      case 'help': {
+        console.log('🔐 Secrets Management\n');
+        console.log('Usage:');
+        console.log('  kaseki-agent secrets init                    Initialize keyring');
+        console.log('  kaseki-agent secrets set <KEY> <VALUE>       Store a secret');
+        console.log('  kaseki-agent secrets get <KEY> [--show]      Retrieve a secret');
+        console.log('  kaseki-agent secrets delete <KEY>            Delete a secret');
+        console.log('  kaseki-agent secrets list                    List all secret keys');
+        console.log('\nCommon Keys:');
+        console.log('  openrouter-api-key    OpenRouter API key');
+        console.log('  github-app-id         GitHub App ID');
+        console.log('  github-app-client-id  GitHub App Client ID');
+        console.log('  github-app-private-key GitHub App Private Key\n');
+        console.log('Storage:');
+        console.log('  - Uses Linux pass (password-store) by default');
+        console.log('  - Falls back to ~/.kaseki/secrets/ with 0600 permissions');
+        console.log('  - Keys are never exposed via environment variables');
+        return 0;
+      }
+
+      default:
+        console.error('Unknown subcommand: ' + subcommand);
+        console.error('\nRun: kaseki-agent secrets help');
+        return 1;
+      }
+    } catch (error) {
+      logger.error(`Secrets command failed: ${error}`);
+      return 1;
+    }
+  }
+}

package/src/cli/commands/ServeCommand.ts

@@ -0,0 +1,62 @@
+/**
+ * Serve Command
+ * Start kaseki API service
+ */
+
+import { BaseCommand } from '../BaseCommand';
+import { KasekiAPIService } from '../../kaseki-api-service-wrapper';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('serve-cmd');
+
+export class ServeCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { flags } = this.parseArgs(args);
+      const portValue = flags.get('port');
+      const port = parseInt(
+        (typeof portValue === 'string' ? portValue : undefined) || '8080',
+        10
+      );
+
+      console.log('🚀 Kaseki API Service\n');
+
+      await this.configManager.load();
+
+      // Get API keys from config or environment
+      const apiKeysEnv = process.env.KASEKI_API_KEYS || '';
+      const apiKeys = apiKeysEnv ? apiKeysEnv.split(',') : [];
+
+      // Create and start service
+      const apiService = new KasekiAPIService({
+        port,
+        apiKeys,
+        logLevel: this.configManager.get('debug.log_level', 'info'),
+      });
+
+      await apiService.start();
+
+      console.log('Press Ctrl+C to stop the service\n');
+
+      // Keep the process alive
+      return new Promise((resolve) => {
+        process.on('SIGINT', async () => {
+          console.log('\n\nShutting down...');
+          await apiService.stop();
+          console.log('✓ Service stopped');
+          resolve(0);
+        });
+
+        process.on('SIGTERM', async () => {
+          console.log('\n\nShutting down...');
+          await apiService.stop();
+          console.log('✓ Service stopped');
+          resolve(0);
+        });
+      });
+    } catch (error) {
+      logger.error(`Serve failed: ${error}`);
+      return 1;
+    }
+  }
+}

package/src/cli/commands/SetupCommand.ts

@@ -0,0 +1,301 @@
+/**
+ * Setup Command
+ * Interactive setup wizard for first-time configuration
+ */
+
+import readline from 'readline';
+import { execSync } from 'child_process';
+import path from 'path';
+import os from 'os';
+import { SecretsManager } from '../../secrets/SecretsManager';
+import { DoctorCommand } from './DoctorCommand';
+import { BaseCommand } from '../BaseCommand';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('setup-cmd');
+
+interface SetupAnswers {
+  apiKey: string;
+  configLocation: 'project' | 'global';
+  validationCommands: string[];
+  modelName: string;
+}
+
+export class SetupCommand extends BaseCommand {
+  private rl: readline.Interface | null = null;
+
+  async execute(_args: string[]): Promise<number> {
+    try {
+      console.log('\n🔧 Kaseki Agent Setup Wizard\n');
+      console.log('This will configure kaseki-agent for your system.\n');
+
+      // Step 1: Check Docker
+      console.log('Step 1/5: Checking Docker installation...');
+      if (!this.isDockerInstalled()) {
+        console.error(
+          '❌ Docker is not installed or not accessible.\n' +
+          'Please install Docker and ensure the daemon is running:\n' +
+          '  https://docs.docker.com/install/\n\n' +
+          'After installation, run: kaseki-agent setup\n'
+        );
+        return 1;
+      }
+      console.log('✓ Docker found and accessible\n');
+
+      // Step 2: Check Node.js
+      console.log('Step 2/5: Checking Node.js...');
+      const nodeVersion = this.getNodeVersion();
+      if (!nodeVersion || !this.isNodeVersionValid(nodeVersion)) {
+        console.error(`❌ Node.js v24+ is required. Found: ${nodeVersion || 'not installed'}`);
+        return 1;
+      }
+      console.log(`✓ Node.js ${nodeVersion} detected\n`);
+
+      // Step 3: Collect configuration
+      console.log('Step 3/5: Configuring OpenRouter API key...');
+      const answers = await this.promptForAnswers();
+      if (!answers) {
+        console.log('Setup cancelled.');
+        return 1;
+      }
+
+      // Step 4: Store configuration
+      console.log('\nStep 4/5: Saving configuration...');
+      await this.saveConfiguration(answers);
+      console.log('✓ Configuration saved\n');
+
+      // Step 5: Run health check
+      console.log('Step 5/5: Running health check...\n');
+      const doctorCmd = new DoctorCommand(this.configManager);
+      const doctorResult = await doctorCmd.execute(['--verbose']);
+      if (doctorResult !== 0) {
+        console.log(
+          '\n⚠️  Health check found issues. Review the output above.\n' +
+          'You can run "kaseki-agent doctor --fix" to auto-remediate.\n'
+        );
+        // Don't fail - configuration is still valid even if some checks failed
+      }
+
+      console.log(
+        '\n✅ Setup complete!\n\n' +
+        'You can now use kaseki-agent:\n' +
+        '  kaseki-agent run <repo-url> <git-ref>     # Run agent\n' +
+        '  kaseki-agent doctor --verbose             # Health check\n' +
+        '  kaseki-agent serve --port 8080            # Start API\n\n' +
+        'For help: kaseki-agent --help\n'
+      );
+
+      return 0;
+    } catch (error) {
+      logger.error(`Setup failed: ${error}`);
+      return 1;
+    } finally {
+      this.closeReadline();
+    }
+  }
+
+  /**
+   * Prompt user for configuration answers
+   */
+  private async promptForAnswers(): Promise<SetupAnswers | null> {
+    try {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      // Prompt for API key
+      const apiKey = await this.prompt(
+        '📌 Enter your OpenRouter API key (sk-or-...): ',
+        true
+      );
+
+      if (!apiKey) {
+        console.error('API key is required.');
+        return null;
+      }
+
+      // Verify API key format
+      if (!apiKey.startsWith('sk-or-')) {
+        console.warn('⚠️  API key should start with "sk-or-". Continuing anyway...');
+      }
+
+      // Prompt for config location
+      const configLocation = await this.promptChoice(
+        'Where should config be stored?',
+        [
+          { label: 'Project-local (./kaseki-agent.json)', value: 'project' },
+          { label: 'User home (~/.kaseki/config.json)', value: 'global' },
+        ]
+      );
+
+      if (!configLocation) {
+        return null;
+      }
+
+      // Prompt for model
+      const modelName = await this.prompt(
+        'Model identifier (default: openrouter/free): ',
+        false
+      );
+
+      return {
+        apiKey,
+        configLocation: configLocation as 'project' | 'global',
+        validationCommands: [
+          'npm run check',
+          'npm run test',
+          'npm run build',
+        ],
+        modelName: modelName || 'openrouter/free',
+      };
+    } finally {
+      this.closeReadline();
+    }
+  }
+
+  /**
+   * Prompt for single answer with optional masking
+   */
+  private prompt(question: string, mask: boolean = false): Promise<string | null> {
+    return new Promise((resolve) => {
+      if (!this.rl) {
+        resolve(null);
+        return;
+      }
+
+      if (mask) {
+        // Mask password input
+        process.stdout.write(question);
+        const stdin = process.stdin;
+        stdin.resume();
+        stdin.setRawMode(true);
+
+        let password = '';
+        stdin.on('data', (char: Buffer) => {
+          const charStr = char.toString('utf-8');
+          if (charStr === '\n' || charStr === '\r' || charStr === '\u0004') {
+            // Enter key or Ctrl-D
+            stdin.setRawMode(false);
+            stdin.pause();
+            console.log(); // Newline for cleanliness
+            resolve(password);
+          } else if (charStr === '\u0003') {
+            // Ctrl-C
+            process.exit();
+          } else {
+            password += charStr;
+            process.stdout.write('*');
+          }
+        });
+      } else {
+        this.rl!.question(question, (answer) => {
+          resolve(answer || null);
+        });
+      }
+    });
+  }
+
+  /**
+   * Prompt for choice from list
+   */
+  private async promptChoice(
+    question: string,
+    choices: Array<{ label: string; value: string }>
+  ): Promise<string | null> {
+    return new Promise((resolve) => {
+      if (!this.rl) {
+        resolve(null);
+        return;
+      }
+
+      console.log(`\n${question}`);
+      choices.forEach((choice, index) => {
+        console.log(`  ${index + 1}) ${choice.label}`);
+      });
+
+      this.rl!.question('Enter number (1-' + choices.length + '): ', (answer) => {
+        const index = parseInt(answer, 10) - 1;
+        if (index >= 0 && index < choices.length) {
+          resolve(choices[index].value);
+        } else {
+          resolve(null);
+        }
+      });
+    });
+  }
+
+  /**
+   * Save configuration to file and secrets
+   */
+  private async saveConfiguration(answers: SetupAnswers): Promise<void> {
+    // Store API key securely
+    const secretsManager = new SecretsManager();
+    await secretsManager.store('openrouter_api_key', answers.apiKey);
+
+    // Determine config file path
+    const configPath = answers.configLocation === 'project'
+      ? path.join(process.cwd(), 'kaseki-agent.json')
+      : path.join(os.homedir(), '.kaseki', 'config.json');
+
+    // Load current configuration
+    await this.configManager.load();
+
+    // Update configuration
+    this.configManager.set('agent.model', answers.modelName);
+    this.configManager.set('auth.openrouter_api_key_file',
+      path.join(os.homedir(), '.kaseki', 'secrets', 'openrouter_api_key')
+    );
+    this.configManager.set('validation.commands', answers.validationCommands);
+
+    // Save configuration
+    await this.configManager.save(configPath);
+
+    logger.debug(`Configuration saved to: ${configPath}`);
+    console.log(`Config saved: ${configPath}`);
+  }
+
+  /**
+   * Check if Docker is installed and running
+   */
+  private isDockerInstalled(): boolean {
+    try {
+      execSync('docker --version', { stdio: 'ignore' });
+      // Also check if daemon is accessible
+      execSync('docker ps', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get installed Node.js version
+   */
+  private getNodeVersion(): string | null {
+    try {
+      const version = execSync('node --version', { encoding: 'utf-8' }).trim();
+      return version.replace('v', '');
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check if Node.js version is v24+
+   */
+  private isNodeVersionValid(version: string): boolean {
+    const major = parseInt(version.split('.')[0], 10);
+    return major >= 24;
+  }
+
+  /**
+   * Close readline interface
+   */
+  private closeReadline(): void {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+  }
+}