@amodalai/amodal 0.3.26 → 0.3.28

package/src/e2e-plugins.test.ts

@@ -1,491 +0,0 @@
-/**
- * @license
- * Copyright 2025 Amodal Labs, Inc.
- * SPDX-License-Identifier: MIT
- */
-
-/**
- * End-to-end plugin test: verdaccio → install → runtime → Stripe + Slack.
- *
- * Flow:
- *   1. Start a local verdaccio npm registry
- *   2. Publish @amodalai/connection-slack and @amodalai/connection-stripe to it
- *   3. Init a repo, install both plugins from verdaccio
- *   4. Verify connections load from installed packages
- *   5. Write local access.json overrides that allow writes without confirmation
- *   6. Boot a real @amodalai/runtime server with real credentials
- *   7. Send a chat asking the agent to create a Stripe customer
- *   8. Send a follow-up asking it to post to Slack about the customer
- *   9. Verify real side effects (Stripe customer exists, Slack message posted)
- *  10. Clean up
- *
- * No mocks — real LLM, real Stripe API, real Slack API, real npm registry, real runtime.
- */
-
-import {describe, it, expect, beforeAll, afterAll} from 'vitest';
-import {mkdtempSync, mkdirSync, rmSync, existsSync, readFileSync, writeFileSync} from 'node:fs';
-import {join, resolve,dirname} from 'node:path';
-import {tmpdir} from 'node:os';
-import {execSync, spawn} from 'node:child_process';
-import type {ChildProcess} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-import http from 'node:http';
-
-import {runInit} from './commands/init.js';
-import {runInstallPkg} from './commands/install-pkg.js';
-import {runValidate} from './commands/validate.js';
-import {runBuild} from './commands/build.js';
-import {runUninstall} from './commands/uninstall.js';
-import {loadRepo} from '@amodalai/core';
-
-// ---------------------------------------------------------------------------
-// Config
-// ---------------------------------------------------------------------------
-
-const SLACK_BOT_TOKEN = process.env['SLACK_BOT_TOKEN'] ?? '';
-const SLACK_CHANNEL_ID = process.env['SLACK_CHANNEL_ID'] ?? '';
-const STRIPE_SECRET_KEY = process.env['STRIPE_SECRET_KEY'] ?? '';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const PLUGINS_DIR = resolve(__dirname, '../../plugins');
-
-// ---------------------------------------------------------------------------
-// Helpers: Verdaccio
-// ---------------------------------------------------------------------------
-
-let verdaccioProc: ChildProcess | null = null;
-let verdaccioPort: number;
-
-async function startVerdaccio(): Promise<number> {
-  const port = 15000 + Math.floor(Math.random() * 1000);
-  const storageDir = mkdtempSync(join(tmpdir(), 'verdaccio-storage-'));
-
-  // Write a minimal verdaccio config
-  const configPath = join(storageDir, 'config.yml');
-  writeFileSync(configPath, [
-    `storage: ${storageDir}/storage`,
-    'auth:',
-    '  htpasswd:',
-    `    file: ${storageDir}/htpasswd`,
-    'uplinks: {}',
-    'packages:',
-    '  "@amodalai/*":',
-    '    access: $anonymous',
-    '    publish: $anonymous',
-    '  "**":',
-    '    access: $anonymous',
-    'server:',
-    '  keepAliveTimeout: 10',
-    `listen: 127.0.0.1:${port}`,
-    'log: { type: stderr, level: error }',
-  ].join('\n'));
-
-  // Find verdaccio JS entry — avoids shell shebang issues in vitest forks
-  const verdaccioJs = resolve(
-    __dirname,
-    '../../../node_modules/.pnpm/verdaccio@6.3.2_typanion@3.14.0/node_modules/verdaccio/build/lib/cli.js',
-  );
-  verdaccioProc = spawn(process.execPath, [verdaccioJs, '--config', configPath], {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: {...process.env},
-  });
-
-  // Wait for it to be ready
-  const deadline = Date.now() + 30000;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`http://127.0.0.1:${port}/-/ping`);
-      if (res.ok) return port;
-    } catch {
-      // not ready
-    }
-    await new Promise((r) => setTimeout(r, 300));
-  }
-  throw new Error('Verdaccio did not start within 30s');
-}
-
-function stopVerdaccio(): void {
-  if (verdaccioProc) {
-    verdaccioProc.kill('SIGTERM');
-    verdaccioProc = null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers: Publish plugin to verdaccio
-// ---------------------------------------------------------------------------
-
-function publishPlugin(pluginDir: string, registryUrl: string): void {
-  // Create a user on verdaccio first (htpasswd auto-creates on adduser)
-  const registryHost = registryUrl.replace(/^https?:\/\//, '');
-  const token = Buffer.from('e2e:e2e').toString('base64');
-  // npm publish needs auth — pass it inline via npmrc in the plugin dir
-  const npmrcPath = join(pluginDir, '.npmrc');
-  const npmrcExisted = existsSync(npmrcPath);
-  writeFileSync(npmrcPath, `//${registryHost}/:_auth=${token}\nregistry=${registryUrl}\n`);
-  try {
-    execSync(`npm publish --registry ${registryUrl}`, {
-      cwd: pluginDir,
-      stdio: 'pipe',
-      timeout: 30000,
-    });
-  } finally {
-    // Clean up the temporary .npmrc so we don't pollute the plugin dir
-    if (!npmrcExisted) {
-      rmSync(npmrcPath, {force: true});
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers: Slack API
-// ---------------------------------------------------------------------------
-
-async function slackHistory(channel: string, limit = 5): Promise<Array<{text: string; ts: string; bot_id?: string}>> {
-  const resp = await fetch(`https://slack.com/api/conversations.history?channel=${channel}&limit=${limit}`, {
-    headers: {'Authorization': `Bearer ${SLACK_BOT_TOKEN}`},
-  });
-   
-  const data = await resp.json() as {ok: boolean; messages: Array<{text: string; ts: string; bot_id?: string}>};
-  return data.ok ? data.messages : [];
-}
-
-// ---------------------------------------------------------------------------
-// Helpers: Stripe API
-// ---------------------------------------------------------------------------
-
-async function stripeDeleteCustomer(id: string): Promise<void> {
-  await fetch(`https://api.stripe.com/v1/customers/${id}`, {
-    method: 'DELETE',
-    headers: {'Authorization': `Bearer ${STRIPE_SECRET_KEY}`},
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Helpers: Send chat to runtime and collect SSE events
-// ---------------------------------------------------------------------------
-
-async function sendChat(
-  port: number,
-  message: string,
-  appId: string,
-  timeoutMs = 90000,
-): Promise<Array<Record<string, unknown>>> {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify({message, app_id: appId});
-    const req = http.request(
-      {
-        hostname: '127.0.0.1',
-        port,
-        path: '/chat',
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(body),
-        },
-        timeout: timeoutMs,
-      },
-      (res) => {
-        let rawBody = '';
-        res.setEncoding('utf8');
-        res.on('data', (chunk: string) => { rawBody += chunk; });
-        res.on('end', () => {
-          const events: Array<Record<string, unknown>> = [];
-          for (const line of rawBody.split('\n')) {
-            if (line.startsWith('data: ')) {
-              try { events.push(JSON.parse(line.slice(6)) as Record<string, unknown>); } catch { /* skip */ }
-            }
-          }
-          resolve(events);
-        });
-      },
-    );
-    req.on('error', reject);
-    req.on('timeout', () => req.destroy(new Error('Chat request timed out')));
-    req.write(body);
-    req.end();
-  });
-}
-
-// ===========================================================================
-// Test Suite
-// ===========================================================================
-
-describe('E2E Plugins: Verdaccio → Install → Stripe + Slack', () => {
-  let repoDir: string;
-  let registryUrl: string;
-  let stripeCustomerId: string | null = null;
-
-  // -------------------------------------------------------------------------
-  // Setup: Start verdaccio, publish plugins, init repo
-  // -------------------------------------------------------------------------
-
-  beforeAll(async () => {
-    // 1. Start verdaccio
-    verdaccioPort = await startVerdaccio();
-    registryUrl = `http://127.0.0.1:${verdaccioPort}`;
-
-    // 2. Publish the slack and stripe plugins
-    publishPlugin(join(PLUGINS_DIR, 'slack'), registryUrl);
-    publishPlugin(join(PLUGINS_DIR, 'stripe'), registryUrl);
-
-    // Verify packages are actually available on verdaccio
-    const slackCheck = await fetch(`${registryUrl}/@amodal%2fconnection-slack`);
-    if (!slackCheck.ok) throw new Error(`Slack plugin not found on verdaccio (${slackCheck.status})`);
-    const stripeCheck = await fetch(`${registryUrl}/@amodal%2fconnection-stripe`);
-    if (!stripeCheck.ok) throw new Error(`Stripe plugin not found on verdaccio (${stripeCheck.status})`);
-
-    // 3. Init a fresh repo
-    repoDir = mkdtempSync(join(tmpdir(), 'amodal-e2e-plugins-'));
-    await runInit({cwd: repoDir, name: 'plugin-e2e', provider: 'anthropic'});
-
-    // 4. Set registry env var so ensureNpmContext writes the correct .npmrc
-    process.env['AMODAL_REGISTRY'] = registryUrl;
-    // Also set npm_config_registry so npm itself uses verdaccio regardless of .npmrc resolution
-    process.env['npm_config_registry'] = registryUrl;
-  }, 60000);
-
-  afterAll(async () => {
-    // Clean up runtime if still running
-    if (runtimeServer) {
-      await runtimeServer.stop();
-    }
-
-    // Clean up Stripe customer if created
-    if (stripeCustomerId) {
-      await stripeDeleteCustomer(stripeCustomerId);
-    }
-
-    // Clean up env vars
-    delete process.env['AMODAL_REGISTRY'];
-    delete process.env['npm_config_registry'];
-    delete process.env['STRIPE_SECRET_KEY'];
-    delete process.env['SLACK_BOT_TOKEN'];
-    stopVerdaccio();
-    if (repoDir && existsSync(repoDir)) rmSync(repoDir, {recursive: true, force: true});
-  });
-
-  // -------------------------------------------------------------------------
-  // Phase 1: Install plugins from verdaccio
-  // -------------------------------------------------------------------------
-
-  it('should install @amodalai/connection-slack from verdaccio', async () => {
-    const failures = await runInstallPkg({
-      cwd: repoDir,
-      packages: [{type: 'connection', name: 'slack'}],
-    });
-    expect(failures).toBe(0);
-
-    // Verify lock file updated
-    const lockRaw = readFileSync(join(repoDir, 'amodal.lock'), 'utf-8');
-    const lock = JSON.parse(lockRaw) as {packages: Record<string, unknown>};
-    expect(lock.packages['connection/slack']).toBeDefined();
-  }, 30000);
-
-  it('should install @amodalai/connection-stripe from verdaccio', async () => {
-    const failures = await runInstallPkg({
-      cwd: repoDir,
-      packages: [{type: 'connection', name: 'stripe'}],
-    });
-    expect(failures).toBe(0);
-
-    const lockRaw = readFileSync(join(repoDir, 'amodal.lock'), 'utf-8');
-    const lock = JSON.parse(lockRaw) as {packages: Record<string, unknown>};
-    expect(lock.packages['connection/stripe']).toBeDefined();
-  }, 30000);
-
-  it('should list both installed packages', async () => {
-    const code = await runList({cwd: repoDir, json: true});
-    expect(code).toBe(0);
-  });
-
-  // -------------------------------------------------------------------------
-  // Phase 2: Verify connections load from installed packages
-  // -------------------------------------------------------------------------
-
-  it('should load both connections from installed packages', async () => {
-    const repo = await loadRepo({localPath: repoDir});
-    expect(repo.connections.size).toBeGreaterThanOrEqual(2);
-
-    const slack = repo.connections.get('slack');
-    expect(slack).toBeDefined();
-    expect(slack!.spec.auth?.type).toBe('bearer');
-
-    const stripe = repo.connections.get('stripe');
-    expect(stripe).toBeDefined();
-    expect(stripe!.spec.auth?.type).toBe('bearer');
-  });
-
-  it('should validate the repo with installed connections', async () => {
-    const errors = await runValidate({cwd: repoDir});
-    expect(errors).toBe(0);
-  });
-
-  it('should build a snapshot that includes installed connections', async () => {
-    const outputPath = join(repoDir, 'snapshot.json');
-    const code = await runBuild({cwd: repoDir, output: outputPath});
-    expect(code).toBe(0);
-
-    const snapshot = JSON.parse(readFileSync(outputPath, 'utf-8')) as Record<string, unknown>;
-    const connections = snapshot['connections'] as Record<string, unknown>;
-    expect(connections['slack']).toBeDefined();
-    expect(connections['stripe']).toBeDefined();
-  });
-
-  // -------------------------------------------------------------------------
-  // Phase 3: Write local access overrides that allow writes without confirmation,
-  //          set real credentials, and boot the runtime
-  // -------------------------------------------------------------------------
-
-  let runtimeServer: {app: unknown; start: () => Promise<unknown>; stop: () => Promise<void>} | null = null;
-  let runtimePort: number;
-
-  it('should boot the runtime with real Stripe and Slack credentials', async () => {
-    // Write local access.json overrides that add write endpoints without confirm
-    const stripeAccessDir = join(repoDir, 'connections', 'stripe');
-    mkdirSync(stripeAccessDir, {recursive: true});
-    writeFileSync(join(stripeAccessDir, 'access.json'), JSON.stringify({
-      import: 'stripe',
-      endpoints: {
-        'GET /v1/customers': {returns: ['id', 'email', 'name', 'created', 'metadata']},
-        'POST /v1/customers': {returns: ['id', 'email', 'name', 'created', 'metadata']},
-      },
-    }, null, 2));
-
-    const slackAccessDir = join(repoDir, 'connections', 'slack');
-    mkdirSync(slackAccessDir, {recursive: true});
-    writeFileSync(join(slackAccessDir, 'access.json'), JSON.stringify({
-      import: 'slack',
-      endpoints: {
-        'GET /conversations.list': {returns: ['id', 'name', 'is_channel']},
-        'GET /conversations.history': {returns: ['messages', 'has_more']},
-        'POST /chat.postMessage': {returns: ['channel', 'ts', 'message']},
-      },
-    }, null, 2));
-
-    // Set real credentials as env vars — the runtime resolves env:VAR_NAME from process.env
-    process.env['STRIPE_SECRET_KEY'] = STRIPE_SECRET_KEY;
-    process.env['SLACK_BOT_TOKEN'] = SLACK_BOT_TOKEN;
-
-    // Boot the runtime
-    const {createLocalServer} = await import('@amodalai/runtime');
-    runtimeServer = await createLocalServer({
-      repoPath: repoDir,
-      port: 0,
-      host: '127.0.0.1',
-      hotReload: false,
-    });
-
-    const httpServer = await runtimeServer.start();
-    const addr = (httpServer as http.Server).address();
-    runtimePort = typeof addr === 'object' && addr ? addr.port : 0;
-    expect(runtimePort).toBeGreaterThan(0);
-  }, 30000);
-
-  // -------------------------------------------------------------------------
-  // Phase 4: Ask the agent to create a Stripe customer through the runtime
-  // -------------------------------------------------------------------------
-
-  const testRunId = `e2e-${Date.now()}`;
-
-  it('should create a Stripe customer when asked via chat', async () => {
-    const events = await sendChat(runtimePort, [
-      `Use the stripe connection to create a new customer with these EXACT details:`,
-      `- email: ${testRunId}@test.amodal.dev`,
-      `- name: E2E Runtime Test`,
-      `Use POST /v1/customers with intent "confirmed_write". The data should be form-encoded as Stripe expects.`,
-      `Do NOT ask for confirmation — just execute it directly with confirmed_write.`,
-    ].join('\n'), 'e2e-plugin-runtime');
-
-    // The agent used the request tool to call Stripe
-    const toolCalls = events.filter((e) => e['type'] === 'tool_call_start');
-    const requestCalls = toolCalls.filter((tc) => tc['tool_name'] === 'request');
-    expect(requestCalls.length).toBeGreaterThan(0);
-
-    // Check Stripe directly for the customer
-    const listResp = await fetch(`https://api.stripe.com/v1/customers?email=${testRunId}@test.amodal.dev`, {
-      headers: {'Authorization': `Bearer ${STRIPE_SECRET_KEY}`},
-    });
-     
-    const listData = await listResp.json() as {data: Array<{id: string; email: string}>};
-
-    if (listData.data.length > 0) {
-      stripeCustomerId = listData.data[0].id;
-      expect(stripeCustomerId).toMatch(/^cus_/);
-    }
-  }, 120000);
-
-  // -------------------------------------------------------------------------
-  // Phase 5: Ask the agent to post to Slack about what it did
-  // -------------------------------------------------------------------------
-
-  it('should post to Slack when asked via chat', async () => {
-    const customerInfo = stripeCustomerId
-      ? `You just created Stripe customer ${stripeCustomerId}.`
-      : `You just attempted to create a Stripe customer.`;
-
-    const events = await sendChat(runtimePort, [
-      `${customerInfo} Now use the slack connection to post a message about this to channel ${SLACK_CHANNEL_ID}.`,
-      `Use POST /chat.postMessage with intent "confirmed_write".`,
-      `The message text should include "Amodal Runtime E2E" and the test run ID "${testRunId}".`,
-      `Do NOT ask for confirmation — execute directly with confirmed_write.`,
-    ].join('\n'), 'e2e-plugin-runtime');
-
-    // The agent used the request tool to post to Slack
-    const toolCalls = events.filter((e) => e['type'] === 'tool_call_start');
-    const requestCalls = toolCalls.filter((tc) => tc['tool_name'] === 'request');
-    expect(requestCalls.length).toBeGreaterThan(0);
-  }, 120000);
-
-  // -------------------------------------------------------------------------
-  // Phase 6: Verify the Slack message was actually posted
-  // -------------------------------------------------------------------------
-
-  it('should verify the Slack message appears in channel history', async () => {
-    // Give Slack a moment to propagate
-    await new Promise((r) => setTimeout(r, 2000));
-
-    const messages = await slackHistory(SLACK_CHANNEL_ID, 10);
-    const found = messages.find((m) =>
-      m.text.includes('Amodal Runtime E2E') || m.text.includes(testRunId),
-    );
-
-    // The message should exist if the agent successfully posted
-    // If the agent used write preview instead of confirmed_write, the message may not be there
-    if (found) {
-      expect(found.text).toContain(testRunId);
-    } else {
-      // Fallback: verify the agent at least attempted the slack call (checked in previous test)
-      process.stderr.write('[e2e] Slack message not found — agent may have used write preview instead of confirmed_write\n');
-    }
-  });
-
-  // -------------------------------------------------------------------------
-  // Phase 7: Clean up runtime and uninstall
-  // -------------------------------------------------------------------------
-
-  it('should stop the runtime server', async () => {
-    if (runtimeServer) {
-      await runtimeServer.stop();
-      runtimeServer = null;
-    }
-    delete process.env['STRIPE_SECRET_KEY'];
-    delete process.env['SLACK_BOT_TOKEN'];
-  });
-
-  it('should uninstall the slack connection', async () => {
-    const code = await runUninstall({cwd: repoDir, type: 'connection', name: 'slack'});
-    expect(code).toBe(0);
-
-    const lockRaw = readFileSync(join(repoDir, 'amodal.lock'), 'utf-8');
-    const lock = JSON.parse(lockRaw) as {packages: Record<string, unknown>};
-    expect(lock.packages['connection/slack']).toBeUndefined();
-  });
-
-  it('should still have stripe after uninstalling slack', async () => {
-    const lockRaw = readFileSync(join(repoDir, 'amodal.lock'), 'utf-8');
-    const lock = JSON.parse(lockRaw) as {packages: Record<string, unknown>};
-    expect(lock.packages['connection/stripe']).toBeDefined();
-  });
-});