@init-computer/mcp 0.1.0

package/bin/init-mcp.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import readline from "node:readline";
+import { InitApiError, createClient } from "../../sdk/dist/index.js";
+
+const client = createClient({
+  apiKey: process.env.INIT_API_KEY,
+  baseUrl: process.env.INIT_API_BASE_URL,
+});
+
+const tools = [
+  {
+    name: "init_generate",
+    description: "Create or edit an Init API resource from a natural language prompt.",
+    inputSchema: objectSchema({
+      prompt: stringSchema("API to generate or edit."),
+      resource_id: optionalStringSchema("Existing resource id when editing."),
+      directories: arraySchema("Directory names to attach if they already exist."),
+    }, ["prompt"]),
+    handler: (args) => client.generate(args),
+  },
+	{
+		name: "init_generate_project",
+		description: "Create an Init project and a cohesive suite of one to seven generated endpoints.",
+		inputSchema: objectSchema({
+			prompt: stringSchema("Project and endpoint suite to generate."),
+			name: optionalStringSchema("Optional project name."),
+			description: optionalStringSchema("Optional project description."),
+		}, ["prompt"]),
+		handler: (args) => client.project.generate(args),
+	},
+	{
+		name: "init_edit_project",
+		description: "Add endpoints or create new versions of endpoints in an Init project.",
+		inputSchema: objectSchema({ project_id: stringSchema("Project id."), prompt: stringSchema("Project change request.") }, ["project_id", "prompt"]),
+		handler: ({ project_id, prompt }) => client.project.edit(project_id, { prompt }),
+	},
+  {
+    name: "init_run",
+    description: "Call a generated Init API route.",
+    inputSchema: objectSchema({
+      route: stringSchema("Route id, /vN/route path, or full URL."),
+      version: numberSchema("Version number when route is a bare id."),
+      input: freeObjectSchema("Request body to send to the generated endpoint."),
+      requestFormat: stringSchema("json or multipart/form-data."),
+    }, ["route"]),
+    handler: ({ route, version, input, requestFormat }) => client.run(route, input || {}, { version, requestFormat }),
+  },
+  {
+    name: "init_list_resources",
+    description: "List generated Init API resources owned by the API key user.",
+    inputSchema: freeObjectSchema("Optional resource filters."),
+    handler: (args) => client.resource.list(args || {}),
+  },
+  {
+    name: "init_get_resource",
+    description: "Get full details for one generated resource.",
+    inputSchema: objectSchema({ id: stringSchema("Resource id.") }, ["id"]),
+    handler: ({ id }) => client.resource.get(id),
+  },
+  {
+    name: "init_list_directories",
+    description: "List flat Init directories.",
+    inputSchema: freeObjectSchema("Optional directory filters."),
+    handler: (args) => client.directory.list(args || {}),
+  },
+  {
+    name: "init_list_daemons",
+    description: "List Init daemon workflows.",
+    inputSchema: freeObjectSchema("Optional daemon filters."),
+    handler: (args) => client.daemon.list(args || {}),
+  },
+  {
+    name: "init_create_daemon",
+    description: "Create a daemon for an existing Init resource/version.",
+    inputSchema: objectSchema({
+      resource_id: stringSchema("Resource id."),
+      version_id: stringSchema("Version id."),
+      input: freeObjectSchema("Daemon input body."),
+      interval_seconds: numberSchema("Interval in seconds."),
+      max_runs: numberSchema("Optional max run count."),
+      description: stringSchema("Optional daemon description."),
+      schedule: stringSchema("Schedule type or label."),
+    }, ["resource_id", "version_id", "input", "interval_seconds"]),
+    handler: (args) => client.daemon.create(args),
+  },
+  {
+    name: "init_run_daemon",
+    description: "Run a daemon once immediately.",
+    inputSchema: objectSchema({ id: stringSchema("Daemon id.") }, ["id"]),
+    handler: ({ id }) => client.daemon.run(id),
+  },
+  {
+    name: "init_list_packages",
+    description: "List package catalog entries and packages enabled for the user.",
+    inputSchema: freeObjectSchema("Optional package filters."),
+    handler: (args) => client.pkg.list(args || {}),
+  },
+];
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: false,
+});
+
+rl.on("line", async (line) => {
+  if (!line.trim()) return;
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch (error) {
+    send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+    return;
+  }
+  try {
+    const result = await handle(request);
+    if (request.id !== undefined) send({ jsonrpc: "2.0", id: request.id, result });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    send({
+      jsonrpc: "2.0",
+      id: request.id ?? null,
+      error: {
+        code: error instanceof InitApiError ? -32001 : -32603,
+        message,
+        data: error instanceof InitApiError ? { status: error.status, details: error.details } : undefined,
+      },
+    });
+  }
+});
+
+async function handle(request) {
+  switch (request.method) {
+    case "initialize":
+      return {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "init-mcp", version: "0.1.0" },
+      };
+    case "tools/list":
+      return { tools: tools.map(({ handler, ...tool }) => tool) };
+    case "tools/call": {
+      const name = request.params?.name;
+      const tool = tools.find((candidate) => candidate.name === name);
+      if (!tool) {
+        throw new Error(`Unknown tool: ${name}`);
+      }
+      const output = await tool.handler(request.params?.arguments || {});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+          },
+        ],
+      };
+    }
+    case "ping":
+      return {};
+    default:
+      throw new Error(`Unsupported MCP method: ${request.method}`);
+  }
+}
+
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function objectSchema(properties, required = []) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    required,
+  };
+}
+
+function freeObjectSchema(description) {
+  return {
+    type: "object",
+    description,
+    additionalProperties: true,
+    properties: {},
+  };
+}
+
+function stringSchema(description) {
+  return { type: "string", description };
+}
+
+function optionalStringSchema(description) {
+  return { type: "string", description };
+}
+
+function numberSchema(description) {
+  return { type: "number", description };
+}
+
+function arraySchema(description) {
+  return { type: "array", description, items: { type: "string" } };
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@init-computer/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Init generated backend APIs.",
+  "type": "module",
+  "bin": {
+    "init-mcp": "./bin/init-mcp.js"
+  },
+  "dependencies": {
+    "@init-computer/sdk": "^0.1.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED"
+}