blun-king-cli 9.1.587 → 9.1.588

package/bin/session-resume-checkpoint.cjs

@@ -1,254 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const RESUME_CHECKPOINT_SCHEMA_VERSION = 2;
-const MAX_RESUME_SNAPSHOT_BYTES = 4 * 1024 * 1024;
-const MAX_RESUME_CHECKPOINT_BYTES = MAX_RESUME_SNAPSHOT_BYTES + 256 * 1024;
-const WIRE_SAMPLE_BYTES = 4096;
-
-function resumeCheckpointPath(wirePath) {
-  return path.join(path.dirname(wirePath), 'resume-checkpoint.json');
-}
-
-function sha256(value) {
-  return crypto.createHash('sha256').update(value).digest('hex');
-}
-
-function invalid(reason) {
-  return { ok: false, reason };
-}
-
-function isNonNegativeInteger(value) {
-  return Number.isSafeInteger(value) && value >= 0;
-}
-
-function sampleRanges(offset) {
-  if (offset === 0) return [];
-  const length = Math.min(WIRE_SAMPLE_BYTES, offset);
-  const starts = [
-    0,
-    Math.max(0, Math.floor((offset - length) / 2)),
-    Math.max(0, offset - length),
-  ];
-  return [...new Set(starts)].map((start) => ({
-    start,
-    length: Math.min(length, offset - start),
-  }));
-}
-
-async function readExact(handle, start, length) {
-  const buffer = Buffer.alloc(length);
-  let filled = 0;
-  while (filled < length) {
-    const { bytesRead } = await handle.read(
-      buffer,
-      filled,
-      length - filled,
-      start + filled,
-    );
-    if (bytesRead === 0) break;
-    filled += bytesRead;
-  }
-  return filled === length ? buffer : buffer.subarray(0, filled);
-}
-
-async function captureWireSamples(handle, offset) {
-  const samples = [];
-  for (const range of sampleRanges(offset)) {
-    const bytes = await readExact(handle, range.start, range.length);
-    if (bytes.length !== range.length) {
-      throw new Error('wire_changed_during_checkpoint');
-    }
-    samples.push({ ...range, sha256: sha256(bytes) });
-  }
-  return samples;
-}
-
-async function writeAtomic(filePath, bytes) {
-  const directory = path.dirname(filePath);
-  const temporaryPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
-  let handle;
-  try {
-    handle = await fs.promises.open(temporaryPath, 'wx', 0o600);
-    await handle.writeFile(bytes);
-    await handle.sync();
-    await handle.close();
-    handle = undefined;
-    await fs.promises.rename(temporaryPath, filePath);
-  } finally {
-    if (handle) await handle.close().catch(() => {});
-    await fs.promises.rm(temporaryPath, { force: true }).catch(() => {});
-  }
-}
-
-async function writeResumeCheckpoint({ wirePath, wireOffset, recordCount, snapshot }) {
-  if (!isNonNegativeInteger(recordCount)) {
-    return { written: false, reason: 'record_count_invalid' };
-  }
-  if (wireOffset !== undefined && !isNonNegativeInteger(wireOffset)) {
-    return { written: false, reason: 'wire_offset_invalid' };
-  }
-
-  let snapshotJson;
-  try {
-    snapshotJson = JSON.stringify(snapshot);
-  } catch {
-    return { written: false, reason: 'snapshot_not_serializable' };
-  }
-  if (snapshotJson === undefined) {
-    return { written: false, reason: 'snapshot_not_serializable' };
-  }
-  const snapshotBytes = Buffer.byteLength(snapshotJson, 'utf8');
-  if (snapshotBytes > MAX_RESUME_SNAPSHOT_BYTES) {
-    return { written: false, reason: 'snapshot_too_large' };
-  }
-
-  const handle = await fs.promises.open(wirePath, 'r');
-  let stat;
-  let offset;
-  let samples;
-  try {
-    stat = await handle.stat();
-    offset = wireOffset ?? stat.size;
-    if (offset > stat.size) {
-      return { written: false, reason: 'wire_truncated' };
-    }
-    if (offset > 0) {
-      const boundary = await readExact(handle, offset - 1, 1);
-      if (boundary.length !== 1 || boundary[0] !== 0x0a) {
-        return { written: false, reason: 'wire_not_line_terminated' };
-      }
-    }
-    samples = await captureWireSamples(handle, offset);
-  } finally {
-    await handle.close();
-  }
-
-  const payload = {
-    schemaVersion: RESUME_CHECKPOINT_SCHEMA_VERSION,
-    createdAt: new Date().toISOString(),
-    wire: {
-      offset,
-      recordCount,
-      sizeAtCheckpoint: offset,
-      identity: {
-        ino: Number.isSafeInteger(stat.ino) ? stat.ino : null,
-        birthtimeMs: Number.isFinite(stat.birthtimeMs) ? stat.birthtimeMs : null,
-        samples,
-      },
-    },
-    snapshot,
-    snapshotSha256: sha256(snapshotJson),
-  };
-  const checkpointBytes = Buffer.from(`${JSON.stringify(payload)}\n`, 'utf8');
-  if (checkpointBytes.length > MAX_RESUME_CHECKPOINT_BYTES) {
-    return { written: false, reason: 'checkpoint_too_large' };
-  }
-
-  await writeAtomic(resumeCheckpointPath(wirePath), checkpointBytes);
-  return {
-    written: true,
-    offset,
-    recordCount,
-    checkpointPath: resumeCheckpointPath(wirePath),
-  };
-}
-
-async function loadResumeCheckpoint({ wirePath }) {
-  const checkpointPath = resumeCheckpointPath(wirePath);
-  let checkpointStat;
-  try {
-    checkpointStat = await fs.promises.stat(checkpointPath);
-  } catch (error) {
-    return invalid(error && error.code === 'ENOENT' ? 'checkpoint_missing' : 'checkpoint_unreadable');
-  }
-  if (checkpointStat.size > MAX_RESUME_CHECKPOINT_BYTES) {
-    return invalid('checkpoint_too_large');
-  }
-
-  let checkpoint;
-  try {
-    checkpoint = JSON.parse(await fs.promises.readFile(checkpointPath, 'utf8'));
-  } catch (error) {
-    return invalid(error instanceof SyntaxError ? 'checkpoint_invalid_json' : 'checkpoint_unreadable');
-  }
-  if (!checkpoint || checkpoint.schemaVersion !== RESUME_CHECKPOINT_SCHEMA_VERSION) {
-    return invalid('checkpoint_schema_unsupported');
-  }
-  const wire = checkpoint.wire;
-  if (
-    !wire
-    || !isNonNegativeInteger(wire.offset)
-    || !isNonNegativeInteger(wire.recordCount)
-    || !wire.identity
-    || !Array.isArray(wire.identity.samples)
-    || typeof checkpoint.snapshotSha256 !== 'string'
-  ) {
-    return invalid('checkpoint_invalid_shape');
-  }
-
-  let snapshotJson;
-  try {
-    snapshotJson = JSON.stringify(checkpoint.snapshot);
-  } catch {
-    return invalid('checkpoint_invalid_snapshot');
-  }
-  if (snapshotJson === undefined || Buffer.byteLength(snapshotJson, 'utf8') > MAX_RESUME_SNAPSHOT_BYTES) {
-    return invalid('checkpoint_invalid_snapshot');
-  }
-  if (sha256(snapshotJson) !== checkpoint.snapshotSha256) {
-    return invalid('checkpoint_snapshot_mismatch');
-  }
-
-  let handle;
-  try {
-    handle = await fs.promises.open(wirePath, 'r');
-    const stat = await handle.stat();
-    if (stat.size < wire.offset) return invalid('wire_truncated');
-    if (wire.offset > 0) {
-      const boundary = await readExact(handle, wire.offset - 1, 1);
-      if (boundary.length !== 1 || boundary[0] !== 0x0a) {
-        return invalid('wire_offset_not_line_boundary');
-      }
-    }
-    for (const sample of wire.identity.samples) {
-      if (
-        !sample
-        || !isNonNegativeInteger(sample.start)
-        || !isNonNegativeInteger(sample.length)
-        || sample.start + sample.length > wire.offset
-        || typeof sample.sha256 !== 'string'
-      ) {
-        return invalid('checkpoint_invalid_shape');
-      }
-      const bytes = await readExact(handle, sample.start, sample.length);
-      if (bytes.length !== sample.length || sha256(bytes) !== sample.sha256) {
-        return invalid('wire_identity_mismatch');
-      }
-    }
-  } catch (error) {
-    return invalid(error && error.code === 'ENOENT' ? 'wire_missing' : 'wire_unreadable');
-  } finally {
-    if (handle) await handle.close().catch(() => {});
-  }
-
-  return {
-    ok: true,
-    offset: wire.offset,
-    recordCount: wire.recordCount,
-    snapshot: checkpoint.snapshot,
-    checkpointPath,
-  };
-}
-
-module.exports = {
-  MAX_RESUME_CHECKPOINT_BYTES,
-  MAX_RESUME_SNAPSHOT_BYTES,
-  RESUME_CHECKPOINT_SCHEMA_VERSION,
-  loadResumeCheckpoint,
-  resumeCheckpointPath,
-  writeResumeCheckpoint,
-};

package/bin/session-scrollback-archive.cjs

@@ -1,229 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const ARCHIVE_SCHEMA_VERSION = 1;
-const INDEX_FILE = 'index.json';
-
-function sessionScrollbackArchiveDirectory(wirePath) {
-  return path.join(path.dirname(wirePath), 'tui-scrollback-v1');
-}
-
-function isNonNegativeInteger(value) {
-  return Number.isSafeInteger(value) && value >= 0;
-}
-
-function writeAtomic(filePath, value) {
-  const temporaryPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
-  try {
-    fs.writeFileSync(temporaryPath, value, {
-      encoding: 'utf8',
-      flag: 'wx',
-      mode: 0o600,
-    });
-    fs.renameSync(temporaryPath, filePath);
-  } finally {
-    try {
-      fs.rmSync(temporaryPath, { force: true });
-    } catch {}
-  }
-}
-
-class SessionScrollbackArchive {
-  constructor({ directory, reset = false, reuse = false }) {
-    if (typeof directory !== 'string' || directory.length === 0) {
-      throw new TypeError('session scrollback directory is required');
-    }
-    this.directory = path.resolve(directory);
-    this.chunks = [];
-    this.loadedChunks = new Map();
-    this.lineCount = 0;
-    this.loadedExisting = false;
-    this.activeTurnCount = undefined;
-
-    if (reset) {
-      this.reset();
-    } else if (reuse) {
-      this.loadExisting();
-    }
-  }
-
-  get totalLines() {
-    return this.lineCount;
-  }
-
-  get loadedChunkCount() {
-    return this.loadedChunks.size;
-  }
-
-  append(lines) {
-    if (!Array.isArray(lines) || !lines.every((line) => typeof line === 'string')) {
-      return false;
-    }
-    if (lines.length === 0) return true;
-
-    fs.mkdirSync(this.directory, { recursive: true });
-    const file = `chunk-${String(this.chunks.length).padStart(8, '0')}-${crypto.randomBytes(6).toString('hex')}.json`;
-    const chunkPath = path.join(this.directory, file);
-    const chunk = {
-      file,
-      startLine: this.lineCount,
-      lineCount: lines.length,
-    };
-
-    try {
-      writeAtomic(chunkPath, JSON.stringify(lines));
-      const nextChunks = [...this.chunks, chunk];
-      const nextLineCount = this.lineCount + lines.length;
-      this.writeIndex(nextChunks, nextLineCount);
-      this.chunks = nextChunks;
-      this.lineCount = nextLineCount;
-      return true;
-    } catch {
-      try {
-        fs.rmSync(chunkPath, { force: true });
-      } catch {}
-      return false;
-    }
-  }
-
-  readRange(start, end) {
-    if (!Number.isFinite(start) || !Number.isFinite(end)) return [];
-    if (start >= end || start >= this.lineCount) return [];
-    const boundedStart = Math.max(0, Math.floor(start));
-    const boundedEnd = Math.min(this.lineCount, Math.floor(end));
-    const output = [];
-
-    for (let index = 0; index < this.chunks.length; index++) {
-      const chunk = this.chunks[index];
-      const chunkEnd = chunk.startLine + chunk.lineCount;
-      if (chunkEnd <= boundedStart) continue;
-      if (chunk.startLine >= boundedEnd) break;
-      const lines = this.readChunk(index);
-      const sliceStart = Math.max(0, boundedStart - chunk.startLine);
-      const sliceEnd = Math.min(lines.length, boundedEnd - chunk.startLine);
-      output.push(...lines.slice(sliceStart, sliceEnd));
-    }
-    return output;
-  }
-
-  setActiveTurnCount(count) {
-    if (!isNonNegativeInteger(count)) return false;
-    if (this.activeTurnCount === count) return true;
-    const previous = this.activeTurnCount;
-    this.activeTurnCount = count;
-    try {
-      fs.mkdirSync(this.directory, { recursive: true });
-      this.writeIndex(this.chunks, this.lineCount);
-      return true;
-    } catch {
-      this.activeTurnCount = previous;
-      return false;
-    }
-  }
-
-  reset() {
-    try {
-      fs.rmSync(this.directory, { recursive: true, force: true });
-    } catch {}
-    this.chunks = [];
-    this.loadedChunks.clear();
-    this.lineCount = 0;
-    this.loadedExisting = false;
-    this.activeTurnCount = undefined;
-  }
-
-  clear() {
-    this.reset();
-  }
-
-  dispose() {
-    this.loadedChunks.clear();
-  }
-
-  loadExisting() {
-    const indexPath = path.join(this.directory, INDEX_FILE);
-    try {
-      const parsed = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
-      if (
-        parsed?.schemaVersion !== ARCHIVE_SCHEMA_VERSION
-        || !isNonNegativeInteger(parsed.totalLines)
-        || !Array.isArray(parsed.chunks)
-      ) {
-        return;
-      }
-
-      let nextLine = 0;
-      const chunks = [];
-      for (const candidate of parsed.chunks) {
-        if (
-          typeof candidate?.file !== 'string'
-          || path.basename(candidate.file) !== candidate.file
-          || !candidate.file.startsWith('chunk-')
-          || !candidate.file.endsWith('.json')
-          || candidate.startLine !== nextLine
-          || !Number.isSafeInteger(candidate.lineCount)
-          || candidate.lineCount <= 0
-        ) {
-          return;
-        }
-        const chunkPath = path.join(this.directory, candidate.file);
-        if (!fs.statSync(chunkPath).isFile()) return;
-        chunks.push({
-          file: candidate.file,
-          startLine: candidate.startLine,
-          lineCount: candidate.lineCount,
-        });
-        nextLine += candidate.lineCount;
-      }
-      if (nextLine !== parsed.totalLines) return;
-
-      this.chunks = chunks;
-      this.lineCount = parsed.totalLines;
-      this.activeTurnCount = isNonNegativeInteger(parsed.activeTurnCount)
-        ? parsed.activeTurnCount
-        : undefined;
-      this.loadedExisting = true;
-    } catch {}
-  }
-
-  readChunk(index) {
-    const loaded = this.loadedChunks.get(index);
-    if (loaded !== undefined) return loaded;
-    const chunk = this.chunks[index];
-    if (chunk === undefined) return [];
-    try {
-      const value = JSON.parse(fs.readFileSync(path.join(this.directory, chunk.file), 'utf8'));
-      if (
-        !Array.isArray(value)
-        || value.length !== chunk.lineCount
-        || !value.every((line) => typeof line === 'string')
-      ) {
-        return [];
-      }
-      this.loadedChunks.set(index, value);
-      return value;
-    } catch {
-      return [];
-    }
-  }
-
-  writeIndex(chunks, totalLines) {
-    writeAtomic(path.join(this.directory, INDEX_FILE), JSON.stringify({
-      schemaVersion: ARCHIVE_SCHEMA_VERSION,
-      totalLines,
-      chunks,
-      ...(isNonNegativeInteger(this.activeTurnCount)
-        ? { activeTurnCount: this.activeTurnCount }
-        : {}),
-    }));
-  }
-}
-
-module.exports = {
-  ARCHIVE_SCHEMA_VERSION,
-  SessionScrollbackArchive,
-  sessionScrollbackArchiveDirectory,
-};

package/bin/skill-activation-performance-policy.cjs

@@ -1,69 +0,0 @@
-'use strict';
-
-const {
-  hasHistoricalOffloadPressure,
-  historyTextChars,
-} = require('./history-offload-pressure-policy.cjs');
-
-const SKILL_ACTIVATION_KEEP_RECENT_MESSAGES = 20;
-const SKILL_ACTIVATION_MIN_CHARS = 4_000;
-const SKILL_ACTIVATION_MARKER = '[Earlier skill activation compacted]';
-
-function compactSkillActivationMessage(message) {
-  if (message?.role !== 'user' || message.origin?.kind !== 'skill_activation') return message;
-  if (!Array.isArray(message.content) || message.content.length !== 1) return message;
-  if (Array.isArray(message.toolCalls) && message.toolCalls.length > 0) return message;
-
-  const part = message.content[0];
-  const skillName = String(message.origin.skillName || '').trim();
-  const skillPath = String(message.origin.skillPath || '').trim();
-  if (
-    part?.type !== 'text'
-    || typeof part.text !== 'string'
-    || part.text.length <= SKILL_ACTIVATION_MIN_CHARS
-    || !skillName
-    || !skillPath
-  ) return message;
-
-  const lines = [
-    SKILL_ACTIVATION_MARKER,
-    'The complete instructions remain available and were removed only from the model projection.',
-    `skill_name: ${skillName}`,
-    `skill_path: ${skillPath}`,
-  ];
-  const trigger = String(message.origin.trigger || '').trim();
-  const skillArgs = String(message.origin.skillArgs || '').trim();
-  if (trigger) lines.push(`trigger: ${trigger}`);
-  if (skillArgs) lines.push(`skill_args: ${skillArgs}`);
-  lines.push('next_step: If this skill still governs the current work, reload it with the Skill tool using skill_name and skill_args when present, or Read skill_path before continuing.');
-
-  return {
-    ...message,
-    content: [{ ...part, text: lines.join('\n') }],
-  };
-}
-
-function compactHistoricalSkillActivations(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-  if (!hasHistoricalOffloadPressure({
-    historyLength: messages.length,
-    historyChars: historyTextChars(messages),
-  })) return messages;
-  const recentStart = Math.max(0, messages.length - SKILL_ACTIVATION_KEEP_RECENT_MESSAGES);
-  let changed = false;
-  const projected = messages.map((message, index) => {
-    if (index >= recentStart) return message;
-    const compacted = compactSkillActivationMessage(message);
-    if (compacted !== message) changed = true;
-    return compacted;
-  });
-  return changed ? projected : messages;
-}
-
-module.exports = {
-  SKILL_ACTIVATION_KEEP_RECENT_MESSAGES,
-  SKILL_ACTIVATION_MARKER,
-  SKILL_ACTIVATION_MIN_CHARS,
-  compactHistoricalSkillActivations,
-  compactSkillActivationMessage,
-};

package/bin/skill-listing-performance-policy.cjs

@@ -1,92 +0,0 @@
-'use strict';
-
-const SKILL_DESCRIPTION_MAX_CHARS = 80;
-const FIRST_USE_SKILLS = new Set([
-  'agent-browser',
-  'windows-mcp',
-  'translate-native',
-  'native-diacritics',
-  'blun-app-design-system',
-  'blun-design-dna',
-]);
-
-const DEFAULT_SEARCH_LIMIT = 12;
-
-function compactDescription(value) {
-  const normalized = String(value || '').replace(/\s+/g, ' ').trim();
-  if (normalized.length <= SKILL_DESCRIPTION_MAX_CHARS) return normalized;
-  return `${normalized.slice(0, SKILL_DESCRIPTION_MAX_CHARS - 1).trimEnd()}...`;
-}
-
-function renderCompactSkillEntry(skill) {
-  const name = String(skill?.name || '').trim();
-  if (!FIRST_USE_SKILLS.has(name.toLowerCase())) return `- ${name}`;
-  const description = compactDescription(skill?.description);
-  return description ? `- ${name}: ${description}` : `- ${name}`;
-}
-
-function renderCompactSkillListing(skills) {
-  return (Array.isArray(skills) ? skills : []).map(renderCompactSkillEntry).join('\n');
-}
-
-function isResidentSkill(skill) {
-  return FIRST_USE_SKILLS.has(String(skill?.name || '').trim().toLowerCase());
-}
-
-function renderResidentSkillListing(skills) {
-  return (Array.isArray(skills) ? skills : [])
-    .filter(isResidentSkill)
-    .map(renderCompactSkillEntry)
-    .join('\n');
-}
-
-function normalizeSearchText(value) {
-  return String(value || '')
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim();
-}
-
-function searchSkills(skills, query, limit = DEFAULT_SEARCH_LIMIT, options = {}) {
-  const normalizedQuery = normalizeSearchText(query);
-  const queryTokens = normalizedQuery.split(/\s+/).filter(Boolean);
-  if (queryTokens.length === 0 || !Number.isFinite(limit) || limit <= 0) return [];
-
-  return (Array.isArray(skills) ? skills : [])
-    .filter((skill) => options.includeModelDisabled === true || skill?.metadata?.disableModelInvocation !== true)
-    .map((skill) => {
-      const name = normalizeSearchText(skill?.name);
-      const description = normalizeSearchText(skill?.description);
-      const searchable = `${name} ${description}`.trim();
-      if (!queryTokens.every((token) => searchable.includes(token))) return null;
-      const score = name === normalizedQuery ? 0 : name.startsWith(normalizedQuery) ? 1 : name.includes(normalizedQuery) ? 2 : 3;
-      return { skill, name, score };
-    })
-    .filter(Boolean)
-    .sort((left, right) => left.score - right.score || left.name.localeCompare(right.name))
-    .slice(0, Math.floor(limit))
-    .map((entry) => entry.skill);
-}
-
-function renderSkillSearchResult(query, skills) {
-  const lines = [`No exact skill named "${String(query || '').trim()}" was found. Matching skills:`];
-  for (const skill of skills) {
-    const description = compactDescription(skill?.description);
-    lines.push(description ? `- ${skill.name}: ${description}` : `- ${skill.name}`);
-  }
-  lines.push('Call the Skill tool again with one exact skill name from this list.');
-  return lines.join('\n');
-}
-
-module.exports = {
-  DEFAULT_SEARCH_LIMIT,
-  SKILL_DESCRIPTION_MAX_CHARS,
-  isResidentSkill,
-  renderCompactSkillEntry,
-  renderCompactSkillListing,
-  renderResidentSkillListing,
-  renderSkillSearchResult,
-  searchSkills,
-};