@deksden-com/dd-flow-cli 0.6.0 → 0.8.0-beta.135

package/dist/services/run-engine-bindings.js

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+export const runEngineBindingSchemaId = "dd-flow/run-engine-binding@1";
+export function findRunHome(ddFlowHome, projectRoot, runIdOrAlias) {
+    const projectsRoot = path.join(ddFlowHome, "projects");
+    if (!fs.existsSync(projectsRoot))
+        return null;
+    const expectedRoot = realpathOrResolve(projectRoot);
+    const matches = [];
+    for (const projectId of fs.readdirSync(projectsRoot)) {
+        const runsRoot = path.join(projectsRoot, projectId, "runs");
+        if (!isDirectory(runsRoot))
+            continue;
+        for (const runId of fs.readdirSync(runsRoot)) {
+            if (!runIdMatches(runId, runIdOrAlias))
+                continue;
+            const runHome = path.join(runsRoot, runId);
+            const authorityPath = path.join(runHome, "run.json");
+            const bindingPath = path.join(runHome, "engine-binding.json");
+            const binding = readRunEngineBinding(bindingPath, { allowMissing: true });
+            const authorityRoot = binding?.project_root ?? projectRootFromAuthority(authorityPath);
+            if (!authorityRoot || realpathOrResolve(authorityRoot) !== expectedRoot)
+                continue;
+            matches.push({ project_id: projectId, run_id: runId, run_home: runHome, authority_path: authorityPath, binding_path: bindingPath });
+        }
+    }
+    if (matches.length > 1) {
+        throw new AppError("ambiguous_id", `RUN id is ambiguous for project: ${runIdOrAlias}`, 2, {
+            project_root: expectedRoot,
+            candidates: matches.map((match) => match.run_id)
+        });
+    }
+    return matches[0] ?? null;
+}
+export function readRunEngineBinding(file, options = {}) {
+    if (!fs.existsSync(file)) {
+        if (options.allowMissing)
+            return null;
+        throw new AppError("run_engine_binding_missing", "RUN engine binding is missing", 1, { path: file });
+    }
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new AppError("run_engine_binding_invalid", "RUN engine binding is not valid JSON", 2, { path: file, cause: String(error) });
+    }
+    if (!isRunEngineBinding(value)) {
+        throw new AppError("run_engine_binding_invalid", "RUN engine binding is invalid", 2, { path: file });
+    }
+    return value;
+}
+export function writeRunEngineBinding(file, binding) {
+    const existing = readRunEngineBinding(file, { allowMissing: true });
+    if (existing) {
+        if (sameEngine(existing.engine, binding.engine) && existing.run_id === binding.run_id && realpathOrResolve(existing.project_root) === realpathOrResolve(binding.project_root)) {
+            return { changed: false, binding: existing };
+        }
+        throw new AppError("run_engine_binding_immutable", "RUN engine binding cannot be changed", 1, {
+            path: file,
+            current: existing.engine,
+            requested: binding.engine
+        });
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(temporary, `${JSON.stringify(binding, null, 2)}\n`);
+    fs.renameSync(temporary, file);
+    return { changed: true, binding };
+}
+export function allRunEngineBindings(ddFlowHome) {
+    const projectsRoot = path.join(ddFlowHome, "projects");
+    if (!fs.existsSync(projectsRoot))
+        return [];
+    const bindings = [];
+    for (const projectId of fs.readdirSync(projectsRoot)) {
+        const runsRoot = path.join(projectsRoot, projectId, "runs");
+        if (!isDirectory(runsRoot))
+            continue;
+        for (const runId of fs.readdirSync(runsRoot)) {
+            const binding = readRunEngineBinding(path.join(runsRoot, runId, "engine-binding.json"), { allowMissing: true });
+            if (binding)
+                bindings.push(binding);
+        }
+    }
+    return bindings;
+}
+function isRunEngineBinding(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    const engine = record.engine;
+    const probe = record.probe;
+    return record.schema_id === runEngineBindingSchemaId
+        && typeof record.run_id === "string"
+        && typeof record.project_root === "string"
+        && typeof record.bound_at === "string"
+        && ["run_creation", "legacy_recovery"].includes(String(record.source))
+        && typeof record.reason === "string"
+        && Boolean(engine && typeof engine === "object" && !Array.isArray(engine)
+            && typeof engine.package_name === "string"
+            && typeof engine.package_version === "string"
+            && typeof engine.engine_version === "string"
+            && /^[a-f0-9]{64}$/.test(String(engine.integrity_checksum))
+            && typeof engine.snapshot_root === "string")
+        && Boolean(probe && typeof probe === "object" && !Array.isArray(probe)
+            && ["not_required", "passed"].includes(String(probe.status))
+            && (typeof probe.command === "string" || probe.command === null));
+}
+function sameEngine(left, right) {
+    return left.package_name === right.package_name
+        && left.package_version === right.package_version
+        && left.engine_version === right.engine_version
+        && left.integrity_checksum === right.integrity_checksum
+        && left.snapshot_root === right.snapshot_root;
+}
+function projectRootFromAuthority(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, "utf8"));
+        const execution = recordValue(value.execution);
+        const workspace = recordValue(value.workspace);
+        const project = recordValue(value.project);
+        return stringValue(execution?.project_root)
+            ?? stringValue(workspace?.project_root)
+            ?? stringValue(project?.root)
+            ?? stringValue(value.project_root);
+    }
+    catch {
+        return null;
+    }
+}
+function runIdMatches(fullId, idOrAlias) {
+    return fullId === idOrAlias || /^RUN-[0-9]+$/.test(idOrAlias) && fullId.startsWith(`${idOrAlias}-`);
+}
+function isDirectory(value) {
+    try {
+        return fs.statSync(value).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function realpathOrResolve(value) {
+    try {
+        return fs.realpathSync(value);
+    }
+    catch {
+        return path.resolve(value);
+    }
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}

package/dist/services/run-projection.js

@@ -2,16 +2,23 @@ import fs from "node:fs";
 import path from "node:path";
 import { reconcileSessionCoverageRows } from "../domain/session-coverage.js";
 export function refreshRunSessionProjection(context, projectId, runId) {
-    const run = context.db.get("SELECT id, status, project_root, subject_type, subject_id, runtime_path, run_index_path, index_json FROM flow_runs WHERE project_id = ? AND id = ?", [projectId, runId]);
+    const run = context.db.get("SELECT id, flow_kind, status, project_root, subject_type, subject_id, runtime_path, run_index_path, index_json FROM runs WHERE project_id = ? AND id = ?", [projectId, runId]);
     if (!run)
         return;
     const index = JSON.parse(run.index_json);
-    const sessionRows = context.db.all(`SELECT session_id, parent_session_id, role, session_kind, worker_id, current_stage, status,
+    const sessionRows = context.db.all(`SELECT session_id, harness, provider_session_id, parent_session_id, role, session_kind, worker_id, current_stage, status,
             created_at, updated_at, stopped_at, coverage_units_json
-       FROM flow_sessions WHERE project_id = ? AND run_id = ? ORDER BY created_at, session_id`, [projectId, runId]);
+       FROM sessions WHERE project_id = ? AND run_id = ? ORDER BY created_at, session_id`, [projectId, runId]);
     const sessions = sessionRows.map(sessionProjection);
+    const workRows = context.db.all("SELECT work_id, parent_work_id, status, depends_on_json, launch_policy, started_at, completed_at FROM works WHERE project_id = ? AND run_id = ? ORDER BY created_at, work_id", [projectId, runId]);
+    const works = workRows.map((work) => ({ work_id: work.work_id, parent_work_id: work.parent_work_id, status: work.status, depends_on: parseStringArray(work.depends_on_json), launch_policy: work.launch_policy, started_at: work.started_at, completed_at: work.completed_at }));
+    const rootWorkId = workRows.find((work) => work.parent_work_id === null)?.work_id ?? null;
     const coverage = reconcileSessionCoverageRows(sessionRows);
-    const sessionCoverage = {
+    const sessionCoverage = run.flow_kind === "vnext_specify" && coverage.expected_unit_ids.length === 0 ? {
+        status: "not_applicable",
+        expected: [], observed: [], missing: [],
+        diagnostics: ["worker_coverage_not_required"]
+    } : {
         status: coverage.status,
         expected: coverage.expected_unit_ids,
         observed: coverage.observed_unit_ids,
@@ -20,19 +27,35 @@ export function refreshRunSessionProjection(context, projectId, runId) {
     };
     const plan = run.subject_type === "protocol" ? planProjection(context, projectId, run.subject_id, run.project_root) : {};
     const workers = workerProjection(context, projectId, runId);
+    const vnext = run.flow_kind === "vnext_specify" || run.flow_kind === "vnext_protocolize";
+    const hadLegacyCoverage = vnext && ("session_coverage" in index || "usage_coverage" in index);
+    if (vnext) {
+        delete index.session_coverage;
+        delete index.usage_coverage;
+        delete index.workers;
+        delete index.current_stage;
+        delete index.attempts;
+    }
     if (JSON.stringify(index.sessions ?? []) === JSON.stringify(sessions)
-        && JSON.stringify(index.session_coverage) === JSON.stringify(sessionCoverage)
+        && JSON.stringify(index.works ?? []) === JSON.stringify(works)
+        && index.root_work_id === rootWorkId
+        && (vnext || JSON.stringify(index.session_coverage) === JSON.stringify(sessionCoverage))
         && JSON.stringify(index.plan_ref) === JSON.stringify(plan.plan_ref)
         && JSON.stringify(index.plan_progress) === JSON.stringify(plan.plan_progress)
-        && JSON.stringify(index.workers ?? {}) === JSON.stringify(workers))
+        && (vnext || JSON.stringify(index.workers ?? {}) === JSON.stringify(workers))
+        && !hadLegacyCoverage)
         return;
     index.sessions = sessions;
-    index.session_coverage = sessionCoverage;
+    index.works = works;
+    index.root_work_id = rootWorkId;
+    if (!vnext)
+        index.session_coverage = sessionCoverage;
     if (plan.plan_ref)
         index.plan_ref = plan.plan_ref;
     if (plan.plan_progress)
         index.plan_progress = plan.plan_progress;
-    index.workers = workers;
+    if (!vnext)
+        index.workers = workers;
     index.updated_at = context.now();
     const runtime = readJson(run.runtime_path);
     const runtimeRevision = typeof runtime?.runtime_revision === "number"
@@ -41,19 +64,30 @@ export function refreshRunSessionProjection(context, projectId, runId) {
             ? index.runtime_revision + 1
             : 1;
     index.runtime_revision = runtimeRevision;
-    const authoritative = runtime ?? { ...index, schema_id: "dd-flow/flow-run@2" };
+    const authoritative = { ...(runtime ?? {}), ...index, schema_id: String(index.schema_id ?? runtime?.schema_id ?? "dd-flow/flow-run@3") };
     authoritative.sessions = sessions;
-    authoritative.session_coverage = sessionCoverage;
+    authoritative.works = works;
+    authoritative.root_work_id = rootWorkId;
+    if (vnext) {
+        delete authoritative.session_coverage;
+        delete authoritative.usage_coverage;
+        delete authoritative.workers;
+        delete authoritative.current_stage;
+        delete authoritative.attempts;
+    }
+    else
+        authoritative.session_coverage = sessionCoverage;
     if (plan.plan_ref)
         authoritative.plan_ref = plan.plan_ref;
     if (plan.plan_progress)
         authoritative.plan_progress = plan.plan_progress;
-    authoritative.workers = workers;
+    if (!vnext)
+        authoritative.workers = workers;
     authoritative.updated_at = index.updated_at;
     authoritative.runtime_revision = runtimeRevision;
     if (run.status !== "discarded" || fs.existsSync(run.runtime_path))
         writeJson(run.runtime_path, authoritative);
-    context.db.run("UPDATE flow_runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ?", [JSON.stringify(index), index.updated_at, projectId, runId]);
+    context.db.run("UPDATE runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ?", [JSON.stringify(index), index.updated_at, projectId, runId]);
 }
 function planProjection(context, projectId, protocolId, projectRoot) {
     const binding = context.db.get("SELECT plan_path, plan_revision, plan_sha256 FROM plan_bindings WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
@@ -107,10 +141,12 @@ function parseStringArray(value) {
 function sessionProjection(row) {
     return {
         session_id: row.session_id,
+        harness: row.harness,
+        provider_session_id: row.provider_session_id,
         parent_session_id: row.parent_session_id,
         role: row.role,
         session_kind: row.session_kind,
-        worker_id: row.worker_id,
+        work_id: row.worker_id,
         current_stage: row.current_stage,
         status: row.status,
         created_at: row.created_at,