@aigne/aos 0.2.0-beta

package/dist/mcp/tools.cjs

@@ -0,0 +1,218 @@
+const require_utils = require('./utils.cjs');
+let _aigne_afs_utils_env = require("@aigne/afs/utils/env");
+let zod = require("zod");
+
+//#region src/mcp/tools.ts
+/**
+* Batch-read cap for the MCP tool layer. Deliberately a notch BELOW the CF
+* wire cap (BATCH_LIMITS_CF.maxReadEntries = 20) so a full tool-layer batch
+* never collides with the remote wire budget when the AFS backend is itself
+* remote, and so 16 files' content stays inside a sane tool-result size.
+*/
+const BATCH_READ_MAX_ENTRIES = 16;
+function registerAfsTools(server, afs, context) {
+	server.tool("afs_read", `Read content at an AFS path. To read SEVERAL files, pass \`entries\` (max ${BATCH_READ_MAX_ENTRIES} per call) instead of calling this tool once per file — ONE batched call is always preferred. Batch results are per-entry: check each results[i].success, partial success is normal (a missing file fails alone).`, {
+		path: zod.z.string().optional(),
+		entries: zod.z.array(zod.z.object({ path: zod.z.string() })).max(BATCH_READ_MAX_ENTRIES).optional().describe(`Batch mode: array of {path} entries, up to ${BATCH_READ_MAX_ENTRIES} per call. When provided, \`path\`/\`startLine\`/\`endLine\` are ignored. Chunk larger sets into multiple calls.`),
+		startLine: zod.z.number().int().optional(),
+		endLine: zod.z.number().int().optional()
+	}, async ({ path, entries, startLine, endLine }) => {
+		try {
+			if (entries && entries.length > 0) {
+				if (entries.length > BATCH_READ_MAX_ENTRIES) return require_utils.errorResult(/* @__PURE__ */ new Error(`Too many entries (${entries.length} > ${BATCH_READ_MAX_ENTRIES}) — split into chunks of ${BATCH_READ_MAX_ENTRIES}`));
+				return require_utils.jsonResult(await require_utils.withTimeout(() => afs.batchRead(entries.map((e) => ({ path: require_utils.extractQueryParams(e.path).cleanPath })), { context }), require_utils.TOOL_TIMEOUT_MS * Math.min(entries.length, 10)));
+			}
+			if (!path) return require_utils.errorResult(/* @__PURE__ */ new Error("path is required (or pass `entries` for batch)"));
+			const { cleanPath, query } = require_utils.extractQueryParams(path);
+			const opts = {
+				startLine,
+				endLine
+			};
+			if (Object.keys(query).length > 0) Object.assign(opts, query);
+			const r = await require_utils.withTimeout(() => afs.read(cleanPath, {
+				...opts,
+				context
+			}));
+			if (!r.data && r.data !== "") return require_utils.errorResult(new Error(r.message || "Not found"));
+			return require_utils.jsonResult(r);
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_list", "List directory contents at an AFS path", {
+		path: zod.z.string().describe("AFS path to list, e.g. / or /modules/memory"),
+		depth: zod.z.number().optional().describe("Recursion depth, default 1"),
+		pattern: zod.z.string().optional().describe("Filter pattern, e.g. *.md"),
+		limit: zod.z.number().optional().describe("Max entries to return")
+	}, async ({ path, depth, pattern, limit }) => {
+		try {
+			const { cleanPath, query } = require_utils.extractQueryParams(path);
+			const opts = {
+				maxDepth: depth ?? 1,
+				pattern,
+				limit
+			};
+			if (Object.keys(query).length > 0) Object.assign(opts, query);
+			return require_utils.jsonResult(await require_utils.withTimeout(() => afs.list(cleanPath, {
+				...opts,
+				context
+			})));
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_write", "Write content to an AFS path. To write SEVERAL files, pass `entries` in ONE call (preferred whenever writing more than one file) — never loop single writes. Batch is NOT a transaction: results are per-entry, check each results[i], partial success is normal.", {
+		path: zod.z.string().optional(),
+		content: zod.z.union([zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())]).optional(),
+		mode: zod.z.enum([
+			"replace",
+			"append",
+			"prepend",
+			"patch",
+			"create",
+			"update"
+		]).optional().describe("Write mode (default: replace). Can also ride the path as ?mode=... (explicit param wins)."),
+		patches: zod.z.array(zod.z.object({
+			op: zod.z.enum([
+				"str_replace",
+				"insert_before",
+				"insert_after",
+				"delete"
+			]),
+			target: zod.z.string(),
+			content: zod.z.string().optional().default("")
+		})).optional(),
+		ifMatch: zod.z.string().optional().describe("Optimistic-concurrency token from a previous stat/read meta.version. Mismatch fails with AFS_CONFLICT. Can also ride the path as ?ifMatch=... (explicit param wins)."),
+		entries: zod.z.array(zod.z.object({
+			path: zod.z.string(),
+			content: zod.z.union([zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())]).optional(),
+			mode: zod.z.enum([
+				"replace",
+				"append",
+				"prepend",
+				"patch",
+				"create",
+				"update"
+			]).optional(),
+			patches: zod.z.array(zod.z.object({
+				op: zod.z.enum([
+					"str_replace",
+					"insert_before",
+					"insert_after",
+					"delete"
+				]),
+				target: zod.z.string(),
+				content: zod.z.string().optional().default("")
+			})).optional()
+		})).optional()
+	}, async ({ path, content, mode, patches, ifMatch, entries }) => {
+		try {
+			if (entries && entries.length > 0) {
+				const batch = entries.map((e) => ({
+					path: e.path,
+					content: e.content !== void 0 ? { content: e.content } : void 0,
+					mode: e.mode,
+					patches: e.patches
+				}));
+				return require_utils.jsonResult(await require_utils.withTimeout(() => afs.batchWrite(batch, { context }), require_utils.TOOL_TIMEOUT_MS * Math.min(entries.length, 10)));
+			}
+			if (!path) return require_utils.errorResult(/* @__PURE__ */ new Error("path is required"));
+			const { cleanPath, query } = require_utils.extractQueryParams(path);
+			const payload = {};
+			if (content !== void 0) payload.content = content;
+			if (patches) payload.patches = patches;
+			const { mode: queryMode, ...restQuery } = query;
+			const writeOptions = {};
+			if (Object.keys(restQuery).length > 0) Object.assign(writeOptions, restQuery);
+			const effectiveMode = mode ?? queryMode;
+			if (effectiveMode !== void 0) writeOptions.mode = effectiveMode;
+			if (ifMatch !== void 0) writeOptions.ifMatch = ifMatch;
+			return require_utils.jsonResult(await require_utils.withTimeout(() => afs.write(cleanPath, payload, {
+				...writeOptions,
+				context
+			})));
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_delete", "Delete files at AFS paths. To delete SEVERAL paths, pass `entries` in ONE call (preferred whenever deleting more than one) — never loop single deletes. Batch is NOT a transaction: results are per-entry, check each results[i], partial success is normal.", {
+		path: zod.z.string().optional(),
+		recursive: zod.z.boolean().optional(),
+		ifMatch: zod.z.string().optional().describe("Optimistic-concurrency token from a previous stat/read meta.version. Mismatch fails with AFS_CONFLICT. Can also ride the path as ?ifMatch=... (explicit param wins)."),
+		entries: zod.z.array(zod.z.object({
+			path: zod.z.string(),
+			recursive: zod.z.boolean().optional()
+		})).optional()
+	}, async ({ path, recursive, ifMatch, entries }) => {
+		try {
+			if (entries && entries.length > 0) return require_utils.jsonResult(await require_utils.withTimeout(() => afs.batchDelete(entries.map((e) => ({
+				path: e.path,
+				recursive: e.recursive
+			})), { context }), require_utils.TOOL_TIMEOUT_MS * Math.min(entries.length, 10)));
+			if (!path) return require_utils.errorResult(/* @__PURE__ */ new Error("path is required"));
+			const { cleanPath, query } = require_utils.extractQueryParams(path);
+			const { ifMatch: queryIfMatch, recursive: queryRecursive, ...restQuery } = query;
+			const deleteOptions = {};
+			if (Object.keys(restQuery).length > 0) Object.assign(deleteOptions, restQuery);
+			const effectiveRecursive = recursive ?? (queryRecursive !== void 0 ? (0, _aigne_afs_utils_env.parseBool)(queryRecursive, false) : void 0);
+			if (effectiveRecursive !== void 0) deleteOptions.recursive = effectiveRecursive;
+			const effectiveIfMatch = ifMatch ?? queryIfMatch;
+			if (effectiveIfMatch !== void 0) deleteOptions.meta = {
+				...deleteOptions.meta,
+				ifMatch: effectiveIfMatch
+			};
+			return require_utils.jsonResult(await require_utils.withTimeout(() => afs.delete(cleanPath, {
+				...deleteOptions,
+				context
+			})));
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_search", "Search for content within an AFS path", {
+		path: zod.z.string(),
+		query: zod.z.string(),
+		pattern: zod.z.string().optional(),
+		limit: zod.z.number().optional(),
+		explain: zod.z.boolean().optional()
+	}, async ({ path, query, limit, explain }) => {
+		try {
+			return require_utils.jsonResult(await require_utils.withTimeout(() => afs.search(path, query, {
+				limit,
+				explain,
+				context
+			})));
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_exec", "Execute an action. Use afs_list on {path}/.actions to discover available actions and their inputSchema.", {
+		path: zod.z.string().describe("Action path, e.g. /.actions/mount or /sites/my-site/.actions/build"),
+		args: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Action arguments matching the action's inputSchema")
+	}, async ({ path, args }) => {
+		try {
+			return require_utils.jsonResult(await require_utils.withTimeout(() => afs.exec(path, args ?? {}, { context }), require_utils.EXEC_TIMEOUT_MS));
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_stat", "Get metadata for an AFS path", { path: zod.z.string() }, async ({ path }) => {
+		try {
+			const r = await require_utils.withTimeout(() => afs.stat(path, { context }));
+			if (!r.data) return require_utils.errorResult(new Error(r.message || "Not found"));
+			return require_utils.jsonResult(r);
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+	server.tool("afs_explain", "Get explanation for an AFS path", { path: zod.z.string() }, async ({ path }) => {
+		try {
+			return require_utils.textResult((await require_utils.withTimeout(() => afs.explain(path, { context }))).content);
+		} catch (e) {
+			return require_utils.errorResult(e);
+		}
+	});
+}
+
+//#endregion
+exports.registerAfsTools = registerAfsTools;

package/dist/mcp/tools.d.cts

@@ -0,0 +1,8 @@
+import { AFS, AFSContext } from "@aigne/afs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/mcp/tools.d.ts
+declare function registerAfsTools(server: McpServer, afs: AFS, context?: AFSContext): void;
+//#endregion
+export { registerAfsTools };
+//# sourceMappingURL=tools.d.cts.map

package/dist/mcp/tools.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.cts","names":[],"sources":["../../src/mcp/tools.ts"],"mappings":";;;;iBAsBgB,gBAAA,CAAiB,MAAA,EAAQ,SAAA,EAAW,GAAA,EAAK,GAAA,EAAK,OAAA,GAAU,UAAA"}

package/dist/mcp/tools.d.mts

@@ -0,0 +1,8 @@
+import { AFS, AFSContext } from "@aigne/afs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/mcp/tools.d.ts
+declare function registerAfsTools(server: McpServer, afs: AFS, context?: AFSContext): void;
+//#endregion
+export { registerAfsTools };
+//# sourceMappingURL=tools.d.mts.map

package/dist/mcp/tools.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.mts","names":[],"sources":["../../src/mcp/tools.ts"],"mappings":";;;;iBAsBgB,gBAAA,CAAiB,MAAA,EAAQ,SAAA,EAAW,GAAA,EAAK,GAAA,EAAK,OAAA,GAAU,UAAA"}

package/dist/mcp/tools.mjs

@@ -0,0 +1,219 @@
+import { EXEC_TIMEOUT_MS, TOOL_TIMEOUT_MS, errorResult, extractQueryParams, jsonResult, textResult, withTimeout } from "./utils.mjs";
+import { parseBool } from "@aigne/afs/utils/env";
+import { z } from "zod";
+
+//#region src/mcp/tools.ts
+/**
+* Batch-read cap for the MCP tool layer. Deliberately a notch BELOW the CF
+* wire cap (BATCH_LIMITS_CF.maxReadEntries = 20) so a full tool-layer batch
+* never collides with the remote wire budget when the AFS backend is itself
+* remote, and so 16 files' content stays inside a sane tool-result size.
+*/
+const BATCH_READ_MAX_ENTRIES = 16;
+function registerAfsTools(server, afs, context) {
+	server.tool("afs_read", `Read content at an AFS path. To read SEVERAL files, pass \`entries\` (max ${BATCH_READ_MAX_ENTRIES} per call) instead of calling this tool once per file — ONE batched call is always preferred. Batch results are per-entry: check each results[i].success, partial success is normal (a missing file fails alone).`, {
+		path: z.string().optional(),
+		entries: z.array(z.object({ path: z.string() })).max(BATCH_READ_MAX_ENTRIES).optional().describe(`Batch mode: array of {path} entries, up to ${BATCH_READ_MAX_ENTRIES} per call. When provided, \`path\`/\`startLine\`/\`endLine\` are ignored. Chunk larger sets into multiple calls.`),
+		startLine: z.number().int().optional(),
+		endLine: z.number().int().optional()
+	}, async ({ path, entries, startLine, endLine }) => {
+		try {
+			if (entries && entries.length > 0) {
+				if (entries.length > BATCH_READ_MAX_ENTRIES) return errorResult(/* @__PURE__ */ new Error(`Too many entries (${entries.length} > ${BATCH_READ_MAX_ENTRIES}) — split into chunks of ${BATCH_READ_MAX_ENTRIES}`));
+				return jsonResult(await withTimeout(() => afs.batchRead(entries.map((e) => ({ path: extractQueryParams(e.path).cleanPath })), { context }), TOOL_TIMEOUT_MS * Math.min(entries.length, 10)));
+			}
+			if (!path) return errorResult(/* @__PURE__ */ new Error("path is required (or pass `entries` for batch)"));
+			const { cleanPath, query } = extractQueryParams(path);
+			const opts = {
+				startLine,
+				endLine
+			};
+			if (Object.keys(query).length > 0) Object.assign(opts, query);
+			const r = await withTimeout(() => afs.read(cleanPath, {
+				...opts,
+				context
+			}));
+			if (!r.data && r.data !== "") return errorResult(new Error(r.message || "Not found"));
+			return jsonResult(r);
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_list", "List directory contents at an AFS path", {
+		path: z.string().describe("AFS path to list, e.g. / or /modules/memory"),
+		depth: z.number().optional().describe("Recursion depth, default 1"),
+		pattern: z.string().optional().describe("Filter pattern, e.g. *.md"),
+		limit: z.number().optional().describe("Max entries to return")
+	}, async ({ path, depth, pattern, limit }) => {
+		try {
+			const { cleanPath, query } = extractQueryParams(path);
+			const opts = {
+				maxDepth: depth ?? 1,
+				pattern,
+				limit
+			};
+			if (Object.keys(query).length > 0) Object.assign(opts, query);
+			return jsonResult(await withTimeout(() => afs.list(cleanPath, {
+				...opts,
+				context
+			})));
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_write", "Write content to an AFS path. To write SEVERAL files, pass `entries` in ONE call (preferred whenever writing more than one file) — never loop single writes. Batch is NOT a transaction: results are per-entry, check each results[i], partial success is normal.", {
+		path: z.string().optional(),
+		content: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+		mode: z.enum([
+			"replace",
+			"append",
+			"prepend",
+			"patch",
+			"create",
+			"update"
+		]).optional().describe("Write mode (default: replace). Can also ride the path as ?mode=... (explicit param wins)."),
+		patches: z.array(z.object({
+			op: z.enum([
+				"str_replace",
+				"insert_before",
+				"insert_after",
+				"delete"
+			]),
+			target: z.string(),
+			content: z.string().optional().default("")
+		})).optional(),
+		ifMatch: z.string().optional().describe("Optimistic-concurrency token from a previous stat/read meta.version. Mismatch fails with AFS_CONFLICT. Can also ride the path as ?ifMatch=... (explicit param wins)."),
+		entries: z.array(z.object({
+			path: z.string(),
+			content: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+			mode: z.enum([
+				"replace",
+				"append",
+				"prepend",
+				"patch",
+				"create",
+				"update"
+			]).optional(),
+			patches: z.array(z.object({
+				op: z.enum([
+					"str_replace",
+					"insert_before",
+					"insert_after",
+					"delete"
+				]),
+				target: z.string(),
+				content: z.string().optional().default("")
+			})).optional()
+		})).optional()
+	}, async ({ path, content, mode, patches, ifMatch, entries }) => {
+		try {
+			if (entries && entries.length > 0) {
+				const batch = entries.map((e) => ({
+					path: e.path,
+					content: e.content !== void 0 ? { content: e.content } : void 0,
+					mode: e.mode,
+					patches: e.patches
+				}));
+				return jsonResult(await withTimeout(() => afs.batchWrite(batch, { context }), TOOL_TIMEOUT_MS * Math.min(entries.length, 10)));
+			}
+			if (!path) return errorResult(/* @__PURE__ */ new Error("path is required"));
+			const { cleanPath, query } = extractQueryParams(path);
+			const payload = {};
+			if (content !== void 0) payload.content = content;
+			if (patches) payload.patches = patches;
+			const { mode: queryMode, ...restQuery } = query;
+			const writeOptions = {};
+			if (Object.keys(restQuery).length > 0) Object.assign(writeOptions, restQuery);
+			const effectiveMode = mode ?? queryMode;
+			if (effectiveMode !== void 0) writeOptions.mode = effectiveMode;
+			if (ifMatch !== void 0) writeOptions.ifMatch = ifMatch;
+			return jsonResult(await withTimeout(() => afs.write(cleanPath, payload, {
+				...writeOptions,
+				context
+			})));
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_delete", "Delete files at AFS paths. To delete SEVERAL paths, pass `entries` in ONE call (preferred whenever deleting more than one) — never loop single deletes. Batch is NOT a transaction: results are per-entry, check each results[i], partial success is normal.", {
+		path: z.string().optional(),
+		recursive: z.boolean().optional(),
+		ifMatch: z.string().optional().describe("Optimistic-concurrency token from a previous stat/read meta.version. Mismatch fails with AFS_CONFLICT. Can also ride the path as ?ifMatch=... (explicit param wins)."),
+		entries: z.array(z.object({
+			path: z.string(),
+			recursive: z.boolean().optional()
+		})).optional()
+	}, async ({ path, recursive, ifMatch, entries }) => {
+		try {
+			if (entries && entries.length > 0) return jsonResult(await withTimeout(() => afs.batchDelete(entries.map((e) => ({
+				path: e.path,
+				recursive: e.recursive
+			})), { context }), TOOL_TIMEOUT_MS * Math.min(entries.length, 10)));
+			if (!path) return errorResult(/* @__PURE__ */ new Error("path is required"));
+			const { cleanPath, query } = extractQueryParams(path);
+			const { ifMatch: queryIfMatch, recursive: queryRecursive, ...restQuery } = query;
+			const deleteOptions = {};
+			if (Object.keys(restQuery).length > 0) Object.assign(deleteOptions, restQuery);
+			const effectiveRecursive = recursive ?? (queryRecursive !== void 0 ? parseBool(queryRecursive, false) : void 0);
+			if (effectiveRecursive !== void 0) deleteOptions.recursive = effectiveRecursive;
+			const effectiveIfMatch = ifMatch ?? queryIfMatch;
+			if (effectiveIfMatch !== void 0) deleteOptions.meta = {
+				...deleteOptions.meta,
+				ifMatch: effectiveIfMatch
+			};
+			return jsonResult(await withTimeout(() => afs.delete(cleanPath, {
+				...deleteOptions,
+				context
+			})));
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_search", "Search for content within an AFS path", {
+		path: z.string(),
+		query: z.string(),
+		pattern: z.string().optional(),
+		limit: z.number().optional(),
+		explain: z.boolean().optional()
+	}, async ({ path, query, limit, explain }) => {
+		try {
+			return jsonResult(await withTimeout(() => afs.search(path, query, {
+				limit,
+				explain,
+				context
+			})));
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_exec", "Execute an action. Use afs_list on {path}/.actions to discover available actions and their inputSchema.", {
+		path: z.string().describe("Action path, e.g. /.actions/mount or /sites/my-site/.actions/build"),
+		args: z.record(z.string(), z.unknown()).optional().describe("Action arguments matching the action's inputSchema")
+	}, async ({ path, args }) => {
+		try {
+			return jsonResult(await withTimeout(() => afs.exec(path, args ?? {}, { context }), EXEC_TIMEOUT_MS));
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_stat", "Get metadata for an AFS path", { path: z.string() }, async ({ path }) => {
+		try {
+			const r = await withTimeout(() => afs.stat(path, { context }));
+			if (!r.data) return errorResult(new Error(r.message || "Not found"));
+			return jsonResult(r);
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+	server.tool("afs_explain", "Get explanation for an AFS path", { path: z.string() }, async ({ path }) => {
+		try {
+			return textResult((await withTimeout(() => afs.explain(path, { context }))).content);
+		} catch (e) {
+			return errorResult(e);
+		}
+	});
+}
+
+//#endregion
+export { registerAfsTools };
+//# sourceMappingURL=tools.mjs.map

package/dist/mcp/tools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.mjs","names":[],"sources":["../../src/mcp/tools.ts"],"sourcesContent":["import type { AFS, AFSContext } from \"@aigne/afs\";\nimport { parseBool } from \"@aigne/afs/utils/env\";\nimport type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { z } from \"zod\";\nimport {\n  EXEC_TIMEOUT_MS,\n  errorResult,\n  extractQueryParams,\n  jsonResult,\n  TOOL_TIMEOUT_MS,\n  textResult,\n  withTimeout,\n} from \"./utils.js\";\n\n/**\n * Batch-read cap for the MCP tool layer. Deliberately a notch BELOW the CF\n * wire cap (BATCH_LIMITS_CF.maxReadEntries = 20) so a full tool-layer batch\n * never collides with the remote wire budget when the AFS backend is itself\n * remote, and so 16 files' content stays inside a sane tool-result size.\n */\nconst BATCH_READ_MAX_ENTRIES = 16;\n\nexport function registerAfsTools(server: McpServer, afs: AFS, context?: AFSContext): void {\n  server.tool(\n    \"afs_read\",\n    \"Read content at an AFS path. To read SEVERAL files, pass `entries` (max \" +\n      `${BATCH_READ_MAX_ENTRIES} per call) instead of calling this tool once per file — ` +\n      \"ONE batched call is always preferred. Batch results are per-entry: check each \" +\n      \"results[i].success, partial success is normal (a missing file fails alone).\",\n    {\n      path: z.string().optional(),\n      entries: z\n        .array(z.object({ path: z.string() }))\n        .max(BATCH_READ_MAX_ENTRIES)\n        .optional()\n        .describe(\n          `Batch mode: array of {path} entries, up to ${BATCH_READ_MAX_ENTRIES} per call. ` +\n            \"When provided, `path`/`startLine`/`endLine` are ignored. \" +\n            \"Chunk larger sets into multiple calls.\",\n        ),\n      startLine: z.number().int().optional(),\n      endLine: z.number().int().optional(),\n    },\n    async ({ path, entries, startLine, endLine }) => {\n      try {\n        if (entries && entries.length > 0) {\n          if (entries.length > BATCH_READ_MAX_ENTRIES) {\n            return errorResult(\n              new Error(\n                `Too many entries (${entries.length} > ${BATCH_READ_MAX_ENTRIES}) — split into chunks of ${BATCH_READ_MAX_ENTRIES}`,\n              ),\n            );\n          }\n          const r = await withTimeout(\n            () =>\n              afs.batchRead(\n                entries.map((e) => ({ path: extractQueryParams(e.path).cleanPath })),\n                { context },\n              ),\n            TOOL_TIMEOUT_MS * Math.min(entries.length, 10),\n          );\n          return jsonResult(r);\n        }\n        if (!path) return errorResult(new Error(\"path is required (or pass `entries` for batch)\"));\n        const { cleanPath, query } = extractQueryParams(path);\n        const opts: Record<string, unknown> = { startLine, endLine };\n        if (Object.keys(query).length > 0) Object.assign(opts, query);\n        const r = await withTimeout(() => afs.read(cleanPath, { ...opts, context }));\n        if (!r.data && r.data !== \"\") return errorResult(new Error(r.message || \"Not found\"));\n        return jsonResult(r);\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_list\",\n    \"List directory contents at an AFS path\",\n    {\n      path: z.string().describe(\"AFS path to list, e.g. / or /modules/memory\"),\n      depth: z.number().optional().describe(\"Recursion depth, default 1\"),\n      pattern: z.string().optional().describe(\"Filter pattern, e.g. *.md\"),\n      limit: z.number().optional().describe(\"Max entries to return\"),\n    },\n    async ({ path, depth, pattern, limit }) => {\n      try {\n        const { cleanPath, query } = extractQueryParams(path);\n        const opts: Record<string, unknown> = { maxDepth: depth ?? 1, pattern, limit };\n        if (Object.keys(query).length > 0) Object.assign(opts, query);\n        return jsonResult(await withTimeout(() => afs.list(cleanPath, { ...opts, context })));\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_write\",\n    \"Write content to an AFS path. To write SEVERAL files, pass `entries` in ONE call \" +\n      \"(preferred whenever writing more than one file) — never loop single writes. \" +\n      \"Batch is NOT a transaction: results are per-entry, check each results[i], \" +\n      \"partial success is normal.\",\n    {\n      path: z.string().optional(),\n      content: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),\n      mode: z\n        .enum([\"replace\", \"append\", \"prepend\", \"patch\", \"create\", \"update\"])\n        .optional()\n        .describe(\n          \"Write mode (default: replace). Can also ride the path as ?mode=... (explicit param wins).\",\n        ),\n      patches: z\n        .array(\n          z.object({\n            op: z.enum([\"str_replace\", \"insert_before\", \"insert_after\", \"delete\"]),\n            target: z.string(),\n            content: z.string().optional().default(\"\"),\n          }),\n        )\n        .optional(),\n      ifMatch: z\n        .string()\n        .optional()\n        .describe(\n          \"Optimistic-concurrency token from a previous stat/read meta.version. Mismatch fails with AFS_CONFLICT. Can also ride the path as ?ifMatch=... (explicit param wins).\",\n        ),\n      entries: z\n        .array(\n          z.object({\n            path: z.string(),\n            content: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),\n            mode: z.enum([\"replace\", \"append\", \"prepend\", \"patch\", \"create\", \"update\"]).optional(),\n            patches: z\n              .array(\n                z.object({\n                  op: z.enum([\"str_replace\", \"insert_before\", \"insert_after\", \"delete\"]),\n                  target: z.string(),\n                  content: z.string().optional().default(\"\"),\n                }),\n              )\n              .optional(),\n          }),\n        )\n        .optional(),\n    },\n    async ({ path, content, mode, patches, ifMatch, entries }) => {\n      try {\n        if (entries && entries.length > 0) {\n          const batch = entries.map((e) => ({\n            path: e.path,\n            content: e.content !== undefined ? { content: e.content } : undefined,\n            mode: e.mode as any,\n            patches: e.patches,\n          }));\n          return jsonResult(\n            await withTimeout(\n              () => afs.batchWrite(batch, { context }),\n              TOOL_TIMEOUT_MS * Math.min(entries.length, 10),\n            ),\n          );\n        }\n        if (!path) return errorResult(new Error(\"path is required\"));\n        // Query-param channel (same shape as afs_read/afs_list): ?session=…,\n        // ?ifMatch=…, ?mode=… ride the path and merge into write options. The\n        // explicit tool params win over their query counterparts. Mirrors\n        // runtimes/node/src/mcp/tools.ts — the daemon serves THIS registration\n        // on /mcp, so the optimistic-concurrency channel must exist here too.\n        const { cleanPath, query } = extractQueryParams(path);\n        const payload: Record<string, unknown> = {};\n        if (content !== undefined) payload.content = content;\n        if (patches) payload.patches = patches;\n        const { mode: queryMode, ...restQuery } = query;\n        const writeOptions: Record<string, unknown> = {};\n        if (Object.keys(restQuery).length > 0) Object.assign(writeOptions, restQuery);\n        const effectiveMode = mode ?? queryMode;\n        if (effectiveMode !== undefined) writeOptions.mode = effectiveMode;\n        if (ifMatch !== undefined) writeOptions.ifMatch = ifMatch;\n        return jsonResult(\n          await withTimeout(() => afs.write(cleanPath, payload, { ...writeOptions, context })),\n        );\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_delete\",\n    \"Delete files at AFS paths. To delete SEVERAL paths, pass `entries` in ONE call \" +\n      \"(preferred whenever deleting more than one) — never loop single deletes. \" +\n      \"Batch is NOT a transaction: results are per-entry, check each results[i], \" +\n      \"partial success is normal.\",\n    {\n      path: z.string().optional(),\n      recursive: z.boolean().optional(),\n      ifMatch: z\n        .string()\n        .optional()\n        .describe(\n          \"Optimistic-concurrency token from a previous stat/read meta.version. Mismatch fails with AFS_CONFLICT. Can also ride the path as ?ifMatch=... (explicit param wins).\",\n        ),\n      entries: z\n        .array(z.object({ path: z.string(), recursive: z.boolean().optional() }))\n        .optional(),\n    },\n    async ({ path, recursive, ifMatch, entries }) => {\n      try {\n        if (entries && entries.length > 0) {\n          return jsonResult(\n            await withTimeout(\n              () =>\n                afs.batchDelete(\n                  entries.map((e) => ({ path: e.path, recursive: e.recursive })),\n                  { context },\n                ),\n              TOOL_TIMEOUT_MS * Math.min(entries.length, 10),\n            ),\n          );\n        }\n        if (!path) return errorResult(new Error(\"path is required\"));\n        // Query-param channel (same shape as afs_read/afs_list). Delete-side\n        // ifMatch travels in options.meta.ifMatch (AFSDeleteOptions contract);\n        // explicit tool params (ifMatch, recursive) win over query values.\n        const { cleanPath, query } = extractQueryParams(path);\n        const { ifMatch: queryIfMatch, recursive: queryRecursive, ...restQuery } = query;\n        const deleteOptions: Record<string, unknown> = {};\n        if (Object.keys(restQuery).length > 0) Object.assign(deleteOptions, restQuery);\n        // Query-string \"?recursive=…\" coerces with parseBool semantics; an\n        // unrecognized token falls back to FALSE — delete is destructive, a\n        // typo must never turn into a recursive delete.\n        const effectiveRecursive =\n          recursive ??\n          (queryRecursive !== undefined ? parseBool(queryRecursive, false) : undefined);\n        if (effectiveRecursive !== undefined) deleteOptions.recursive = effectiveRecursive;\n        const effectiveIfMatch = ifMatch ?? queryIfMatch;\n        if (effectiveIfMatch !== undefined) {\n          deleteOptions.meta = {\n            ...(deleteOptions.meta as Record<string, unknown> | undefined),\n            ifMatch: effectiveIfMatch,\n          };\n        }\n        return jsonResult(\n          await withTimeout(() => afs.delete(cleanPath, { ...deleteOptions, context })),\n        );\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_search\",\n    \"Search for content within an AFS path\",\n    {\n      path: z.string(),\n      query: z.string(),\n      pattern: z.string().optional(),\n      limit: z.number().optional(),\n      // Per-result \"why did this match\" debug info (issue #1069). When true, a\n      // semantic-index-backed search (`/user/**`) attaches `explanation` (+\n      // matched `anchors` for anchor hits) on each result's `meta`.\n      explain: z.boolean().optional(),\n    },\n    async ({ path, query, limit, explain }) => {\n      try {\n        return jsonResult(\n          await withTimeout(() => afs.search(path, query, { limit, explain, context })),\n        );\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_exec\",\n    \"Execute an action. Use afs_list on {path}/.actions to discover available actions and their inputSchema.\",\n    {\n      path: z\n        .string()\n        .describe(\"Action path, e.g. /.actions/mount or /sites/my-site/.actions/build\"),\n      args: z\n        .record(z.string(), z.unknown())\n        .optional()\n        .describe(\"Action arguments matching the action's inputSchema\"),\n    },\n    async ({ path, args }) => {\n      try {\n        return jsonResult(\n          await withTimeout(() => afs.exec(path, args ?? {}, { context }), EXEC_TIMEOUT_MS),\n        );\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_stat\",\n    \"Get metadata for an AFS path\",\n    { path: z.string() },\n    async ({ path }) => {\n      try {\n        const r = await withTimeout(() => afs.stat(path, { context }));\n        if (!r.data) return errorResult(new Error(r.message || \"Not found\"));\n        return jsonResult(r);\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n  server.tool(\n    \"afs_explain\",\n    \"Get explanation for an AFS path\",\n    { path: z.string() },\n    async ({ path }) => {\n      try {\n        return textResult((await withTimeout(() => afs.explain(path, { context }))).content);\n      } catch (e) {\n        return errorResult(e);\n      }\n    },\n  );\n}\n"],"mappings":"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"}

package/dist/mcp/utils.cjs

@@ -0,0 +1,75 @@
+
+//#region src/mcp/utils.ts
+const TOOL_TIMEOUT_MS = 3e4;
+const EXEC_TIMEOUT_MS = 3e5;
+function withTimeout(fn, timeoutMs = TOOL_TIMEOUT_MS) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Operation timed out after ${timeoutMs / 1e3}s`)), timeoutMs);
+		fn().then((r) => {
+			clearTimeout(timer);
+			resolve(r);
+		}, (e) => {
+			clearTimeout(timer);
+			reject(e);
+		});
+	});
+}
+function errorResult(error) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: (error instanceof Error ? error.message : String(error)).split("\n")[0] || "Operation failed"
+		}]
+	};
+}
+function jsonResult(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+function textResult(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+const QUERY_PARAM_CACHE_MAX = 256;
+const queryParamCache = /* @__PURE__ */ new Map();
+function extractQueryParams(path) {
+	const cached = queryParamCache.get(path);
+	if (cached) return {
+		cleanPath: cached.cleanPath,
+		query: { ...cached.query }
+	};
+	const q = path.indexOf("?");
+	if (q < 0) return {
+		cleanPath: path,
+		query: {}
+	};
+	const cleanPath = path.slice(0, q);
+	const query = {};
+	for (const [k, v] of new URLSearchParams(path.slice(q + 1))) query[k] = v;
+	queryParamCache.set(path, {
+		cleanPath,
+		query
+	});
+	if (queryParamCache.size > QUERY_PARAM_CACHE_MAX) {
+		const firstKey = queryParamCache.keys().next().value;
+		if (firstKey !== void 0) queryParamCache.delete(firstKey);
+	}
+	return {
+		cleanPath,
+		query: { ...query }
+	};
+}
+
+//#endregion
+exports.EXEC_TIMEOUT_MS = EXEC_TIMEOUT_MS;
+exports.TOOL_TIMEOUT_MS = TOOL_TIMEOUT_MS;
+exports.errorResult = errorResult;
+exports.extractQueryParams = extractQueryParams;
+exports.jsonResult = jsonResult;
+exports.textResult = textResult;
+exports.withTimeout = withTimeout;

package/dist/mcp/utils.mjs

@@ -0,0 +1,69 @@
+//#region src/mcp/utils.ts
+const TOOL_TIMEOUT_MS = 3e4;
+const EXEC_TIMEOUT_MS = 3e5;
+function withTimeout(fn, timeoutMs = TOOL_TIMEOUT_MS) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Operation timed out after ${timeoutMs / 1e3}s`)), timeoutMs);
+		fn().then((r) => {
+			clearTimeout(timer);
+			resolve(r);
+		}, (e) => {
+			clearTimeout(timer);
+			reject(e);
+		});
+	});
+}
+function errorResult(error) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: (error instanceof Error ? error.message : String(error)).split("\n")[0] || "Operation failed"
+		}]
+	};
+}
+function jsonResult(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+function textResult(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+const QUERY_PARAM_CACHE_MAX = 256;
+const queryParamCache = /* @__PURE__ */ new Map();
+function extractQueryParams(path) {
+	const cached = queryParamCache.get(path);
+	if (cached) return {
+		cleanPath: cached.cleanPath,
+		query: { ...cached.query }
+	};
+	const q = path.indexOf("?");
+	if (q < 0) return {
+		cleanPath: path,
+		query: {}
+	};
+	const cleanPath = path.slice(0, q);
+	const query = {};
+	for (const [k, v] of new URLSearchParams(path.slice(q + 1))) query[k] = v;
+	queryParamCache.set(path, {
+		cleanPath,
+		query
+	});
+	if (queryParamCache.size > QUERY_PARAM_CACHE_MAX) {
+		const firstKey = queryParamCache.keys().next().value;
+		if (firstKey !== void 0) queryParamCache.delete(firstKey);
+	}
+	return {
+		cleanPath,
+		query: { ...query }
+	};
+}
+
+//#endregion
+export { EXEC_TIMEOUT_MS, TOOL_TIMEOUT_MS, errorResult, extractQueryParams, jsonResult, textResult, withTimeout };
+//# sourceMappingURL=utils.mjs.map

package/dist/mcp/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../src/mcp/utils.ts"],"sourcesContent":["export const TOOL_TIMEOUT_MS = 30_000;\nexport const EXEC_TIMEOUT_MS = 300_000;\nexport function withTimeout<T>(fn: () => Promise<T>, timeoutMs = TOOL_TIMEOUT_MS): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(\n      () => reject(new Error(`Operation timed out after ${timeoutMs / 1000}s`)),\n      timeoutMs,\n    );\n    fn().then(\n      (r) => {\n        clearTimeout(timer);\n        resolve(r);\n      },\n      (e) => {\n        clearTimeout(timer);\n        reject(e);\n      },\n    );\n  });\n}\nexport function errorResult(error: unknown) {\n  const m = error instanceof Error ? error.message : String(error);\n  return {\n    isError: true as const,\n    content: [{ type: \"text\" as const, text: m.split(\"\\n\")[0] || \"Operation failed\" }],\n  };\n}\nexport function jsonResult(data: unknown) {\n  return { content: [{ type: \"text\" as const, text: JSON.stringify(data, null, 2) }] };\n}\nexport function textResult(text: string) {\n  return { content: [{ type: \"text\" as const, text }] };\n}\n\nconst QUERY_PARAM_CACHE_MAX = 256;\nconst queryParamCache = new Map<string, { cleanPath: string; query: Record<string, string> }>();\n\nexport function extractQueryParams(path: string): {\n  cleanPath: string;\n  query: Record<string, string>;\n} {\n  const cached = queryParamCache.get(path);\n  if (cached) return { cleanPath: cached.cleanPath, query: { ...cached.query } };\n\n  const q = path.indexOf(\"?\");\n  if (q < 0) return { cleanPath: path, query: {} };\n\n  const cleanPath = path.slice(0, q);\n  const query: Record<string, string> = {};\n  for (const [k, v] of new URLSearchParams(path.slice(q + 1))) query[k] = v;\n\n  queryParamCache.set(path, { cleanPath, query });\n  if (queryParamCache.size > QUERY_PARAM_CACHE_MAX) {\n    const firstKey = queryParamCache.keys().next().value;\n    if (firstKey !== undefined) queryParamCache.delete(firstKey);\n  }\n\n  return { cleanPath, query: { ...query } };\n}\n"],"mappings":";AAAA,MAAa,kBAAkB;AAC/B,MAAa,kBAAkB;AAC/B,SAAgB,YAAe,IAAsB,YAAY,iBAA6B;AAC5F,QAAO,IAAI,SAAY,SAAS,WAAW;EACzC,MAAM,QAAQ,iBACN,uBAAO,IAAI,MAAM,6BAA6B,YAAY,IAAK,GAAG,CAAC,EACzE,UACD;AACD,MAAI,CAAC,MACF,MAAM;AACL,gBAAa,MAAM;AACnB,WAAQ,EAAE;MAEX,MAAM;AACL,gBAAa,MAAM;AACnB,UAAO,EAAE;IAEZ;GACD;;AAEJ,SAAgB,YAAY,OAAgB;AAE1C,QAAO;EACL,SAAS;EACT,SAAS,CAAC;GAAE,MAAM;GAAiB,OAH3B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,EAGnB,MAAM,KAAK,CAAC,MAAM;GAAoB,CAAC;EACnF;;AAEH,SAAgB,WAAW,MAAe;AACxC,QAAO,EAAE,SAAS,CAAC;EAAE,MAAM;EAAiB,MAAM,KAAK,UAAU,MAAM,MAAM,EAAE;EAAE,CAAC,EAAE;;AAEtF,SAAgB,WAAW,MAAc;AACvC,QAAO,EAAE,SAAS,CAAC;EAAE,MAAM;EAAiB;EAAM,CAAC,EAAE;;AAGvD,MAAM,wBAAwB;AAC9B,MAAM,kCAAkB,IAAI,KAAmE;AAE/F,SAAgB,mBAAmB,MAGjC;CACA,MAAM,SAAS,gBAAgB,IAAI,KAAK;AACxC,KAAI,OAAQ,QAAO;EAAE,WAAW,OAAO;EAAW,OAAO,EAAE,GAAG,OAAO,OAAO;EAAE;CAE9E,MAAM,IAAI,KAAK,QAAQ,IAAI;AAC3B,KAAI,IAAI,EAAG,QAAO;EAAE,WAAW;EAAM,OAAO,EAAE;EAAE;CAEhD,MAAM,YAAY,KAAK,MAAM,GAAG,EAAE;CAClC,MAAM,QAAgC,EAAE;AACxC,MAAK,MAAM,CAAC,GAAG,MAAM,IAAI,gBAAgB,KAAK,MAAM,IAAI,EAAE,CAAC,CAAE,OAAM,KAAK;AAExE,iBAAgB,IAAI,MAAM;EAAE;EAAW;EAAO,CAAC;AAC/C,KAAI,gBAAgB,OAAO,uBAAuB;EAChD,MAAM,WAAW,gBAAgB,MAAM,CAAC,MAAM,CAAC;AAC/C,MAAI,aAAa,OAAW,iBAAgB,OAAO,SAAS;;AAG9D,QAAO;EAAE;EAAW,OAAO,EAAE,GAAG,OAAO;EAAE"}

package/dist/mount/index.cjs

@@ -0,0 +1,4 @@
+const require_materializer = require('./materializer.cjs');
+
+exports.materializeProviderMount = require_materializer.materializeProviderMount;
+exports.redactError = require_materializer.redactError;