@agimon-ai/po-task 0.0.0-alpha.7 → 0.0.0-alpha.71

package/dist/extensions/mcp.mjs

@@ -1,11 +1,11 @@
 import { defineMcpPlugin, defineMcpTool } from "@agimon-ai/po-core/mcpFacet";
 import { InlineAgentSchema } from "@agimon-ai/po-core/delegation";
 import { Type } from "typebox";
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "@agimon-ai/po-core/childProcess";
 import { piAgentDirectory } from "@agimon-ai/po-core/piSettings";
-import { Check } from "typebox/value";
+import { Check, Errors } from "typebox/value";
 //#region src/schemas/task.ts
 const TASK_ACTIONS = [
 	"upsert",
@@ -317,16 +317,6 @@ var TaskStore = class {
 	get snapshot() {
 		return this.cached;
 	}
-	read() {
-		try {
-			const raw = fs.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);
@@ -336,7 +326,7 @@ var TaskStore = class {
 	}
 	async readDocumentAsync(storePath = this.storePath, onReadError) {
 		try {
-			const raw = await fs.promises.readFile(storePath, UTF8_ENCODING);
+			const raw = await fs.readFile(storePath, UTF8_ENCODING);
 			return normalizeDocument(JSON.parse(raw));
 		} catch (error) {
 			if (error.code !== MISSING_FILE_CODE) {
@@ -357,15 +347,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,
@@ -374,7 +365,7 @@ var TaskStore = class {
 					notification: committed
 				};
 			} finally {
-				release();
+				await release();
 			}
 		})();
 		if (outcome.notification) this.notifyCommitted(outcome.notification);
@@ -387,49 +378,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
 		};
-		fs.mkdirSync(path.dirname(this.storePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.storePath), { recursive: true });
 		const temp = tempPathFor(this.storePath);
-		fs.writeFileSync(temp, `${JSON.stringify(next, void 0, 2)}\n`, UTF8_ENCODING);
-		fs.renameSync(temp, this.storePath);
+		await fs.writeFile(temp, `${JSON.stringify(next, void 0, 2)}\n`, UTF8_ENCODING);
+		await fs.rename(temp, this.storePath);
 		this.cached = next;
 		return next;
 	}
 	async acquireLock() {
 		const lockPath = lockPathFor(this.storePath);
-		fs.mkdirSync(path.dirname(this.storePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.storePath), { recursive: true });
 		const deadline = Date.now() + this.lockTimeoutMs;
 		for (;;) try {
-			const handle = fs.openSync(lockPath, "wx");
-			fs.writeSync(handle, JSON.stringify({
-				pid: process.pid,
-				time: Date.now()
-			}));
-			fs.closeSync(handle);
-			return () => fs.rmSync(lockPath, { force: true });
+			const handle = await fs.open(lockPath, "wx");
+			try {
+				await handle.writeFile(JSON.stringify({
+					pid: process.pid,
+					time: Date.now()
+				}));
+			} finally {
+				await handle.close();
+			}
+			return () => fs.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(fs.readFileSync(lockPath, UTF8_ENCODING));
+			const holder = JSON.parse(await fs.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;
-			fs.unlinkSync(lockPath);
+			await fs.unlink(lockPath);
 			return true;
 		} catch (error) {
 			if (error.code !== MISSING_FILE_CODE) this.report?.warn(TASK_EVENT.storeLockBreakFailed, error, { [STORE_PATH_ATTRIBUTE]: lockPath });
@@ -1031,6 +1025,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 (!Check(TaskParamsSchema, rawParams)) {
+		const [first] = 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",
@@ -1039,33 +1064,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 (!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