@bli-cockpit/cli 0.2.48 → 0.2.49

package/dist/autostart-windows.js

@@ -0,0 +1,237 @@
+import os from "node:os";
+import { AUTOSTART_LABEL, DEFAULT_AUTOSTART_INTERVAL_SECONDS, resolveAutostartSettings, schedulerNodeExecutable, WINDOWS_AUTOSTART_TASK_NAME, } from "./autostart-contract.js";
+import { removeWindowsAutostartScripts, syncLauncherProblem, syncScriptProblem, windowsAutostartLauncherPath, windowsAutostartRegistrationScriptPath, windowsAutostartScriptPath, windowsWScriptPath, writeWindowsAutostartScripts, } from "./autostart-windows-scripts.js";
+import { windowsTaskRegistrationProblems } from "./autostart-windows-task-xml.js";
+/**
+ * Installs (or repairs) the scheduled task that runs `cockpit sync` every
+ * `intervalSeconds`, then reads the registration back to say whether Windows
+ * actually agrees — a rewrite that "succeeded" and still disagrees is the
+ * BLI-2996 failure and gets its own log line.
+ */
+export async function installWindowsTask(options) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const settings = resolveAutostartSettings(options, "win32");
+    const intervalMinutes = Math.max(1, Math.ceil(settings.interval_seconds / 60));
+    const node = await schedulerNodeExecutable(options, "win32");
+    const written = await writeWindowsAutostartScripts({
+        homeDir,
+        workDirs: settings.work_dirs,
+        dashboardUrl: settings.dashboard_url,
+        nodeExecutable: node.path,
+        cliEntryPoint: settings.cli_entry_point,
+        intervalMinutes,
+    });
+    const created = await runWindowsRegistrationScript(options.exec, written.registration_path);
+    if (created.code !== 0)
+        reportRegistrationRewriteFailed(created);
+    const verified = created.code === 0
+        ? await windowsTaskStatus({
+            ...options,
+            repoRoot: settings.work_dir,
+            repoRoots: settings.work_dirs,
+            dashboardUrl: settings.dashboard_url,
+            intervalSeconds: intervalMinutes * 60,
+            nodeExecutable: node.path,
+            cliEntryPoint: settings.cli_entry_point,
+        })
+        : null;
+    const loaded = verified?.status === "loaded";
+    if (created.code === 0 && loaded)
+        reportRepairConverged();
+    return {
+        status: "installed",
+        label: AUTOSTART_LABEL,
+        plist_path: written.script_path,
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        registration_path: written.registration_path,
+        loaded,
+        interval_seconds: intervalMinutes * 60,
+        work_dir: settings.work_dir,
+        work_dirs: settings.work_dirs,
+        dashboard_url: settings.dashboard_url,
+        ...(loaded ? {} : { message: installFailureMessage(created, verified) }),
+    };
+}
+/**
+ * Why the install did not converge, in the operator's own terms: the rewrite's
+ * own failure when it never ran, otherwise what the read-back objected to.
+ */
+function installFailureMessage(created, verified) {
+    if (created.code !== 0) {
+        return `PowerShell task registration exited ${created.code}: ${created.stderr.trim() || created.stdout.trim() || "unknown error"}`;
+    }
+    return verified?.message ?? "Windows task registration could not be verified";
+}
+/**
+ * Deletes the scheduled task and the three files it ran. A task that was never
+ * registered still gets its files removed, so the command is safe to repeat.
+ */
+export async function uninstallWindowsTask(options) {
+    const scriptPath = windowsAutostartScriptPath(options.homeDir);
+    const registrationPath = windowsAutostartRegistrationScriptPath(options.homeDir);
+    const current = await windowsTaskStatus(options);
+    if (current.status === "absent") {
+        await removeWindowsAutostartScripts(options.homeDir);
+        return {
+            ...current,
+            plist_path: scriptPath,
+            registration_path: registrationPath,
+        };
+    }
+    const removed = await options.exec("schtasks.exe", [
+        "/Delete",
+        "/TN",
+        WINDOWS_AUTOSTART_TASK_NAME,
+        "/F",
+    ]);
+    if (removed.code === 0) {
+        await removeWindowsAutostartScripts(options.homeDir);
+    }
+    return {
+        status: removed.code === 0 ? "uninstalled" : "not_loaded",
+        label: AUTOSTART_LABEL,
+        plist_path: scriptPath,
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        registration_path: registrationPath,
+        ...(removed.code === 0
+            ? {}
+            : {
+                message: `schtasks /Delete exited ${removed.code}: ${removed.stderr.trim() || removed.stdout.trim() || "unknown error"}`,
+            }),
+    };
+}
+/**
+ * Whether Windows still has the task, still has the files it runs, and still
+ * agrees with the roots and runtime this build would register.
+ */
+export async function windowsTaskStatus(options) {
+    const scriptPath = windowsAutostartScriptPath(options.homeDir);
+    const query = await queryWindowsTaskXml(options.exec);
+    if (query.code !== 0)
+        return windowsTaskQueryFailure(query, scriptPath);
+    const intervalMinutes = Math.max(1, Math.ceil((options.intervalSeconds ?? DEFAULT_AUTOSTART_INTERVAL_SECONDS) / 60));
+    const problems = [
+        ...(isTaskDisabled(query.stdout) ? ["task is disabled"] : []),
+        ...windowsTaskRegistrationProblems(query.stdout, {
+            launcherPath: windowsAutostartLauncherPath(options.homeDir),
+            intervalMinutes,
+            wscriptPath: windowsWScriptPath(),
+        }),
+        ...(await writtenScriptProblems(options)),
+    ];
+    reportWindowsValidation(problems, intervalMinutes);
+    return {
+        status: problems.length > 0 ? "not_loaded" : "loaded",
+        label: AUTOSTART_LABEL,
+        plist_path: scriptPath,
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        ...(problems.length > 0
+            ? { message: `Windows task needs repair: ${problems.join("; ")}` }
+            : {}),
+    };
+}
+/** The sync script first, then its launcher — the order an operator reads them
+ * in the repair message. */
+async function writtenScriptProblems(options) {
+    const problems = [];
+    const scriptProblem = await syncScriptProblem(options);
+    if (scriptProblem)
+        problems.push(scriptProblem);
+    const launcherProblem = await syncLauncherProblem(options);
+    if (launcherProblem)
+        problems.push(launcherProblem);
+    return problems;
+}
+function runWindowsRegistrationScript(exec, registrationPath) {
+    return exec("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        registrationPath,
+    ]);
+}
+function queryWindowsTaskXml(exec) {
+    return exec("schtasks.exe", [
+        "/Query",
+        "/TN",
+        WINDOWS_AUTOSTART_TASK_NAME,
+        "/XML",
+    ]);
+}
+function isTaskDisabled(taskXml) {
+    return /<Enabled>\s*false\s*<\/Enabled>/iu.test(taskXml);
+}
+/**
+ * A task Windows would not show us: absent when it says so in as many words,
+ * otherwise not_loaded — an unreadable task is not a missing one, and treating
+ * it as missing would make a repair create a second registration.
+ */
+function windowsTaskQueryFailure(query, scriptPath) {
+    const queryMessage = `${query.stderr}\n${query.stdout}`;
+    const taskIsKnownAbsent = query.code === 1 &&
+        /cannot find|not found|does not exist/iu.test(queryMessage);
+    // Metadata only: schtasks stderr can carry the state directory, so the exit
+    // code and the classification travel, never the text.
+    console.error("[autostart] windows task query failed", JSON.stringify({
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        exit_code: query.code,
+        status: taskIsKnownAbsent ? "absent" : "not_loaded",
+    }));
+    return {
+        status: taskIsKnownAbsent ? "absent" : "not_loaded",
+        label: AUTOSTART_LABEL,
+        plist_path: scriptPath,
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        message: query.stderr.trim() || query.stdout.trim() || undefined,
+    };
+}
+/**
+ * BLI-2996: before this, a nonzero exit here (schtasks rejected the
+ * registration script, or Set-ScheduledTask threw) skipped straight to the
+ * return with `verified: null` and never logged anything — the doctor row
+ * said "needs repair" every run with no way to tell "the rewrite itself
+ * never ran" apart from "it ran and Windows still disagrees" (BLI-2996,
+ * Brandon's machine: same silent non-convergence under two different
+ * validator messages across CLI versions). Metadata only: exit code and
+ * whether the process produced any output, never the stderr/stdout text
+ * (it can carry the state directory or a workspace path).
+ */
+function reportRegistrationRewriteFailed(created) {
+    console.error("[autostart] windows task repair rewrite failed", JSON.stringify({
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        exit_code: created.code,
+        had_output: Boolean(created.stderr.trim() || created.stdout.trim()),
+    }));
+}
+/**
+ * windowsTaskStatus() already logs the needs-repair case (with the problem
+ * list) when the rewrite ran but the read-back still disagrees; the converged
+ * branch is logged here too, tagged as a repair outcome and by name, so "did
+ * the rewrite actually fix it this run" never depends on inferring it from a
+ * routine status log emitted for an unrelated reason.
+ */
+function reportRepairConverged() {
+    console.error("[autostart] windows task repair converged", JSON.stringify({ task_name: WINDOWS_AUTOSTART_TASK_NAME }));
+}
+/**
+ * Both branches log. A line that only fires on failure cannot answer "did
+ * background collection validate at all today?", which is the question that
+ * would have caught a validator rejecting every healthy Windows task.
+ * Problem labels carry no paths, so they are safe to emit verbatim.
+ */
+function reportWindowsValidation(problems, intervalMinutes) {
+    if (problems.length > 0) {
+        console.error("[autostart] windows task needs repair", JSON.stringify({
+            task_name: WINDOWS_AUTOSTART_TASK_NAME,
+            problem_count: problems.length,
+            problems,
+        }));
+        return;
+    }
+    console.error("[autostart] windows task validated", JSON.stringify({
+        task_name: WINDOWS_AUTOSTART_TASK_NAME,
+        interval_minutes: intervalMinutes,
+    }));
+}

package/dist/autostart-xml.js

@@ -0,0 +1,23 @@
+/**
+ * The two directions of XML text, shared by both host families (BLI-3571).
+ *
+ * The plist writer escapes on the way out; the plist reader and the Task
+ * Scheduler read-back both decode on the way in. Kept as one symmetric pair so
+ * a change to either side is made where its opposite is visible.
+ */
+export function xmlEscape(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+export function decodeXmlEntities(value) {
+    return value
+        .replace(/&quot;/giu, '"')
+        .replace(/&apos;/giu, "'")
+        .replace(/&lt;/giu, "<")
+        .replace(/&gt;/giu, ">")
+        .replace(/&amp;/giu, "&");
+}