@cyanautomation/kaseki-agent 1.4.1

package/scripts/test-github-app.sh

@@ -0,0 +1,248 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+HELPER="$ROOT_DIR/dist/github-app-token.js"
+RUNNER="$ROOT_DIR/run-kaseki.sh"
+
+if [ ! -x "$HELPER" ]; then
+  if command -v npx >/dev/null 2>&1; then
+    npx --yes tsc "$ROOT_DIR/src/github-app-token.ts" --outDir "$ROOT_DIR/dist" --target es2020 --module commonjs --esModuleInterop >/dev/null 2>&1 || true
+    chmod +x "$HELPER" 2>/dev/null || true
+  fi
+fi
+
+if [ ! -x "$HELPER" ]; then
+  echo "Expected executable helper at $HELPER" >&2
+  exit 1
+fi
+
+TMP_DIR="$(mktemp -d)"
+trap 'rm -rf "$TMP_DIR"' EXIT
+
+assert_token_error_contract() {
+  local expected_exit="$1"
+  local expected_substring="$2"
+  shift 2
+
+  local stdout_file="$TMP_DIR/token.stdout"
+  local stderr_file="$TMP_DIR/token.stderr"
+
+  set +e
+  node "$HELPER" "$@" >"$stdout_file" 2>"$stderr_file"
+  local status=$?
+  set -e
+
+  if [ "$status" -ne "$expected_exit" ]; then
+    echo "Unexpected helper exit code. expected=$expected_exit got=$status args=[$*]" >&2
+    exit 1
+  fi
+
+  if [ "$expected_substring" = "Usage:" ]; then
+    if ! grep -q "Usage:" "$stderr_file"; then
+      echo "Expected usage message in stderr for args=[$*]" >&2
+      exit 1
+    fi
+    if [ -s "$stdout_file" ]; then
+      echo "Expected empty stdout for usage errors" >&2
+      exit 1
+    fi
+    return
+  fi
+
+  node --input-type=commonjs - "$stdout_file" "$expected_substring" <<'NODEEOF'
+const fs = require('node:fs');
+const stdoutPath = process.argv[2];
+const expected = process.argv[3];
+const raw = fs.readFileSync(stdoutPath, 'utf8').trim();
+if (!raw) throw new Error('expected JSON output on stdout');
+let parsed;
+try { parsed = JSON.parse(raw); } catch (err) { throw new Error('invalid JSON output: ' + err.message); }
+if (!parsed.error || typeof parsed.error !== 'string') throw new Error('missing string error field');
+if (!parsed.error.includes(expected)) throw new Error('error field missing expected substring: ' + expected);
+NODEEOF
+}
+
+echo "Test 1: helper arg validation + structured failures"
+assert_token_error_contract 1 "Usage:"
+assert_token_error_contract 1 "Usage:" "123" "missing.pem" "owner"
+assert_token_error_contract 1 "ENOENT" "123" "$TMP_DIR/does-not-exist.pem" "owner" "repo"
+
+MOCK_KEY="$TMP_DIR/mock-key.pem"
+openssl genrsa -out "$MOCK_KEY" 2048 >/dev/null 2>&1
+
+run_helper_with_https_mock() {
+  local fixture="$1"
+  local stdout_file="$TMP_DIR/mock-${fixture}.stdout"
+  local stderr_file="$TMP_DIR/mock-${fixture}.stderr"
+
+  set +e
+  NODE_OPTIONS="--require $TMP_DIR/mock-https.js" MOCK_GITHUB_FIXTURE="$fixture" \
+    node "$HELPER" "123" "$MOCK_KEY" "octo" "hello" >"$stdout_file" 2>"$stderr_file"
+  local status=$?
+  set -e
+
+  echo "$status" > "$TMP_DIR/mock-${fixture}.status"
+}
+
+cat > "$TMP_DIR/mock-https.js" <<'EOF_JS'
+const https = require('node:https');
+const { EventEmitter } = require('node:events');
+
+const fixture = process.env.MOCK_GITHUB_FIXTURE;
+const original = https.request;
+
+https.request = (options, cb) => {
+  const req = new EventEmitter();
+  req.end = () => {
+    const res = new EventEmitter();
+    res.statusCode = 500;
+    let body = '{"error":"unconfigured fixture"}';
+
+    if (fixture === 'success-installation') {
+      if (options.path.endsWith('/installation')) {
+        res.statusCode = 200;
+        body = JSON.stringify({ id: 777 });
+      } else if (options.path.includes('/access_tokens')) {
+        res.statusCode = 201;
+        body = JSON.stringify({ token: 'ghu_fixture_token', expires_at: '2026-06-01T00:00:00Z' });
+      }
+    } else if (fixture === 'installation-failure' && options.path.endsWith('/installation')) {
+      res.statusCode = 404;
+      body = JSON.stringify({ message: 'Not Found' });
+    } else if (fixture === 'token-failure') {
+      if (options.path.endsWith('/installation')) {
+        res.statusCode = 200;
+        body = JSON.stringify({ id: 777 });
+      } else if (options.path.includes('/access_tokens')) {
+        res.statusCode = 403;
+        body = JSON.stringify({ message: 'Forbidden' });
+      }
+    }
+
+    process.nextTick(() => {
+      cb(res);
+      res.emit('data', Buffer.from(body));
+      res.emit('end');
+    });
+  };
+  req.on = (...args) => EventEmitter.prototype.on.apply(req, args);
+  req.write = () => {};
+  return req;
+};
+
+process.on('exit', () => { https.request = original; });
+EOF_JS
+
+echo "Test 2: helper token-generation flow with stubbed GitHub API"
+run_helper_with_https_mock success-installation
+[ "$(cat "$TMP_DIR/mock-success-installation.status")" -eq 0 ] || { echo "Expected success fixture to exit 0" >&2; exit 1; }
+node --input-type=commonjs -e '
+const fs = require("node:fs");
+const out = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+if (out.token !== "ghu_fixture_token") throw new Error("token mismatch");
+if (out.expires_at !== "2026-06-01T00:00:00Z") throw new Error("expires_at mismatch");
+' "$TMP_DIR/mock-success-installation.stdout"
+
+run_helper_with_https_mock installation-failure
+[ "$(cat "$TMP_DIR/mock-installation-failure.status")" -eq 1 ] || { echo "Expected installation failure exit 1" >&2; exit 1; }
+node --input-type=commonjs -e 'const f=require("node:fs"); const out=JSON.parse(f.readFileSync(process.argv[1],"utf8")); if (!out.error.includes("Failed to get installation ID")) throw new Error("missing installation error");' "$TMP_DIR/mock-installation-failure.stdout"
+
+run_helper_with_https_mock token-failure
+[ "$(cat "$TMP_DIR/mock-token-failure.status")" -eq 1 ] || { echo "Expected token failure exit 1" >&2; exit 1; }
+node --input-type=commonjs -e 'const f=require("node:fs"); const out=JSON.parse(f.readFileSync(process.argv[1],"utf8")); if (!out.error.includes("Failed to get access token")) throw new Error("missing token error");' "$TMP_DIR/mock-token-failure.stdout"
+
+echo "Test 3/4: run-kaseki metadata + credential artifact handling"
+DOCKER_BIN="$TMP_DIR/docker"
+cat > "$DOCKER_BIN" <<'EOF_DOCKER'
+#!/usr/bin/env bash
+set -euo pipefail
+if [ "$1" = "run" ]; then
+  result_dir=""
+  while [ "$#" -gt 0 ]; do
+    if [ "$1" = "-v" ]; then
+      shift
+      case "$1" in
+        *:/results) result_dir="${1%%:/results}" ;;
+        *:/results:*) result_dir="${1%%:/results:*}" ;;
+      esac
+    fi
+    shift || true
+  done
+  [ -n "$result_dir" ] || { echo "missing results mount" >&2; exit 1; }
+  mkdir -p "$result_dir"
+  cat > "$result_dir/metadata.json" <<'META'
+{
+  "github_pr_url": "https://github.com/octo/hello/pull/42",
+  "github_push_exit_code": 0,
+  "github_pr_exit_code": 1
+}
+META
+  touch "$result_dir/stdout.log" "$result_dir/stderr.log" "$result_dir/progress.log" "$result_dir/progress.jsonl" "$result_dir/quality.log" "$result_dir/secret-scan.log" "$result_dir/git-push.log"
+  exit 0
+fi
+exit 0
+EOF_DOCKER
+chmod +x "$DOCKER_BIN"
+
+KASEKI_ROOT="$TMP_DIR/kaseki-root"
+mkdir -p "$KASEKI_ROOT"
+HOST_KEY_FILE="$TMP_DIR/github-app.pem"
+printf '%s\n' 'PRIVATEKEY' > "$HOST_KEY_FILE"
+HOST_APP_ID_FILE="$TMP_DIR/github-app-id"
+HOST_CLIENT_ID_FILE="$TMP_DIR/github-app-client-id"
+printf '%s\n' '1' > "$HOST_APP_ID_FILE"
+printf '%s\n' 'abc' > "$HOST_CLIENT_ID_FILE"
+
+mkdir -p "$TMP_DIR/scripts"
+cat > "$TMP_DIR/scripts/kaseki-preflight.sh" <<'EOF_PREFLIGHT'
+#!/usr/bin/env bash
+exit 0
+EOF_PREFLIGHT
+chmod +x "$TMP_DIR/scripts/kaseki-preflight.sh"
+
+set +e
+env PATH="$TMP_DIR:/usr/bin:/bin" \
+  KASEKI_ROOT="$KASEKI_ROOT" \
+  OPENROUTER_API_KEY="dummy" \
+  GITHUB_APP_ID_FILE="$HOST_APP_ID_FILE" \
+  GITHUB_APP_CLIENT_ID_FILE="$HOST_CLIENT_ID_FILE" \
+  GITHUB_APP_PRIVATE_KEY_FILE="$HOST_KEY_FILE" \
+  "$RUNNER" >"$TMP_DIR/run.stdout" 2>"$TMP_DIR/run.stderr"
+run_status=$?
+set -e
+
+if [ "$run_status" -ne 0 ]; then
+  echo "Expected run-kaseki.sh to exit 0, got $run_status" >&2
+  cat "$TMP_DIR/run.stderr" >&2 || true
+  exit 1
+fi
+
+result_dir="$KASEKI_ROOT/kaseki-results/kaseki-1"
+[ -d "$result_dir" ] || { echo "Expected result dir" >&2; exit 1; }
+
+node --input-type=commonjs -e '
+const fs = require("node:fs");
+const path = require("node:path");
+const dir = process.argv[1];
+const jsonFiles = fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
+let found = false;
+for (const file of jsonFiles) {
+  let data;
+  try { data = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8")); } catch { continue; }
+  if (Object.prototype.hasOwnProperty.call(data, "github_pr_url") &&
+      Object.prototype.hasOwnProperty.call(data, "github_push_exit_code") &&
+      Object.prototype.hasOwnProperty.call(data, "github_pr_exit_code")) {
+    found = true;
+    break;
+  }
+}
+if (!found) throw new Error("no JSON artifact includes github_pr_url/github_push_exit_code/github_pr_exit_code");
+' "$result_dir"
+
+if ! grep -q "workspace_removed=" "$result_dir/cleanup.log"; then
+  echo "Expected cleanup.log to include workspace removal status" >&2
+  exit 1
+fi
+
+echo "All behavior-focused GitHub App tests passed"

package/src/add-js-extensions.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * add-js-extensions.ts
+ *
+ * Post-compilation script to add .js extensions to local imports in ES modules.
+ * This is required for proper ES module resolution in Node.js.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const distDir = __dirname;
+
+function addJsExtensions(filePath: string): void {
+  let content = fs.readFileSync(filePath, 'utf8');
+
+  // Match imports/exports from relative paths without extensions
+  // Pattern: from './path', from '../path', from '../../path', etc.
+  // But not: from './path.js' or from 'npm-package' or from 'npm-package/subpath'
+  content = content.replace(
+    /from\s+['"](\.[.]*[/\\][^'"]*?)['"](?!\.js\b)/g,
+    (match: string, importPath: string) => {
+      // Skip if already has .js extension
+      if (importPath.endsWith('.js')) {
+        return match;
+      }
+      // Add .js extension to relative imports
+      return `from '${importPath}.js'`;
+    },
+  );
+
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function processDirectory(dir: string): void {
+  const files = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+
+    if (stat.isDirectory()) {
+      processDirectory(filePath);
+    } else if (file.endsWith('.js')) {
+      addJsExtensions(filePath);
+    }
+  }
+}
+
+try {
+  if (fs.existsSync(distDir)) {
+    processDirectory(distDir);
+    console.log('✓ Added .js extensions to imports in dist/');
+  }
+} catch (error) {
+  const err = error as Error;
+  console.error('Error adding .js extensions:', err.message);
+  process.exit(1);
+}

package/src/ansi-colors.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from '@jest/globals';
+import { ANSI_COLORS, stripAnsi } from '../src/ansi-colors';
+
+describe('ansi-colors', () => {
+  describe('ANSI_COLORS', () => {
+    it('exports color constants', () => {
+      // Colors might be empty strings if not a TTY, but should exist
+      expect(ANSI_COLORS).toHaveProperty('RED');
+      expect(ANSI_COLORS).toHaveProperty('YELLOW');
+      expect(ANSI_COLORS).toHaveProperty('GREEN');
+      expect(ANSI_COLORS).toHaveProperty('BLUE');
+      expect(ANSI_COLORS).toHaveProperty('RESET');
+    });
+
+    it('exports formatting codes', () => {
+      expect(ANSI_COLORS).toHaveProperty('BOLD');
+      expect(ANSI_COLORS).toHaveProperty('DIM');
+    });
+
+    it('color codes are strings (possibly empty)', () => {
+      expect(typeof ANSI_COLORS.RED).toBe('string');
+      expect(typeof ANSI_COLORS.YELLOW).toBe('string');
+      expect(typeof ANSI_COLORS.RESET).toBe('string');
+    });
+  });
+
+  describe('stripAnsi', () => {
+    it('removes red color codes', () => {
+      const text = `${ANSI_COLORS.RED}error message${ANSI_COLORS.RESET}`;
+      const stripped = stripAnsi(text);
+      expect(stripped).toBe('error message');
+    });
+
+    it('removes multiple color codes', () => {
+      const text = `${ANSI_COLORS.YELLOW}warn${ANSI_COLORS.RESET} and ${ANSI_COLORS.RED}error${ANSI_COLORS.RESET}`;
+      const stripped = stripAnsi(text);
+      expect(stripped).toBe('warn and error');
+    });
+
+    it('handles text without color codes', () => {
+      const text = 'plain text';
+      expect(stripAnsi(text)).toBe('plain text');
+    });
+
+    it('removes bold and dim codes', () => {
+      const text = `${ANSI_COLORS.BOLD}bold${ANSI_COLORS.RESET} ${ANSI_COLORS.DIM}dim${ANSI_COLORS.RESET}`;
+      const stripped = stripAnsi(text);
+      expect(stripped).toBe('bold dim');
+    });
+
+    it('handles empty string', () => {
+      expect(stripAnsi('')).toBe('');
+    });
+
+    it('removes all ANSI escape sequences', () => {
+      // Test with raw ANSI codes
+      const text = '\x1b[31mred\x1b[0m \x1b[33myellow\x1b[0m';
+      const stripped = stripAnsi(text);
+      expect(stripped).toBe('red yellow');
+    });
+  });
+});

package/src/ansi-colors.ts

@@ -0,0 +1,67 @@
+/**
+ * ANSI Color codes for terminal output
+ * Only applied when outputting to a TTY
+ */
+
+export interface AnsiColorSet {
+  RED: string;
+  YELLOW: string;
+  GREEN: string;
+  BLUE: string;
+  CYAN: string;
+  MAGENTA: string;
+  WHITE: string;
+  RESET: string;
+  BOLD: string;
+  DIM: string;
+}
+
+/**
+ * Check if output should be colored (not piped, is TTY)
+ */
+function shouldUseColor(): boolean {
+  // Check if stdout is a TTY and TERM is not 'dumb'
+  const isTTY = process.stdout?.isTTY ?? false;
+  const notDumb = process.env.TERM !== 'dumb';
+  const noColorEnv = process.env.NO_COLOR;
+
+  return isTTY && notDumb && !noColorEnv;
+}
+
+/**
+ * ANSI color codes
+ * Only include actual colors if output is to a TTY
+ */
+export const ANSI_COLORS: AnsiColorSet = shouldUseColor()
+  ? {
+    RED: '\x1b[31m',
+    YELLOW: '\x1b[33m',
+    GREEN: '\x1b[32m',
+    BLUE: '\x1b[34m',
+    CYAN: '\x1b[36m',
+    MAGENTA: '\x1b[35m',
+    WHITE: '\x1b[37m',
+    RESET: '\x1b[0m',
+    BOLD: '\x1b[1m',
+    DIM: '\x1b[2m',
+  }
+  : {
+    RED: '',
+    YELLOW: '',
+    GREEN: '',
+    BLUE: '',
+    CYAN: '',
+    MAGENTA: '',
+    WHITE: '',
+    RESET: '',
+    BOLD: '',
+    DIM: '',
+  };
+
+/**
+ * Strip ANSI codes from a string
+ */
+export function stripAnsi(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/src/cli/BaseCommand.ts

@@ -0,0 +1,40 @@
+/**
+ * Base class for all CLI commands
+ */
+
+import { ConfigManager } from '../config/ConfigManager';
+
+export abstract class BaseCommand {
+  protected configManager: ConfigManager;
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+  }
+
+  abstract execute(args: string[]): Promise<number>;
+
+  /**
+   * Parse simple arguments
+   * Handles: command arg1 arg2 --flag --key=value
+   */
+  protected parseArgs(args: string[]): {
+    positional: string[];
+    flags: Map<string, string | boolean>;
+  } {
+    const positional: string[] = [];
+    const flags = new Map<string, string | boolean>();
+
+    for (const arg of args) {
+      if (arg.startsWith('--')) {
+        const [key, value] = arg.substring(2).split('=');
+        flags.set(key, value || true);
+      } else if (arg.startsWith('-') && arg.length === 2) {
+        flags.set(arg.substring(1), true);
+      } else {
+        positional.push(arg);
+      }
+    }
+
+    return { positional, flags };
+  }
+}

package/src/cli/KasekiCLI.ts

@@ -0,0 +1,154 @@
+/**
+ * KasekiCLI - Main command router
+ *
+ * Dispatches CLI subcommands to their respective handlers
+ */
+
+import { createLogger } from '../logger';
+import { ConfigManager } from '../config/ConfigManager';
+
+const logger = createLogger('kaseki-cli');
+
+export interface CLICommand {
+  name: string;
+  description: string;
+  execute(args: string[]): Promise<number>;
+}
+
+export class KasekiCLI {
+  private configManager: ConfigManager;
+  private commands: Map<string, CLICommand>;
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+    this.commands = new Map();
+    this.registerCommands();
+  }
+
+  /**
+   * Register all available commands
+   * These will be lazily loaded when needed
+   */
+  private registerCommands(): void {
+    // Commands will be loaded dynamically to avoid circular dependencies
+    // and reduce startup time
+    this.commands.set('setup', {
+      name: 'setup',
+      description: 'Interactive setup wizard (first-time configuration)',
+      execute: async (args) => {
+        const { SetupCommand } = await import('./commands/SetupCommand');
+        const cmd = new SetupCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('run', {
+      name: 'run',
+      description: 'Run kaseki agent on target repository',
+      execute: async (args) => {
+        const { RunCommand } = await import('./commands/RunCommand');
+        const cmd = new RunCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('doctor', {
+      name: 'doctor',
+      description: 'Health checks and dependency validation',
+      execute: async (args) => {
+        const { DoctorCommand } = await import('./commands/DoctorCommand');
+        const cmd = new DoctorCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('serve', {
+      name: 'serve',
+      description: 'Start REST API service for async execution',
+      execute: async (args) => {
+        const { ServeCommand } = await import('./commands/ServeCommand');
+        const cmd = new ServeCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('config', {
+      name: 'config',
+      description: 'Manage configuration',
+      execute: async (args) => {
+        const { ConfigCommand } = await import('./commands/ConfigCommand');
+        const cmd = new ConfigCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('list', {
+      name: 'list',
+      description: 'List all kaseki instances',
+      execute: async (args) => {
+        const { ListCommand } = await import('./commands/ListCommand');
+        const cmd = new ListCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('report', {
+      name: 'report',
+      description: 'Generate report for completed instance',
+      execute: async (args) => {
+        const { ReportCommand } = await import('./commands/ReportCommand');
+        const cmd = new ReportCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+
+    this.commands.set('secrets', {
+      name: 'secrets',
+      description: 'Manage stored secrets (keyring/file)',
+      execute: async (args) => {
+        const { SecretsCommand } = await import('./commands/SecretsCommand');
+        const cmd = new SecretsCommand(this.configManager);
+        return cmd.execute(args);
+      },
+    });
+  }
+
+  /**
+   * Dispatch to appropriate subcommand
+   */
+  async dispatch(subcommand: string | undefined, args: string[]): Promise<number> {
+    if (!subcommand) {
+      console.error('No command specified');
+      return 1;
+    }
+
+    const command = this.commands.get(subcommand);
+    if (!command) {
+      console.error(`Unknown command: ${subcommand}`);
+      console.error('\nRun \'kaseki-agent --help\' for available commands');
+      return 1;
+    }
+
+    try {
+      logger.debug(`Executing command: ${subcommand}`);
+      return await command.execute(args);
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(`Command failed: ${error.message}`);
+        if (process.env.DEBUG === '1') {
+          console.error(error.stack);
+        }
+      } else {
+        logger.error('Unknown error in command execution');
+      }
+      return 1;
+    }
+  }
+
+  /**
+   * Get list of available commands
+   */
+  getCommands(): CLICommand[] {
+    return Array.from(this.commands.values());
+  }
+}