@amodalai/amodal 0.1.2

package/src/commands/validate.test.ts

@@ -0,0 +1,260 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach} from 'vitest';
+
+const mockFindRepoRoot = vi.fn(() => '/test/repo');
+const mockLoadRepo = vi.fn();
+const mockReadLockFile = vi.fn();
+const mockResolveAllPackages = vi.fn();
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  loadRepo: mockLoadRepo,
+  readLockFile: mockReadLockFile,
+  resolveAllPackages: mockResolveAllPackages,
+}));
+
+describe('runValidate', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+  });
+
+  it('should return 0 when repo is valid', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {
+        surface: [{method: 'GET', path: '/test'}],
+        access: {},
+      }]]),
+      skills: [{name: 'test', body: 'content'}],
+      automations: [{name: 'daily', schedule: '0 8 * * *'}],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(0);
+  });
+
+  it('should warn when no connections exist', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(0); // warnings don't cause failure
+  });
+
+  it('should warn when connection has no surface endpoints', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {surface: [], access: {}}]]),
+      skills: [],
+      automations: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(0);
+  });
+
+  it('should error when skill has empty body', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [{name: 'empty-skill', body: ''}],
+      automations: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(1);
+  });
+
+  it('should warn when automation has no schedule', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [{name: 'webhook-only'}],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(0);
+  });
+
+  it('should return 1 when repo load fails', async () => {
+    mockLoadRepo.mockRejectedValue(new Error('Config parse failed'));
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(1);
+  });
+
+  it('should return 1 when repo root not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(1);
+  });
+
+  it('should handle multiple skill errors', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [
+        {name: 'skill-1', body: ''},
+        {name: 'skill-2', body: ''},
+      ],
+      automations: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(2);
+  });
+
+  it('should report both errors and warnings', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [{name: 'bad', body: ''}],
+      automations: [{name: 'no-schedule'}],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(1); // 1 error
+  });
+
+  // Package-aware validation tests
+  it('should run package validation when packages flag set', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {surface: [{method: 'GET', path: '/test'}], access: {}}]]),
+      skills: [{name: 'test', body: 'content'}],
+      automations: [],
+    });
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate({packages: true});
+    expect(result).toBe(0);
+    expect(mockResolveAllPackages).toHaveBeenCalled();
+  });
+
+  it('should report resolution warnings as validation warnings', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+    });
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-x'}}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+      knowledge: [],
+      warnings: ['Package connection/salesforce is in lock file but not installed (broken symlink?)'],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate({packages: true});
+    expect(result).toBe(0); // warnings only
+  });
+
+  it('should error on empty resolved skill', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+    });
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map(),
+      skills: [{name: 'bad-skill', body: '  '}],
+      automations: [],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate({packages: true});
+    expect(result).toBe(1);
+  });
+
+  it('should skip package validation when no lock file', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {surface: [{method: 'GET', path: '/test'}], access: {}}]]),
+      skills: [],
+      automations: [],
+    });
+    mockReadLockFile.mockResolvedValue(null);
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate({packages: true});
+    expect(result).toBe(0);
+    expect(mockResolveAllPackages).not.toHaveBeenCalled();
+  });
+
+  it('should not run package checks without packages flag', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {surface: [{method: 'GET', path: '/test'}], access: {}}]]),
+      skills: [],
+      automations: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate();
+    expect(result).toBe(0);
+    expect(mockReadLockFile).not.toHaveBeenCalled();
+  });
+
+  it('should handle package resolution failure', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+    });
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockRejectedValue(new Error('Disk error'));
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate({packages: true});
+    expect(result).toBe(1);
+  });
+
+  it('should warn on resolved connection with no endpoints', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+    });
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map([['empty-conn', {surface: [], spec: {auth: null}}]]),
+      skills: [],
+      automations: [],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runValidate} = await import('./validate.js');
+    const result = await runValidate({packages: true});
+    expect(result).toBe(0); // warning only
+  });
+});

package/src/commands/validate.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {loadRepo, readLockFile, resolveAllPackages} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface ValidateOptions {
+  cwd?: string;
+  packages?: boolean;
+}
+
+interface ValidationIssue {
+  level: 'error' | 'warning';
+  message: string;
+}
+
+/**
+ * Validates the amodal project configuration by loading the full repo
+ * and running cross-reference checks.
+ *
+ * Returns the number of errors found (0 = valid).
+ */
+export async function runValidate(options: ValidateOptions = {}): Promise<number> {
+  const issues: ValidationIssue[] = [];
+
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[validate] ${msg}\n`);
+    return 1;
+  }
+
+  process.stderr.write(`[validate] Loading repo from ${repoPath}\n`);
+
+  try {
+    const repo = await loadRepo({localPath: repoPath});
+
+    // Check: at least one connection
+    if (repo.connections.size === 0) {
+      issues.push({level: 'warning', message: 'No connections defined. The agent cannot access external systems.'});
+    }
+
+    // Check: surface endpoints reference valid access config
+    for (const [name, conn] of repo.connections) {
+      if (conn.surface.length === 0) {
+        issues.push({level: 'warning', message: `Connection "${name}" has no surface endpoints.`});
+      }
+    }
+
+    // Check: skills have non-empty bodies
+    for (const skill of repo.skills) {
+      if (!skill.body.trim()) {
+        issues.push({level: 'error', message: `Skill "${skill.name}" has an empty body.`});
+      }
+    }
+
+    // Check: automations have schedules
+    for (const auto of repo.automations) {
+      if (!auto.schedule) {
+        issues.push({level: 'warning', message: `Automation "${auto.name}" has no schedule. It will only run via webhook.`});
+      }
+    }
+
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    issues.push({level: 'error', message: `Failed to load repo: ${msg}`});
+  }
+
+  // Package-aware validation
+  if (options.packages) {
+    try {
+      const lockFile = await readLockFile(repoPath);
+      if (lockFile) {
+        const resolved = await resolveAllPackages({repoPath, lockFile});
+
+        // Report warnings from resolution (missing packages, broken symlinks)
+        for (const warning of resolved.warnings) {
+          issues.push({level: 'warning', message: warning});
+        }
+
+        // Check for empty resolved connections
+        for (const [name, conn] of resolved.connections) {
+          if (conn.surface.length === 0) {
+            issues.push({level: 'warning', message: `Resolved connection "${name}" has no surface endpoints.`});
+          }
+        }
+
+        // Check for empty resolved skills
+        for (const skill of resolved.skills) {
+          if (!skill.body.trim()) {
+            issues.push({level: 'error', message: `Resolved skill "${skill.name}" has an empty body.`});
+          }
+        }
+      } else {
+        process.stderr.write('[validate] No lock file found, skipping package validation.\n');
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      issues.push({level: 'error', message: `Package resolution failed: ${msg}`});
+    }
+  }
+
+  // Print results
+  const errors = issues.filter((i) => i.level === 'error');
+  const warnings = issues.filter((i) => i.level === 'warning');
+
+  for (const issue of errors) {
+    process.stderr.write(`  ERROR: ${issue.message}\n`);
+  }
+  for (const issue of warnings) {
+    process.stderr.write(`  WARN:  ${issue.message}\n`);
+  }
+
+  if (errors.length === 0 && warnings.length === 0) {
+    process.stderr.write('[validate] All checks passed.\n');
+  } else {
+    process.stderr.write(`[validate] ${errors.length} error(s), ${warnings.length} warning(s)\n`);
+  }
+
+  return errors.length;
+}
+
+export const validateCommand: CommandModule = {
+  command: 'validate',
+  describe: 'Validate the project configuration',
+  builder: (yargs) =>
+    yargs.option('packages', {type: 'boolean', default: false, describe: 'Include package resolution validation'}),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const code = await runValidate({packages: argv['packages'] as boolean});
+    process.exit(code);
+  },
+};

package/src/e2e-automations.test.ts

@@ -0,0 +1,305 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * End-to-end test: Automation lifecycle
+ *
+ * Tests the full automation control flow via the HTTP API:
+ *   1. Create repo with cron + webhook automations on disk
+ *   2. Boot `createLocalServer` (which integrates ProactiveRunner)
+ *   3. List automations — verify both appear, cron is stopped, webhook is running
+ *   4. Start a cron automation — verify it becomes running
+ *   5. Stop a cron automation — verify it becomes stopped
+ *   6. Reject starting a webhook automation (always active)
+ *   7. Manually trigger an automation (run)
+ *   8. Webhook endpoint accepts events
+ */
+
+import {describe, it, expect, beforeAll, afterAll} from 'vitest';
+import {mkdtempSync, mkdirSync, writeFileSync, rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import type {AddressInfo} from 'node:net';
+
+// ---------------------------------------------------------------------------
+// Fixture data
+// ---------------------------------------------------------------------------
+
+const CONFIG = {
+  name: 'automation-test-agent',
+  version: '1.0.0',
+  description: 'Agent with automations for e2e testing',
+  models: {
+    main: {provider: 'anthropic', model: 'claude-sonnet-4-20250514'},
+  },
+};
+
+const CRON_AUTOMATION = `# Automation: Daily Scan
+
+Schedule: */5 * * * *
+
+## Check
+Scan all zones for anomalies and report findings.
+
+## Output
+Summary of anomalies found.
+
+## Delivery
+stdout
+`;
+
+const WEBHOOK_AUTOMATION = `# Automation: Alert Handler
+
+## Check
+Run on webhook when an alert fires. Triage the alert and determine severity.
+
+## Output
+Triage assessment with severity level.
+
+## Delivery
+stdout
+`;
+
+// ---------------------------------------------------------------------------
+// Test suite
+// ---------------------------------------------------------------------------
+
+describe('E2E: Automation Lifecycle', () => {
+  let repoDir: string;
+  let server: {app: unknown; start: () => Promise<unknown>; stop: () => Promise<void>} | null = null;
+  let baseUrl: string;
+
+  beforeAll(async () => {
+    // 1. Create repo directory with automations
+    repoDir = mkdtempSync(join(tmpdir(), 'amodal-e2e-automations-'));
+
+    // Config
+    writeFileSync(join(repoDir, 'amodal.json'), JSON.stringify(CONFIG, null, 2));
+
+    // Automations
+    const autoDir = join(repoDir, 'automations');
+    mkdirSync(autoDir, {recursive: true});
+    writeFileSync(join(autoDir, 'daily-scan.md'), CRON_AUTOMATION);
+    writeFileSync(join(autoDir, 'alert-handler.md'), WEBHOOK_AUTOMATION);
+
+    // 2. Boot repo server
+    const {createLocalServer} = await import('@amodalai/runtime');
+    const srv = await createLocalServer({
+      repoPath: repoDir,
+      port: 0, // random port
+      host: '127.0.0.1',
+      hotReload: false,
+      corsOrigin: '*',
+    });
+
+    const httpServer = await srv.start();
+    const addr = httpServer.address() as AddressInfo;
+    baseUrl = `http://127.0.0.1:${addr.port}`;
+    server = srv;
+  }, 30000);
+
+  afterAll(async () => {
+    if (server) {
+      await server.stop();
+      server = null;
+    }
+    rmSync(repoDir, {recursive: true, force: true});
+  });
+
+  // =========================================================================
+  // Health check — server is up
+  // =========================================================================
+
+  it('should respond to health check', async () => {
+    const resp = await fetch(`${baseUrl}/health`);
+    expect(resp.status).toBe(200);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['status']).toBe('ok');
+    expect(data['mode']).toBe('repo');
+  });
+
+  // =========================================================================
+  // List — both automations appear with correct initial state
+  // =========================================================================
+
+  it('should list automations with correct types and initial state', async () => {
+    const resp = await fetch(`${baseUrl}/automations`);
+    expect(resp.status).toBe(200);
+
+     
+    const data = (await resp.json()) as {
+      automations: Array<{
+        name: string;
+        title: string;
+        schedule?: string;
+        webhookTriggered: boolean;
+        running: boolean;
+      }>;
+    };
+
+    expect(data.automations).toHaveLength(2);
+
+    const cronAuto = data.automations.find((a) => a.name === 'daily-scan');
+    expect(cronAuto).toBeDefined();
+    expect(cronAuto?.title).toBe('Daily Scan');
+    expect(cronAuto?.schedule).toBe('*/5 * * * *');
+    expect(cronAuto?.webhookTriggered).toBe(false);
+    expect(cronAuto?.running).toBe(false); // not started yet
+
+    const webhookAuto = data.automations.find((a) => a.name === 'alert-handler');
+    expect(webhookAuto).toBeDefined();
+    expect(webhookAuto?.title).toBe('Alert Handler');
+    expect(webhookAuto?.webhookTriggered).toBe(true);
+    expect(webhookAuto?.running).toBe(true); // webhooks always active
+  });
+
+  // =========================================================================
+  // Start — cron automation becomes running
+  // =========================================================================
+
+  it('should start a cron automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/daily-scan/start`, {method: 'POST'});
+    expect(resp.status).toBe(200);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['status']).toBe('started');
+
+    // Verify it's now running
+    const listResp = await fetch(`${baseUrl}/automations`);
+     
+    const listData = (await listResp.json()) as {
+      automations: Array<{name: string; running: boolean}>;
+    };
+    const cronAuto = listData.automations.find((a) => a.name === 'daily-scan');
+    expect(cronAuto?.running).toBe(true);
+  });
+
+  // =========================================================================
+  // Start again — should fail (already running)
+  // =========================================================================
+
+  it('should reject starting an already running automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/daily-scan/start`, {method: 'POST'});
+    expect(resp.status).toBe(400);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['error']).toContain('already running');
+  });
+
+  // =========================================================================
+  // Stop — cron automation becomes stopped
+  // =========================================================================
+
+  it('should stop a running cron automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/daily-scan/stop`, {method: 'POST'});
+    expect(resp.status).toBe(200);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['status']).toBe('stopped');
+
+    // Verify it's now stopped
+    const listResp = await fetch(`${baseUrl}/automations`);
+     
+    const listData = (await listResp.json()) as {
+      automations: Array<{name: string; running: boolean}>;
+    };
+    const cronAuto = listData.automations.find((a) => a.name === 'daily-scan');
+    expect(cronAuto?.running).toBe(false);
+  });
+
+  // =========================================================================
+  // Stop again — should fail (not running)
+  // =========================================================================
+
+  it('should reject stopping a non-running automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/daily-scan/stop`, {method: 'POST'});
+    expect(resp.status).toBe(400);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['error']).toContain('not running');
+  });
+
+  // =========================================================================
+  // Start webhook automation — should fail (always active)
+  // =========================================================================
+
+  it('should reject starting a webhook-triggered automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/alert-handler/start`, {method: 'POST'});
+    expect(resp.status).toBe(400);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['error']).toContain('webhook-triggered');
+  });
+
+  // =========================================================================
+  // Start unknown — should fail
+  // =========================================================================
+
+  it('should reject starting unknown automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/nonexistent/start`, {method: 'POST'});
+    expect(resp.status).toBe(400);
+    const data = (await resp.json()) as Record<string, unknown>;
+    expect(data['error']).toContain('not found');
+  });
+
+  // =========================================================================
+  // Run — manually trigger an automation (fire and forget)
+  // =========================================================================
+
+  it('should reject triggering unknown automation', async () => {
+    const resp = await fetch(`${baseUrl}/automations/nonexistent/run`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(resp.status).toBe(404);
+  });
+
+  // =========================================================================
+  // Webhook endpoint — accepts events
+  // =========================================================================
+
+  it('should accept webhook events for webhook-triggered automations', async () => {
+    const resp = await fetch(`${baseUrl}/webhooks/alert-handler`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({alert: 'high-cpu', host: 'web-01'}),
+    });
+
+    // May succeed or fail (depends on LLM availability), but route exists
+    expect([200, 500]).toContain(resp.status);
+    const data = (await resp.json()) as Record<string, unknown>;
+    // If 200, it matched and ran
+    if (resp.status === 200) {
+      expect(data['status']).toBe('accepted');
+    }
+    // If 500, it matched but execution failed (no LLM configured) — still validates routing
+    if (resp.status === 500) {
+      expect(data['matched']).toBe(true);
+    }
+  });
+
+  // =========================================================================
+  // Webhook for non-webhook automation — should 404
+  // =========================================================================
+
+  it('should reject webhook for cron-only automation', async () => {
+    const resp = await fetch(`${baseUrl}/webhooks/daily-scan`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(resp.status).toBe(404);
+  });
+
+  // =========================================================================
+  // Webhook for unknown automation — should 404
+  // =========================================================================
+
+  it('should reject webhook for unknown automation', async () => {
+    const resp = await fetch(`${baseUrl}/webhooks/nonexistent`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(resp.status).toBe(404);
+  });
+});