@bli-cockpit/cli 0.2.265 → 0.2.266

package/dist/autostart-darwin-plist.js

@@ -126,7 +126,8 @@ export async function readRegisteredDarwinRuntimePaths(homeDir) {
     const command = decodeXmlEntities(plist);
     return {
         node_executable: /node_bin='([^']*)'/u.exec(command)?.[1] ?? null,
-        cli_entry_point: /"\$node_bin" '([^']*)' sync /u.exec(command)?.[1] ?? null,
+        cli_entry_point: /"\$node_bin"(?: --optimize-for-size)? '([^']*)' sync /u.exec(command)?.[1] ?? null,
+        optimize_for_size: /"\$node_bin" '[^']*' sync /u.test(command) ? false : /"\$node_bin" --optimize-for-size '[^']*' sync /u.test(command) ? true : null,
     };
 }
 /**
@@ -222,12 +223,15 @@ function watchPathsBlock(watchPaths) {
         "  </array>",
     ];
 }
+/** The V8 flag the scheduled sync runs node with (BLI-23317). */
+export const NODE_OPTIMIZE_FOR_SIZE_FLAG = "--optimize-for-size";
 function renderDarwinSyncCommand(options) {
+    const nodeFlag = options.optimizeForSize === false ? "" : ` ${NODE_OPTIMIZE_FOR_SIZE_FLAG}`;
     const dashboardArg = isDefaultDashboardUrl(options.dashboardUrl)
         ? ""
         : ` --dashboard-url ${shellQuote(options.dashboardUrl)}`;
     const discoveryArg = options.discoveryArgs.length > 0 ? ` ${options.discoveryArgs.join(" ")}` : "";
-    const commands = options.workDirs.map((root) => `"$node_bin" ${shellQuote(options.cliEntryPoint)} sync --workspace ${shellQuote(root)}${dashboardArg}${discoveryArg} --json || exit_code=1`);
+    const commands = options.workDirs.map((root) => `"$node_bin"${nodeFlag} ${shellQuote(options.cliEntryPoint)} sync --workspace ${shellQuote(root)}${dashboardArg}${discoveryArg} --json || exit_code=1`);
     return [
         "exit_code=0",
         ...darwinNodeResolutionPreamble(options.nodeExecutable),
@@ -278,14 +282,16 @@ function darwinAgentRegistrationProblems(plist, expected) {
     if (!plist.includes(`  <key>ThrottleInterval</key>\n  <integer>${DARWIN_MIN_SECONDS_BETWEEN_TICKS}</integer>`)) {
         problems.push(`minimum gap between ticks is not ${DARWIN_MIN_SECONDS_BETWEEN_TICKS} seconds`);
     }
-    const expectedCommand = renderDarwinSyncCommand({
+    // BLI-23317: the form with --optimize-for-size is what is written; the form without it is still accepted.
+    const matchesCurrentRuntime = [true, false].some((optimizeForSize) => plist.includes(programArgumentsBlock(renderDarwinSyncCommand({
         discoveryArgs: expected.discoveryArgs,
         workDirs: expected.workDirs,
         dashboardUrl: expected.dashboardUrl,
         nodeExecutable: expected.nodeExecutable,
         cliEntryPoint: expected.cliEntryPoint,
-    });
-    if (!plist.includes(programArgumentsBlock(expectedCommand).join("\n"))) {
+        optimizeForSize,
+    })).join("\n")));
+    if (!matchesCurrentRuntime) {
         problems.push("command does not match the current roots, dashboard URL, or Tower runtime");
     }
     return problems;

package/dist/autostart-self-heal.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { autostartStatus, installAutostartAgent, registeredRuntimePathProblems, } from "./autostart.js";
+import { autostartStatus, installAutostartAgent, registeredLauncherUpgradeProblems, registeredRuntimePathProblems, } from "./autostart.js";
 import { detectSecondCockpitInstall, secondInstallReason, } from "./second-install.js";
 import { isAutostartOptedOut } from "./autostart-opt-out.js";
 export const AUTOSTART_REPAIR_THROTTLE_MARKER = ".last-autostart-repair";
@@ -52,6 +52,14 @@ async function readAutostartProblem(paths, options, platform) {
             platform,
         })
         : [];
+    // BLI-23317: an install that still runs node without --optimize-for-size works, so it is not "broken";
+    // it is rewritten once here, on the normal cadence, and logged as its own reason.
+    const upgradeProblems = status.status === "loaded"
+        ? await registeredLauncherUpgradeProblems({ homeDir: options.homeDir, exec: options.exec, platform })
+        : [];
+    if (upgradeProblems.length > 0) {
+        console.error("[autostart-self-heal] registration runs node without --optimize-for-size; rewriting it", JSON.stringify({ reason: "registration_predates_optimize_for_size", platform }));
+    }
     const marker = path.join(paths.state_dir, AUTOSTART_REPAIR_THROTTLE_MARKER);
     // BLI-21564: the reminder job is repaired with the sync agent. A missing or broken reminder job is a
     // problem of its own (an existing install that predates it gets it created here), and the opt-out
@@ -59,7 +67,7 @@ async function readAutostartProblem(paths, options, platform) {
     const remindProblem = status.status === "loaded" && status.remind && status.remind.status !== "loaded" && status.remind.status !== "unsupported"
         ? [`reminder job ${status.remind.status === "absent" ? "absent" : status.remind.message ?? "not loaded"}`]
         : [];
-    if (!absent && status.status !== "not_loaded" && runtimeProblems.length === 0 && remindProblem.length === 0) {
+    if (!absent && status.status !== "not_loaded" && runtimeProblems.length === 0 && upgradeProblems.length === 0 && remindProblem.length === 0) {
         // Healthy is the steady state and stays silent. A marker left by an
         // earlier attempt is spent: that repair worked, so the next break starts
         // fresh instead of waiting out a retry window.
@@ -70,6 +78,7 @@ async function readAutostartProblem(paths, options, platform) {
         ...(absent ? ["registration absent"] : []),
         ...(status.message ? [status.message] : []),
         ...runtimeProblems,
+        ...upgradeProblems,
         ...remindProblem,
     ]
         .join("; ")

package/dist/autostart-windows-scripts.js

@@ -110,6 +110,9 @@ export async function readRegisteredWindowsRuntimePaths(homeDir) {
     return {
         node_executable: /\$nodeExecutable = '([^']*)'/u.exec(script)?.[1] ?? null,
         cli_entry_point: /\$cliEntryPoint = '([^']*)'/u.exec(script)?.[1] ?? null,
+        optimize_for_size: /& \$nodeExecutable --optimize-for-size \$cliEntryPoint sync /u.test(script)
+            ? true
+            : /& \$nodeExecutable \$cliEntryPoint sync /u.test(script) ? false : null,
     };
 }
 /**
@@ -125,15 +128,22 @@ export async function syncScriptProblem(options) {
     if (!options.repoRoots || options.repoRoots.length === 0)
         return null;
     const settings = resolveAutostartSettings(options, "win32");
-    const expected = `${UTF8_BOM}${renderWindowsSyncScript({
+    const onDisk = await readFile(scriptPath, "utf8").catch(() => null);
+    const expectedFor = async (optimizeForSize) => `${UTF8_BOM}${renderWindowsSyncScript({
         discoveryArgs: await savedDiscoveryLimitArgs(options.homeDir),
         workDirs: settings.work_dirs,
         dashboardUrl: settings.dashboard_url,
         nodeExecutable: (await schedulerNodeExecutable(options, "win32")).path,
         cliEntryPoint: settings.cli_entry_point,
         syncLogPath: windowsSyncLogPath(options.homeDir),
+        optimizeForSize,
     })}`;
-    const difference = renderedFileDifference(await readFile(scriptPath, "utf8").catch(() => null), expected);
+    // BLI-23317: the script with --optimize-for-size is what is written; the older one without it is still accepted.
+    const difference = renderedFileDifference(onDisk, await expectedFor(true)) === null
+        ? null
+        : renderedFileDifference(onDisk, await expectedFor(false)) === null
+            ? null
+            : renderedFileDifference(onDisk, await expectedFor(true));
     return difference
         ? `sync script does not match the current roots or Tower runtime (${describeDifference(difference)})`
         : null;
@@ -271,13 +281,14 @@ export function renderWindowsLauncherScript(options) {
     ].join("\r\n");
 }
 function renderWindowsSyncScript(options) {
+    const nodeFlag = options.optimizeForSize === false ? "" : " --optimize-for-size";
     const dashboardArgs = isDefaultDashboardUrl(options.dashboardUrl)
         ? ""
         : ` --dashboard-url ${powershellLiteral(options.dashboardUrl)}`;
     const discoveryArgs = options.discoveryArgs.length > 0 ? ` ${options.discoveryArgs.join(" ")}` : "";
     const commands = options.workDirs.flatMap((root) => [
         "try {",
-        `  & $nodeExecutable $cliEntryPoint sync --workspace ${powershellLiteral(root)}${dashboardArgs}${discoveryArgs} --json 2>&1 | ForEach-Object { "$_" } | Add-Content -LiteralPath $syncLogPath -Encoding UTF8`,
+        `  & $nodeExecutable${nodeFlag} $cliEntryPoint sync --workspace ${powershellLiteral(root)}${dashboardArgs}${discoveryArgs} --json 2>&1 | ForEach-Object { "$_" } | Add-Content -LiteralPath $syncLogPath -Encoding UTF8`,
         "  if ($LASTEXITCODE -ne 0) { $exitCode = $LASTEXITCODE }",
         "} catch {",
         "  Add-Content -LiteralPath $syncLogPath -Encoding UTF8 -Value $_.Exception.Message",

package/dist/autostart.js

@@ -75,7 +75,20 @@ export async function readRegisteredRuntimePaths(options) {
     if (platform === "win32") {
         return readRegisteredWindowsRuntimePaths(options.homeDir);
     }
-    return { node_executable: null, cli_entry_point: null };
+    return { node_executable: null, cli_entry_point: null, optimize_for_size: null };
+}
+/**
+ * BLI-23317: a registration written before `--optimize-for-size` still RUNS, so it is not a broken
+ * registration and `registeredRuntimePathProblems` stays silent about it. The scheduled tick's
+ * self-heal asks this separately so the existing fleet is rewritten to the new form on its normal
+ * cadence instead of waiting for a hand-run `cockpit doctor`.
+ */
+export async function registeredLauncherUpgradeProblems(options) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== (options.hostPlatform ?? process.platform))
+        return [];
+    const registered = await readRegisteredRuntimePaths(options);
+    return registered.optimize_for_size === false ? ["registration predates --optimize-for-size"] : [];
 }
 /**
  * Named problems with the registered runtime, or an empty list. Path-free

package/dist/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+// BLI-23317: first import, so the V8 flag is set before the heavy modules below load.
+import "./optimize-for-size-entry.js";
 import { runCockpitCli } from "./commands/public-root.js";
 import {
   EXIT_DIED_MID_RUN,

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.265");
+    writeLine(io?.stdout ?? process.stdout, "0.2.266");
     return 0;
   }
 

package/dist/image-description-session.js

@@ -207,7 +207,12 @@ async function describeAndReplace(run, input, finds) {
     const deferredOnly = counts.over_budget + counts.backing_off > 0
         && counts.described_now + counts.known + counts.failed + counts.too_large + counts.settled_earlier === 0;
     const replaced = mode === "describe_and_drop" ? finds.swapped(replace) : { replacedCount: 0, charsSaved: 0 };
-    const pendingImages = [...unique.keys()].filter((sha256) => !described.has(imageStateKey(sha256)));
+    // BLI-23317: an image over the describe limit is never sent, so it can never gain a description and
+    // never changes the output. Listing it made the describer look like it still had room, and the
+    // transcript was rebuilt on every tick (rebuilt_describer_has_room). Counted in `too_large` above.
+    const pendingImages = [...unique.values()]
+        .filter((image) => !described.has(imageStateKey(image.sha256)) && image.byteSize <= IMAGE_DESCRIBE_MAX_BYTES)
+        .map((image) => image.sha256);
     console.error(TAG + " transcript prepared", JSON.stringify({
         mode,
         source: input.source,

package/dist/optimize-for-size-entry.js

@@ -0,0 +1,3 @@
+import { applyOptimizeForSize } from "./optimize-for-size.js";
+// Side-effect module: imported FIRST by the CLI entry so the flag is set before the heavy imports load (BLI-23317).
+applyOptimizeForSize();

package/dist/optimize-for-size.js

@@ -0,0 +1,25 @@
+import v8 from "node:v8";
+/**
+ * BLI-23317: run V8 with `--optimize-for-size`. Measured 15-30% lower peak memory with no slowdown on
+ * Node 20-26 (one 200 MB transcript 848 -> 721 MB; CLI floor 113 -> 94 MB). `NODE_OPTIONS` rejects the
+ * flag, so the scheduled launchers pass it on the node command line and a hand-run `cockpit` applies it
+ * here, as the first statement of the entry (`optimize-for-size-entry.ts`, imported before anything heavy).
+ *
+ * Only a refusal is logged: this runs at the start of every command a person types, and a stderr line
+ * on each success would be noise in their terminal. A refusal is logged and ignored, never fatal: the flag is a memory saving, not a requirement.
+ */
+export const OPTIMIZE_FOR_SIZE_FLAG = "--optimize-for-size";
+export function applyOptimizeForSize(options = {}) {
+    const execArgv = options.execArgv ?? process.execArgv;
+    if (execArgv.includes(OPTIMIZE_FOR_SIZE_FLAG)) {
+        return "already_set_by_launcher";
+    }
+    try {
+        (options.setFlags ?? v8.setFlagsFromString)(OPTIMIZE_FOR_SIZE_FLAG);
+        return "applied";
+    }
+    catch (error) {
+        console.error("[optimize-for-size] could not apply the flag; continuing without it", JSON.stringify({ reason: "set_flags_refused", error: error instanceof Error ? error.name : "unknown" }));
+        return "refused";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.265",
+  "version": "0.2.266",
   "private": false,
   "type": "module",
   "bin": {