baselineos 0.2.0-beta.1

package/dist/mcp/server.js

@@ -0,0 +1,676 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+// src/mcp/server.ts
+var TOOL_RISKS = {
+  search_knowledge: { level: "low", requiresEscalation: false, reason: "Read-only retrieval" },
+  get_context: { level: "low", requiresEscalation: false, reason: "Read-only retrieval" },
+  get_context_delta: { level: "low", requiresEscalation: false, reason: "Read-only retrieval" },
+  remember: { level: "medium", requiresEscalation: false, reason: "Writes to memory store" },
+  recall: { level: "low", requiresEscalation: false, reason: "Read-only memory access" },
+  run_task: { level: "high", requiresEscalation: true, reason: "Triggers autonomous execution" },
+  list_tasks: { level: "low", requiresEscalation: false, reason: "Read-only task listing" },
+  list_workflows: { level: "low", requiresEscalation: false, reason: "Read-only workflow listing" },
+  run_workflow: { level: "high", requiresEscalation: true, reason: "Triggers autonomous execution" },
+  get_checkpoint: { level: "medium", requiresEscalation: false, reason: "Reads checkpoint state" },
+  recover_checkpoint: { level: "high", requiresEscalation: true, reason: "Recovers task state" },
+  get_task_audit: { level: "medium", requiresEscalation: false, reason: "Reads audit trail" },
+  get_evidence_bundle: { level: "medium", requiresEscalation: false, reason: "Reads evidence bundle" },
+  get_task: { level: "low", requiresEscalation: false, reason: "Read-only task access" },
+  stats: { level: "low", requiresEscalation: false, reason: "Read-only stats" },
+  get_tool_risks: { level: "low", requiresEscalation: false, reason: "Read-only tool metadata" }
+};
+var CONTEXT_LEVELS = ["oneliner", "summary", "working", "full", "expanded"];
+var TASK_PRIORITIES = ["critical", "high", "medium", "low"];
+var TASK_STATUSES = [
+  "pending",
+  "planning",
+  "executing",
+  "verifying",
+  "reviewing",
+  "correcting",
+  "completed",
+  "failed",
+  "blocked"
+];
+var MEMORY_SCOPES = ["working", "session", "long-term", "shared"];
+var RETRIEVE_SCOPES = [...MEMORY_SCOPES, "all"];
+function parsePolicy(value) {
+  if (!value || typeof value !== "object") return void 0;
+  return value;
+}
+function parseBudget(value) {
+  if (!value || typeof value !== "object") return void 0;
+  return value;
+}
+function parseLevel(value) {
+  if (typeof value === "string" && CONTEXT_LEVELS.includes(value)) {
+    return value;
+  }
+  return "working";
+}
+function parseOverlayOrder(value) {
+  if (!Array.isArray(value)) return void 0;
+  const overlays = value.map((entry) => String(entry)).filter((entry) => entry === "org" || entry === "repo" || entry === "public");
+  return overlays.length > 0 ? overlays : void 0;
+}
+function parseMemoryScope(value) {
+  if (typeof value === "string" && MEMORY_SCOPES.includes(value)) {
+    return value;
+  }
+  return "session";
+}
+function parseRetrieveScope(value) {
+  if (typeof value === "string" && RETRIEVE_SCOPES.includes(value)) {
+    return value;
+  }
+  return "all";
+}
+function parseTaskPriority(value) {
+  if (typeof value === "string" && TASK_PRIORITIES.includes(value)) {
+    return value;
+  }
+  return "medium";
+}
+function parseTaskStatus(value) {
+  if (typeof value === "string" && TASK_STATUSES.includes(value)) {
+    return value;
+  }
+  return void 0;
+}
+function parseAcceptanceCriteria(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => {
+    return Boolean(entry && typeof entry === "object" && typeof entry.description === "string");
+  }).map((entry) => ({
+    description: entry.description,
+    type: entry.type ?? "automated",
+    weight: typeof entry.weight === "number" ? entry.weight : 1
+  }));
+}
+var MCPServer = class {
+  baseline;
+  server;
+  transport;
+  running = false;
+  constructor(baseline) {
+    this.baseline = baseline;
+  }
+  async start() {
+    if (this.running) return;
+    this.server = new Server(
+      { name: "baselineos", version: "0.2.0-beta.1" },
+      { capabilities: { tools: {}, resources: {} } }
+    );
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: this.getTools()
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const name = request.params.name;
+      const args = request.params.arguments || {};
+      try {
+        const result = await this.handleToolCall(name, args);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { error: error.message || "Unknown error" },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: this.getResources()
+    }));
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const resource = await this.readResource(uri);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(resource, null, 2)
+          }
+        ]
+      };
+    });
+    this.transport = new StdioServerTransport();
+    await this.server.connect(this.transport);
+    this.running = true;
+    console.error("[MCP] Server started (stdio)");
+  }
+  async stop() {
+    this.running = false;
+    console.error("[MCP] Server stopped");
+  }
+  isRunning() {
+    return this.running;
+  }
+  getTools() {
+    return [
+      {
+        name: "search_knowledge",
+        description: "Search the BaselineOS knowledge index",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string" },
+            limit: { type: "number", default: 5 },
+            policy: {
+              type: "object",
+              properties: {
+                repo: { type: "array", items: { type: "string" } },
+                overlays: { type: "array", items: { type: "string", enum: ["org", "repo", "public"] } },
+                sensitivity: { type: "string", enum: ["public", "internal", "restricted"] },
+                scopes: { type: "array", items: { type: "string" } },
+                roles: { type: "array", items: { type: "string" } }
+              },
+              additionalProperties: false
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "get_context",
+        description: "Get context for a subject at a specified compression level",
+        inputSchema: {
+          type: "object",
+          properties: {
+            subject: { type: "string" },
+            level: {
+              type: "string",
+              enum: ["oneliner", "summary", "working", "full", "expanded"],
+              default: "working"
+            },
+            policy: {
+              type: "object",
+              properties: {
+                repo: { type: "array", items: { type: "string" } },
+                overlays: { type: "array", items: { type: "string", enum: ["org", "repo", "public"] } },
+                sensitivity: { type: "string", enum: ["public", "internal", "restricted"] },
+                scopes: { type: "array", items: { type: "string" } },
+                roles: { type: "array", items: { type: "string" } }
+              },
+              additionalProperties: false
+            },
+            overlayOrder: { type: "array", items: { type: "string", enum: ["org", "repo", "public"] } },
+            budget: {
+              type: "object",
+              properties: {
+                maxTokens: { type: "number" },
+                maxCostUsd: { type: "number" },
+                costPer1kTokensUsd: { type: "number" }
+              },
+              additionalProperties: false
+            }
+          },
+          required: ["subject"]
+        }
+      },
+      {
+        name: "get_context_delta",
+        description: "Get only changed/unknown context for a subject (delta compression)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            subject: { type: "string" },
+            level: {
+              type: "string",
+              enum: ["oneliner", "summary", "working", "full", "expanded"],
+              default: "working"
+            },
+            known: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  hash: { type: "string" }
+                },
+                required: ["id"],
+                additionalProperties: false
+              }
+            },
+            policy: {
+              type: "object",
+              properties: {
+                repo: { type: "array", items: { type: "string" } },
+                overlays: { type: "array", items: { type: "string", enum: ["org", "repo", "public"] } },
+                sensitivity: { type: "string", enum: ["public", "internal", "restricted"] },
+                scopes: { type: "array", items: { type: "string" } },
+                roles: { type: "array", items: { type: "string" } }
+              },
+              additionalProperties: false
+            },
+            overlayOrder: { type: "array", items: { type: "string", enum: ["org", "repo", "public"] } },
+            budget: {
+              type: "object",
+              properties: {
+                maxTokens: { type: "number" },
+                maxCostUsd: { type: "number" },
+                costPer1kTokensUsd: { type: "number" }
+              },
+              additionalProperties: false
+            }
+          },
+          required: ["subject"]
+        }
+      },
+      {
+        name: "remember",
+        description: "Store a value in memory",
+        inputSchema: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            value: {},
+            scope: {
+              type: "string",
+              enum: ["working", "session", "long-term", "shared"],
+              default: "session"
+            },
+            sessionId: { type: "string" },
+            taskId: { type: "string" },
+            repo: { type: "string" },
+            persona: { type: "string" },
+            ttl: { type: "number" },
+            tags: { type: "array", items: { type: "string" } }
+          },
+          required: ["key", "value"]
+        }
+      },
+      {
+        name: "recall",
+        description: "Retrieve a value from memory",
+        inputSchema: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            scope: {
+              type: "string",
+              enum: ["working", "session", "long-term", "shared", "all"],
+              default: "all"
+            },
+            sessionId: { type: "string" },
+            taskId: { type: "string" },
+            repo: { type: "string" },
+            persona: { type: "string" }
+          },
+          required: ["key"]
+        }
+      },
+      {
+        name: "run_task",
+        description: "Execute a task in BaselineOS",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            description: { type: "string" },
+            priority: {
+              type: "string",
+              enum: ["critical", "high", "medium", "low"],
+              default: "medium"
+            },
+            requiredCapabilities: { type: "array", items: { type: "string" } },
+            acceptanceCriteria: { type: "array" },
+            context: { type: "object" },
+            blocking: { type: "boolean", default: false },
+            timeout: { type: "number", default: 3e5 },
+            allowHighRisk: { type: "boolean", default: false },
+            reason: { type: "string" }
+          },
+          required: ["title", "description"]
+        }
+      },
+      {
+        name: "list_tasks",
+        description: "List tasks by status",
+        inputSchema: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              enum: [
+                "pending",
+                "planning",
+                "executing",
+                "verifying",
+                "reviewing",
+                "correcting",
+                "completed",
+                "failed",
+                "blocked"
+              ]
+            }
+          }
+        }
+      },
+      {
+        name: "list_workflows",
+        description: "List registered workflows",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "run_workflow",
+        description: "Execute a workflow by ID",
+        inputSchema: {
+          type: "object",
+          properties: {
+            workflowId: { type: "string" },
+            title: { type: "string" },
+            description: { type: "string" },
+            priority: {
+              type: "string",
+              enum: ["critical", "high", "medium", "low"],
+              default: "medium"
+            },
+            requiredCapabilities: { type: "array", items: { type: "string" } },
+            acceptanceCriteria: { type: "array" },
+            context: { type: "object" },
+            blocking: { type: "boolean", default: false },
+            timeout: { type: "number", default: 3e5 },
+            allowHighRisk: { type: "boolean", default: false },
+            reason: { type: "string" }
+          },
+          required: ["workflowId"]
+        }
+      },
+      {
+        name: "get_checkpoint",
+        description: "Get checkpoint by ID",
+        inputSchema: {
+          type: "object",
+          properties: {
+            checkpointId: { type: "string" },
+            allowHighRisk: { type: "boolean", default: false },
+            reason: { type: "string" }
+          },
+          required: ["checkpointId"]
+        }
+      },
+      {
+        name: "recover_checkpoint",
+        description: "Recover a task from checkpoint",
+        inputSchema: {
+          type: "object",
+          properties: {
+            checkpointId: { type: "string" }
+          },
+          required: ["checkpointId"]
+        }
+      },
+      {
+        name: "get_task_audit",
+        description: "Get audit trail for a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string" }
+          },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "get_evidence_bundle",
+        description: "Get evidence bundle for a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string" }
+          },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "get_task",
+        description: "Get a specific task by ID",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string" }
+          },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "stats",
+        description: "Get BaselineOS system stats",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "get_tool_risks",
+        description: "Get risk scoring for MCP tools",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ];
+  }
+  getResources() {
+    return [
+      {
+        uri: "baseline://tasks",
+        name: "Tasks",
+        description: "Task list and status",
+        mimeType: "application/json"
+      },
+      {
+        uri: "baseline://agents",
+        name: "Agents",
+        description: "Agent registry",
+        mimeType: "application/json"
+      },
+      {
+        uri: "baseline://stats",
+        name: "Stats",
+        description: "System statistics",
+        mimeType: "application/json"
+      }
+    ];
+  }
+  async handleToolCall(name, args) {
+    const riskDecision = this.enforceToolRisk(name, args);
+    if (!riskDecision.allowed) {
+      return riskDecision.response ?? {
+        error: "escalation_required",
+        tool: name,
+        risk: { level: "high", requiresEscalation: true, reason: "Escalation required" },
+        next: "retry_with_escalation=true"
+      };
+    }
+    switch (name) {
+      case "search_knowledge": {
+        const query = String(args.query ?? "");
+        const limit = typeof args.limit === "number" ? args.limit : 5;
+        const policy = parsePolicy(args.policy);
+        return this.baseline.search(query, { limit, policy });
+      }
+      case "get_context": {
+        const subject = String(args.subject ?? "");
+        const level = parseLevel(args.level);
+        const policy = parsePolicy(args.policy);
+        const overlayOrder = parseOverlayOrder(args.overlayOrder);
+        const budget = parseBudget(args.budget);
+        return this.baseline.getContext(subject, level, { policy, overlayOrder, budget });
+      }
+      case "get_context_delta": {
+        const subject = String(args.subject ?? "");
+        const level = parseLevel(args.level);
+        const policy = parsePolicy(args.policy);
+        const overlayOrder = parseOverlayOrder(args.overlayOrder);
+        const known = Array.isArray(args.known) ? args.known : void 0;
+        const budget = parseBudget(args.budget);
+        return this.baseline.getContextDelta(subject, level, { policy, overlayOrder, known, budget });
+      }
+      case "remember": {
+        const key = String(args.key ?? "");
+        const value = args.value;
+        const scope = parseMemoryScope(args.scope);
+        await this.baseline.remember(key, value, {
+          scope,
+          sessionId: typeof args.sessionId === "string" ? args.sessionId : void 0,
+          taskId: typeof args.taskId === "string" ? args.taskId : void 0,
+          repo: typeof args.repo === "string" ? args.repo : void 0,
+          persona: typeof args.persona === "string" ? args.persona : void 0,
+          ttl: typeof args.ttl === "number" ? args.ttl : void 0,
+          tags: Array.isArray(args.tags) ? args.tags : void 0
+        });
+        return { status: "ok" };
+      }
+      case "recall": {
+        const key = String(args.key ?? "");
+        const scope = parseRetrieveScope(args.scope);
+        return { value: await this.baseline.recall(key, {
+          scope,
+          sessionId: typeof args.sessionId === "string" ? args.sessionId : void 0,
+          taskId: typeof args.taskId === "string" ? args.taskId : void 0,
+          repo: typeof args.repo === "string" ? args.repo : void 0,
+          persona: typeof args.persona === "string" ? args.persona : void 0
+        }) };
+      }
+      case "run_task": {
+        const input = {
+          title: String(args.title ?? ""),
+          description: String(args.description ?? ""),
+          priority: parseTaskPriority(args.priority),
+          requiredCapabilities: Array.isArray(args.requiredCapabilities) ? args.requiredCapabilities : [],
+          acceptanceCriteria: parseAcceptanceCriteria(args.acceptanceCriteria),
+          context: args.context && typeof args.context === "object" ? args.context : {}
+        };
+        const handle = await this.baseline.run(input);
+        const blocking = Boolean(args.blocking);
+        if (blocking) {
+          const task = await handle.wait(typeof args.timeout === "number" ? args.timeout : 3e5);
+          return { task };
+        }
+        return { taskId: handle.id, status: handle.status };
+      }
+      case "list_tasks": {
+        const status = parseTaskStatus(args.status);
+        return this.baseline.listTasks(status ? { status } : void 0);
+      }
+      case "list_workflows": {
+        return this.baseline.listWorkflows();
+      }
+      case "run_workflow": {
+        const workflowId = String(args.workflowId ?? "");
+        const handle = await this.baseline.runWorkflow(workflowId, {
+          title: typeof args.title === "string" ? args.title : void 0,
+          description: typeof args.description === "string" ? args.description : void 0,
+          priority: parseTaskPriority(args.priority),
+          requiredCapabilities: Array.isArray(args.requiredCapabilities) ? args.requiredCapabilities : void 0,
+          acceptanceCriteria: parseAcceptanceCriteria(args.acceptanceCriteria),
+          context: args.context && typeof args.context === "object" ? args.context : void 0
+        });
+        const blocking = Boolean(args.blocking);
+        if (blocking) {
+          const task = await handle.wait(typeof args.timeout === "number" ? args.timeout : 3e5);
+          return { task };
+        }
+        return { taskId: handle.id, status: handle.status };
+      }
+      case "get_checkpoint": {
+        const checkpointId = String(args.checkpointId ?? "");
+        const checkpoint = this.baseline.loadCheckpoint(checkpointId);
+        if (!checkpoint) return { error: "not_found" };
+        return { checkpoint };
+      }
+      case "recover_checkpoint": {
+        const checkpointId = String(args.checkpointId ?? "");
+        const task = this.baseline.recoverTaskFromCheckpoint(checkpointId);
+        if (!task) return { error: "not_found" };
+        return { task };
+      }
+      case "get_task_audit": {
+        const taskId = String(args.taskId ?? "");
+        return { taskId, audit: this.baseline.getAuditTrail(taskId) };
+      }
+      case "get_evidence_bundle": {
+        const taskId = String(args.taskId ?? "");
+        return { taskId, bundle: this.baseline.getEvidenceBundle(taskId) };
+      }
+      case "get_task": {
+        const taskId = String(args.taskId ?? "");
+        const task = this.baseline.getTask(taskId);
+        if (!task) return { error: "not_found" };
+        return task;
+      }
+      case "stats": {
+        return this.baseline.getStats();
+      }
+      case "get_tool_risks": {
+        return { tools: TOOL_RISKS };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  }
+  enforceToolRisk(name, args) {
+    const risk = TOOL_RISKS[name];
+    if (!risk || !risk.requiresEscalation) {
+      return { allowed: true };
+    }
+    const allowHighRisk = args.allowHighRisk === true;
+    const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+    if (!allowHighRisk || reason.length === 0) {
+      return {
+        allowed: false,
+        response: {
+          error: "escalation_required",
+          tool: name,
+          risk,
+          next: "Retry with { allowHighRisk: true, reason: '...' } after supervisor approval."
+        }
+      };
+    }
+    return { allowed: true };
+  }
+  async readResource(uri) {
+    switch (uri) {
+      case "baseline://tasks":
+        return this.baseline.listTasks();
+      case "baseline://agents":
+        return this.baseline.listAgents();
+      case "baseline://stats":
+        return this.baseline.getStats();
+      default:
+        return { error: "not_found" };
+    }
+  }
+};
+/**
+ * BaselineOS MCP Server
+ *
+ * Model Context Protocol server for Claude Desktop and other MCP clients.
+ *
+ * @license Apache-2.0
+ */
+
+export { MCPServer };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map