kibi-mcp 3.4.0 → 3.5.0

package/dist/server/json-schema-to-zod.js

@@ -118,7 +118,68 @@ function conditionalRequiredKeys(value, condition) {
         ? required.filter((key) => typeof key === "string" && key.length > 0)
         : [];
 }
-// implements REQ-002
+const GUARD_KEYWORDS = new Set([
+    "required",
+    "not",
+    "anyOf",
+    "allOf",
+    "description",
+]);
+// A guard branch only states which keys must or must not be present
+// (required/not/anyOf/allOf of such conditions). It carries no property
+// schemas, so enforcing a oneOf of guard branches can only tighten
+// validation, never loosen it.
+function isGuardBranch(branch) {
+    if (branch === null || typeof branch !== "object" || Array.isArray(branch))
+        return false;
+    const record = branch;
+    const keys = Object.keys(record);
+    if (keys.length === 0)
+        return false;
+    return keys.every((key) => {
+        if (!GUARD_KEYWORDS.has(key))
+            return false;
+        const entry = record[key];
+        if (key === "required")
+            return (Array.isArray(entry) && entry.every((item) => typeof item === "string"));
+        if (key === "not")
+            return isGuardBranch(entry);
+        if (key === "anyOf" || key === "allOf")
+            return Array.isArray(entry) && entry.every(isGuardBranch);
+        return true;
+    });
+}
+function guardOneOfBranches(obj) {
+    if (!Array.isArray(obj.oneOf) || obj.oneOf.length < 2)
+        return [];
+    return obj.oneOf.every(isGuardBranch) ? obj.oneOf : [];
+}
+function describeGuardBranch(branch) {
+    const required = Array.isArray(branch.required)
+        ? branch.required
+        : [];
+    const forbidden = new Set();
+    const collect = (entry) => {
+        if (entry === null || typeof entry !== "object")
+            return;
+        const record = entry;
+        if (Array.isArray(record.required))
+            for (const key of record.required)
+                forbidden.add(key);
+        if (Array.isArray(record.anyOf))
+            for (const item of record.anyOf)
+                collect(item);
+        if (Array.isArray(record.allOf))
+            for (const item of record.allOf)
+                collect(item);
+    };
+    collect(branch.not);
+    const parts = [`{${required.join(", ")}}`];
+    if (forbidden.size > 0)
+        parts.push(`without ${[...forbidden].join(", ")}`);
+    return parts.join(" ");
+}
+// implements REQ-002, REQ-mcp-oneof-guard-input-validation
 export function jsonSchemaToZod(schema) {
     if (!schema || typeof schema !== "object") {
         return z.any();
@@ -160,9 +221,10 @@ export function jsonSchemaToZod(schema) {
     // JSON Schema anyOf unions become real Zod unions so MCP output
     // validation enforces the declared alternatives instead of silently
     // degrading to z.any() — e.g. kb_check's synchronous payload versus its
-    // kibi.job.v1 async receipt. oneOf is intentionally left degrading: its
-    // required-guard branches carry no properties and would loosen input
-    // validation instead of tightening it.
+    // kibi.job.v1 async receipt. oneOf is not turned into a union: its
+    // required-guard branches carry no properties and a union would loosen
+    // input validation. Guard oneOf branches on an object are enforced as a
+    // refinement in the object case below instead.
     const anyOfVariants = Array.isArray(obj.anyOf) ? obj.anyOf : [];
     if (anyOfVariants.length > 0) {
         const variants = anyOfVariants.map((variant) => jsonSchemaToZod(variant));
@@ -218,6 +280,27 @@ export function jsonSchemaToZod(schema) {
                 })
                     .meta({ allOf: obj.allOf });
             }
+            // A top-level oneOf of guard branches (for example "plan with
+            // approvedPlanHash, or recoveryJournalId alone") is enforced with the
+            // same condition matcher as if/then: exactly one branch must match.
+            // It is not republished as JSON Schema metadata, because hosts reject
+            // a top-level oneOf in a tool input schema; the CLI enforces the same
+            // rule with ajv.
+            const guardBranches = guardOneOfBranches(obj);
+            if (guardBranches.length > 0) {
+                result = result.superRefine((value, context) => {
+                    if (value === null || typeof value !== "object")
+                        return;
+                    const matches = guardBranches.filter((branch) => matchesJsonSchemaCondition(value, branch)).length;
+                    if (matches === 1)
+                        return;
+                    context.addIssue({
+                        code: "custom",
+                        path: [],
+                        message: `Input must match exactly one of: ${guardBranches.map(describeGuardBranch).join("; ")} (matched ${matches}).`,
+                    });
+                });
+            }
             return result;
         }
         case "array": {

package/dist/server/tool-registration.js

@@ -1,5 +1,5 @@
 import { getSpec, statusSpec } from "kibi-runtime";
-import { MODEL_ROUTES, SKILL_ROUTES, dispatchComposite, executeApplyPlan, executeCompileIntent, executeDelete, executeIngestProof, executeUpsert, } from "kibi-runtime";
+import { MODEL_ROUTES, SKILL_ROUTES, dispatchComposite, executeApplyPlan, executeCompileIntent, executeDelete, executeIngestProof, executeUpsert, preflightApplyPlan, } from "kibi-runtime";
 import { OPTIONAL_TOOL_NAMES, enabledOptionalTools } from "../tools-config.js";
 import { startJob } from "./jobs.js";
 // implements REQ-002, REQ-013
@@ -165,6 +165,10 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             // Detach it into a job and return the kibi.job.v1 receipt; the agent
             // polls kb_job_status. The request is over once the receipt returns,
             // so the job reports no progress and refreshes the branch stamp itself.
+            // Input and stale-plan errors (missing or wrong approvedPlanHash, a
+            // changed snapshot) fail this call rather than the job; the apply
+            // repeats every check under the workspace lock.
+            await (runtime.preflightApplyPlan ?? preflightApplyPlan)(applyArgs, context);
             const { onProgress: _requestProgress, ...jobContext } = context;
             return startJob("kb_apply_plan", async () => {
                 const result = await apply(jobContext);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "mcpName": "io.github.Looted/kibi-mcp",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
@@ -10,7 +10,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-runtime": "^2.7.0",
+    "kibi-runtime": "^2.8.0",
     "kibi-core": "^0.17.0",
     "zod": "^4.3.6"
   },