@tomflow/proflow-platform-cli 0.1.13 → 0.1.15

package/dist/src/planner/upgrade.js

@@ -1,114 +0,0 @@
-import { assessModuleCompatibility, } from "@tomflow/proflow-module-contract";
-import { PlatformError } from "../errors.js";
-import { buildDependencyGraph } from "../graph/graph.js";
-import { assemblePlan, toResolvedModule } from "./assemble.js";
-import { configStep, createSequencer, humanActionsFromModules, humanStep, lifecycleStep, packageStep, upstreamDependencies, } from "./steps.js";
-export function assessUpgrade(current, target) {
-    const assessment = assessModuleCompatibility(current, target);
-    const migrationDeclared = target.lifecycle.supported.includes("migrate");
-    return {
-        compatible: assessment.compatible,
-        breakingChanges: assessment.breakingChanges,
-        templateVersionChanged: current.templateVersion !== target.templateVersion,
-        migrationDeclared,
-        migrationRequired: migrationDeclared && assessment.breakingChanges.length > 0,
-    };
-}
-function canonicalize(value) {
-    if (Array.isArray(value))
-        return value.map(canonicalize);
-    if (value !== null && typeof value === "object") {
-        const record = value;
-        const out = {};
-        for (const key of Object.keys(record).sort()) {
-            out[key] = canonicalize(record[key]);
-        }
-        return out;
-    }
-    return value;
-}
-/**
- * Deterministic descriptor equality (key-order independent). Used to detect
- * an already-satisfied upgrade target so we never emit a pretend
- * `package:upgrade` mutation for an unchanged module.
- */
-export function descriptorsEqual(current, target) {
-    return (JSON.stringify(canonicalize(current)) ===
-        JSON.stringify(canonicalize(target)));
-}
-export function planUpgrade(input) {
-    const currentDescriptors = input.currentDescriptors;
-    const targetDescriptors = input.targetDescriptors;
-    if (currentDescriptors === undefined || targetDescriptors === undefined) {
-        throw new PlatformError("INVALID_REQUEST", "upgrade requires currentDescriptors and targetDescriptors");
-    }
-    const modules = targetDescriptors.map(toResolvedModule);
-    const graph = buildDependencyGraph(modules);
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const currentByRef = new Map(currentDescriptors.map((descriptor) => [descriptor.moduleRef, descriptor]));
-    const targetByRef = new Map(targetDescriptors.map((descriptor) => [descriptor.moduleRef, descriptor]));
-    const seq = createSequencer();
-    const deps = upstreamDependencies(graph);
-    const steps = [];
-    for (const ref of graph.order) {
-        const module = byRef.get(ref);
-        if (module === undefined)
-            continue;
-        const current = currentByRef.get(ref);
-        const target = targetByRef.get(ref);
-        if (current !== undefined &&
-            target !== undefined &&
-            descriptorsEqual(current, target)) {
-            // already satisfied: no pretend package/config/lifecycle mutation
-            continue;
-        }
-        const assessment = current !== undefined && target !== undefined
-            ? assessUpgrade(current, target)
-            : undefined;
-        if (assessment !== undefined &&
-            !assessment.compatible &&
-            !assessment.migrationDeclared) {
-            throw new PlatformError("UPGRADE_FAILED", `upgrade ${ref} has breaking changes but declares no migrate lifecycle: ${assessment.breakingChanges.join("; ")}`);
-        }
-        const dependencies = deps.get(ref) ?? [];
-        const configTarget = input.config?.[ref];
-        const missingRequiredConfig = module.configSlots
-            .filter((slot) => slot.required &&
-            slot.default === undefined &&
-            configTarget?.[slot.key] === undefined)
-            .map((slot) => slot.key);
-        if (missingRequiredConfig.length > 0) {
-            throw new PlatformError("UPGRADE_FAILED", `upgrade ${ref} requires configuration before package mutation: ${missingRequiredConfig.join(", ")}`);
-        }
-        steps.push(packageStep(seq, module, "upgrade", dependencies));
-        if (configTarget !== undefined) {
-            steps.push(configStep(seq, module));
-        }
-        if (assessment?.migrationRequired === true) {
-            steps.push(lifecycleStep(seq, module, "migrate"));
-        }
-        if (module.kind === "service") {
-            if (module.lifecycle.includes("restart")) {
-                steps.push(lifecycleStep(seq, module, "restart"));
-            }
-            else if (module.lifecycle.includes("start")) {
-                steps.push(lifecycleStep(seq, module, "start"));
-            }
-        }
-        for (const requirement of module.requirements) {
-            if (requirement.kind === "human") {
-                steps.push(humanStep(seq, module, requirement.action));
-            }
-        }
-    }
-    return assemblePlan({
-        intent: "upgrade",
-        modules,
-        targets: input.targets ?? [],
-        config: input.config,
-        steps,
-        humanActions: humanActionsFromModules(modules),
-        now: input.now ?? new Date(),
-        targetDescriptors,
-    });
-}

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

@@ -1,11 +0,0 @@
-import type { ResolvedModule } from "../contracts.ts";
-import type { PreflightFinding } from "./findings.ts";
-export interface ResolvedModuleConfig {
-    moduleRef: string;
-    values: Record<string, string>;
-    secretRefs: string[];
-    missing: string[];
-}
-export declare function resolveModuleConfig(module: ResolvedModule, provided: Record<string, string> | undefined): ResolvedModuleConfig;
-export declare function checkConfigReadiness(modules: readonly ResolvedModule[], config: Record<string, Record<string, string>> | undefined): PreflightFinding[];
-export declare function checkConfigReality(modules: readonly ResolvedModule[], config: Record<string, Record<string, string>> | undefined): Promise<PreflightFinding[]>;

package/dist/src/preflight/config.js

@@ -1,88 +0,0 @@
-import { constants } from "node:fs";
-import { access, readFile, stat } from "node:fs/promises";
-import { PlatformError } from "../errors.js";
-import { isValidSecretRef } from "../security/redact.js";
-function compareRef(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-export function resolveModuleConfig(module, provided) {
-    const values = {};
-    const secretRefs = [];
-    const missing = [];
-    for (const slot of module.configSlots) {
-        let value = provided?.[slot.key];
-        if (value === undefined && slot.default !== undefined) {
-            value = String(slot.default);
-        }
-        if (slot.required && value === undefined) {
-            missing.push(slot.key);
-            continue;
-        }
-        if (value === undefined)
-            continue;
-        values[slot.key] = value;
-        if (slot.type === "secretRef") {
-            if (!isValidSecretRef(value))
-                throw new PlatformError("SECRET_REF_INVALID", `secretRef config "${slot.key}" for ${module.moduleRef} must be an opaque reference identity (e.g. secret://provider/name)`);
-            secretRefs.push(slot.key);
-        }
-    }
-    return { moduleRef: module.moduleRef, values, secretRefs, missing };
-}
-export function checkConfigReadiness(modules, config) {
-    const findings = [];
-    const sorted = [...modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef));
-    for (const module of sorted) {
-        const resolved = resolveModuleConfig(module, config?.[module.moduleRef]);
-        for (const key of resolved.missing) {
-            findings.push({
-                code: "CONFIG_MISSING",
-                severity: "error",
-                moduleRef: module.moduleRef,
-                message: `missing required config "${key}" for ${module.moduleRef}`,
-            });
-        }
-    }
-    return findings;
-}
-function requiresExistingInputFile(key, sensitive) {
-    return (sensitive === true ||
-        /(?:ConfigPath|ProfilesFile|CredentialFile|TokenFile|tokenFile|credentialFile)$/.test(key));
-}
-function requiresJsonFile(key) {
-    return /(?:ConfigPath|ProfilesFile)$/.test(key);
-}
-export async function checkConfigReality(modules, config) {
-    const findings = [];
-    for (const module of [...modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef))) {
-        for (const slot of module.configSlots) {
-            if (slot.type !== "path")
-                continue;
-            const value = config?.[module.moduleRef]?.[slot.key] ??
-                (slot.default === undefined ? undefined : String(slot.default));
-            if (!value || !requiresExistingInputFile(slot.key, slot.sensitive))
-                continue;
-            try {
-                await access(value, constants.R_OK);
-                const info = await stat(value);
-                if (!info.isFile())
-                    throw new Error("not a file");
-                const raw = await readFile(value, "utf8");
-                if (slot.sensitive === true && raw.trim().length < 32) {
-                    throw new Error("credential/token file is shorter than 32 characters");
-                }
-                if (requiresJsonFile(slot.key))
-                    JSON.parse(raw);
-            }
-            catch (error) {
-                findings.push({
-                    code: "CONFIG_INVALID",
-                    severity: "error",
-                    moduleRef: module.moduleRef,
-                    message: `config path "${slot.key}" for ${module.moduleRef} is not runtime-ready: ${error instanceof Error ? error.message : String(error)}`,
-                });
-            }
-        }
-    }
-    return findings;
-}

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

@@ -1,26 +0,0 @@
-import type { PlatformState } from "../contracts.ts";
-import type { PlatformErrorCode } from "../errors.ts";
-import type { DependencyGraph } from "../graph/graph.ts";
-import type { RequirementProbe } from "./requirements.ts";
-export type FindingSeverity = "error" | "warning" | "action";
-export type PreflightFindingCode = PlatformErrorCode | "REQUIREMENT_FAIL" | "HUMAN_ACTION" | "MODULE_REF_UNRESOLVED" | "MODULE_PREFLIGHT_BLOCKED" | "MODULE_PREFLIGHT_FAILED" | "MODULE_PREFLIGHT_ACTION_REQUIRED";
-export interface PreflightFinding {
-    code: PreflightFindingCode;
-    severity: FindingSeverity;
-    moduleRef?: string;
-    message: string;
-}
-export type ModulePreflightStatus = "SUCCEEDED" | "ACTION_REQUIRED" | "BLOCKED" | "FAILED" | "UNBOUND";
-export interface ModulePreflightResult {
-    moduleRef: string;
-    status: ModulePreflightStatus;
-    message: string;
-}
-export interface PreflightResult {
-    ok: boolean;
-    status: PlatformState;
-    findings: PreflightFinding[];
-    requirementProbes: RequirementProbe[];
-    modulePreflight: ModulePreflightResult[];
-    dependency: DependencyGraph | undefined;
-}

package/dist/src/preflight/findings.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,7 +0,0 @@
-export type { ResolvedModuleConfig } from "./config.ts";
-export { checkConfigReadiness, resolveModuleConfig } from "./config.ts";
-export type { FindingSeverity, ModulePreflightResult, ModulePreflightStatus, PreflightFinding, PreflightFindingCode, PreflightResult, } from "./findings.ts";
-export type { PreflightOptions } from "./preflight.ts";
-export { runPreflight } from "./preflight.ts";
-export type { ProbeStatus, RequirementProbe } from "./requirements.ts";
-export { probeAllRequirements, probeRequirement } from "./requirements.ts";

package/dist/src/preflight/index.js

@@ -1,3 +0,0 @@
-export { checkConfigReadiness, resolveModuleConfig } from "./config.js";
-export { runPreflight } from "./preflight.js";
-export { probeAllRequirements, probeRequirement } from "./requirements.js";

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

@@ -1,10 +0,0 @@
-import type { ResolvedModule } from "../contracts.ts";
-import type { ModuleCatalog } from "../modules.ts";
-import type { WorkspacePaths } from "../paths.ts";
-import type { PreflightResult } from "./findings.ts";
-export interface PreflightOptions {
-    config?: Record<string, Record<string, string>>;
-    catalog?: ModuleCatalog;
-    paths?: WorkspacePaths;
-}
-export declare function runPreflight(modules: readonly ResolvedModule[], options?: PreflightOptions): Promise<PreflightResult>;

package/dist/src/preflight/preflight.js

@@ -1,190 +0,0 @@
-import { PlatformError } from "../errors.js";
-import { buildDependencyGraph, ModuleRefUnresolvedError, } from "../graph/graph.js";
-import { dispatchLifecycle } from "../lifecycle/index.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;
-    try {
-        dependency = buildDependencyGraph(modules, options.config === undefined ? {} : { config: options.config });
-    }
-    catch (error) {
-        if (error instanceof ModuleRefUnresolvedError) {
-            findings.push({
-                code: "MODULE_REF_UNRESOLVED",
-                severity: "error",
-                moduleRef: error.from,
-                message: error.message,
-            });
-        }
-        else if (error instanceof PlatformError) {
-            findings.push({
-                code: error.code,
-                severity: "error",
-                message: error.message,
-            });
-        }
-        else {
-            throw error;
-        }
-    }
-    findings.push(...checkConfigReadiness(modules, options.config));
-    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({
-                code: "HUMAN_ACTION",
-                severity: "action",
-                moduleRef: probe.moduleRef,
-                message: probe.message,
-            });
-        }
-        else if (probe.status === "FAIL") {
-            findings.push({
-                code: "REQUIREMENT_FAIL",
-                severity: "warning",
-                moduleRef: probe.moduleRef,
-                message: probe.message,
-            });
-        }
-    }
-    const modulePreflight = await runModulePreflight(modules, options.catalog);
-    for (const result of modulePreflight) {
-        findings.push(...toFindings(result));
-    }
-    const status = deriveStatus(findings);
-    return {
-        ok: status === "READY",
-        status,
-        findings,
-        requirementProbes,
-        modulePreflight,
-        dependency,
-    };
-}
-async function runModulePreflight(modules, catalog) {
-    if (catalog === undefined)
-        return [];
-    const sorted = [...modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef));
-    const results = [];
-    for (const module of sorted) {
-        if (!module.lifecycle.includes("preflight"))
-            continue;
-        results.push(await preflightOne(catalog, module));
-    }
-    return results;
-}
-async function preflightOne(catalog, module) {
-    try {
-        const dispatched = await dispatchLifecycle(catalog, module, "preflight");
-        const result = dispatched.result;
-        return {
-            moduleRef: module.moduleRef,
-            status: result.status,
-            message: modulePreflightMessage(module.moduleRef, result),
-        };
-    }
-    catch (error) {
-        return {
-            moduleRef: module.moduleRef,
-            status: "UNBOUND",
-            message: `module ${module.moduleRef} preflight unavailable: adapter is not bound to a runtime (${errorMessage(error)})`,
-        };
-    }
-}
-function modulePreflightMessage(moduleRef, result) {
-    switch (result.status) {
-        case "SUCCEEDED":
-            return `module ${moduleRef} preflight succeeded`;
-        case "ACTION_REQUIRED": {
-            const action = result.actionRequired;
-            return action !== undefined
-                ? `module ${moduleRef} preflight requires action "${action.action}": ${action.description}`
-                : `module ${moduleRef} preflight requires an unspecified human action`;
-        }
-        case "BLOCKED":
-        case "FAILED": {
-            const error = result.error;
-            return error !== undefined
-                ? `module ${moduleRef} preflight ${result.status.toLowerCase()}: ${error.code}: ${error.message}`
-                : `module ${moduleRef} preflight ${result.status.toLowerCase()}`;
-        }
-    }
-}
-function toFindings(result) {
-    switch (result.status) {
-        case "SUCCEEDED":
-            return [];
-        case "ACTION_REQUIRED":
-        case "UNBOUND":
-            return [
-                {
-                    code: "MODULE_PREFLIGHT_ACTION_REQUIRED",
-                    severity: "action",
-                    moduleRef: result.moduleRef,
-                    message: result.message,
-                },
-            ];
-        case "BLOCKED":
-            return [
-                {
-                    code: "MODULE_PREFLIGHT_BLOCKED",
-                    severity: "error",
-                    moduleRef: result.moduleRef,
-                    message: result.message,
-                },
-            ];
-        case "FAILED":
-            return [
-                {
-                    code: "MODULE_PREFLIGHT_FAILED",
-                    severity: "error",
-                    moduleRef: result.moduleRef,
-                    message: result.message,
-                },
-            ];
-    }
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function deriveStatus(findings) {
-    let hasError = false;
-    let hasAction = false;
-    let hasWarning = false;
-    for (const finding of findings) {
-        if (finding.severity === "error")
-            hasError = true;
-        else if (finding.severity === "action")
-            hasAction = true;
-        else if (finding.severity === "warning")
-            hasWarning = true;
-    }
-    if (hasError)
-        return "NOT_READY";
-    if (hasAction)
-        return "ACTION_REQUIRED";
-    if (hasWarning)
-        return "DEGRADED";
-    return "READY";
-}

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

@@ -1,11 +0,0 @@
-import type { ModuleRequirement } from "@tomflow/proflow-module-contract";
-import type { ResolvedModule } from "../contracts.ts";
-export type ProbeStatus = "PASS" | "FAIL" | "ACTION_REQUIRED";
-export interface RequirementProbe {
-    moduleRef: string;
-    requirement: ModuleRequirement;
-    status: ProbeStatus;
-    message: string;
-}
-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>;