@tomflow/proflow-platform-cli 0.1.1 → 0.1.3

package/dist/src/preflight/preflight.js

@@ -1,11 +1,25 @@
 import { PlatformError } from "../errors.js";
 import { buildDependencyGraph, ModuleRefUnresolvedError, } from "../graph/graph.js";
 import { dispatchLifecycle } from "../lifecycle/index.js";
-import { checkConfigReadiness } from "./config.js";
+import { loadLatestVerification } from "../persistence/index.js";
+import { checkConfigReadiness, checkConfigReality } from "./config.js";
 import { probeAllRequirements } from "./requirements.js";
 function compareRef(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
+async function humanVerifiedModules(modules, paths) {
+    const verified = new Set();
+    if (paths === undefined)
+        return verified;
+    for (const module of modules) {
+        const latest = await loadLatestVerification(paths, module.moduleRef);
+        if (latest?.result === "PASS" &&
+            latest.moduleVersion === module.moduleVersion) {
+            verified.add(module.moduleRef);
+        }
+    }
+    return verified;
+}
 export async function runPreflight(modules, options = {}) {
     const findings = [];
     let dependency;
@@ -33,7 +47,9 @@ export async function runPreflight(modules, options = {}) {
         }
     }
     findings.push(...checkConfigReadiness(modules, options.config));
-    const requirementProbes = await probeAllRequirements(modules);
+    findings.push(...(await checkConfigReality(modules, options.config)));
+    const verifiedHumanModules = await humanVerifiedModules(modules, options.paths);
+    const requirementProbes = await probeAllRequirements(modules, verifiedHumanModules);
     for (const probe of requirementProbes) {
         if (probe.status === "ACTION_REQUIRED") {
             findings.push({

package/dist/src/preflight/requirements.d.ts

@@ -7,5 +7,5 @@ export interface RequirementProbe {
     status: ProbeStatus;
     message: string;
 }
-export declare function probeAllRequirements(modules: readonly ResolvedModule[]): Promise<RequirementProbe[]>;
-export declare function probeRequirement(moduleRef: string, requirement: ModuleRequirement, modules: readonly ResolvedModule[]): Promise<RequirementProbe>;
+export declare function probeAllRequirements(modules: readonly ResolvedModule[], humanVerifiedModuleRefs?: ReadonlySet<string>): Promise<RequirementProbe[]>;
+export declare function probeRequirement(moduleRef: string, requirement: ModuleRequirement, modules: readonly ResolvedModule[], humanVerifiedModuleRefs?: ReadonlySet<string>): Promise<RequirementProbe>;

package/dist/src/preflight/requirements.js

@@ -5,17 +5,17 @@ import { versionSatisfies } from "../modules.js";
 function compareRef(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
-export async function probeAllRequirements(modules) {
+export async function probeAllRequirements(modules, humanVerifiedModuleRefs = new Set()) {
     const sorted = [...modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef));
     const results = [];
     for (const module of sorted) {
         for (const requirement of module.requirements) {
-            results.push(await probeRequirement(module.moduleRef, requirement, modules));
+            results.push(await probeRequirement(module.moduleRef, requirement, modules, humanVerifiedModuleRefs));
         }
     }
     return results;
 }
-export async function probeRequirement(moduleRef, requirement, modules) {
+export async function probeRequirement(moduleRef, requirement, modules, humanVerifiedModuleRefs = new Set()) {
     switch (requirement.kind) {
         case "runtime":
             return probeRuntime(moduleRef, requirement);
@@ -30,12 +30,19 @@ export async function probeRequirement(moduleRef, requirement, modules) {
         case "module-contract":
             return probeModuleContract(moduleRef, requirement, modules);
         case "human":
-            return {
-                moduleRef,
-                requirement,
-                status: "ACTION_REQUIRED",
-                message: requirement.action,
-            };
+            return humanVerifiedModuleRefs.has(moduleRef)
+                ? {
+                    moduleRef,
+                    requirement,
+                    status: "PASS",
+                    message: `human prerequisite verified for ${moduleRef}`,
+                }
+                : {
+                    moduleRef,
+                    requirement,
+                    status: "ACTION_REQUIRED",
+                    message: requirement.action,
+                };
     }
 }
 function probeRuntime(moduleRef, requirement) {

package/dist/src/registry/npm-registry.d.ts

@@ -6,7 +6,7 @@ export interface NpmCommandResult {
     stderr: string;
 }
 export interface NpmCommandRunner {
-    run(args: readonly string[], cwd: string): Promise<NpmCommandResult>;
+    run(args: readonly string[], cwd: string, timeoutMs?: number): Promise<NpmCommandResult>;
 }
 export interface RegistryModuleCandidate {
     packageName: string;

package/dist/src/registry/npm-registry.js

@@ -12,12 +12,13 @@ export const PRO_FLOW_SCOPE = "@tomflow";
 export const PRO_FLOW_PACKAGE_PREFIX = "@tomflow/proflow-";
 export function systemNpmRunner() {
     return {
-        async run(args, cwd) {
+        async run(args, cwd, timeoutMs) {
             try {
                 const result = await execFileAsync("npm", [...args], {
                     cwd,
                     encoding: "utf8",
                     maxBuffer: 4 * 1024 * 1024,
+                    ...(timeoutMs === undefined ? {} : { timeout: timeoutMs }),
                 });
                 return { stdout: result.stdout, stderr: result.stderr };
             }

package/dist/src/security/lock.js

@@ -45,6 +45,32 @@ function lockedError(existing) {
         : `pid=${existing.pid} planRef=${existing.planRef} since=${existing.createdAt} fingerprint=${existing.workspaceFingerprint}`;
     return new PlatformError("WORKSPACE_LOCKED", `workspace apply already in progress (${details})`);
 }
+function isProvablyDeadPid(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return errorHasCode(error, "ESRCH");
+    }
+}
+async function reclaimProvablyStaleLock(paths, expectedFingerprint) {
+    const existing = await readWorkspaceLock(paths);
+    if (existing === undefined ||
+        existing.workspaceFingerprint !== expectedFingerprint ||
+        !isProvablyDeadPid(existing.pid)) {
+        return false;
+    }
+    try {
+        await unlink(workspaceLockPath(paths));
+        return true;
+    }
+    catch (error) {
+        if (errorHasCode(error, "ENOENT"))
+            return true;
+        throw error;
+    }
+}
 // v1 single-process exclusive lock: O_EXCL create, no distributed coordination,
 // and no reclaim of a lock that cannot be proven stale.
 export async function acquireWorkspaceLock(paths, planRef) {
@@ -61,10 +87,22 @@ export async function acquireWorkspaceLock(paths, planRef) {
         handle = await open(file, "wx", 0o644);
     }
     catch (error) {
-        if (errorHasCode(error, "EEXIST")) {
+        if (!errorHasCode(error, "EEXIST"))
+            throw error;
+        if (await reclaimProvablyStaleLock(paths, record.workspaceFingerprint)) {
+            try {
+                handle = await open(file, "wx", 0o644);
+            }
+            catch (retryError) {
+                if (errorHasCode(retryError, "EEXIST")) {
+                    throw lockedError(await readWorkspaceLock(paths));
+                }
+                throw retryError;
+            }
+        }
+        else {
             throw lockedError(await readWorkspaceLock(paths));
         }
-        throw error;
     }
     try {
         await handle.writeFile(`${JSON.stringify(record, null, 2)}\n`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,11 +21,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@tomflow/proflow-module-contract": "^0.1.0"
+    "@tomflow/proflow-module-contract": "^0.1.1"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.1",
-    "@tomflow/proflow-module-template": "^0.1.1"
+    "@tomflow/proflow-deployment-conformance": "^0.1.2",
+    "@tomflow/proflow-module-template": "^0.1.2"
   },
   "description": "Deterministic platform-level deployment discovery, planning, lifecycle and verification CLI.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-cli",
 	"packageName": "@tomflow/proflow-platform-cli",
-	"moduleVersion": "0.1.1",
+	"moduleVersion": "0.1.3",
 	"kind": "cli",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",