@deksden-com/dd-flow-cli 0.4.2 → 0.6.0

package/dist/services/dashboard.js

@@ -12,6 +12,7 @@ import { protocolRunDiagnostics, protocolSetBoardForProtocol, protocolSetBoardsF
 import { activeFlowSessionsForProject } from "./sessions.js";
 import { usageForRun } from "./usage.js";
 import { normalizeProtocolLifecycle } from "./protocol-lifecycle.js";
+import { planSummary, planWithProgress } from "./plan-runtime.js";
 export function getCmuxStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     return { ok: true, project_root: project.root, cmux: detectCmux(context) };
@@ -626,14 +627,20 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
     const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
      FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
      ORDER BY updated_at DESC, id DESC`, [project.id, protocolId]);
-    const primaryRun = runs.find((run) => run.status === "running") ?? runs[0];
+    const warnings = [...runDiagnostics.diagnostics];
+    const canonicalRuns = runs.filter((run) => {
+        if (isCanonicalRun(run))
+            return true;
+        warnings.push({ code: "legacy_run_ignored", run_id: run.id });
+        return false;
+    });
+    const primaryRun = lifecycle.terminal ? canonicalRuns[0] : canonicalRuns.find((run) => run.status === "running") ?? canonicalRuns[0];
     const observability = primaryRun
         ? usageForRun(context, { projectId: project.id, runId: primaryRun.id, groupBy: "role" })
         : { status: "not_observable", reason: "no_protocol_run" };
-    const warnings = [...runDiagnostics.diagnostics];
     const protocolSetBoard = protocolSetBoardForProtocol(context, project.id, project.root, protocolId);
     const reviewRuns = recentReviewRunsForProtocol(context, project.id, protocolId, 8);
-    const runHistory = runs.map((run) => {
+    const runHistory = canonicalRuns.map((run) => {
         const index = safeRunIndex(run.index_json, warnings, run.id);
         return {
             id: run.id,
@@ -707,10 +714,10 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
         run_history: runHistory,
         stage_pipeline: latestStages(runHistory),
         metrics: [
-            metric("runs", runs.length, "known", "flow_runs"),
+            metric("runs", canonicalRuns.length, "known", "flow_runs"),
             metric("open_defs", jsonArray(protocol.active_def_json).length, "known", "protocols.active_def_json"),
             metric("blockers", jsonArray(protocol.blockers_json).length, "known", "protocols.blockers_json"),
-            metric("completed_runs", runs.filter((run) => run.status === "done").length, "known", "flow_runs"),
+            metric("completed_runs", canonicalRuns.filter((run) => run.status === "done").length, "known", "flow_runs"),
             metric("review_runs", reviewRuns.length, "known", "flow_runs.flow_kind=mb-sdlc-review|review")
         ],
         warnings
@@ -881,34 +888,39 @@ function protocolsForProject(context, projectId) {
      FROM protocols WHERE project_id = ? ORDER BY updated_at DESC`, [projectId]);
 }
 function planSummaryForProtocol(context, projectId, protocolId) {
-    const row = context.db.get("SELECT plan_json FROM plans WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
-    if (!row) {
+    const protocol = context.db.get("SELECT plan_path FROM protocols WHERE project_id = ? AND id = ?", [projectId, protocolId]);
+    if (!protocol) {
         return { plan_id: "none", total: 0, done: 0, blocked: 0 };
     }
-    const plan = JSON.parse(row.plan_json);
-    const items = Array.isArray(plan.items) ? plan.items : [];
-    return {
-        plan_id: plan.plan_id ?? "unknown",
-        total: items.length,
-        done: items.filter((item) => item.status === "done").length,
-        blocked: items.filter((item) => item.status === "blocked").length
-    };
+    try {
+        const summary = planSummary(context, { projectId, protocolId, planPath: protocol.plan_path });
+        return { plan_id: summary.plan_id, total: summary.total, done: summary.done, blocked: summary.blocked };
+    }
+    catch {
+        return { plan_id: "stale", total: 0, done: 0, blocked: 0 };
+    }
 }
 function activePlanItems(context, projectId, protocols) {
     const items = [];
     for (const protocol of protocols) {
-        const row = context.db.get("SELECT plan_json FROM plans WHERE project_id = ? AND protocol_id = ?", [projectId, protocol.id]);
-        if (!row) {
+        const record = context.db.get("SELECT plan_path FROM protocols WHERE project_id = ? AND id = ?", [projectId, protocol.id]);
+        if (!record) {
             continue;
         }
-        const plan = JSON.parse(row.plan_json);
-        for (const item of Array.isArray(plan.items) ? plan.items : []) {
+        let plan;
+        try {
+            plan = planWithProgress(context, { projectId, protocolId: protocol.id, planPath: record.plan_path }).plan;
+        }
+        catch {
+            continue;
+        }
+        for (const item of plan.items) {
             if (["in_progress", "blocked"].includes(item.status ?? "")) {
                 items.push({
                     protocol: protocol.id,
-                    id: item.id ?? "unknown",
-                    status: item.status ?? "unknown",
-                    summary: item.block_reason ?? item.summary ?? item.title ?? ""
+                    id: item.id,
+                    status: item.status,
+                    summary: item.block_reason ?? item.summary ?? item.title
                 });
             }
         }
@@ -1040,9 +1052,10 @@ function buildProtocolCard(context, project, protocol, generatePage) {
     const summary = planSummaryForProtocol(context, project.id, protocol.id);
     const activeDefCount = jsonArray(protocol.active_def_json).length;
     const blockerCount = jsonArray(protocol.blockers_json).length;
-    const latestRun = context.db.get(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
+    const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
      FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
-     ORDER BY updated_at DESC, id DESC LIMIT 1`, [project.id, protocol.id]);
+     ORDER BY updated_at DESC, id DESC`, [project.id, protocol.id]);
+    const latestRun = runs.find((run) => isCanonicalRun(run));
     let diagnostics = [];
     let lifecycle = normalizeProtocolLifecycle({ rawStage: protocol.stage, rawStatus: protocol.status });
     try {
@@ -1242,10 +1255,19 @@ function safeRunIndex(text, warnings, runId) {
         return null;
     }
 }
+function isCanonicalRun(run) {
+    try {
+        const parsed = JSON.parse(run.index_json);
+        return parsed?.schema_id === "dd-flow/flow-run@2";
+    }
+    catch {
+        return false;
+    }
+}
 function stageLink(projectRoot, run, stage) {
     const item = stage && typeof stage === "object" && !Array.isArray(stage) ? stage : {};
     const report = typeof item.stage_report === "string" ? item.stage_report : undefined;
-    const href = report ? path.join(path.dirname(run.run_index_path), report) : "";
+    const href = report ? runArtifactPath(run.run_index_path, report) : "";
     return {
         order: typeof item.order === "number" ? item.order : 0,
         stage: String(item.stage ?? "unknown"),
@@ -1253,10 +1275,13 @@ function stageLink(projectRoot, run, stage) {
         status: String(item.status ?? "unknown"),
         display_status: normalizeDisplayStatus(String(item.status ?? "unknown")),
         report: report ? link("Stage report", href, fs.existsSync(href) ? "available" : "missing", fs.existsSync(href) ? undefined : "stage_report_missing") : link("Stage report", "", "pending", "stage_report_not_created_yet"),
-        data: typeof item.data === "string" ? path.join(path.dirname(run.run_index_path), item.data) : null,
+        data: typeof item.data === "string" ? runArtifactPath(run.run_index_path, item.data) : null,
         run_index: path.relative(projectRoot, run.run_index_path)
     };
 }
+function runArtifactPath(runIndexPath, artifact) {
+    return path.isAbsolute(artifact) ? artifact : path.resolve(path.dirname(runIndexPath), artifact);
+}
 function latestStages(runHistory) {
     const byStage = new Map();
     for (const run of runHistory) {

package/dist/services/engines.js

@@ -1,7 +1,8 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { getCliBuildInfo } from "./build-info.js";
 import { AppError } from "../shared/errors.js";
@@ -34,12 +35,12 @@ export function installCurrentEngine(context, input = {}) {
     const target = engineVersionRoot(context.ddFlowHome, build.package_name, build.version);
     const manifestPath = path.join(target, "engine.json");
     const existing = readManifest(manifestPath);
-    if (existing && !input.force && manifestHealthy(existing)) {
+    if (existing && !input.force && (input.forRouting || manifestHealthy(existing))) {
         return {
             ok: true,
             action: "engine_install",
             changed: false,
-            engine: manifestSummary(existing),
+            ...(input.forRouting ? {} : { engine: manifestSummary(existing) }),
             path: target
         };
     }
@@ -47,12 +48,12 @@ export function installCurrentEngine(context, input = {}) {
     acquireInstallLock(lockDir);
     try {
         const afterLock = readManifest(manifestPath);
-        if (afterLock && !input.force && manifestHealthy(afterLock)) {
+        if (afterLock && !input.force && (input.forRouting || manifestHealthy(afterLock))) {
             return {
                 ok: true,
                 action: "engine_install",
                 changed: false,
-                engine: manifestSummary(afterLock),
+                ...(input.forRouting ? {} : { engine: manifestSummary(afterLock) }),
                 path: target
             };
         }
@@ -64,14 +65,21 @@ export function installCurrentEngine(context, input = {}) {
         copyPackageSnapshot(packageRoot, tmp);
         const manifest = buildManifest(context, build.package_name, build.version, packageRoot, target, tmp);
         fs.writeFileSync(path.join(tmp, "engine.json"), `${JSON.stringify(manifest, null, 2)}\n`);
-        fs.rmSync(target, { recursive: true, force: true });
-        fs.renameSync(tmp, target);
+        const stagedManifest = requireManifest(path.join(tmp, "engine.json"));
+        const stagedDiagnostics = manifestDiagnostics({ ...stagedManifest, package_root: tmp, snapshot_root: tmp }, { checkEntrypoint: !input.forRouting });
+        if (stagedDiagnostics.length > 0) {
+            throw new AppError("engine_install_failed", "Staged dd-flow engine failed its integrity or dependency health check", 1, {
+                diagnostics: stagedDiagnostics,
+                path: tmp
+            });
+        }
+        activateEngineAtomically(tmp, target);
         const installed = requireManifest(path.join(target, "engine.json"));
         return {
             ok: true,
             action: "engine_install",
             changed: true,
-            engine: manifestSummary(installed),
+            ...(input.forRouting ? {} : { engine: manifestSummary(installed) }),
             path: target
         };
     }
@@ -121,8 +129,8 @@ export function doctorEngines(context, input = {}) {
 export function routeArgsThroughEngine(context, args, io, stdin, env, resolvedProjectRoot) {
     if (isEngineMode(env) || isRouterNativeCommand(args))
         return Promise.resolve(null);
-    installCurrentEngine(context);
-    const selection = selectEngine(context, { projectRoot: resolvedProjectRoot ?? resolveOperationProjectRoot(context, args) ?? undefined });
+    installCurrentEngine(context, { forRouting: true });
+    const selection = selectEngine(context, { projectRoot: resolvedProjectRoot ?? resolveOperationProjectRoot(context, args) ?? undefined }, { allowCurrentInProcess: true });
     if (selection.status === "missing") {
         const classification = classifyCliOperation(args, env);
         if (classification.mode === "read_only_diagnostics" || classification.mode === "mb_upgrade") {
@@ -148,7 +156,7 @@ export function engineRoutingMetadata(env) {
         routed_from: env.DD_FLOW_ROUTED_FROM ?? null
     };
 }
-export function selectEngine(context, input) {
+export function selectEngine(context, input, options = {}) {
     const compatibility = readCompatibilityForProject(input.projectRoot);
     const build = getCliBuildInfo();
     const packageName = stringValue(compatibility?.engine?.package_name) ?? build.package_name;
@@ -158,7 +166,11 @@ export function selectEngine(context, input) {
     const manifests = readInstalledManifests(engineStoreRoot(context.ddFlowHome))
         .filter((manifest) => manifest.package_name === packageName)
         .filter((manifest) => satisfiesRange(manifest.package_version, requiredRange))
-        .filter((manifest) => manifestHealthy(manifest))
+        .filter((manifest) => options.allowCurrentInProcess
+        && manifest.package_name === build.package_name
+        && manifest.package_version === build.version
+        ? true
+        : manifestHealthy(manifest))
         .sort((a, b) => compareSemverStrings(b.package_version, a.package_version));
     const selected = manifests[0] ?? null;
     return {
@@ -275,13 +287,13 @@ function buildManifest(context, packageName, version, packageRoot, snapshotRoot,
         },
         integrity: {
             source: "package_snapshot",
-            checksum: fileListChecksum(checksumRoot),
-            mode: "file_list"
+            checksum: engineSnapshotChecksum(checksumRoot),
+            mode: "full_content"
         }
     };
 }
 function copyPackageSnapshot(packageRoot, target) {
-    for (const item of ["dist", "package.json", "README.md", "CHANGELOG.md"]) {
+    for (const item of ["dist", "package.json", "README.md", "CHANGELOG.md", "tools"]) {
         const from = path.join(packageRoot, item);
         if (!fs.existsSync(from))
             continue;
@@ -441,7 +453,7 @@ function readManifest(file) {
 function manifestHealthy(manifest) {
     return manifestDiagnostics(manifest).length === 0;
 }
-function manifestDiagnostics(manifest) {
+function manifestDiagnostics(manifest, options = {}) {
     const diagnostics = [];
     if (manifest.schema_id !== engineManifestSchemaId)
         diagnostics.push("schema_id_mismatch");
@@ -455,6 +467,34 @@ function manifestDiagnostics(manifest) {
         diagnostics.push("entrypoint_outside_snapshot");
     else if (!fs.existsSync(entrypoint))
         diagnostics.push("entrypoint_missing");
+    if (!manifest.integrity || manifest.integrity.mode !== "full_content" || !manifest.integrity.checksum) {
+        diagnostics.push("content_checksum_missing");
+    }
+    else if (fs.existsSync(snapshotRoot)) {
+        try {
+            if (engineSnapshotChecksum(snapshotRoot) !== manifest.integrity.checksum)
+                diagnostics.push("content_checksum_mismatch");
+        }
+        catch {
+            diagnostics.push("snapshot_unreadable");
+        }
+    }
+    if (options.checkEntrypoint !== false && entrypoint && fs.existsSync(entrypoint) && !diagnostics.includes("entrypoint_outside_snapshot")) {
+        const health = spawnSync(process.execPath, [entrypoint, "--version", "--json"], {
+            cwd: snapshotRoot,
+            env: {
+                ...process.env,
+                DD_FLOW_ENGINE_MODE: "1",
+                DD_FLOW_ENGINE_HOME: snapshotRoot,
+                DD_FLOW_ENGINE_HEALTHCHECK: "1"
+            },
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 15_000
+        });
+        if (health.status !== 0)
+            diagnostics.push("entrypoint_dependency_load_failed");
+    }
     return diagnostics;
 }
 function manifestSummary(manifest) {
@@ -592,10 +632,17 @@ function findPackageRoot(start) {
         current = parent;
     }
 }
-function fileListChecksum(root) {
+export function engineSnapshotChecksum(root) {
     const files = [];
     collectFiles(root, root, files);
-    return Buffer.from(files.sort().join("\n")).toString("base64url");
+    const checksum = crypto.createHash("sha256");
+    for (const file of files.sort()) {
+        checksum.update(file);
+        checksum.update("\0");
+        checksum.update(fs.readFileSync(path.join(root, file)));
+        checksum.update("\0");
+    }
+    return checksum.digest("hex");
 }
 function collectFiles(root, current, files) {
     for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
@@ -608,6 +655,25 @@ function collectFiles(root, current, files) {
             files.push(path.relative(root, full));
     }
 }
+function activateEngineAtomically(staging, target) {
+    const previous = `${target}.previous-${process.pid}-${Date.now()}`;
+    const hadPrevious = fs.existsSync(target);
+    if (hadPrevious)
+        fs.renameSync(target, previous);
+    try {
+        fs.renameSync(staging, target);
+    }
+    catch (error) {
+        if (hadPrevious && !fs.existsSync(target) && fs.existsSync(previous))
+            fs.renameSync(previous, target);
+        throw new AppError("engine_install_failed", "Atomic engine activation failed; previous engine was preserved", 1, {
+            target,
+            cause: String(error)
+        });
+    }
+    if (hadPrevious)
+        fs.rmSync(previous, { recursive: true, force: true });
+}
 function stringValue(value) {
     return typeof value === "string" && value.length > 0 ? value : null;
 }