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

package/dist/cli/commands/prime/buildExecutionRequest.js

@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import { hasControlChars } from "../../argvalidate.js";
+import { loadYamlMapping } from "../../../core/yaml.js";
+import { preCutoverCommand } from "../../preCutoverCommand.js";
+export const BUILD_EXECUTION_REQUEST_SCHEMA = "agentera.buildExecutionRequest.v1";
+export const BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES = 32 * 1024;
+export const BUILD_EXECUTION_REQUEST_MAX_ITEMS = 12;
+export const BUILD_EXECUTION_REQUEST_MAX_CODE_POINTS = 160;
+const BUILD_EXECUTION_REQUEST_READ_CHUNK_BYTES = 8 * 1024;
+export class BuildExecutionRequestError extends Error {
+    body;
+    constructor(body) {
+        super(body.message);
+        this.body = body;
+    }
+}
+function fail(body) {
+    throw new BuildExecutionRequestError(body);
+}
+function codePointLength(value) {
+    return [...value].length;
+}
+function validateText(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        fail({ class: "schema_violation", message: `Build execution request ${field} must be a non-empty string` });
+    }
+    if (codePointLength(value) > BUILD_EXECUTION_REQUEST_MAX_CODE_POINTS) {
+        fail({ class: "schema_violation", message: `Build execution request ${field} exceeds 160 Unicode code points` });
+    }
+    if (hasControlChars(value)) {
+        fail({ class: "schema_violation", message: `Build execution request ${field} contains control characters` });
+    }
+    return value;
+}
+function unreadableInput() {
+    return fail({
+        class: "invalid_format",
+        message: "Build execution request input must be one readable regular file or bounded stdin stream",
+        syntax: preCutoverCommand("prime --context build --input <file|-> --format json"),
+    });
+}
+function oversizedInput() {
+    return fail({ class: "schema_violation", message: "Build execution request input exceeds the 32768-byte UTF-8 bound" });
+}
+function readBoundedDescriptor(fd) {
+    const chunks = [];
+    let total = 0;
+    while (total <= BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES) {
+        const remaining = BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES + 1 - total;
+        const chunk = Buffer.allocUnsafe(Math.min(BUILD_EXECUTION_REQUEST_READ_CHUNK_BYTES, remaining));
+        const count = fs.readSync(fd, chunk, 0, chunk.byteLength, null);
+        if (count === 0)
+            break;
+        chunks.push(chunk.subarray(0, count));
+        total += count;
+    }
+    if (total > BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES)
+        oversizedInput();
+    return Buffer.concat(chunks, total);
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function readBoundedFile(source) {
+    let observed;
+    try {
+        observed = fs.lstatSync(source, { bigint: true });
+    }
+    catch {
+        return unreadableInput();
+    }
+    if (observed.isSymbolicLink() || !observed.isFile())
+        unreadableInput();
+    if (observed.size > BigInt(BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES))
+        oversizedInput();
+    let fd = null;
+    try {
+        fd = fs.openSync(source, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+        const opened = fs.fstatSync(fd, { bigint: true });
+        if (!opened.isFile() || !sameIdentity(observed, opened))
+            unreadableInput();
+        if (opened.size > BigInt(BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES))
+            oversizedInput();
+        return readBoundedDescriptor(fd);
+    }
+    catch (error) {
+        if (error instanceof BuildExecutionRequestError)
+            throw error;
+        return unreadableInput();
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+}
+function readBytes(source, readStdin) {
+    if (source !== "-")
+        return readBoundedFile(source);
+    if (readStdin) {
+        let value;
+        try {
+            value = readStdin();
+        }
+        catch {
+            return unreadableInput();
+        }
+        const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+        if (bytes.byteLength > BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES)
+            oversizedInput();
+        return bytes;
+    }
+    if (process.stdin.isTTY)
+        return Buffer.alloc(0);
+    try {
+        return readBoundedDescriptor(0);
+    }
+    catch (error) {
+        if (error instanceof BuildExecutionRequestError)
+            throw error;
+        return unreadableInput();
+    }
+}
+export function loadBuildExecutionRequest(source, readStdin) {
+    const bytes = readBytes(source, readStdin);
+    let input;
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        input = loadYamlMapping(text);
+    }
+    catch {
+        return fail({
+            class: "invalid_format",
+            message: "Build execution request input must be one valid UTF-8 YAML or JSON mapping",
+        });
+    }
+    const fields = Object.keys(input);
+    const expected = ["schema_version", "scope", "acceptance"];
+    if (fields.some((field) => !expected.includes(field))) {
+        fail({ class: "schema_violation", message: "Build execution request contains unsupported fields" });
+    }
+    if (fields.length !== expected.length || expected.some((field) => !Object.hasOwn(input, field))) {
+        fail({ class: "schema_violation", message: "Build execution request requires exactly schema_version, scope, and acceptance" });
+    }
+    if (input.schema_version !== BUILD_EXECUTION_REQUEST_SCHEMA) {
+        fail({ class: "schema_violation", message: `Build execution request schema_version must be ${BUILD_EXECUTION_REQUEST_SCHEMA}` });
+    }
+    const scope = validateText(input.scope, "scope");
+    if (!Array.isArray(input.acceptance) || input.acceptance.length < 1 || input.acceptance.length > BUILD_EXECUTION_REQUEST_MAX_ITEMS) {
+        fail({ class: "schema_violation", message: "Build execution request acceptance must contain 1 to 12 strings" });
+    }
+    const acceptance = input.acceptance.map((value, index) => validateText(value, `acceptance[${index}]`));
+    if (new Set(acceptance).size !== acceptance.length) {
+        fail({ class: "schema_violation", message: "Build execution request acceptance must not contain duplicate values" });
+    }
+    return {
+        schema_version: BUILD_EXECUTION_REQUEST_SCHEMA,
+        scope,
+        acceptance,
+        source: {
+            kind: source === "-" ? "stdin" : "file",
+            schema_version: BUILD_EXECUTION_REQUEST_SCHEMA,
+            persisted: false,
+        },
+    };
+}

package/dist/cli/commands/prime/bundleStatus.js

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { APP_OUTDATED, buildDoctorStatus } from "../../../upgrade/doctor.js";
+import { doctorRoots, loadSuiteVersion, resolveDoctorInstallRoot, resolveSourceRootStrict } from "../../../upgrade/appModel.js";
+import { isNpxBundleRoot } from "../../../core/sourceRoot.js";
+import { resolveInvokedUpdateChannel } from "../../../upgrade/channels.js";
+import { classifyResolvedRoot } from "../../../state/installRoot.js";
+import { resolveLatestOnChannel } from "../../../upgrade/versionResolution.js";
+import { resolveNpxPlatformStatus } from "../../../upgrade/npxPlatformStatus.js";
+function frontmatterVersion(p) {
+    let lines;
+    try {
+        if (!fs.statSync(p).isFile())
+            return null;
+        lines = fs.readFileSync(p, "utf8").split(/\r\n|\r|\n/);
+    }
+    catch {
+        return null;
+    }
+    if (lines.length === 0 || lines[0].trim() !== "---")
+        return null;
+    for (const line of lines.slice(1)) {
+        const stripped = line.trim();
+        if (stripped === "---")
+            return null;
+        if (stripped.startsWith("version:")) {
+            const version = stripped.split(":", 2)[1].trim().replace(/^["']|["']$/g, "");
+            return version || null;
+        }
+    }
+    return null;
+}
+function versionKey(version) {
+    if (!version)
+        return [];
+    const parts = [];
+    for (const item of version.split(/[.+_-]/)) {
+        if (/^\d+$/.test(item))
+            parts.push(parseInt(item, 10));
+        else
+            break;
+    }
+    return parts;
+}
+function versionKeyGe(a, b) {
+    const n = Math.max(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        const ai = a[i] ?? 0;
+        const bi = b[i] ?? 0;
+        if (ai !== bi)
+            return ai > bi;
+    }
+    return true;
+}
+function visibleSkillVersion(home, env, installRoot, sourceRoot) {
+    const candidates = [];
+    if (env.AGENTERA_VISIBLE_SKILL_ROOT)
+        candidates.push(env.AGENTERA_VISIBLE_SKILL_ROOT);
+    candidates.push(path.join(installRoot, "skills", "agentera"));
+    candidates.push(path.join(sourceRoot, "skills", "agentera"));
+    candidates.push(path.join(home, ".config", "opencode", "skills", "agentera"));
+    candidates.push(path.join(home, ".agents", "skills", "agentera"));
+    const versions = [];
+    for (const root of candidates) {
+        const version = frontmatterVersion(path.join(root, "SKILL.md"));
+        if (version)
+            versions.push([versionKey(version), version, root]);
+    }
+    if (versions.length === 0)
+        return [null, null];
+    versions.sort((a, b) => (versionKeyGe(a[0], b[0]) ? -1 : 1));
+    return [versions[0][1], versions[0][2]];
+}
+function recognizedSkillRoots(home, env, installRoot, sourceRoot) {
+    const roots = [];
+    if (env.AGENTERA_VISIBLE_SKILL_ROOT)
+        roots.push(env.AGENTERA_VISIBLE_SKILL_ROOT);
+    roots.push(path.join(installRoot, "skills", "agentera"));
+    roots.push(path.join(sourceRoot, "skills", "agentera"));
+    roots.push(path.join(home, ".config", "opencode", "skills", "agentera"));
+    roots.push(path.join(home, ".agents", "skills", "agentera"));
+    return roots;
+}
+function detectSkillRootDivergence(home, env, installRoot, sourceRoot, expected) {
+    if (!expected)
+        return [];
+    const expectedKey = versionKey(expected);
+    if (expectedKey.length === 0)
+        return [];
+    const divergent = [];
+    const seen = new Set();
+    for (const root of recognizedSkillRoots(home, env, installRoot, sourceRoot)) {
+        if (seen.has(root))
+            continue;
+        seen.add(root);
+        const version = frontmatterVersion(path.join(root, "SKILL.md"));
+        if (!version)
+            continue;
+        if (!versionKeyGe(versionKey(version), expectedKey)) {
+            divergent.push({ root, version });
+        }
+    }
+    return divergent;
+}
+function statusExpectedVersion(opts, sourceRoot, home, env, installRoot, channel) {
+    if (opts.expectedVersion)
+        return [opts.expectedVersion, "--expected-version"];
+    if (env.AGENTERA_EXPECTED_VERSION)
+        return [env.AGENTERA_EXPECTED_VERSION, "AGENTERA_EXPECTED_VERSION"];
+    if (channel.channel === "stable") {
+        const roots = doctorRoots(installRoot);
+        const classification = classifyResolvedRoot(roots.activeBundleRoot, { source: "explicit" });
+        if (classification.current_version) {
+            return [classification.current_version, "installed app registry"];
+        }
+        return [resolveLatestOnChannel(channel, sourceRoot), "stable channel catalog"];
+    }
+    const sourceVersion = loadSuiteVersion(sourceRoot);
+    const [visibleVersion, visibleSource] = visibleSkillVersion(home, env, installRoot, sourceRoot);
+    if (visibleVersion && versionKeyGe(versionKey(visibleVersion), versionKey(sourceVersion))) {
+        return [visibleVersion, visibleSource || "visible skill"];
+    }
+    return [sourceVersion, "source registry"];
+}
+export function statusBundleContext(opts) {
+    const env = opts.env ?? process.env;
+    const home = opts.home ? opts.home : os.homedir();
+    const sourceRoot = resolveSourceRootStrict(env);
+    const channel = resolveInvokedUpdateChannel({ env, home, sourceRoot });
+    const [installRoot, rootSource] = resolveDoctorInstallRoot(opts.installRoot ?? null, {
+        home,
+        env,
+        sourceRoot,
+    });
+    const [expected, expectedSource] = statusExpectedVersion(opts, sourceRoot, home, env, installRoot, channel);
+    const observation = {};
+    const status = buildDoctorStatus(installRoot, {
+        rootSource,
+        sourceRoot,
+        home,
+        project: process.cwd(),
+        expectedVersion: expected,
+        expectedCommands: ["prime"],
+        channel: channel.channel,
+        resolvedChannel: channel,
+        observation,
+        env,
+    });
+    status.expectedVersionSource = expectedSource;
+    if (isNpxBundleRoot(sourceRoot)) {
+        const { platformRoot, platformStatus } = resolveNpxPlatformStatus({
+            home,
+            sourceRoot,
+            project: process.cwd(),
+            expectedVersion: expected,
+            expectedCommands: ["prime"],
+            env,
+        });
+        status.platformAppHome = {
+            path: platformRoot,
+            status: platformStatus.status,
+            rootStatus: platformStatus.rootStatus,
+            dryRunCommand: platformStatus.dryRunCommand,
+            applyCommand: platformStatus.applyCommand,
+        };
+        status.cliApp = {
+            path: sourceRoot,
+            status: status.status,
+            rootStatus: status.rootStatus,
+        };
+    }
+    const divergent = detectSkillRootDivergence(home, env, installRoot, sourceRoot, expected);
+    if (divergent.length > 0) {
+        status.status = APP_OUTDATED;
+        for (const d of divergent) {
+            status.signals.push({
+                status: APP_OUTDATED,
+                kind: "skill_root_divergence",
+                message: `skill root ${d.root} is at v${d.version}; expected v${expected}`,
+                expected: expected ?? undefined,
+                actual: d.version,
+            });
+        }
+    }
+    return { bundle: status, channel, ...observation };
+}
+export function statusBundleStatus(opts) {
+    return statusBundleContext(opts).bundle;
+}