agentera 3.0.0-dev.7 → 3.0.0-dev.72

package/dist/cli/commands/upgrade.js

@@ -1,4 +1,8 @@
 import { buildUpgradePlan, renderUpgradePlan, sortKeysDeep, upgradeExitCode, validateUpgradeApply, } from "../../upgrade/upgradeOrchestrator.js";
+import { renderVerifySummary, verifyOneWayUpgrade, verifyUpgrade, } from "./upgradeVerify.js";
+import { detectStateMode } from "../../state/stateMode.js";
+import { UpgradeLockError } from "../../upgrade/upgradeLock.js";
+import { fullEntityUpgradeCommand } from "../../upgrade/upgradeCommands.js";
 /** Canonical stable-channel update entry point. */
 export const UPGRADE_COMMAND = "npx -y agentera@latest";
 function toOrchestratorArgs(args) {
@@ -11,38 +15,175 @@ function toOrchestratorArgs(args) {
         dryRun: args.dryRun ?? false,
         only: args.only && args.only.length > 0 ? args.only : null,
         force: args.force ?? false,
+        runtime: args.runtime ?? null,
+        legacyCleanup: args.legacyCleanup ?? null,
     };
 }
-export function cmdUpgrade(args, io = {}) {
+function toVerifyContext(args) {
+    return {
+        installRoot: args.installRoot ?? null,
+        home: args.home ?? null,
+        project: args.project ?? null,
+        expectedVersion: args.expectedVersion ?? null,
+    };
+}
+function renderOneWayResult(verification, applyPassed, json) {
+    const verificationPassed = verification.state_validation.status === "passed"
+        && verification.startup_validation.status === "passed";
+    const result = {
+        phase: applyPassed ? (verificationPassed ? "complete" : "verification") : "apply",
+        startup_validation: verification.startup_validation,
+        state_validation: verification.state_validation,
+        status: applyPassed && verificationPassed ? "success" : "failed",
+    };
+    if (json)
+        return JSON.stringify(result, null, 2) + "\n";
+    return result.status === "success"
+        ? "Agentera upgraded this project from v2 to v3; state and startup validation passed.\n"
+        : "Agentera could not verify the v2-to-v3 upgrade.\n";
+}
+function entityAuthorityConfirmedActive(project) {
+    try {
+        return detectStateMode(project) === "entities";
+    }
+    catch {
+        return false;
+    }
+}
+export function cmdUpgrade(args, io = {}, dependencies = {}) {
     const out = io.out ?? ((t) => process.stdout.write(t));
     const err = io.err ?? ((t) => process.stderr.write(t));
     const orchestratorArgs = toOrchestratorArgs(args);
+    if (orchestratorArgs.runtime) {
+        err(`upgrade error: --runtime ${orchestratorArgs.runtime} is retired; Agentera now uses the shared skill at ` +
+            "~/.agents/skills/agentera plus the CLI. Remove --runtime and rerun. " +
+            "For explicit Agentera-owned native resource cleanup, use --legacy-cleanup RESOURCE_ID.\n");
+        return 2;
+    }
     if (orchestratorArgs.yes && orchestratorArgs.dryRun) {
         err("upgrade error: --yes and --dry-run are mutually exclusive\n");
         return 2;
     }
+    if (orchestratorArgs.yes && orchestratorArgs.only?.length) {
+        err(`upgrade error: --only is preview-only; apply must run as one full upgrade --yes\nRecovery: ${fullEntityUpgradeCommand(path.resolve(args.project ?? process.cwd()))}\n`);
+        return 2;
+    }
+    if (orchestratorArgs.legacyCleanup
+        && orchestratorArgs.only
+        && orchestratorArgs.only.length > 0) {
+        err("upgrade error: --only cannot be combined with --legacy-cleanup; cleanup preview must include the complete app phase\n");
+        return 2;
+    }
+    if (args.verify && orchestratorArgs.dryRun) {
+        err("upgrade error: --verify cannot be combined with --dry-run\n");
+        return 2;
+    }
+    if (args.verify && !orchestratorArgs.yes && (orchestratorArgs.legacyCleanup)) {
+        err("upgrade error: legacy cleanup with --verify requires --yes; preview cleanup with --dry-run instead\n");
+        return 2;
+    }
+    if (args.verify && !orchestratorArgs.yes) {
+        let result;
+        try {
+            result = verifyUpgrade(toVerifyContext(args));
+        }
+        catch (exc) {
+            err(`upgrade error: ${exc.message}\n`);
+            return 2;
+        }
+        out(renderVerifySummary(result, (args.format ?? "text") === "json"));
+        return result.passed ? 0 : 1;
+    }
     let plan;
+    let fullEntityCutoverApply = false;
     try {
         if (orchestratorArgs.yes) {
             const preview = buildUpgradePlan({ ...orchestratorArgs, yes: false });
+            fullEntityCutoverApply = !orchestratorArgs.only && (preview.crossMajorBoundary || preview.phases.some((phase) => phase.name === "entities" && phase.items.some((item) => item.action === "entity-cutover" && item.status === "pending")));
             const applyError = validateUpgradeApply(orchestratorArgs, preview);
             if (applyError) {
-                err(`upgrade error: ${applyError}\n`);
+                if (preview.crossMajorBoundary) {
+                    if (orchestratorArgs.only) {
+                        err("upgrade error: v2-to-v3 apply must run as one full upgrade --yes; --only is preview-only.\n");
+                    }
+                    else if (preview.channel.distributionMajor < 3) {
+                        err("upgrade error: v2-to-v3 apply requires the development channel; preview there, then retry with --yes.\n");
+                    }
+                    else if (!entityAuthorityConfirmedActive(preview.project)) {
+                        err(`upgrade error: v2-to-v3 preflight failed: ${applyError}. Recover the tracked v2 checkout with Git and retry.\n`);
+                    }
+                    else {
+                        err("upgrade error: v2-to-v3 preflight failed. Rerun the same upgrade command to continue forward.\n");
+                    }
+                }
+                else {
+                    err(`upgrade error: ${applyError}\n`);
+                }
                 return 1;
             }
         }
         plan = buildUpgradePlan(orchestratorArgs);
     }
     catch (exc) {
-        err(`upgrade error: ${exc.message}\n`);
+        if (exc instanceof UpgradeLockError) {
+            err(`upgrade error: ${exc.message}\n`);
+        }
+        else if (fullEntityCutoverApply) {
+            err(`upgrade error: ${exc.message}. Rerun the same upgrade command to continue forward.\n`);
+        }
+        else {
+            err(`upgrade error: ${exc.message}\n`);
+        }
         return 2;
     }
+    if (fullEntityCutoverApply) {
+        const applyExit = upgradeExitCode(plan);
+        const verification = (dependencies.verifyOneWayUpgrade ?? verifyOneWayUpgrade)(toVerifyContext(args));
+        const authorityActive = entityAuthorityConfirmedActive(plan.project);
+        const verificationPassed = verification.state_validation.status === "passed"
+            && verification.startup_validation.status === "passed";
+        out(renderOneWayResult(verification, applyExit === 0 && authorityActive, (args.format ?? "text") === "json"));
+        if (applyExit !== 0 || !authorityActive || !verificationPassed) {
+            if (!authorityActive) {
+                err("Recover the tracked v2 checkout with Git and retry; no v3 authority was activated.\n");
+            }
+            else {
+                const unresolved = plan.phases
+                    .filter((phase) => ["runtime", "cleanup", "lifecycle"].includes(phase.name))
+                    .flatMap((phase) => phase.items)
+                    .find((item) => item.status === "blocked" || item.status === "failed");
+                if (unresolved) {
+                    const unresolvedPath = unresolved.source ?? unresolved.target ?? unresolved.action;
+                    err(`action-required after entity activation: ${unresolvedPath}: ${unresolved.message}. Rerun the same upgrade command to continue forward.\n`);
+                }
+                else {
+                    err("Rerun the same upgrade command to continue forward; verification is read-only and no completed effect was reversed.\n");
+                }
+            }
+            return 1;
+        }
+        return 0;
+    }
     if ((args.format ?? "text") === "json") {
         out(JSON.stringify(sortKeysDeep(plan), null, 2) + "\n");
     }
     else {
         out(renderUpgradePlan(plan));
     }
-    return upgradeExitCode(plan);
+    let exit = upgradeExitCode(plan);
+    if (args.verify && orchestratorArgs.yes) {
+        let result;
+        try {
+            result = verifyUpgrade(toVerifyContext(args));
+        }
+        catch (exc) {
+            err(`upgrade error: ${exc.message}\n`);
+            return 2;
+        }
+        err(renderVerifySummary(result, false));
+        if (!result.passed)
+            exit = 1;
+    }
+    return exit;
 }
-//# sourceMappingURL=upgrade.js.map
+import path from "node:path";

package/dist/cli/commands/upgradeVerify.js

@@ -0,0 +1,118 @@
+import os from "node:os";
+import { expanduser, resolvePath } from "../../core/paths.js";
+import { resolveDoctorInstallRoot, resolveSourceRootStrict } from "../../upgrade/appModel.js";
+import { APP_UP_TO_DATE, buildDoctorStatus } from "../../upgrade/doctor.js";
+import { CAPABILITY_INSTRUCTIONS } from "../../capabilities/index.js";
+import { buildPrimeCapabilityContextPayload } from "../capabilityContext.js";
+import { collectOrientationState } from "./prime/collectOrientationState.js";
+import { cmdPrime } from "./prime.js";
+import { validateStatePayload } from "./validate.js";
+import { enforceCompletedEntityCutover } from "../migrationRequired.js";
+function inProject(project, action) {
+    const previous = process.cwd();
+    process.chdir(project);
+    try {
+        return action();
+    }
+    finally {
+        process.chdir(previous);
+    }
+}
+/** Mandatory read-only checks for an activated v2-to-v3 project. */
+export function verifyOneWayUpgrade(ctx) {
+    const project = resolvePath(expanduser(ctx.project ?? process.cwd()));
+    const cutoverPassed = enforceCompletedEntityCutover(project, "json", {
+        out: () => { },
+        err: () => { },
+    }) === null;
+    let stateValidation;
+    try {
+        const state = validateStatePayload(project);
+        stateValidation = {
+            status: cutoverPassed && state.valid === true ? "passed" : "failed",
+            entity_count: Number(state.entity_count),
+            issue_count: Number(state.issue_count) + (cutoverPassed ? 0 : 1),
+        };
+    }
+    catch {
+        stateValidation = { status: "failed", entity_count: 0, issue_count: 1 };
+    }
+    let startupPassed = false;
+    if (cutoverPassed) {
+        try {
+            startupPassed = inProject(project, () => cmdPrime({
+                context: "status",
+                format: "json",
+                home: resolvePath(expanduser(ctx.home ?? os.homedir())),
+                installRoot: ctx.installRoot ?? null,
+                expectedVersion: ctx.expectedVersion ?? null,
+            }, { out: () => { }, err: () => { } })) === 0;
+        }
+        catch {
+            startupPassed = false;
+        }
+    }
+    return {
+        state_validation: stateValidation,
+        startup_validation: { status: startupPassed ? "passed" : "failed" },
+    };
+}
+export function verifyUpgrade(ctx) {
+    const sourceRoot = resolveSourceRootStrict();
+    const home = resolvePath(expanduser(ctx.home ?? os.homedir()));
+    const project = resolvePath(expanduser(ctx.project ?? process.cwd()));
+    const [installRoot, rootSource] = resolveDoctorInstallRoot(ctx.installRoot ?? null, {
+        home,
+        sourceRoot,
+    });
+    const checks = [];
+    const status = buildDoctorStatus(installRoot, {
+        rootSource,
+        sourceRoot,
+        home,
+        project,
+        expectedVersion: ctx.expectedVersion ?? null,
+    });
+    const doctorOk = status.status === APP_UP_TO_DATE && status.signals.length === 0;
+    checks.push({
+        name: "doctor",
+        passed: doctorOk,
+        detail: `status=${status.status}; signals=${status.signals.length}`,
+    });
+    const state = collectOrientationState({
+        home,
+        installRoot,
+        expectedVersion: ctx.expectedVersion ?? null,
+    });
+    for (const capability of Object.keys(CAPABILITY_INSTRUCTIONS)) {
+        const payload = buildPrimeCapabilityContextPayload(state, capability, "prime");
+        const capabilityContext = payload.capability_context;
+        const stateBlock = capabilityContext?.state;
+        const schemaError = stateBlock?.schema_error ?? null;
+        const passed = schemaError === null;
+        checks.push({
+            name: `prime --context ${capability}`,
+            passed,
+            detail: passed ? "schema_error: null" : `schema_error: ${String(schemaError)}`,
+        });
+    }
+    return { passed: checks.every((c) => c.passed), checks };
+}
+export function renderVerifySummary(result, json) {
+    if (json) {
+        return (JSON.stringify({
+            command: "upgrade --verify",
+            status: result.passed ? "passed" : "failed",
+            checks: result.checks,
+        }, null, 2) + "\n");
+    }
+    const lines = [
+        "Agentera verify",
+        `status: ${result.passed ? "passed" : "failed"}`,
+        "checks:",
+    ];
+    for (const check of result.checks) {
+        lines.push(`  - ${check.name}: ${check.passed ? "passed" : "failed"}  (${check.detail})`);
+    }
+    return lines.join("\n") + "\n";
+}