blun-king-cli 9.1.459 → 9.1.461

package/bin/session-resume-checkpoint.cjs

@@ -4,7 +4,7 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 
-const RESUME_CHECKPOINT_SCHEMA_VERSION = 1;
+const RESUME_CHECKPOINT_SCHEMA_VERSION = 2;
 const MAX_RESUME_SNAPSHOT_BYTES = 4 * 1024 * 1024;
 const MAX_RESUME_CHECKPOINT_BYTES = MAX_RESUME_SNAPSHOT_BYTES + 256 * 1024;
 const WIRE_SAMPLE_BYTES = 4096;

package/bin/session-scrollback-archive.cjs

@@ -0,0 +1,206 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ARCHIVE_SCHEMA_VERSION = 1;
+const INDEX_FILE = 'index.json';
+
+function sessionScrollbackArchiveDirectory(wirePath) {
+  return path.join(path.dirname(wirePath), 'tui-scrollback-v1');
+}
+
+function isNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function writeAtomic(filePath, value) {
+  const temporaryPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  try {
+    fs.writeFileSync(temporaryPath, value, {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: 0o600,
+    });
+    fs.renameSync(temporaryPath, filePath);
+  } finally {
+    try {
+      fs.rmSync(temporaryPath, { force: true });
+    } catch {}
+  }
+}
+
+class SessionScrollbackArchive {
+  constructor({ directory, reset = false, reuse = false }) {
+    if (typeof directory !== 'string' || directory.length === 0) {
+      throw new TypeError('session scrollback directory is required');
+    }
+    this.directory = path.resolve(directory);
+    this.chunks = [];
+    this.loadedChunks = new Map();
+    this.lineCount = 0;
+    this.loadedExisting = false;
+
+    if (reset) {
+      this.reset();
+    } else if (reuse) {
+      this.loadExisting();
+    }
+  }
+
+  get totalLines() {
+    return this.lineCount;
+  }
+
+  get loadedChunkCount() {
+    return this.loadedChunks.size;
+  }
+
+  append(lines) {
+    if (!Array.isArray(lines) || !lines.every((line) => typeof line === 'string')) {
+      return false;
+    }
+    if (lines.length === 0) return true;
+
+    fs.mkdirSync(this.directory, { recursive: true });
+    const file = `chunk-${String(this.chunks.length).padStart(8, '0')}-${crypto.randomBytes(6).toString('hex')}.json`;
+    const chunkPath = path.join(this.directory, file);
+    const chunk = {
+      file,
+      startLine: this.lineCount,
+      lineCount: lines.length,
+    };
+
+    try {
+      writeAtomic(chunkPath, JSON.stringify(lines));
+      const nextChunks = [...this.chunks, chunk];
+      const nextLineCount = this.lineCount + lines.length;
+      this.writeIndex(nextChunks, nextLineCount);
+      this.chunks = nextChunks;
+      this.lineCount = nextLineCount;
+      return true;
+    } catch {
+      try {
+        fs.rmSync(chunkPath, { force: true });
+      } catch {}
+      return false;
+    }
+  }
+
+  readRange(start, end) {
+    if (!Number.isFinite(start) || !Number.isFinite(end)) return [];
+    if (start >= end || start >= this.lineCount) return [];
+    const boundedStart = Math.max(0, Math.floor(start));
+    const boundedEnd = Math.min(this.lineCount, Math.floor(end));
+    const output = [];
+
+    for (let index = 0; index < this.chunks.length; index++) {
+      const chunk = this.chunks[index];
+      const chunkEnd = chunk.startLine + chunk.lineCount;
+      if (chunkEnd <= boundedStart) continue;
+      if (chunk.startLine >= boundedEnd) break;
+      const lines = this.readChunk(index);
+      const sliceStart = Math.max(0, boundedStart - chunk.startLine);
+      const sliceEnd = Math.min(lines.length, boundedEnd - chunk.startLine);
+      output.push(...lines.slice(sliceStart, sliceEnd));
+    }
+    return output;
+  }
+
+  reset() {
+    try {
+      fs.rmSync(this.directory, { recursive: true, force: true });
+    } catch {}
+    this.chunks = [];
+    this.loadedChunks.clear();
+    this.lineCount = 0;
+    this.loadedExisting = false;
+  }
+
+  clear() {
+    this.reset();
+  }
+
+  dispose() {
+    this.loadedChunks.clear();
+  }
+
+  loadExisting() {
+    const indexPath = path.join(this.directory, INDEX_FILE);
+    try {
+      const parsed = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+      if (
+        parsed?.schemaVersion !== ARCHIVE_SCHEMA_VERSION
+        || !isNonNegativeInteger(parsed.totalLines)
+        || !Array.isArray(parsed.chunks)
+      ) {
+        return;
+      }
+
+      let nextLine = 0;
+      const chunks = [];
+      for (const candidate of parsed.chunks) {
+        if (
+          typeof candidate?.file !== 'string'
+          || path.basename(candidate.file) !== candidate.file
+          || !candidate.file.startsWith('chunk-')
+          || !candidate.file.endsWith('.json')
+          || candidate.startLine !== nextLine
+          || !Number.isSafeInteger(candidate.lineCount)
+          || candidate.lineCount <= 0
+        ) {
+          return;
+        }
+        const chunkPath = path.join(this.directory, candidate.file);
+        if (!fs.statSync(chunkPath).isFile()) return;
+        chunks.push({
+          file: candidate.file,
+          startLine: candidate.startLine,
+          lineCount: candidate.lineCount,
+        });
+        nextLine += candidate.lineCount;
+      }
+      if (nextLine !== parsed.totalLines) return;
+
+      this.chunks = chunks;
+      this.lineCount = parsed.totalLines;
+      this.loadedExisting = true;
+    } catch {}
+  }
+
+  readChunk(index) {
+    const loaded = this.loadedChunks.get(index);
+    if (loaded !== undefined) return loaded;
+    const chunk = this.chunks[index];
+    if (chunk === undefined) return [];
+    try {
+      const value = JSON.parse(fs.readFileSync(path.join(this.directory, chunk.file), 'utf8'));
+      if (
+        !Array.isArray(value)
+        || value.length !== chunk.lineCount
+        || !value.every((line) => typeof line === 'string')
+      ) {
+        return [];
+      }
+      this.loadedChunks.set(index, value);
+      return value;
+    } catch {
+      return [];
+    }
+  }
+
+  writeIndex(chunks, totalLines) {
+    writeAtomic(path.join(this.directory, INDEX_FILE), JSON.stringify({
+      schemaVersion: ARCHIVE_SCHEMA_VERSION,
+      totalLines,
+      chunks,
+    }));
+  }
+}
+
+module.exports = {
+  ARCHIVE_SCHEMA_VERSION,
+  SessionScrollbackArchive,
+  sessionScrollbackArchiveDirectory,
+};

package/bin/telegram-console-status-policy.cjs

@@ -7,6 +7,7 @@ const STATUS_FILE = 'telegram-console-status.json';
 const MAX_STATUS_BYTES = 16_384;
 const MAX_TASK_CHARS = 240;
 const MAX_TOOL_NAME_CHARS = 80;
+const MAX_VERSION_CHARS = 80;
 
 function validInstant(value) {
   if (typeof value !== 'string' || value.length === 0) return undefined;
@@ -25,6 +26,16 @@ function boundedToolName(value) {
   return name.length > 0 ? name.slice(0, MAX_TOOL_NAME_CHARS) : undefined;
 }
 
+function boundedVersion(value) {
+  if (typeof value !== 'string') return undefined;
+  const version = value.trim();
+  return version.length > 0
+    && version.length <= MAX_VERSION_CHARS
+    && /^[0-9A-Za-z][0-9A-Za-z.+-]*$/u.test(version)
+    ? version
+    : undefined;
+}
+
 function instantFromMilliseconds(value) {
   if (!Number.isFinite(value) || value < 0) return undefined;
   try {
@@ -54,6 +65,7 @@ function buildTurnDiagnostics(turnActive, activity) {
 
 function buildTelegramConsoleStatus(input = {}) {
   const capturedAt = validInstant(input.capturedAt);
+  const loadedVersion = boundedVersion(input.loadedVersion);
   const processStartedAt = validInstant(input.processStartedAt);
   const pid = Number.isSafeInteger(input.pid) && input.pid > 1 ? input.pid : undefined;
   const step = Number.isSafeInteger(input.step) && input.step >= 0 ? input.step : 0;
@@ -66,6 +78,7 @@ function buildTelegramConsoleStatus(input = {}) {
     : undefined;
   return {
     version: 1,
+    ...(loadedVersion === undefined ? {} : { loadedVersion }),
     pid,
     capturedAt,
     processStartedAt,
@@ -88,6 +101,8 @@ function parseTelegramConsoleStatus(value, options = {}) {
         || typeof parsed.turnActive !== 'boolean'
         || !Number.isSafeInteger(parsed.step) || parsed.step < 0) return undefined;
     const activeTask = boundedTask(parsed.activeTask);
+    const hasLoadedVersion = Object.hasOwn(parsed, 'loadedVersion');
+    const loadedVersion = boundedVersion(parsed.loadedVersion);
     const hasTurnStartedAt = Object.hasOwn(parsed, 'turnStartedAt');
     const hasLastProgressAt = Object.hasOwn(parsed, 'lastProgressAt');
     const hasLastToolName = Object.hasOwn(parsed, 'lastToolName');
@@ -96,7 +111,8 @@ function parseTelegramConsoleStatus(value, options = {}) {
     const lastProgressAt = validInstant(parsed.lastProgressAt);
     const lastToolName = boundedToolName(parsed.lastToolName);
     const failedRepetitions = parsed.failedRepetitions;
-    if ((hasTurnStartedAt && turnStartedAt === undefined)
+    if ((hasLoadedVersion && loadedVersion === undefined)
+        || (hasTurnStartedAt && turnStartedAt === undefined)
         || (hasLastProgressAt && lastProgressAt === undefined)
         || (hasLastToolName && lastToolName === undefined)
         || (hasFailedRepetitions && (!Number.isSafeInteger(failedRepetitions)
@@ -109,6 +125,7 @@ function parseTelegramConsoleStatus(value, options = {}) {
     } : {};
     return {
       version: 1,
+      ...(loadedVersion === undefined ? {} : { loadedVersion }),
       pid: parsed.pid,
       capturedAt: parsed.capturedAt,
       processStartedAt: parsed.processStartedAt,

package/bin/telegram-remote-status-policy.cjs

@@ -13,6 +13,16 @@ function resolveTelegramRemoteVersion(input = {}) {
     || 'unbekannt';
 }
 
+function resolveVersionDisplay(input = {}) {
+  const loaded = trustedVersion(input.consoleStatus?.loadedVersion)
+    || trustedVersion(input.version)
+    || 'unbekannt';
+  const installed = trustedVersion(input.installedVersion);
+  return installed !== undefined && installed !== loaded
+    ? `${loaded} -> ${installed}`
+    : loaded;
+}
+
 function formatDuration(seconds) {
   const minutes = Math.max(0, Math.floor(Number(seconds) / 60));
   if (minutes < 60) return `${minutes} min`;
@@ -89,7 +99,7 @@ function buildTelegramRemoteStatus(input) {
   return [
     `BLUN-Fernstatus für ${username}`,
     `Rechner: ${input.machineName || 'unbekannt'}`,
-    `Version: ${input.version || 'unbekannt'}`,
+    `Version: ${resolveVersionDisplay(input)}`,
     `Brücke: aktiv (PID ${input.bridgePid}, ${formatDuration(input.bridgeUptimeSeconds)})`,
     `Konsole: ${tui}`,
     `Zustellung: ${delivery}`,

package/blun.mjs

@@ -12,6 +12,7 @@ import runtimeExitLedger from "./bin/runtime-exit-ledger.cjs";
 import compactionModelPolicy from "./bin/compaction-model-policy.cjs";
 import agentResumeSnapshot from "./bin/agent-resume-snapshot.cjs";
 import sessionResumeCheckpoint from "./bin/session-resume-checkpoint.cjs";
+import sessionScrollbackArchive from "./bin/session-scrollback-archive.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs$16 from "node:fs";
 import Kt, { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -48,6 +49,7 @@ const { recordRuntimeExit } = runtimeExitLedger;
 const { resolveCompactionModelAlias } = compactionModelPolicy;
 const { createAgentResumeSnapshot, restoreAgentResumeSnapshot } = agentResumeSnapshot;
 const { loadResumeCheckpoint, writeResumeCheckpoint } = sessionResumeCheckpoint;
+const { SessionScrollbackArchive, sessionScrollbackArchiveDirectory } = sessionScrollbackArchive;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -235236,6 +235238,7 @@ var init_records = __esmMin((() => {
 		persistence;
 		_restoring = null;
 		metadataInitialized = false;
+		resumeCheckpointRestored = false;
 		messageTimes = new WeakMap();
 		constructor(agent, persistence) {
 			this.agent = agent;
@@ -235274,6 +235277,7 @@ var init_records = __esmMin((() => {
 		}
 		async replay(options = {}) {
 			if (!this.persistence) throw new Error("No persistence provided for AgentRecords");
+			this.resumeCheckpointRestored = false;
 			const rewriteMigratedRecords = options.rewriteMigratedRecords ?? true;
 			if (rewriteMigratedRecords && await this.tryReplayResumeCheckpoint()) return {};
 			let migrations = [];
@@ -235331,6 +235335,7 @@ var init_records = __esmMin((() => {
 			}
 			this.persistence.persistedRecordCount = checkpoint.recordCount + tailRecordCount;
 			if (this.agent.blobStore !== void 0) for (const msg of this.agent.context.history) await this.agent.blobStore.rehydrateParts(msg.content);
+			this.resumeCheckpointRestored = true;
 			return true;
 		}
 		async writeResumeCheckpoint() {
@@ -316822,6 +316827,8 @@ async function resumeSessionResult(summary, session, warning) {
 		const usage = await api.getUsage({ agentId });
 		agents[agentId] = {
 			type: agent.type,
+			resumeCheckpointRestored: agent.records.resumeCheckpointRestored === true,
+			sessionWirePath: agent.records.persistence instanceof FileSystemAgentRecordPersistence ? agent.records.persistence.filePath : void 0,
 			config,
 			context,
 			replay: agent.replayBuilder.buildResult(),
@@ -341013,6 +341020,14 @@ function getVersion() {
 	if (BLUN_BUILD_INFO.version !== void 0) return BLUN_BUILD_INFO.version;
 	return JSON.parse(readFileSync(getHostPackageJsonPath(), "utf-8")).version;
 }
+function getInstalledPackageVersion() {
+	try {
+		const version = JSON.parse(readFileSync(getHostPackageJsonPath(), "utf-8")).version;
+		return typeof version === "string" && version.trim().length > 0 ? version.trim() : void 0;
+	} catch {
+		return void 0;
+	}
+}
 function createBlunHostIdentity(version = getVersion()) {
 	return {
 		userAgentProduct: CLI_USER_AGENT_PRODUCT,
@@ -417979,6 +417994,10 @@ function buildStatusReportLines(options) {
 			value: sessionId
 		}
 	];
+	if (options.installedVersion !== void 0 && options.installedVersion !== options.version) rows.push({
+		label: uiText("status.label.warning"),
+		value: uiText("plugins.market.status.installedVersion", { version: options.installedVersion })
+	});
 	const title = options.sessionTitle?.trim();
 	if (title !== void 0 && title.length > 0) rows.push({
 		label: uiText("status.label.title"),
@@ -418875,6 +418894,7 @@ async function showStatusReport(host) {
 	const appState = host.state.appState;
 	const reportArgs = {
 		version: appState.version,
+		installedVersion: getInstalledPackageVersion(),
 		model: appState.model,
 		workDir: appState.workDir,
 		sessionId: appState.sessionId,
@@ -506093,6 +506113,27 @@ var ScrollbackBuffer = class {
 	archiveLines(lines) {
 		return this.archive.append(lines);
 	}
+	usePersistentArchive(directory, options) {
+		this.releaseArchive();
+		const archive = new SessionScrollbackArchive({
+			directory,
+			reset: options.reset,
+			reuse: options.reuse
+		});
+		this.archive = archive;
+		return archive.loadedExisting;
+	}
+	releaseArchive() {
+		if (this.archive instanceof DiskBackedLineArchive) this.archive.clear();
+		else this.archive.dispose();
+		this.archive = new DiskBackedLineArchive();
+		this.resetViewState();
+	}
+	dispose() {
+		if (this.archive instanceof DiskBackedLineArchive) this.archive.clear();
+		else this.archive.dispose();
+		this.resetViewState();
+	}
 	activate() {
 		this.active = true;
 		this.scrollOffset = 0;
@@ -506103,6 +506144,9 @@ var ScrollbackBuffer = class {
 	}
 	clear() {
 		this.archive.clear();
+		this.resetViewState();
+	}
+	resetViewState() {
 		this.snapshotLines = [];
 		this.publishedLineCount = 0;
 		this.deactivate();
@@ -506414,6 +506458,7 @@ var ScrollbackController = class {
 	state;
 	buffer;
 	disposeListener;
+	suppressReplayArchiveWrites = false;
 	constructor(state) {
 		this.state = state;
 	}
@@ -506428,16 +506473,52 @@ var ScrollbackController = class {
 	dispose() {
 		this.disposeListener?.();
 		this.disposeListener = void 0;
-		this.buffer?.clear();
+		this.buffer?.dispose();
 		if (this.state.ui instanceof BottomPinnedTUI) this.state.ui.scrollbackBuffer = void 0;
 		this.buffer = void 0;
 	}
 	reset() {
 		this.buffer?.clear();
+		this.suppressReplayArchiveWrites = false;
+	}
+	releaseSessionArchive() {
+		this.buffer?.releaseArchive();
+		this.suppressReplayArchiveWrites = false;
+	}
+	prepareNewSession(session) {
+		const sessionDirectory = session?.summary?.sessionDir;
+		if (typeof sessionDirectory !== "string" || sessionDirectory.length === 0) return false;
+		const wirePath = path.join(sessionDirectory, "agents", "main", "wire.jsonl");
+		this.buffer?.usePersistentArchive(sessionScrollbackArchiveDirectory(wirePath), {
+			reset: true,
+			reuse: false
+		});
+		this.suppressReplayArchiveWrites = false;
+		return true;
+	}
+	prepareSessionReplay(agent) {
+		const buffer = this.buffer;
+		if (buffer === void 0) return false;
+		const persistence = agent?.records?.persistence;
+		let directory;
+		if (typeof persistence?.filePath === "string") directory = sessionScrollbackArchiveDirectory(persistence.filePath);
+		else if (typeof agent?.sessionWirePath === "string") directory = sessionScrollbackArchiveDirectory(agent.sessionWirePath);
+		else return false;
+		const resumeCheckpointRestored = agent?.records?.resumeCheckpointRestored === true || agent?.resumeCheckpointRestored === true;
+		const loadedExisting = buffer.usePersistentArchive(directory, {
+			reset: !resumeCheckpointRestored,
+			reuse: resumeCheckpointRestored
+		});
+		this.suppressReplayArchiveWrites = resumeCheckpointRestored && loadedExisting;
+		return true;
+	}
+	finishSessionReplay() {
+		this.suppressReplayArchiveWrites = false;
 	}
 	archiveComponents(components) {
 		const buffer = this.buffer;
 		if (buffer === void 0 || components.length === 0) return components.length === 0;
+		if (this.suppressReplayArchiveWrites && this.state.appState.isReplaying) return true;
 		try {
 			const width = Math.max(1, this.state.terminal.columns);
 			const lines = components.flatMap((component) => component.render(width));
@@ -509723,6 +509804,7 @@ var SessionReplayRenderer = class {
 				this.host.showError(uiText("replay.error.unavailable"));
 				return false;
 			}
+			this.host.scrollbackController.prepareSessionReplay(main);
 			this.hydrateSnapshot(main);
 			await this.renderRecords(main);
 			this.applyTerminalBackgroundAgentStatuses(main);
@@ -509734,6 +509816,7 @@ var SessionReplayRenderer = class {
 			this.host.showError(uiText("replay.error.failed", { error: message }));
 			return false;
 		} finally {
+			this.host.scrollbackController.finishSessionReplay();
 			this.host.setAppState({ isReplaying: false });
 		}
 	}
@@ -511539,6 +511622,7 @@ var StreamingUIController = class {
 			writeTelegramConsoleStatus({
 				directory: telegramStateDir(),
 				capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				loadedVersion: this.host.state.appState.version,
 				pid: process.pid,
 				processStartedAt: this._remoteProcessStartedAt,
 				step: this._currentStep,
@@ -516940,7 +517024,7 @@ var BlunTUI = class {
 		if (shouldReplayHistory) {
 			await this.sessionReplay.hydrateFromReplay(this.requireSession());
 			this.applyStartupPermissionAndPlanToAppState();
-		}
+		} else if (this.session !== void 0) this.scrollbackController.prepareNewSession(this.session);
 		const resumeState = this.session?.getResumeState();
 		if (resumeState?.warning !== void 0) this.showStatus(uiText("blunTui.warning", { warning: resumeState.warning }), "warning");
 		if (this.session !== void 0) {
@@ -518902,7 +518986,7 @@ var BlunTUI = class {
 			await this.refreshSkillCommands(this.session);
 			await this.refreshPluginCommands(this.session);
 		} catch {}
-		this.clearTranscriptAndRedraw();
+		this.clearTranscriptAndRedraw({ preserveScrollbackArchive: true });
 		try {
 			await this.sessionReplay.hydrateFromReplay(session);
 		} catch (error) {
@@ -518974,7 +519058,8 @@ var BlunTUI = class {
 			await this.refreshPluginCommands(this.session);
 		} catch {}
 		this.sessionEventHandler.startSubscription();
-		this.clearTranscriptAndRedraw();
+		this.clearTranscriptAndRedraw({ preserveScrollbackArchive: true });
+		this.scrollbackController.prepareNewSession(session);
 		this.showStatus(uiText("blunTui.session.started", { sessionId: session.id }));
 		this.showSessionWarnings(session);
 		this.showConfigWarningsIfAny();
@@ -519090,9 +519175,10 @@ var BlunTUI = class {
 	disposeTranscriptChildren() {
 		for (const child of this.state.transcriptContainer.children) if (hasDispose(child)) child.dispose();
 	}
-	clearTranscriptAndRedraw() {
+	clearTranscriptAndRedraw(options = {}) {
 		this.streamingUI.discardPending();
-		this.scrollbackController.reset();
+		if (options.preserveScrollbackArchive === true) this.scrollbackController.releaseSessionArchive();
+		else this.scrollbackController.reset();
 		this.state.transcriptEntries = [];
 		this.streamingUI.disposeActiveCompactionBlock();
 		this.streamingUI.resetLiveText();

package/package.json

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

package/telegram-plugin/dist/bridge.mjs

@@ -4809,6 +4809,7 @@ bot.command("status", async (ctx) => {
 			queueCheckpointAt,
 			queueUnreadBytes: queueSnapshot.unreadBytes,
 			senderId,
+			installedVersion: version,
 			tuiFresh: isTuiLeaseFresh(),
 			tuiHeartbeatAt,
 			tuiPid: Number.isInteger(tuiPid) ? tuiPid : void 0,