blun-king-cli 9.1.321 → 9.1.322

package/bin/personality-choice-policy.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { ensurePersonalityWorkspace } = require('./personality-setup-policy.cjs');
+
+const MAX_PERSONA_BYTES = 64 * 1024;
+
+function fail(code, detail = '') {
+  throw new Error(detail ? `${code}:${detail}` : code);
+}
+
+function resolvedHome(env) {
+  const configured = String(env.BLUN_SHARED_HOME ?? env.BLUN_HOME ?? '').trim();
+  return path.resolve(configured || path.join(os.homedir(), '.blun'));
+}
+
+function safeHome(env) {
+  const home = resolvedHome(env);
+  fs.mkdirSync(home, { recursive: true });
+  const stat = fs.lstatSync(home);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) fail('PERSONALITY_CHOICE_UNSAFE_HOME');
+  const realHome = fs.realpathSync(home);
+  if (path.resolve(realHome) !== home) fail('PERSONALITY_CHOICE_UNSAFE_HOME');
+  return home;
+}
+
+function readPersonaState(target) {
+  try {
+    const stat = fs.lstatSync(target);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_PERSONA_BYTES) {
+      fail('PERSONALITY_CHOICE_UNSAFE_PERSONA');
+    }
+    const raw = fs.readFileSync(target, 'utf8');
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      fail('PERSONALITY_CHOICE_UNSAFE_PERSONA');
+    }
+    return { existed: true, raw, value };
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { existed: false, raw: '', value: {} };
+    if (String(error?.message ?? '').startsWith('PERSONALITY_CHOICE_')) throw error;
+    fail('PERSONALITY_CHOICE_UNSAFE_PERSONA');
+  }
+}
+
+function atomicWrite(target, raw) {
+  const parent = path.dirname(target);
+  const temp = path.join(parent, `.persona-${process.pid}-${crypto.randomBytes(8).toString('hex')}.tmp`);
+  let handle;
+  try {
+    handle = fs.openSync(temp, 'wx', 0o600);
+    fs.writeFileSync(handle, raw, 'utf8');
+    fs.fsyncSync(handle);
+    fs.closeSync(handle);
+    handle = undefined;
+    fs.renameSync(temp, target);
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+    try {
+      fs.unlinkSync(temp);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+function setPersonalityEnabledAtomic(enabled, env = process.env) {
+  if (typeof enabled !== 'boolean') fail('PERSONALITY_CHOICE_INVALID_VALUE');
+  const home = safeHome(env);
+  const target = path.join(home, 'persona.json');
+  const previous = readPersonaState(target);
+
+  if (enabled) {
+    const setup = ensurePersonalityWorkspace(env);
+    if (!setup.ready) fail('PERSONALITY_SETUP_FAILED', setup.reason);
+  }
+
+  const nextRaw = `${JSON.stringify({ ...previous.value, personalityEnabled: enabled }, null, 2)}\n`;
+  atomicWrite(target, nextRaw);
+  return Object.freeze({ target, previousRaw: previous.raw, previousExisted: previous.existed, nextRaw });
+}
+
+function rollbackPersonalityChoice(receipt) {
+  if (!receipt || typeof receipt !== 'object') fail('PERSONALITY_CHOICE_INVALID_RECEIPT');
+  const target = path.resolve(String(receipt.target ?? ''));
+  const current = readPersonaState(target);
+  if (!current.existed || current.raw !== receipt.nextRaw) fail('PERSONALITY_CHOICE_CONFLICT');
+
+  if (receipt.previousExisted) {
+    atomicWrite(target, String(receipt.previousRaw ?? ''));
+  } else {
+    fs.unlinkSync(target);
+  }
+}
+
+module.exports = { rollbackPersonalityChoice, setPersonalityEnabledAtomic };

package/blun.mjs

@@ -21442,6 +21442,7 @@ var { identitySystemBlock, recordChannelIdentity } = createRequire(import.meta.u
 var { naturalPresenceSystemBlock } = createRequire(import.meta.url)("./bin/natural-presence-policy.cjs");
 var { personalityContextEnabled } = createRequire(import.meta.url)("./bin/personality-mode.cjs");
 var { ensurePersonalityWorkspace } = createRequire(import.meta.url)("./bin/personality-setup-policy.cjs");
+var { rollbackPersonalityChoice, setPersonalityEnabledAtomic } = createRequire(import.meta.url)("./bin/personality-choice-policy.cjs");
 var { projectSoulText } = createRequire(import.meta.url)("./bin/soul-organization-policy.cjs");
 var { soulFileInstruction } = createRequire(import.meta.url)("./bin/soul-preservation-policy.cjs");
 async function prepareSystemPromptContext(kaos, brandHome, options) {
@@ -420827,10 +420828,19 @@ function showPersonalityPicker(host) {
 	}));
 }
 async function applyPersonalityChoice(host, enabled) {
+	let receipt;
 	try {
-		setPersonalityEnabled(enabled);
-		await refreshPersonaInSession(host);
+		receipt = setPersonalityEnabled(enabled);
+		await refreshPersonaInSession(host, true);
 	} catch (error) {
+		if (receipt !== void 0) {
+			try {
+				rollbackPersonalityChoice(receipt);
+			} catch (rollbackError) {
+				host.showError(uiText("session.persona.note.saveFailed", { error: formatErrorMessage$2(rollbackError) }));
+				return;
+			}
+		}
 		host.showError(uiText("session.persona.note.saveFailed", { error: formatErrorMessage$2(error) }));
 		return;
 	}
@@ -427281,16 +427291,7 @@ function setLanguage(language) {
 	writeFileSync(personaFilePath(), `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 function setPersonalityEnabled(enabled) {
-	const next = {
-		...readPersona(),
-		personalityEnabled: enabled
-	};
-	mkdirSync(getDataDir(), { recursive: true });
-	writeFileSync(personaFilePath(), `${JSON.stringify(next, null, 2)}\n`, "utf8");
-	if (enabled) {
-		const setup = ensurePersonalityWorkspace();
-		if (!setup.ready) throw new Error(`PERSONALITY_SETUP_FAILED:${setup.reason}`);
-	}
+	return setPersonalityEnabledAtomic(enabled);
 }
 /** Append a note about how the user likes the agent to be (persona growth). */
 function addPersonaNote(note) {
@@ -427549,12 +427550,14 @@ async function handleNameCommand(host, args) {
 * The system prompt is cached at session start; reloadSession rebuilds it, and
 * `personaSystemBlock` re-reads persona.json at render time.
 */
-async function refreshPersonaInSession(host) {
+async function refreshPersonaInSession(host, strict = false) {
 	const session = host.session;
 	if (session === void 0) return;
 	try {
 		await session.reloadSession({ mcpServers: sessionMcpServers() });
-	} catch {}
+	} catch (error) {
+		if (strict) throw error;
+	}
 }
 async function handlePersonaCommand(host, args) {
 	const trimmed = args.trim();

package/package.json

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