@tac0de/project-bootstrap-mcp 1.1.1 → 1.2.0

package/README.md

@@ -61,7 +61,7 @@ This project turns the MCP (Management Control Plane) bootstrap documentation in
 ```json
 {
   "command": "npx",
-  "args": ["-y", "project-bootstrap-mcp"]
+  "args": ["-y", "@tac0de/project-bootstrap-mcp"]
 }
 ```
 

package/bin/project-bootstrap-mcp.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index.js');

package/dist/index.d.ts

@@ -1,5 +1,3 @@
 import BootstrapStore from './store';
-import createApp from './app';
-import startServer from './server';
-export { BootstrapStore, createApp, startServer };
+export { BootstrapStore };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,SAAS,CAAC;AACrC,OAAO,SAAS,MAAM,OAAO,CAAC;AAC9B,OAAO,WAAW,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,cAAc,MAAM,SAAS,CAAC;AAqMrC,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/index.js

@@ -3,10 +3,187 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startServer = exports.createApp = exports.BootstrapStore = void 0;
+exports.BootstrapStore = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const store_1 = __importDefault(require("./store"));
 exports.BootstrapStore = store_1.default;
-const app_1 = __importDefault(require("./app"));
-exports.createApp = app_1.default;
-const server_1 = __importDefault(require("./server"));
-exports.startServer = server_1.default;
+// Create MCP server
+const server = new index_js_1.Server({
+    name: '@tac0de/project-bootstrap-mcp',
+    version: '1.1.2',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const store = new store_1.default();
+// List available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'list_bootstraps',
+                description: 'List all bootstrap project definitions',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'create_bootstrap',
+                description: 'Create a new bootstrap project definition with steps and criteria',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the bootstrap project',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Description of the bootstrap project',
+                        },
+                        primaryAction: {
+                            type: 'string',
+                            description: 'The primary action to be performed',
+                        },
+                        targetPlatforms: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                            },
+                            description: 'Target platforms for this bootstrap',
+                        },
+                        successCriteria: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                            },
+                            description: 'Criteria for successful completion',
+                        },
+                        steps: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    title: {
+                                        type: 'string',
+                                        description: 'Title of the step',
+                                    },
+                                    detail: {
+                                        type: 'string',
+                                        description: 'Detailed instructions for the step',
+                                    },
+                                },
+                                required: ['title', 'detail'],
+                            },
+                            description: 'Steps to complete the bootstrap',
+                        },
+                    },
+                    required: ['name', 'description', 'primaryAction', 'steps'],
+                },
+            },
+            {
+                name: 'get_bootstrap',
+                description: 'Get a specific bootstrap project by ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: {
+                            type: 'string',
+                            description: 'The ID of the bootstrap project',
+                        },
+                    },
+                    required: ['id'],
+                },
+            },
+        ],
+    };
+});
+// Handle tool execution
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+        case 'list_bootstraps': {
+            const items = store.list();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ items }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'create_bootstrap': {
+            const payload = {
+                name: String(args?.name),
+                description: String(args?.description),
+                primaryAction: String(args?.primaryAction),
+                targetPlatforms: Array.isArray(args?.targetPlatforms)
+                    ? args.targetPlatforms.map(String)
+                    : [],
+                successCriteria: Array.isArray(args?.successCriteria)
+                    ? args.successCriteria.map(String)
+                    : [],
+                steps: Array.isArray(args?.steps)
+                    ? args.steps
+                    : [],
+            };
+            const saved = store.add(payload);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(saved, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'get_bootstrap': {
+            const id = String(args?.id);
+            const record = store.find(id);
+            if (!record) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: 'Bootstrap not found' }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(record, null, 2),
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ error: 'Unknown tool' }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('Project Bootstrap MCP server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/package.json

@@ -1,14 +1,14 @@
 {
     "name": "@tac0de/project-bootstrap-mcp",
-    "version": "1.1.0",
+    "version": "1.1.2",
     "description": "Project Bootstrap MCP API tooling for launching MCP bootstrap definitions and documentation.",
     "main": "dist/index.js",
     "bin": {
-        "project-bootstrap-mcp": "dist/bin/project-bootstrap-mcp.js"
+        "project-bootstrap-mcp": "bin/project-bootstrap-mcp.js"
     },
     "scripts": {
         "build": "tsc",
-        "start": "npm run build && node ./dist/bin/project-bootstrap-mcp.js",
+        "start": "npm run build && node ./bin/project-bootstrap-mcp.js",
         "test": "node --test -r ts-node/register test/store.test.ts"
     },
     "keywords": [

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@tac0de/project-bootstrap-mcp",
-  "version": "1.1.1",
-  "description": "Project Bootstrap MCP API tooling for launching MCP bootstrap definitions and documentation.",
+  "version": "1.2.0",
+  "description": "MCP server for managing project bootstrap definitions with steps and success criteria.",
   "main": "dist/index.js",
   "bin": {
-    "project-bootstrap-mcp": "dist/bin/project-bootstrap-mcp.js"
+    "project-bootstrap-mcp": "bin/project-bootstrap-mcp.js"
   },
   "scripts": {
     "build": "tsc",
-    "start": "npm run build && node ./dist/bin/project-bootstrap-mcp.js",
+    "start": "npm run build && node ./bin/project-bootstrap-mcp.js",
     "test": "node --test -r ts-node/register test/store.test.ts"
   },
   "keywords": [
@@ -42,10 +42,9 @@
     "url": "https://github.com/tac0de/project-bootstrap-mcp"
   },
   "dependencies": {
-    "express": "^4.19.2"
+    "@modelcontextprotocol/sdk": "^1.25.1"
   },
   "devDependencies": {
-    "@types/express": "^5.0.6",
     "@types/node": "^25.0.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"

package/src/index.ts

@@ -1,5 +1,204 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
 import BootstrapStore from './store';
-import createApp from './app';
-import startServer from './server';
+import type { BootstrapPayload } from './types';
 
-export { BootstrapStore, createApp, startServer };
+// Create MCP server
+const server = new Server(
+  {
+    name: '@tac0de/project-bootstrap-mcp',
+    version: '1.1.2',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+const store = new BootstrapStore();
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'list_bootstraps',
+        description: 'List all bootstrap project definitions',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'create_bootstrap',
+        description: 'Create a new bootstrap project definition with steps and criteria',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'Name of the bootstrap project',
+            },
+            description: {
+              type: 'string',
+              description: 'Description of the bootstrap project',
+            },
+            primaryAction: {
+              type: 'string',
+              description: 'The primary action to be performed',
+            },
+            targetPlatforms: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+              description: 'Target platforms for this bootstrap',
+            },
+            successCriteria: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+              description: 'Criteria for successful completion',
+            },
+            steps: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  title: {
+                    type: 'string',
+                    description: 'Title of the step',
+                  },
+                  detail: {
+                    type: 'string',
+                    description: 'Detailed instructions for the step',
+                  },
+                },
+                required: ['title', 'detail'],
+              },
+              description: 'Steps to complete the bootstrap',
+            },
+          },
+          required: ['name', 'description', 'primaryAction', 'steps'],
+        },
+      },
+      {
+        name: 'get_bootstrap',
+        description: 'Get a specific bootstrap project by ID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              description: 'The ID of the bootstrap project',
+            },
+          },
+          required: ['id'],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  switch (name) {
+    case 'list_bootstraps': {
+      const items = store.list();
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({ items }, null, 2),
+          },
+        ],
+      };
+    }
+
+    case 'create_bootstrap': {
+      const payload: BootstrapPayload = {
+        name: String(args?.name),
+        description: String(args?.description),
+        primaryAction: String(args?.primaryAction),
+        targetPlatforms: Array.isArray(args?.targetPlatforms)
+          ? args.targetPlatforms.map(String)
+          : [],
+        successCriteria: Array.isArray(args?.successCriteria)
+          ? args.successCriteria.map(String)
+          : [],
+        steps: Array.isArray(args?.steps)
+          ? (args.steps as BootstrapPayload['steps'])
+          : [],
+      };
+
+      const saved = store.add(payload);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(saved, null, 2),
+          },
+        ],
+      };
+    }
+
+    case 'get_bootstrap': {
+      const id = String(args?.id);
+      const record = store.find(id);
+
+      if (!record) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ error: 'Bootstrap not found' }, null, 2),
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(record, null, 2),
+          },
+        ],
+      };
+    }
+
+    default:
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({ error: 'Unknown tool' }, null, 2),
+          },
+        ],
+        isError: true,
+      };
+  }
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Project Bootstrap MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});
+
+export { BootstrapStore };

package/bin/project-bootstrap-mcp.ts

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import startServer from '../src/server.js';
-
-function parsePort(args: string[], envPort: string | undefined): number {
-  let portValue = envPort || '4000';
-  args.forEach((arg, index, list) => {
-    if (arg === '--port' && list[index + 1]) {
-      portValue = list[index + 1];
-    }
-    if (arg.startsWith('--port=')) {
-      portValue = arg.split('=')[1];
-    }
-    if (arg === '-p' && list[index + 1]) {
-      portValue = list[index + 1];
-    }
-  });
-  const parsed = Number.parseInt(portValue, 10);
-  if (Number.isNaN(parsed)) {
-    console.error(`invalid port value: ${portValue}`);
-    process.exit(1);
-  }
-  return parsed;
-}
-
-const port = parsePort(process.argv.slice(2), process.env.PORT);
-startServer({ port });

package/src/app.ts

@@ -1,73 +0,0 @@
-import express, { Express, Request, Response, NextFunction } from 'express';
-import pkg from '../package.json';
-import { validateBootstrapPayload } from './validators';
-import BootstrapStore from './store';
-import type { BootstrapPayload } from './types';
-
-interface CreateAppOptions {
-  store?: BootstrapStore;
-}
-
-export default function createApp(options: CreateAppOptions = {}) {
-  const store = options.store ?? new BootstrapStore();
-  const app: Express = express();
-
-  app.use(express.json());
-
-  app.get('/api/status', (_req: Request, res: Response) => {
-    res.json({
-      service: pkg.name,
-      version: pkg.version,
-      uptime: process.uptime(),
-      timestamp: new Date().toISOString(),
-    });
-  });
-
-  app.get('/api/bootstraps', (_req: Request, res: Response) => {
-    res.json({ items: store.list() });
-  });
-
-  app.post('/api/bootstraps', (req: Request, res: Response) => {
-    const validation = validateBootstrapPayload(req.body);
-    if (!validation.valid) {
-      return res.status(400).json({ errors: validation.errors });
-    }
-    const payload: BootstrapPayload = {
-      name: req.body.name,
-      description: req.body.description,
-      primaryAction: req.body.primaryAction,
-      targetPlatforms: Array.isArray(req.body.targetPlatforms)
-        ? req.body.targetPlatforms.map(String)
-        : [],
-      successCriteria: Array.isArray(req.body.successCriteria)
-        ? req.body.successCriteria.map(String)
-        : [],
-      steps: Array.isArray(req.body.steps)
-        ? (req.body.steps as BootstrapPayload['steps'])
-        : [],
-    };
-    const saved = store.add(payload);
-    res.status(201).json(saved);
-  });
-
-  app.get('/api/bootstraps/:id', (req: Request, res: Response) => {
-    const record = store.find(req.params.id);
-    if (!record) {
-      return res.status(404).json({ error: 'bootstrap not found' });
-    }
-    res.json(record);
-  });
-
-  app.use((_req: Request, res: Response) => {
-    res.status(404).json({ error: 'not found' });
-  });
-
-  app.use((err: Error, _req: Request, res: Response, next: NextFunction) => {
-    // eslint-disable-next-line no-console
-    console.error('internal error', err);
-    res.status(500).json({ error: 'internal server error' });
-    next(err);
-  });
-
-  return { app, store };
-}

package/src/server.ts

@@ -1,44 +0,0 @@
-import type { Express } from 'express';
-import type { Server } from 'http';
-import createApp from './app';
-
-export interface StartServerOptions {
-  port?: number;
-  onStart?: (message: string, port: number) => void;
-}
-
-export interface StartServerResult {
-  app: Express;
-  server: Server;
-}
-
-export default function startServer({
-  port,
-  onStart,
-}: StartServerOptions = {}): StartServerResult {
-  const defaultPort = Number(process.env.PORT) || 4000;
-  const resolvedPort = port ?? defaultPort;
-  const { app } = createApp();
-  const server = app.listen(resolvedPort, () => {
-    const message = `Project Bootstrap MCP listening on port ${resolvedPort}`;
-    if (typeof onStart === 'function') {
-      onStart(message, resolvedPort);
-    } else {
-      // eslint-disable-next-line no-console
-      console.log(message);
-    }
-  });
-
-  const graceful = () => {
-    server.close(() => {
-      // eslint-disable-next-line no-console
-      console.log('Project Bootstrap MCP shutting down');
-      process.exit(0);
-    });
-  };
-
-  process.on('SIGINT', graceful);
-  process.on('SIGTERM', graceful);
-
-  return { app, server };
-}

package/src/validators.ts

@@ -1,43 +0,0 @@
-import type { BootstrapPayload, BootstrapStep } from './types';
-
-export interface ValidationResult {
-  valid: boolean;
-  errors: string[];
-}
-
-export function validateBootstrapPayload(payload: unknown): ValidationResult {
-  const errors: string[] = [];
-  if (!payload || typeof payload !== 'object') {
-    errors.push('payload must be an object');
-    return { valid: false, errors };
-  }
-
-  const typedPayload = payload as BootstrapPayload;
-  const { name, description, primaryAction, steps } = typedPayload;
-
-  if (!name || typeof name !== 'string') {
-    errors.push('name is required and must be a string');
-  }
-  if (!description || typeof description !== 'string') {
-    errors.push('description is required and must be a string');
-  }
-  if (!primaryAction || typeof primaryAction !== 'string') {
-    errors.push('primaryAction is required and must be a string');
-  }
-
-  if (!Array.isArray(steps) || steps.length === 0) {
-    errors.push('steps must be a non-empty array');
-  } else {
-    steps.forEach((step, index) => {
-      const currentStep = step as BootstrapStep | undefined;
-      if (!currentStep || typeof currentStep.title !== 'string') {
-        errors.push(`steps[${index}].title is required`);
-      }
-      if (!currentStep || typeof currentStep.detail !== 'string') {
-        errors.push(`steps[${index}].detail is required`);
-      }
-    });
-  }
-
-  return { valid: errors.length === 0, errors };
-}