@standardagents/code 0.0.2-dev.51cdb4c → 0.1.0

package/src/mcp.ts

@@ -1,563 +0,0 @@
-/**
- * Model Context Protocol (MCP) client + manager.
- *
- * The CLI is the MCP **host**: for each configured server it spawns the process
- * locally and speaks JSON-RPC 2.0 over stdio (newline-delimited UTF-8 frames, as
- * the MCP stdio transport specifies). It performs the real capability handshake
- * (`initialize` → `notifications/initialized`), discovers tools and resources
- * (`tools/list`, `resources/list`), and executes the agent's forwarded calls
- * (`tools/call`, `resources/read`).
- *
- * Nothing here talks to the Standard Agents instance — the instance only ever
- * forwards an `mcp` tool request down the bridge; this module is what turns that
- * into a genuine MCP exchange on the user's machine and returns the result.
- *
- * Zero-dependency: Node globals only.
- */
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import crypto from "node:crypto";
-import type { McpServerConfig } from "./mcp-config.ts";
-
-/** MCP protocol revision this client implements/negotiates. */
-export const MCP_PROTOCOL_VERSION = "2025-06-18";
-/** Protocol versions we know how to speak, newest first (for negotiation fallback). */
-const SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
-
-const CLIENT_INFO = { name: "standard-code", version: "0.1.0" };
-
-interface JsonRpcRequest {
-  jsonrpc: "2.0";
-  id: number;
-  method: string;
-  params?: unknown;
-}
-interface JsonRpcNotification {
-  jsonrpc: "2.0";
-  method: string;
-  params?: unknown;
-}
-interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  id: number;
-  result?: unknown;
-  error?: { code: number; message: string; data?: unknown };
-}
-
-export interface McpToolDef {
-  name: string;
-  description?: string;
-  inputSchema?: Record<string, unknown>;
-}
-
-export interface McpResourceDef {
-  uri: string;
-  name?: string;
-  description?: string;
-  mimeType?: string;
-}
-
-export interface McpServerInfo {
-  name: string;
-  version?: string;
-}
-
-/** A signed-ish provenance record proving which server produced a result. */
-export interface McpAttestation {
-  /** Configured server id. */
-  server: string;
-  /** Server's self-reported identity from `initialize`. */
-  serverInfo: McpServerInfo;
-  /** Negotiated protocol version. */
-  protocolVersion: string;
-  /** Tool or resource invoked. */
-  target: string;
-  /** sha256 of the canonicalized arguments. */
-  argsSha256: string;
-  /** sha256 of the returned content. */
-  resultSha256: string;
-  /** Random per-call nonce. */
-  nonce: string;
-  /** Whether the server flagged the result as an error. */
-  isError: boolean;
-  /** Unix ms when the result was received. */
-  at: number;
-}
-
-export interface McpCallResult {
-  ok: boolean;
-  /** Flattened text content from the server's response. */
-  text: string;
-  attestation: McpAttestation;
-}
-
-/** Public, JSON-serializable view of a connected server (for the KV catalog). */
-export interface McpServerCatalogEntry {
-  name: string;
-  status: "connected" | "error" | "disabled";
-  serverInfo?: McpServerInfo;
-  protocolVersion?: string;
-  instructions?: string;
-  capabilities?: Record<string, unknown>;
-  tools: McpToolDef[];
-  resources: McpResourceDef[];
-  error?: string;
-}
-
-const RPC_TIMEOUT_MS = 30_000;
-// Generous: a first `npx -y <server>` cold-start downloads the package before the
-// server even speaks, which can take a while on a slow network.
-const INIT_TIMEOUT_MS = 90_000;
-
-/**
- * One live connection to a single MCP server process. Owns the child process,
- * the JSON-RPC framing, the pending-request map, and the handshake.
- */
-export class McpClient {
-  private child: ChildProcessWithoutNullStreams | null = null;
-  private nextId = 1;
-  private pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> }>();
-  private buffer = "";
-  private closed = false;
-
-  serverInfo: McpServerInfo;
-  protocolVersion = MCP_PROTOCOL_VERSION;
-  capabilities: Record<string, unknown> = {};
-  instructions = "";
-  tools: McpToolDef[] = [];
-  resources: McpResourceDef[] = [];
-  lastError: string | null = null;
-
-  constructor(private config: McpServerConfig) {
-    this.serverInfo = { name: config.name };
-  }
-
-  /** Spawn the server, run the initialize handshake, and discover capabilities. */
-  async connect(defaultCwd: string): Promise<void> {
-    const child = spawn(this.config.command, this.config.args, {
-      cwd: this.config.cwd || defaultCwd,
-      env: { ...process.env, ...(this.config.env || {}) },
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    this.child = child;
-
-    child.on("error", (err) => this.failAll(new Error(`MCP server '${this.config.name}' failed to start: ${err.message}`)));
-    child.on("exit", (code) => {
-      if (!this.closed) this.failAll(new Error(`MCP server '${this.config.name}' exited (code ${code ?? "unknown"}).`));
-    });
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk: string) => this.onData(chunk));
-    // Surface server stderr only on failure; many servers log freely to stderr.
-    child.stderr.setEncoding("utf8");
-    let stderrTail = "";
-    child.stderr.on("data", (d: string) => {
-      stderrTail = (stderrTail + d).slice(-2000);
-    });
-
-    try {
-      const initResult = (await this.request(
-        "initialize",
-        {
-          protocolVersion: MCP_PROTOCOL_VERSION,
-          capabilities: { tools: {}, resources: {} },
-          clientInfo: CLIENT_INFO,
-        },
-        INIT_TIMEOUT_MS
-      )) as {
-        protocolVersion?: string;
-        capabilities?: Record<string, unknown>;
-        serverInfo?: McpServerInfo;
-        instructions?: string;
-      };
-
-      const negotiated = initResult.protocolVersion || MCP_PROTOCOL_VERSION;
-      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(negotiated)) {
-        // The server insists on a revision we don't implement. Per the spec the
-        // host should disconnect rather than guess at an incompatible wire format.
-        throw new Error(
-          `Server requires unsupported MCP protocol version '${negotiated}' (this client speaks ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")}).`
-        );
-      }
-      this.protocolVersion = negotiated;
-      this.capabilities = initResult.capabilities || {};
-      this.serverInfo = initResult.serverInfo || { name: this.config.name };
-      this.instructions = initResult.instructions || "";
-
-      // Tell the server the handshake is complete before issuing other calls.
-      this.notify("notifications/initialized");
-
-      // Discover what the server offers (guarded by advertised capabilities).
-      if (this.capabilities.tools) await this.refreshTools();
-      if (this.capabilities.resources) await this.refreshResources();
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      this.lastError = stderrTail ? `${msg}\n${stderrTail.trim()}` : msg;
-      this.close();
-      throw new Error(this.lastError);
-    }
-  }
-
-  async refreshTools(): Promise<void> {
-    const res = (await this.request("tools/list", {})) as { tools?: McpToolDef[] };
-    this.tools = Array.isArray(res?.tools) ? res.tools : [];
-  }
-
-  async refreshResources(): Promise<void> {
-    try {
-      const res = (await this.request("resources/list", {})) as { resources?: McpResourceDef[] };
-      this.resources = Array.isArray(res?.resources) ? res.resources : [];
-    } catch {
-      this.resources = []; // resources are optional; tolerate servers that decline
-    }
-  }
-
-  /** Call a tool and return its flattened text + a provenance attestation. */
-  async callTool(name: string, args: Record<string, unknown>): Promise<McpCallResult> {
-    const res = (await this.request("tools/call", { name, arguments: args })) as {
-      content?: Array<Record<string, unknown>>;
-      isError?: boolean;
-      structuredContent?: unknown;
-    };
-    const text = flattenContent(res?.content, res?.structuredContent);
-    return this.attest(name, args, text, !!res?.isError);
-  }
-
-  /** Read a resource and return its flattened text + attestation. */
-  async readResource(uri: string): Promise<McpCallResult> {
-    const res = (await this.request("resources/read", { uri })) as {
-      contents?: Array<Record<string, unknown>>;
-    };
-    const text = flattenResourceContents(res?.contents);
-    return this.attest(uri, { uri }, text, false);
-  }
-
-  private attest(target: string, args: Record<string, unknown>, text: string, isError: boolean): McpCallResult {
-    const attestation: McpAttestation = {
-      server: this.config.name,
-      serverInfo: this.serverInfo,
-      protocolVersion: this.protocolVersion,
-      target,
-      argsSha256: sha256(canonicalJson(args)),
-      resultSha256: sha256(text),
-      nonce: crypto.randomBytes(8).toString("hex"),
-      isError,
-      at: Date.now(),
-    };
-    return { ok: !isError, text, attestation };
-  }
-
-  catalogEntry(): McpServerCatalogEntry {
-    return {
-      name: this.config.name,
-      status: this.lastError ? "error" : "connected",
-      serverInfo: this.serverInfo,
-      protocolVersion: this.protocolVersion,
-      instructions: this.instructions || undefined,
-      capabilities: this.capabilities,
-      tools: this.tools,
-      resources: this.resources,
-      error: this.lastError || undefined,
-    };
-  }
-
-  close(): void {
-    this.closed = true;
-    this.failAll(new Error("connection closed"));
-    try {
-      this.child?.stdin.end();
-    } catch {
-      /* ignore */
-    }
-    try {
-      this.child?.kill("SIGTERM");
-    } catch {
-      /* ignore */
-    }
-    this.child = null;
-  }
-
-  // ── JSON-RPC plumbing ─────────────────────────────────────────────────────
-
-  private request(method: string, params: unknown, timeoutMs = RPC_TIMEOUT_MS): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-      if (!this.child || this.closed) {
-        reject(new Error(`MCP server '${this.config.name}' is not connected.`));
-        return;
-      }
-      const id = this.nextId++;
-      const payload: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`MCP request '${method}' to '${this.config.name}' timed out after ${timeoutMs}ms.`));
-      }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
-      this.write(payload);
-    });
-  }
-
-  private notify(method: string, params?: unknown): void {
-    const payload: JsonRpcNotification = { jsonrpc: "2.0", method, params };
-    this.write(payload);
-  }
-
-  private write(payload: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): void {
-    if (!this.child) return;
-    try {
-      // Newline-delimited JSON: one message per line, no embedded newlines.
-      this.child.stdin.write(JSON.stringify(payload) + "\n");
-    } catch (err) {
-      this.failAll(err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-
-  private onData(chunk: string): void {
-    this.buffer += chunk;
-    let nl: number;
-    while ((nl = this.buffer.indexOf("\n")) >= 0) {
-      const line = this.buffer.slice(0, nl).trim();
-      this.buffer = this.buffer.slice(nl + 1);
-      if (!line) continue;
-      let msg: JsonRpcResponse & JsonRpcRequest & JsonRpcNotification;
-      try {
-        msg = JSON.parse(line);
-      } catch {
-        continue; // ignore non-JSON noise (some servers print banners)
-      }
-      this.dispatch(msg);
-    }
-  }
-
-  private dispatch(msg: JsonRpcResponse & Partial<JsonRpcRequest>): void {
-    // A response to one of our requests.
-    if (typeof msg.id === "number" && (("result" in msg) || ("error" in msg)) && msg.method === undefined) {
-      const entry = this.pending.get(msg.id);
-      if (!entry) return;
-      this.pending.delete(msg.id);
-      clearTimeout(entry.timer);
-      if (msg.error) entry.reject(new Error(`${msg.error.message} (code ${msg.error.code})`));
-      else entry.resolve(msg.result);
-      return;
-    }
-    // A request FROM the server to us. We don't offer sampling/roots, so reply
-    // politely: answer pings, decline everything else with method-not-found so
-    // the server never hangs waiting on us.
-    if (msg.method && typeof msg.id === "number") {
-      if (msg.method === "ping") {
-        this.write({ jsonrpc: "2.0", id: msg.id, result: {} });
-      } else {
-        this.write({
-          jsonrpc: "2.0",
-          id: msg.id,
-          error: { code: -32601, message: `Method not supported by host: ${msg.method}` },
-        });
-      }
-      return;
-    }
-    // A notification from the server (e.g. tools/list_changed) — refresh lazily.
-    if (msg.method && msg.id === undefined) {
-      if (msg.method === "notifications/tools/list_changed") void this.refreshTools().catch(() => {});
-      if (msg.method === "notifications/resources/list_changed") void this.refreshResources().catch(() => {});
-    }
-  }
-
-  private failAll(err: Error): void {
-    for (const [, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.reject(err);
-    }
-    this.pending.clear();
-  }
-}
-
-/**
- * Manages every configured MCP server connection for a session: connects the
- * enabled ones, exposes a catalog for context injection, and dispatches the
- * agent's forwarded `mcp` tool calls to the right client.
- */
-export class McpManager {
-  private clients = new Map<string, McpClient>();
-  /** Last attestations produced this session (most recent last). */
-  private attestations: McpAttestation[] = [];
-
-  constructor(private defaultCwd: string) {}
-
-  /** Connect one server (replacing any existing client of the same name). */
-  async connect(config: McpServerConfig): Promise<McpClient> {
-    this.disconnect(config.name);
-    const client = new McpClient(config);
-    this.clients.set(config.name, client);
-    await client.connect(this.defaultCwd);
-    return client;
-  }
-
-  disconnect(name: string): void {
-    const existing = this.clients.get(name);
-    if (existing) {
-      existing.close();
-      this.clients.delete(name);
-    }
-  }
-
-  closeAll(): void {
-    for (const [, c] of this.clients) c.close();
-    this.clients.clear();
-  }
-
-  get(name: string): McpClient | undefined {
-    return this.clients.get(name);
-  }
-
-  connectedNames(): string[] {
-    return Array.from(this.clients.keys()).sort();
-  }
-
-  toolCount(): number {
-    let n = 0;
-    for (const [, c] of this.clients) n += c.tools.length;
-    return n;
-  }
-
-  /** A JSON-serializable catalog of every connected server for the KV/context. */
-  catalog(): { servers: McpServerCatalogEntry[]; generatedAt: number } {
-    return {
-      servers: Array.from(this.clients.values()).map((c) => c.catalogEntry()),
-      generatedAt: Date.now(),
-    };
-  }
-
-  recentAttestations(n = 10): McpAttestation[] {
-    return this.attestations.slice(-n);
-  }
-
-  /** Execute a forwarded `mcp` tool request and return host-shaped text. */
-  async dispatch(args: Record<string, unknown>): Promise<{ ok: boolean; result?: string; error?: string }> {
-    const action = String(args.action || "call");
-    const serverName = typeof args.server === "string" ? args.server : "";
-
-    if (action === "list") {
-      // A concise inventory of connected MCP servers (name + tool count) — what
-      // the agent should consult to answer "which MCP servers are installed?".
-      const servers = this.catalog().servers.map((s) => ({
-        name: s.name,
-        tools: s.tools.length,
-        resources: s.resources?.length ?? 0,
-      }));
-      return {
-        ok: true,
-        result: servers.length
-          ? JSON.stringify({ servers }, null, 2)
-          : "No MCP servers are connected. The user can add one with the /mcp command, or you can install one with install_mcp.",
-      };
-    }
-
-    if (action === "list_tools") {
-      // No server → list everything; a server → just that one.
-      const cat = this.catalog().servers.filter((s) => !serverName || s.name === serverName);
-      if (!cat.length) return { ok: false, error: serverName ? `No connected MCP server named '${serverName}'.` : "No MCP servers are connected. The user can add one with the /mcp command." };
-      return { ok: true, result: JSON.stringify(cat, null, 2) };
-    }
-
-    const client = this.clients.get(serverName);
-    if (!client) {
-      const avail = this.connectedNames();
-      return {
-        ok: false,
-        error: avail.length
-          ? `No connected MCP server named '${serverName}'. Connected servers: ${avail.join(", ")}.`
-          : `No MCP servers are connected. The user can add one with the /mcp command.`,
-      };
-    }
-
-    try {
-      let res: McpCallResult;
-      if (action === "read_resource") {
-        const uri = String(args.uri || "");
-        if (!uri) return { ok: false, error: "read_resource requires a 'uri'." };
-        res = await client.readResource(uri);
-      } else {
-        const toolName = String(args.tool || "");
-        if (!toolName) return { ok: false, error: "call requires a 'tool' name." };
-        const callArgs = parseArgs(args.arguments_json);
-        if (callArgs instanceof Error) return { ok: false, error: callArgs.message };
-        res = await client.callTool(toolName, callArgs);
-      }
-
-      this.attestations.push(res.attestation);
-      const footer = formatAttestation(res.attestation);
-      if (!res.ok) {
-        return { ok: false, error: `${res.text || "The MCP tool reported an error."}\n${footer}` };
-      }
-      return { ok: true, result: `${res.text}\n${footer}` };
-    } catch (err) {
-      return { ok: false, error: err instanceof Error ? err.message : String(err) };
-    }
-  }
-}
-
-// ── helpers ──────────────────────────────────────────────────────────────────
-
-function parseArgs(raw: unknown): Record<string, unknown> | Error {
-  if (raw == null || raw === "") return {};
-  if (typeof raw === "object") return raw as Record<string, unknown>;
-  if (typeof raw !== "string") return new Error("arguments_json must be a JSON object string.");
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as Record<string, unknown>;
-    return new Error("arguments_json must encode a JSON object.");
-  } catch (e) {
-    return new Error(`arguments_json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
-  }
-}
-
-/** Flatten MCP tool-call `content` blocks into a single text string. */
-function flattenContent(content: Array<Record<string, unknown>> | undefined, structured: unknown): string {
-  const parts: string[] = [];
-  for (const block of content || []) {
-    if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
-    else if (block.type === "resource" && block.resource && typeof block.resource === "object") {
-      const r = block.resource as Record<string, unknown>;
-      if (typeof r.text === "string") parts.push(r.text);
-      else parts.push(`[resource ${String(r.uri ?? "")}]`);
-    } else if (block.type === "image") parts.push(`[image ${String(block.mimeType ?? "")}]`);
-    else if (block.type === "audio") parts.push(`[audio ${String(block.mimeType ?? "")}]`);
-    else parts.push(JSON.stringify(block));
-  }
-  if (!parts.length && structured !== undefined) parts.push(JSON.stringify(structured, null, 2));
-  return parts.join("\n").trim();
-}
-
-function flattenResourceContents(contents: Array<Record<string, unknown>> | undefined): string {
-  const parts: string[] = [];
-  for (const c of contents || []) {
-    if (typeof c.text === "string") parts.push(c.text);
-    else if (typeof c.blob === "string") parts.push(`[binary resource ${String(c.uri ?? "")} (${c.blob.length} b64 chars)]`);
-  }
-  return parts.join("\n").trim();
-}
-
-function formatAttestation(a: McpAttestation): string {
-  const id = `${a.serverInfo.name}${a.serverInfo.version ? `@${a.serverInfo.version}` : ""}`;
-  return (
-    `[attestation] server=${a.server} (${id}) protocol=${a.protocolVersion} ` +
-    `target=${a.target} args_sha256=${a.argsSha256.slice(0, 16)} ` +
-    `result_sha256=${a.resultSha256.slice(0, 16)} nonce=${a.nonce}`
-  );
-}
-
-/** Stable JSON for hashing (sorted keys) so identical args hash identically. */
-function canonicalJson(value: unknown): string {
-  return JSON.stringify(sortKeys(value));
-}
-function sortKeys(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(sortKeys);
-  if (value && typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const k of Object.keys(value as Record<string, unknown>).sort()) {
-      out[k] = sortKeys((value as Record<string, unknown>)[k]);
-    }
-    return out;
-  }
-  return value;
-}
-function sha256(input: string): string {
-  return crypto.createHash("sha256").update(input).digest("hex");
-}

package/src/permissions.ts

@@ -1,53 +0,0 @@
-/**
- * Permission engine. Combines the current mode with the model-supplied risk
- * (1–5) to decide whether a forwarded tool runs automatically, needs the user's
- * approval, or is blocked outright.
- */
-import type { Level } from "./types.ts";
-
-export type Decision = "allow" | "ask" | "deny";
-
-export interface PermissionState {
-  /** Auto-accept level 1–5: calls at risk ≤ level run automatically; riskier ones ask. */
-  level: Level;
-  /** Tool names the user chose to always allow this session. */
-  alwaysAllow: Set<string>;
-  /** Risk levels the user chose to always allow this session ("allow all level N"). */
-  allowRisk: Set<number>;
-}
-
-export function decide(
-  state: PermissionState,
-  tool: string,
-  risk: number | null,
-  hasPermissionRequest: boolean
-): Decision {
-  const effectiveRisk = typeof risk === "number" ? Math.min(5, Math.max(1, risk)) : hasPermissionRequest ? 3 : 1;
-
-  // Standing approvals the user granted this session: a specific tool, or every
-  // call at a given risk level. The risk profile is aware of both.
-  if (state.alwaysAllow.has(tool)) return "allow";
-  if (state.allowRisk.has(effectiveRisk)) return "allow";
-
-  // The auto-accept level: anything at or below it runs without asking.
-  return effectiveRisk <= state.level ? "allow" : "ask";
-}
-
-/**
- * Catastrophic-command guard that applies regardless of mode. These are blocked
- * even in bypass mode — a coding agent should never be able to wipe the machine.
- */
-const CATASTROPHIC_PATTERNS: RegExp[] = [
-  /\brm\s+(-[a-z]*\s+)*-[a-z]*f[a-z]*\s+(-[a-z]*\s+)*(\/|~|\$HOME|\/\*|\.\s*$|\/\s*$)/i, // rm -rf / , rm -rf ~
-  /\brm\s+-rf\s+--no-preserve-root/i,
-  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/, // fork bomb
-  /\bmkfs(\.\w+)?\b/i, // format filesystem
-  /\bdd\b[^\n]*\bof=\/dev\/(sd|disk|nvme|hd)/i, // overwrite raw disk
-  /\b(shutdown|reboot|halt|poweroff)\b/i,
-  />\s*\/dev\/(sd|disk|nvme|hd)/i,
-  /\bchmod\s+-R\s+(000|777)\s+\/(?:\s|$)/i,
-];
-
-export function isCatastrophic(command: string): boolean {
-  return CATASTROPHIC_PATTERNS.some((re) => re.test(command));
-}