@argo-video/cli 0.1.0 → 0.1.1

package/tests/asset-server.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { startAssetServer } from '../src/asset-server.js';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('startAssetServer', () => {
-  let tmpDir: string;
-  let close: (() => Promise<void>) | undefined;
-
-  function setup() {
-    tmpDir = mkdtempSync(join(tmpdir(), 'argo-asset-'));
-    mkdirSync(join(tmpDir, 'assets'), { recursive: true });
-  }
-
-  afterEach(async () => {
-    if (close) await close();
-    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('serves files from the asset directory', async () => {
-    setup();
-    writeFileSync(join(tmpDir, 'assets', 'test.txt'), 'hello');
-    const server = await startAssetServer(join(tmpDir, 'assets'));
-    close = server.close;
-
-    const res = await fetch(`${server.url}/test.txt`);
-    expect(res.status).toBe(200);
-    expect(await res.text()).toBe('hello');
-  });
-
-  it('returns 404 for missing files', async () => {
-    setup();
-    const server = await startAssetServer(join(tmpDir, 'assets'));
-    close = server.close;
-
-    const res = await fetch(`${server.url}/nope.png`);
-    expect(res.status).toBe(404);
-  });
-
-  it('prevents path traversal', async () => {
-    setup();
-    writeFileSync(join(tmpDir, 'secret.txt'), 'private');
-    const server = await startAssetServer(join(tmpDir, 'assets'));
-    close = server.close;
-
-    const res = await fetch(`${server.url}/../secret.txt`);
-    expect(res.status).toBe(403);
-  });
-
-  it('assigns a random available port', async () => {
-    setup();
-    const server = await startAssetServer(join(tmpDir, 'assets'));
-    close = server.close;
-    expect(server.port).toBeGreaterThan(0);
-  });
-
-  it('serves PNG with correct content type', async () => {
-    setup();
-    writeFileSync(join(tmpDir, 'assets', 'img.png'), Buffer.from([0x89, 0x50]));
-    const server = await startAssetServer(join(tmpDir, 'assets'));
-    close = server.close;
-
-    const res = await fetch(`${server.url}/img.png`);
-    expect(res.headers.get('content-type')).toBe('image/png');
-  });
-});

package/tests/captions.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { showCaption, hideCaption, withCaption } from '../src/captions.js';
-
-function createMockPage() {
-  const calls: string[] = [];
-  const page = {
-    evaluate: vi.fn(async () => {
-      calls.push('evaluate');
-    }),
-    waitForTimeout: vi.fn(async () => {
-      calls.push('waitForTimeout');
-    }),
-  };
-  return { page: page as any, calls };
-}
-
-// ---------- showCaption ----------
-describe('showCaption', () => {
-  it('calls evaluate to inject, waits for duration, then calls evaluate to remove', async () => {
-    const { page, calls } = createMockPage();
-    await showCaption(page, 'intro', 'Hello world', 3000);
-
-    expect(page.evaluate).toHaveBeenCalledTimes(2);
-    expect(page.waitForTimeout).toHaveBeenCalledWith(3000);
-    expect(calls).toEqual(['evaluate', 'waitForTimeout', 'evaluate']);
-  });
-});
-
-// ---------- hideCaption ----------
-describe('hideCaption', () => {
-  it('calls evaluate once to remove the overlay', async () => {
-    const { page } = createMockPage();
-    await hideCaption(page);
-
-    expect(page.evaluate).toHaveBeenCalledTimes(1);
-  });
-});
-
-// ---------- withCaption ----------
-describe('withCaption', () => {
-  it('shows caption, runs action, then hides caption in order', async () => {
-    const order: string[] = [];
-    const page = {
-      evaluate: vi.fn(async () => {
-        order.push('evaluate');
-      }),
-      waitForTimeout: vi.fn(async () => {
-        order.push('waitForTimeout');
-      }),
-    } as any;
-
-    const action = async () => {
-      order.push('action');
-    };
-
-    await withCaption(page, 'demo', 'Doing stuff', action);
-
-    // inject, action, remove
-    expect(order).toEqual(['evaluate', 'action', 'evaluate']);
-  });
-
-  it('hides caption even if action throws', async () => {
-    const { page } = createMockPage();
-
-    const failingAction = async () => {
-      throw new Error('boom');
-    };
-
-    await expect(
-      withCaption(page, 'demo', 'Failing', failingAction),
-    ).rejects.toThrow('boom');
-
-    // Should still have called evaluate twice: inject + remove
-    expect(page.evaluate).toHaveBeenCalledTimes(2);
-  });
-});

package/tests/cli.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock('../src/config.js', () => ({
-  loadConfig: vi.fn(),
-}));
-
-vi.mock('../src/record.js', () => ({
-  record: vi.fn(),
-}));
-
-vi.mock('../src/tts/generate.js', () => ({
-  generateClips: vi.fn(),
-}));
-
-vi.mock('../src/export.js', () => ({
-  exportVideo: vi.fn(),
-}));
-
-vi.mock('../src/pipeline.js', () => ({
-  runPipeline: vi.fn(),
-}));
-
-vi.mock('../src/init.js', () => ({
-  init: vi.fn(),
-}));
-
-import { loadConfig } from '../src/config.js';
-import { record } from '../src/record.js';
-import { generateClips } from '../src/tts/generate.js';
-import { exportVideo } from '../src/export.js';
-import { runPipeline } from '../src/pipeline.js';
-import { init } from '../src/init.js';
-import { createProgram } from '../src/cli.js';
-
-const mockedLoadConfig = vi.mocked(loadConfig);
-const mockedRecord = vi.mocked(record);
-const mockedGenerateClips = vi.mocked(generateClips);
-const mockedExportVideo = vi.mocked(exportVideo);
-const mockedRunPipeline = vi.mocked(runPipeline);
-const mockedInit = vi.mocked(init);
-
-const defaultConfig = {
-  baseURL: 'http://localhost:3000',
-  demosDir: 'demos',
-  outputDir: 'videos',
-  tts: { defaultVoice: 'af_heart', defaultSpeed: 1.0 },
-  video: { width: 1920, height: 1080, fps: 30 },
-  export: { preset: 'slow', crf: 16 },
-};
-
-beforeEach(() => {
-  vi.resetAllMocks();
-  mockedLoadConfig.mockResolvedValue(defaultConfig as any);
-  mockedRecord.mockResolvedValue({ videoPath: '', timingPath: '' });
-  mockedGenerateClips.mockResolvedValue([]);
-  mockedExportVideo.mockResolvedValue('videos/onboarding.mp4');
-  mockedRunPipeline.mockResolvedValue('videos/onboarding.mp4');
-  mockedInit.mockResolvedValue(undefined as any);
-});
-
-function run(...args: string[]) {
-  const program = createProgram();
-  program.exitOverride();
-  return program.parseAsync(['node', 'argo', ...args]);
-}
-
-describe('CLI', () => {
-  describe('argo record <demo>', () => {
-    it('calls loadConfig and record with demo name', async () => {
-      await run('record', 'onboarding');
-
-      expect(mockedLoadConfig).toHaveBeenCalledWith(process.cwd(), undefined);
-      expect(mockedRecord).toHaveBeenCalledWith('onboarding', expect.objectContaining({
-        demosDir: 'demos',
-      }));
-    });
-
-    it('passes --config to loadConfig', async () => {
-      await run('--config', 'custom.ts', 'record', 'onboarding');
-
-      expect(mockedLoadConfig).toHaveBeenCalledWith(process.cwd(), 'custom.ts');
-    });
-  });
-
-  describe('argo tts generate <manifest>', () => {
-    it('calls loadConfig and generateClips', async () => {
-      await run('tts', 'generate', 'manifest.json');
-
-      expect(mockedLoadConfig).toHaveBeenCalledWith(process.cwd(), undefined);
-      expect(mockedGenerateClips).toHaveBeenCalledWith(
-        expect.objectContaining({ manifestPath: 'manifest.json' }),
-      );
-    });
-  });
-
-  describe('argo export <demo>', () => {
-    it('calls loadConfig and exportVideo', async () => {
-      await run('export', 'onboarding');
-
-      expect(mockedLoadConfig).toHaveBeenCalledWith(process.cwd(), undefined);
-      expect(mockedExportVideo).toHaveBeenCalledWith(
-        expect.objectContaining({ demoName: 'onboarding' }),
-      );
-    });
-  });
-
-  describe('argo pipeline <demo>', () => {
-    it('calls loadConfig and runPipeline', async () => {
-      await run('pipeline', 'onboarding');
-
-      expect(mockedLoadConfig).toHaveBeenCalledWith(process.cwd(), undefined);
-      expect(mockedRunPipeline).toHaveBeenCalledWith('onboarding', defaultConfig);
-    });
-  });
-
-  describe('argo init', () => {
-    it('calls init()', async () => {
-      await run('init');
-
-      expect(mockedInit).toHaveBeenCalled();
-    });
-  });
-
-  describe('global --config option', () => {
-    it('passes config path to loadConfig for export command', async () => {
-      await run('-c', 'my-config.ts', 'export', 'onboarding');
-
-      expect(mockedLoadConfig).toHaveBeenCalledWith(process.cwd(), 'my-config.ts');
-    });
-  });
-});

package/tests/config.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { join } from 'node:path';
-import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import {
-  defineConfig,
-  loadConfig,
-  demosProject,
-  type ArgoConfig,
-  type TTSEngine,
-} from '../src/config.js';
-
-const DEFAULTS: ArgoConfig = {
-  demosDir: 'demos',
-  outputDir: 'videos',
-  tts: { defaultVoice: 'af_heart', defaultSpeed: 1.0 },
-  video: { width: 1920, height: 1080, fps: 30 },
-  export: { preset: 'slow', crf: 16 },
-};
-
-// ---------- defineConfig ----------
-describe('defineConfig', () => {
-  it('returns defaults when given an empty object', () => {
-    const config = defineConfig({});
-    expect(config).toEqual(DEFAULTS);
-  });
-
-  it('merges top-level overrides while preserving unset defaults', () => {
-    const config = defineConfig({ baseURL: 'http://localhost:3000', demosDir: 'my-demos' });
-    expect(config.baseURL).toBe('http://localhost:3000');
-    expect(config.demosDir).toBe('my-demos');
-    expect(config.outputDir).toBe('videos');
-    expect(config.tts).toEqual(DEFAULTS.tts);
-    expect(config.video).toEqual(DEFAULTS.video);
-    expect(config.export).toEqual(DEFAULTS.export);
-  });
-
-  it('deep-merges nested tts config', () => {
-    const config = defineConfig({ tts: { defaultSpeed: 1.5 } });
-    expect(config.tts.defaultVoice).toBe('af_heart');
-    expect(config.tts.defaultSpeed).toBe(1.5);
-  });
-
-  it('deep-merges nested video config', () => {
-    const config = defineConfig({ video: { width: 1920, height: 1080 } });
-    expect(config.video.width).toBe(1920);
-    expect(config.video.height).toBe(1080);
-    expect(config.video.fps).toBe(30);
-  });
-
-  it('deep-merges nested export config', () => {
-    const config = defineConfig({ export: { crf: 23 } });
-    expect(config.export.preset).toBe('slow');
-    expect(config.export.crf).toBe(23);
-  });
-
-  it('preserves a custom TTS engine', () => {
-    const engine: TTSEngine = {
-      generate: async (_text, _options) => Buffer.from('audio'),
-    };
-    const config = defineConfig({ tts: { engine } });
-    expect(config.tts.engine).toBe(engine);
-    expect(config.tts.defaultVoice).toBe('af_heart');
-  });
-});
-
-// ---------- demosProject ----------
-describe('demosProject', () => {
-  it('returns the correct Playwright project shape', () => {
-    const project = demosProject({ baseURL: 'http://localhost:4000' });
-    expect(project).toEqual({
-      name: 'demos',
-      testDir: 'demos',
-      testMatch: '**/*.demo.ts',
-      use: {
-        baseURL: 'http://localhost:4000',
-        video: 'on',
-      },
-    });
-  });
-
-  it('uses a custom demosDir as testDir', () => {
-    const project = demosProject({ baseURL: 'http://localhost:4000', demosDir: 'my-demos' });
-    expect(project.testDir).toBe('my-demos');
-  });
-});
-
-// ---------- loadConfig ----------
-describe('loadConfig', () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'argo-config-test-'));
-  });
-
-  afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns defaults when no config file exists', async () => {
-    const config = await loadConfig(tmpDir);
-    expect(config).toEqual(DEFAULTS);
-  });
-
-  it('loads argo.config.js and merges with defaults', async () => {
-    await writeFile(
-      join(tmpDir, 'argo.config.js'),
-      `export default { demosDir: 'custom-demos', tts: { defaultSpeed: 2.0 } };`,
-    );
-    const config = await loadConfig(tmpDir);
-    expect(config.demosDir).toBe('custom-demos');
-    expect(config.tts.defaultSpeed).toBe(2.0);
-    expect(config.tts.defaultVoice).toBe('af_heart');
-    expect(config.outputDir).toBe('videos');
-  });
-
-  it('loads argo.config.mjs', async () => {
-    await writeFile(
-      join(tmpDir, 'argo.config.mjs'),
-      `export default { outputDir: 'out' };`,
-    );
-    const config = await loadConfig(tmpDir);
-    expect(config.outputDir).toBe('out');
-    expect(config.demosDir).toBe('demos');
-  });
-
-  it('loads from an explicit path', async () => {
-    const customDir = join(tmpDir, 'nested');
-    await mkdir(customDir, { recursive: true });
-    const customPath = join(customDir, 'my-config.mjs');
-    await writeFile(customPath, `export default { baseURL: 'http://example.com' };`);
-
-    const config = await loadConfig(tmpDir, customPath);
-    expect(config.baseURL).toBe('http://example.com');
-    expect(config.demosDir).toBe('demos');
-  });
-
-  it('finds argo.config.ts first in search order', async () => {
-    await writeFile(
-      join(tmpDir, 'argo.config.ts'),
-      `export default { demosDir: 'from-ts' };`,
-    );
-    await writeFile(
-      join(tmpDir, 'argo.config.js'),
-      `export default { demosDir: 'from-js' };`,
-    );
-    const config = await loadConfig(tmpDir);
-    expect(config.demosDir).toBe('from-ts');
-  });
-});

package/tests/e2e/fake-server.ts

@@ -1,45 +0,0 @@
-import http from 'node:http';
-import type { AddressInfo } from 'node:net';
-
-const HTML = `<!DOCTYPE html>
-<html>
-<head><title>Argo E2E Test</title></head>
-<body>
-  <h1>Welcome to Argo Demo</h1>
-  <p>This is a fake app for E2E testing.</p>
-  <button id="action" onclick="document.getElementById('result').textContent='Done!'">
-    Get Started
-  </button>
-  <div id="result"></div>
-</body>
-</html>`;
-
-export interface FakeServer {
-  url: string;
-  port: number;
-  close: () => Promise<void>;
-}
-
-export function startFakeServer(): Promise<FakeServer> {
-  return new Promise((resolve, reject) => {
-    const server = http.createServer((_req, res) => {
-      res.writeHead(200, { 'Content-Type': 'text/html' });
-      res.end(HTML);
-    });
-
-    const onError = (error: Error) => {
-      reject(error);
-    };
-
-    server.once('error', onError);
-    server.listen(0, '127.0.0.1', () => {
-      server.off('error', onError);
-      const { port } = server.address() as AddressInfo;
-      resolve({
-        url: `http://127.0.0.1:${port}`,
-        port,
-        close: () => new Promise((res, rej) => server.close((error) => (error ? rej(error) : res()))),
-      });
-    });
-  });
-}

package/tests/e2e/record.e2e.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm, writeFile, mkdir, readdir, stat } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import { execFile } from 'node:child_process';
-import { startFakeServer, type FakeServer } from './fake-server.js';
-
-const PROJECT_ROOT = resolve(import.meta.dirname, '../..');
-
-async function canBindLocalhost(): Promise<boolean> {
-  try {
-    const probeServer = await startFakeServer();
-    await probeServer.close();
-    return true;
-  } catch (error) {
-    const err = error as NodeJS.ErrnoException;
-    if (err.code === 'EPERM' || err.code === 'EACCES') {
-      return false;
-    }
-    throw error;
-  }
-}
-
-const describeE2E = (await canBindLocalhost()) ? describe : describe.skip;
-
-describeE2E('E2E: argo record', () => {
-  let server: FakeServer;
-  let workDir: string;
-
-  beforeAll(async () => {
-    server = await startFakeServer();
-  }, 30_000);
-
-  afterAll(async () => {
-    await server.close();
-  });
-
-  beforeEach(async () => {
-    workDir = await mkdtemp(join(tmpdir(), 'argo-e2e-'));
-  });
-
-  afterEach(async () => {
-    await rm(workDir, { recursive: true, force: true });
-  });
-
-  function writePlaywrightConfig(baseURL: string): Promise<void> {
-    // testDir uses absolute path so Playwright can find it from any cwd
-    const demosDir = join(workDir, 'demos');
-    const config = `
-import { defineConfig } from '@playwright/test';
-
-export default defineConfig({
-  projects: [
-    {
-      name: 'demos',
-      testDir: '${demosDir}',
-      testMatch: '**/*.demo.ts',
-      use: {
-        baseURL: '${baseURL}',
-        video: 'on',
-      },
-    },
-  ],
-  outputDir: '${join(workDir, 'test-results')}',
-});
-`;
-    return writeFile(join(workDir, 'playwright.config.ts'), config);
-  }
-
-  function writeDemoFile(): Promise<void> {
-    const demo = `
-import { test, expect } from '@playwright/test';
-
-test('example', async ({ page }) => {
-  await page.goto('/');
-  await expect(page.locator('h1')).toHaveText('Welcome to Argo Demo');
-  await page.click('#action');
-  await expect(page.locator('#result')).toHaveText('Done!');
-});
-`;
-    return writeFile(join(workDir, 'demos', 'example.demo.ts'), demo);
-  }
-
-  function runPlaywright(): Promise<{ stdout: string; stderr: string }> {
-    return new Promise((resolve, reject) => {
-      execFile(
-        'npx',
-        [
-          'playwright', 'test',
-          '--config', join(workDir, 'playwright.config.ts'),
-          '--grep', 'example',
-          '--project', 'demos',
-        ],
-        {
-          cwd: PROJECT_ROOT,
-          env: {
-            ...process.env,
-            BASE_URL: server.url,
-            NODE_PATH: join(PROJECT_ROOT, 'node_modules'),
-          },
-          timeout: 30_000,
-        },
-        (error, stdout, stderr) => {
-          if (error) {
-            reject(new Error(`Playwright failed:\n${stdout}\n${stderr}`));
-            return;
-          }
-          resolve({ stdout, stderr });
-        },
-      );
-    });
-  }
-
-  it('records a demo against the fake server', async () => {
-    await mkdir(join(workDir, 'demos'), { recursive: true });
-    await writePlaywrightConfig(server.url);
-    await writeDemoFile();
-
-    await runPlaywright();
-
-    // Playwright with video: 'on' creates test-results/<test-name>/video.webm
-    const testResults = join(workDir, 'test-results');
-    const resultsStat = await stat(testResults);
-    expect(resultsStat.isDirectory()).toBe(true);
-
-    // Find the video file somewhere in test-results
-    const entries = await readdir(testResults, { recursive: true });
-    const videoFile = entries.find((e) => e.endsWith('.webm'));
-    expect(videoFile).toBeDefined();
-  }, 60_000);
-});