@agimon-ai/doompi-workflow 0.0.1-alpha.113 → 0.0.1-alpha.115

package/dist/extensions/server.mjs

@@ -8,12 +8,14 @@ import path, { basename, isAbsolute, join, relative, resolve } from "node:path";
 import { NativeTerminalService, WORKFLOW_DECISION_FILE_ENV, WORKFLOW_DECISION_STEERING_ENV, WORKFLOW_DECISION_STEERING_HOST, WorkflowRegistryService, WorkflowTerminalService, connectNativeTerminal, createEmbeddedWorkflowFeature, diagnoseWorkflow, gateStepDecision, readStepDecision, readWorkflowCatalog, serveNativeTerminal, summarizeWorkflow, terminalSocketPath } from "@agimon-ai/workflow-mcp";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
 import { defineMinorMode, serverMinorModes } from "@agimon-ai/doompi-minor-mode";
 import { createDoomTelemetry } from "@agimon-ai/doompi-telemetry";
 import { defineServerPlugin } from "@agimon-ai/doompi-core/serverFacet";
 import { DOOM_NOTIFICATION_ENTRY_TYPE, createDoomNotificationEntryData } from "@agimon-ai/doompi-core/notification";
 import { WORKFLOW_STEP_SESSION_PROVENANCE } from "@agimon-ai/doompi-core/hubChannel";
 import { Readable } from "node:stream";
+import { doomApiCallerFrom } from "@agimon-ai/doompi-core/packageApi";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { apiResponse, defineApiRoutes } from "@agimon-ai/doompi-core/web";
@@ -216,14 +218,56 @@ function jobPhase(name) {
 	if (name === PHASE_JOB_POST) return PHASE_JOB_POST;
 	return "job";
 }
-/**
-* Folds the event log into the current job tree; later events win, so a job
-* that started and later failed reads as failed. Jobs and steps keep the
-* order of their first appearance.
-*/
-function foldWorkflowProgress(events) {
-	const jobs = [];
-	const jobByName = /* @__PURE__ */ new Map();
+/** Names match the engine's progress log, including unnamed parallel children. */
+function plannedSteps(steps = []) {
+	return steps.flatMap((step, index) => {
+		const name = step.name ?? `step ${index + 1}`;
+		return step.parallel === void 0 ? [{
+			name,
+			status: "pending"
+		}] : step.parallel.map((child, childIndex) => ({
+			name: child.name ?? `${name} ${childIndex + 1}`,
+			status: "pending",
+			group: name
+		}));
+	});
+}
+/** The whole declared route, before any job or step has emitted progress. */
+function planWorkflowJobs(workflow, order) {
+	const jobs = order.map((name) => {
+		const job = workflow.jobs[name];
+		return {
+			name,
+			phase: "job",
+			status: "pending",
+			steps: [
+				...plannedSteps(job.preJob?.steps),
+				...plannedSteps(job.steps),
+				...plannedSteps(job.postJob?.steps)
+			]
+		};
+	});
+	if (workflow.pre !== void 0) jobs.unshift({
+		name: PHASE_JOB_PRE,
+		phase: "pre",
+		status: "pending",
+		steps: plannedSteps(workflow.pre.steps)
+	});
+	if (workflow.post !== void 0) jobs.push({
+		name: PHASE_JOB_POST,
+		phase: "post",
+		status: "pending",
+		steps: plannedSteps(workflow.post.steps)
+	});
+	return jobs;
+}
+/** Overlay progress on the plan, retaining recorded jobs and steps absent from the current definition. */
+function foldWorkflowProgress(events, plan = []) {
+	const jobs = plan.map((job) => ({
+		...job,
+		steps: job.steps.map((step) => ({ ...step }))
+	}));
+	const jobByName = new Map(jobs.map((job) => [job.name, job]));
 	for (const event of events) {
 		let job = jobByName.get(event.job);
 		if (job === void 0) {
@@ -251,6 +295,7 @@ function foldWorkflowProgress(events) {
 			continue;
 		}
 		if (event.step === void 0) continue;
+		if (job.status === "pending") job.status = event.status;
 		let step = job.steps.find((candidate) => candidate.name === event.step);
 		if (step === void 0) {
 			step = {
@@ -271,6 +316,9 @@ function foldWorkflowProgress(events) {
 		if (event.status === "running" && step.startedAt === void 0) step.startedAt = event.at;
 		if (STEP_TERMINAL_STATES.has(event.status)) step.endedAt = event.at;
 	}
+	for (const job of jobs) if (job.status === "skipped") {
+		for (const step of job.steps) if (step.status === "pending") step.status = "skipped";
+	}
 	return jobs;
 }
 const ACTIVE_PROGRESS_STATES = /* @__PURE__ */ new Set([
@@ -1361,9 +1409,15 @@ var apiRoutes_default = defineApiRoutes({
 		path: "/launch",
 		response: apiResponse()
 	},
+	openRunDirectory: {
+		method: "POST",
+		path: `${RUN}/open-directory`,
+		response: apiResponse()
+	},
 	artifacts: {
 		method: "GET",
 		path: `${RUN}/artifacts`,
+		query: ["directory"],
 		response: apiResponse()
 	},
 	/** One artifact: its metadata and text, or its raw bytes under `raw=1`. */
@@ -1674,18 +1728,49 @@ function createWorkflowHubApi(options = {}) {
 		}
 		return context.json({ deleted: true });
 	});
+	app.post(apiRoutes_default.openRunDirectory.path, async (context) => {
+		if (doomApiCallerFrom(context.req.raw.headers)?.locality !== "local") return context.json({ error: "Opening Finder is only available on the host." }, 403);
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		if (process.platform !== "darwin") return context.json({ error: "Finder is only available on macOS." }, 409);
+		try {
+			const runDir = path.resolve(registry.runDirectoryFor(record));
+			if (!fs.statSync(runDir).isDirectory()) return context.json({ error: "The run directory is not a folder." }, 409);
+			await new Promise((resolve, reject) => {
+				execFile("/usr/bin/open", [
+					"-a",
+					"Finder",
+					runDir
+				], { timeout: 5e3 }, (error) => {
+					if (error) reject(error);
+					else resolve();
+				});
+			});
+			return context.json({ opened: true });
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+	});
 	app.get(apiRoutes_default.artifacts.path, async (context) => {
 		const workspace = context.req.param("workspace");
 		const runKey = context.req.param("runKey");
 		const record = await runOf(workspace, runKey);
 		if (record === void 0) return context.json(missing(workspace, runKey), 404);
 		const runDir = registry.runDirectoryFor(record);
-		const body = {
-			runDir,
-			description: record.runDirectory?.description ?? "",
-			artifacts: readArtifacts(runDir, record)
-		};
-		return context.json(body);
+		const directory = context.req.query("directory") ?? "";
+		if (resolveInside(runDir, directory) === void 0) return context.json({ error: "That folder is not inside this run." }, 400);
+		try {
+			const body = {
+				runDir,
+				description: record.runDirectory?.description ?? "",
+				artifacts: readArtifacts(runDir, record, directory)
+			};
+			return context.json(body);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
 	});
 	app.get(apiRoutes_default.artifact.path, async (context) => {
 		const workspace = context.req.param("workspace");
@@ -1714,7 +1799,20 @@ function resolveInside(runDir, requested) {
 	const resolved = path.resolve(runDir, requested);
 	const root = path.resolve(runDir);
 	if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) return void 0;
-	return resolved;
+	try {
+		const realRoot = fs.realpathSync(root);
+		let ancestor = resolved;
+		while (!fs.existsSync(ancestor)) {
+			const parent = path.dirname(ancestor);
+			if (parent === ancestor) return void 0;
+			ancestor = parent;
+		}
+		const real = fs.realpathSync(ancestor);
+		if (real !== realRoot && !real.startsWith(`${realRoot}${path.sep}`)) return void 0;
+		return resolved;
+	} catch {
+		return;
+	}
 }
 /** Size and modification time of one path, or undefined when it is not there. */
 function statOf(target) {
@@ -1730,10 +1828,12 @@ function stateOf(stats) {
 	return stats.size === 0 ? "empty" : "written";
 }
 function viewOf(runDir, entry) {
-	const stats = statOf(path.join(runDir, entry.path));
+	const target = resolveInside(runDir, entry.path);
+	const stats = target === void 0 ? void 0 : statOf(target);
 	return {
 		...entry,
-		state: stateOf(stats),
+		kind: stats?.isDirectory() ? "directory" : entry.kind,
+		state: target === void 0 ? "unreadable" : stateOf(stats),
 		...stats === void 0 ? {} : {
 			size: stats.size,
 			modifiedAt: stats.mtime.toISOString()
@@ -1749,7 +1849,7 @@ function viewOf(runDir, entry) {
 * hidden: the engine's own context.md and progress log are often exactly what a
 * reader is looking for.
 */
-function readArtifacts(runDir, record) {
+function readArtifacts(runDir, record, directory = "") {
 	const declared = (record.runDirectory?.entries ?? []).map((entry) => viewOf(runDir, {
 		path: entry.path,
 		kind: entry.kind,
@@ -1757,21 +1857,16 @@ function readArtifacts(runDir, record) {
 		producedBy: entry["produced-by"] ?? [],
 		declared: true
 	}));
-	const claimed = new Set(declared.map((entry) => entry.path));
-	let names;
-	try {
-		names = fs.readdirSync(runDir, { withFileTypes: true });
-	} catch {
-		return declared;
-	}
-	const found = names.filter((entry) => !claimed.has(entry.name)).map((entry) => viewOf(runDir, {
-		path: entry.name,
+	const children = declared.filter((entry) => path.posix.dirname(entry.path) === (directory || "."));
+	const claimed = new Set(children.map((entry) => entry.path));
+	const found = fs.readdirSync(path.join(runDir, directory), { withFileTypes: true }).filter((entry) => !claimed.has(path.posix.join(directory, entry.name))).map((entry) => viewOf(runDir, {
+		path: path.posix.join(directory, entry.name),
 		kind: entry.isDirectory() ? "directory" : "file",
 		description: "",
 		producedBy: [],
 		declared: false
 	})).sort((left, right) => left.path.localeCompare(right.path));
-	return [...declared, ...found];
+	return [...directory === "" ? declared : children, ...found];
 }
 /** Browser content type inferred from a filename without trusting client input. */
 function artifactMimeType(requested) {
@@ -2072,6 +2167,7 @@ function createWorkflowSessionLifecycle(deps) {
 }
 //#endregion
 //#region src/services/workflowWatcher/index.ts
+const { parser } = createEmbeddedWorkflowFeature();
 /**
 * Read the durable workflow registry once.
 *
@@ -2119,6 +2215,18 @@ function readWorkflowRuns(options = {}) {
 			return [];
 		}
 	};
+	const plans = /* @__PURE__ */ new Map();
+	const planFor = (workflowPath) => {
+		const cached = plans.get(workflowPath);
+		if (cached !== void 0) return cached;
+		let plan = [];
+		try {
+			const workflow = parser.parseWorkflowFile(workflowPath);
+			plan = planWorkflowJobs(workflow, parser.resolveJobOrder(workflow.jobs, null));
+		} catch {}
+		plans.set(workflowPath, plan);
+		return plan;
+	};
 	const runs = [];
 	for (const workspace of listDir(workspacesDir)) for (const stage of WORKFLOW_STAGES) {
 		const stageDir = path.join(workspacesDir, workspace, stage);
@@ -2128,7 +2236,7 @@ function readWorkflowRuns(options = {}) {
 			const progressPath = path.join(runDir, PROGRESS_FILE_NAME);
 			const parsed = cachedParse(recordCache, recordPath, parseWorkflowRunRecord, void 0);
 			if (parsed === void 0) continue;
-			const jobs = cachedParse(progressCache, progressPath, (raw) => foldWorkflowProgress(parseWorkflowProgress(raw)), []);
+			const jobs = foldWorkflowProgress(cachedParse(progressCache, progressPath, parseWorkflowProgress, []), planFor(parsed.view.workflowPath));
 			runs.push({
 				...parsed,
 				view: completeWorkflowRunView(parsed.view, jobs)
@@ -2734,8 +2842,13 @@ function createWorkflowServerRuntime(host, serverHost) {
 				},
 				name: LAUNCH_TOOL,
 				label: "Launch Workflow",
-				description: "Start a workflow run. A successful launch is not a completed workflow.",
-				promptGuidelines: ["Launch returns when a run starts, not when it finishes. Use the exact run key and separate workspace from its launch result for workflow_run status, not Agiflow project or job identifiers.", "Do not relaunch a healthy running workflow merely because it has not completed."],
+				description: "Start a workflow run. Prefer in-process Pi execution with command: \"pi\" when supported; runner: \"codex\" is not an alias for it. A successful launch is not a completed workflow.",
+				promptGuidelines: [
+					"Before launching, inspect the workflow and its imports for commands and interactiveRun choices. Prefer a supported Pi template with inProcess: true, selected explicitly with command: \"pi\" (or a supported in-process \"pi-claude\" command when requested). Only use an external CLI when the user requests it or no in-process option exists.",
+					"command selects the exact template. Without it, runner only matches an exact command name; otherwise each step uses its first command. runner: \"codex\" does not imply command: \"pi\", so pass command explicitly to avoid switching to \"claude\" on later steps.",
+					"Launch returns when a run starts, not when it finishes. Use the exact run key and separate workspace from its launch result for workflow_run status, not Agiflow project or job identifiers.",
+					"Do not relaunch a healthy running workflow merely because it has not completed."
+				],
 				parameters: z.toJSONSchema(feature.runTool.getInputSchema()),
 				executionMode: "serial",
 				async execute(_toolCallId, parameters, signal, _onUpdate, context) {