moving

packages/cli/tests/cli-runtime.test.ts

@@ -0,0 +1,580 @@
+import { spawn, spawnSync } from 'node:child_process';
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+import { once } from 'node:events';
+import fs from 'node:fs';
+import { createServer } from 'node:http';
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const ROOT = path.resolve(import.meta.dirname, '..', '..', '..');
+const CLI_DIR = path.join(ROOT, 'packages', 'cli');
+
+function bin(name: string): string {
+  return process.platform === 'win32' ? `${name}.cmd` : name;
+}
+
+function makeHome(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-cli-runtime-'));
+}
+
+function run(
+  command: string,
+  args: string[],
+  home: string,
+): Promise<AsyncRunResult> {
+  return runInCwdAsync(command, args, ROOT, home);
+}
+
+function runInCwd(
+  command: string,
+  args: string[],
+  cwd: string,
+  home: string,
+): Promise<AsyncRunResult> {
+  return runInCwdAsync(command, args, cwd, home);
+}
+
+function spawnInCwd(
+  command: string,
+  args: string[],
+  cwd: string,
+  home: string,
+  extraEnv: NodeJS.ProcessEnv = {},
+): ChildProcessWithoutNullStreams {
+  return spawn(command, args, {
+    cwd,
+    env: {
+      ...process.env,
+      HOME: home,
+      USERPROFILE: home,
+      NO_COLOR: '1',
+      ...extraEnv,
+    },
+    stdio: ['pipe', 'pipe', 'pipe'],
+    shell: process.platform === 'win32' && command.endsWith('.cmd'),
+  });
+}
+
+interface AsyncRunResult {
+  status: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+}
+
+function runInCwdAsync(
+  command: string,
+  args: string[],
+  cwd: string,
+  home: string,
+): Promise<AsyncRunResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawnInCwd(command, args, cwd, home);
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('exit', (status, signal) => resolve({ status, signal, stdout, stderr }));
+  });
+}
+
+interface MockLiteLlmRequest {
+  url: string;
+  authorization: string | undefined;
+  body: {
+    model?: string;
+    messages?: Array<{ role: string; content?: string | null }>;
+    stream?: boolean;
+    stream_options?: { include_usage?: boolean };
+  };
+}
+
+interface MockLiteLlm {
+  baseUrl: string;
+  requests: MockLiteLlmRequest[];
+  close: () => Promise<void>;
+}
+
+async function readJson(req: IncomingMessage): Promise<MockLiteLlmRequest['body']> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+
+  const raw = Buffer.concat(chunks).toString('utf8');
+  return raw ? JSON.parse(raw) as MockLiteLlmRequest['body'] : {};
+}
+
+function writeSse(res: ServerResponse, payload: unknown): void {
+  res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+
+async function startMockLiteLlm(): Promise<MockLiteLlm> {
+  const requests: MockLiteLlmRequest[] = [];
+  const server: Server = createServer(async (req, res) => {
+    try {
+      if (req.method !== 'POST' || req.url !== '/v1/chat/completions') {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('not found');
+        return;
+      }
+
+      const body = await readJson(req);
+      requests.push({
+        url: req.url,
+        authorization: req.headers.authorization,
+        body,
+      });
+
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream; charset=utf-8',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+
+      const id = 'chatcmpl-installed-cli-test';
+      writeSse(res, {
+        id,
+        object: 'chat.completion.chunk',
+        choices: [{ index: 0, delta: { content: 'Mock installed ' }, finish_reason: null }],
+      });
+      writeSse(res, {
+        id,
+        object: 'chat.completion.chunk',
+        choices: [{ index: 0, delta: { content: 'chat response' }, finish_reason: null }],
+      });
+      writeSse(res, {
+        id,
+        object: 'chat.completion.chunk',
+        choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 12, completion_tokens: 5, total_tokens: 17 },
+      });
+      res.write('data: [DONE]\n\n');
+      res.end();
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+      res.end((err as Error).message);
+    }
+  });
+
+  server.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+  const address = server.address() as AddressInfo;
+
+  return {
+    baseUrl: `http://127.0.0.1:${address.port}/v1`,
+    requests,
+    close: () => new Promise((resolve, reject) => {
+      server.close((err) => (err ? reject(err) : resolve()));
+    }),
+  };
+}
+
+async function extractTarball(file: string, cwd: string): Promise<void> {
+  const tar = await import('tar');
+  await tar.x({ file, cwd });
+}
+
+async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  timeoutMs: number,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms`);
+}
+
+async function waitForExit(child: ChildProcessWithoutNullStreams, timeoutMs: number): Promise<void> {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await Promise.race([
+    new Promise<void>((resolve) => child.once('exit', () => resolve())),
+    new Promise<void>((_, reject) => setTimeout(() => reject(new Error('process did not exit')), timeoutMs)),
+  ]);
+}
+
+async function stopProcess(child: ChildProcessWithoutNullStreams): Promise<void> {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  if (process.platform === 'win32' && child.pid) {
+    spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+  } else {
+    child.kill('SIGTERM');
+  }
+
+  await Promise.race([
+    new Promise<void>((resolve) => child.once('exit', () => resolve())),
+    new Promise<void>((resolve) => setTimeout(resolve, 5_000)),
+  ]);
+
+  if (child.exitCode === null && child.signalCode === null) {
+    child.kill('SIGKILL');
+  }
+}
+
+const CLI_PACKAGE_CLOSURE = [
+  '@waggle/shared',
+  '@waggle/hive-mind-core',
+  '@waggle/core',
+  '@waggle/marketplace',
+  '@waggle/agent',
+  '@waggle/weaver',
+  '@waggle/cli',
+] as const;
+
+describe('@waggle/cli runtime UX', () => {
+  it('runs built help without loading the REPL dependency graph', async () => {
+    const home = makeHome();
+    try {
+      const build = await run(bin('npm'), ['run', 'build', '--workspace', '@waggle/cli'], home);
+      expect(build.status).toBe(0);
+
+      const result = await run(process.execPath, [path.join(CLI_DIR, 'dist', 'index.js'), '--help'], home);
+
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('Waggle CLI');
+      expect(result.stdout).toContain('Usage:');
+      expect(result.stderr).toBe('');
+      expect(fs.existsSync(path.join(home, '.waggle'))).toBe(false);
+    } finally {
+      fs.rmSync(home, { recursive: true, force: true });
+    }
+  });
+
+  it('packs a tarball with a runnable bin help command', async () => {
+    const home = makeHome();
+    try {
+      const build = await run(bin('npm'), ['run', 'build', '--workspace', '@waggle/cli'], home);
+      expect(build.status).toBe(0);
+
+      const pack = await run(
+        bin('npm'),
+        ['pack', '--workspace', '@waggle/cli', '--pack-destination', home, '--json'],
+        home,
+      );
+      expect(pack.status).toBe(0);
+
+      const [packResult] = JSON.parse(pack.stdout) as Array<{ filename: string }>;
+      const extractDir = path.join(home, 'packed');
+      fs.mkdirSync(extractDir, { recursive: true });
+      await extractTarball(path.join(home, packResult.filename), extractDir);
+
+      const pkg = JSON.parse(
+        fs.readFileSync(path.join(extractDir, 'package', 'package.json'), 'utf8'),
+      );
+      const result = await run(
+        process.execPath,
+        [path.join(extractDir, 'package', 'bin', 'waggle.js'), '--help'],
+        home,
+      );
+
+      expect(pkg.bin.waggle).toBe('bin/waggle.js');
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('Waggle CLI');
+      expect(result.stdout).toContain('Usage:');
+      expect(result.stderr).toBe('');
+      expect(fs.existsSync(path.join(home, '.waggle'))).toBe(false);
+    } finally {
+      fs.rmSync(home, { recursive: true, force: true });
+    }
+  });
+
+  it('installs the local package closure and runs npx help', async () => {
+    const home = makeHome();
+    try {
+      const packsDir = path.join(home, 'packs');
+      const projectDir = path.join(home, 'project');
+      fs.mkdirSync(packsDir, { recursive: true });
+      fs.mkdirSync(projectDir, { recursive: true });
+
+      const dependencies: Record<string, string> = {};
+      for (const workspace of CLI_PACKAGE_CLOSURE) {
+        const build = await run(bin('npm'), ['run', 'build', '--workspace', workspace], home);
+        expect(build.status).toBe(0);
+
+        const pack = await run(
+          bin('npm'),
+          ['pack', '--workspace', workspace, '--pack-destination', packsDir, '--json'],
+          home,
+        );
+        expect(pack.status).toBe(0);
+
+        const [packResult] = JSON.parse(pack.stdout) as Array<{ filename: string }>;
+        const tarball = path.join(packsDir, packResult.filename).replace(/\\/g, '/');
+        dependencies[workspace] = `file:${tarball}`;
+      }
+
+      fs.writeFileSync(
+        path.join(projectDir, 'package.json'),
+        JSON.stringify({ private: true, type: 'module', dependencies }, null, 2),
+      );
+
+      const install = await runInCwd(
+        bin('npm'),
+        ['install', '--no-audit', '--no-fund', '--ignore-scripts', '--prefer-offline'],
+        projectDir,
+        home,
+      );
+      expect(install.status).toBe(0);
+
+      const result = await runInCwd(bin('npx'), ['waggle', '--help'], projectDir, home);
+
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('Waggle CLI');
+      expect(result.stdout).toContain('Usage:');
+      expect(result.stderr).toBe('');
+      expect(fs.existsSync(path.join(home, '.waggle'))).toBe(false);
+    } finally {
+      fs.rmSync(home, { recursive: true, force: true });
+    }
+  }, 120_000);
+
+  it('installs the local package closure and starts the local REPL', async () => {
+    const home = makeHome();
+    let child: ChildProcessWithoutNullStreams | undefined;
+    try {
+      const packsDir = path.join(home, 'packs');
+      const projectDir = path.join(home, 'project');
+      fs.mkdirSync(packsDir, { recursive: true });
+      fs.mkdirSync(projectDir, { recursive: true });
+
+      const dependencies: Record<string, string> = {};
+      for (const workspace of CLI_PACKAGE_CLOSURE) {
+        const build = await run(bin('npm'), ['run', 'build', '--workspace', workspace], home);
+        expect(build.status).toBe(0);
+
+        const pack = await run(
+          bin('npm'),
+          ['pack', '--workspace', workspace, '--pack-destination', packsDir, '--json'],
+          home,
+        );
+        expect(pack.status).toBe(0);
+
+        const [packResult] = JSON.parse(pack.stdout) as Array<{ filename: string }>;
+        const tarball = path.join(packsDir, packResult.filename).replace(/\\/g, '/');
+        dependencies[workspace] = `file:${tarball}`;
+      }
+
+      fs.writeFileSync(
+        path.join(projectDir, 'package.json'),
+        JSON.stringify({ private: true, type: 'module', dependencies }, null, 2),
+      );
+
+      const install = await runInCwdAsync(
+        bin('npm'),
+        // The REPL opens MindDB on startup, so this install must allow better-sqlite3's
+        // native binding lifecycle rather than using the help-only --ignore-scripts path.
+        ['install', '--no-audit', '--no-fund', '--prefer-offline'],
+        projectDir,
+        home,
+      );
+      if (install.status !== 0) {
+        throw new Error(
+          [
+            'Installed waggle REPL dependency install failed.',
+            `status=${install.status ?? 'null'} signal=${install.signal ?? 'none'}`,
+            `stdout:\n${install.stdout}`,
+            `stderr:\n${install.stderr}`,
+          ].join('\n'),
+        );
+      }
+
+      let stdout = '';
+      let stderr = '';
+      child = spawnInCwd(bin('npx'), ['waggle', '--local'], projectDir, home);
+      child.stdout.setEncoding('utf8');
+      child.stderr.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => { stdout += chunk; });
+      child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+      try {
+        await waitFor(() => stdout.includes('Type /help for commands') && stdout.includes('you >'), 30_000);
+      } catch (err) {
+        throw new Error(
+          [
+            'Installed waggle REPL did not reach the prompt.',
+            `exitCode=${child.exitCode ?? 'running'} signalCode=${child.signalCode ?? 'none'}`,
+            `stdout:\n${stdout}`,
+            `stderr:\n${stderr}`,
+          ].join('\n'),
+          { cause: err },
+        );
+      }
+
+      const writeCommand = async (command: string, expected: string | string[]) => {
+        child!.stdin.write(`${command}\n`);
+        const expectedText = Array.isArray(expected) ? expected : [expected];
+        await waitFor(() => expectedText.every((text) => stdout.includes(text)), 10_000);
+      };
+
+      await writeCommand('/help', ['Available commands:', '/models', '/whoami']);
+      await writeCommand('/mode', 'Current mode: local');
+      await writeCommand('/whoami', ['User:', 'not logged in', 'Server:']);
+      await writeCommand('/models', ['Available models:', 'No models configured']);
+      await writeCommand('/cost', ['Tokens: 0 in / 0 out', 'Est. cost: $0.0000']);
+      await writeCommand('/clear', 'Conversation cleared.');
+
+      child.stdin.write('/exit\n');
+      await waitForExit(child, 10_000);
+
+      expect(child.exitCode).toBe(0);
+      expect(stdout).toContain('Waggle');
+      expect(stdout).toContain('Mode:');
+      expect(stdout).toContain('local');
+      expect(stdout).toContain('Available commands:');
+      expect(stdout).toContain('Current mode: local');
+      expect(stdout).toContain('No models configured');
+      expect(stdout).toContain('Conversation cleared.');
+      expect(stdout).toContain('Goodbye!');
+      expect(stderr).not.toContain('Fatal error');
+      expect(fs.existsSync(path.join(home, '.waggle', 'default.mind'))).toBe(true);
+    } finally {
+      if (child) await stopProcess(child);
+      fs.rmSync(home, { recursive: true, force: true });
+    }
+  }, 180_000);
+
+  it('installs the local package closure and completes a streamed chat turn', async () => {
+    const home = makeHome();
+    let child: ChildProcessWithoutNullStreams | undefined;
+    let mockLiteLlm: MockLiteLlm | undefined;
+    try {
+      const packsDir = path.join(home, 'packs');
+      const projectDir = path.join(home, 'project');
+      fs.mkdirSync(packsDir, { recursive: true });
+      fs.mkdirSync(projectDir, { recursive: true });
+
+      const dependencies: Record<string, string> = {};
+      for (const workspace of CLI_PACKAGE_CLOSURE) {
+        const build = await run(bin('npm'), ['run', 'build', '--workspace', workspace], home);
+        expect(build.status).toBe(0);
+
+        const pack = await run(
+          bin('npm'),
+          ['pack', '--workspace', workspace, '--pack-destination', packsDir, '--json'],
+          home,
+        );
+        expect(pack.status).toBe(0);
+
+        const [packResult] = JSON.parse(pack.stdout) as Array<{ filename: string }>;
+        const tarball = path.join(packsDir, packResult.filename).replace(/\\/g, '/');
+        dependencies[workspace] = `file:${tarball}`;
+      }
+
+      fs.writeFileSync(
+        path.join(projectDir, 'package.json'),
+        JSON.stringify({ private: true, type: 'module', dependencies }, null, 2),
+      );
+
+      const install = await runInCwdAsync(
+        bin('npm'),
+        ['install', '--no-audit', '--no-fund', '--prefer-offline'],
+        projectDir,
+        home,
+      );
+      if (install.status !== 0) {
+        throw new Error(
+          [
+            'Installed waggle chat dependency install failed.',
+            `status=${install.status ?? 'null'} signal=${install.signal ?? 'none'}`,
+            `stdout:\n${install.stdout}`,
+            `stderr:\n${install.stderr}`,
+          ].join('\n'),
+        );
+      }
+
+      mockLiteLlm = await startMockLiteLlm();
+      const waggleHome = path.join(home, '.waggle');
+      const workspaceConfigDir = path.join(projectDir, '.waggle');
+      fs.mkdirSync(waggleHome, { recursive: true });
+      fs.mkdirSync(workspaceConfigDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(waggleHome, 'config.json'),
+        JSON.stringify({
+          defaultModel: 'mock-model',
+          providers: {
+            litellm: {
+              apiKey: 'sk-test',
+              models: ['mock-model'],
+            },
+          },
+        }, null, 2),
+      );
+      fs.writeFileSync(
+        path.join(workspaceConfigDir, 'workspace.json'),
+        JSON.stringify({
+          model: 'mock-model',
+          litellmUrl: mockLiteLlm.baseUrl,
+        }, null, 2),
+      );
+
+      let stdout = '';
+      let stderr = '';
+      child = spawnInCwd(
+        bin('npx'),
+        ['waggle', '--local'],
+        projectDir,
+        home,
+        {
+          LITELLM_API_KEY: 'sk-test',
+          WAGGLE_LLM_TIMEOUT_MS: '30000',
+        },
+      );
+      child.stdout.setEncoding('utf8');
+      child.stderr.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => { stdout += chunk; });
+      child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+      try {
+        await waitFor(() => stdout.includes('Type /help for commands') && stdout.includes('you >'), 30_000);
+      } catch (err) {
+        throw new Error(
+          [
+            'Installed waggle REPL did not reach the prompt before chat.',
+            `exitCode=${child.exitCode ?? 'running'} signalCode=${child.signalCode ?? 'none'}`,
+            `stdout:\n${stdout}`,
+            `stderr:\n${stderr}`,
+          ].join('\n'),
+          { cause: err },
+        );
+      }
+
+      child.stdin.write('Say hello from the installed CLI test.\n');
+      await waitFor(
+        () => stdout.includes('Mock installed chat response') && stdout.includes('[mock-model |'),
+        30_000,
+      );
+
+      child.stdin.write('/exit\n');
+      await waitForExit(child, 10_000);
+
+      const chatRequest = mockLiteLlm.requests.find((request) => request.url === '/v1/chat/completions');
+      expect(chatRequest).toBeDefined();
+      expect(chatRequest?.authorization).toBe('Bearer sk-test');
+      expect(chatRequest?.body.model).toBe('mock-model');
+      expect(chatRequest?.body.stream).toBe(true);
+      expect(chatRequest?.body.stream_options).toEqual({ include_usage: true });
+      expect(JSON.stringify(chatRequest?.body.messages)).toContain('Say hello from the installed CLI test.');
+      expect(child.exitCode).toBe(0);
+      expect(stdout).toContain('Model:');
+      expect(stdout).toContain('mock-model');
+      expect(stdout).toContain('Mock installed chat response');
+      expect(stdout).toContain('12');
+      expect(stdout).toContain('5');
+      expect(stdout).toContain('Goodbye!');
+      expect(stderr).not.toContain('Fatal error');
+    } finally {
+      if (child) await stopProcess(child);
+      if (mockLiteLlm) await mockLiteLlm.close();
+      fs.rmSync(home, { recursive: true, force: true });
+    }
+  }, 240_000);
+});