@vellumai/assistant 0.3.21 → 0.3.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "type": "module",
   "bin": {
     "vellum": "./src/index.ts"

package/src/__tests__/mcp-cli.test.ts

@@ -0,0 +1,141 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+
+const CLI = join(import.meta.dir, '..', 'index.ts');
+
+let testDataDir: string;
+let configPath: string;
+
+function runMcpList(args: string[] = []): { stdout: string; exitCode: number } {
+  const result = spawnSync('bun', ['run', CLI, 'mcp', 'list', ...args], {
+    encoding: 'utf-8',
+    timeout: 10_000,
+    env: { ...process.env, BASE_DATA_DIR: testDataDir },
+  });
+  return {
+    stdout: (result.stdout ?? '').toString(),
+    exitCode: result.status ?? 1,
+  };
+}
+
+function writeConfig(config: Record<string, unknown>): void {
+  writeFileSync(configPath, JSON.stringify(config), 'utf-8');
+}
+
+describe('vellum mcp list', () => {
+  beforeAll(() => {
+    testDataDir = join(tmpdir(), `vellum-mcp-cli-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const workspaceDir = join(testDataDir, '.vellum', 'workspace');
+    mkdirSync(workspaceDir, { recursive: true });
+    configPath = join(workspaceDir, 'config.json');
+    writeConfig({});
+  });
+
+  afterAll(() => {
+    rmSync(testDataDir, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    writeConfig({});
+  });
+
+  test('shows message when no MCP servers configured', () => {
+    const { stdout, exitCode } = runMcpList();
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain('No MCP servers configured');
+  });
+
+  test('lists configured servers', () => {
+    writeConfig({
+      mcp: {
+        servers: {
+          'test-server': {
+            transport: { type: 'streamable-http', url: 'https://example.com/mcp' },
+            enabled: true,
+            defaultRiskLevel: 'medium',
+          },
+        },
+      },
+    });
+
+    const { stdout, exitCode } = runMcpList();
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain('1 MCP server(s) configured');
+    expect(stdout).toContain('test-server');
+    expect(stdout).toContain('streamable-http');
+    expect(stdout).toContain('https://example.com/mcp');
+    expect(stdout).toContain('medium');
+  });
+
+  test('shows disabled status', () => {
+    writeConfig({
+      mcp: {
+        servers: {
+          'disabled-server': {
+            transport: { type: 'sse', url: 'https://example.com/sse' },
+            enabled: false,
+            defaultRiskLevel: 'high',
+          },
+        },
+      },
+    });
+
+    const { stdout, exitCode } = runMcpList();
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain('disabled');
+  });
+
+  test('shows stdio command info', () => {
+    writeConfig({
+      mcp: {
+        servers: {
+          'stdio-server': {
+            transport: { type: 'stdio', command: 'npx', args: ['-y', 'some-mcp-server'] },
+            enabled: true,
+            defaultRiskLevel: 'low',
+          },
+        },
+      },
+    });
+
+    const { stdout, exitCode } = runMcpList();
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain('stdio-server');
+    expect(stdout).toContain('stdio');
+    expect(stdout).toContain('npx -y some-mcp-server');
+    expect(stdout).toContain('low');
+  });
+
+  test('--json outputs valid JSON', () => {
+    writeConfig({
+      mcp: {
+        servers: {
+          'json-server': {
+            transport: { type: 'streamable-http', url: 'https://example.com/mcp' },
+            enabled: true,
+            defaultRiskLevel: 'high',
+          },
+        },
+      },
+    });
+
+    const { stdout, exitCode } = runMcpList(['--json']);
+    expect(exitCode).toBe(0);
+    const parsed = JSON.parse(stdout);
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].id).toBe('json-server');
+    expect(parsed[0].transport.url).toBe('https://example.com/mcp');
+  });
+
+  test('--json outputs empty array when no servers', () => {
+    const { stdout, exitCode } = runMcpList(['--json']);
+    expect(exitCode).toBe(0);
+    const parsed = JSON.parse(stdout);
+    expect(parsed).toEqual([]);
+  });
+});

package/src/cli/mcp.ts

@@ -1,6 +1,6 @@
 import type { Command } from 'commander';
 
-import { loadRawConfig } from '../config/loader.js';
+import { loadRawConfig, saveRawConfig } from '../config/loader.js';
 import type { McpConfig, McpServerConfig } from '../config/mcp-schema.js';
 import { getCliLogger } from '../util/logger.js';
 
@@ -29,13 +29,19 @@ export function registerMcpCommand(program: Command): void {
       }
 
       if (opts.json) {
-        const result = entries.map(([id, config]) => ({ id, ...config }));
+        const result = entries
+          .filter(([, config]) => config && typeof config === 'object')
+          .map(([id, config]) => ({ id, ...config }));
         process.stdout.write(JSON.stringify(result, null, 2) + '\n');
         return;
       }
 
       log.info(`${entries.length} MCP server(s) configured:\n`);
       for (const [id, cfg] of entries) {
+        if (!cfg || typeof cfg !== 'object') {
+          log.info(`  ${id} (invalid config — skipped)\n`);
+          continue;
+        }
         const enabled = cfg.enabled !== false;
         const transport = cfg.transport;
         const risk = cfg.defaultRiskLevel ?? 'high';
@@ -55,4 +61,70 @@ export function registerMcpCommand(program: Command): void {
         log.info('');
       }
     });
+
+  mcp
+    .command('add <name>')
+    .description('Add an MCP server configuration')
+    .requiredOption('-t, --transport-type <type>', 'Transport type: stdio, sse, or streamable-http')
+    .option('-u, --url <url>', 'Server URL (for sse/streamable-http)')
+    .option('-c, --command <cmd>', 'Command to run (for stdio)')
+    .option('-a, --args <args...>', 'Command arguments (for stdio)')
+    .option('-r, --risk <level>', 'Default risk level: low, medium, or high', 'high')
+    .option('--disabled', 'Add as disabled')
+    .action((name: string, opts: {
+      transportType: string;
+      url?: string;
+      command?: string;
+      args?: string[];
+      risk: string;
+      disabled?: boolean;
+    }) => {
+      const raw = loadRawConfig();
+      if (!raw.mcp) raw.mcp = { servers: {} };
+      const mcpConfig = raw.mcp as Record<string, unknown>;
+      if (!mcpConfig.servers) mcpConfig.servers = {};
+      const servers = mcpConfig.servers as Record<string, unknown>;
+
+      if (servers[name]) {
+        log.error(`MCP server "${name}" already exists. Remove it first with: vellum mcp remove ${name}`);
+        return;
+      }
+
+      let transport: Record<string, unknown>;
+      switch (opts.transportType) {
+        case 'stdio':
+          if (!opts.command) {
+            log.error('--command is required for stdio transport');
+            return;
+          }
+          transport = { type: 'stdio', command: opts.command, args: opts.args ?? [] };
+          break;
+        case 'sse':
+        case 'streamable-http':
+          if (!opts.url) {
+            log.error(`--url is required for ${opts.transportType} transport`);
+            return;
+          }
+          transport = { type: opts.transportType, url: opts.url };
+          break;
+        default:
+          log.error(`Unknown transport type: ${opts.transportType}. Must be stdio, sse, or streamable-http`);
+          return;
+      }
+
+      if (!['low', 'medium', 'high'].includes(opts.risk)) {
+        log.error(`Invalid risk level: ${opts.risk}. Must be low, medium, or high`);
+        return;
+      }
+
+      servers[name] = {
+        transport,
+        enabled: !opts.disabled,
+        defaultRiskLevel: opts.risk,
+      };
+
+      saveRawConfig(raw);
+      log.info(`Added MCP server "${name}" (${opts.transportType})`);
+      log.info('Restart the daemon for changes to take effect: vellum daemon restart');
+    });
 }