@nimrobo/mcporter-remote 0.1.0

package/tests/cli-list-verbose-e2e.test.ts

@@ -0,0 +1,83 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { restoreCwdSafely } from './fixtures/test-helpers.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('mcporter list --verbose end-to-end', () => {
+  let tempDir: string;
+  let originalCwd: string;
+  let restoreHomedir: (() => void) | undefined;
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    originalEnv = { ...process.env };
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-cli-verbose-'));
+    const spy = vi.spyOn(os, 'homedir');
+    spy.mockReturnValue(tempDir);
+    restoreHomedir = () => spy.mockRestore();
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+    process.env.HOME = tempDir;
+    process.env.USERPROFILE = tempDir;
+  });
+
+  afterEach(async () => {
+    restoreHomedir?.();
+    delete process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env = { ...originalEnv };
+    restoreCwdSafely(originalCwd);
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    process.exitCode = undefined;
+  });
+
+  it('prints verbose source markers in text output and includes sources in JSON', { concurrent: false }, async () => {
+    const projectConfigPath = path.join(tempDir, 'config', 'mcporter.json');
+    await fs.mkdir(path.dirname(projectConfigPath), { recursive: true });
+    await fs.writeFile(
+      projectConfigPath,
+      JSON.stringify(
+        { imports: ['cursor'], mcpServers: { alpha: { baseUrl: 'https://primary.example.com/mcp' } } },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const cursorConfigPath = path.join(tempDir, '.cursor', 'mcp.json');
+    await fs.mkdir(path.dirname(cursorConfigPath), { recursive: true });
+    await fs.writeFile(
+      cursorConfigPath,
+      JSON.stringify({ mcpServers: { alpha: { baseUrl: 'https://shadow.example.com/mcp' } } }, null, 2),
+      'utf8'
+    );
+
+    const { runCli } = await cliModulePromise;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    // Text mode verbose should render primary + shadowed paths.
+    process.env.MCPORTER_CONFIG = projectConfigPath;
+    await runCli(['list', '--verbose']);
+    const textOutput = logSpy.mock.calls.map((call) => call.join(' ')).join('\n');
+    expect(textOutput).toContain('alpha');
+    expect(textOutput).toContain('(primary');
+    expect(textOutput).toContain('(shadowed by local');
+    expect(textOutput).toContain('cursor');
+
+    logSpy.mockClear();
+
+    // JSON mode with --sources should include the sources array even without --verbose.
+    await runCli(['list', '--json', '--sources']);
+    const jsonPayload = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}');
+    const server = jsonPayload.servers?.find((entry: { name: string }) => entry.name === 'alpha');
+    const sources = (server?.sources ?? []).map((entry: { path: string }) => entry.path.replace('/private', ''));
+    const expected = [projectConfigPath.replace('/private', ''), cursorConfigPath.replace('/private', '')];
+    expect(sources).toEqual(expected);
+
+    logSpy.mockRestore();
+  });
+});

package/tests/cli-oauth-timeout-flag.test.ts

@@ -0,0 +1,94 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { Runtime } from '../src/runtime.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+
+describe('mcporter --oauth-timeout flag', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+  });
+
+  it('passes the override through to createRuntime', async () => {
+    const definition = {
+      name: 'fake',
+      description: 'Fake HTTP server',
+      command: { kind: 'http' as const, url: new URL('https://example.com/mcp') },
+    };
+    const listToolsSpy = vi.fn(async () => []);
+    const runtimeStub: Runtime = {
+      listServers: vi.fn(() => [definition.name]),
+      getDefinitions: vi.fn(() => [definition]),
+      getDefinition: vi.fn(() => definition),
+      registerDefinition: vi.fn(),
+      listTools: listToolsSpy,
+      callTool: vi.fn(),
+      listResources: vi.fn(),
+      connect: vi.fn(),
+      close: vi.fn(async () => {}),
+    };
+    const runtimeModule = await import('../src/runtime.js');
+    const createRuntimeSpy = vi.spyOn(runtimeModule, 'createRuntime').mockResolvedValue(runtimeStub);
+    const { runCli } = await import('../src/cli.js');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const previousNoForce = process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+    try {
+      await runCli(['--oauth-timeout', '250', 'list', 'fake']);
+    } finally {
+      process.env.MCPORTER_NO_FORCE_EXIT = previousNoForce;
+    }
+
+    expect(createRuntimeSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        oauthTimeoutMs: 250,
+      })
+    );
+    expect(listToolsSpy).toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    createRuntimeSpy.mockRestore();
+  });
+
+  it('returns once runtime.listTools surfaces an OAuth timeout error', async () => {
+    const definition = {
+      name: 'fake',
+      description: 'Fake HTTP server',
+      command: { kind: 'http' as const, url: new URL('https://example.com/mcp') },
+    };
+    const runtimeModule = await import('../src/runtime.js');
+    const { OAuthTimeoutError: TimeoutError } = await import('../src/runtime/oauth.js');
+    const failingListTools = vi.fn(async () => {
+      throw new TimeoutError('fake', 500);
+    });
+    const closeSpy = vi.fn(async () => {});
+    const runtimeStub: Runtime = {
+      listServers: vi.fn(() => [definition.name]),
+      getDefinitions: vi.fn(() => [definition]),
+      getDefinition: vi.fn(() => definition),
+      registerDefinition: vi.fn(),
+      listTools: failingListTools,
+      callTool: vi.fn(),
+      listResources: vi.fn(),
+      connect: vi.fn(),
+      close: closeSpy,
+    };
+    const createRuntimeSpy = vi.spyOn(runtimeModule, 'createRuntime').mockResolvedValue(runtimeStub);
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const previousNoForce = process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+    const { runCli } = await import('../src/cli.js');
+
+    try {
+      await runCli(['list', 'fake']);
+      expect(failingListTools).toHaveBeenCalled();
+      expect(closeSpy).toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Tools: <timed out'));
+    } finally {
+      process.env.MCPORTER_NO_FORCE_EXIT = previousNoForce;
+      warnSpy.mockRestore();
+      createRuntimeSpy.mockRestore();
+    }
+  });
+});

package/tests/cli-output-utils.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it, vi } from 'vitest';
+import { printCallOutput } from '../src/cli/output-utils.js';
+import { createCallResult } from '../src/result-utils.js';
+
+describe('printCallOutput format selection', () => {
+  it.each([
+    [
+      'auto prefers json payloads when available',
+      'auto',
+      {
+        content: [
+          { type: 'text', text: 'fallback text' },
+          { type: 'json', json: { source: 'json' } },
+          { type: 'markdown', text: '# heading' },
+        ],
+      },
+      (logged: unknown) => {
+        expect(JSON.parse(String(logged))).toEqual({ source: 'json' });
+      },
+    ],
+    [
+      'text prefers text over markdown/json',
+      'text',
+      {
+        content: [
+          { type: 'text', text: 'plain text wins' },
+          { type: 'markdown', text: '# heading' },
+          { type: 'json', json: { source: 'json' } },
+        ],
+      },
+      (logged: unknown) => {
+        expect(logged).toBe('plain text wins\n# heading');
+      },
+    ],
+    [
+      'markdown prefers markdown content',
+      'markdown',
+      {
+        content: [
+          { type: 'text', text: 'plain text' },
+          { type: 'markdown', text: '## markdown wins' },
+        ],
+      },
+      (logged: unknown) => {
+        expect(logged).toBe('## markdown wins');
+      },
+    ],
+    [
+      'json falls back to raw output when no JSON candidate exists',
+      'json',
+      'raw-only-string',
+      (logged: unknown) => {
+        expect(logged).toBe('raw-only-string');
+      },
+    ],
+    [
+      'raw prints inspect output even when json exists',
+      'raw',
+      { content: [{ type: 'json', json: { id: 1 } }] },
+      (logged: unknown) => {
+        expect(String(logged)).toContain("type: 'json'");
+      },
+    ],
+  ] as const)('%s', (_name, format, raw, assertLogged) => {
+    const wrapped = createCallResult(raw);
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      printCallOutput(wrapped, raw, format);
+      expect(log).toHaveBeenCalledTimes(1);
+      const logged = log.mock.calls[0]?.[0];
+      assertLogged(logged);
+    } finally {
+      log.mockRestore();
+    }
+  });
+});
+
+describe('printCallOutput raw output', () => {
+  it('does not truncate long strings when printing raw output', () => {
+    const longText = 'x'.repeat(15000);
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const raw = { t: longText };
+    const wrapped = createCallResult(raw);
+
+    try {
+      printCallOutput(wrapped, raw, 'raw');
+
+      expect(log).toHaveBeenCalledTimes(1);
+      const logged = log.mock.calls[0]?.[0];
+      expect(typeof logged).toBe('string');
+      expect(logged).not.toContain('... 5000 more characters');
+      expect(logged).toContain(longText.slice(-50));
+    } finally {
+      log.mockRestore();
+    }
+  });
+
+  it('prints nested values beyond the default inspect depth', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const raw = {
+      level1: {
+        level2: {
+          level3: {
+            level4: {
+              level5: {
+                level6: {
+                  leaf: 'done',
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+    const wrapped = createCallResult(raw);
+
+    try {
+      printCallOutput(wrapped, raw, 'raw');
+
+      expect(log).toHaveBeenCalledTimes(1);
+      const logged = log.mock.calls[0]?.[0];
+      expect(typeof logged).toBe('string');
+      expect(logged).toContain("leaf: 'done'");
+    } finally {
+      log.mockRestore();
+    }
+  });
+});

package/tests/cli-regenerate.test.ts

@@ -0,0 +1,261 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { CliArtifactMetadata } from '../src/cli-metadata.js';
+import { metadataPathForArtifact } from '../src/cli-metadata.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+
+const generateCliMock = vi.fn(
+  async (options: {
+    serverRef: string;
+    configPath?: string;
+    rootDir?: string;
+    outputPath?: string;
+    runtime: 'node' | 'bun';
+    bundle?: boolean | string;
+    timeoutMs: number;
+    minify: boolean;
+    compile?: boolean | string;
+  }) => ({
+    outputPath: options.outputPath ?? path.join(os.tmpdir(), 'mcporter-out.ts'),
+    bundlePath: typeof options.bundle === 'string' ? options.bundle : undefined,
+    compilePath: typeof options.compile === 'string' ? options.compile : undefined,
+  })
+);
+
+vi.mock('../src/generate-cli.js', () => ({
+  generateCli: generateCliMock,
+}));
+
+const cliModule = await import('../src/cli.js');
+const { handleGenerateCli, handleInspectCli } = cliModule;
+
+const tmpDir = path.join(os.tmpdir(), 'mcporter-cli-regenerate');
+const describeCliRegenerate = process.platform === 'win32' ? describe.skip : describe;
+
+afterEach(async () => {
+  generateCliMock.mockClear();
+  await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+});
+
+describeCliRegenerate('inspect/generate CLI artifacts', () => {
+  it('normalizes HTTP selectors passed to --command', async () => {
+    const args = ['--command', 'shadcn.io/api/mcp.getComponents', '--name', 'demo', '--output', 'out.ts'];
+    await handleGenerateCli(args, {});
+    expect(generateCliMock).toHaveBeenCalledTimes(1);
+    const invocation = generateCliMock.mock.calls[0]?.[0];
+    expect(invocation?.serverRef).toContain('shadcn.io/api/mcp');
+  });
+
+  it('prints metadata summary for inspect-cli', async () => {
+    const artifactPath = await writeMetadataFixture('binary');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleInspectCli([artifactPath]);
+
+    const printed = logSpy.mock.calls
+      .flat()
+      .map((entry) => String(entry))
+      .join('\n');
+    expect(printed).toContain('Artifact:');
+    expect(printed).toContain('Server: vercel');
+    expect(printed).toContain('mcporter generate-cli --from');
+    expect(printed).toContain('Underlying generate-cli command');
+
+    logSpy.mockRestore();
+  });
+
+  it('replays artifacts via generate-cli --from', async () => {
+    const artifactPath = await writeMetadataFixture('binary');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleGenerateCli(['--from', artifactPath], {});
+
+    expect(generateCliMock).toHaveBeenCalledTimes(1);
+    const invocation = generateCliMock.mock.calls[0]?.[0];
+    expect(invocation).toMatchObject({
+      serverRef: 'vercel',
+      configPath: '/tmp/config/mcporter.json',
+      runtime: 'bun',
+      compile: artifactPath,
+      timeoutMs: 30000,
+      minify: false,
+    });
+    expect(logSpy.mock.calls.some((call) => String(call[0]).includes('Regenerated'))).toBe(true);
+
+    logSpy.mockRestore();
+  });
+
+  it('supports generate-cli --from --dry-run', async () => {
+    const artifactPath = await writeMetadataFixture('bundle');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleGenerateCli(['--from', artifactPath, '--dry-run'], {});
+
+    expect(generateCliMock).not.toHaveBeenCalled();
+    const printed = logSpy.mock.calls
+      .flat()
+      .map((entry) => String(entry))
+      .join('\n');
+    expect(printed).toContain('Dry run');
+    expect(printed).toContain('generate-cli --server');
+
+    logSpy.mockRestore();
+  });
+
+  it('allows positional server references', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleGenerateCli(['linear'], {});
+
+    expect(generateCliMock).toHaveBeenCalledTimes(1);
+    const invocation = generateCliMock.mock.calls[0]?.[0];
+    expect(invocation).toMatchObject({
+      serverRef: 'linear',
+    });
+    expect(logSpy.mock.calls.some((call) => String(call[0]).includes('Generated CLI'))).toBe(true);
+
+    logSpy.mockRestore();
+  });
+
+  it('treats positional http urls as ad-hoc commands', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const commandUrl = 'https://www.shadcn.io/api/mcp';
+
+    await handleGenerateCli([commandUrl, '--name', 'shadcn'], {});
+
+    expect(generateCliMock).toHaveBeenCalledTimes(1);
+    const invocation = generateCliMock.mock.calls[0]?.[0];
+    expect(invocation).toBeDefined();
+    if (!invocation) {
+      throw new Error('generateCli was not invoked with options');
+    }
+    expect(invocation.serverRef).toBe(
+      JSON.stringify({
+        name: 'shadcn',
+        command: commandUrl,
+      })
+    );
+    expect(logSpy.mock.calls.some((call) => String(call[0]).includes('Generated CLI'))).toBe(true);
+
+    logSpy.mockRestore();
+  });
+
+  it('falls back to legacy metadata files when present', async () => {
+    await fs.mkdir(tmpDir, { recursive: true });
+    const artifactPath = path.join(tmpDir, 'legacy-artifact');
+    const script = '#!/usr/bin/env node\nconsole.log("noop");\n';
+    await fs.writeFile(artifactPath, script, 'utf8');
+    await fs.chmod(artifactPath, 0o755);
+
+    const metadata: CliArtifactMetadata = {
+      schemaVersion: 1,
+      generatedAt: new Date().toISOString(),
+      generator: { name: 'mcporter', version: '0.1.0' },
+      server: {
+        name: 'legacy',
+        source: { kind: 'local', path: '/tmp/config/mcporter.json' },
+        definition: {
+          name: 'legacy',
+          description: 'Legacy test server',
+          command: { kind: 'http', url: 'https://example.com/mcp' },
+        },
+      },
+      artifact: {
+        path: artifactPath,
+        kind: 'template',
+      },
+      invocation: {
+        serverRef: 'legacy',
+        configPath: '/tmp/config/mcporter.json',
+        runtime: 'node',
+        timeoutMs: 30_000,
+        minify: false,
+      },
+    };
+    await fs.writeFile(metadataPathForArtifact(artifactPath), JSON.stringify(metadata, null, 2), 'utf8');
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await handleInspectCli([artifactPath]);
+    expect(logSpy.mock.calls.some((call) => String(call[0]).includes('legacy'))).toBe(true);
+    logSpy.mockRestore();
+  });
+});
+
+type ArtifactKind = 'template' | 'bundle' | 'binary';
+
+async function writeMetadataFixture(kind: ArtifactKind): Promise<string> {
+  await fs.mkdir(tmpDir, { recursive: true });
+  const artifactPath = path.join(tmpDir, `artifact-${kind}`);
+
+  const definition = {
+    name: 'vercel',
+    description: 'Vercel MCP',
+    command: {
+      kind: 'http' as const,
+      url: 'https://mcp.vercel.com',
+      headers: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: metadata preserves env-placeholder format
+        Authorization: 'Bearer ${VERCEL_TOKEN}',
+      },
+    },
+    env: undefined,
+    auth: 'oauth',
+    tokenCacheDir: '/tmp/tokens',
+    clientName: 'mcporter-cli',
+    oauthRedirectUrl: 'http://localhost:3000/callback',
+  };
+
+  const invocation: CliArtifactMetadata['invocation'] = {
+    serverRef: 'vercel',
+    configPath: '/tmp/config/mcporter.json',
+    rootDir: '/workspace',
+    runtime: 'bun',
+    outputPath: undefined,
+    bundle: kind === 'bundle' ? artifactPath : undefined,
+    compile: kind === 'binary' ? artifactPath : undefined,
+    timeoutMs: 30000,
+    minify: false,
+  };
+
+  const metadata: CliArtifactMetadata = {
+    schemaVersion: 1 as const,
+    generatedAt: new Date().toISOString(),
+    generator: { name: 'mcporter', version: '0.1.0' },
+    server: {
+      name: 'vercel',
+      source: { kind: 'local' as const, path: '/tmp/config/mcporter.json' },
+      definition,
+    },
+    artifact: {
+      path: artifactPath,
+      kind,
+    },
+    invocation,
+  };
+
+  const script = `#!/usr/bin/env node
+const payload = ${JSON.stringify(metadata)};
+if (process.argv[2] === '__mcporter_inspect') {
+  const artifactPath = process.argv[1] || payload.artifact.path;
+  payload.artifact.path = artifactPath;
+  payload.artifact.kind = ${JSON.stringify(kind)};
+  if (${JSON.stringify(kind)} === 'template') {
+    payload.invocation.outputPath = payload.invocation.outputPath || artifactPath;
+  } else if (${JSON.stringify(kind)} === 'bundle') {
+    payload.invocation.bundle = payload.invocation.bundle || artifactPath;
+  } else if (${JSON.stringify(kind)} === 'binary') {
+    payload.invocation.compile = payload.invocation.compile || artifactPath;
+  }
+  console.log(JSON.stringify(payload));
+  process.exit(0);
+}
+console.log('mock cli');
+`;
+
+  await fs.writeFile(artifactPath, script, 'utf8');
+  await fs.chmod(artifactPath, 0o755);
+  return artifactPath;
+}

package/tests/cli-version.test.ts

@@ -0,0 +1,24 @@
+import fsPromises from 'node:fs/promises';
+import { describe, expect, it, vi } from 'vitest';
+
+import { MCPORTER_VERSION } from '../src/runtime.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('mcporter --version', () => {
+  it('reads package.json when available, falling back to runtime version on failure', async () => {
+    const { runCli } = await cliModulePromise;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const readSpy = vi.spyOn(fsPromises, 'readFile').mockRejectedValueOnce(new Error('missing'));
+
+    await runCli(['--version']);
+
+    expect(logSpy).toHaveBeenCalledWith(MCPORTER_VERSION);
+    expect(readSpy).toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    readSpy.mockRestore();
+    process.exitCode = undefined;
+  });
+});

package/tests/config-add-dry-run.test.ts

@@ -0,0 +1,45 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleAddCommand } from '../src/cli/config/add.js';
+import type { LoadConfigOptions } from '../src/config.js';
+
+describe('config add --dry-run', () => {
+  let tempDir: string;
+  let loadOptions: LoadConfigOptions;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-add-'));
+    loadOptions = { rootDir: tempDir };
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('prints entry without writing config when dry-run is set', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleAddCommand({ loadOptions } as never, [
+      'linear',
+      'https://linear.app/mcp',
+      '--description',
+      'test',
+      '--dry-run',
+    ]);
+
+    const outputs = logSpy.mock.calls.map((call) => call[0]).join('\n');
+    logSpy.mockRestore();
+
+    const configPath = path.join(tempDir, 'config', 'mcporter.json');
+    const exists = await fs
+      .access(configPath)
+      .then(() => true)
+      .catch(() => false);
+    expect(exists).toBe(false);
+    expect(outputs).toContain('(dry-run) No changes were written.');
+    expect(outputs).toContain('"linear"');
+  });
+});