@geminilight/mindos 0.6.71 → 0.6.73

package/tests/unit/cli-mcp-install.test.ts

@@ -1,123 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * Tests for MCP install config — entry format and config file merging.
- *
- * mcpInstall() is an interactive TUI function that can't be directly imported
- * without triggering readline. We test the two critical contracts:
- *
- * 1. Entry format (contract test — logic extracted from source)
- * 2. Config file merge (e2e — real file I/O)
- */
-
-let tempDir: string;
-
-beforeEach(() => {
-  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-mcp-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tempDir, { recursive: true, force: true });
-});
-
-// ── Entry format contract ───────────────────────────────────────────────────
-// Extracted from mcp-install.js lines 278-282
-
-function buildEntry(transport: string, url?: string, token?: string) {
-  return transport === 'stdio'
-    ? { type: 'stdio', command: 'mindos', args: ['mcp'], env: { MCP_TRANSPORT: 'stdio' } }
-    : token
-      ? { url, headers: { Authorization: `Bearer ${token}` } }
-      : { url };
-}
-
-describe('MCP entry format', () => {
-  it('stdio entry has correct structure', () => {
-    const entry = buildEntry('stdio');
-    expect(entry).toEqual({
-      type: 'stdio',
-      command: 'mindos',
-      args: ['mcp'],
-      env: { MCP_TRANSPORT: 'stdio' },
-    });
-  });
-
-  it('http entry with token includes Authorization header', () => {
-    const entry = buildEntry('http', 'http://localhost:8781/mcp', 'tok-abc');
-    expect(entry).toEqual({
-      url: 'http://localhost:8781/mcp',
-      headers: { Authorization: 'Bearer tok-abc' },
-    });
-  });
-
-  it('http entry without token has no headers', () => {
-    const entry = buildEntry('http', 'http://localhost:8781/mcp');
-    expect(entry).toEqual({ url: 'http://localhost:8781/mcp' });
-    expect(entry).not.toHaveProperty('headers');
-  });
-});
-
-// ── Config file merge ───────────────────────────────────────────────────────
-// Simulates the read→merge→write logic from mcp-install.js lines 312-329
-
-function mergeAndWrite(configPath: string, agentKey: string, entry: unknown) {
-  let config: Record<string, Record<string, unknown>> = {};
-  if (fs.existsSync(configPath)) {
-    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  }
-  if (!config[agentKey]) config[agentKey] = {};
-  config[agentKey].mindos = entry;
-
-  const dir = path.dirname(configPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-}
-
-describe('MCP config file merge', () => {
-  it('creates new config file when none exists', () => {
-    const configPath = path.join(tempDir, 'mcp.json');
-    const entry = buildEntry('stdio');
-    mergeAndWrite(configPath, 'mcpServers', entry);
-
-    const result = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    expect(result.mcpServers.mindos).toEqual(entry);
-  });
-
-  it('preserves other mcpServers when adding mindos', () => {
-    const configPath = path.join(tempDir, 'mcp.json');
-    // Pre-existing config with another server
-    fs.writeFileSync(configPath, JSON.stringify({
-      mcpServers: {
-        'other-server': { url: 'http://other:9000/mcp' },
-      },
-    }, null, 2));
-
-    const entry = buildEntry('http', 'http://localhost:8781/mcp', 'tok-123');
-    mergeAndWrite(configPath, 'mcpServers', entry);
-
-    const result = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    expect(result.mcpServers.mindos).toEqual(entry);
-    expect(result.mcpServers['other-server']).toEqual({ url: 'http://other:9000/mcp' });
-  });
-
-  it('updates existing mindos entry without losing other servers', () => {
-    const configPath = path.join(tempDir, 'mcp.json');
-    // Pre-existing config with old mindos + another server
-    fs.writeFileSync(configPath, JSON.stringify({
-      mcpServers: {
-        mindos: { url: 'http://old:8000/mcp' },
-        'other-server': { command: 'other-cmd' },
-      },
-    }, null, 2));
-
-    const newEntry = buildEntry('stdio');
-    mergeAndWrite(configPath, 'mcpServers', newEntry);
-
-    const result = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    expect(result.mcpServers.mindos).toEqual(newEntry);
-    expect(result.mcpServers['other-server']).toEqual({ command: 'other-cmd' });
-  });
-});

package/tests/unit/cli-mcp-stdio-default.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { createServer, Server } from 'net';
-import { spawn, ChildProcess } from 'child_process';
-import { join } from 'path';
-
-/**
- * Regression test: `mindos mcp` (standalone) must default to stdio transport.
- *
- * Bug: When MindOS is already running (ports 3456 + 8781 bound), invoking
- * `mindos mcp` via an MCP client would start the MCP server in HTTP mode
- * (the default) and crash with EADDRINUSE on port 8781.
- *
- * Root cause: bin/cli.js `mcp` handler did not set MCP_TRANSPORT, so
- * mcp/src/index.ts fell through to the default "http" transport.
- */
-
-const CLI = join(__dirname, '../../bin/cli.js');
-
-const children: ChildProcess[] = [];
-
-afterEach(() => {
-  for (const child of children) {
-    try { child.kill('SIGTERM'); } catch {}
-  }
-  children.length = 0;
-});
-
-function getFreePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const srv = createServer();
-    srv.listen(0, '127.0.0.1', () => {
-      const addr = srv.address();
-      if (addr && typeof addr === 'object') {
-        srv.close(() => resolve(addr.port));
-      } else {
-        reject(new Error('no addr'));
-      }
-    });
-    srv.on('error', reject);
-  });
-}
-
-// ── Core regression test ──────────────────────────────────────────────────
-
-describe('mindos mcp stdio transport (regression)', () => {
-  let blocker: Server | null = null;
-
-  afterEach(async () => {
-    if (blocker) {
-      await new Promise<void>((resolve) => blocker!.close(() => resolve()));
-      blocker = null;
-    }
-  });
-
-  it('starts in stdio mode even when MCP_PORT is already in use', async () => {
-    const port = await getFreePort();
-
-    blocker = createServer();
-    await new Promise<void>((resolve, reject) => {
-      blocker!.listen(port, '127.0.0.1', () => resolve());
-      blocker!.on('error', reject);
-    });
-
-    const proc = spawn(process.execPath, [CLI, 'mcp'], {
-      env: {
-        ...process.env,
-        MCP_TRANSPORT: 'stdio',
-        MCP_PORT: String(port),
-        MINDOS_URL: 'http://localhost:3456',
-      },
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    children.push(proc);
-
-    let stderr = '';
-    proc.stderr?.on('data', (d: Buffer) => { stderr += d.toString(); });
-
-    const response = await new Promise<string>((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error(`No response within 10s. stderr: ${stderr}`)),
-        10_000,
-      );
-      let buf = '';
-      proc.stdout?.on('data', (chunk: Buffer) => {
-        buf += chunk.toString();
-        for (const line of buf.split('\n')) {
-          if (!line.trim()) continue;
-          try {
-            const parsed = JSON.parse(line);
-            if (parsed.id === 1) {
-              clearTimeout(timeout);
-              resolve(line);
-              return;
-            }
-          } catch { /* incomplete */ }
-        }
-      });
-
-      proc.stdin?.write(JSON.stringify({
-        jsonrpc: '2.0', method: 'initialize', id: 1,
-        params: {
-          protocolVersion: '2025-03-26',
-          capabilities: {},
-          clientInfo: { name: 'test', version: '0.0.1' },
-        },
-      }) + '\n');
-    });
-
-    const parsed = JSON.parse(response);
-    expect(parsed).toHaveProperty('result');
-    expect(parsed.result.serverInfo.name).toBe('mindos-mcp-server');
-
-    // Port is STILL occupied by blocker — stdio never tried to bind
-    expect(blocker!.listening).toBe(true);
-    proc.kill('SIGTERM');
-  }, 15_000);
-});
-
-// ── CLI handler env construction (pure logic, no spawning) ────────────────
-
-describe('CLI mcp handler environment construction', () => {
-  /**
-   * Mirrors the logic in bin/cli.js `mcp` handler after the fix.
-   * This is the contract we're verifying.
-   */
-  function buildMcpEnv(incoming: Record<string, string | undefined>) {
-    const env = { ...incoming };
-    if (!env.MCP_TRANSPORT) {
-      env.MCP_TRANSPORT = 'stdio';
-    }
-    const webPort = env.MINDOS_WEB_PORT || '3456';
-    env.MINDOS_URL = env.MINDOS_URL || `http://localhost:${webPort}`;
-    if (env.MCP_TRANSPORT === 'http') {
-      env.MCP_PORT = env.MINDOS_MCP_PORT || '8781';
-    }
-    return env;
-  }
-
-  it('defaults MCP_TRANSPORT to stdio when not set', () => {
-    const env = buildMcpEnv({});
-    expect(env.MCP_TRANSPORT).toBe('stdio');
-  });
-
-  it('preserves MCP_TRANSPORT when caller provides it', () => {
-    const env = buildMcpEnv({ MCP_TRANSPORT: 'http' });
-    expect(env.MCP_TRANSPORT).toBe('http');
-  });
-
-  it('does not set MCP_PORT for stdio transport', () => {
-    const env = buildMcpEnv({});
-    expect(env.MCP_PORT).toBeUndefined();
-  });
-
-  it('sets MCP_PORT for explicit http transport', () => {
-    const env = buildMcpEnv({ MCP_TRANSPORT: 'http' });
-    expect(env.MCP_PORT).toBe('8781');
-  });
-
-  it('respects custom MCP port from config for http', () => {
-    const env = buildMcpEnv({ MCP_TRANSPORT: 'http', MINDOS_MCP_PORT: '9999' });
-    expect(env.MCP_PORT).toBe('9999');
-  });
-
-  it('sets MINDOS_URL from web port when not provided', () => {
-    const env = buildMcpEnv({ MINDOS_WEB_PORT: '4000' });
-    expect(env.MINDOS_URL).toBe('http://localhost:4000');
-  });
-
-  it('preserves MINDOS_URL when already set', () => {
-    const env = buildMcpEnv({ MINDOS_URL: 'http://remote:5000' });
-    expect(env.MINDOS_URL).toBe('http://remote:5000');
-  });
-
-  it('uses default ports when nothing is configured', () => {
-    const env = buildMcpEnv({});
-    expect(env.MCP_TRANSPORT).toBe('stdio');
-    expect(env.MINDOS_URL).toBe('http://localhost:3456');
-    expect(env.MCP_PORT).toBeUndefined();
-  });
-});

package/tests/unit/cli-modules-load.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-
-/**
- * Module-load smoke tests — verify every bin/ JS module can be parsed by
- * the Node.js ESM loader without SyntaxError.
- *
- * Catches issues like premature comment termination (e.g. `MINDOS_*​/` inside
- * a block comment being treated as the closing `*​/`).
- */
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const BIN = path.join(ROOT, 'bin');
-
-/** Collect all .js files under a directory (non-recursive, single level). */
-function listJs(dir: string): string[] {
-  if (!fs.existsSync(dir)) return [];
-  return fs
-    .readdirSync(dir)
-    .filter((f) => f.endsWith('.js'))
-    .sort()
-    .map((f) => path.join(dir, f));
-}
-
-// Gather every module under bin/
-const modules = [
-  ...listJs(BIN),
-  ...listJs(path.join(BIN, 'commands')),
-  ...listJs(path.join(BIN, 'lib')),
-];
-
-describe('bin/ modules can be parsed by Node.js ESM loader', () => {
-  it.each(modules.map((m) => [path.relative(ROOT, m), m]))(
-    '%s loads without SyntaxError',
-    (_label, modulePath) => {
-      // Use a subprocess so a SyntaxError in one module doesn't kill the
-      // test runner. The script simply imports the module and exits.
-      const script = `import(${JSON.stringify('file://' + modulePath)}).then(() => process.exit(0)).catch(e => { process.stderr.write(e.message); process.exit(1); })`;
-
-      try {
-        execFileSync(process.execPath, ['--input-type=module', '-e', script], {
-          encoding: 'utf-8',
-          timeout: 10_000,
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-      } catch (err: unknown) {
-        const e = err as { stderr?: string };
-        const msg = (e.stderr || '').trim();
-        expect.fail(
-          `Module failed to load: ${path.relative(ROOT, modulePath as string)}\n` +
-            `  Error: ${msg}`,
-        );
-      }
-    },
-  );
-
-  it('discovered at least 40 modules (sanity check)', () => {
-    // We currently have ~50 modules; fail if the glob suddenly finds very few,
-    // which would mean the test isn't actually covering anything.
-    expect(modules.length).toBeGreaterThanOrEqual(40);
-  });
-});

package/tests/unit/cli-port.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { createServer, Server } from 'net';
-
-/**
- * Tests for bin/lib/port.js — isPortInUse.
- * Uses real TCP servers to verify port detection accuracy.
- */
-
-// Dynamic import to match ESM module
-async function importPort() {
-  return await import('../../bin/lib/port.js') as {
-    isPortInUse: (port: number) => Promise<boolean>;
-  };
-}
-
-let server: Server | null = null;
-
-afterEach(async () => {
-  if (server) {
-    await new Promise<void>((resolve) => {
-      server!.close(() => resolve());
-    });
-    server = null;
-  }
-});
-
-function startServer(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    server = createServer();
-    server.listen(0, '127.0.0.1', () => {
-      const addr = server!.address();
-      if (addr && typeof addr === 'object') {
-        resolve(addr.port);
-      } else {
-        reject(new Error('Could not get server port'));
-      }
-    });
-    server.on('error', reject);
-  });
-}
-
-describe('isPortInUse', () => {
-  it('returns false for an unused port', async () => {
-    const { isPortInUse } = await importPort();
-    // Use a random high port that's very unlikely to be in use
-    // First find one by binding and immediately releasing
-    const tmpServer = createServer();
-    const port = await new Promise<number>((resolve, reject) => {
-      tmpServer.listen(0, '127.0.0.1', () => {
-        const addr = tmpServer.address();
-        if (addr && typeof addr === 'object') {
-          const p = addr.port;
-          tmpServer.close(() => resolve(p));
-        } else {
-          reject(new Error('no addr'));
-        }
-      });
-    });
-    const result = await isPortInUse(port);
-    expect(result).toBe(false);
-  });
-
-  it('returns true when a server is listening on the port', async () => {
-    const port = await startServer();
-    const { isPortInUse } = await importPort();
-    const result = await isPortInUse(port);
-    expect(result).toBe(true);
-  });
-
-  it('returns false after server is closed', async () => {
-    const port = await startServer();
-    const { isPortInUse } = await importPort();
-
-    // Verify it's in use first
-    expect(await isPortInUse(port)).toBe(true);
-
-    // Close the server
-    await new Promise<void>((resolve) => {
-      server!.close(() => resolve());
-    });
-    server = null;
-
-    // Now should be free
-    const result = await isPortInUse(port);
-    expect(result).toBe(false);
-  });
-});