canary-test-cli 5.7.0 → 5.11.0

package/dist/engine-checks.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRegistryVersion = parseRegistryVersion;
+exports.isOlder = isOlder;
+exports.checkVersion = checkVersion;
+exports.checkGit = checkGit;
+exports.checkOverlays = checkOverlays;
+exports.checkProjectConfig = checkProjectConfig;
+exports.checkMcpConfig = checkMcpConfig;
+exports.runEngineChecks = runEngineChecks;
+/**
+ * Built-in `canary doctor` engine checks (Phase 2, tier 1). Each returns a
+ * {@link CheckResult}; none throws. Network is injectable and offline-tolerant.
+ */
+const fs = __importStar(require("node:fs"));
+const https = __importStar(require("node:https"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const overlay_commands_js_1 = require("./overlay-commands.js");
+const registry = __importStar(require("./overlays-registry.js"));
+/** The published npm package name (mirrors the install remedy in the shim). */
+const PKG = "canary-test-cli";
+const DEFAULT_TIMEOUT_MS = 5000;
+const realGit = (args, opts = {}) => {
+    const { spawnSync } = require("node:child_process");
+    const r = spawnSync("git", args, { cwd: opts.cwd, encoding: "utf8" });
+    if (r.error) {
+        const code = r.error.code;
+        return { status: code === "ENOENT" ? 127 : 1, stdout: "", stderr: String(r.error.message) };
+    }
+    return { status: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+};
+/** Read this package's own version from its package.json (best effort). */
+function ownVersion() {
+    try {
+        const pkgPath = path.join(__dirname, "..", "package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** String `version` from a registry body; null on parse error or non-string shape (SEC-DES-001: registry JSON is untrusted). */
+function parseRegistryVersion(rawBody) {
+    try {
+        const v = JSON.parse(rawBody)?.version;
+        return typeof v === "string" ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** GET the latest published version from the npm registry. null on any error. */
+function fetchLatestVersion(timeoutMs) {
+    return new Promise((resolve) => {
+        const req = https.get(`https://registry.npmjs.org/${PKG}/latest`, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                resolve(null);
+                return;
+            }
+            let body = "";
+            res.on("data", (c) => (body += c));
+            res.on("end", () => resolve(parseRegistryVersion(body)));
+        });
+        req.on("error", () => resolve(null));
+        req.setTimeout(timeoutMs, () => req.destroy());
+    });
+}
+/** True when semver `a` is strictly older than `b` (numeric compare, no prerelease). */
+function isOlder(a, b) {
+    const pa = a.split(".").map((n) => Number.parseInt(n, 10));
+    const pb = b.split(".").map((n) => Number.parseInt(n, 10));
+    for (let i = 0; i < 3; i += 1) {
+        const x = pa[i] ?? 0;
+        const y = pb[i] ?? 0;
+        if (x !== y) {
+            return x < y;
+        }
+    }
+    return false;
+}
+/** CLI version vs latest release. Offline degrades to info, never a failure. */
+async function checkVersion(deps = {}) {
+    const current = deps.currentVersion ?? ownVersion();
+    if (!current) {
+        return { id: "engine:version", status: "info", label: "CLI version: unknown" };
+    }
+    const getLatest = deps.getLatestVersion ?? (() => fetchLatestVersion(deps.timeoutMs ?? DEFAULT_TIMEOUT_MS));
+    const latest = await getLatest();
+    if (!latest) {
+        return { id: "engine:version", status: "info", label: `CLI ${current} (could not check latest — offline?)` };
+    }
+    if (isOlder(current, latest)) {
+        return {
+            id: "engine:version",
+            status: "fail",
+            label: `CLI ${current} is behind latest ${latest}`,
+            remedy: `Upgrade: npm install -g ${PKG}@latest`,
+        };
+    }
+    return { id: "engine:version", status: "pass", label: `CLI ${current} (latest)` };
+}
+/** git present on PATH. */
+function checkGit(deps = {}) {
+    const git = deps.git ?? realGit;
+    const res = git(["--version"]);
+    if (res.status === 0) {
+        return { id: "engine:git", status: "pass", label: `git present (${res.stdout.trim() || "ok"})` };
+    }
+    return {
+        id: "engine:git",
+        status: "fail",
+        label: "git not found on PATH",
+        remedy: "Install git and ensure it is on your PATH — overlay add/update need it.",
+    };
+}
+/** Registered overlays present, fresh, and free of local modifications. */
+function checkOverlays(deps = {}) {
+    const git = deps.git ?? realGit;
+    const homeDir = deps.homeDir ?? os.homedir();
+    let reg;
+    try {
+        reg = registry.read(homeDir);
+    }
+    catch (e) {
+        return [
+            {
+                id: "engine:overlays",
+                status: "fail",
+                label: "overlays registry unreadable",
+                remedy: e.message,
+            },
+        ];
+    }
+    if (reg.overlays.length === 0) {
+        return [{ id: "engine:overlays", status: "info", label: "no overlays registered" }];
+    }
+    const results = [];
+    for (const o of reg.overlays) {
+        const fresh = (0, overlay_commands_js_1.freshness)(o.path, o, git);
+        if (fresh.startsWith("missing")) {
+            results.push({
+                id: `overlay:${o.name}:present`,
+                status: "fail",
+                label: `overlay "${o.name}": clone missing`,
+                remedy: `Re-add it: canary overlay remove ${o.name} (if needed) then canary overlay add ${o.source}`,
+            });
+            continue;
+        }
+        if (fresh.includes("behind")) {
+            results.push({
+                id: `overlay:${o.name}:fresh`,
+                status: "fail",
+                label: `overlay "${o.name}": ${fresh}`,
+                remedy: `Update it: canary overlay update ${o.name}`,
+            });
+        }
+        else {
+            results.push({ id: `overlay:${o.name}:fresh`, status: "pass", label: `overlay "${o.name}": ${fresh}` });
+        }
+        const clean = (0, overlay_commands_js_1.workingTreeStatus)(o.path, git);
+        if (clean === "clean") {
+            results.push({ id: `overlay:${o.name}:clean`, status: "pass", label: `overlay "${o.name}": no local changes` });
+        }
+        else {
+            results.push({
+                id: `overlay:${o.name}:clean`,
+                status: "fail",
+                label: `overlay "${o.name}": ${clean === "dirty" ? "local modifications" : "git status unreadable"}`,
+                remedy: `Commit/stash changes in ${o.path}, or canary overlay remove ${o.name} and re-add.`,
+            });
+        }
+    }
+    return results;
+}
+/** Parse a JSON file; returns an error message or null when it parses (or is absent). */
+function parseErrorOrNull(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (e) {
+        return e.code === "ENOENT" ? null : e.message;
+    }
+    try {
+        JSON.parse(raw);
+        return null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
+/** Project `.canary/` config files parse as JSON. */
+function checkProjectConfig(deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const dir = path.join(cwd, ".canary");
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => /^company(\.[\w-]+)?\.json$/.test(n));
+    }
+    catch {
+        return { id: "engine:project-config", status: "skip", label: "no project .canary/ config" };
+    }
+    if (names.length === 0) {
+        return { id: "engine:project-config", status: "skip", label: "no project .canary/ config" };
+    }
+    for (const name of names) {
+        const err = parseErrorOrNull(path.join(dir, name));
+        if (err) {
+            return {
+                id: "engine:project-config",
+                status: "fail",
+                label: `project .canary/${name} does not parse`,
+                remedy: `Fix the JSON in .canary/${name}: ${err}`,
+            };
+        }
+    }
+    return { id: "engine:project-config", status: "pass", label: `project .canary/ config parses (${names.length} file(s))` };
+}
+/** Assert a single `.mcp.json` parses and each server entry is well-formed. */
+function inspectMcpFile(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            return { present: false };
+        }
+        return { present: true, error: e.message };
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch (e) {
+        return { present: true, error: `does not parse: ${e.message}` };
+    }
+    const servers = data.mcpServers;
+    if (servers === undefined) {
+        return { present: true };
+    }
+    if (typeof servers !== "object" || servers === null) {
+        return { present: true, error: "mcpServers is not an object" };
+    }
+    for (const [key, entry] of Object.entries(servers)) {
+        const e = entry;
+        if (typeof e.command !== "string" && typeof e.url !== "string") {
+            return { present: true, error: `server "${key}" has neither a command nor a url` };
+        }
+    }
+    return { present: true };
+}
+/** MCP config references resolvable — read project and home `.mcp.json` directly. */
+function checkMcpConfig(deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const homeDir = deps.homeDir ?? os.homedir();
+    const files = [path.join(cwd, ".mcp.json"), path.join(homeDir, ".mcp.json")];
+    let anyPresent = false;
+    for (const file of files) {
+        const r = inspectMcpFile(file);
+        anyPresent = anyPresent || r.present;
+        if (r.error) {
+            return {
+                id: "engine:mcp",
+                status: "fail",
+                label: `MCP config ${file} is invalid`,
+                remedy: `Fix ${file}: ${r.error}`,
+            };
+        }
+    }
+    if (!anyPresent) {
+        return { id: "engine:mcp", status: "skip", label: "no .mcp.json found" };
+    }
+    return { id: "engine:mcp", status: "pass", label: "MCP config resolves" };
+}
+/** Run every engine check, in display order. */
+async function runEngineChecks(deps = {}) {
+    return [
+        await checkVersion(deps),
+        checkGit(deps),
+        ...checkOverlays(deps),
+        checkProjectConfig(deps),
+        checkMcpConfig(deps),
+    ];
+}