kibi-mcp 3.1.2 → 3.4.0

package/dist/runtime/mcp-runtime.js

@@ -64,6 +64,7 @@ export function createMcpRuntime(session) {
                 ...(fs ? { sourceFirst: true } : {}),
                 ...(git ? { git } : {}),
                 ...(net ? { net } : {}),
+                ...(options.onProgress ? { onProgress: options.onProgress } : {}),
             };
             const resolved = resolveMcpAttachment(context.workspaceRoot, spec);
             const attachment = resolved instanceof Promise ? await resolved : resolved;

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

@@ -13,23 +13,92 @@ export function singleLiteralOrAny(literalSchemas, description) {
     }
     return description ? single.describe(description) : single;
 }
-function hasRequiredProperties(value, schema) {
-    if (schema === null || typeof schema !== "object")
+function matchesJsonType(value, type) {
+    switch (type) {
+        case "object":
+            return (value !== null && typeof value === "object" && !Array.isArray(value));
+        case "array":
+            return Array.isArray(value);
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "null":
+            return value === null;
+        default:
+            return true;
+    }
+}
+function sameJsonValue(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+// Evaluates a JSON Schema `if` condition the way a JSON Schema validator
+// would for the keywords Kibi's operation schemas use in conditionals:
+// boolean schemas, type, const, enum, required, properties (applied only to
+// present keys), not, anyOf, allOf and oneOf. Keywords outside this set do not
+// constrain the condition. The CLI validates the same schemas with ajv, so
+// this must stay faithful: a mismatch makes MCP reject payloads the CLI
+// accepts (or the reverse).
+// implements REQ-002, REQ-mcp-conditional-input-validation
+export function matchesJsonSchemaCondition(value, schema) {
+    if (schema === true || schema === undefined)
+        return true;
+    if (schema === false)
         return false;
+    if (schema === null || typeof schema !== "object")
+        return true;
     const condition = schema;
-    const required = Array.isArray(condition.required)
-        ? condition.required.filter((key) => typeof key === "string" && key.length > 0)
-        : [];
-    if (required.length > 0 &&
-        !required.every((key) => Object.hasOwn(value, key))) {
+    const types = Array.isArray(condition.type)
+        ? condition.type.filter((entry) => typeof entry === "string")
+        : typeof condition.type === "string"
+            ? [condition.type]
+            : [];
+    if (types.length > 0 && !types.some((type) => matchesJsonType(value, type))) {
+        return false;
+    }
+    if (Object.hasOwn(condition, "const") &&
+        !sameJsonValue(value, condition.const)) {
+        return false;
+    }
+    if (Array.isArray(condition.enum) &&
+        !condition.enum.some((entry) => sameJsonValue(value, entry))) {
+        return false;
+    }
+    const isObject = value !== null && typeof value === "object" && !Array.isArray(value);
+    if (isObject) {
+        const record = value;
+        const required = Array.isArray(condition.required)
+            ? condition.required.filter((key) => typeof key === "string" && key.length > 0)
+            : [];
+        if (!required.every((key) => Object.hasOwn(record, key)))
+            return false;
+        if (condition.properties && typeof condition.properties === "object") {
+            for (const [key, propertySchema] of Object.entries(condition.properties)) {
+                if (Object.hasOwn(record, key) &&
+                    !matchesJsonSchemaCondition(record[key], propertySchema)) {
+                    return false;
+                }
+            }
+        }
+    }
+    if ("not" in condition && matchesJsonSchemaCondition(value, condition.not)) {
         return false;
     }
     if (Array.isArray(condition.anyOf) &&
-        !condition.anyOf.some((entry) => hasRequiredProperties(value, entry))) {
+        !condition.anyOf.some((entry) => matchesJsonSchemaCondition(value, entry))) {
         return false;
     }
     if (Array.isArray(condition.allOf) &&
-        !condition.allOf.every((entry) => hasRequiredProperties(value, entry))) {
+        !condition.allOf.every((entry) => matchesJsonSchemaCondition(value, entry))) {
+        return false;
+    }
+    if (Array.isArray(condition.oneOf) &&
+        condition.oneOf.filter((entry) => matchesJsonSchemaCondition(value, entry))
+            .length !== 1) {
         return false;
     }
     return true;
@@ -40,7 +109,7 @@ function conditionalRequiredKeys(value, condition) {
     const rule = condition;
     if (!("if" in rule) || !("then" in rule))
         return [];
-    if (!hasRequiredProperties(value, rule.if))
+    if (!matchesJsonSchemaCondition(value, rule.if))
         return [];
     if (rule.then === null || typeof rule.then !== "object")
         return [];

package/dist/server/tool-registration.js

@@ -150,9 +150,33 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_apply_plan",
-        execute: async (context, args) => runtime.handleKbApplyPlan
-            ? runtime.handleKbApplyPlan(args, context)
-            : executeApplyPlan(args, context),
+        execute: async (context, args) => {
+            const { async: asyncMode, ...applyArgs } = args;
+            const apply = (applyContext) => runtime.handleKbApplyPlan
+                ? runtime.handleKbApplyPlan(applyArgs, applyContext)
+                : executeApplyPlan(applyArgs, applyContext);
+            // Without a registered kb_job_status nothing could poll the receipt,
+            // so async falls back to a synchronous apply (which still reports
+            // progress when the request carries a progressToken).
+            if (asyncMode !== true || !enabledOptionalTools().has("kb_job_status")) {
+                return apply(context);
+            }
+            // A large bootstrap plan can outlast any client request timeout.
+            // 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.
+            const { onProgress: _requestProgress, ...jobContext } = context;
+            return startJob("kb_apply_plan", async () => {
+                const result = await apply(jobContext);
+                await runtime.operationRuntime.afterSuccess({
+                    name: "kb_apply_plan",
+                    effects: getSpec("kb_apply_plan").effects,
+                    requiresProlog: true,
+                    execute: async () => undefined,
+                }, jobContext);
+                return result;
+            });
+        },
     });
     register({
         name: "kb_ingest_proof",

package/dist/server/tools.js

@@ -85,12 +85,14 @@ function isToolTimeoutError(value) {
         value.code === "KIBI_TOOL_TIMEOUT");
 }
 // implements REQ-002
-async function withToolTimeout(toolName, operation, onTimeout) {
+async function withToolTimeout(toolName, operation, onTimeout, activity) {
     const timeoutMs = getToolTimeoutMs();
     let timeout;
+    let fired = false;
     try {
         const timeoutPromise = new Promise((_, reject) => {
-            timeout = setTimeout(() => {
+            const fire = () => {
+                fired = true;
                 const error = createToolTimeoutError(toolName, timeoutMs);
                 // Do not report the timeout until cancellation/reset has completed
                 // and the original request has reached a terminal state. This is
@@ -105,7 +107,17 @@ async function withToolTimeout(toolName, operation, onTimeout) {
                     ]);
                 })
                     .finally(() => reject(error));
-            }, timeoutMs);
+            };
+            timeout = setTimeout(fire, timeoutMs);
+            if (activity) {
+                activity.touch = () => {
+                    if (fired)
+                        return;
+                    if (timeout)
+                        clearTimeout(timeout);
+                    timeout = setTimeout(fire, timeoutMs);
+                };
+            }
         });
         // When abort settles `operation` before this timeout promise rejects,
         // the late reject must not become an unhandled rejection.
@@ -118,6 +130,35 @@ async function withToolTimeout(toolName, operation, onTimeout) {
         }
     }
 }
+/**
+ * Forward operation progress as MCP notifications/progress when the request
+ * carries a progressToken, and push the server-side tool timeout back on each
+ * report. Progress values must increase, so repeats are nudged forward.
+ */
+// implements REQ-bootstrap-apply-long-running
+export function progressReporter(extra, activity) {
+    const token = extra?._meta?.progressToken;
+    const send = extra?.sendNotification;
+    if (token === undefined || typeof send !== "function")
+        return undefined;
+    let last = -1;
+    return ({ progress, total, message }) => {
+        activity.touch();
+        const value = progress > last ? progress : last + 0.001;
+        last = value;
+        void send({
+            method: "notifications/progress",
+            params: {
+                progressToken: token,
+                progress: value,
+                ...(total === undefined ? {} : { total }),
+                ...(message === undefined ? {} : { message }),
+            },
+        }).catch((error) => {
+            debugLog("[KIBI-MCP] progress notification failed:", error instanceof Error ? error.message : String(error));
+        });
+    };
+}
 /**
  * A module that vanished after startup means the package was upgraded or
  * reinstalled under a running server; only a restart loads the new install.
@@ -177,7 +218,7 @@ export function addTool(server, name, description, inputSchema, handler,
 // generic TProlog parameter exists so tests can inject a mock type. The cast is safe
 // because the runtime object satisfies the full ToolsRuntime contract at runtime.
 runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations, outputSchema) {
-    const wrappedHandler = async (rawArgs) => {
+    const wrappedHandler = async (rawArgs, extra) => {
         const startedAt = new Date();
         const diagnosticModeEnabled = runtime.diagnosticModeEnabled();
         let args = rawArgs;
@@ -228,7 +269,12 @@ runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations, outputSchema) {
                 execute: async (input, _context) => handler(input),
             };
             const observed = observeDetachedReads(runtime.operationRuntime);
-            const handlerPromise = executeOperation(observed.runtime, operationSpec, businessArgs, { signal: controller.signal });
+            const activity = { touch: () => undefined };
+            const onProgress = progressReporter(extra, activity);
+            const handlerPromise = executeOperation(observed.runtime, operationSpec, businessArgs, {
+                signal: controller.signal,
+                ...(onProgress ? { onProgress } : {}),
+            });
             trackedRequests.set(requestId, handlerPromise);
             let resetAttempted = false;
             let resetSucceeded = false;
@@ -261,7 +307,7 @@ runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations, outputSchema) {
                                 ? resetFailure.message
                                 : String(resetFailure);
                     }
-                });
+                }, activity);
                 const data = operationData(result);
                 const envelope = withWorkspaceNotice(withWorkspaceNotice(toKibiResult(operationSpec, data), workspaceNotice), observed.notice());
                 // Log usage in diagnostic mode
@@ -414,12 +460,12 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
 }
 /**
  * kb_job_status polls background jobs started by long-running operations
- * (currently `kb_check` with `async: true`). This is an MCP-server-native
+ * (`kb_check` and `kb_apply_plan` with `async: true`). This is an MCP-server-native
  * companion to the job receipts, not part of the canonical CLI operation
  * catalog: jobs live in the server process and have no CLI counterpart.
  */
 function registerJobStatusTool(server) {
-    addTool(server, "kb_job_status", "Poll a background job started with async:true (e.g. kb_check async jobs). Returns the kibi.job.v1 state: running, succeeded (with the full result), or failed (with the error).", {
+    addTool(server, "kb_job_status", "Poll a background job started with async:true (kb_check or kb_apply_plan async jobs). Returns the kibi.job.v1 state: running, succeeded (with the full result), or failed (with the error).", {
         type: "object",
         properties: {
             jobId: {

package/package.json

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