blun-king-cli 9.1.206 → 9.1.208

package/bin/launcher-runtime.js

@@ -37,6 +37,7 @@ const {
   handoffArgsForMode,
   handoffRuntime,
   prepareRunningUpdate,
+  pruneRunningUpdateReleases,
   readActiveRuntime,
 } = require('./running-update.cjs');
 const {
@@ -418,7 +419,16 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         }
         return { ...nextCore, ready };
       },
-      activateTarget: (target) => (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target),
+      activateTarget: async (target) => {
+        await (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target);
+        try {
+          await (options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(env.BLUN_SHARED_HOME, {
+            activePackageRoot: target.packageRoot,
+          });
+        } catch (error) {
+          options.onRunningUpdateError?.(error);
+        }
+      },
     });
     const resumed = handoff.core;
     if (resumed === undefined || resumed.ready !== true) return 1;

package/bin/running-update.cjs

@@ -7,6 +7,7 @@ const path = require('node:path');
 const { spawn } = require('node:child_process');
 
 const { compareSemver, requestTrustedJson } = require('./update-notice');
+const { tryAcquireUpdateLease } = require('./update-lease');
 const { ensurePrivateDirectory, securePrivateFile, writePrivateFile } = require('./private-paths');
 
 const PACKAGE_NAME = 'blun-king-cli';
@@ -19,6 +20,8 @@ const RUNNING_UPDATE_HANDOFF_MESSAGE = 'blun-running-update-handoff';
 const RUNNING_UPDATE_MODE_MESSAGE = 'blun-running-update-mode';
 const RUNTIME_READY_MESSAGE = 'blun-runtime-session-ready';
 const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
+const AUTO_UPDATE_SETTLE_MS = 30 * 60 * 1000;
+const DEFAULT_RETAINED_RELEASE_VERSIONS = 3;
 
 function ownData(value, key) {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
@@ -37,22 +40,110 @@ function validIntegrity(value) {
   }
 }
 
-function selectRunningUpdateTarget(currentVersion, manifest) {
+function selectRunningUpdateTarget(currentVersion, manifest, options = {}) {
   const name = ownData(manifest, 'name');
   const version = ownData(manifest, 'latest');
   const integrity = ownData(manifest, 'integrity');
   const releasedAt = ownData(manifest, 'releasedAt');
+  const releasedAtMs = Date.parse(releasedAt);
+  const now = options.now || Date.now;
   if (name !== PACKAGE_NAME
     || typeof version !== 'string'
     || compareSemver(currentVersion, version) !== -1
     || !validIntegrity(integrity)
     || typeof releasedAt !== 'string'
-    || !Number.isFinite(Date.parse(releasedAt))) {
+    || !Number.isFinite(releasedAtMs)
+    || now() - releasedAtMs < AUTO_UPDATE_SETTLE_MS) {
     return null;
   }
   return Object.freeze({ version, integrity });
 }
 
+function releaseVersionEntries(sharedHome) {
+  const root = releasesRoot(sharedHome);
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const releases = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+    const version = entry.name;
+    try {
+      if (compareSemver('0.0.0', version) !== -1) continue;
+    } catch {
+      continue;
+    }
+    const versionRoot = path.join(root, version);
+    const digestEntries = fs.readdirSync(versionRoot, { withFileTypes: true });
+    const packageRoots = [];
+    let valid = digestEntries.length > 0;
+    for (const digestEntry of digestEntries) {
+      if (!digestEntry.isDirectory() || digestEntry.isSymbolicLink()) {
+        valid = false;
+        break;
+      }
+      const packageRoot = path.join(versionRoot, digestEntry.name, 'node_modules', PACKAGE_NAME);
+      if (!verifyRuntimePackage(packageRoot, version, { allowedRoot: versionRoot })) {
+        valid = false;
+        break;
+      }
+      packageRoots.push(path.resolve(packageRoot));
+    }
+    if (valid && packageRoots.length > 0) releases.push({ packageRoots, version, versionRoot });
+  }
+  releases.sort((left, right) => compareSemver(right.version, left.version));
+  return releases;
+}
+
+async function pruneRunningUpdateReleases(sharedHome, options = {}) {
+  const keepVersions = Number.isInteger(options.keepVersions) && options.keepVersions >= 1
+    ? options.keepVersions
+    : DEFAULT_RETAINED_RELEASE_VERSIONS;
+  const activePackageRoot = typeof options.activePackageRoot === 'string'
+    ? path.resolve(options.activePackageRoot)
+    : readActiveRuntime(sharedHome)?.packageRoot;
+  const acquire = options.tryAcquireLease
+    || (({ packageRoot }) => tryAcquireUpdateLease({ packageRoot, role: 'install' }));
+  const releases = releaseVersionEntries(sharedHome);
+  const kept = new Set(releases.slice(0, keepVersions).map((release) => release.version));
+  for (const release of releases) {
+    if (release.packageRoots.includes(activePackageRoot)) kept.add(release.version);
+  }
+  const removedVersions = [];
+  const busyVersions = [];
+  for (const release of releases) {
+    if (kept.has(release.version)) continue;
+    const leases = [];
+    let blocked = false;
+    try {
+      for (const packageRoot of release.packageRoots) {
+        const result = await acquire({ packageRoot });
+        if (!result?.acquired || !result.lease) {
+          blocked = true;
+          break;
+        }
+        leases.push(result.lease);
+      }
+      if (blocked) {
+        busyVersions.push(release.version);
+        continue;
+      }
+      for (const lease of leases) lease.assertOwned();
+      fs.rmSync(release.versionRoot, { recursive: true, force: true });
+      removedVersions.push(release.version);
+    } finally {
+      await Promise.allSettled(leases.map((lease) => lease.release()));
+    }
+  }
+  return Object.freeze({
+    busyVersions: Object.freeze(busyVersions),
+    removedVersions: Object.freeze(removedVersions),
+  });
+}
+
 function isSafeRuntimeBoundary(state) {
   return state?.isShuttingDown === false
     && state.streamingPhase === 'idle'
@@ -325,7 +416,7 @@ async function prepareRunningUpdate(options) {
   const manifest = await (options.loadManifest
     ? options.loadManifest()
     : requestTrustedJson(MANIFEST_URL));
-  const target = selectRunningUpdateTarget(options.currentVersion, manifest);
+  const target = selectRunningUpdateTarget(options.currentVersion, manifest, { now: options.now });
   if (target === null) return null;
   const registry = await (options.loadRegistry
     ? options.loadRegistry()
@@ -378,6 +469,7 @@ async function prepareRunningUpdate(options) {
 
 module.exports = {
   ACTIVE_RUNTIME_FILE,
+  AUTO_UPDATE_SETTLE_MS,
   RUNNING_UPDATE_HANDOFF_EXIT_CODE,
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
@@ -390,6 +482,7 @@ module.exports = {
   handoffRuntime,
   isSafeRuntimeBoundary,
   prepareRunningUpdate,
+  pruneRunningUpdateReleases,
   readActiveRuntime,
   resumeArgsForHandoff,
   selectRunningUpdateTarget,

package/bin/telemetry-spool-policy.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+const TELEMETRY_RETRY_MAX_FILES = 16;
+const TELEMETRY_SPOOL_MAX_FILES = 512;
+const TELEMETRY_SPOOL_MAX_BYTES = 16 * 1024 * 1024;
+const TELEMETRY_SPOOL_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+function isFailedTelemetryEntry(entry) {
+  return entry !== null
+    && typeof entry === 'object'
+    && /^failed_[^.]+\.jsonl$/u.test(entry.name ?? '')
+    && Number.isFinite(entry.mtimeMs)
+    && Number.isFinite(entry.size)
+    && entry.size >= 0;
+}
+
+function oldestFirst(left, right) {
+  return left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name);
+}
+
+function newestFirst(left, right) {
+  return right.mtimeMs - left.mtimeMs || right.name.localeCompare(left.name);
+}
+
+function selectTelemetryRetryEntries(entries, maxFiles = TELEMETRY_RETRY_MAX_FILES) {
+  if (!Number.isSafeInteger(maxFiles) || maxFiles < 0) return [];
+  return entries.filter(isFailedTelemetryEntry).sort(oldestFirst).slice(0, maxFiles);
+}
+
+function selectTelemetrySpoolPruneEntries(entries, now = Date.now()) {
+  const failed = entries.filter(isFailedTelemetryEntry);
+  const expired = failed.filter((entry) => now - entry.mtimeMs > TELEMETRY_SPOOL_MAX_AGE_MS);
+  const expiredNames = new Set(expired.map((entry) => entry.name));
+  const live = failed.filter((entry) => !expiredNames.has(entry.name)).sort(newestFirst);
+  const keptNames = new Set();
+  let keptBytes = 0;
+
+  for (const entry of live) {
+    if (keptNames.size >= TELEMETRY_SPOOL_MAX_FILES) continue;
+    if (keptBytes + entry.size > TELEMETRY_SPOOL_MAX_BYTES) continue;
+    keptNames.add(entry.name);
+    keptBytes += entry.size;
+  }
+
+  return failed
+    .filter((entry) => expiredNames.has(entry.name) || !keptNames.has(entry.name))
+    .sort(oldestFirst);
+}
+
+module.exports = {
+  TELEMETRY_RETRY_MAX_FILES,
+  TELEMETRY_SPOOL_MAX_AGE_MS,
+  TELEMETRY_SPOOL_MAX_BYTES,
+  TELEMETRY_SPOOL_MAX_FILES,
+  selectTelemetryRetryEntries,
+  selectTelemetrySpoolPruneEntries,
+};

package/blun.mjs

@@ -328163,6 +328163,10 @@ const RETRY_BACKOFFS_MS = [
 	16e3
 ];
 const DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+const {
+	selectTelemetryRetryEntries,
+	selectTelemetrySpoolPruneEntries
+} = createRequire(import.meta.url)("./bin/telemetry-spool-policy.cjs");
 var AsyncTransport = class {
 	homeDir;
 	deviceId;
@@ -328173,6 +328177,7 @@ var AsyncTransport = class {
 	requestTimeoutMs;
 	sleepImpl;
 	now;
+	spoolWritesSincePrune = 0;
 	constructor(options) {
 		this.homeDir = options.homeDir;
 		this.deviceId = options.deviceId;
@@ -328235,26 +328240,44 @@ var AsyncTransport = class {
 		try {
 			chmodSync(path, 384);
 		} catch {}
+		this.spoolWritesSincePrune += 1;
+		if (this.spoolWritesSincePrune === 1 || this.spoolWritesSincePrune >= 64) {
+			this.pruneDiskSpool();
+			this.spoolWritesSincePrune = 0;
+		}
 	}
-	async retryDiskEvents() {
-		let entries;
+	readSpoolEntries() {
+		let names;
 		try {
-			entries = readdirSync(this.telemetryDir());
+			names = readdirSync(this.telemetryDir());
 		} catch {
-			return;
+			return [];
 		}
-		const now = this.now();
-		for (const entry of entries) {
-			if (!entry.startsWith("failed_") || !entry.endsWith(".jsonl")) continue;
-			const path = join(this.telemetryDir(), entry);
+		const entries = [];
+		for (const name of names) {
+			if (!name.startsWith("failed_") || !name.endsWith(".jsonl")) continue;
+			const path = join(this.telemetryDir(), name);
 			try {
-				if (now - statSync(path).mtimeMs > 6048e5) {
-					unlinkSync(path);
-					continue;
-				}
-			} catch {
-				continue;
-			}
+				const stats = statSync(path);
+				entries.push({ name, mtimeMs: stats.mtimeMs, size: stats.size });
+			} catch {}
+		}
+		return entries;
+	}
+	pruneDiskSpool(spoolEntries = this.readSpoolEntries()) {
+		const pruned = selectTelemetrySpoolPruneEntries(spoolEntries, this.now());
+		for (const entry of pruned) try {
+			unlinkSync(join(this.telemetryDir(), entry.name));
+		} catch {}
+		return new Set(pruned.map((entry) => entry.name));
+	}
+	async retryDiskEvents() {
+		const spoolEntries = this.readSpoolEntries();
+		const prunedNames = this.pruneDiskSpool(spoolEntries);
+		const retryEntries = selectTelemetryRetryEntries(spoolEntries
+			.filter((entry) => !prunedNames.has(entry.name)));
+		for (const entry of retryEntries) {
+			const path = join(this.telemetryDir(), entry.name);
 			let events;
 			let payload;
 			try {
@@ -328270,7 +328293,7 @@ var AsyncTransport = class {
 				await this.sendHttp(payload);
 				unlinkSync(path);
 			} catch (error) {
-				if (error instanceof TransientTelemetryError) continue;
+				if (error instanceof TransientTelemetryError) break;
 			}
 		}
 	}
@@ -515013,12 +515036,14 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 //#endregion
 //#region src/tui/blun-tui.ts
 const {
+	AUTO_UPDATE_SETTLE_MS,
 	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
 	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
 	RUNTIME_READY_MESSAGE,
-	isSafeRuntimeBoundary
+	isSafeRuntimeBoundary,
+	pruneRunningUpdateReleases
 } = __require("./bin/running-update.cjs");
 const {
 	RUNNING_UPDATE_MODES,
@@ -515026,6 +515051,9 @@ const {
 	writeRunningUpdateMode
 } = __require("./bin/running-update-preference.cjs");
 function notifyRunningRuntimeReady(tui) {
+	if (typeof process.env["BLUN_SHARED_HOME"] === "string" && process.env["BLUN_SHARED_HOME"].length > 0) void pruneRunningUpdateReleases(process.env["BLUN_SHARED_HOME"], {
+		activePackageRoot: __dirname
+	}).catch(() => {});
 	if (!process.connected) return;
 	const sessionId = tui.getCurrentSessionId();
 	if (sessionId.length === 0) return;
@@ -515038,6 +515066,17 @@ function notifyRunningRuntimeReady(tui) {
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
 	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdatePreparedMode === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
+	const waitMs = tui.runningUpdateNotBeforeMs - Date.now();
+	if (Number.isFinite(waitMs) && waitMs > 0) {
+		if (tui.runningUpdateDelayTimer === void 0) {
+			tui.runningUpdateDelayTimer = setTimeout(() => {
+				tui.runningUpdateDelayTimer = void 0;
+				requestRunningUpdateAtSafeBoundary(tui);
+			}, waitMs);
+			tui.runningUpdateDelayTimer.unref?.();
+		}
+		return false;
+	}
 	const boundaryState = () => ({
 		isShuttingDown: tui.isShuttingDown,
 		streamingPhase: tui.state.appState.streamingPhase,
@@ -515168,6 +515207,8 @@ var BlunTUI = class {
 	runningUpdatePreparedVersion;
 	runningUpdatePreparedMode;
 	runningUpdateHandoffStarted = false;
+	runningUpdateNotBeforeMs = Date.now() + AUTO_UPDATE_SETTLE_MS;
+	runningUpdateDelayTimer;
 	runningUpdateMessageDispose;
 	startupPhaseMs = {};
 	lastActivityMode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.206",
+  "version": "9.1.208",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {