@critical-path/mcp 0.7.0 → 0.9.0

package/src/bin/args.ts

@@ -0,0 +1,50 @@
+export interface CliOptions {
+  db?: string;
+  api?: string;
+  headers: string[];
+  help?: boolean;
+}
+
+export function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = { headers: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--db' && args[i + 1]) {
+      options.db = args[++i];
+    } else if (arg === '--api' && args[i + 1]) {
+      options.api = args[++i];
+    } else if (arg === '--header' && args[i + 1]) {
+      options.headers.push(args[++i]);
+    }
+  }
+  return options;
+}
+
+/**
+ * Builds request headers for `--api` mode from repeated `--header "Name: value"` flags and the
+ * `CRITICAL_PATH_API_TOKEN` environment variable (sent as `Authorization: Bearer <token>`).
+ * Prefer the environment variable for secrets: command-line flags are visible in process lists.
+ */
+export function buildApiHeaders(headerFlags: string[], env: Record<string, string | undefined>): Record<string, string> {
+  const headers: Record<string, string> = {};
+  if (env.CRITICAL_PATH_API_TOKEN) {
+    headers['Authorization'] = `Bearer ${env.CRITICAL_PATH_API_TOKEN}`;
+  }
+  for (const flag of headerFlags) {
+    const separator = flag.indexOf(':');
+    if (separator <= 0) {
+      throw new Error(`Invalid --header "${flag}". Expected "Name: value".`);
+    }
+    headers[flag.slice(0, separator).trim()] = flag.slice(separator + 1).trim();
+  }
+  return headers;
+}
+
+/** True when credentials would be sent in cleartext to a host other than this machine. */
+export function isInsecureRemote(apiUrl: string): boolean {
+  const url = new URL(apiUrl);
+  const localHosts = ['localhost', '127.0.0.1', '[::1]'];
+  return url.protocol === 'http:' && !localHosts.includes(url.hostname) && !url.hostname.endsWith('.localhost');
+}

package/src/bin/cli.ts

@@ -2,21 +2,7 @@
 import { CriticalPathEngine, SQLiteStore, InMemoryStore } from '@critical-path/core';
 import { CriticalPathClient } from '@critical-path/client';
 import { createCriticalPathMcpServer, startStdioServer } from '../server/index.js';
-
-function parseArgs(args: string[]) {
-  const options: { db?: string; api?: string; help?: boolean } = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--help' || arg === '-h') {
-      options.help = true;
-    } else if (arg === '--db' && args[i + 1]) {
-      options.db = args[++i];
-    } else if (arg === '--api' && args[i + 1]) {
-      options.api = args[++i];
-    }
-  }
-  return options;
-}
+import { parseArgs, buildApiHeaders, isInsecureRemote } from './args.js';
 
 function showHelp() {
   console.log(`
@@ -25,9 +11,13 @@ Critical Path MCP Server (Stdio)
 Usage:
   npx @critical-path/mcp [options]
 
+Environment:
+  CRITICAL_PATH_API_TOKEN   Sent as "Authorization: Bearer <token>" in --api mode
+
 Options:
   --db <path>      Path to SQLite database file (uses SQLiteStore)
   --api <url>      Base URL of remote Critical Path server (uses CriticalPathClient)
+  --header <h>     Extra request header for --api, as "Name: value" (repeatable)
   --help, -h       Display this help message
 
 Examples:
@@ -37,6 +27,9 @@ Examples:
   # Run against remote Next.js or SvelteKit route handler
   npx @critical-path/mcp --api http://localhost:3000/api/critical-path
 
+  # Authenticate against a protected API (token read from the environment)
+  CRITICAL_PATH_API_TOKEN=secret npx @critical-path/mcp --api https://app.example.com/api/critical-path
+
   # Run with in-memory store (for testing)
   npx @critical-path/mcp
 `);
@@ -54,7 +47,11 @@ async function main() {
   let server;
 
   if (options.api) {
-    const client = new CriticalPathClient({ baseUrl: options.api });
+    const headers = buildApiHeaders(options.headers, process.env);
+    if (Object.keys(headers).length > 0 && isInsecureRemote(options.api)) {
+      console.error('[Critical Path MCP] Warning: sending credentials over plain http to a remote host.');
+    }
+    const client = new CriticalPathClient({ baseUrl: options.api, headers });
     server = createCriticalPathMcpServer({ client, name: 'critical-path-api-mcp' });
     console.error(`[Critical Path MCP] Connecting to remote API at ${options.api} over stdio...`);
   } else if (options.db) {

package/src/tools/definitions.test.ts

@@ -2,8 +2,8 @@ import { describe, it, expect } from 'vitest';
 import { ALL_TOOLS } from './definitions.js';
 
 describe('MCP tool definitions', () => {
-  // Tool arguments are parsed with zodSchema before execution (unknown keys are stripped),
-  // while clients see inputSchema. The two must describe the same fields.
+  // inputSchema is generated from zodSchema by defineTool; this guards the generation itself
+  // (e.g. a zod feature that zod-to-json-schema cannot express would drop fields here).
   it.each(ALL_TOOLS.map((t) => [t.name, t] as const))('%s: zodSchema and inputSchema agree', (_name, tool) => {
     const json = tool.inputSchema as { properties?: Record<string, unknown>; required?: string[] };
     const shape = tool.zodSchema.shape as Record<string, { isOptional(): boolean }>;
@@ -16,4 +16,14 @@ describe('MCP tool definitions', () => {
         .sort()
     ).toEqual([...(json.required ?? [])].sort());
   });
+
+  it('generates closed object schemas with descriptions for every tool', () => {
+    for (const tool of ALL_TOOLS) {
+      expect(tool.inputSchema).toMatchObject({ type: 'object', additionalProperties: false });
+      expect(tool.inputSchema).not.toHaveProperty('$schema');
+    }
+    const updateTask = ALL_TOOLS.find((t) => t.name === 'update_task')!;
+    expect((updateTask.inputSchema as any).properties.isBlocked.description).toBe('Whether the task is blocked');
+  });
 });
+