@nimrobo/mcporter-remote 0.1.0

package/tests/cli-auth.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { ServerDefinition } from '../src/config.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+const createRuntimeDouble = () => {
+  const definitions = new Map<string, Record<string, unknown>>();
+  const registerDefinition = vi.fn((definition: Record<string, unknown>) => {
+    definitions.set(definition.name as string, { ...definition });
+  });
+  const getDefinition = vi.fn((name: string) => {
+    const definition = definitions.get(name);
+    if (!definition) {
+      throw new Error(`Unknown MCP server '${name}'.`);
+    }
+    return definition;
+  });
+  const listTools = vi.fn().mockResolvedValue([{ name: 'ok' }]);
+  const runtime = {
+    registerDefinition,
+    getDefinition,
+    getDefinitions: () => Array.from(definitions.values()),
+    listTools,
+  } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+  return { runtime, listTools };
+};
+
+describe('mcporter auth ad-hoc support', () => {
+  it('registers ad-hoc HTTP servers via --http-url', async () => {
+    const { handleAuth } = await cliModulePromise;
+    const { runtime, listTools } = createRuntimeDouble();
+
+    await handleAuth(runtime, ['--http-url', 'https://mcp.deepwiki.com/sse']);
+
+    expect(listTools).toHaveBeenCalledWith('mcp-deepwiki-com-sse', { autoAuthorize: true });
+  });
+
+  it('accepts bare URLs as the auth target', async () => {
+    const { handleAuth } = await cliModulePromise;
+    const { runtime, listTools } = createRuntimeDouble();
+
+    await handleAuth(runtime, ['https://mcp.supabase.com/mcp']);
+
+    expect(listTools).toHaveBeenCalledWith('mcp-supabase-com-mcp', { autoAuthorize: true });
+  });
+
+  it('reuses configured servers when auth target is a URL', async () => {
+    const { handleAuth } = await cliModulePromise;
+    const definition = {
+      name: 'vercel',
+      command: { kind: 'http', url: new URL('https://mcp.vercel.com') },
+      tokenCacheDir: '/tmp/cache',
+    } as ServerDefinition;
+    const registerDefinition = vi.fn();
+    const listTools = vi.fn().mockResolvedValue([{ name: 'ok' }]);
+    const runtime = {
+      getDefinitions: () => [definition],
+      registerDefinition,
+      listTools,
+      getDefinition: () => definition,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    await handleAuth(runtime, ['https://mcp.vercel.com']);
+
+    expect(listTools).toHaveBeenCalledWith('vercel', { autoAuthorize: true });
+    expect(registerDefinition).not.toHaveBeenCalled();
+  });
+
+  it('emits JSON envelopes when auth fails and --json is provided', async () => {
+    const { handleAuth } = await cliModulePromise;
+    const definition = {
+      name: 'linear',
+      command: { kind: 'http', url: new URL('https://mcp.linear.app/mcp') },
+    } as ServerDefinition;
+    const runtime = {
+      getDefinitions: () => [definition],
+      registerDefinition: vi.fn(),
+      listTools: vi.fn().mockRejectedValue(new Error('fetch failed: connect ECONNREFUSED 127.0.0.1:9000')),
+      getDefinition: () => definition,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(handleAuth(runtime, ['linear', '--json'])).resolves.toBeUndefined();
+
+    expect(process.exitCode).toBe(1);
+    const payload = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}');
+    expect(payload.server).toBe('linear');
+    expect(payload.issue.kind).toBe('offline');
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    process.exitCode = undefined;
+  });
+});

package/tests/cli-call-args.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CliUsageError } from '../src/cli/errors.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('CLI call argument parsing', () => {
+  it('treats quoted stdio commands as ad-hoc servers without --stdio', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    const parsed = parseCallArguments(['npx -y vercel-domains-mcp', 'domain=answeroverflow.com']);
+    expect(parsed.selector).toBeUndefined();
+    expect(parsed.ephemeral?.stdioCommand).toBe('npx -y vercel-domains-mcp');
+    expect(parsed.args).toEqual({ domain: 'answeroverflow.com' });
+  });
+
+  it('falls back to default call timeout when env is empty', async () => {
+    vi.stubEnv('MCPORTER_CALL_TIMEOUT', '');
+    try {
+      const { resolveCallTimeout } = await cliModulePromise;
+      expect(resolveCallTimeout()).toBe(60_000);
+    } finally {
+      vi.unstubAllEnvs();
+    }
+  });
+
+  it('accepts server and tool as separate positional arguments', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    const parsed = parseCallArguments(['chrome-devtools', 'list_pages']);
+    expect(parsed.selector).toBe('chrome-devtools');
+    expect(parsed.tool).toBe('list_pages');
+    expect(parsed.args).toEqual({});
+  });
+
+  it('captures timeout flag values', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    const parsed = parseCallArguments(['chrome-devtools', '--timeout', '2500', '--tool', 'list_pages']);
+    expect(parsed.selector).toBe('chrome-devtools');
+    expect(parsed.tool).toBe('list_pages');
+    expect(parsed.timeoutMs).toBe(2500);
+  });
+
+  it('parses function-call syntax with named arguments', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    const parsed = parseCallArguments(['linear.create_comment(issueId: "ISSUE-123", notify: false)']);
+    expect(parsed.server).toBe('linear');
+    expect(parsed.tool).toBe('create_comment');
+    expect(parsed.args).toEqual({ issueId: 'ISSUE-123', notify: false });
+  });
+
+  it('parses HTTP call expressions with named arguments', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    const parsed = parseCallArguments(['https://www.shadcn.io/api/mcp.getComponent(component: "vortex")']);
+    expect(parsed.server).toBe('https://www.shadcn.io/api/mcp');
+    expect(parsed.tool).toBe('getComponent');
+    expect(parsed.args).toEqual({ component: 'vortex' });
+  });
+
+  it('rejects conflicting server names between flags and call syntax', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    expect(() => parseCallArguments(['--server', 'github', 'linear.create_comment(issueId: "123")'])).toThrow(
+      /Conflicting server names/
+    );
+  });
+
+  it('surfaces a helpful error when function-call syntax cannot be parsed', async () => {
+    const { parseCallArguments } = await cliModulePromise;
+    expect(() => parseCallArguments(['linear.create_comment(oops)'])).toThrow(CliUsageError);
+  });
+});

package/tests/cli-call-errors.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from 'vitest';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('CLI call error reporting', () => {
+  it('reports connection issues and emits JSON payloads when requested', async () => {
+    const { handleCall } = await cliModulePromise;
+    const callTool = vi.fn().mockRejectedValue(new Error('SSE error: Non-200 status code (401)'));
+    const runtime = {
+      callTool,
+      close: vi.fn().mockResolvedValue(undefined),
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await handleCall(runtime, ['github.list_repos', '--output', 'json']);
+
+    const payload = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}');
+    expect(payload.issue?.kind).toBe('auth');
+    expect(errorSpy.mock.calls.some((call) => call.join(' ').includes('Authorization required'))).toBe(true);
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+});

package/tests/cli-call-execution.test.ts

@@ -0,0 +1,279 @@
+import { describe, expect, it, vi } from 'vitest';
+import { resolveEphemeralServer } from '../src/cli/adhoc-server.js';
+import type { ServerDefinition } from '../src/config.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('CLI call execution behavior', () => {
+  it('auto-selects the sole tool when omitted', async () => {
+    const toolName = 'list_issues';
+    const { handleCall } = await cliModulePromise;
+    const { runtime, callTool } = createRuntimeStub(
+      {
+        linear: [
+          {
+            name: toolName,
+            description: 'List issues',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                limit: { type: 'number' },
+              },
+              required: [],
+            },
+          },
+        ],
+      },
+      {
+        definitions: [
+          {
+            name: 'linear',
+            command: { kind: 'stdio', command: 'linear', args: [], cwd: process.cwd() },
+            source: { kind: 'local', path: '<test>' },
+          },
+        ],
+      }
+    );
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await handleCall(runtime, ['linear', 'limit=5']);
+    expect(callTool).toHaveBeenCalledWith('linear', toolName, expect.objectContaining({ args: { limit: 5 } }));
+    logSpy.mockRestore();
+  });
+
+  it('still requires an explicit tool when multiple are available', async () => {
+    const { handleCall } = await cliModulePromise;
+    const { runtime, callTool } = createRuntimeStub(
+      {
+        linear: [
+          { name: 'list_issues', inputSchema: {} },
+          { name: 'create_issue', inputSchema: {} },
+        ],
+      },
+      {
+        definitions: [
+          {
+            name: 'linear',
+            command: { kind: 'stdio', command: 'linear', args: [], cwd: process.cwd() },
+            source: { kind: 'local', path: '<test>' },
+          },
+        ],
+      }
+    );
+    await expect(handleCall(runtime, ['linear'])).rejects.toThrow(
+      'Missing tool name. Provide it via <server>.<tool> or --tool.'
+    );
+    expect(callTool).not.toHaveBeenCalled();
+  });
+
+  it('runs quoted stdio commands without --stdio and infers the tool automatically', async () => {
+    const command = 'npx -y vercel-domains-mcp';
+    const { name: adhocName } = resolveEphemeralServer({ stdioCommand: command });
+    const { handleCall } = await cliModulePromise;
+    const { runtime, callTool } = createRuntimeStub({
+      [adhocName]: [
+        {
+          name: 'getDomainAvailability',
+          inputSchema: {
+            type: 'object',
+            properties: { domain: { type: 'string' } },
+            required: ['domain'],
+          },
+        },
+      ],
+    });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await handleCall(runtime, [command, 'domain=answeroverflow.com']);
+    expect(callTool).toHaveBeenCalledWith(
+      adhocName,
+      'getDomainAvailability',
+      expect.objectContaining({
+        args: { domain: 'answeroverflow.com' },
+      })
+    );
+    logSpy.mockRestore();
+  });
+
+  it('aborts long-running tools when the timeout elapses', async () => {
+    vi.useFakeTimers();
+    try {
+      const { handleCall } = await cliModulePromise;
+      const close = vi.fn().mockResolvedValue(undefined);
+      const runtime = {
+        callTool: () =>
+          new Promise((resolve) => {
+            setTimeout(() => resolve('done'), 1000);
+          }),
+        close,
+      };
+      const promise = handleCall(runtime as never, ['chrome-devtools.list_pages', '--timeout', '10']);
+      const expectation = expect(promise).rejects.toThrow('Call to chrome-devtools.list_pages timed out after 10ms.');
+      await vi.runOnlyPendingTimersAsync();
+      await expectation;
+      expect(close).toHaveBeenCalledWith('chrome-devtools');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('auto-corrects near-miss tool names', async () => {
+    const { handleCall } = await cliModulePromise;
+    const callTool = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('MCP error -32602: Tool listIssues not found'))
+      .mockResolvedValueOnce({ ok: true });
+    const listTools = vi.fn().mockResolvedValue([{ name: 'list_issues' }]);
+    const runtime = {
+      callTool,
+      listTools,
+      close: vi.fn().mockResolvedValue(undefined),
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleCall(runtime, ['linear.listIssues']);
+
+    const notes = logSpy.mock.calls.map((call) => call.join(' '));
+    expect(notes.some((line) => line.includes('Auto-corrected tool call to linear.list_issues'))).toBe(true);
+    expect(callTool).toHaveBeenCalledTimes(2);
+    expect(callTool).toHaveBeenNthCalledWith(1, 'linear', 'listIssues', expect.objectContaining({ args: {} }));
+    expect(callTool).toHaveBeenNthCalledWith(2, 'linear', 'list_issues', expect.objectContaining({ args: {} }));
+    expect(listTools).toHaveBeenCalledWith('linear', { autoAuthorize: true, includeSchema: false });
+
+    logSpy.mockRestore();
+  });
+
+  it('suggests similar tool names when the match is uncertain', async () => {
+    const { handleCall } = await cliModulePromise;
+    const callTool = vi.fn().mockRejectedValue(new Error('MCP error -32602: Tool listIssues not found'));
+    const listTools = vi.fn().mockResolvedValue([{ name: 'list_issue_statuses' }]);
+    const runtime = {
+      callTool,
+      listTools,
+      close: vi.fn().mockResolvedValue(undefined),
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(handleCall(runtime, ['linear.listIssues'])).rejects.toThrow('listIssues not found');
+
+    const messages = errorSpy.mock.calls.map((call) => call.join(' '));
+    expect(messages.some((line) => line.includes('Did you mean linear.list_issue_statuses'))).toBe(true);
+
+    errorSpy.mockRestore();
+  });
+
+  it("falls back to 'list' output when calling a missing help tool", async () => {
+    const listModule = await import('../src/cli/list-command.js');
+    const listSpy = vi.spyOn(listModule, 'handleList').mockResolvedValue(undefined);
+    const { handleCall } = await cliModulePromise;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const definition: ServerDefinition = {
+      name: 'chrome-devtools',
+      description: 'Chrome DevTools MCP server',
+      command: { kind: 'stdio', command: 'chrome-devtools', args: [], cwd: process.cwd() },
+      source: { kind: 'local', path: '<test>' },
+    };
+    const { runtime, callTool } = createRuntimeStub(
+      {
+        'chrome-devtools': [
+          {
+            name: 'take_snapshot',
+            description: 'Takes a snapshot.',
+            inputSchema: {
+              type: 'object',
+              properties: { url: { type: 'string' } },
+              required: ['url'],
+            },
+          },
+        ],
+      },
+      { definitions: [definition] }
+    );
+
+    try {
+      await handleCall(runtime, ['chrome-devtools.help']);
+      expect(listSpy).toHaveBeenNthCalledWith(1, runtime, ['chrome-devtools']);
+      expect(
+        logSpy.mock.calls.some((call) => call.some((line) => line.includes("does not expose a 'help' tool")))
+      ).toBe(true);
+      logSpy.mockClear();
+      await handleCall(runtime, ['chrome-devtools.help', '--output', 'json']);
+      expect(listSpy).toHaveBeenNthCalledWith(2, runtime, ['chrome-devtools', '--json']);
+      expect(callTool).not.toHaveBeenCalled();
+    } finally {
+      listSpy.mockRestore();
+      logSpy.mockRestore();
+    }
+  });
+
+  it('treats list_tools selector as a shortcut for mcporter list', async () => {
+    const listModule = await import('../src/cli/list-command.js');
+    const listSpy = vi.spyOn(listModule, 'handleList').mockResolvedValue(undefined);
+    const { handleCall } = await cliModulePromise;
+    const definition: ServerDefinition = {
+      name: 'chrome-devtools',
+      description: 'Chrome DevTools MCP server',
+      command: { kind: 'stdio', command: 'chrome-devtools', args: [], cwd: process.cwd() },
+      source: { kind: 'local', path: '<test>' },
+    };
+    const { runtime, callTool } = createRuntimeStub({ 'chrome-devtools': [] }, { definitions: [definition] });
+
+    try {
+      await handleCall(runtime, ['chrome-devtools.list_tools']);
+      await handleCall(runtime, ['chrome-devtools.list_tools', '--output', 'json']);
+      expect(listSpy).toHaveBeenNthCalledWith(1, runtime, ['chrome-devtools']);
+      expect(listSpy).toHaveBeenNthCalledWith(2, runtime, ['chrome-devtools', '--json']);
+      expect(callTool).not.toHaveBeenCalled();
+    } finally {
+      listSpy.mockRestore();
+    }
+  });
+});
+
+function createRuntimeStub(
+  toolCatalog: Record<
+    string,
+    Array<{
+      name: string;
+      description?: string;
+      inputSchema?: unknown;
+    }>
+  >,
+  options: { definitions?: ServerDefinition[] } = {}
+): {
+  runtime: Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+  callTool: ReturnType<typeof vi.fn>;
+  listTools: ReturnType<typeof vi.fn>;
+} {
+  const definitions = new Map<string, ServerDefinition>();
+  for (const entry of options.definitions ?? []) {
+    definitions.set(entry.name, entry);
+  }
+  const callTool = vi.fn().mockResolvedValue({ ok: true });
+  const listTools = vi.fn().mockImplementation(async (server: string) => {
+    const tools = toolCatalog[server];
+    if (!tools) {
+      throw new Error(`Unknown MCP server '${server}'.`);
+    }
+    return tools;
+  });
+  const close = vi.fn().mockResolvedValue(undefined);
+  const runtime = {
+    getDefinitions: () => [...definitions.values()],
+    getDefinition: vi.fn().mockImplementation((name: string) => {
+      const definition = definitions.get(name);
+      if (!definition) {
+        throw new Error(`Unknown MCP server '${name}'.`);
+      }
+      return definition;
+    }),
+    registerDefinition: vi.fn().mockImplementation((definition: ServerDefinition) => {
+      definitions.set(definition.name, definition);
+    }),
+    listTools,
+    callTool,
+    close,
+  } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+  return { runtime, callTool, listTools };
+}

package/tests/cli-call-help.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('mcporter call help shortcut', () => {
+  let previousNoForceExit: string | undefined;
+
+  beforeEach(() => {
+    previousNoForceExit = process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+    if (previousNoForceExit === undefined) {
+      delete process.env.MCPORTER_NO_FORCE_EXIT;
+    } else {
+      process.env.MCPORTER_NO_FORCE_EXIT = previousNoForceExit;
+    }
+  });
+
+  it('prints call-specific help when --help is used', async () => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(['call', '--help']);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage: mcporter call'));
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('prints call-specific help when the bare help token follows the command', async () => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(['call', 'help']);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage: mcporter call'));
+    expect(process.exitCode).toBe(0);
+  });
+});

package/tests/cli-command-inference.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { inferCommandRouting } from '../src/cli/command-inference.js';
+
+const definitions = [
+  { name: 'firecrawl', description: '', command: { kind: 'http' as const, url: new URL('https://example.com') } },
+  { name: 'vercel', description: '', command: { kind: 'http' as const, url: new URL('https://api.vercel.com') } },
+];
+
+describe('command inference', () => {
+  it('routes bare server names to list', () => {
+    const result = inferCommandRouting('firecrawl', ['--schema'], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: ['firecrawl', '--schema'] });
+  });
+
+  it('respects explicit list command tokens', () => {
+    const result = inferCommandRouting('list', [], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: [] });
+  });
+
+  it('treats describe as a hidden list alias', () => {
+    const result = inferCommandRouting('describe', ['chrome-devtools'], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: ['chrome-devtools'] });
+  });
+
+  it('treats list-tools as a hidden list alias', () => {
+    const result = inferCommandRouting('list-tools', ['linear'], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: ['linear'] });
+  });
+
+  it('auto-corrects close server names', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const result = inferCommandRouting('vercek', [], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: ['vercel'] });
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Auto-corrected server name to vercel'));
+    logSpy.mockRestore();
+  });
+
+  it('routes HTTP URLs to list for ad-hoc mode', () => {
+    const result = inferCommandRouting('https://mcp.deepwiki.com/sse', [], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: ['https://mcp.deepwiki.com/sse'] });
+  });
+
+  it('routes scheme-less HTTP URLs to list for ad-hoc mode', () => {
+    const result = inferCommandRouting('shadcn.io/api/mcp', [], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'list', args: ['shadcn.io/api/mcp'] });
+  });
+
+  it('routes HTTP tool selectors directly to call', () => {
+    const token = 'https://api.example.com/mcp.getStatus';
+    const result = inferCommandRouting(token, ['limit=1'], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'call', args: [token, 'limit=1'] });
+  });
+
+  it('routes HTTP tool expressions with arguments directly to call', () => {
+    const token = 'https://api.example.com/mcp.getStatus(component: "foo")';
+    const result = inferCommandRouting(token, [], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'call', args: [token] });
+  });
+
+  it('suggests names when edit distance is large', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const result = inferCommandRouting('unknown', [], definitions);
+    expect(result).toEqual({ kind: 'abort', exitCode: 1 });
+    expect(errorSpy).toHaveBeenCalled();
+    errorSpy.mockRestore();
+  });
+
+  it('treats dotted selectors as call expressions', () => {
+    const result = inferCommandRouting('firecrawl.scrape', ['--foo'], definitions);
+    expect(result).toEqual({ kind: 'command', command: 'call', args: ['firecrawl.scrape', '--foo'] });
+  });
+});