ultra-builder-pro-cli 0.25.1 → 0.26.0

package/mcp-server/lib/runtime-state.cjs

@@ -1,222 +0,0 @@
-'use strict';
-
-const { randomUUID } = require('node:crypto');
-
-const ops = require('./state-ops.cjs');
-const defaultProjector = require('./projector.cjs');
-
-class RuntimeStateError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'RuntimeStateError';
-    this.code = code;
-  }
-}
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function parseJson(value) {
-  if (value == null) return null;
-  try { return JSON.parse(value); }
-  catch (error) {
-    throw new RuntimeStateError('STATE_CORRUPT', `invalid runtime JSON: ${error.message}`);
-  }
-}
-
-function rowToIncident(row) {
-  if (!row) return null;
-  return {
-    ...row,
-    retryable: Boolean(row.retryable),
-    evidence: parseJson(row.evidence_json),
-  };
-}
-
-function recordIncident(db, input) {
-  if (!input || !input.code || !input.message) {
-    throw new RuntimeStateError('VALIDATION_ERROR', 'incident code and message required');
-  }
-  return ops.tx(db, () => {
-    const existing = db.prepare(
-      `SELECT * FROM incidents
-       WHERE status = 'open' AND code = ?
-         AND change_id IS ? AND task_id IS ? AND session_id IS ?
-         AND source_kind IS ? AND source_id IS ?
-       ORDER BY first_seen_at ASC LIMIT 1`,
-    ).get(
-      input.code, input.change_id ?? null, input.task_id ?? null, input.session_id ?? null,
-      input.source_kind ?? null, input.source_id ?? null,
-    );
-    const ts = nowIso();
-    if (existing) {
-      db.prepare(
-        `UPDATE incidents SET message = ?, severity = ?, retryable = ?, evidence_json = ?,
-         occurrence_count = occurrence_count + 1, last_seen_at = ? WHERE id = ?`,
-      ).run(
-        input.message, input.severity || 'error', input.retryable ? 1 : 0,
-        input.evidence === undefined ? existing.evidence_json : JSON.stringify(input.evidence),
-        ts, existing.id,
-      );
-      return rowToIncident(db.prepare('SELECT * FROM incidents WHERE id = ?').get(existing.id));
-    }
-    const id = `inc-${randomUUID().slice(0, 12)}`;
-    db.prepare(
-      `INSERT INTO incidents
-       (id, code, severity, retryable, message, change_id, task_id, session_id,
-        source_kind, source_id, evidence_json, first_seen_at, last_seen_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    ).run(
-      id, input.code, input.severity || 'error', input.retryable ? 1 : 0, input.message,
-      input.change_id ?? null, input.task_id ?? null, input.session_id ?? null,
-      input.source_kind ?? null, input.source_id ?? null,
-      input.evidence === undefined ? null : JSON.stringify(input.evidence), ts, ts,
-    );
-    return rowToIncident(db.prepare('SELECT * FROM incidents WHERE id = ?').get(id));
-  });
-}
-
-function resolveIncident(db, id, resolution) {
-  const result = db.prepare(
-    `UPDATE incidents SET status = 'resolved', resolved_at = ?, resolution = ?
-     WHERE id = ? AND status = 'open'`,
-  ).run(nowIso(), resolution || 'resolved', id);
-  return { resolved: result.changes > 0 };
-}
-
-const LIST_INCIDENTS_SQL = "SELECT * FROM incidents WHERE (@status IS NULL OR status = @status) AND (@change_id IS NULL OR change_id = @change_id) AND (@task_id IS NULL OR task_id = @task_id) ORDER BY last_seen_at DESC LIMIT @maxn";
-
-function listIncidents(db, { status = null, change_id = null, task_id = null, limit = 100 } = {}) {
-  return db.prepare(LIST_INCIDENTS_SQL).all({
-    status, change_id, task_id, maxn: Math.min(Math.max(limit, 1), 500),
-  }).map(rowToIncident);
-}
-
-function enqueueProjection(db, { tool_name, event_cursor, max_attempts = 3 } = {}) {
-  if (!tool_name) throw new RuntimeStateError('VALIDATION_ERROR', 'projection tool_name required');
-  const cursor = Number.isInteger(event_cursor)
-    ? event_cursor
-    : Number(db.prepare('SELECT COALESCE(MAX(id), 0) AS id FROM events').get().id);
-  const result = db.prepare(
-    `INSERT INTO projection_jobs (tool_name, event_cursor, max_attempts)
-     VALUES (?, ?, ?)`,
-  ).run(tool_name, cursor, max_attempts);
-  return readProjectionJob(db, Number(result.lastInsertRowid));
-}
-
-function readProjectionJob(db, id) {
-  return db.prepare('SELECT * FROM projection_jobs WHERE id = ?').get(id) || null;
-}
-
-const LIST_PROJECTION_JOBS_SQL = "SELECT * FROM projection_jobs WHERE (@status IS NULL OR status = @status) ORDER BY id ASC LIMIT @maxn";
-
-function listProjectionJobs(db, { status = null, limit = 100 } = {}) {
-  return db.prepare(LIST_PROJECTION_JOBS_SQL).all({
-    status, maxn: Math.min(Math.max(limit, 1), 500),
-  });
-}
-
-function processProjectionJobs(db, {
-  rootDir = '.', project = defaultProjector.projectAll, limit = 10,
-} = {}) {
-  const pending = listProjectionJobs(db, { status: 'pending', limit });
-  const jobs = [];
-  for (const row of pending) {
-    const claimed = db.prepare(
-      "UPDATE projection_jobs SET status = 'running', updated_at = ? WHERE id = ? AND status = 'pending'",
-    ).run(nowIso(), row.id);
-    if (claimed.changes === 0) continue;
-    const active = readProjectionJob(db, row.id);
-    try {
-      const projection = project(db, { rootDir });
-      const ts = nowIso();
-      db.prepare(
-        `UPDATE projection_jobs SET status = 'completed', attempts = attempts + 1,
-         last_error = NULL, updated_at = ?, completed_at = ? WHERE id = ?`,
-      ).run(ts, ts, row.id);
-      const related = db.prepare(
-        "SELECT id FROM incidents WHERE status = 'open' AND source_kind = 'projection_job' AND source_id = ?",
-      ).all(String(row.id));
-      for (const incident of related) resolveIncident(db, incident.id, 'projection completed on retry');
-      jobs.push({ id: row.id, status: 'completed', projection });
-    } catch (error) {
-      const attempts = active.attempts + 1;
-      const status = attempts >= active.max_attempts ? 'failed' : 'pending';
-      db.prepare(
-        `UPDATE projection_jobs SET status = ?, attempts = ?, last_error = ?, updated_at = ?
-         WHERE id = ?`,
-      ).run(status, attempts, error.message, nowIso(), row.id);
-      const incident = recordIncident(db, {
-        code: 'PROJECTION_FAILED', severity: 'error', retryable: true,
-        message: error.message, source_kind: 'projection_job', source_id: String(row.id),
-        evidence: { tool_name: row.tool_name, event_cursor: row.event_cursor, attempts },
-      });
-      jobs.push({ id: row.id, status: status === 'pending' ? 'retrying' : 'failed', error: error.message, incident_id: incident.id });
-    }
-  }
-  return { processed: jobs.length, jobs };
-}
-
-function requeueInterruptedProjections(db, { staleBefore } = {}) {
-  const cutoff = staleBefore || new Date(Date.now() - 5 * 60 * 1000).toISOString();
-  if (typeof cutoff !== 'string' || Number.isNaN(Date.parse(cutoff))) {
-    throw new RuntimeStateError('VALIDATION_ERROR', 'staleBefore must be an ISO date-time');
-  }
-  const result = db.prepare(
-    `UPDATE projection_jobs
-     SET status = 'pending', last_error = 'interrupted projection requeued by doctor',
-         updated_at = ?, completed_at = NULL
-     WHERE status = 'running' AND updated_at < ?`,
-  ).run(nowIso(), cutoff);
-  return { requeued: result.changes, stale_before: cutoff };
-}
-
-function requeueFailedProjections(db) {
-  const result = db.prepare(
-    "UPDATE projection_jobs SET status = 'pending', attempts = 0, updated_at = ? WHERE status = 'failed'",
-  ).run(nowIso());
-  return { requeued: result.changes };
-}
-
-function ensureProjectionJob(db, { tool_name = 'runtime.reconcile' } = {}) {
-  const eventCursor = Number(db.prepare('SELECT COALESCE(MAX(id), 0) AS id FROM events').get().id);
-  const projectedCursor = Number(db.prepare(
-    "SELECT COALESCE(MAX(event_cursor), 0) AS id FROM projection_jobs WHERE status IN ('pending', 'running', 'completed')",
-  ).get().id);
-  if (eventCursor <= projectedCursor) return { enqueued: false, event_cursor: eventCursor };
-  return { enqueued: true, job: enqueueProjection(db, { tool_name, event_cursor: eventCursor }) };
-}
-
-function readConsumerCursor(db, name) {
-  const row = db.prepare('SELECT cursor FROM event_consumers WHERE name = ?').get(name);
-  return row ? Number(row.cursor) : 0;
-}
-
-function writeConsumerCursor(db, name, cursor) {
-  if (!name || !Number.isInteger(cursor) || cursor < 0) {
-    throw new RuntimeStateError('VALIDATION_ERROR', 'consumer name and non-negative cursor required');
-  }
-  db.prepare(
-    `INSERT INTO event_consumers (name, cursor, updated_at) VALUES (?, ?, ?)
-     ON CONFLICT(name) DO UPDATE SET
-       cursor = MAX(event_consumers.cursor, excluded.cursor), updated_at = excluded.updated_at`,
-  ).run(name, cursor, nowIso());
-  return { name, cursor: readConsumerCursor(db, name) };
-}
-
-module.exports = {
-  RuntimeStateError,
-  recordIncident,
-  resolveIncident,
-  listIncidents,
-  enqueueProjection,
-  readProjectionJob,
-  listProjectionJobs,
-  processProjectionJobs,
-  requeueInterruptedProjections,
-  requeueFailedProjections,
-  ensureProjectionJob,
-  readConsumerCursor,
-  writeConsumerCursor,
-};

package/mcp-server/lib/safe-project-file.cjs

@@ -1,385 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-class SafeProjectFileError extends Error {
-  constructor(code, message, details = undefined) {
-    super(message);
-    this.name = 'SafeProjectFileError';
-    this.code = code;
-    if (details !== undefined) this.details = details;
-  }
-}
-
-function fail(code, message, details = undefined) {
-  throw new SafeProjectFileError(code, message, details);
-}
-
-function normalizeProjectRelative(value) {
-  if (typeof value !== 'string' || value.trim() === '') {
-    fail('PROJECT_FILE_PATH_INVALID', 'project file path is required');
-  }
-  const raw = value.trim().replaceAll('\\', '/');
-  if (path.posix.isAbsolute(raw) || path.win32.isAbsolute(raw)) {
-    fail('PROJECT_FILE_PATH_INVALID', 'project file path must be project-relative');
-  }
-  const relative = path.posix.normalize(raw).replace(/^\.\//, '');
-  if (relative === '.' || relative === '..' || relative.startsWith('../')) {
-    fail('PROJECT_FILE_PATH_INVALID', `project file path escapes the project: ${value}`);
-  }
-  return relative;
-}
-
-function identity(stat) {
-  return {
-    dev: String(stat.dev),
-    ino: String(stat.ino),
-    mode: stat.mode,
-  };
-}
-
-function sameIdentity(left, right) {
-  return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode;
-}
-
-function fileVersion(stat) {
-  return {
-    size: String(stat.size),
-    mtime_ns: String(stat.mtimeNs),
-    ctime_ns: String(stat.ctimeNs),
-  };
-}
-
-function sameFileVersion(left, right) {
-  return left.size === right.size
-    && left.mtime_ns === right.mtime_ns
-    && left.ctime_ns === right.ctime_ns;
-}
-
-function inspectProjectRoot(rootDir) {
-  const root = path.resolve(rootDir);
-  let stat;
-  try {
-    stat = fs.lstatSync(root);
-  } catch (cause) {
-    fail('PROJECT_ROOT_UNSAFE', `project root is unavailable: ${root}`, {
-      cause: cause.message,
-    });
-  }
-  if (stat.isSymbolicLink() || !stat.isDirectory()) {
-    fail('PROJECT_ROOT_UNSAFE', `project root must be a real directory: ${root}`);
-  }
-  let physicalRoot;
-  try {
-    physicalRoot = fs.realpathSync.native(root);
-  } catch (cause) {
-    fail('PROJECT_ROOT_UNSAFE', `project root cannot be resolved safely: ${root}`, {
-      cause: cause.message,
-    });
-  }
-  return {
-    root,
-    physicalRoot,
-    rootIdentity: identity(stat),
-  };
-}
-
-function inspectProjectFile(rootDir, candidate) {
-  const relative = normalizeProjectRelative(candidate);
-  const project = inspectProjectRoot(rootDir);
-  const components = relative.split('/').filter(Boolean);
-  const identities = [{
-    file: project.root,
-    relative: '.',
-    kind: 'directory',
-    ...project.rootIdentity,
-  }];
-  let current = project.physicalRoot;
-  for (let index = 0; index < components.length; index += 1) {
-    current = path.join(current, components[index]);
-    const final = index === components.length - 1;
-    let stat;
-    try {
-      stat = fs.lstatSync(current);
-    } catch (cause) {
-      if (cause?.code === 'ENOENT' || cause?.code === 'ENOTDIR') {
-        fail('PROJECT_FILE_MISSING', `project file does not exist: ${relative}`);
-      }
-      fail('PROJECT_FILE_UNSAFE', `project file cannot be inspected safely: ${relative}`, {
-        component: components.slice(0, index + 1).join('/'),
-        cause: cause.message,
-      });
-    }
-    if (stat.isSymbolicLink()) {
-      fail('PROJECT_FILE_UNSAFE', `project file path contains a symbolic link: ${relative}`, {
-        component: components.slice(0, index + 1).join('/'),
-      });
-    }
-    if (final ? !stat.isFile() : !stat.isDirectory()) {
-      fail(
-        'PROJECT_FILE_UNSAFE',
-        `project file path contains a non-regular ${final ? 'file' : 'ancestor'}: ${relative}`,
-        { component: components.slice(0, index + 1).join('/') },
-      );
-    }
-    let physical;
-    try {
-      physical = fs.realpathSync.native(current);
-    } catch (cause) {
-      fail('PROJECT_FILE_UNSAFE', `project file cannot be resolved safely: ${relative}`, {
-        component: components.slice(0, index + 1).join('/'),
-        cause: cause.message,
-      });
-    }
-    if (physical !== project.physicalRoot
-      && !physical.startsWith(`${project.physicalRoot}${path.sep}`)) {
-      fail('PROJECT_FILE_UNSAFE', `project file escapes the physical project root: ${relative}`, {
-        component: components.slice(0, index + 1).join('/'),
-        physical,
-      });
-    }
-    identities.push({
-      file: current,
-      relative: components.slice(0, index + 1).join('/'),
-      kind: final ? 'file' : 'directory',
-      ...identity(stat),
-    });
-  }
-  return {
-    ...project,
-    relative,
-    file: current,
-    identities,
-    final: identities.at(-1),
-  };
-}
-
-function verifyProjectFileSnapshot(before, fd) {
-  const after = inspectProjectFile(before.root, before.relative);
-  let opened;
-  try {
-    opened = fs.fstatSync(fd);
-  } catch (cause) {
-    fail('PROJECT_FILE_UNSAFE', `project file descriptor is unavailable: ${before.relative}`, {
-      cause: cause.message,
-    });
-  }
-  if (!opened.isFile()
-    || !sameIdentity(identity(opened), before.final)
-    || before.identities.length !== after.identities.length
-    || before.identities.some((entry, index) => (
-      entry.relative !== after.identities[index].relative
-      || entry.kind !== after.identities[index].kind
-      || !sameIdentity(entry, after.identities[index])
-    ))) {
-    fail('PROJECT_FILE_UNSAFE', `project file path changed identity while it was read: ${before.relative}`);
-  }
-}
-
-function readStableFdSnapshot(fd, relative) {
-  let before;
-  try {
-    before = fs.fstatSync(fd, { bigint: true });
-  } catch (cause) {
-    fail('PROJECT_FILE_UNSAFE', `project file descriptor is unavailable: ${relative}`, {
-      cause: cause.message,
-    });
-  }
-  if (!before.isFile()) {
-    fail('PROJECT_FILE_UNSAFE', `project file descriptor is not a regular file: ${relative}`);
-  }
-  const size = Number(before.size);
-  if (!Number.isSafeInteger(size) || size < 0) {
-    fail('PROJECT_FILE_UNSAFE', `project file is too large to read safely: ${relative}`);
-  }
-  const bytes = Buffer.allocUnsafe(size);
-  let offset = 0;
-  while (offset < size) {
-    const count = fs.readSync(fd, bytes, offset, size - offset, offset);
-    if (count === 0) {
-      fail('PROJECT_FILE_CHANGED', `project file changed while it was read: ${relative}`);
-    }
-    offset += count;
-  }
-  const overflow = Buffer.allocUnsafe(1);
-  if (fs.readSync(fd, overflow, 0, 1, size) !== 0) {
-    fail('PROJECT_FILE_CHANGED', `project file changed while it was read: ${relative}`);
-  }
-  const after = fs.fstatSync(fd, { bigint: true });
-  const beforeVersion = fileVersion(before);
-  const afterVersion = fileVersion(after);
-  if (!after.isFile() || !sameFileVersion(beforeVersion, afterVersion)) {
-    fail('PROJECT_FILE_CHANGED', `project file changed while it was read: ${relative}`, {
-      before: beforeVersion,
-      after: afterVersion,
-    });
-  }
-  return {
-    bytes,
-    version: afterVersion,
-    digest: crypto.createHash('sha256').update(bytes).digest('hex'),
-  };
-}
-
-function openStableProjectRead(rootDir, candidate) {
-  const snapshot = inspectProjectFile(rootDir, candidate);
-  let fd;
-  try {
-    fd = fs.openSync(
-      snapshot.file,
-      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0),
-    );
-    verifyProjectFileSnapshot(snapshot, fd);
-    const initial = readStableFdSnapshot(fd, snapshot.relative);
-    verifyProjectFileSnapshot(snapshot, fd);
-    return {
-      root: snapshot.root,
-      physicalRoot: snapshot.physicalRoot,
-      relative: snapshot.relative,
-      file: snapshot.file,
-      bytes: initial.bytes,
-      digest: initial.digest,
-      verify() {
-        verifyProjectFileSnapshot(snapshot, fd);
-        const current = readStableFdSnapshot(fd, snapshot.relative);
-        if (!sameFileVersion(initial.version, current.version)
-          || initial.digest !== current.digest) {
-          fail('PROJECT_FILE_CHANGED', `project file changed after it was read: ${snapshot.relative}`, {
-            expected_digest: initial.digest,
-            actual_digest: current.digest,
-            expected_version: initial.version,
-            actual_version: current.version,
-          });
-        }
-        verifyProjectFileSnapshot(snapshot, fd);
-      },
-      close() {
-        if (fd !== undefined) {
-          fs.closeSync(fd);
-          fd = undefined;
-        }
-      },
-    };
-  } catch (error) {
-    if (fd !== undefined) fs.closeSync(fd);
-    if (error instanceof SafeProjectFileError) throw error;
-    if (error?.code === 'ENOENT') {
-      fail('PROJECT_FILE_MISSING', `project file does not exist: ${snapshot.relative}`);
-    }
-    fail(
-      'PROJECT_FILE_UNSAFE',
-      `project file cannot be opened without following links: ${snapshot.relative}`,
-      { cause: error.message },
-    );
-  }
-}
-
-function readStableProjectFile(rootDir, candidate, { encoding = null } = {}) {
-  const reader = openStableProjectRead(rootDir, candidate);
-  try {
-    reader.verify();
-    return {
-      root: reader.root,
-      physicalRoot: reader.physicalRoot,
-      relative: reader.relative,
-      file: reader.file,
-      bytes: reader.bytes,
-      text: encoding ? reader.bytes.toString(encoding) : null,
-      digest: reader.digest,
-    };
-  } finally {
-    reader.close();
-  }
-}
-
-function walkStableProjectTree(rootDir, candidate, {
-  ignore = () => false,
-} = {}) {
-  const relativeRoot = normalizeProjectRelative(candidate);
-  const project = inspectProjectRoot(rootDir);
-  const absoluteRoot = path.join(project.physicalRoot, ...relativeRoot.split('/'));
-  let rootStat;
-  try {
-    rootStat = fs.lstatSync(absoluteRoot);
-  } catch (cause) {
-    if (cause?.code === 'ENOENT') return { files: [], unsafe: [] };
-    return {
-      files: [],
-      unsafe: [{ path: relativeRoot, reason: cause.message }],
-    };
-  }
-  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
-    return {
-      files: [],
-      unsafe: [{
-        path: relativeRoot,
-        reason: rootStat.isSymbolicLink()
-          ? 'tree root is a symbolic link'
-          : 'tree root is not a directory',
-      }],
-    };
-  }
-  const files = [];
-  const unsafe = [];
-
-  const visit = (directory, relative, expected) => {
-    let entries;
-    try {
-      const before = fs.lstatSync(directory);
-      if (before.isSymbolicLink() || !before.isDirectory()
-        || !sameIdentity(identity(before), expected)) {
-        unsafe.push({ path: relative, reason: 'directory identity changed' });
-        return;
-      }
-      entries = fs.readdirSync(directory, { withFileTypes: true });
-      const after = fs.lstatSync(directory);
-      if (after.isSymbolicLink() || !after.isDirectory()
-        || !sameIdentity(identity(after), expected)) {
-        unsafe.push({ path: relative, reason: 'directory identity changed while listed' });
-        return;
-      }
-    } catch (cause) {
-      unsafe.push({ path: relative, reason: cause.message });
-      return;
-    }
-    for (const entry of entries) {
-      const childRelative = `${relative}/${entry.name}`;
-      const child = path.join(directory, entry.name);
-      let stat;
-      try {
-        stat = fs.lstatSync(child);
-      } catch (cause) {
-        unsafe.push({ path: childRelative, reason: cause.message });
-        continue;
-      }
-      if (stat.isSymbolicLink()) {
-        unsafe.push({ path: childRelative, reason: 'tree entry is a symbolic link' });
-        continue;
-      }
-      if (ignore(childRelative, entry, stat)) continue;
-      if (stat.isDirectory()) {
-        visit(child, childRelative, identity(stat));
-        continue;
-      }
-      if (!stat.isFile()) {
-        unsafe.push({ path: childRelative, reason: 'tree entry is not a regular file' });
-        continue;
-      }
-      files.push(childRelative);
-    }
-  };
-
-  visit(absoluteRoot, relativeRoot, identity(rootStat));
-  return { files, unsafe };
-}
-
-module.exports = {
-  SafeProjectFileError,
-  inspectProjectFile,
-  normalizeProjectRelative,
-  openStableProjectRead,
-  readStableProjectFile,
-  walkStableProjectTree,
-};