cli4ai 0.9.2 → 1.0.0

package/src/core/routine-engine.test.ts

@@ -1,139 +0,0 @@
-/**
- * Tests for routine-engine.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  dryRunRoutine,
-  loadRoutineDefinition,
-  runRoutine,
-  RoutineParseError,
-  RoutineTemplateError,
-  RoutineValidationError,
-  type RoutineDefinition
-} from './routine-engine.js';
-
-describe('routine-engine', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-routine-engine-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  test('loadRoutineDefinition throws RoutineParseError on invalid JSON', () => {
-    const path = join(tempDir, 'bad.routine.json');
-    writeFileSync(path, '{not json');
-    expect(() => loadRoutineDefinition(path)).toThrow(RoutineParseError);
-  });
-
-  test('loadRoutineDefinition throws RoutineValidationError on duplicate step ids', () => {
-    const path = join(tempDir, 'dup.routine.json');
-    writeFileSync(
-      path,
-      JSON.stringify({
-        version: 1,
-        name: 'dup',
-        steps: [
-          { id: 'a', type: 'set', vars: {} },
-          { id: 'a', type: 'set', vars: {} }
-        ]
-      })
-    );
-    expect(() => loadRoutineDefinition(path)).toThrow(RoutineValidationError);
-  });
-
-  test('runRoutine executes exec+set steps and renders object result templates', async () => {
-    const def: RoutineDefinition = {
-      version: 1,
-      name: 'demo',
-      vars: {
-        lang: { default: 'rust' }
-      },
-      steps: [
-        {
-          id: 'hello',
-          type: 'exec',
-          cmd: 'bash',
-          args: ['-lc', "echo '{\"x\":1,\"lang\":\"{{vars.lang}}\"}'"],
-          capture: 'json'
-        },
-        {
-          id: 'setvars',
-          type: 'set',
-          vars: {
-            lang2: '{{steps.hello.json.lang}}',
-            x: '{{steps.hello.json.x}}'
-          }
-        },
-        {
-          id: 'echo',
-          type: 'exec',
-          cmd: 'bash',
-          args: ['-lc', "echo '{{vars.lang2}} {{vars.x}}'"],
-          capture: 'text'
-        }
-      ],
-      result: {
-        lang: '{{vars.lang2}}',
-        x: '{{vars.x}}',
-        raw: '{{steps.echo.stdout}}'
-      }
-    };
-
-    const summary = await runRoutine(def, { lang: 'typescript' }, tempDir);
-    expect(summary.status).toBe('success');
-    expect(summary.exitCode).toBe(0);
-    expect(summary.result).toEqual({
-      lang: 'typescript',
-      x: 1,
-      raw: 'typescript 1\n'
-    });
-  });
-
-  test('runRoutine fails fast on missing template path', async () => {
-    const def: RoutineDefinition = {
-      version: 1,
-      name: 'bad-template',
-      steps: [
-        {
-          id: 'set',
-          type: 'set',
-          vars: {
-            x: '{{steps.nope.json.0}}'
-          }
-        }
-      ]
-    };
-
-    await expect(runRoutine(def, {}, tempDir)).rejects.toThrow(RoutineTemplateError);
-  });
-
-  test('dryRunRoutine is lenient for missing step paths', async () => {
-    const def: RoutineDefinition = {
-      version: 1,
-      name: 'dry',
-      steps: [
-        {
-          id: 'set',
-          type: 'set',
-          vars: {
-            x: '{{steps.nope.json.0}}'
-          }
-        }
-      ],
-      result: { x: '{{vars.x}}' }
-    };
-
-    const plan = await dryRunRoutine(def, {}, tempDir);
-    expect(plan.vars.x).toBe('{{steps.nope.json.0}}');
-    expect(plan.result).toEqual({ x: '{{steps.nope.json.0}}' });
-  });
-});
-

package/src/core/scheduler.test.ts

@@ -1,291 +0,0 @@
-/**
- * Tests for scheduler core functionality.
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { rmSync, existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-import {
-  parseInterval,
-  getNextRunTime,
-  isDaemonRunning,
-  getDaemonPid,
-  writeDaemonPid,
-  removeDaemonPid,
-  loadSchedulerState,
-  saveSchedulerState,
-  saveRunRecord,
-  getRunHistory,
-  Scheduler,
-  SCHEDULER_PID_FILE,
-  SCHEDULER_STATE_FILE,
-  SCHEDULER_RUNS_DIR,
-  type SchedulerState,
-  type SchedulerRunRecord
-} from './scheduler.js';
-import { validateScheduleConfig, type RoutineSchedule } from './routine-engine.js';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// INTERVAL PARSING TESTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('parseInterval', () => {
-  test('parses seconds', () => {
-    expect(parseInterval('30s')).toBe(30 * 1000);
-    expect(parseInterval('1s')).toBe(1000);
-    expect(parseInterval('120s')).toBe(120 * 1000);
-  });
-
-  test('parses minutes', () => {
-    expect(parseInterval('5m')).toBe(5 * 60 * 1000);
-    expect(parseInterval('1m')).toBe(60 * 1000);
-    expect(parseInterval('60m')).toBe(60 * 60 * 1000);
-  });
-
-  test('parses hours', () => {
-    expect(parseInterval('1h')).toBe(60 * 60 * 1000);
-    expect(parseInterval('24h')).toBe(24 * 60 * 60 * 1000);
-  });
-
-  test('parses days', () => {
-    expect(parseInterval('1d')).toBe(24 * 60 * 60 * 1000);
-    expect(parseInterval('7d')).toBe(7 * 24 * 60 * 60 * 1000);
-  });
-
-  test('throws on invalid format', () => {
-    expect(() => parseInterval('10')).toThrow();
-    expect(() => parseInterval('10x')).toThrow();
-    expect(() => parseInterval('abc')).toThrow();
-    expect(() => parseInterval('')).toThrow();
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// NEXT RUN TIME TESTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('getNextRunTime', () => {
-  test('calculates next run from interval', () => {
-    const now = new Date('2024-01-01T10:00:00Z');
-    const schedule: RoutineSchedule = { interval: '1h' };
-
-    const nextRun = getNextRunTime(schedule, now);
-
-    expect(nextRun).not.toBeNull();
-    expect(nextRun!.getTime()).toBe(now.getTime() + (60 * 60 * 1000));
-  });
-
-  test('calculates next run from cron', () => {
-    const now = new Date('2024-01-01T10:30:00Z');
-    const schedule: RoutineSchedule = { cron: '0 * * * *' }; // Every hour at :00
-
-    const nextRun = getNextRunTime(schedule, now);
-
-    expect(nextRun).not.toBeNull();
-    expect(nextRun!.getUTCMinutes()).toBe(0);
-    expect(nextRun!.getUTCHours()).toBe(11); // Next hour in UTC
-  });
-
-  test('returns earliest when both cron and interval specified', () => {
-    const now = new Date('2024-01-01T10:55:00Z');
-    const schedule: RoutineSchedule = {
-      cron: '0 * * * *',  // 5 minutes until :00
-      interval: '30m'      // 30 minutes
-    };
-
-    const nextRun = getNextRunTime(schedule, now);
-
-    expect(nextRun).not.toBeNull();
-    // Should be the cron time (5 min) not interval (30 min)
-    expect(nextRun!.getMinutes()).toBe(0);
-  });
-
-  test('returns null for invalid schedule', () => {
-    const schedule: RoutineSchedule = {} as RoutineSchedule;
-    const nextRun = getNextRunTime(schedule);
-    expect(nextRun).toBeNull();
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULE VALIDATION TESTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('validateScheduleConfig', () => {
-  test('validates interval schedule', () => {
-    const schedule = validateScheduleConfig({ interval: '1h' });
-    expect(schedule.interval).toBe('1h');
-  });
-
-  test('validates cron schedule', () => {
-    const schedule = validateScheduleConfig({ cron: '0 9 * * *' });
-    expect(schedule.cron).toBe('0 9 * * *');
-  });
-
-  test('validates all optional fields', () => {
-    const schedule = validateScheduleConfig({
-      interval: '1h',
-      timezone: 'Pacific/Auckland',
-      enabled: true,
-      retries: 3,
-      retryDelayMs: 60000,
-      concurrency: 'skip'
-    });
-
-    expect(schedule.timezone).toBe('Pacific/Auckland');
-    expect(schedule.enabled).toBe(true);
-    expect(schedule.retries).toBe(3);
-    expect(schedule.retryDelayMs).toBe(60000);
-    expect(schedule.concurrency).toBe('skip');
-  });
-
-  test('throws when missing cron and interval', () => {
-    expect(() => validateScheduleConfig({})).toThrow('Schedule must have "cron" or "interval"');
-  });
-
-  test('throws on invalid interval format', () => {
-    expect(() => validateScheduleConfig({ interval: 'invalid' })).toThrow('must be like "30s"');
-  });
-
-  test('throws on invalid cron format', () => {
-    expect(() => validateScheduleConfig({ cron: '* *' })).toThrow('must have 5 or 6 fields');
-  });
-
-  test('throws on invalid retries', () => {
-    expect(() => validateScheduleConfig({ interval: '1h', retries: -1 })).toThrow('non-negative integer');
-    expect(() => validateScheduleConfig({ interval: '1h', retries: 'abc' })).toThrow('non-negative integer');
-  });
-
-  test('throws on invalid concurrency', () => {
-    expect(() => validateScheduleConfig({ interval: '1h', concurrency: 'invalid' })).toThrow('"skip" or "queue"');
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// STATE MANAGEMENT TESTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('state management', () => {
-  // Note: These tests use the actual ~/.cli4ai/scheduler directory
-  // because paths are resolved at module import time
-
-  test('saves and loads scheduler state', () => {
-    // Clean up first
-    if (existsSync(SCHEDULER_STATE_FILE)) {
-      rmSync(SCHEDULER_STATE_FILE);
-    }
-
-    const state: SchedulerState = {
-      version: 1,
-      startedAt: new Date().toISOString(),
-      routines: {
-        'test-routine': {
-          name: 'test-routine',
-          path: '/path/to/routine.json',
-          schedule: { interval: '1h' },
-          nextRunAt: new Date().toISOString(),
-          lastRunAt: null,
-          lastStatus: null,
-          running: false,
-          retryCount: 0
-        }
-      }
-    };
-
-    saveSchedulerState(state);
-    const loaded = loadSchedulerState();
-
-    expect(loaded).not.toBeNull();
-    expect(loaded!.version).toBe(1);
-    expect(loaded!.routines['test-routine'].name).toBe('test-routine');
-
-    // Clean up
-    rmSync(SCHEDULER_STATE_FILE);
-  });
-
-  test('returns null when no state file exists', () => {
-    // Ensure no state file exists
-    if (existsSync(SCHEDULER_STATE_FILE)) {
-      rmSync(SCHEDULER_STATE_FILE);
-    }
-
-    const state = loadSchedulerState();
-    expect(state).toBeNull();
-  });
-
-  test('saves and retrieves run records', () => {
-    // Clean up existing run files for this test
-    if (existsSync(SCHEDULER_RUNS_DIR)) {
-      const files = readdirSync(SCHEDULER_RUNS_DIR);
-      for (const f of files) {
-        if (f.startsWith('test-routine-')) {
-          rmSync(join(SCHEDULER_RUNS_DIR, f));
-        }
-      }
-    }
-
-    const record: SchedulerRunRecord = {
-      routine: 'test-routine',
-      startedAt: new Date().toISOString(),
-      finishedAt: new Date().toISOString(),
-      status: 'success',
-      exitCode: 0,
-      durationMs: 1234,
-      retryAttempt: 0
-    };
-
-    saveRunRecord(record);
-    const history = getRunHistory('test-routine');
-
-    expect(history.length).toBeGreaterThanOrEqual(1);
-    expect(history[0].routine).toBe('test-routine');
-    expect(history[0].status).toBe('success');
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// PID FILE TESTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('daemon PID management', () => {
-  // Note: These tests use the actual ~/.cli4ai/scheduler directory
-  // because paths are resolved at module import time
-
-  beforeEach(() => {
-    // Clean up any existing PID file
-    if (existsSync(SCHEDULER_PID_FILE)) {
-      rmSync(SCHEDULER_PID_FILE);
-    }
-  });
-
-  afterEach(() => {
-    // Clean up
-    if (existsSync(SCHEDULER_PID_FILE)) {
-      rmSync(SCHEDULER_PID_FILE);
-    }
-  });
-
-  test('writes and reads PID file', () => {
-    writeDaemonPid(12345);
-    const pid = getDaemonPid();
-    expect(pid).toBe(12345);
-  });
-
-  test('removes PID file', () => {
-    writeDaemonPid(12345);
-    removeDaemonPid();
-    const pid = getDaemonPid();
-    expect(pid).toBeNull();
-  });
-
-  test('returns null when no PID file', () => {
-    const pid = getDaemonPid();
-    expect(pid).toBeNull();
-  });
-
-  test('isDaemonRunning returns false for non-existent process', () => {
-    writeDaemonPid(999999); // Unlikely to be running
-    const running = isDaemonRunning();
-    expect(running).toBe(false);
-  });
-});

package/src/core/secrets.test.ts

@@ -1,79 +0,0 @@
-/**
- * Tests for secrets.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir, hostname, userInfo } from 'os';
-import { createCipheriv, createHash, randomBytes } from 'crypto';
-import { getSecret, listSecretKeys } from './secrets.js';
-
-const ALGORITHM = 'aes-256-gcm';
-
-function legacyEncrypt(value: string): string {
-  const machineId = `${hostname()}-${userInfo().username}-cli4ai-secrets`;
-  const key = createHash('sha256').update(machineId).digest();
-  const iv = randomBytes(16);
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-
-  let encrypted = cipher.update(value, 'utf8', 'hex');
-  encrypted += cipher.final('hex');
-
-  const authTag = cipher.getAuthTag();
-
-  return JSON.stringify({
-    iv: iv.toString('hex'),
-    encrypted,
-    authTag: authTag.toString('hex')
-  });
-}
-
-describe('secrets', () => {
-  let tempDir: string;
-  let secretsFile: string;
-  let saltFile: string;
-  let originalSecretsFileEnv: string | undefined;
-  let originalSaltFileEnv: string | undefined;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-secrets-test-'));
-    secretsFile = join(tempDir, 'secrets.json');
-    saltFile = join(tempDir, 'secrets.salt');
-
-    originalSecretsFileEnv = process.env.C4AI_SECRETS_FILE;
-    originalSaltFileEnv = process.env.C4AI_SECRETS_SALT_FILE;
-
-    process.env.C4AI_SECRETS_FILE = secretsFile;
-    process.env.C4AI_SECRETS_SALT_FILE = saltFile;
-  });
-
-  afterEach(() => {
-    if (originalSecretsFileEnv !== undefined) process.env.C4AI_SECRETS_FILE = originalSecretsFileEnv;
-    else delete process.env.C4AI_SECRETS_FILE;
-
-    if (originalSaltFileEnv !== undefined) process.env.C4AI_SECRETS_SALT_FILE = originalSaltFileEnv;
-    else delete process.env.C4AI_SECRETS_SALT_FILE;
-
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  test('decrypts legacy secrets and migrates to salted format', () => {
-    writeFileSync(
-      secretsFile,
-      JSON.stringify({ SLACK_BOT_TOKEN: legacyEncrypt('xoxb-test') }, null, 2),
-      { mode: 0o600 }
-    );
-
-    expect(getSecret('SLACK_BOT_TOKEN')).toBe('xoxb-test');
-    expect(listSecretKeys()).toEqual(['SLACK_BOT_TOKEN']);
-
-    // Migration should create a salt file for the new scheme.
-    expect(existsSync(saltFile)).toBe(true);
-    expect(readFileSync(saltFile).length).toBe(32);
-
-    // Subsequent reads should still work.
-    expect(getSecret('SLACK_BOT_TOKEN')).toBe('xoxb-test');
-  });
-});
-

package/src/mcp/adapter.test.ts

@@ -1,132 +0,0 @@
-/**
- * Tests for mcp/adapter.ts
- */
-
-import { describe, test, expect } from 'vitest';
-import {
-  manifestToMcpTools,
-  commandToMcpTool,
-  type McpTool
-} from './adapter.js';
-import type { Manifest, CommandDef } from '../core/manifest.js';
-
-describe('mcp/adapter', () => {
-  describe('commandToMcpTool', () => {
-    test('converts simple command', () => {
-      const manifest: Manifest = {
-        name: 'github',
-        version: '1.0.0',
-        entry: 'run.ts'
-      };
-      const cmd: CommandDef = {
-        description: 'Get notifications'
-      };
-
-      const tool = commandToMcpTool(manifest, 'notifs', cmd);
-
-      expect(tool.name).toBe('github_notifs');
-      expect(tool.description).toContain('Get notifications');
-      expect(tool.inputSchema.type).toBe('object');
-      expect(tool.inputSchema.properties).toEqual({});
-      expect(tool.inputSchema.required).toEqual([]);
-    });
-
-    test('converts command with args', () => {
-      const manifest: Manifest = {
-        name: 'search',
-        version: '1.0.0',
-        entry: 'run.ts'
-      };
-      const cmd: CommandDef = {
-        description: 'Find items',
-        args: [
-          { name: 'query', description: 'Search query', required: true },
-          { name: 'limit', description: 'Max results', required: false }
-        ]
-      };
-
-      const tool = commandToMcpTool(manifest, 'find', cmd);
-
-      expect(tool.inputSchema.properties.query).toBeDefined();
-      expect(tool.inputSchema.properties.query.description).toBe('Search query');
-      expect(tool.inputSchema.properties.limit).toBeDefined();
-      expect(tool.inputSchema.required).toEqual(['query']);
-    });
-
-    test('uses manifest name as prefix', () => {
-      const manifest: Manifest = {
-        name: 'my-tool',
-        version: '1.0.0',
-        entry: 'run.ts'
-      };
-      const cmd: CommandDef = { description: 'Do action' };
-
-      const tool = commandToMcpTool(manifest, 'action', cmd);
-
-      expect(tool.name).toBe('my-tool_action');
-    });
-  });
-
-  describe('manifestToMcpTools', () => {
-    test('returns empty array when no commands', () => {
-      const manifest: Manifest = {
-        name: 'tool',
-        version: '1.0.0',
-        entry: 'run.ts'
-      };
-
-      const tools = manifestToMcpTools(manifest);
-      expect(tools).toEqual([]);
-    });
-
-    test('returns empty array for empty commands', () => {
-      const manifest: Manifest = {
-        name: 'tool',
-        version: '1.0.0',
-        entry: 'run.ts',
-        commands: {}
-      };
-
-      const tools = manifestToMcpTools(manifest);
-      expect(tools).toEqual([]);
-    });
-
-    test('converts single command', () => {
-      const manifest: Manifest = {
-        name: 'github',
-        version: '1.0.0',
-        entry: 'run.ts',
-        commands: {
-          notifs: { description: 'Get notifications' }
-        }
-      };
-
-      const tools = manifestToMcpTools(manifest);
-
-      expect(tools).toHaveLength(1);
-      expect(tools[0].name).toBe('github_notifs');
-    });
-
-    test('converts multiple commands', () => {
-      const manifest: Manifest = {
-        name: 'api',
-        version: '1.0.0',
-        entry: 'run.ts',
-        commands: {
-          list: { description: 'List items' },
-          get: { description: 'Get item' },
-          create: { description: 'Create item' }
-        }
-      };
-
-      const tools = manifestToMcpTools(manifest);
-
-      expect(tools).toHaveLength(3);
-      expect(tools.map(t => t.name).sort()).toEqual([
-        'api_create',
-        'api_get',
-        'api_list'
-      ]);
-    });
-  });
-});