synartesis 0.6.12 → 0.6.13

package/dist/{chunk-FUVEHRJP.js → chunk-6X7GPUGJ.js}

@@ -257,6 +257,19 @@ CREATE INDEX IF NOT EXISTS actions_by_run ON actions(run_id, seq);
 -- two-kilobyte snapshots: 61ms to 0.01ms, and 56ms to 0.00ms.
 CREATE INDEX IF NOT EXISTS actions_approved ON actions(server, tool, status, approved_at);
 CREATE INDEX IF NOT EXISTS actions_gated ON actions(status, ts);
+
+-- Covering, and that is the whole point. listRuns needs a count and three
+-- status tallies per run, and without this the group-by scans the table --
+-- which carries the snapshots, so the cost of listing sessions grew with the
+-- size of the data those sessions touched, not with how many there were.
+-- Adding status to the run index lets sqlite answer entirely from the index.
+-- Measured on forty runs of five hundred actions with two-kilobyte snapshots,
+-- a hundred-megabyte journal: 76ms to 2ms.
+--
+-- Added the same way as the two above and for the same reason: no row changes,
+-- no meaning changes, IF NOT EXISTS makes it idempotent, and an older build
+-- opening the same file afterwards neither notices nor cares.
+CREATE INDEX IF NOT EXISTS actions_run_status ON actions(run_id, status);
 `;
 
 // src/journal/journal.ts
@@ -268,6 +281,13 @@ var runSchema = z.object({
   ended_at: z.string().nullable(),
   status: z.enum(["active", "complete", "rolled_back", "partial"])
 });
+var tallySchema = z.object({
+  run_id: z.string(),
+  actions: z.number(),
+  unknown: z.number().nullable(),
+  waiting: z.number().nullable(),
+  applied: z.number().nullable()
+});
 var actionSchema = z.object({
   id: z.string(),
   run_id: z.string(),
@@ -699,6 +719,30 @@ var SqliteJournal = class {
       () => this.#db.prepare("SELECT * FROM actions WHERE run_id = ? ORDER BY seq").all(runId).map(toAction)
     );
   }
+  tallyRuns() {
+    return this.#run("tallyRuns", () => {
+      const rows = this.#db.prepare(
+        `SELECT run_id,
+                  COUNT(*) AS actions,
+                  SUM(status = 'pending') AS unknown,
+                  SUM(status = 'gated') AS waiting,
+                  SUM(status = 'applied') AS applied
+             FROM actions
+            GROUP BY run_id`
+      ).all();
+      const tally = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const counts = tallySchema.parse(row);
+        tally.set(counts.run_id, {
+          actions: counts.actions,
+          unknown: counts.unknown ?? 0,
+          waiting: counts.waiting ?? 0,
+          applied: counts.applied ?? 0
+        });
+      }
+      return tally;
+    });
+  }
   recentActions(limit) {
     return this.#run(
       "recentActions",
@@ -973,17 +1017,20 @@ var toolPolicy = z2.strictObject({
   gate: z2.enum(["always", "on_write", "never"]).optional(),
   refusal: z2.enum(["uncertain", "clean"]).optional(),
   snapshot: callTemplate.optional(),
-  inverse: callTemplate.optional()
+  inverse: callTemplate.optional(),
+  verify: callTemplate.optional()
 });
 var serverSpec = z2.strictObject({
   command: z2.string().min(1),
   args: z2.array(z2.string()).default([]),
-  env: z2.record(z2.string(), z2.string()).optional()
+  env: z2.record(z2.string(), z2.string()).optional(),
+  provenance: z2.enum(["live", "documented"]).optional()
 });
 var manifestSchema = z2.strictObject({
   version: z2.literal(1),
   servers: z2.record(z2.string(), serverSpec),
-  tools: z2.array(toolPolicy).default([])
+  tools: z2.array(toolPolicy).default([]),
+  pins: z2.record(z2.string(), z2.record(z2.string(), z2.string().min(1))).optional()
 });
 var Source = class {
   constructor(doc, lines, file) {
@@ -1066,6 +1113,11 @@ function validate(source, manifest) {
   if (servers.length === 0) {
     source.fail(["servers"], "at least one server must be declared");
   }
+  for (const name of Object.keys(manifest.pins ?? {})) {
+    if (!servers.includes(name)) {
+      source.fail(["pins", name], `pins name server ${name}, which is not declared`);
+    }
+  }
   const seen = /* @__PURE__ */ new Map();
   manifest.tools.forEach((policy, index) => {
     const path = ["tools", index];
@@ -1087,6 +1139,9 @@ function validate(source, manifest) {
         `${policy.match} names server ${segment}, which is not declared`
       );
     }
+    if (policy.verify !== void 0 && policy.class === "readonly") {
+      source.fail([...path, "verify"], "a readonly tool has no post-state to check for drift");
+    }
     const needsInverse = policy.class === "reversible" || policy.class === "compensable";
     if (needsInverse && policy.inverse === void 0) {
       source.fail(path, `a ${policy.class} tool must declare an inverse`);
@@ -1130,7 +1185,8 @@ function withGate(policy) {
     gate,
     refusal: policy.refusal ?? "uncertain",
     ...policy.snapshot === void 0 ? {} : { snapshot: toCall(policy.snapshot) },
-    ...policy.inverse === void 0 ? {} : { inverse: toCall(policy.inverse) }
+    ...policy.inverse === void 0 ? {} : { inverse: toCall(policy.inverse) },
+    ...policy.verify === void 0 ? {} : { verify: toCall(policy.verify) }
   };
 }
 function parseManifest(text, file) {
@@ -1166,11 +1222,13 @@ function parseManifest(text, file) {
         {
           command: spec.command,
           args: spec.args,
-          ...spec.env === void 0 ? {} : { env: expandEnvironment(source, ["servers", name], spec.env) }
+          ...spec.env === void 0 ? {} : { env: expandEnvironment(source, ["servers", name], spec.env) },
+          ...spec.provenance === void 0 ? {} : { provenance: spec.provenance }
         }
       ])
     ),
-    tools: parsed.data.tools.map(withGate)
+    tools: parsed.data.tools.map(withGate),
+    ...parsed.data.pins === void 0 ? {} : { pins: parsed.data.pins }
   };
   validate(source, manifest);
   return manifest;
@@ -1193,8 +1251,41 @@ function loadManifest(path) {
   return parseManifest(text, path);
 }
 
-// src/manifest/verify.ts
-import { z as z3 } from "zod";
+// src/manifest/pin.ts
+import { createHash } from "crypto";
+
+// src/manifest/match.ts
+function toRegExp(pattern) {
+  const source = pattern.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
+  return new RegExp(`^${source}$`);
+}
+function literalLength(pattern) {
+  return pattern.length - pattern.split("*").length + 1;
+}
+function failClosed(qualifiedName) {
+  return { match: qualifiedName, class: "irreversible", gate: "always", refusal: "uncertain" };
+}
+function createPolicyResolver(manifest) {
+  const compiled = manifest.tools.map((policy) => ({
+    policy,
+    test: toRegExp(policy.match),
+    specificity: literalLength(policy.match),
+    wildcards: policy.match.split("*").length - 1
+  })).sort((a, b) => b.specificity - a.specificity || a.wildcards - b.wildcards);
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    resolve(qualifiedName) {
+      const cached2 = cache.get(qualifiedName);
+      if (cached2 !== void 0) {
+        return cached2;
+      }
+      const hit = compiled.find((candidate) => candidate.test.test(qualifiedName));
+      const match = hit === void 0 ? { policy: failClosed(qualifiedName), matched: false } : { policy: hit.policy, matched: true };
+      cache.set(qualifiedName, match);
+      return match;
+    }
+  };
+}
 
 // src/manifest/types.ts
 function qualify(server, tool) {
@@ -1208,13 +1299,77 @@ function splitQualified(qualified) {
   return { server: qualified.slice(0, dot), tool: qualified.slice(dot + 1) };
 }
 
+// src/manifest/pin.ts
+function fingerprint(inputSchema) {
+  return `sha256:${createHash("sha256").update(canonical(inputSchema)).digest("hex")}`;
+}
+function auditPins(server, advertised, manifest) {
+  const pins = manifest.pins?.[server];
+  if (pins === void 0) {
+    return [];
+  }
+  const resolver = createPolicyResolver(manifest);
+  const faults = [];
+  const present = /* @__PURE__ */ new Set();
+  for (const tool of advertised) {
+    present.add(tool.name);
+    if (!resolver.resolve(qualify(server, tool.name)).matched) {
+      continue;
+    }
+    const found = fingerprint(tool.inputSchema);
+    const pinned = pins[tool.name];
+    if (pinned === void 0) {
+      faults.push({ kind: "unpinned", tool: tool.name, found });
+    } else if (pinned !== found) {
+      faults.push({ kind: "moved", tool: tool.name, pinned, found });
+    }
+  }
+  for (const name of Object.keys(pins)) {
+    if (!present.has(name)) {
+      faults.push({ kind: "gone", tool: name });
+    }
+  }
+  return faults;
+}
+function pinBlock(shapes, manifest) {
+  const resolver = createPolicyResolver(manifest);
+  const lines = ["pins:"];
+  for (const server of [...shapes.keys()].sort()) {
+    const governed = (shapes.get(server) ?? []).filter((tool) => resolver.resolve(qualify(server, tool.name)).matched).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    if (governed.length === 0) {
+      continue;
+    }
+    lines.push(`  ${server}:`);
+    for (const tool of governed) {
+      lines.push(`    ${tool.name}: "${fingerprint(tool.inputSchema)}"`);
+    }
+  }
+  return lines.join("\n");
+}
+function explainPins(server, faults) {
+  return faults.map((fault) => {
+    switch (fault.kind) {
+      case "moved":
+        return `${server}.${fault.tool} no longer has the shape it was pinned at. Its policy was written for the old one, so the snapshot and inverse it carries may no longer describe this tool.
+      pinned ${fault.pinned}
+      now    ${fault.found}`;
+      case "unpinned":
+        return `${server}.${fault.tool} is governed by a policy and has no pin, on a server where everything else is pinned.
+      add    ${fault.tool}: "${fault.found}"`;
+      case "gone":
+        return `${server}.${fault.tool} is pinned but the server does not expose it, so the pin vouches for nothing. Remove it, or connect the server that has it.`;
+    }
+  });
+}
+
 // src/manifest/verify.ts
+import { z as z3 } from "zod";
 var listSchema = z3.looseObject({
-  tools: z3.array(z3.looseObject({ name: z3.string() })),
+  tools: z3.array(z3.looseObject({ name: z3.string(), inputSchema: z3.unknown() })),
   nextCursor: z3.string().optional()
 });
-async function toolNames(upstream) {
-  const names = /* @__PURE__ */ new Set();
+async function toolShapes(upstream) {
+  const shapes = [];
   let cursor;
   do {
     const page = listSchema.parse(
@@ -1224,16 +1379,19 @@ async function toolNames(upstream) {
       )
     );
     for (const tool of page.tools) {
-      names.add(tool.name);
+      shapes.push({ name: tool.name, inputSchema: tool.inputSchema });
     }
     cursor = page.nextCursor;
   } while (cursor !== void 0);
-  return names;
+  return shapes;
 }
 async function verifyAgainstServers(upstreams, manifest) {
+  const shapes = /* @__PURE__ */ new Map();
   const available = /* @__PURE__ */ new Map();
   for (const upstream of upstreams) {
-    available.set(upstream.name, await toolNames(upstream));
+    const advertised = await toolShapes(upstream);
+    shapes.set(upstream.name, advertised);
+    available.set(upstream.name, new Set(advertised.map((tool) => tool.name)));
   }
   const problems = [];
   const check = (qualified, role, match) => {
@@ -1259,11 +1417,50 @@ async function verifyAgainstServers(upstreams, manifest) {
     if (policy.inverse !== void 0) {
       check(policy.inverse.tool, "inverse", policy.match);
     }
+    if (policy.verify !== void 0) {
+      check(policy.verify.tool, "verify", policy.match);
+    }
   }
   if (problems.length > 0) {
     throw new ManifestError(`the manifest calls tools that do not exist:
   ${problems.join("\n  ")}`);
   }
+  const drifted = [];
+  for (const upstream of upstreams) {
+    const faults = auditPins(upstream.name, shapes.get(upstream.name) ?? [], manifest);
+    drifted.push(...explainPins(upstream.name, faults));
+  }
+  if (drifted.length > 0) {
+    throw new ManifestError(
+      "a pinned tool no longer matches the policy written for it:\n  " + drifted.join("\n  ") + "\n\n  Review what changed before trusting undo on these tools. `synartesis pin` prints the block for the servers you have now."
+    );
+  }
+}
+
+// src/manifest/standing.ts
+function standing(manifest) {
+  return Object.entries(manifest.servers).map(([server, spec]) => ({
+    server,
+    provenance: spec.provenance ?? "unstated"
+  }));
+}
+function untested(manifest) {
+  return standing(manifest).filter((entry) => entry.provenance === "documented").map((entry) => entry.server);
+}
+function describeStanding(entry) {
+  switch (entry.provenance) {
+    case "live":
+      return "checked against the real server";
+    case "documented":
+      return "written from documentation, never run against the real server";
+    case "unstated":
+      return "no claim either way";
+  }
+}
+function warnUntested(servers) {
+  const names = servers.join(", ");
+  const these = servers.length === 1 ? "this policy has" : "these policies have";
+  return `${names}: ${these} never been run against the real server. The classes and inverses here come from documentation, so undo may not work where it says it will. Run \`synartesis check\` against your own credentials, and expect to correct something.`;
 }
 
 // src/proxy/routing.ts
@@ -1390,37 +1587,17 @@ async function start(spec) {
   return { client };
 }
 
-// src/manifest/match.ts
-function toRegExp(pattern) {
-  const source = pattern.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
-  return new RegExp(`^${source}$`);
-}
-function literalLength(pattern) {
-  return pattern.length - pattern.split("*").length + 1;
-}
-function failClosed(qualifiedName) {
-  return { match: qualifiedName, class: "irreversible", gate: "always", refusal: "uncertain" };
-}
-function createPolicyResolver(manifest) {
-  const compiled = manifest.tools.map((policy) => ({
-    policy,
-    test: toRegExp(policy.match),
-    specificity: literalLength(policy.match),
-    wildcards: policy.match.split("*").length - 1
-  })).sort((a, b) => b.specificity - a.specificity || a.wildcards - b.wildcards);
-  const cache = /* @__PURE__ */ new Map();
-  return {
-    resolve(qualifiedName) {
-      const cached2 = cache.get(qualifiedName);
-      if (cached2 !== void 0) {
-        return cached2;
-      }
-      const hit = compiled.find((candidate) => candidate.test.test(qualifiedName));
-      const match = hit === void 0 ? { policy: failClosed(qualifiedName), matched: false } : { policy: hit.policy, matched: true };
-      cache.set(qualifiedName, match);
-      return match;
+// src/idempotency.ts
+var IDEMPOTENCY_META_KEY = "synartesis.dev/idempotency-key";
+function withIdempotencyKey(meta, key) {
+  const merged = {};
+  if (typeof meta === "object" && meta !== null) {
+    for (const [name, value] of Object.entries(meta)) {
+      merged[name] = value;
     }
-  };
+  }
+  merged[IDEMPOTENCY_META_KEY] = key;
+  return merged;
 }
 
 // src/proxy/snapshot.ts
@@ -1582,9 +1759,17 @@ export {
   wasRefused,
   parseManifest,
   loadManifest,
+  createPolicyResolver,
   qualify,
+  pinBlock,
+  toolShapes,
   verifyAgainstServers,
-  createPolicyResolver,
+  standing,
+  untested,
+  describeStanding,
+  warnUntested,
+  IDEMPOTENCY_META_KEY,
+  withIdempotencyKey,
   createRouter,
   refusal,
   toPayload,
@@ -1597,4 +1782,4 @@ export {
   observeState,
   connectStdioUpstream
 };
-//# sourceMappingURL=chunk-FUVEHRJP.js.map
+//# sourceMappingURL=chunk-6X7GPUGJ.js.map