blun-king-cli 9.1.284 → 9.1.286

package/bin/input-draft-persistence.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const MAX_INPUT_DRAFT_BYTES = 64 * 1024;
+const MAX_INPUT_DRAFT_FILE_BYTES = MAX_INPUT_DRAFT_BYTES + 1024;
+const SCHEMA_VERSION = 1;
+const VALID_MODES = new Set(['bash', 'prompt']);
+
+function normalizeInputDraft(value) {
+  if (!value || typeof value !== 'object') return null;
+  if (!VALID_MODES.has(value.mode) || typeof value.text !== 'string') return null;
+  if (value.text.length === 0) return null;
+  if (Buffer.byteLength(value.text, 'utf8') > MAX_INPUT_DRAFT_BYTES) return null;
+  return { mode: value.mode, text: value.text };
+}
+
+async function clearInputDraft(filePath) {
+  await fs.rm(path.resolve(filePath), { force: true });
+}
+
+async function readInputDraft(filePath) {
+  const target = path.resolve(filePath);
+  try {
+    const stat = await fs.lstat(target);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_INPUT_DRAFT_FILE_BYTES) return null;
+    const record = JSON.parse(await fs.readFile(target, 'utf8'));
+    if (record?.schemaVersion !== SCHEMA_VERSION) return null;
+    return normalizeInputDraft(record);
+  } catch {
+    return null;
+  }
+}
+
+async function writeInputDraft(filePath, value) {
+  const target = path.resolve(filePath);
+  const text = typeof value?.text === 'string' ? value.text : '';
+  if (Buffer.byteLength(text, 'utf8') > MAX_INPUT_DRAFT_BYTES) {
+    await clearInputDraft(target);
+    throw new Error('draft_too_large');
+  }
+  if (text.length === 0) {
+    await clearInputDraft(target);
+    return;
+  }
+  const draft = normalizeInputDraft(value);
+  if (draft === null) throw new Error('draft_invalid');
+
+  const directory = path.dirname(target);
+  const temporary = path.join(
+    directory,
+    `.${path.basename(target)}.${process.pid}.${crypto.randomUUID()}.tmp`,
+  );
+  await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  try {
+    await fs.writeFile(
+      temporary,
+      `${JSON.stringify({ schemaVersion: SCHEMA_VERSION, ...draft })}\n`,
+      { encoding: 'utf8', flag: 'wx', mode: 0o600 },
+    );
+    await fs.rename(temporary, target);
+    await fs.chmod(target, 0o600).catch(() => {});
+  } catch (error) {
+    await fs.rm(temporary, { force: true }).catch(() => {});
+    throw error;
+  }
+}
+
+module.exports = {
+  MAX_INPUT_DRAFT_BYTES,
+  clearInputDraft,
+  normalizeInputDraft,
+  readInputDraft,
+  writeInputDraft,
+};

package/bin/model-retry-progress-policy.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+const MAX_MODEL_RETRY_HINT_CHARS = 32;
+const MAX_MODEL_RETRY_ATTEMPTS = 99;
+const MAX_MODEL_RETRY_DELAY_MS = 600_000;
+
+function boundedInteger(value, minimum, maximum, fallback) {
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(maximum, Math.max(minimum, Math.trunc(value)));
+}
+
+function formatRetryDelay(delayMs) {
+  const bounded = boundedInteger(delayMs, 0, MAX_MODEL_RETRY_DELAY_MS, 0);
+  if (bounded === 0) return '';
+  if (bounded < 1_000) return `${bounded}ms`;
+  return `${Math.ceil(bounded / 100) / 10}s`;
+}
+
+function formatModelRetryProgress(event = {}) {
+  const maxAttempts = boundedInteger(
+    event.maxAttempts,
+    1,
+    MAX_MODEL_RETRY_ATTEMPTS,
+    1,
+  );
+  const failedAttempt = boundedInteger(
+    event.failedAttempt,
+    0,
+    maxAttempts - 1,
+    0,
+  );
+  const nextAttempt = boundedInteger(
+    event.nextAttempt,
+    1,
+    maxAttempts,
+    Math.min(maxAttempts, failedAttempt + 1),
+  );
+  const delay = formatRetryDelay(event.delayMs);
+  const hint = `Retry ${nextAttempt}/${maxAttempts}${delay ? ` | ${delay}` : ''}`;
+  return hint.slice(0, MAX_MODEL_RETRY_HINT_CHARS);
+}
+
+module.exports = {
+  MAX_MODEL_RETRY_HINT_CHARS,
+  formatModelRetryProgress,
+};

package/blun.mjs

@@ -328722,6 +328722,7 @@ const BLUN_UPDATE_STATE_FILE_NAME = "latest.json";
 const BLUN_UPDATE_INSTALL_STATE_FILE_NAME = "install.json";
 const BLUN_UPDATE_ROLLOUT_LOG_FILE_NAME = "rollout.log";
 const BLUN_INPUT_HISTORY_DIR_NAME = "user-history";
+const BLUN_INPUT_DRAFT_DIR_NAME = "input-drafts";
 const BLUN_BANNER_DIR_NAME = "banner";
 const BLUN_BANNER_STATE_FILE_NAME = "state.json";
 const BLUN_STARTUP_DIR_NAME = "startup";
@@ -340176,6 +340177,10 @@ function getInputHistoryFile(workDir) {
 	const hash = createHash("md5").update(workDir, "utf-8").digest("hex");
 	return join(getDataDir(), BLUN_INPUT_HISTORY_DIR_NAME, `${hash}.jsonl`);
 }
+function getInputDraftFile(workDir, profile) {
+	const hash = createHash("sha256").update(`${profile}\0${workDir}`, "utf-8").digest("hex");
+	return join(getDataDir(), BLUN_INPUT_DRAFT_DIR_NAME, `${hash}.json`);
+}
 //#endregion
 //#region src/cli/build-info.ts
 function optionalBuildString(value) {
@@ -496904,6 +496909,7 @@ async function appendJsonlLine(filePath, lineSchema, value) {
 //#region src/utils/history/input-history.ts
 init_zod$1();
 const InputHistoryEntrySchema = object({ content: string() });
+var { readInputDraft, writeInputDraft } = createRequire(import.meta.url)("./bin/input-draft-persistence.cjs");
 async function loadInputHistory(file) {
 	return readJsonlFile(file, InputHistoryEntrySchema);
 }
@@ -504234,6 +504240,7 @@ var EditorKeyboardController = class {
 			if (!editor.wasGhostAcceptance()) this.inlineSuggest?.notifyActivity();
 			if (this.pendingExit) this.clearPendingExit();
 			host.updateEditorBorderHighlight(text);
+			host.scheduleInputDraftPersist(text, editor.inputMode);
 		};
 		let browseMode = null;
 		editor.setHistoryFilter((entry) => {
@@ -504360,6 +504367,7 @@ var EditorKeyboardController = class {
 		};
 		editor.onInputModeChange = (mode) => {
 			host.handleInputModeChange(mode);
+			host.scheduleInputDraftPersist(editor.getText(), mode);
 		};
 		editor.onOpenExternalEditor = () => {
 			host.track("shortcut_editor");
@@ -507172,6 +507180,7 @@ function normalizeJson(value) {
 }
 //#endregion
 //#region src/tui/controllers/session-event-handler.ts
+var { formatModelRetryProgress } = createRequire(import.meta.url)("./bin/model-retry-progress-policy.cjs");
 const MANAGED_TELEGRAM_MCP_SERVER = "plugin-telegram:telegram";
 function isManagedTelegramMissingTokenFailure(server) {
 	return server.name === MANAGED_TELEGRAM_MCP_SERVER && server.status === "failed" && server.error?.includes("BLUN_TELEGRAM_BOT_TOKEN required") === true;
@@ -507212,7 +507221,9 @@ var SessionEventHandler = class {
 	queuedGoalPromotionInFlight = false;
 	queuedGoalPromotionTimer;
 	lastCompactionInstruction;
+	modelRetryHint;
 	resetRuntimeState() {
+		this.clearModelRetryHint();
 		this.turnWatchdog.stop();
 		this.backgroundTasks.clear();
 		this.backgroundTaskTranscriptedTerminal.clear();
@@ -507312,7 +507323,9 @@ var SessionEventHandler = class {
 				this.handleStepCompleted(event);
 				this.host.releaseChannelQueueAtSafePoint();
 				break;
-			case "turn.step.retrying": break;
+			case "turn.step.retrying":
+				this.handleStepRetrying(event);
+				break;
 			case "tool.progress":
 				this.handleToolProgress(event);
 				break;
@@ -507401,6 +507414,7 @@ var SessionEventHandler = class {
 		this.mcpServerStatusSpinners.clear();
 	}
 	handleTurnBegin(event) {
+		this.clearModelRetryHint();
 		this.turnWatchdog.start();
 		const sessionId = this.host.session?.id;
 		if (sessionId !== void 0) bindPersonalMemoryRememberIntentTurn(sessionId, event.turnId);
@@ -507443,6 +507457,7 @@ var SessionEventHandler = class {
 		}, 0);
 	}
 	handleTurnEnd(event, sendQueued) {
+		this.clearModelRetryHint();
 		this.turnWatchdog.stop();
 		this.host.restoreQueuedSteerAtTurnEnd(event.turnId);
 		const sessionId = this.host.session?.id;
@@ -507469,6 +507484,7 @@ var SessionEventHandler = class {
 	}
 	handleStepBegin(event) {
 		this.turnWatchdog.recordProgress();
+		this.clearModelRetryHint();
 		this.host.commitQueuedSteerAtStepStart(event.turnId);
 		this.host.streamingUI.flushNow();
 		this.host.streamingUI.setStep(event.step);
@@ -507485,6 +507501,7 @@ var SessionEventHandler = class {
 		});
 	}
 	handleStepCompleted(event) {
+		this.clearModelRetryHint();
 		this.host.streamingUI.flushNow();
 		if (event.usage !== void 0) this.currentTurnTokenCount = (this.currentTurnTokenCount ?? 0) + totalTokenUsage(event.usage);
 		this.maybeShowDebugTiming(event);
@@ -507527,6 +507544,7 @@ var SessionEventHandler = class {
 		this.subAgentEventHandler.markActiveAgentSwarmsCancelled();
 	}
 	handleStepInterrupted(event) {
+		this.clearModelRetryHint();
 		this.host.streamingUI.flushNow();
 		this.host.streamingUI.resetToolUi();
 		this.host.streamingUI.finalizeLiveTextBuffers("idle");
@@ -507539,10 +507557,26 @@ var SessionEventHandler = class {
 		}
 		this.host.showError(reason === "max_steps" ? uiText("sessionEvent.interrupted.maxSteps") : uiText("sessionEvent.interrupted.reason", { reason }));
 	}
+	handleStepRetrying(event) {
+		this.turnWatchdog.recordProgress();
+		const hint = formatModelRetryProgress(event);
+		this.modelRetryHint = hint;
+		this.host.state.footer.setTransientHint(hint);
+		this.host.state.ui.requestRender();
+	}
+	clearModelRetryHint() {
+		if (this.modelRetryHint === void 0) return;
+		if (this.host.state.footer.getTransientHint() === this.modelRetryHint) {
+			this.host.state.footer.setTransientHint(null);
+			this.host.state.ui.requestRender();
+		}
+		this.modelRetryHint = void 0;
+	}
 	handleThinkingDelta(event) {
 		const { state, streamingUI } = this.host;
 		if (event.delta.length === 0 && !streamingUI.hasThinkingDraft()) return;
 		if (event.delta.length > 0) this.turnWatchdog.recordProgress();
+		if (event.delta.length > 0) this.clearModelRetryHint();
 		streamingUI.appendThinkingDelta(event.delta);
 		this.host.patchLivePane({ mode: "idle" });
 		if (state.appState.streamingPhase !== "thinking") this.host.setAppState({
@@ -507556,6 +507590,7 @@ var SessionEventHandler = class {
 		if (streamingUI.hasThinkingDraft()) streamingUI.flushThinkingToTranscript("idle");
 		if (event.delta.trim().length > 0) {
 			this.turnWatchdog.recordProgress();
+			this.clearModelRetryHint();
 			this.currentTurnHasAssistantText = true;
 			this.pendingModelBlockedFallback = void 0;
 		}
@@ -507593,6 +507628,7 @@ var SessionEventHandler = class {
 		});
 	}
 	handleToolCall(event) {
+		this.clearModelRetryHint();
 		this.turnWatchdog.recordToolCall(event.toolCallId, event.name, event.args);
 		const { streamingUI } = this.host;
 		streamingUI.flushNow();
@@ -515552,6 +515588,9 @@ var BlunTUI = class {
 	mediaActivityTickTimer;
 	mediaActivityExpanded = false;
 	lastHistoryContent;
+	inputDraftTimer;
+	pendingInputDraft;
+	inputDraftWrite = Promise.resolve();
 	shellOutputStreams = /* @__PURE__ */ new Map();
 	streamingUI;
 	authFlow;
@@ -515798,6 +515837,7 @@ var BlunTUI = class {
 		this.loadPersistedInputHistory();
 		this.state.editorContainer.clear();
 		this.state.editorContainer.addChild(this.state.editor);
+		await this.loadPersistedInputDraft();
 		this.state.ui.setFocus(this.state.editor);
 		return shouldReplayHistory;
 	}
@@ -516069,6 +516109,7 @@ var BlunTUI = class {
 	async stop(exitCode) {
 		if (this.isShuttingDown) return;
 		this.isShuttingDown = true;
+		await this.flushInputDraft();
 		if (exitCode === 0 && process.connected) try {
 			process.send({ type: RUNTIME_EXIT_INTENT_MESSAGE });
 		} catch {}
@@ -516952,6 +516993,40 @@ var BlunTUI = class {
 			this.managedImageReaderAvailable = false;
 		}
 	}
+	inputDraftFile() {
+		return getInputDraftFile(
+			this.state.appState.workDir,
+			process.env["BLUN_PROFILE"] ?? "default"
+		);
+	}
+	async loadPersistedInputDraft() {
+		const draft = await readInputDraft(this.inputDraftFile());
+		if (draft === null || this.state.editor.getText().length > 0) return;
+		this.state.editor.setInputMode(draft.mode);
+		this.state.editor.setText(draft.text);
+		this.updateEditorBorderHighlight(draft.text);
+	}
+	scheduleInputDraftPersist(text, mode) {
+		this.pendingInputDraft = { text, mode };
+		if (this.inputDraftTimer !== void 0) clearTimeout(this.inputDraftTimer);
+		this.inputDraftTimer = setTimeout(() => {
+			this.inputDraftTimer = void 0;
+			void this.flushInputDraft();
+		}, 300);
+	}
+	async flushInputDraft() {
+		if (this.inputDraftTimer !== void 0) {
+			clearTimeout(this.inputDraftTimer);
+			this.inputDraftTimer = void 0;
+		}
+		const draft = this.pendingInputDraft;
+		this.pendingInputDraft = void 0;
+		if (draft === void 0) return this.inputDraftWrite;
+		this.inputDraftWrite = this.inputDraftWrite
+			.then(() => writeInputDraft(this.inputDraftFile(), draft))
+			.catch(() => {});
+		return this.inputDraftWrite;
+	}
 	async loadPersistedInputHistory() {
 		try {
 			const entries = await loadInputHistory(getInputHistoryFile(this.state.appState.workDir));

package/package.json

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