blun-king-cli 9.1.536 → 9.1.561

package/bin/scoped-cron-run-policy.cjs

@@ -0,0 +1,358 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const path = require('node:path');
+
+const MAX_ALLOWED_TOOLS = 64;
+const MAX_TOOL_NAME_BYTES = 160;
+const MAX_RECEIPT_TOOL_NAMES = 64;
+const MAX_RECEIPT_OUTPUTS = 32;
+const MAX_LIST_LIMIT = 100;
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'lost']);
+const ALL_STATUSES = new Set(['buffered', 'running', ...TERMINAL_STATUSES]);
+const TRANSITIONS = new Map([
+  ['buffered', new Set(['running', 'failed', 'cancelled', 'lost'])],
+  ['running', new Set(['completed', 'failed', 'cancelled', 'lost'])],
+]);
+const ERROR_CATEGORIES = new Set(['executor', 'provider', 'policy', 'unknown']);
+
+class ScopedCronRunError extends TypeError {
+  constructor(code, message) {
+    super(message);
+    this.name = 'ScopedCronRunError';
+    this.code = code;
+  }
+}
+
+function fail(code, message) {
+  throw new ScopedCronRunError(code, message);
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
+function assertOpaqueId(value, field) {
+  if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value)) {
+    fail('CRON_RUN_INVALID_ID', `${field} must be a bounded opaque identifier`);
+  }
+  return value;
+}
+
+function canonicalToolName(value, field) {
+  if (
+    typeof value !== 'string'
+    || value.length === 0
+    || Buffer.byteLength(value, 'utf8') > MAX_TOOL_NAME_BYTES
+    || /[*?[\]{}]/u.test(value)
+    || !/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u.test(value)
+  ) {
+    fail('CRON_SCOPE_INVALID_TOOL', `${field} must be an exact canonical tool name`);
+  }
+  return value;
+}
+
+function canonicalToolNames(tools, field = 'tools') {
+  if (!Array.isArray(tools)) fail('CRON_SCOPE_INVALID_CATALOG', `${field} must be an array`);
+  const names = tools.map((entry) => canonicalToolName(
+    typeof entry === 'string' ? entry : entry && entry.name,
+    field,
+  ));
+  return [...new Set(names)];
+}
+
+function cronToolScopeDigest(names) {
+  return `sha256:${crypto.createHash('sha256').update(JSON.stringify(names)).digest('hex')}`;
+}
+
+function normalizeCronAllowedTools(input, effectiveTools) {
+  if (input === undefined) return Object.freeze({mode: 'legacy', names: null, digest: null});
+  if (!Array.isArray(input)) fail('CRON_SCOPE_NOT_ARRAY', 'allowed_tools must be an array');
+  if (input.length > MAX_ALLOWED_TOOLS) {
+    fail('CRON_SCOPE_TOO_MANY_TOOLS', `allowed_tools supports at most ${MAX_ALLOWED_TOOLS} entries`);
+  }
+  const catalog = new Set(canonicalToolNames(effectiveTools, 'effective tools'));
+  const names = [];
+  const seen = new Set();
+  for (const rawName of input) {
+    const name = canonicalToolName(rawName, 'allowed_tools entry');
+    if (!catalog.has(name)) fail('CRON_SCOPE_UNKNOWN_TOOL', `Unknown current tool: ${name}`);
+    if (seen.has(name)) continue;
+    seen.add(name);
+    names.push(name);
+  }
+  return deepFreeze({mode: 'scoped', names, digest: cronToolScopeDigest(names)});
+}
+
+function cronToolScopeForTask(task) {
+  if (!task || task.allowedTools === undefined) {
+    return Object.freeze({mode: 'legacy', names: null, digest: null});
+  }
+  if (!Array.isArray(task.allowedTools)) fail('CRON_SCOPE_INVALID_TASK', 'Persisted allowedTools must be an array');
+  const names = canonicalToolNames(task.allowedTools, 'persisted allowedTools');
+  const digest = cronToolScopeDigest(names);
+  if (task.toolScopeDigest !== digest) fail('CRON_SCOPE_DIGEST_MISMATCH', 'Persisted tool scope digest does not match');
+  return deepFreeze({mode: 'scoped', names, digest});
+}
+
+function isCronToolScope(value) {
+  if (!value || value.mode !== 'scoped' || !Array.isArray(value.names)) return false;
+  try {
+    const names = canonicalToolNames(value.names, 'tool scope');
+    return names.length === value.names.length && value.digest === cronToolScopeDigest(names);
+  } catch {
+    return false;
+  }
+}
+
+function filterToolsForCronScope(tools, scope) {
+  if (!Array.isArray(tools)) fail('CRON_SCOPE_INVALID_CATALOG', 'tools must be an array');
+  if (!scope || scope.mode === 'legacy') return tools;
+  if (!isCronToolScope(scope)) fail('CRON_SCOPE_INVALID_ORIGIN', 'Invalid cron tool scope');
+  const allowed = new Set(scope.names);
+  return tools.filter((tool) => tool && allowed.has(tool.name));
+}
+
+function inheritedCronToolScope(parentScope) {
+  if (!parentScope || parentScope.mode === 'legacy') return undefined;
+  if (!isCronToolScope(parentScope)) fail('CRON_SCOPE_INVALID_ORIGIN', 'Invalid inherited cron tool scope');
+  return deepFreeze({mode: 'scoped', names: [...parentScope.names], digest: parentScope.digest});
+}
+
+function isoTimestamp(value, field) {
+  if (typeof value !== 'string' || !Number.isFinite(Date.parse(value))) {
+    fail('CRON_RUN_INVALID_TIME', `${field} must be an ISO timestamp`);
+  }
+  return value;
+}
+
+function createCronRunReceipt(input) {
+  const digest = input.toolScopeDigest;
+  if (digest !== null && (typeof digest !== 'string' || !/^sha256:[a-f0-9]{64}$/u.test(digest))) {
+    fail('CRON_RUN_INVALID_DIGEST', 'toolScopeDigest is invalid');
+  }
+  if (!Number.isSafeInteger(input.coalescedCount) || input.coalescedCount < 1) {
+    fail('CRON_RUN_INVALID_COALESCE', 'coalescedCount must be a positive integer');
+  }
+  return deepFreeze({
+    runId: assertOpaqueId(input.runId, 'runId'),
+    jobId: assertOpaqueId(input.jobId, 'jobId'),
+    jobDeleted: false,
+    cron: String(input.cron),
+    recurring: input.recurring === true,
+    stale: input.stale === true,
+    coalescedCount: input.coalescedCount,
+    toolScopeDigest: digest,
+    status: 'buffered',
+    firedAt: isoTimestamp(input.firedAt, 'firedAt'),
+    startedAt: null,
+    endedAt: null,
+    turnId: null,
+    toolSummary: {calls: 0, errors: 0, names: [], excessNames: 0},
+    outputs: [],
+    finalMessageRef: null,
+  });
+}
+
+function summarizeCronToolCalls(toolCalls) {
+  if (!Array.isArray(toolCalls)) fail('CRON_RUN_INVALID_TOOLS', 'toolCalls must be an array');
+  const names = new Set();
+  let errors = 0;
+  for (const call of toolCalls) {
+    canonicalToolName(call && call.name, 'tool call name');
+    names.add(call.name);
+    if (call.isError === true) errors += 1;
+  }
+  const sorted = [...names].sort((left, right) => left.localeCompare(right));
+  return deepFreeze({
+    calls: toolCalls.length,
+    errors,
+    names: sorted.slice(0, MAX_RECEIPT_TOOL_NAMES),
+    excessNames: Math.max(0, sorted.length - MAX_RECEIPT_TOOL_NAMES),
+  });
+}
+
+function normalizeRelativeFilePath(value) {
+  if (typeof value !== 'string' || value.length === 0 || value.includes('\0')) return null;
+  const normalized = value.replaceAll('\\', '/');
+  if (normalized.startsWith('/') || /^[A-Za-z]:\//u.test(normalized) || normalized.startsWith('//')) return null;
+  const posix = path.posix.normalize(normalized);
+  if (posix === '.' || posix === '..' || posix.startsWith('../')) return null;
+  return posix;
+}
+
+function rootRelativeFile(absolutePath, root, rootRef, pathApi) {
+  const relative = pathApi.relative(pathApi.resolve(root), pathApi.resolve(absolutePath));
+  if (relative === '' || relative === '..' || relative.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative)) return null;
+  const relativePath = normalizeRelativeFilePath(relative);
+  return relativePath === null ? null : {rootRef, relativePath};
+}
+
+function buildCronFileCandidate({toolName, toolCallId, display, workspaceRoot, additionalRoots = [], pathExists}) {
+  if (!['Write', 'Edit'].includes(toolName)) return null;
+  if (!display || display.kind !== 'file_io' || typeof display.path !== 'string') return null;
+  assertOpaqueId(toolCallId, 'toolCallId');
+  const pathApi = process.platform === 'win32' || /^[A-Za-z]:[\\/]/u.test(display.path) ? path.win32 : path;
+  let located = rootRelativeFile(display.path, workspaceRoot, 'root:workspace', pathApi);
+  if (located === null) {
+    for (let index = 0; index < additionalRoots.length; index += 1) {
+      located = rootRelativeFile(display.path, additionalRoots[index], `root:additional:${String(index + 1)}`, pathApi);
+      if (located !== null) break;
+    }
+  }
+  if (located === null) return null;
+  return deepFreeze({
+    ...located,
+    change: toolName === 'Edit' || pathExists === true ? 'modified' : 'created',
+    toolCallId,
+    kind: 'file',
+  });
+}
+
+function normalizeCronOutputs(outputs) {
+  if (!Array.isArray(outputs)) fail('CRON_RUN_INVALID_OUTPUTS', 'outputs must be an array');
+  const safe = [];
+  for (const output of outputs) {
+    if (safe.length >= MAX_RECEIPT_OUTPUTS) break;
+    if (!output || output.kind !== 'file') continue;
+    if (!/^root:(workspace|additional:[1-9][0-9]*)$/u.test(output.rootRef)) continue;
+    const relativePath = normalizeRelativeFilePath(output.relativePath);
+    if (relativePath === null || !['created', 'modified'].includes(output.change)) continue;
+    safe.push({
+      rootRef: output.rootRef,
+      relativePath,
+      change: output.change,
+      toolCallId: assertOpaqueId(output.toolCallId, 'toolCallId'),
+      kind: 'file',
+    });
+  }
+  return deepFreeze(safe);
+}
+
+function safeCronRunError(status, error) {
+  if (status !== 'failed') return undefined;
+  const category = error && ERROR_CATEGORIES.has(error.category) ? error.category : 'unknown';
+  const rawCode = error && typeof error.code === 'string' ? error.code : 'unspecified';
+  const code = /^[A-Za-z0-9._-]{1,64}$/u.test(rawCode) ? rawCode : 'redacted';
+  return {category, code};
+}
+
+function transitionCronRunReceipt(receipt, status, details = {}) {
+  const allowed = receipt && TRANSITIONS.get(receipt.status);
+  if (!allowed || !allowed.has(status)) {
+    fail('CRON_RUN_INVALID_TRANSITION', `Invalid cron run transition: ${String(receipt && receipt.status)} -> ${status}`);
+  }
+  if (status === 'running') {
+    if (!Number.isSafeInteger(details.turnId) || details.turnId < 0) {
+      fail('CRON_RUN_INVALID_TURN', 'turnId must be a non-negative integer');
+    }
+    return deepFreeze({
+      ...clone(receipt),
+      status,
+      startedAt: isoTimestamp(details.startedAt, 'startedAt'),
+      turnId: details.turnId,
+    });
+  }
+  const terminal = {
+    ...clone(receipt),
+    status,
+    endedAt: isoTimestamp(details.endedAt, 'endedAt'),
+    toolSummary: summarizeCronToolCalls(details.toolCalls || []),
+    outputs: normalizeCronOutputs(details.outputs || []),
+    finalMessageRef: typeof details.finalStepId === 'string' && details.finalStepId.length > 0
+      ? {stepId: assertOpaqueId(details.finalStepId, 'finalStepId')}
+      : null,
+  };
+  const error = safeCronRunError(status, details.error);
+  if (error !== undefined) terminal.error = error;
+  return deepFreeze(terminal);
+}
+
+function markCronJobDeleted(receipt) {
+  return deepFreeze({...clone(receipt), jobDeleted: true});
+}
+
+function isValidCronRunReceipt(value) {
+  if (!value || typeof value !== 'object') return false;
+  try {
+    assertOpaqueId(value.runId, 'runId');
+    assertOpaqueId(value.jobId, 'jobId');
+    isoTimestamp(value.firedAt, 'firedAt');
+    if (!ALL_STATUSES.has(value.status)) return false;
+    if (!Array.isArray(value.outputs) || !value.toolSummary || typeof value.toolSummary.calls !== 'number') return false;
+    if (value.status === 'running' && (!Number.isSafeInteger(value.turnId) || value.startedAt === null)) return false;
+    if (TERMINAL_STATUSES.has(value.status) && value.endedAt === null) return false;
+    return assertCronRunReceiptPrivacy(value);
+  } catch {
+    return false;
+  }
+}
+
+function publicCronRunList(receipts, {jobId, status, limit = 20} = {}) {
+  if (!Array.isArray(receipts)) fail('CRON_RUN_INVALID_LIST', 'receipts must be an array');
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LIST_LIMIT) {
+    fail('CRON_RUN_INVALID_LIMIT', `limit must be between 1 and ${MAX_LIST_LIMIT}`);
+  }
+  if (status !== undefined && !ALL_STATUSES.has(status)) fail('CRON_RUN_INVALID_STATUS', 'Unknown cron run status');
+  return receipts
+    .filter((receipt) => jobId === undefined || receipt.jobId === jobId)
+    .filter((receipt) => status === undefined || receipt.status === status)
+    .sort((left, right) => Date.parse(right.firedAt) - Date.parse(left.firedAt))
+    .slice(0, limit)
+    .map((receipt) => ({
+      runId: receipt.runId,
+      jobId: receipt.jobId,
+      status: receipt.status,
+      firedAt: receipt.firedAt,
+      startedAt: receipt.startedAt,
+      endedAt: receipt.endedAt,
+      coalescedCount: receipt.coalescedCount,
+      toolCalls: receipt.toolSummary.calls,
+      toolErrors: receipt.toolSummary.errors,
+      outputCount: receipt.outputs.length,
+      finalMessageAvailable: receipt.finalMessageRef !== null,
+    }));
+}
+
+function assertCronRunReceiptPrivacy(receipt, canaries = []) {
+  const serialized = JSON.stringify(receipt);
+  const forbidden = ['thoughts', 'reasoning', 'prompt', 'arguments', 'results', 'headers', 'approvalFeedback', 'rawError'];
+  for (const key of forbidden) {
+    if (new RegExp(`"${key}"\\s*:`, 'u').test(serialized)) {
+      fail('CRON_RUN_PRIVATE_FIELD', `Forbidden cron receipt field: ${key}`);
+    }
+  }
+  for (const canary of canaries) {
+    if (typeof canary === 'string' && canary.length > 0 && serialized.includes(canary)) {
+      fail('CRON_RUN_SECRET_LEAK', 'Cron receipt contains a secret canary');
+    }
+  }
+  return true;
+}
+
+module.exports = {
+  MAX_ALLOWED_TOOLS,
+  MAX_LIST_LIMIT,
+  MAX_RECEIPT_OUTPUTS,
+  ScopedCronRunError,
+  assertCronRunReceiptPrivacy,
+  buildCronFileCandidate,
+  createCronRunReceipt,
+  cronToolScopeDigest,
+  cronToolScopeForTask,
+  filterToolsForCronScope,
+  inheritedCronToolScope,
+  isCronToolScope,
+  isValidCronRunReceipt,
+  markCronJobDeleted,
+  normalizeCronAllowedTools,
+  publicCronRunList,
+  summarizeCronToolCalls,
+  transitionCronRunReceipt,
+};

package/bin/session-checkpoint-policy.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const TOOL_ABORTED_BEFORE_DISPATCH = 'TOOL_ABORTED_BEFORE_DISPATCH';
+
+async function checkpointBeforeExternalSideEffect(options = {}) {
+  const flush = options.flush;
+  const signal = options.signal;
+  if (typeof flush !== 'function') {
+    throw new TypeError('checkpointBeforeExternalSideEffect requires flush');
+  }
+  await flush();
+  if (signal?.aborted === true) {
+    return {
+      allowed: false,
+      code: TOOL_ABORTED_BEFORE_DISPATCH,
+      error: 'Tool call aborted before dispatch while its durable checkpoint was being written.',
+    };
+  }
+  return { allowed: true };
+}
+
+module.exports = {
+  TOOL_ABORTED_BEFORE_DISPATCH,
+  checkpointBeforeExternalSideEffect,
+};

package/bin/startup-preferences.cjs

@@ -20,7 +20,7 @@ function safeConfigPath(profileHome, fsImpl = fs) {
 
 function parseStartupPreferences(text) {
   let section = '';
-  let autoInstall = true;
+  let autoInstall = false;
   let uiLocale = 'en';
 
   for (const line of String(text).replace(/^\uFEFF/u, '').split(/\r?\n/u)) {
@@ -47,11 +47,11 @@ function parseStartupPreferences(text) {
 
 function readStartupPreferences(profileHome, fsImpl = fs) {
   const configPath = safeConfigPath(profileHome, fsImpl);
-  if (!configPath) return { autoInstall: true, uiLocale: 'en' };
+  if (!configPath) return { autoInstall: false, uiLocale: 'en' };
   try {
     return parseStartupPreferences(fsImpl.readFileSync(configPath, 'utf8'));
   } catch {
-    return { autoInstall: true, uiLocale: 'en' };
+    return { autoInstall: false, uiLocale: 'en' };
   }
 }
 
@@ -125,6 +125,7 @@ function migrateLegacyStartupPreferences(profileHome, fsImpl = fs) {
 
 module.exports = {
   migrateLegacyStartupPreferences,
+  parseStartupPreferences,
   readStartupPreferences,
   resolveStartupUiLocale,
 };