blun-king-cli 9.1.536 → 9.1.561

package/scripts/check-session-start-hook-context-regression.js

@@ -1,228 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
-  : path.resolve(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-const renderer = bundle.match(
-  /function renderSessionStartHookResult\(results\) \{[\s\S]*?\n\}/,
-);
-const allowRenderer = bundle.match(
-  /function renderAllowHookResult\(event, results\) \{[\s\S]*?\n\}/,
-);
-const wrapperRenderer = bundle.match(
-  /function renderHookResult\(event, message\) \{[\s\S]*?\n\}/,
-);
-const messageSelector = bundle.match(
-  /function userPromptHookMessage\(result\) \{[\s\S]*?\n\}/,
-);
-const stringPredicate = bundle.match(
-  /function isNonEmptyString\$1\(value\) \{[\s\S]*?\n\}/,
-);
-const trigger = bundle.match(
-  /async triggerSessionStart\(source\) \{[\s\S]*?\n\t\t\}/,
-);
-const scheduler = bundle.match(
-  /scheduleSessionStart\(source\) \{[\s\S]*?\n\t\t\}/,
-);
-const createMain = bundle.match(
-  /async createMain\(\) \{[\s\S]*?\n\t\t\}/,
-);
-const resume = bundle.match(
-  /async resume\(\) \{[\s\S]*?\n\t\t\}/,
-);
-
-assert(renderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart renderer is missing');
-assert(allowRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: shared allow renderer is missing');
-assert(wrapperRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook wrapper renderer is missing');
-assert(messageSelector, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook message selector is missing');
-assert(stringPredicate, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook string predicate is missing');
-assert(trigger, 'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart trigger is missing');
-assert(scheduler, 'SESSION_START_HOOK_CONTEXT_REGRESSION: non-blocking SessionStart scheduler is missing');
-assert(createMain, 'SESSION_START_HOOK_CONTEXT_REGRESSION: createMain is missing');
-assert(resume, 'SESSION_START_HOOK_CONTEXT_REGRESSION: resume is missing');
-assert(
-  /renderAllowHookResult\("SessionStart", results\)/.test(renderer[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart output is not rendered',
-);
-assert(
-  /const results = await this\.hookEngine\.trigger\("SessionStart"/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart results are still discarded',
-);
-assert(
-  /renderSessionStartHookResult\(results\)/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart result does not reach the context path',
-);
-assert(
-  /appendSystemReminder\([\s\S]*variant: "session_start_hook"/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart result is not persisted as a scoped reminder',
-);
-assert(
-  /await mainAgent\.records\.flush\(\)/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: completed SessionStart reminder is not flushed',
-);
-assert(
-  /this\.scheduleSessionStart\("startup"\)/.test(createMain[0])
-    && !/await this\.triggerSessionStart\("startup"\)/.test(createMain[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: fresh-session input is still blocked by SessionStart',
-);
-assert(
-  /this\.scheduleSessionStart\("resume"\)/.test(resume[0])
-    && !/await this\.triggerSessionStart\("resume"\)/.test(resume[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: resumed-session input is still blocked by SessionStart',
-);
-assert(
-  /void this\.triggerSessionStart\(source\)\.catch\(/.test(scheduler[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart is not detached from interactive startup',
-);
-
-const packageRoot = path.resolve(__dirname, '..');
-const agentSpineRoot = path.join(packageRoot, 'agent-spine-plugin');
-const agentSpineManifest = JSON.parse(
-  fs.readFileSync(path.join(agentSpineRoot, 'blun.plugin.json'), 'utf8'),
-);
-const agentSpineCodexHooks = JSON.parse(
-  fs.readFileSync(path.join(agentSpineRoot, 'hooks', 'codex.json'), 'utf8'),
-);
-const blunSessionStart = agentSpineManifest.hooks.find(
-  (hook) => hook.event === 'SessionStart',
-);
-const codexSessionStart = agentSpineCodexHooks.hooks.SessionStart?.[0]?.hooks?.[0];
-
-assert(
-  blunSessionStart?.timeout >= 180,
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover the measured 123.6 s cold scan',
-);
-assert(
-  codexSessionStart?.timeout >= 180,
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: Codex AgentSpine SessionStart timeout must match the BLUN runtime budget',
-);
-
-const probeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-session-start-hook-'));
-try {
-  fs.mkdirSync(path.join(probeRoot, '.git'));
-  fs.writeFileSync(
-    path.join(probeRoot, 'AGENTS.md'),
-    '# SessionStart probe\n\nLoad this project instruction automatically.\n',
-  );
-  const stateRoot = path.join(probeRoot, '.agentspine-state');
-  const hookRun = spawnSync(process.execPath, [path.join(agentSpineRoot, 'src', 'hook.js')], {
-    cwd: agentSpineRoot,
-    input: JSON.stringify({
-      hook_event_name: 'SessionStart',
-      session_id: 'session-start-regression',
-      cwd: probeRoot,
-      source: 'resume',
-    }),
-    encoding: 'utf8',
-    timeout: 30_000,
-    env: {
-      ...process.env,
-      BLUN_HOME: probeRoot,
-      BLUN_PLUGIN_ROOT: agentSpineRoot,
-      AGENTSPINE_STATE_DIR: stateRoot,
-    },
-  });
-  assert(
-    hookRun.error === undefined && hookRun.status === 0,
-    `SESSION_START_HOOK_CONTEXT_REGRESSION: real AgentSpine hook failed: ${hookRun.error?.message || hookRun.stderr}`,
-  );
-  const hookOutput = JSON.parse(hookRun.stdout.trim());
-  assert(
-    hookOutput.hookSpecificOutput?.hookEventName === 'SessionStart'
-      && hookOutput.hookSpecificOutput?.message?.includes('AgentSpine'),
-    `SESSION_START_HOOK_CONTEXT_REGRESSION: real AgentSpine process output is not injectable: ${hookRun.stdout.trim()}`,
-  );
-} finally {
-  fs.rmSync(probeRoot, { recursive: true, force: true });
-}
-
-const triggerFunction = trigger[0].replace(
-  /^async triggerSessionStart/,
-  'async function triggerSessionStart',
-);
-const schedulerFunction = scheduler[0].replace(
-  /^scheduleSessionStart/,
-  'function scheduleSessionStart',
-);
-const runTrigger = Function(
-  `${wrapperRenderer[0]}\n${messageSelector[0]}\n${stringPredicate[0]}\n${allowRenderer[0]}\n${renderer[0]}\n${triggerFunction}\nreturn triggerSessionStart;`,
-)();
-const scheduleTrigger = Function(
-  `${schedulerFunction}\nreturn scheduleSessionStart;`,
-)();
-
-(async () => {
-  const reminders = [];
-  let flushes = 0;
-  const fakeSession = {
-    hookEngine: {
-      async trigger(event, args) {
-        assert(event === 'SessionStart', 'runtime probe called the wrong hook event');
-        assert(args.matcherValue === 'resume', 'runtime probe lost the reload matcher');
-        return [{ action: 'allow', message: 'AgentSpine ready: 152 sources indexed.' }];
-      },
-    },
-    requireMainAgent() {
-      return {
-        context: {
-          appendSystemReminder(text, origin) {
-            reminders.push({ text, origin });
-          },
-        },
-        records: {
-          async flush() {
-            flushes += 1;
-          },
-        },
-      };
-    },
-  };
-
-  await runTrigger.call(fakeSession, 'resume');
-  assert(reminders.length === 1, 'runtime probe did not append exactly one reminder');
-  assert(flushes === 1, 'runtime probe did not flush exactly once');
-  assert(
-    reminders[0].text.includes('<hook_result hook_event="SessionStart">')
-      && reminders[0].text.includes('AgentSpine ready: 152 sources indexed.'),
-    'runtime probe lost the AgentSpine SessionStart message',
-  );
-  assert(
-    reminders[0].origin?.kind === 'injection'
-      && reminders[0].origin?.variant === 'session_start_hook',
-    'runtime probe used the wrong reminder origin',
-  );
-
-  let detachedCompleted = false;
-  const detachedStartedAt = Date.now();
-  scheduleTrigger.call({
-    async triggerSessionStart(source) {
-      assert(source === 'startup', 'detached runtime probe lost the startup source');
-      await new Promise((resolve) => setTimeout(resolve, 75));
-      detachedCompleted = true;
-    },
-    log: { warn() {} },
-  }, 'startup');
-  assert(
-    Date.now() - detachedStartedAt < 50 && detachedCompleted === false,
-    'SessionStart scheduler still waits for the hook before returning',
-  );
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  assert(detachedCompleted, 'detached SessionStart hook did not finish in the background');
-
-  process.stdout.write('session-start-hook-context-regression PASS\n');
-})().catch((error) => {
-  process.stderr.write(`${error.stack || error.message}\n`);
-  process.exitCode = 1;
-});

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

@@ -1,81 +0,0 @@
-'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

@@ -1,89 +0,0 @@
-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-startup-swarm-command-regression.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const packageRoot = process.env.BLUN_PACKAGE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_PACKAGE_UNDER_TEST)
-  : path.resolve(__dirname, '..');
-const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
-
-for (const needle of [
-  '.option("--swarm", "Start in swarm mode.", false)',
-  'swarm: raw["swarm"] === true,',
-  'thinking: startup.effort,',
-  'if (startup.effort !== void 0) await session.setThinking(startup.effort);',
-  'if (startup.swarm && !(await session.getStatus()).swarmMode) await session.setSwarmMode(true, "effort");',
-  'if (startup.swarm) this.setAppState({ swarmMode: true, swarmModeEntry: "effort" });',
-]) {
-  assert.ok(bundle.includes(needle), `startup swarm command wiring missing: ${needle}`);
-}
-
-process.stdout.write('startup-swarm-command-regression PASS\n');