synartesis 0.1.0

package/dist/proxy.js

@@ -0,0 +1,913 @@
+#!/usr/bin/env node
+import {
+  cliCommandFrom,
+  connectStdioUpstream,
+  createPolicyResolver,
+  createRouter,
+  findJournal,
+  findManifest,
+  isDisconnected,
+  loadManifest,
+  mark,
+  mayHaveArrived,
+  observeState,
+  openJournal,
+  planInverse,
+  planRead,
+  qualify,
+  refusal,
+  runRead,
+  toPayload,
+  verifyAgainstServers
+} from "./chunk-X4VQNEP5.js";
+import {
+  SnapshotError,
+  UpstreamError,
+  describe
+} from "./chunk-K3QIPVBY.js";
+
+// src/proxy/stdio.ts
+import { resolve } from "path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/gate/gate.ts
+var DEFAULT_GATE_TIMEOUT_MS = 3e5;
+var DEFAULT_HINT = (actionId) => `synartesis approve ${actionId.slice(0, 8)}`;
+function createRetryGate(journal, approveHint = DEFAULT_HINT) {
+  return {
+    decide(request) {
+      journal.markGated(request.actionId, request.why);
+      return Promise.resolve({
+        approved: false,
+        awaiting: true,
+        reason: "it is waiting for a person to approve it. Ask them to run: " + approveHint(request.actionId) + "  --- then make this exact call again."
+      });
+    }
+  };
+}
+
+// src/logging.ts
+import pino from "pino";
+var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "silent"];
+function isLogLevel(value) {
+  return LOG_LEVELS.some((level) => level === value);
+}
+function createLogger(level) {
+  return pino(
+    { level, base: { name: "synartesis" } },
+    pino.destination({ dest: 2, sync: true })
+  );
+}
+
+// src/proxy/proxy.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  CallToolRequestSchema,
+  CompleteRequestSchema,
+  ErrorCode,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ReadResourceRequestSchema,
+  SetLevelRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+
+// src/gate/heuristic.ts
+var READ_ONLY = /^(select|with|show|explain|describe|desc|values|table)\b/;
+function isReadOnlyStatement(text) {
+  const stripped = text.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").trim();
+  if (!READ_ONLY.test(stripped.toLowerCase())) {
+    return false;
+  }
+  return stripped.replace(/;\s*$/, "").indexOf(";") === -1;
+}
+function shouldGateOnWrite(args) {
+  if (typeof args !== "object" || args === null) {
+    return true;
+  }
+  const strings = Object.values(args).filter(
+    (value) => typeof value === "string"
+  );
+  if (strings.length === 0) {
+    return true;
+  }
+  return !strings.every(isReadOnlyStatement);
+}
+
+// src/proxy/proxy.ts
+var APPROVAL_WINDOW_MS = 60 * 60 * 1e3;
+var PassthroughResult = z.looseObject({});
+var ToolList = z.looseObject({
+  tools: z.array(z.looseObject({ name: z.string() })),
+  nextCursor: z.string().optional()
+});
+var PromptList = z.looseObject({
+  prompts: z.array(z.looseObject({ name: z.string() })),
+  nextCursor: z.string().optional()
+});
+var ResourceList = z.looseObject({
+  resources: z.array(z.looseObject({ uri: z.string() })),
+  nextCursor: z.string().optional()
+});
+var TemplateList = z.looseObject({
+  resourceTemplates: z.array(z.looseObject({ uriTemplate: z.string() })),
+  nextCursor: z.string().optional()
+});
+function unwrap(error) {
+  const prefix = `MCP error ${String(error.code)}: `;
+  return error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message;
+}
+function rethrow(server, operation, error) {
+  if (error instanceof McpError) {
+    throw new McpError(error.code, unwrap(error), error.data);
+  }
+  throw new UpstreamError(server, operation, error);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeCapabilities(all) {
+  const merged = {};
+  for (const capabilities of all) {
+    for (const [key, value] of Object.entries(capabilities)) {
+      const existing = merged[key];
+      merged[key] = isRecord(existing) && isRecord(value) ? { ...existing, ...value } : value;
+    }
+  }
+  return merged;
+}
+function identityFor(router) {
+  const only = router.upstreams[0];
+  if (!router.prefixed && only !== void 0) {
+    const upstream = only.client.getServerVersion();
+    if (upstream !== void 0) {
+      return upstream;
+    }
+  }
+  return { name: "synartesis", version: "0.0.0" };
+}
+var SYNARTESIS_INSTRUCTIONS = [
+  "These tools are guarded by Synartesis, which records every change so it can be undone later.",
+  "",
+  "Some actions cannot be undone. Those are held until a person approves them, and the call",
+  'will fail with a message beginning "Synartesis is holding this call for approval".',
+  "When that happens:",
+  "  1. Tell the user plainly that you are asking Synartesis for approval, and what for.",
+  "  2. Give them the exact `synartesis approve ...` command from the error.",
+  "  3. Once they say they have approved it, make the same call again. It will go through.",
+  "Do not try to work around a held call by using a different tool to achieve the same thing."
+].join("\n");
+function instructionsFor(router) {
+  const sections = router.upstreams.map((upstream2) => ({
+    name: upstream2.name,
+    text: upstream2.client.getInstructions()
+  })).filter(
+    (section) => section.text !== void 0
+  );
+  const upstream = router.prefixed ? sections.map((section) => `Tools prefixed ${section.name}__:
+${section.text}`).join("\n\n") : sections[0]?.text ?? "";
+  return upstream === "" ? SYNARTESIS_INSTRUCTIONS : `${SYNARTESIS_INSTRUCTIONS}
+
+${upstream}`;
+}
+async function drain(fetch) {
+  const collected = [];
+  let cursor;
+  do {
+    const page = await fetch(cursor);
+    collected.push(...page.items);
+    cursor = page.nextCursor;
+  } while (cursor !== void 0);
+  return collected;
+}
+function createProxyServer(options) {
+  const { upstreams, manifest, journal } = options;
+  const router = createRouter(upstreams, manifest);
+  const policies = createPolicyResolver(manifest);
+  const log = options.logger;
+  const gate = options.gate ?? createRetryGate(journal, options.approveHint);
+  const capabilities = mergeCapabilities(
+    upstreams.map((upstream) => upstream.client.getServerCapabilities() ?? {})
+  );
+  const instructions = instructionsFor(router);
+  const wrapper = new McpServer(identityFor(router), { capabilities, instructions });
+  const server = wrapper.server;
+  let runId;
+  let resolveReady = () => void 0;
+  const ready = new Promise((resolve2) => {
+    resolveReady = resolve2;
+  });
+  let inflight = 0;
+  const idle = [];
+  const enter = () => {
+    inflight += 1;
+  };
+  const leave = () => {
+    inflight -= 1;
+    if (inflight === 0) {
+      for (const resolve2 of idle.splice(0)) {
+        resolve2();
+      }
+    }
+  };
+  const whenIdle = async () => {
+    if (inflight === 0) {
+      return;
+    }
+    await new Promise((resolve2) => idle.push(resolve2));
+  };
+  let labelled = false;
+  const ensureLabel = () => {
+    if (labelled || runId === void 0) {
+      return;
+    }
+    const name = server.getClientVersion()?.name;
+    if (name !== void 0) {
+      journal.setRunLabel(runId, name);
+      labelled = true;
+    }
+  };
+  const supports = (upstream, key) => upstream.client.getServerCapabilities()?.[key] !== void 0;
+  const ask = async (upstream, request, signal) => {
+    try {
+      return await upstream.client.request(request, PassthroughResult, {
+        signal
+      });
+    } catch (error) {
+      return rethrow(upstream.name, request.method, error);
+    }
+  };
+  let owners;
+  let schemes;
+  let conflict;
+  const refreshResources = async (signal) => {
+    const nextOwners = /* @__PURE__ */ new Map();
+    const nextSchemes = /* @__PURE__ */ new Map();
+    let nextConflict;
+    for (const upstream of router.upstreams) {
+      if (!supports(upstream, "resources")) {
+        continue;
+      }
+      const resources = await drain(async (cursor) => {
+        const raw = await ask(
+          upstream,
+          {
+            method: "resources/list",
+            params: cursor === void 0 ? {} : { cursor }
+          },
+          signal
+        );
+        const page = ResourceList.parse(raw);
+        return { items: page.resources, nextCursor: page.nextCursor };
+      });
+      for (const resource of resources) {
+        const existing = nextOwners.get(resource.uri);
+        if (existing !== void 0 && existing !== upstream.name) {
+          nextConflict ??= `resource ${resource.uri} is advertised by both ${existing} and ${upstream.name}; a uri cannot be namespaced, so one of them must stop exposing it`;
+        }
+        nextOwners.set(resource.uri, existing ?? upstream.name);
+        const scheme = resource.uri.split(":")[0] ?? "";
+        if (scheme !== "" && !nextSchemes.has(scheme)) {
+          nextSchemes.set(scheme, upstream.name);
+        }
+      }
+      const templates = await drain(async (cursor) => {
+        const raw = await ask(
+          upstream,
+          {
+            method: "resources/templates/list",
+            params: cursor === void 0 ? {} : { cursor }
+          },
+          signal
+        );
+        const page = TemplateList.parse(raw);
+        return { items: page.resourceTemplates, nextCursor: page.nextCursor };
+      });
+      for (const template of templates) {
+        const scheme = template.uriTemplate.split(":")[0] ?? "";
+        if (scheme !== "" && !nextSchemes.has(scheme)) {
+          nextSchemes.set(scheme, upstream.name);
+        }
+      }
+    }
+    owners = nextOwners;
+    schemes = nextSchemes;
+    conflict = nextConflict;
+  };
+  const ensureResources = async (signal) => {
+    if (owners === void 0) {
+      await refreshResources(signal);
+    }
+    if (conflict !== void 0) {
+      throw new McpError(ErrorCode.InternalError, conflict);
+    }
+  };
+  const ownerOf = async (uri, signal) => {
+    await ensureResources(signal);
+    const direct = owners?.get(uri);
+    const scheme = uri.split(":")[0] ?? "";
+    const name = direct ?? schemes?.get(scheme);
+    const upstream = name === void 0 ? void 0 : router.byName(name);
+    if (upstream === void 0) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `no configured server provides ${uri}`
+      );
+    }
+    return upstream;
+  };
+  if (capabilities.tools !== void 0) {
+    server.setRequestHandler(
+      ListToolsRequestSchema,
+      async (_request, extra) => {
+        const tools = [];
+        for (const upstream of router.upstreams) {
+          if (!supports(upstream, "tools")) {
+            continue;
+          }
+          const items = await drain(async (cursor) => {
+            const raw = await ask(
+              upstream,
+              {
+                method: "tools/list",
+                params: cursor === void 0 ? {} : { cursor }
+              },
+              extra.signal
+            );
+            const page = ToolList.parse(raw);
+            return { items: page.tools, nextCursor: page.nextCursor };
+          });
+          for (const tool of items) {
+            tools.push({
+              ...tool,
+              name: router.expose(upstream.name, tool.name)
+            });
+          }
+        }
+        return { tools };
+      }
+    );
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+      if (runId === void 0) {
+        throw new UpstreamError("proxy", "tools/call", "no active run");
+      }
+      const activeRun = runId;
+      ensureLabel();
+      const route = router.route(request.params.name);
+      if (route === void 0) {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `no configured server provides tool ${request.params.name}`
+        );
+      }
+      const { policy } = policies.resolve(qualify(route.upstream.name, route.tool));
+      const args = request.params.arguments ?? {};
+      enter();
+      try {
+        const wantsGate = policy.gate === "always" || policy.gate === "on_write" && shouldGateOnWrite(args);
+        const granted = wantsGate ? journal.findApproval({
+          server: route.upstream.name,
+          tool: route.tool,
+          args,
+          notBefore: new Date(Date.now() - APPROVAL_WINDOW_MS).toISOString()
+        }) : void 0;
+        const inherited = granted !== void 0 && granted.runId !== activeRun ? granted : void 0;
+        const waiting = granted === void 0 && wantsGate ? journal.findGated({
+          runId: activeRun,
+          server: route.upstream.name,
+          tool: route.tool,
+          args
+        }) : void 0;
+        const reusable = waiting ?? (inherited === void 0 ? granted : void 0);
+        const pending = reusable === void 0 ? journal.recordPending({
+          runId: activeRun,
+          server: route.upstream.name,
+          tool: route.tool,
+          args,
+          class: policy.class
+        }) : {
+          actionId: reusable.id,
+          seq: reusable.seq,
+          idempotencyKey: reusable.idempotencyKey
+        };
+        if (inherited !== void 0) {
+          journal.adoptApproval(pending.actionId, inherited);
+        } else if (granted !== void 0 && waiting === void 0) {
+          journal.markInFlight(granted.id);
+        }
+        if (granted !== void 0) {
+          log?.info(
+            { action: pending.actionId, by: granted.approvedBy, from: granted.runId },
+            "proceeding on a standing approval"
+          );
+        }
+        const decide = async (why) => {
+          leave();
+          let decision;
+          try {
+            decision = await gate.decide({
+              actionId: pending.actionId,
+              runId: activeRun,
+              seq: pending.seq,
+              server: route.upstream.name,
+              tool: route.tool,
+              args,
+              why,
+              signal: extra.signal
+            });
+          } finally {
+            enter();
+          }
+          log?.info(
+            { action: pending.actionId, approved: decision.approved },
+            decision.approved ? "approved" : "denied"
+          );
+          if (decision.approved && extra.signal.aborted) {
+            journal.settleAsDenied(
+              pending.actionId,
+              decision.by,
+              "approved, but the client had already stopped waiting, so it was not sent"
+            );
+            throw new McpError(
+              ErrorCode.InvalidRequest,
+              `synartesis blocked ${request.params.name}: it was approved after the client stopped waiting, so it was not sent. Ask the agent to try again.`
+            );
+          }
+          if (!decision.approved) {
+            if (decision.awaiting === true) {
+              log?.warn(
+                {
+                  action: pending.actionId,
+                  tool: `${route.upstream.name}.${route.tool}`,
+                  approve: options.approveHint?.(pending.actionId) ?? pending.actionId
+                },
+                "awaiting approval"
+              );
+              throw new McpError(
+                ErrorCode.InvalidRequest,
+                `Synartesis is holding this call for approval, because ${why}. ${decision.reason}`
+              );
+            }
+            const who = decision.by === void 0 ? "" : ` by ${decision.by}`;
+            throw new McpError(
+              ErrorCode.InvalidRequest,
+              `synartesis blocked ${request.params.name}: ${why} and was denied${who}. ${decision.reason}`
+            );
+          }
+        };
+        const askedAlready = wantsGate;
+        if (wantsGate && granted === void 0) {
+          await decide("this action cannot be undone");
+        }
+        let snapshot;
+        let verify;
+        let missingPriorState;
+        if (policy.snapshot !== void 0) {
+          try {
+            verify = planRead(policy.snapshot, { args });
+            snapshot = await runRead(router, verify, extra.signal);
+            journal.attachSnapshot(pending.actionId, snapshot);
+          } catch (error) {
+            const reason = describe(error);
+            if (error instanceof SnapshotError && error.absent) {
+              missingPriorState = reason;
+              verify = void 0;
+            } else {
+              journal.markFailed(pending.actionId, reason);
+              log?.error(
+                { seq: pending.seq, tool: route.tool, reason },
+                "write blocked: snapshot failed"
+              );
+              throw new McpError(
+                ErrorCode.InternalError,
+                `synartesis blocked ${request.params.name}: ${reason}`
+              );
+            }
+          }
+        }
+        if (missingPriorState !== void 0 && !askedAlready) {
+          const standing = journal.findApproval({
+            server: route.upstream.name,
+            tool: route.tool,
+            args,
+            notBefore: new Date(Date.now() - APPROVAL_WINDOW_MS).toISOString()
+          });
+          if (standing === void 0) {
+            await decide(
+              `nothing was captured to restore, so this cannot be undone \u2014 the read said: ${missingPriorState}`
+            );
+          } else {
+            journal.adoptApproval(pending.actionId, standing);
+            log?.info(
+              { action: pending.actionId, by: standing.approvedBy, from: standing.runId },
+              "proceeding on a standing approval"
+            );
+          }
+        }
+        const forwarded = {
+          method: "tools/call",
+          params: { ...request.params, name: route.tool }
+        };
+        try {
+          const result = await route.upstream.client.request(forwarded, PassthroughResult, {
+            signal: extra.signal
+          });
+          const refused = refusal(result);
+          if (refused !== void 0) {
+            journal.markFailed(pending.actionId, `the upstream refused the call: ${refused}`);
+            log?.debug(
+              { seq: pending.seq, tool: route.tool, reason: refused },
+              "refused by the upstream"
+            );
+            return result;
+          }
+          const context = { args, snapshot, result: toPayload(result) };
+          const warnings = [];
+          if (missingPriorState !== void 0) {
+            warnings.push(
+              `no prior state existed, so there is nothing to restore: ${missingPriorState}`
+            );
+          }
+          let inverse;
+          if (policy.inverse !== void 0 && missingPriorState === void 0) {
+            try {
+              inverse = planInverse(policy.inverse, context);
+            } catch (error) {
+              warnings.push(`inverse could not be resolved: ${describe(error)}`);
+            }
+          }
+          let postSnapshot;
+          if (verify !== void 0) {
+            try {
+              postSnapshot = await observeState(router, verify, extra.signal);
+            } catch (error) {
+              warnings.push(`post-state could not be captured: ${describe(error)}`);
+            }
+          }
+          if (warnings.length > 0) {
+            log?.warn({ seq: pending.seq, tool: route.tool, warnings }, "applied with reservations");
+          }
+          log?.debug(
+            { seq: pending.seq, server: route.upstream.name, tool: route.tool, class: policy.class },
+            "applied"
+          );
+          journal.markApplied(pending.actionId, {
+            result,
+            ...inverse === void 0 ? {} : { inverse },
+            ...verify === void 0 ? {} : { verify },
+            ...postSnapshot === void 0 ? {} : { postSnapshot },
+            ...warnings.length === 0 ? {} : { warning: warnings.join("; ") }
+          });
+          return result;
+        } catch (error) {
+          const disconnected = isDisconnected(error);
+          if (extra.signal.aborted || mayHaveArrived(error)) {
+            journal.markUnknown(pending.actionId, describe(error));
+          } else {
+            journal.markFailed(pending.actionId, describe(error));
+          }
+          if (disconnected && route.upstream.reconnect !== void 0) {
+            await route.upstream.reconnect().catch(() => void 0);
+          }
+          return rethrow(route.upstream.name, "tools/call", error);
+        }
+      } finally {
+        leave();
+      }
+    });
+  }
+  if (capabilities.resources !== void 0) {
+    server.setRequestHandler(
+      ListResourcesRequestSchema,
+      async (_request, extra) => {
+        await refreshResources(extra.signal);
+        await ensureResources(extra.signal);
+        const resources = [];
+        for (const upstream of router.upstreams) {
+          if (!supports(upstream, "resources")) {
+            continue;
+          }
+          const items = await drain(async (cursor) => {
+            const raw = await ask(
+              upstream,
+              {
+                method: "resources/list",
+                params: cursor === void 0 ? {} : { cursor }
+              },
+              extra.signal
+            );
+            const page = ResourceList.parse(raw);
+            return { items: page.resources, nextCursor: page.nextCursor };
+          });
+          resources.push(...items);
+        }
+        return { resources };
+      }
+    );
+    server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async (_request, extra) => {
+        const resourceTemplates = [];
+        for (const upstream of router.upstreams) {
+          if (!supports(upstream, "resources")) {
+            continue;
+          }
+          const items = await drain(async (cursor) => {
+            const raw = await ask(
+              upstream,
+              {
+                method: "resources/templates/list",
+                params: cursor === void 0 ? {} : { cursor }
+              },
+              extra.signal
+            );
+            const page = TemplateList.parse(raw);
+            return {
+              items: page.resourceTemplates,
+              nextCursor: page.nextCursor
+            };
+          });
+          resourceTemplates.push(...items);
+        }
+        return { resourceTemplates };
+      }
+    );
+    server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request, extra) => {
+        const upstream = await ownerOf(request.params.uri, extra.signal);
+        return ask(upstream, request, extra.signal);
+      }
+    );
+    if (capabilities.resources.subscribe === true) {
+      for (const schema of [SubscribeRequestSchema, UnsubscribeRequestSchema]) {
+        server.setRequestHandler(schema, async (request, extra) => {
+          const upstream = await ownerOf(request.params.uri, extra.signal);
+          return ask(upstream, request, extra.signal);
+        });
+      }
+    }
+  }
+  if (capabilities.prompts !== void 0) {
+    server.setRequestHandler(
+      ListPromptsRequestSchema,
+      async (_request, extra) => {
+        const prompts = [];
+        for (const upstream of router.upstreams) {
+          if (!supports(upstream, "prompts")) {
+            continue;
+          }
+          const items = await drain(async (cursor) => {
+            const raw = await ask(
+              upstream,
+              {
+                method: "prompts/list",
+                params: cursor === void 0 ? {} : { cursor }
+              },
+              extra.signal
+            );
+            const page = PromptList.parse(raw);
+            return { items: page.prompts, nextCursor: page.nextCursor };
+          });
+          for (const prompt of items) {
+            prompts.push({
+              ...prompt,
+              name: router.expose(upstream.name, prompt.name)
+            });
+          }
+        }
+        return { prompts };
+      }
+    );
+    server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
+      const route = router.route(request.params.name);
+      if (route === void 0) {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `no configured server provides prompt ${request.params.name}`
+        );
+      }
+      return ask(
+        route.upstream,
+        {
+          method: "prompts/get",
+          params: { ...request.params, name: route.tool }
+        },
+        extra.signal
+      );
+    });
+  }
+  if (capabilities.completions !== void 0) {
+    server.setRequestHandler(CompleteRequestSchema, async (request, extra) => {
+      const reference = request.params.ref;
+      if (reference.type === "ref/prompt") {
+        const route = router.route(reference.name);
+        if (route === void 0) {
+          throw new McpError(
+            ErrorCode.InvalidParams,
+            `unknown prompt ${reference.name}`
+          );
+        }
+        return ask(
+          route.upstream,
+          {
+            method: "completion/complete",
+            params: {
+              ...request.params,
+              ref: { ...reference, name: route.tool }
+            }
+          },
+          extra.signal
+        );
+      }
+      const upstream = await ownerOf(reference.uri, extra.signal);
+      return ask(upstream, request, extra.signal);
+    });
+  }
+  if (capabilities.logging !== void 0) {
+    server.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+      for (const upstream of router.upstreams) {
+        if (supports(upstream, "logging")) {
+          await ask(upstream, request, extra.signal);
+        }
+      }
+      return {};
+    });
+  }
+  let connected = false;
+  for (const upstream of router.upstreams) {
+    upstream.client.fallbackNotificationHandler = async (notification) => {
+      if (notification.method.endsWith("list_changed")) {
+        owners = void 0;
+        schemes = void 0;
+        conflict = void 0;
+      }
+      if (connected) {
+        await server.notification(notification);
+      }
+    };
+  }
+  server.oninitialized = () => {
+    connected = true;
+    const name = server.getClientVersion()?.name;
+    const id = journal.beginRun(name);
+    runId = id;
+    labelled = name !== void 0;
+    resolveReady(id);
+  };
+  const previousOnClose = server.onclose;
+  server.onclose = () => {
+    connected = false;
+    if (runId !== void 0) {
+      journal.endRun(runId, "complete");
+      runId = void 0;
+    }
+    previousOnClose?.();
+  };
+  return {
+    server: wrapper,
+    ready,
+    whenIdle,
+    busy: () => inflight > 0,
+    get runId() {
+      return runId;
+    }
+  };
+}
+
+// src/proxy/stdio.ts
+var NODE_MAJOR = Number(process.versions.node.split(".")[0]);
+if (NODE_MAJOR < 22) {
+  process.stderr.write(
+    `synartesis: needs Node 22 or newer, and this is ${process.version}.
+`
+  );
+  process.exit(2);
+}
+function parseArgv(argv) {
+  const read = (flag) => {
+    const at = argv.indexOf(flag);
+    return at === -1 ? void 0 : argv[at + 1];
+  };
+  const known = ["--manifest", "--journal", "--gate-timeout", "--log-level"];
+  const unknown = argv.find((token) => token.startsWith("--") && !known.includes(token));
+  if (unknown !== void 0) {
+    throw new Error(`unknown flag ${unknown}; expected one of ${known.join(", ")}`);
+  }
+  const rawTimeout = read("--gate-timeout");
+  const seconds = rawTimeout === void 0 ? void 0 : Number(rawTimeout);
+  if (seconds !== void 0 && (!Number.isFinite(seconds) || seconds <= 0)) {
+    throw new Error("--gate-timeout needs a positive number of seconds");
+  }
+  const level = read("--log-level") ?? "info";
+  if (!isLogLevel(level)) {
+    throw new Error(`--log-level must be one of ${LOG_LEVELS.join(", ")}`);
+  }
+  const manifest = findManifest(read("--manifest"));
+  return {
+    manifest,
+    journal: findJournal(read("--journal"), manifest),
+    gateTimeoutMs: seconds === void 0 ? DEFAULT_GATE_TIMEOUT_MS : seconds * 1e3,
+    logLevel: level
+  };
+}
+async function main() {
+  const argv = parseArgv(process.argv.slice(2));
+  const log = createLogger(argv.logLevel);
+  if (process.stderr.isTTY) {
+    process.stderr.write(mark());
+  }
+  const manifest = loadManifest(argv.manifest);
+  const journal = openJournal(argv.journal);
+  const upstreams = [];
+  for (const [name, spec] of Object.entries(manifest.servers)) {
+    upstreams.push(
+      await connectStdioUpstream({
+        name,
+        command: spec.command,
+        args: spec.args,
+        ...spec.env === void 0 ? {} : { env: spec.env }
+      })
+    );
+  }
+  await verifyAgainstServers(upstreams, manifest);
+  log.info(
+    {
+      manifest: argv.manifest,
+      journal: argv.journal,
+      servers: upstreams.map((upstream) => upstream.name),
+      policies: manifest.tools.length
+    },
+    "proxy ready"
+  );
+  const proxy = createProxyServer({
+    upstreams,
+    manifest,
+    journal,
+    gateTimeoutMs: argv.gateTimeoutMs,
+    logger: log,
+    // Absolute, because whoever approves may be in any directory at all.
+    approveHint: (actionId) => `${cliCommandFrom(import.meta.url)} approve ${actionId.slice(0, 8)} --journal ${resolve(argv.journal)}`
+  });
+  let shuttingDown = false;
+  const shutdown = (code) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    void (async () => {
+      await Promise.race([
+        proxy.whenIdle(),
+        new Promise((resolve2) => setTimeout(resolve2, 5e3).unref())
+      ]);
+      await proxy.server.close();
+      for (const upstream of upstreams) {
+        await upstream.close();
+      }
+      journal.close();
+      process.exit(code);
+    })();
+  };
+  process.on("SIGINT", () => {
+    shutdown(0);
+  });
+  process.on("SIGTERM", () => {
+    shutdown(0);
+  });
+  const pipeClosed = () => {
+    const giveUpAt = Date.now() + 5e3;
+    let quiet = 0;
+    const settle = () => {
+      quiet = proxy.busy() ? 0 : quiet + 1;
+      if (quiet >= 10 || Date.now() > giveUpAt) {
+        shutdown(0);
+        return;
+      }
+      setImmediate(settle);
+    };
+    setImmediate(settle);
+  };
+  process.stdin.on("end", pipeClosed);
+  process.stdin.on("close", pipeClosed);
+  const inner = proxy.server.server;
+  const onclose = inner.onclose;
+  inner.onclose = () => {
+    onclose?.();
+    shutdown(0);
+  };
+  await proxy.server.connect(new StdioServerTransport());
+}
+try {
+  await main();
+} catch (error) {
+  process.stderr.write(`synartesis: ${describe(error)}
+`);
+  process.exit(1);
+}
+//# sourceMappingURL=proxy.js.map