blun-king-cli 9.1.526 → 9.1.536

package/scripts/check-programmatic-context-isolation-regression.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
+const vm = require('node:vm');
+const {
+  PROGRAMMATIC_WIRE_ONLY,
+  isWireOnlyProgrammaticEvent,
+  markProgrammaticNestedEvent,
+} = require('../bin/programmatic-context-isolation.cjs');
+const { projectLoopEventForRecord } = require('../bin/loop-event-record-policy.cjs');
+
+const root = join(__dirname, '..');
+const bundlePath = process.env.BLUN_PROGRAMMATIC_CONTEXT_BUNDLE || join(root, 'blun.mjs');
+const source = readFileSync(bundlePath, 'utf8');
+
+function between(text, startMarker, endMarker) {
+  const start = text.indexOf(startMarker);
+  const end = text.indexOf(endMarker, start + startMarker.length);
+  assert.ok(start >= 0 && end > start, `missing source region ${startMarker}`);
+  return text.slice(start, end);
+}
+
+function assertRuntimePolicy() {
+  const nestedCall = {
+    type: 'tool.call',
+    toolCallId: 'outer:ptc:ptc_Read_1',
+    name: 'Read',
+    args: { path: 'fixture.txt' },
+  };
+  const markedCall = markProgrammaticNestedEvent(nestedCall);
+  assert.notEqual(markedCall, nestedCall);
+  assert.equal(markedCall.contextVisibility, PROGRAMMATIC_WIRE_ONLY);
+  assert.equal(isWireOnlyProgrammaticEvent(markedCall), true);
+
+  const markedResult = markProgrammaticNestedEvent({
+    type: 'tool.result',
+    toolCallId: nestedCall.toolCallId,
+    result: { output: 'private nested payload' },
+  });
+  assert.equal(isWireOnlyProgrammaticEvent(markedResult), true);
+
+  const contentPart = { type: 'content.part', part: { type: 'text', text: 'visible' } };
+  assert.equal(markProgrammaticNestedEvent(contentPart), contentPart);
+  assert.equal(isWireOnlyProgrammaticEvent({ ...contentPart, contextVisibility: PROGRAMMATIC_WIRE_ONLY }), false);
+  assert.equal(isWireOnlyProgrammaticEvent({ ...nestedCall, contextVisibility: 'other' }), false);
+
+  const recorded = projectLoopEventForRecord(markedCall);
+  assert.equal(recorded.contextVisibility, PROGRAMMATIC_WIRE_ONLY, 'wire projection must preserve the isolation marker for resume');
+}
+
+function assertBundleContract(bundle) {
+  assert.match(bundle, /markProgrammaticNestedEvent\(event\)/u, 'nested dispatcher must mark internal tool events');
+  assert.match(bundle, /isWireOnlyProgrammaticEvent\(event\)/u, 'context fold must recognize wire-only events');
+  assert.match(bundle, /\.\/bin\/programmatic-context-isolation\.cjs/u, 'bundle must load the isolation policy');
+
+  const nestedRegion = between(bundle, 'function createNestedToolInvoker(', 'function nestedToolResultText(');
+  assert.match(
+    nestedRegion,
+    /dispatchEvent:\s*\(event\)\s*=>\s*step\.dispatchEvent\(markProgrammaticNestedEvent\(event\)\)/u,
+    'every nested tool event must cross the wire-only marker boundary',
+  );
+
+  const contextRegion = between(bundle, '\t\tappendLoopEvent(event) {', '\n\t\tappendMessage(message) {');
+  const logIndex = contextRegion.indexOf('this.agent.records.logRecord({');
+  const skipIndex = contextRegion.indexOf('if (isWireOnlyProgrammaticEvent(event)) return;');
+  const switchIndex = contextRegion.indexOf('switch (event.type)');
+  assert.ok(skipIndex >= 0, 'context fold must exclude wire-only events');
+  assert.ok(logIndex >= 0 && skipIndex > logIndex, 'wire record must be written before context exclusion');
+  assert.ok(switchIndex > skipIndex, 'wire-only event must be excluded before any context mutation');
+
+  assert.match(
+    bundle,
+    /case "context\.append_loop_event":\s*agent\.context\.appendLoopEvent\(input\.event\)/u,
+    'resume must reuse the same guarded context fold',
+  );
+}
+
+function loadContextMemoryFromBundle(bundle) {
+  const classBody = between(
+    bundle,
+    '\tContextMemory = class {',
+    '\n\t};\n}));\n//#endregion\n//#region ../../packages/agent-core/src/agent/injection',
+  );
+  const sandbox = {
+    ContextMemory: null,
+    USER_PROMPT_ORIGIN: { kind: 'user' },
+    createPendingTokenEstimateCache: () => ({}),
+    createToolMessage: (toolCallId, output) => ({
+      role: 'tool',
+      content: [{ type: 'text', text: output }],
+      toolCalls: [],
+      toolCallId,
+    }),
+    estimateTokensForMessages: () => 0,
+    isWireOnlyProgrammaticEvent,
+    projectLoopEventForRecord,
+    resolveCompletedStepUuid: () => 'outer-step',
+    resolveStepEventUuid: () => 'outer-step',
+    toolResultOutputForModel: (result) => String(result.output ?? ''),
+  };
+  vm.runInNewContext(`${classBody}\n};`, sandbox, { filename: 'ContextMemory.extracted.js' });
+  return sandbox.ContextMemory;
+}
+
+function createAgentRecordHarness() {
+  const records = [];
+  return {
+    agent: {
+      background: { markDeliveredNotification() {} },
+      log: { warn() {} },
+      records: {
+        restoring: null,
+        logRecord(record) { records.push(record); },
+      },
+      replayBuilder: { push() {} },
+    },
+    records,
+  };
+}
+
+function assertContextFoldRuntime(bundle) {
+  const ContextMemory = loadContextMemoryFromBundle(bundle);
+  const { agent, records } = createAgentRecordHarness();
+  const memory = new ContextMemory(agent);
+  const outerCall = {
+    type: 'tool.call',
+    toolCallId: 'outer-call',
+    name: 'ProgrammaticTool',
+    args: { code: 'return tools.Read({ path: "fixture.txt" })' },
+  };
+  const nestedCall = markProgrammaticNestedEvent({
+    type: 'tool.call',
+    toolCallId: 'outer-call:ptc:ptc_Read_1',
+    name: 'Read',
+    args: { path: 'fixture.txt' },
+  });
+  const nestedResult = markProgrammaticNestedEvent({
+    type: 'tool.result',
+    toolCallId: nestedCall.toolCallId,
+    result: { output: 'private nested payload' },
+  });
+  const outerResult = {
+    type: 'tool.result',
+    toolCallId: outerCall.toolCallId,
+    result: { output: 'bounded outer summary' },
+  };
+
+  for (const event of [outerCall, nestedCall, nestedResult, outerResult]) {
+    memory.appendLoopEvent(event);
+  }
+
+  assert.equal(records.length, 4, 'wire must retain outer and nested events');
+  assert.equal(records[1].event.contextVisibility, PROGRAMMATIC_WIRE_ONLY);
+  assert.equal(records[2].event.contextVisibility, PROGRAMMATIC_WIRE_ONLY);
+  const historyJson = JSON.stringify(memory._history);
+  assert.match(historyJson, /outer-call/u);
+  assert.match(historyJson, /bounded outer summary/u);
+  assert.doesNotMatch(historyJson, /ptc_Read_1/u, 'nested call must stay out of model history');
+  assert.doesNotMatch(historyJson, /private nested payload/u, 'nested result must stay out of model history');
+
+  const resumedHarness = createAgentRecordHarness();
+  const resumed = new ContextMemory(resumedHarness.agent);
+  for (const record of records) resumed.appendLoopEvent(record.event);
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(resumed._history)),
+    JSON.parse(historyJson),
+    'resume must rebuild the same bounded model history',
+  );
+  assert.equal(resumedHarness.records[1].event.contextVisibility, PROGRAMMATIC_WIRE_ONLY);
+  assert.equal(resumedHarness.records[2].event.contextVisibility, PROGRAMMATIC_WIRE_ONLY);
+}
+
+function assertMutationCoverage() {
+  assert.throws(
+    () => assertBundleContract(source.replace(
+      'if (isWireOnlyProgrammaticEvent(event)) return;',
+      'if (isWireOnlyProgrammaticEvent(event)) void 0;',
+    )),
+    /context fold must exclude wire-only events/u,
+  );
+  assert.throws(
+    () => assertBundleContract(source.replace('markProgrammaticNestedEvent(event)', 'event')),
+    /nested dispatcher must mark/u,
+  );
+}
+
+assertRuntimePolicy();
+assertBundleContract(source);
+assertContextFoldRuntime(source);
+assertMutationCoverage();
+process.stdout.write('programmatic-context-isolation-regression PASS\n');

package/scripts/check-programmatic-tool-regression.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
+const { pathToFileURL } = require('node:url');
+const {
+  PROGRAMMATIC_WIRE_ONLY,
+  markProgrammaticNestedEvent,
+} = require('../bin/programmatic-context-isolation.cjs');
+
+const root = join(__dirname, '..');
+const bundlePath = join(root, 'blun.mjs');
+const runtimePath = join(root, 'bin', 'programmatic-tool-runtime.mjs');
+
+function assertBundleContract(source) {
+  assert.match(source, /ProgrammaticTool = class/u, 'ProgrammaticTool class must exist');
+  assert.match(source, /new ProgrammaticTool\(\)/u, 'ProgrammaticTool must be registered as a builtin');
+  assert.match(
+    source,
+    /CodebaseSearch\\n  - ProgrammaticTool\\n/u,
+    'the default agent profile must expose ProgrammaticTool',
+  );
+  assert.match(
+    source,
+    /DEFAULT_APPROVE_TOOLS = new Set\(\[[\s\S]{0,500}"ProgrammaticTool"/u,
+    'the host-isolated outer interpreter must not add a redundant approval dialog',
+  );
+  assert.match(source, /function createNestedToolInvoker\(/u, 'nested tool invoker must exist');
+  assert.match(
+    source,
+    /preflightToolCall\(nestedStep, nestedToolCall\)/u,
+    'nested calls must enter the normal preflight path',
+  );
+  assert.match(
+    source,
+    /prepareToolCall\(nestedStep, preflight\)/u,
+    'nested calls must enter preparation and authorization',
+  );
+  assert.match(
+    source,
+    /finalizePendingToolResult\(nestedStep,/u,
+    'nested calls must enter result finalization',
+  );
+  assert.match(
+    source,
+    /if \(finalized\.stopTurn === true\) invoke\.stopTurn = true/u,
+    'nested turn-stop results must propagate to the outer tool result',
+  );
+  assert.match(
+    source,
+    /if \(context\.invokeTool\.stopTurn === true\) result\.stopTurn = true/u,
+    'ProgrammaticTool must return the propagated turn-stop marker',
+  );
+  assert.match(
+    source,
+    /Nested ProgrammaticTool calls are not allowed/u,
+    'recursive interpreter calls must fail closed',
+  );
+  assert.match(
+    source,
+    /toolName === PROGRAMMATIC_TOOL_NAME[\s\S]{0,240}createNestedToolInvoker/u,
+    'only ProgrammaticTool may receive the nested invocation capability',
+  );
+
+  const { CORE_TOOL_NAMES } = require(join(root, 'bin', 'turn-tool-performance-policy.cjs'));
+  assert.equal(
+    CORE_TOOL_NAMES.includes('ProgrammaticTool'),
+    false,
+    'ProgrammaticTool must remain eligible for schema deferral',
+  );
+}
+
+function extractBetween(source, startNeedle, endNeedle) {
+  const start = source.indexOf(startNeedle);
+  assert.notEqual(start, -1, `missing source start: ${startNeedle}`);
+  const end = source.indexOf(endNeedle, start + startNeedle.length);
+  assert.notEqual(end, -1, `missing source end: ${endNeedle}`);
+  return source.slice(start, end);
+}
+
+async function exerciseBundledProgrammaticTool(source) {
+  const assignment = extractBetween(
+    source,
+    'ProgrammaticTool = class {',
+    '\n\t};\n}));\n//#endregion',
+  );
+  const classSource = `${assignment.slice('ProgrammaticTool = '.length)}\n\t}`
+    .replaceAll('import.meta.url', JSON.stringify(pathToFileURL(bundlePath).href));
+  const ProgrammaticTool = Function(
+    'PROGRAMMATIC_TOOL_NAME',
+    `"use strict"; return (${classSource});`,
+  )('ProgrammaticTool');
+  const tool = new ProgrammaticTool();
+  const updates = [];
+  const nestedCalls = [];
+  const invokeTool = async (call) => {
+    nestedCalls.push(call);
+    return { output: JSON.stringify(call.args) };
+  };
+  invokeTool.stopTurn = true;
+
+  const execution = tool.resolveExecution({
+    code: 'state.done = true; return tools.echo({ value: 12 });',
+    state: {},
+    tools: [{ name: 'Echo', alias: 'echo' }],
+  });
+  const result = await execution.execute({
+    signal: new AbortController().signal,
+    invokeTool,
+    onUpdate: (update) => updates.push(update),
+  });
+  assert.equal(result.isError, false);
+  assert.equal(result.stopTurn, true);
+  assert.equal(nestedCalls.length, 1);
+  assert.equal(nestedCalls[0].name, 'Echo');
+  assert.deepEqual(JSON.parse(result.output).state, { done: true });
+  assert.deepEqual(updates.map((update) => update.event.type), [
+    'interpreter.started',
+    'interpreter.tool_call',
+    'interpreter.tool_result',
+    'interpreter.completed',
+  ]);
+
+  const unavailable = await tool.resolveExecution({ code: 'return 1;' }).execute({
+    signal: new AbortController().signal,
+    onUpdate: () => {},
+  });
+  assert.equal(unavailable.isError, true);
+  assert.match(unavailable.output, /invocation boundary is unavailable/u);
+}
+
+async function exerciseBundledNestedPipeline(source) {
+  const nestedSource = extractBetween(
+    source,
+    'function createNestedToolInvoker(',
+    'function nestedToolResultText(',
+  );
+  const calls = [];
+  let stopNext = true;
+  const preflightToolCall = (step, toolCall) => {
+    calls.push(['preflight', toolCall.name]);
+    return { kind: 'runnable', toolCall, toolName: toolCall.name, args: JSON.parse(toolCall.arguments) };
+  };
+  const prepareToolCall = async (_step, call) => {
+    calls.push(['prepare', call.toolName]);
+    return {
+      task: {
+        start: async () => ({
+          result: Promise.resolve({
+            toolCall: call.toolCall,
+            toolName: call.toolName,
+            args: call.args,
+            result: { output: 'nested-ok' },
+          }),
+        }),
+      },
+    };
+  };
+  const finalizePendingToolResult = async (_step, pending) => {
+    calls.push(['finalize', pending.toolName]);
+    return { ...pending, stopTurn: stopNext };
+  };
+  const nestedToolResultText = (result) => String(result.output || 'nested failure');
+  const createNestedToolInvoker = Function(
+    'preflightToolCall',
+    'prepareToolCall',
+    'finalizePendingToolResult',
+    'nestedToolResultText',
+    'PROGRAMMATIC_TOOL_NAME',
+    'markProgrammaticNestedEvent',
+    `"use strict"; ${nestedSource}; return createNestedToolInvoker;`,
+  )(
+    preflightToolCall,
+    prepareToolCall,
+    finalizePendingToolResult,
+    nestedToolResultText,
+    'ProgrammaticTool',
+    markProgrammaticNestedEvent,
+  );
+  const events = [];
+  const step = {
+    signal: new AbortController().signal,
+    tools: [],
+    dispatchEvent: async (event) => events.push(event),
+  };
+  const invoke = createNestedToolInvoker(step, { id: 'outer' });
+  const result = await invoke({ name: 'Echo', args: { value: 3 }, callId: 'one' });
+  assert.equal(result.output, 'nested-ok');
+  assert.deepEqual(calls, [
+    ['preflight', 'Echo'],
+    ['prepare', 'Echo'],
+    ['finalize', 'Echo'],
+  ]);
+  assert.equal(events[0].type, 'tool.result');
+  assert.equal(events[0].toolCallId, 'outer:ptc:one');
+  assert.equal(events[0].contextVisibility, PROGRAMMATIC_WIRE_ONLY);
+  assert.equal(invoke.stopTurn, true);
+  await assert.rejects(
+    invoke({ name: 'Echo', args: {}, callId: 'two' }),
+    /after a turn-stop result/u,
+  );
+
+  stopNext = false;
+  const recursive = createNestedToolInvoker(step, { id: 'outer-two' });
+  await assert.rejects(
+    recursive({ name: 'ProgrammaticTool', args: {}, callId: 'recursive' }),
+    /Nested ProgrammaticTool calls are not allowed/u,
+  );
+}
+
+async function main() {
+  const suite = spawnSync(
+    process.execPath,
+    ['--test', join(__dirname, 'programmatic-tool-runtime.test.mjs')],
+    { stdio: 'inherit' },
+  );
+  assert.equal(suite.status, 0, 'programmatic runtime test suite must pass');
+
+  const source = readFileSync(bundlePath, 'utf8');
+  assertBundleContract(source);
+  await exerciseBundledProgrammaticTool(source);
+  await exerciseBundledNestedPipeline(source);
+  assert.throws(
+    () => assertBundleContract(source.replace('prepareToolCall(nestedStep, preflight)', 'prepareToolCallBypassed(nestedStep, preflight)')),
+    /preparation and authorization/u,
+    'mutation probe must reject bypassing the authorization path',
+  );
+  assert.throws(
+    () => assertBundleContract(source.replace('CodebaseSearch\\n  - ProgrammaticTool\\n', 'CodebaseSearch\\n')),
+    /default agent profile/u,
+    'mutation probe must reject an unreachable builtin tool',
+  );
+
+  const { createProgrammaticToolRuntime } = await import(pathToFileURL(runtimePath).href);
+  const calls = [];
+  const events = [];
+  const runtime = createProgrammaticToolRuntime({
+    allowedTools: [{ name: 'Echo', alias: 'echo' }],
+    invokeTool: async (call) => {
+      calls.push(call);
+      return { output: JSON.stringify(call.args) };
+    },
+    onEvent: (event) => events.push(event),
+  });
+
+  const outcome = await runtime.run({
+    code: 'state.completed = true; return tools.echo({ value: 7 });',
+    state: {},
+  });
+  assert.deepEqual(outcome.result, { output: '{"value":7}' });
+  assert.deepEqual(outcome.state, { completed: true });
+  assert.equal(calls.length, 1);
+  assert.deepEqual(events.map((event) => event.type), [
+    'interpreter.started',
+    'interpreter.tool_call',
+    'interpreter.tool_result',
+    'interpreter.completed',
+  ]);
+
+  const isolated = await createProgrammaticToolRuntime({
+    allowedTools: [],
+    invokeTool: async () => assert.fail('no tool call expected'),
+  }).run({
+    code: 'return [typeof process, typeof require, typeof fetch, typeof Date, typeof eval];',
+    state: {},
+  });
+  assert.deepEqual(isolated.result, ['undefined', 'undefined', 'undefined', 'undefined', 'undefined']);
+
+  await assert.rejects(
+    createProgrammaticToolRuntime({
+      allowedTools: [],
+      invokeTool: async () => assert.fail('no tool call expected'),
+      limits: { timeoutMs: 30 },
+    }).run({ code: 'while (true) {}', state: {} }),
+    /execution deadline exceeded/u,
+  );
+
+  for (let index = 0; index < 10; index += 1) {
+    const repeated = await runtime.run({
+      code: `return tools.echo({ value: ${index} });`,
+      state: {},
+    });
+    assert.equal(repeated.callCount, 1);
+  }
+
+  process.stdout.write('programmatic tool regression: ok\n');
+}
+
+main().catch((error) => {
+  console.error(error.stack || error);
+  process.exitCode = 1;
+});

package/scripts/check-resume-replay-regression.js

@@ -4,6 +4,7 @@
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const path = require('node:path');
+const { isWireOnlyProgrammaticEvent } = require('../bin/programmatic-context-isolation.cjs');
 
 const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
   ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
@@ -49,6 +50,7 @@ const appendLoopEvent = compileMethod(
   'appendMessage',
   {
     projectLoopEventForRecord: (event) => event,
+    isWireOnlyProgrammaticEvent,
     resolveCompletedStepUuid,
     createToolMessage: (toolCallId, content) => ({ toolCallId, content, toolCalls: [] }),
     toolResultOutputForModel: (result) => result.output,

package/scripts/check-startup-swarm-command-regression.js

@@ -0,0 +1,24 @@
+#!/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');