@agimon-ai/po-task 0.0.0-alpha.8 → 0.0.0-alpha.80

package/dist/extensions/mcp.cjs

@@ -27,8 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let _agimon_ai_po_core_mcpFacet = require("@agimon-ai/po-core/mcpFacet");
 let _agimon_ai_po_core_delegation = require("@agimon-ai/po-core/delegation");
 let typebox = require("typebox");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let _agimon_ai_po_core_childProcess = require("@agimon-ai/po-core/childProcess");
@@ -345,16 +345,6 @@ var TaskStore = class {
 	get snapshot() {
 		return this.cached;
 	}
-	read() {
-		try {
-			const raw = node_fs.default.readFileSync(this.storePath, UTF8_ENCODING);
-			this.cached = normalizeDocument(JSON.parse(raw));
-		} catch (error) {
-			if (error.code !== MISSING_FILE_CODE) this.report?.error(TASK_EVENT.storeReadFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });
-			this.cached = emptyDocument();
-		}
-		return this.cached;
-	}
 	async readAsync(shouldApply = () => true, onReadError) {
 		const storePath = this.storePath;
 		const document = await this.readDocumentAsync(storePath, onReadError);
@@ -364,7 +354,7 @@ var TaskStore = class {
 	}
 	async readDocumentAsync(storePath = this.storePath, onReadError) {
 		try {
-			const raw = await node_fs.default.promises.readFile(storePath, UTF8_ENCODING);
+			const raw = await node_fs_promises.default.readFile(storePath, UTF8_ENCODING);
 			return normalizeDocument(JSON.parse(raw));
 		} catch (error) {
 			if (error.code !== MISSING_FILE_CODE) {
@@ -385,15 +375,16 @@ var TaskStore = class {
 	*/
 	async mutate(mutate) {
 		const release = await this.acquireLock();
-		const outcome = (() => {
+		const outcome = await (async () => {
 			try {
-				const current = this.read();
+				const current = await this.readDocumentAsync();
+				this.cached = current;
 				const mutation = mutate(current);
 				if (!mutation.document) return { result: {
 					document: current,
 					value: mutation.value
 				} };
-				const committed = this.write(mutation.document);
+				const committed = await this.write(mutation.document);
 				return {
 					result: {
 						document: committed,
@@ -402,7 +393,7 @@ var TaskStore = class {
 					notification: committed
 				};
 			} finally {
-				release();
+				await release();
 			}
 		})();
 		if (outcome.notification) this.notifyCommitted(outcome.notification);
@@ -415,49 +406,52 @@ var TaskStore = class {
 			this.report?.error(TASK_EVENT.storeListenerFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });
 		}
 	}
-	write(document) {
+	async write(document) {
 		const next = {
 			...document,
 			version: 1,
 			rev: document.rev + 1
 		};
-		node_fs.default.mkdirSync(node_path.default.dirname(this.storePath), { recursive: true });
+		await node_fs_promises.default.mkdir(node_path.default.dirname(this.storePath), { recursive: true });
 		const temp = tempPathFor(this.storePath);
-		node_fs.default.writeFileSync(temp, `${JSON.stringify(next, void 0, 2)}\n`, UTF8_ENCODING);
-		node_fs.default.renameSync(temp, this.storePath);
+		await node_fs_promises.default.writeFile(temp, `${JSON.stringify(next, void 0, 2)}\n`, UTF8_ENCODING);
+		await node_fs_promises.default.rename(temp, this.storePath);
 		this.cached = next;
 		return next;
 	}
 	async acquireLock() {
 		const lockPath = lockPathFor(this.storePath);
-		node_fs.default.mkdirSync(node_path.default.dirname(this.storePath), { recursive: true });
+		await node_fs_promises.default.mkdir(node_path.default.dirname(this.storePath), { recursive: true });
 		const deadline = Date.now() + this.lockTimeoutMs;
 		for (;;) try {
-			const handle = node_fs.default.openSync(lockPath, "wx");
-			node_fs.default.writeSync(handle, JSON.stringify({
-				pid: process.pid,
-				time: Date.now()
-			}));
-			node_fs.default.closeSync(handle);
-			return () => node_fs.default.rmSync(lockPath, { force: true });
+			const handle = await node_fs_promises.default.open(lockPath, "wx");
+			try {
+				await handle.writeFile(JSON.stringify({
+					pid: process.pid,
+					time: Date.now()
+				}));
+			} finally {
+				await handle.close();
+			}
+			return () => node_fs_promises.default.rm(lockPath, { force: true });
 		} catch (error) {
 			if (error.code !== LOCK_EXISTS_CODE) throw error;
 			if (Date.now() >= deadline) {
 				this.report?.warn(TASK_EVENT.storeLockTimeout, /* @__PURE__ */ new Error(`Task store lock still held after ${this.lockTimeoutMs}ms; proceeding without it`), { [STORE_PATH_ATTRIBUTE]: this.storePath });
-				return () => {};
+				return async () => {};
 			}
-			this.breakStaleLock(lockPath);
+			await this.breakStaleLock(lockPath);
 			await sleep(LOCK_RETRY_BASE_MS + Math.random() * LOCK_RETRY_MAX_MS);
 		}
 	}
 	/** Remove a lock left behind by a dead process or one held implausibly long. */
-	breakStaleLock(lockPath) {
+	async breakStaleLock(lockPath) {
 		try {
-			const holder = JSON.parse(node_fs.default.readFileSync(lockPath, UTF8_ENCODING));
+			const holder = JSON.parse(await node_fs_promises.default.readFile(lockPath, UTF8_ENCODING));
 			const expired = typeof holder.time === "number" && Date.now() - holder.time > LOCK_STALE_MS;
 			const dead = typeof holder.pid === "number" && !isProcessAlive(holder.pid);
 			if (!expired && !dead) return false;
-			node_fs.default.unlinkSync(lockPath);
+			await node_fs_promises.default.unlink(lockPath);
 			return true;
 		} catch (error) {
 			if (error.code !== MISSING_FILE_CODE) this.report?.warn(TASK_EVENT.storeLockBreakFailed, error, { [STORE_PATH_ATTRIBUTE]: lockPath });
@@ -1059,6 +1053,37 @@ async function assignmentBatch(manager, assignments, signal) {
 	}
 	return result;
 }
+/** One task action against the session store, shared by the `task` tool and the `tasks` code-mode namespace. */
+async function runTaskAction(store, manager, maxTasks, rawParams, signal, onUpdate) {
+	if (!(0, typebox_value.Check)(TaskParamsSchema, rawParams)) {
+		const [first] = (0, typebox_value.Errors)(TaskParamsSchema, rawParams);
+		return failure(`Invalid task parameters${first ? `: ${first.instancePath || "/"} ${first.message}` : ""}.`);
+	}
+	const params = rawParams;
+	try {
+		if ((params.action === "assign" || params.action === "cancel") && !manager) throw new Error("Delegation is not available on this connection.");
+		if (params.action === "assign") {
+			if (!params.assignments?.length) throw new Error("assign requires a non-empty assignments[] array");
+			onUpdate?.(output(`Delegating ${params.assignments.length} task${params.assignments.length === 1 ? "" : "s"}...`));
+			const items = await assignmentBatch(manager, params.assignments, signal);
+			const assigned = items.filter((item) => item.ok).map((item) => item.id);
+			const text = formatAssignmentResults(items);
+			if (assigned.length === 0) throw new Error(text);
+			return buildAssignmentResult(params, store.snapshot, text, {
+				assigned,
+				failed: items.length - assigned.length
+			});
+		}
+		if (params.action === "cancel") {
+			const outcome = await manager.cancel(params.id ?? NaN);
+			if (!outcome.ok) throw new Error(outcome.message);
+			return buildTextResult("cancel", params, store.snapshot, outcome.message);
+		}
+		return reducerAction(store, params.action, params, maxTasks);
+	} catch (error) {
+		return failure(error);
+	}
+}
 function createHeadlessTaskTool(store, manager, maxTasks) {
 	return {
 		name: "task",
@@ -1067,33 +1092,7 @@ function createHeadlessTaskTool(store, manager, maxTasks) {
 		parameters: TaskParamsSchema,
 		promptSnippet: "Track complex work persistently and delegate ready tasks",
 		executionMode: "serial",
-		async execute(_toolCallId, rawParams, signal, onUpdate) {
-			if (!(0, typebox_value.Check)(TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
-			const params = rawParams;
-			try {
-				if ((params.action === "assign" || params.action === "cancel") && !manager) throw new Error("Delegation is not available on this connection.");
-				if (params.action === "assign") {
-					if (!params.assignments?.length) throw new Error("assign requires a non-empty assignments[] array");
-					onUpdate?.(output(`Delegating ${params.assignments.length} task${params.assignments.length === 1 ? "" : "s"}...`));
-					const items = await assignmentBatch(manager, params.assignments, signal);
-					const assigned = items.filter((item) => item.ok).map((item) => item.id);
-					const text = formatAssignmentResults(items);
-					if (assigned.length === 0) throw new Error(text);
-					return buildAssignmentResult(params, store.snapshot, text, {
-						assigned,
-						failed: items.length - assigned.length
-					});
-				}
-				if (params.action === "cancel") {
-					const outcome = await manager.cancel(params.id ?? NaN);
-					if (!outcome.ok) throw new Error(outcome.message);
-					return buildTextResult("cancel", params, store.snapshot, outcome.message);
-				}
-				return reducerAction(store, params.action, params, maxTasks);
-			} catch (error) {
-				return failure(error);
-			}
-		}
+		execute: (_toolCallId, rawParams, signal, onUpdate) => runTaskAction(store, manager, maxTasks, rawParams, signal, onUpdate)
 	};
 }
 //#endregion