blun-king-cli 9.1.520 → 9.1.525

package/scripts/check-shell-terminal-isolation-regression.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { spawn } = require('node:child_process');
+
+const packageRoot = path.resolve(__dirname, '..');
+const bundlePath = process.argv[2] === undefined
+  ? path.join(packageRoot, 'blun.mjs')
+  : path.resolve(process.argv[2]);
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+const source = /function buildLocalSpawnOptions\(isWindows, cwd, env\) \{[\s\S]*?\n\}/.exec(bundle)?.[0];
+
+assert(source, 'SHELL_TERMINAL_ISOLATION: buildLocalSpawnOptions is missing');
+
+const context = {};
+vm.runInNewContext(`${source}; globalThis.buildLocalSpawnOptions = buildLocalSpawnOptions;`, context);
+const buildLocalSpawnOptions = context.buildLocalSpawnOptions;
+const cwd = packageRoot;
+const env = { ...process.env, BLUN_SHELL_ISOLATION_PROBE: '1' };
+
+for (const isWindows of [false, true]) {
+  const options = buildLocalSpawnOptions(isWindows, cwd, env);
+  assert.deepEqual(Array.from(options.stdio), ['pipe', 'pipe', 'pipe']);
+  assert.equal(options.detached, true,
+    `local shell must start in a separate process group when isWindows=${String(isWindows)}`);
+  assert.equal(options.windowsHide, true);
+  assert.equal(options.cwd, cwd);
+  assert.equal(options.env, env);
+}
+
+async function runCapturedProcessProbe() {
+  const options = buildLocalSpawnOptions(process.platform === 'win32', cwd, env);
+  const child = spawn(process.execPath, [
+    '-e',
+    [
+      "process.stdin.setEncoding('utf8')",
+      "process.stdin.on('data', () => { process.exitCode = 90 })",
+      "process.stdin.on('end', () => {",
+      "  process.stdout.write('stdout-ok')",
+      "  process.stderr.write('stderr-ok')",
+      '})',
+    ].join(';'),
+  ], options);
+
+  let stdout = '';
+  let stderr = '';
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => { stdout += chunk; });
+  child.stderr.on('data', (chunk) => { stderr += chunk; });
+  child.stdin.end();
+
+  const exit = await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error('captured child did not observe stdin EOF'));
+    }, 10_000);
+    child.once('error', (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once('close', (code, signal) => {
+      clearTimeout(timer);
+      resolve({ code, signal });
+    });
+  });
+
+  assert.deepEqual(exit, { code: 0, signal: null });
+  assert.equal(stdout, 'stdout-ok');
+  assert.equal(stderr, 'stderr-ok');
+}
+
+runCapturedProcessProbe().then(() => {
+  process.stdout.write('shell-terminal-isolation-regression PASS\n');
+}).catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/check-slash-escape-regression.js

@@ -0,0 +1,89 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
+const match = /editor\.onEscape = \(autocompleteCancelled = false\) => \{([\s\S]*?)\n\t\t\};\n\t\teditor\.onShiftTab =/.exec(bundle);
+assert(match, 'SLASH_ESCAPE_REGRESSION: editor.onEscape handler is missing');
+
+const runEscape = Function('host', 'editor', 'autocompleteCancelled', match[1]);
+const ctrlSMatch = /editor\.onCtrlS = \(\) => \{([\s\S]*?)\n\t\t\};\n\t\teditor\.onCtrlB =/.exec(bundle);
+assert(ctrlSMatch, 'SLASH_ESCAPE_REGRESSION: editor.onCtrlS handler is missing');
+const runCtrlS = Function('host', 'editor', ctrlSMatch[1]);
+
+function probe(initialText, autocompleteCancelled) {
+  let text = initialText;
+  const editor = {
+    inputMode: 'prompt',
+    getText: () => text,
+    setText: (value) => { text = value; },
+  };
+  const host = {
+    cancelInFlight: undefined,
+    queueSteerInFlight: undefined,
+    state: {
+      activeDialog: null,
+      appState: {
+        isCompacting: false,
+        streamingPhase: 'idle',
+      },
+    },
+    streamingUI: { hasActiveTurn: () => false },
+    btwPanelController: { closeOrCancel: () => false },
+  };
+  const controller = {
+    pendingExit: null,
+    pendingUndoEsc: null,
+    clearPendingExit() {},
+    clearPendingUndoEsc() {},
+    armPendingUndoEsc() {},
+  };
+
+  runEscape.call(controller, host, editor, autocompleteCancelled);
+  return text;
+}
+
+assert.equal(
+  probe('/reload', true),
+  '',
+  'SLASH_ESCAPE_REGRESSION: Escape must cancel the open slash-command draft together with its menu',
+);
+assert.equal(
+  probe('ordinary draft', true),
+  'ordinary draft',
+  'SLASH_ESCAPE_REGRESSION: cancelling ordinary autocomplete must preserve the draft',
+);
+
+let flushed = null;
+const idleHost = {
+  streamingUI: { hasActiveTurn: () => false },
+  state: {
+    appState: { streamingPhase: 'idle' },
+    ui: { requestRender() {} },
+  },
+  flushQueuedMessages: (draft, mode) => { flushed = { draft, mode }; },
+  updateQueueDisplay() {},
+};
+const slashEditor = {
+  inputMode: 'prompt',
+  getText: () => '/reload',
+};
+runCtrlS(idleHost, slashEditor);
+assert.deepEqual(
+  flushed,
+  { draft: '/reload', mode: 'prompt' },
+  'SLASH_ESCAPE_REGRESSION: Ctrl+S must hand an idle slash draft to the existing queue drain',
+);
+flushed = null;
+runCtrlS(idleHost, {
+  inputMode: 'prompt',
+  getText: () => 'ordinary draft',
+});
+assert.equal(
+  flushed,
+  null,
+  'SLASH_ESCAPE_REGRESSION: the existing idle behavior for ordinary drafts must stay unchanged',
+);
+
+console.log('slash-escape-regression PASS (Escape + Ctrl+S)');

package/scripts/check-telegram-loop-exactly-once-regression.js

@@ -0,0 +1,71 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.join(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+const match = /async function handleLoopCommand\(host, args\) \{([\s\S]*?)\n\}\nfunction hasRunnableSession/.exec(bundle);
+assert(match, 'TELEGRAM_LOOP_EXACTLY_ONCE: handleLoopCommand is missing');
+
+const handleLoopCommand = Function(
+  'parseLoopCommand',
+  'hasRunnableSession',
+  'llmNotSetMessage',
+  'isStreaming',
+  `return async function handleLoopCommand(host, args) {${match[1]}\n};`,
+)(
+  () => ({ kind: 'create', interval: '*/5 * * * *', prompt: 'work once' }),
+  () => true,
+  () => 'missing model',
+  (host) => host.streaming,
+);
+
+function createHost({ telegram = false, streaming = true } = {}) {
+  const calls = { send: [], enqueue: [] };
+  const session = {
+    async createLoop({ interval, prompt }) {
+      return { interval, prompt, status: 'active' };
+    },
+  };
+  const host = {
+    streaming,
+    session,
+    telegramRemoteCommandContext: telegram ? { item: { telegramCommandName: 'loop' } } : undefined,
+    state: { appState: { isCompacting: false, model: 'blun/king' } },
+    requireSession() { return session; },
+    setAppState() {},
+    track() {},
+    showStatus() {},
+    showError(message) { throw new Error(message); },
+    sendNormalUserInput(text) { calls.send.push(text); },
+    enqueueNormalUserInput(text) { calls.enqueue.push(text); },
+  };
+  return { host, calls };
+}
+
+(async () => {
+  const telegram = createHost({ telegram: true, streaming: true });
+  await handleLoopCommand(telegram.host, '5 min work once');
+  assert.deepEqual(telegram.calls.send, ['work once']);
+  assert.deepEqual(
+    telegram.calls.enqueue,
+    [],
+    'TELEGRAM_LOOP_EXACTLY_ONCE: Telegram loop payload must not survive in the normal queue',
+  );
+
+  const local = createHost({ telegram: false, streaming: true });
+  await handleLoopCommand(local.host, '5 min work once');
+  assert.deepEqual(local.calls.send, []);
+  assert.deepEqual(
+    local.calls.enqueue,
+    ['work once'],
+    'TELEGRAM_LOOP_EXACTLY_ONCE: local busy-loop behavior must stay queued',
+  );
+
+  console.log('telegram-loop-exactly-once-regression PASS');
+})().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/telegram-plugin/bin/telegram-approval-relay.cjs

@@ -68,6 +68,8 @@ function resolveTelegramApprovalTarget(allowFrom, configuredChatId) {
     : [];
   const configured = String(configuredChatId ?? '').trim();
   if (configured.length > 0) return allowed.includes(configured) ? configured : null;
+  const privateChats = allowed.filter((value) => /^[1-9]\d*$/u.test(value));
+  if (privateChats.length === 1) return privateChats[0];
   return allowed.length === 1 ? allowed[0] : null;
 }
 
@@ -280,4 +282,3 @@ module.exports = {
   wasTelegramApprovalSent,
   writeTelegramApprovalResponse,
 };
-