@dewtech/dare-cli 3.3.0 → 3.4.0

package/templates/stacks/mcp-node-ts/src/cli.ts.hbs

@@ -1,71 +1,71 @@
-#!/usr/bin/env node
-import { TOOLS } from './tools/index.js';
-import { createServer } from './server.js';
-import { createStdioTransport } from './transports/stdio.js';
-import { startSseTransport } from './transports/sse.js';
-import { startHttpTransport } from './transports/http.js';
-
-type Transport = 'stdio' | 'sse' | 'http';
-
-interface Args {
-  transport: Transport;
-  listToolsJson: boolean;
-}
-
-function parseArgs(argv: string[]): Args {
-  let transport: Transport =
-    (process.env.MCP_TRANSPORT as Transport | undefined) ?? '{{defaultTransport}}';
-  let listToolsJson = false;
-  let json = false;
-
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--transport' && argv[i + 1]) {
-      const next = argv[++i];
-      if (next === 'stdio' || next === 'sse' || next === 'http') {
-        transport = next;
-      } else {
-        throw new Error(`invalid --transport '${next}' (valid: stdio, sse, http)`);
-      }
-    } else if (a === '--json') {
-      json = true;
-    } else if (a === '--list-tools') {
-      listToolsJson = true;
-    }
-  }
-
-  return { transport, listToolsJson: listToolsJson && json };
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-
-  if (args.listToolsJson) {
-    process.stdout.write(JSON.stringify({ tools: TOOLS }, null, 2) + '\n');
-    return;
-  }
-
-  const server = createServer();
-  const port = Number(process.env.MCP_PORT ?? 3001);
-
-  switch (args.transport) {
-    case 'stdio': {
-      const transport = createStdioTransport();
-      await server.connect(transport);
-      return;
-    }
-    case 'sse': {
-      await startSseTransport(server, port);
-      return;
-    }
-    case 'http': {
-      await startHttpTransport(server, port);
-      return;
-    }
-  }
-}
-
-main().catch((err) => {
-  process.stderr.write(`[mcp] fatal: ${(err as Error).message}\n`);
-  process.exit(1);
-});
+#!/usr/bin/env node
+import { TOOLS } from './tools/index.js';
+import { createServer } from './server.js';
+import { createStdioTransport } from './transports/stdio.js';
+import { startSseTransport } from './transports/sse.js';
+import { startHttpTransport } from './transports/http.js';
+
+type Transport = 'stdio' | 'sse' | 'http';
+
+interface Args {
+  transport: Transport;
+  listToolsJson: boolean;
+}
+
+function parseArgs(argv: string[]): Args {
+  let transport: Transport =
+    (process.env.MCP_TRANSPORT as Transport | undefined) ?? '{{defaultTransport}}';
+  let listToolsJson = false;
+  let json = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--transport' && argv[i + 1]) {
+      const next = argv[++i];
+      if (next === 'stdio' || next === 'sse' || next === 'http') {
+        transport = next;
+      } else {
+        throw new Error(`invalid --transport '${next}' (valid: stdio, sse, http)`);
+      }
+    } else if (a === '--json') {
+      json = true;
+    } else if (a === '--list-tools') {
+      listToolsJson = true;
+    }
+  }
+
+  return { transport, listToolsJson: listToolsJson && json };
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.listToolsJson) {
+    process.stdout.write(JSON.stringify({ tools: TOOLS }, null, 2) + '\n');
+    return;
+  }
+
+  const server = createServer();
+  const port = Number(process.env.MCP_PORT ?? 3001);
+
+  switch (args.transport) {
+    case 'stdio': {
+      const transport = createStdioTransport();
+      await server.connect(transport);
+      return;
+    }
+    case 'sse': {
+      await startSseTransport(server, port);
+      return;
+    }
+    case 'http': {
+      await startHttpTransport(server, port);
+      return;
+    }
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[mcp] fatal: ${(err as Error).message}\n`);
+  process.exit(1);
+});

package/templates/stacks/mcp-node-ts/src/prompts/index.ts

@@ -1,36 +1,36 @@
-import type { Prompt } from '@modelcontextprotocol/sdk/types.js';
-
-export const PROMPTS: Prompt[] = [
-  {
-    name: 'summarize',
-    description: 'Summarize the given text in 1-2 sentences.',
-    arguments: [
-      {
-        name: 'text',
-        description: 'Text to summarize',
-        required: true,
-      },
-    ],
-  },
-];
-
-export async function getPrompt(
-  name: string,
-  args: Record<string, unknown>,
-): Promise<{ messages: Array<{ role: 'user'; content: { type: 'text'; text: string } }> }> {
-  if (name === 'summarize') {
-    const text = String(args.text ?? '');
-    return {
-      messages: [
-        {
-          role: 'user',
-          content: {
-            type: 'text',
-            text: `Summarize the following text in 1-2 sentences.\n\n${text}`,
-          },
-        },
-      ],
-    };
-  }
-  throw new Error(`Unknown prompt: ${name}`);
-}
+import type { Prompt } from '@modelcontextprotocol/sdk/types.js';
+
+export const PROMPTS: Prompt[] = [
+  {
+    name: 'summarize',
+    description: 'Summarize the given text in 1-2 sentences.',
+    arguments: [
+      {
+        name: 'text',
+        description: 'Text to summarize',
+        required: true,
+      },
+    ],
+  },
+];
+
+export async function getPrompt(
+  name: string,
+  args: Record<string, unknown>,
+): Promise<{ messages: Array<{ role: 'user'; content: { type: 'text'; text: string } }> }> {
+  if (name === 'summarize') {
+    const text = String(args.text ?? '');
+    return {
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Summarize the following text in 1-2 sentences.\n\n${text}`,
+          },
+        },
+      ],
+    };
+  }
+  throw new Error(`Unknown prompt: ${name}`);
+}

package/templates/stacks/mcp-node-ts/src/server.ts.hbs

@@ -1,45 +1,45 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import {
-  CallToolRequestSchema,
-  GetPromptRequestSchema,
-  ListPromptsRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-
-import { TOOLS, callTool } from './tools/index.js';
-import { PROMPTS, getPrompt } from './prompts/index.js';
-
-export function createServer(): Server {
-  const server = new Server(
-    {
-      name: '{{projectName}}',
-      version: '0.1.0',
-    },
-    {
-      capabilities: {
-        tools: {},
-        prompts: {},
-      },
-    },
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOLS,
-  }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
-    const { name, arguments: args } = req.params;
-    return callTool(name, args ?? {});
-  });
-
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-    prompts: PROMPTS,
-  }));
-
-  server.setRequestHandler(GetPromptRequestSchema, async (req) => {
-    const { name, arguments: args } = req.params;
-    return getPrompt(name, args ?? {});
-  });
-
-  return server;
-}
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { TOOLS, callTool } from './tools/index.js';
+import { PROMPTS, getPrompt } from './prompts/index.js';
+
+export function createServer(): Server {
+  const server = new Server(
+    {
+      name: '{{projectName}}',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+        prompts: {},
+      },
+    },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    return callTool(name, args ?? {});
+  });
+
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: PROMPTS,
+  }));
+
+  server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    return getPrompt(name, args ?? {});
+  });
+
+  return server;
+}

package/templates/stacks/mcp-node-ts/src/tools/echo.ts

@@ -1,23 +1,23 @@
-import { z } from 'zod';
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-
-export const echoInput = z.object({
-  text: z.string().min(1, 'text is required'),
-});
-
-export const echoTool: Tool = {
-  name: 'echo',
-  description: 'Returns its input. Canonical smoke test for an MCP server.',
-  inputSchema: {
-    type: 'object',
-    required: ['text'],
-    properties: {
-      text: { type: 'string', minLength: 1, description: 'Text to echo back' },
-    },
-  },
-};
-
-export async function runEcho(args: unknown): Promise<string> {
-  const parsed = echoInput.parse(args);
-  return parsed.text;
-}
+import { z } from 'zod';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+export const echoInput = z.object({
+  text: z.string().min(1, 'text is required'),
+});
+
+export const echoTool: Tool = {
+  name: 'echo',
+  description: 'Returns its input. Canonical smoke test for an MCP server.',
+  inputSchema: {
+    type: 'object',
+    required: ['text'],
+    properties: {
+      text: { type: 'string', minLength: 1, description: 'Text to echo back' },
+    },
+  },
+};
+
+export async function runEcho(args: unknown): Promise<string> {
+  const parsed = echoInput.parse(args);
+  return parsed.text;
+}

package/templates/stacks/mcp-node-ts/src/tools/index.ts

@@ -1,18 +1,18 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { echoTool, runEcho } from './echo.js';
-
-export const TOOLS: Tool[] = [echoTool];
-
-export async function callTool(
-  name: string,
-  args: Record<string, unknown>,
-): Promise<{ content: Array<{ type: 'text'; text: string }>; isError?: boolean }> {
-  if (name === echoTool.name) {
-    const text = await runEcho(args);
-    return { content: [{ type: 'text', text }] };
-  }
-  return {
-    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-    isError: true,
-  };
-}
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { echoTool, runEcho } from './echo.js';
+
+export const TOOLS: Tool[] = [echoTool];
+
+export async function callTool(
+  name: string,
+  args: Record<string, unknown>,
+): Promise<{ content: Array<{ type: 'text'; text: string }>; isError?: boolean }> {
+  if (name === echoTool.name) {
+    const text = await runEcho(args);
+    return { content: [{ type: 'text', text }] };
+  }
+  return {
+    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+    isError: true,
+  };
+}

package/templates/stacks/mcp-node-ts/src/transports/http.ts

@@ -1,68 +1,68 @@
-import express from 'express';
-import { randomUUID } from 'node:crypto';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-
-/**
- * Streamable HTTP — modern MCP HTTP transport. Each client gets its own
- * session keyed by Mcp-Session-Id header (auto-generated on initialize).
- */
-export async function startHttpTransport(server: Server, port: number): Promise<void> {
-  const app = express();
-  app.use(express.json());
-
-  // Rate limit (same shape as SSE) — apply if RATE_LIMIT_RPM is set.
-  const rpm = Number(process.env.RATE_LIMIT_RPM ?? 0);
-  if (rpm > 0) {
-    const seen = new Map<string, { count: number; resetAt: number }>();
-    app.use((req, res, next) => {
-      const ip = req.ip ?? 'unknown';
-      const now = Date.now();
-      const entry = seen.get(ip);
-      if (!entry || entry.resetAt < now) {
-        seen.set(ip, { count: 1, resetAt: now + 60_000 });
-        return next();
-      }
-      if (entry.count >= rpm) {
-        res.status(429).json({ error: 'rate limit exceeded' });
-        return;
-      }
-      entry.count += 1;
-      next();
-    });
-  }
-
-  const transports = new Map<string, StreamableHTTPServerTransport>();
-
-  app.post('/mcp/v1/messages', async (req, res) => {
-    const sessionId = req.header('mcp-session-id');
-    let transport = sessionId ? transports.get(sessionId) : undefined;
-    if (!transport) {
-      transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        onsessioninitialized: (id: string) => {
-          transports.set(id, transport!);
-        },
-      });
-      await server.connect(transport);
-    }
-    await transport.handleRequest(req, res, req.body);
-  });
-
-  app.get('/mcp/v1/messages', async (req, res) => {
-    const sessionId = req.header('mcp-session-id');
-    const transport = sessionId ? transports.get(sessionId) : undefined;
-    if (!transport) {
-      res.status(400).json({ error: 'no active session' });
-      return;
-    }
-    await transport.handleRequest(req, res);
-  });
-
-  await new Promise<void>((resolve) => {
-    app.listen(port, () => {
-      process.stderr.write(`[mcp/http] listening on :${port}\n`);
-      resolve();
-    });
-  });
-}
+import express from 'express';
+import { randomUUID } from 'node:crypto';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+
+/**
+ * Streamable HTTP — modern MCP HTTP transport. Each client gets its own
+ * session keyed by Mcp-Session-Id header (auto-generated on initialize).
+ */
+export async function startHttpTransport(server: Server, port: number): Promise<void> {
+  const app = express();
+  app.use(express.json());
+
+  // Rate limit (same shape as SSE) — apply if RATE_LIMIT_RPM is set.
+  const rpm = Number(process.env.RATE_LIMIT_RPM ?? 0);
+  if (rpm > 0) {
+    const seen = new Map<string, { count: number; resetAt: number }>();
+    app.use((req, res, next) => {
+      const ip = req.ip ?? 'unknown';
+      const now = Date.now();
+      const entry = seen.get(ip);
+      if (!entry || entry.resetAt < now) {
+        seen.set(ip, { count: 1, resetAt: now + 60_000 });
+        return next();
+      }
+      if (entry.count >= rpm) {
+        res.status(429).json({ error: 'rate limit exceeded' });
+        return;
+      }
+      entry.count += 1;
+      next();
+    });
+  }
+
+  const transports = new Map<string, StreamableHTTPServerTransport>();
+
+  app.post('/mcp/v1/messages', async (req, res) => {
+    const sessionId = req.header('mcp-session-id');
+    let transport = sessionId ? transports.get(sessionId) : undefined;
+    if (!transport) {
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (id: string) => {
+          transports.set(id, transport!);
+        },
+      });
+      await server.connect(transport);
+    }
+    await transport.handleRequest(req, res, req.body);
+  });
+
+  app.get('/mcp/v1/messages', async (req, res) => {
+    const sessionId = req.header('mcp-session-id');
+    const transport = sessionId ? transports.get(sessionId) : undefined;
+    if (!transport) {
+      res.status(400).json({ error: 'no active session' });
+      return;
+    }
+    await transport.handleRequest(req, res);
+  });
+
+  await new Promise<void>((resolve) => {
+    app.listen(port, () => {
+      process.stderr.write(`[mcp/http] listening on :${port}\n`);
+      resolve();
+    });
+  });
+}

package/templates/stacks/mcp-node-ts/src/transports/sse.ts

@@ -1,58 +1,58 @@
-import express from 'express';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-
-/**
- * Legacy MCP SSE transport. Holds one SSE connection at a time; multiple
- * clients require running multiple server instances behind a load balancer.
- *
- * For new deployments prefer the modern Streamable HTTP transport
- * (transports/http.ts) — SSE is kept here for compatibility with older
- * MCP clients that only speak the SSE wire format.
- */
-export async function startSseTransport(server: Server, port: number): Promise<void> {
-  const app = express();
-
-  // Rate limit knob — apply if RATE_LIMIT_RPM is set. Simple token bucket per IP.
-  const rpm = Number(process.env.RATE_LIMIT_RPM ?? 0);
-  if (rpm > 0) {
-    const seen = new Map<string, { count: number; resetAt: number }>();
-    app.use((req, res, next) => {
-      const ip = req.ip ?? 'unknown';
-      const now = Date.now();
-      const entry = seen.get(ip);
-      if (!entry || entry.resetAt < now) {
-        seen.set(ip, { count: 1, resetAt: now + 60_000 });
-        return next();
-      }
-      if (entry.count >= rpm) {
-        res.status(429).json({ error: 'rate limit exceeded' });
-        return;
-      }
-      entry.count += 1;
-      next();
-    });
-  }
-
-  let transport: SSEServerTransport | null = null;
-
-  app.get('/mcp/v1/sse', async (_req, res) => {
-    transport = new SSEServerTransport('/mcp/v1/messages', res);
-    await server.connect(transport);
-  });
-
-  app.post('/mcp/v1/messages', express.json(), async (req, res) => {
-    if (!transport) {
-      res.status(400).json({ error: 'no active SSE session' });
-      return;
-    }
-    await transport.handlePostMessage(req, res, req.body);
-  });
-
-  await new Promise<void>((resolve) => {
-    app.listen(port, () => {
-      process.stderr.write(`[mcp/sse] listening on :${port}\n`);
-      resolve();
-    });
-  });
-}
+import express from 'express';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+
+/**
+ * Legacy MCP SSE transport. Holds one SSE connection at a time; multiple
+ * clients require running multiple server instances behind a load balancer.
+ *
+ * For new deployments prefer the modern Streamable HTTP transport
+ * (transports/http.ts) — SSE is kept here for compatibility with older
+ * MCP clients that only speak the SSE wire format.
+ */
+export async function startSseTransport(server: Server, port: number): Promise<void> {
+  const app = express();
+
+  // Rate limit knob — apply if RATE_LIMIT_RPM is set. Simple token bucket per IP.
+  const rpm = Number(process.env.RATE_LIMIT_RPM ?? 0);
+  if (rpm > 0) {
+    const seen = new Map<string, { count: number; resetAt: number }>();
+    app.use((req, res, next) => {
+      const ip = req.ip ?? 'unknown';
+      const now = Date.now();
+      const entry = seen.get(ip);
+      if (!entry || entry.resetAt < now) {
+        seen.set(ip, { count: 1, resetAt: now + 60_000 });
+        return next();
+      }
+      if (entry.count >= rpm) {
+        res.status(429).json({ error: 'rate limit exceeded' });
+        return;
+      }
+      entry.count += 1;
+      next();
+    });
+  }
+
+  let transport: SSEServerTransport | null = null;
+
+  app.get('/mcp/v1/sse', async (_req, res) => {
+    transport = new SSEServerTransport('/mcp/v1/messages', res);
+    await server.connect(transport);
+  });
+
+  app.post('/mcp/v1/messages', express.json(), async (req, res) => {
+    if (!transport) {
+      res.status(400).json({ error: 'no active SSE session' });
+      return;
+    }
+    await transport.handlePostMessage(req, res, req.body);
+  });
+
+  await new Promise<void>((resolve) => {
+    app.listen(port, () => {
+      process.stderr.write(`[mcp/sse] listening on :${port}\n`);
+      resolve();
+    });
+  });
+}

package/templates/stacks/mcp-node-ts/src/transports/stdio.ts

@@ -1,5 +1,5 @@
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-
-export function createStdioTransport(): StdioServerTransport {
-  return new StdioServerTransport();
-}
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+export function createStdioTransport(): StdioServerTransport {
+  return new StdioServerTransport();
+}