pagegraph 0.8.0 → 0.8.2

package/dist/cli.js

@@ -35710,7 +35710,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.8.0";
+var version = "0.8.2";
 //#endregion
 //#region src/core/projections.ts
 const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
@@ -43389,6 +43389,21 @@ const createWorkflowMutationPolicy = (options) => {
 };
 //#endregion
 //#region src/workflows/opencode.ts
+const isActiveExecutorPlugin = (plugin) => JSON.stringify(plugin.source).toLowerCase().includes("executor") && plugin.state.status === "active";
+const waitForActiveExecutorPlugin = async (options) => {
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	const pollMs = options.pollMs ?? 250;
+	const now = options.now ?? Date.now;
+	const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+	const deadline = now() + timeoutMs;
+	do {
+		if ((await options.list()).some(isActiveExecutorPlugin)) return true;
+		const remaining = deadline - now();
+		if (remaining <= 0) return false;
+		await sleep(Math.min(pollMs, remaining));
+		if (now() >= deadline) return false;
+	} while (true);
+};
 const assertWorkflowSkillsAvailable = (configDirectory, skills) => {
 	const missing = skills.flatMap((skill) => [resolve(configDirectory, "skills", skill, "SKILL.md"), resolve(configDirectory, "skills", skill, "references", "executor.md")].filter((file) => !existsSync(file)));
 	if (missing.length === 0) return;
@@ -43418,7 +43433,7 @@ const TranscriptSchema = Struct({ messages: ArraySchema(Unknown) });
 const decodeTextPart = decodeUnknownOption(TextPartSchema);
 const decodeAssistantMessage = decodeUnknownOption(AssistantMessageSchema);
 const decodeTranscript = decodeUnknownSync(TranscriptSchema);
-const parseState = (transcript) => {
+const parseWorkflowState = (transcript) => {
 	const candidates = decodeTranscript(transcript).messages.flatMap((message) => {
 		const assistant = decodeAssistantMessage(message);
 		if (isNone(assistant)) return [];
@@ -43437,6 +43452,25 @@ const parseState = (transcript) => {
 	}
 	throw new Error("The SEO agent did not return a valid workflow JSON object.");
 };
+const parseWorkflowStateWithRepair = async (transcript, repair) => {
+	try {
+		return {
+			state: parseWorkflowState(transcript),
+			transcript
+		};
+	} catch {
+		const repaired = await repair();
+		return {
+			state: parseWorkflowState(repaired),
+			transcript: repaired
+		};
+	}
+};
+const STATE_REPAIR_PROMPT = [
+	"Your previous turn did not end with the workflow JSON object requested by the original prompt.",
+	"Do not call tools, add commentary, or wrap the response in Markdown.",
+	"Return only one valid JSON object matching the original JSON Schema, using the evidence already collected."
+].join(" ");
 const decodeToolPart = decodeUnknownOption(Struct({
 	type: Literal("tool"),
 	id: String$6,
@@ -43500,14 +43534,14 @@ const interactionEventError = (event, sessionId) => {
 		if (form !== null && typeof form === "object" && form["sessionID"] === sessionId) return /* @__PURE__ */ new Error("OpenCode requested a form; embedded PageGraph workflows are noninteractive.");
 	}
 };
-const waitForIdle = async (host, sessionId, timeoutMs, after) => {
+const waitForIdle = async (host, sessionId, options) => {
 	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const timer = setTimeout(() => controller.abort(), options.timeoutMs);
 	try {
 		for await (const event of host.sessions.log({
 			sessionID: sessionId,
 			follow: true,
-			after
+			after: options.after
 		}, { signal: controller.signal })) {
 			const interactionError = interactionEventError(event, sessionId);
 			if (interactionError !== void 0) throw interactionError;
@@ -43515,6 +43549,9 @@ const waitForIdle = async (host, sessionId, timeoutMs, after) => {
 			if (event.type === "session.execution.failed" && event.data.sessionID === sessionId) throw new Error(`OpenCode session failed: ${JSON.stringify(event.data.error)}`);
 			if (event.type === "session.execution.interrupted" && event.data.sessionID === sessionId) throw new Error(`OpenCode session was interrupted: ${event.data.reason}.`);
 		}
+	} catch (cause) {
+		if (controller.signal.aborted) throw new Error(`OpenCode session did not complete within ${options.configuredTimeoutMs ?? options.timeoutMs}ms.`, { cause });
+		throw cause;
 	} finally {
 		clearTimeout(timer);
 	}
@@ -43533,7 +43570,7 @@ const acquireWorkflowHost = async (options) => {
 	});
 	try {
 		const location = { directory: options.root };
-		if ((await host.plugin.list({ location })).data.find((plugin) => JSON.stringify(plugin.source).toLowerCase().includes("executor") && plugin.state.status === "active") === void 0) throw new Error(`No active Executor plugin was discovered in ${configDirectory}; agentic SEO workflows require Executor.`);
+		if (!await waitForActiveExecutorPlugin({ list: async () => (await host.plugin.list({ location })).data })) throw new Error(`No active Executor plugin was discovered in ${configDirectory}; agentic SEO workflows require Executor.`);
 		const cursors = /* @__PURE__ */ new Map();
 		const complete = async (sessionId, prompt, workflowOptions) => {
 			assertWorkflowSkillsAvailable(configDirectory, workflowOptions.skills);
@@ -43541,22 +43578,62 @@ const acquireWorkflowHost = async (options) => {
 				sessionID: sessionId,
 				permissions: [...workflowOptions.permissions]
 			});
+			const configuredTimeoutMs = options.timeoutMs ?? 18e4;
+			const deadline = Date.now() + configuredTimeoutMs;
+			const remaining = () => Math.max(0, deadline - Date.now());
 			await host.sessions.prompt({
 				sessionID: sessionId,
 				text: prompt,
 				skills: workflowOptions.skills.map((id) => ({ id }))
 			});
-			const cursor = await waitForIdle(host, sessionId, options.timeoutMs ?? 18e4, cursors.get(sessionId));
+			let cursor = await waitForIdle(host, sessionId, {
+				timeoutMs: remaining(),
+				configuredTimeoutMs,
+				after: cursors.get(sessionId)
+			});
 			cursors.set(sessionId, cursor);
-			const transcript = await host.sessions.export({
+			let transcript = await host.sessions.export({
 				sessionID: sessionId,
 				sanitize: false
 			});
+			const parsed = await parseWorkflowStateWithRepair(transcript, async () => {
+				const priorPermissions = [...workflowOptions.permissions ?? []];
+				await host.sessions.update({
+					sessionID: sessionId,
+					permissions: [{
+						action: "*",
+						resource: "*",
+						effect: "deny"
+					}]
+				});
+				try {
+					await host.sessions.prompt({
+						sessionID: sessionId,
+						text: STATE_REPAIR_PROMPT
+					});
+					cursor = await waitForIdle(host, sessionId, {
+						timeoutMs: remaining(),
+						configuredTimeoutMs,
+						after: cursor
+					});
+					cursors.set(sessionId, cursor);
+					transcript = await host.sessions.export({
+						sessionID: sessionId,
+						sanitize: false
+					});
+					return transcript;
+				} finally {
+					await host.sessions.update({
+						sessionID: sessionId,
+						permissions: priorPermissions
+					});
+				}
+			});
 			return {
-				state: parseState(transcript),
+				state: parsed.state,
 				sessionId,
-				transcript,
-				executor: collectExecutorEvidence(transcript)
+				transcript: parsed.transcript,
+				executor: collectExecutorEvidence(parsed.transcript)
 			};
 		};
 		return {