agentera 3.0.0-dev.5 → 3.0.0-dev.51

package/dist/upgrade/projectIntegrationDecision.js

@@ -0,0 +1,50 @@
+import { APP_MANUAL_REVIEW_NEEDED, APP_UP_TO_DATE } from "./doctor.js";
+export function classifyIntegrationScenario(facts) {
+    if (facts.pendingArtifactCount === 0 &&
+        !facts.crossMajor &&
+        !facts.crossMajorMigration &&
+        !facts.crossMajorNeedsPreview &&
+        (facts.bundleStatus === APP_UP_TO_DATE || facts.bundleStatus === APP_MANUAL_REVIEW_NEEDED)) {
+        return "stay";
+    }
+    if (facts.crossMajorNeedsPreview) {
+        return "blocked";
+    }
+    return "upgrade";
+}
+export function integrationScenarioMessage(scenario, facts) {
+    if (scenario === "stay")
+        return "Your Agentera install is up to date.";
+    if (scenario === "blocked") {
+        return "Cross-major version boundary detected; v3 successor not yet announced. Stay on the current channel.";
+    }
+    const reasons = [];
+    if (facts.pendingArtifactCount > 0)
+        reasons.push("project state needs migration");
+    if (facts.needsAppUpgrade)
+        reasons.push("app bundle needs update");
+    if (facts.crossMajorMigration)
+        reasons.push("cross-major version migration needed");
+    if (reasons.length === 0)
+        reasons.push("project changes pending");
+    return `This project needs an Agentera upgrade (${reasons.join(", ")}). Preview the upgrade command.`;
+}
+export function integrationPhase(facts, statusOverride) {
+    const status = statusOverride ?? (facts.blocked > 0 ? "blocked" : facts.pending > 0 ? "pending" : "stay");
+    return {
+        status,
+        counts: { total: facts.total, pending: facts.pending, blocked: facts.blocked },
+        blockers: facts.blockers,
+    };
+}
+export function integrationExit(hasPendingWork, appBlocked) {
+    if (!hasPendingWork && !appBlocked) {
+        return { code: 0, meaning: "no_changes_needed" };
+    }
+    if (hasPendingWork && appBlocked) {
+        return { code: 1, meaning: "preview_and_blockers" };
+    }
+    if (hasPendingWork)
+        return { code: 1, meaning: "preview_required" };
+    return { code: 1, meaning: "manual_review_required" };
+}

package/dist/upgrade/retiredResourceDiagnostics.js

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadNativeResourceCleanupContract, retiredResourceDiagnosticIds, } from "../runtime/nativeResourceCleanup.js";
+function templateRoot(template, roots) {
+    const match = /^\{(home|project|install_root)\}\//.exec(template);
+    if (!match)
+        throw new Error(`unsafe retired-resource diagnostic path template: ${template}`);
+    return roots[match[1]];
+}
+function expandTemplate(template, roots, name) {
+    const root = templateRoot(template, roots);
+    const expanded = template
+        .replace("{home}", roots.home)
+        .replace("{project}", roots.project)
+        .replace("{install_root}", roots.install_root)
+        .replace("{name}", name ?? "");
+    if (expanded.includes("{") || expanded.includes("..")) {
+        throw new Error(`unsafe retired-resource diagnostic path template: ${template}`);
+    }
+    const resolved = path.resolve(expanded);
+    const relative = path.relative(root, resolved);
+    if (relative === "" || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`retired-resource diagnostic path escapes its root: ${template}`);
+    }
+    return resolved;
+}
+function fileContains(pathname, marker, maximumFileBytes) {
+    let stat;
+    try {
+        stat = fs.lstatSync(pathname);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        return "uninspectable";
+    }
+    if (!stat.isFile() || stat.size > maximumFileBytes)
+        return "uninspectable";
+    const fd = fs.openSync(pathname, "r");
+    try {
+        const content = Buffer.alloc(stat.size);
+        fs.readSync(fd, content, 0, content.length, 0);
+        return content.toString("utf8").includes(marker) ? "path_present" : null;
+    }
+    catch {
+        return "uninspectable";
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function observeDestination(pathname, definition, maximumFileBytes) {
+    if (definition.contains) {
+        const observation = fileContains(pathname, definition.contains, maximumFileBytes);
+        return observation ? { path: pathname, observation } : null;
+    }
+    try {
+        fs.lstatSync(pathname);
+        return { path: pathname, observation: "path_present" };
+    }
+    catch (error) {
+        return error.code === "ENOENT"
+            ? null
+            : { path: pathname, observation: "uninspectable" };
+    }
+}
+function namesFor(definition) {
+    return definition.id.includes("{name}") || definition.destinations.some((item) => item.includes("{name}"))
+        ? definition.names
+        : [""];
+}
+export function diagnoseRetiredResources(opts) {
+    const contract = opts.contract ?? loadNativeResourceCleanupContract();
+    if (opts.resourceId && !retiredResourceDiagnosticIds(contract).includes(opts.resourceId)) {
+        throw new Error(`unknown retired Agentera resource ID: ${opts.resourceId}`);
+    }
+    const roots = {
+        home: path.resolve(opts.home),
+        project: path.resolve(opts.project),
+        install_root: path.resolve(opts.installRoot),
+    };
+    const observed = new Map();
+    for (const definition of contract.diagnosticResources) {
+        for (const name of namesFor(definition)) {
+            const id = definition.id.replace("{name}", name);
+            if (opts.resourceId && id !== opts.resourceId)
+                continue;
+            for (const destination of definition.destinations) {
+                const pathname = expandTemplate(destination, roots, name || null);
+                const observation = observeDestination(pathname, definition, contract.diagnosticMaximumFileBytes);
+                if (!observation)
+                    continue;
+                const current = observed.get(id) ?? [];
+                current.push(observation);
+                observed.set(id, current);
+            }
+        }
+    }
+    const entries = [...observed.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const retained = entries.slice(0, contract.diagnosticMaximumResources).map(([id, observations]) => ({
+        id,
+        status: "action_required",
+        evidence: {
+            paths: [...new Set(observations.map((observation) => observation.path))].sort(),
+            observation: observations.some((observation) => observation.observation === "uninspectable")
+                ? "uninspectable"
+                : "path_present",
+        },
+    }));
+    return {
+        schemaVersion: "agentera.retiredResourceDiagnosis.v1",
+        status: retained.length > 0 || entries.length > contract.diagnosticMaximumResources ? "action_required" : "clean",
+        selectedResourceId: opts.resourceId ?? null,
+        resources: retained,
+        omittedResourceCount: Math.max(0, entries.length - retained.length),
+    };
+}