@girardmedia/bootspring 2.1.3 → 2.2.1

package/mcp/server.js

@@ -1,264 +0,0 @@
-/**
- * Bootspring MCP Server
- * Thin stdio proxy for the hosted Bootspring MCP API.
- */
-
-const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
-const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
-const {
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema
-} = require('@modelcontextprotocol/sdk/types.js');
-
-const api = require('../core/api-client');
-const auth = require('../core/auth');
-
-const VERSION = require('../package.json').version;
-
-const FALLBACK_TOOLS = [
-  {
-    name: 'bootspring_agent',
-    description: 'Invoke a hosted Bootspring agent.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        agent: { type: 'string' },
-        task: { type: 'string' }
-      },
-      required: ['agent']
-    }
-  },
-  {
-    name: 'bootspring_skill',
-    description: 'Fetch a hosted Bootspring skill.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        skill: { type: 'string' }
-      },
-      required: ['skill']
-    }
-  },
-  {
-    name: 'bootspring_context',
-    description: 'Get or analyze project context.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        action: { type: 'string', enum: ['get', 'generate', 'analyze'] }
-      },
-      required: ['action']
-    }
-  },
-  {
-    name: 'bootspring_orchestrator',
-    description: 'Use the hosted orchestrator.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        action: { type: 'string', enum: ['analyze', 'start', 'suggest'] },
-        workflow: { type: 'string' }
-      },
-      required: ['action']
-    }
-  },
-  {
-    name: 'bootspring_quality',
-    description: 'Fetch a hosted quality gate.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        gate: { type: 'string', enum: ['pre-commit', 'pre-push', 'pre-deploy'] }
-      },
-      required: ['gate']
-    }
-  },
-  {
-    name: 'bootspring_todo',
-    description: 'Manage local todo items.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        action: { type: 'string', enum: ['list', 'add', 'complete', 'delete'] },
-        text: { type: 'string' },
-        id: { type: 'string' }
-      },
-      required: ['action']
-    }
-  }
-];
-
-const FALLBACK_RESOURCES = [
-  {
-    uri: 'bootspring://context',
-    name: 'Project Context',
-    description: 'Current project context and configuration',
-    mimeType: 'application/json'
-  },
-  {
-    uri: 'bootspring://agents',
-    name: 'Available Agents',
-    description: 'Hosted Bootspring agents for your account',
-    mimeType: 'application/json'
-  },
-  {
-    uri: 'bootspring://skills',
-    name: 'Code Skills',
-    description: 'Hosted Bootspring skills and patterns',
-    mimeType: 'application/json'
-  },
-  {
-    uri: 'bootspring://workflows',
-    name: 'Workflows',
-    description: 'Hosted Bootspring workflows',
-    mimeType: 'application/json'
-  }
-];
-
-const TOOLS = FALLBACK_TOOLS;
-const RESOURCES = FALLBACK_RESOURCES;
-
-function formatTextContent(value) {
-  return typeof value === 'string' ? value : JSON.stringify(value, null, 2);
-}
-
-function createAuthError(message) {
-  return {
-    content: [{ type: 'text', text: message }],
-    isError: true
-  };
-}
-
-async function resolveTools() {
-  if (!auth.isAuthenticated()) {
-    return FALLBACK_TOOLS;
-  }
-
-  try {
-    const response = await api.listMcpTools();
-    return Array.isArray(response) ? response : response.tools || FALLBACK_TOOLS;
-  } catch {
-    return FALLBACK_TOOLS;
-  }
-}
-
-async function resolveResources() {
-  if (!auth.isAuthenticated()) {
-    return FALLBACK_RESOURCES;
-  }
-
-  try {
-    const response = await api.listMcpResources();
-    return Array.isArray(response) ? response : response.resources || FALLBACK_RESOURCES;
-  } catch {
-    return FALLBACK_RESOURCES;
-  }
-}
-
-async function proxyToolCall(name, args) {
-  if (!auth.isAuthenticated()) {
-    return createAuthError('Authentication required. Run `bootspring auth login` first.');
-  }
-
-  try {
-    const response = await api.callMcpTool(name, args || {});
-    return {
-      content: [{ type: 'text', text: formatTextContent(response.result || response) }]
-    };
-  } catch (error) {
-    const message = error.status === 403
-      ? 'This MCP capability requires a paid Bootspring plan.'
-      : error.message;
-
-    return {
-      content: [{ type: 'text', text: `Error: ${message}` }],
-      isError: true
-    };
-  }
-}
-
-async function proxyResourceRead(uri) {
-  if (!auth.isAuthenticated()) {
-    return {
-      contents: [{
-        uri,
-        mimeType: 'text/plain',
-        text: 'Authentication required. Run `bootspring auth login` first.'
-      }]
-    };
-  }
-
-  try {
-    const response = await api.getMcpResource(uri);
-    return {
-      contents: [{
-        uri: response.uri || uri,
-        mimeType: response.mimeType || 'application/json',
-        text: formatTextContent(response.content || response)
-      }]
-    };
-  } catch (error) {
-    return {
-      contents: [{
-        uri,
-        mimeType: 'text/plain',
-        text: `Error: ${error.message}`
-      }]
-    };
-  }
-}
-
-const toolHandlers = Object.fromEntries(
-  TOOLS.map((tool) => [tool.name, async (args = {}) => proxyToolCall(tool.name, args)])
-);
-
-const resourceHandlers = Object.fromEntries(
-  RESOURCES.map((resource) => [resource.uri, async () => proxyResourceRead(resource.uri)])
-);
-
-async function main() {
-  const server = new Server(
-    { name: 'bootspring', version: VERSION },
-    { capabilities: { tools: {}, resources: {} } }
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: await resolveTools()
-  }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return proxyToolCall(name, args);
-  });
-
-  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-    resources: await resolveResources()
-  }));
-
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => (
-    proxyResourceRead(request.params.uri)
-  ));
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error(`Bootspring MCP proxy v${VERSION} started`);
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    console.error('Failed to start MCP proxy:', error.message);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  TOOLS,
-  RESOURCES,
-  toolHandlers,
-  resourceHandlers,
-  FALLBACK_TOOLS,
-  FALLBACK_RESOURCES,
-  main
-};