@yemi33/minions 0.1.2424 → 0.1.2426

package/engine/content-api-validation.js

@@ -0,0 +1,606 @@
+'use strict';
+
+const path = require('path');
+const api = require('./api-validation');
+const shared = require('./shared');
+const memoryStore = require('./memory-store');
+
+const LIMITS = Object.freeze({
+  title: 200,
+  content: 512 * 1024,
+  author: 100,
+  reason: 64 * 1024,
+  basename: 255,
+  pinCount: 500,
+  pinKey: 512,
+  memoryQuery: 500,
+  memoryLimit: 100,
+  skillDir: 2048,
+  skillSource: 200,
+});
+const PIN_LEVELS = Object.freeze(['info', 'warning', 'critical']);
+const DEFAULT_MEMORY_SEARCH_LIMIT = 20;
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+const WINDOWS_INVALID_FILENAME_PATTERN = /[<>:"|?*\x00-\x1f]/;
+const WINDOWS_RESERVED_FILENAME_PATTERN =
+  /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9]|conin\$|conout\$)(?:\..*)?$/i;
+
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function reject(message, options = {}) {
+  throw new api.ApiInputError(message, {
+    code: options.code || 'invalid-input',
+    field: options.field,
+    path: options.path || (options.field ? ['body', options.field] : undefined),
+    expected: options.expected,
+    rejectedValue: options.rejectedValue,
+    allowedValues: options.allowedValues,
+    min: options.min,
+    max: options.max,
+    minLength: options.minLength,
+    maxLength: options.maxLength,
+  });
+}
+
+function validateBody(body) {
+  return api.validatePlainObject(body, { field: 'body', path: 'body' });
+}
+
+function validateSingleLine(value, options = {}) {
+  const normalized = api.validateString(value, {
+    field: options.field,
+    path: options.path,
+    trim: options.trim !== false,
+    allowEmpty: options.allowEmpty === true,
+    minLength: options.allowEmpty === true ? 0 : 1,
+    maxLength: options.maxLength,
+  });
+  if (/[\0\r\n]/.test(normalized)) {
+    reject(`${options.field || 'value'} must be a single line`, {
+      code: 'invalid-string',
+      field: options.field,
+      path: options.path,
+      expected: 'single-line string',
+      rejectedValue: value,
+      maxLength: options.maxLength,
+    });
+  }
+  return normalized;
+}
+
+function validateTitle(value, options = {}) {
+  const title = validateSingleLine(value, {
+    field: options.field || 'title',
+    path: options.path,
+    maxLength: LIMITS.title,
+  });
+  if (/(?:^|[\\/])\.\.(?:$|[\\/])/.test(title)) {
+    reject(`${options.field || 'title'} contains an unsafe path segment`, {
+      code: 'invalid-title',
+      field: options.field || 'title',
+      path: options.path,
+      expected: 'single-line title without traversal segments',
+      rejectedValue: value,
+      maxLength: LIMITS.title,
+    });
+  }
+  if (options.requireSlug && !shared.slugify(title, 60)) {
+    reject(`${options.field || 'title'} must produce a safe file name`, {
+      code: 'invalid-title',
+      field: options.field || 'title',
+      path: options.path,
+      expected: 'title containing letters or numbers',
+      rejectedValue: value,
+      maxLength: LIMITS.title,
+    });
+  }
+  return title;
+}
+
+function validateFreeForm(value, options = {}) {
+  if (value === undefined) {
+    if (options.required) {
+      reject(`${options.field || 'content'} is required`, {
+        code: 'invalid-string',
+        field: options.field,
+        path: options.path,
+        expected: 'string',
+        rejectedValue: value,
+        minLength: 1,
+        maxLength: options.maxLength || LIMITS.content,
+      });
+    }
+    return options.defaultValue === undefined ? '' : options.defaultValue;
+  }
+  const text = api.validateString(value, {
+    field: options.field,
+    path: options.path,
+    maxLength: options.maxLength || LIMITS.content,
+  });
+  if (options.required && !text.trim()) {
+    reject(`${options.field || 'content'} is required`, {
+      code: 'invalid-string',
+      field: options.field,
+      path: options.path,
+      expected: 'non-blank string',
+      rejectedValue: value,
+      minLength: 1,
+      maxLength: options.maxLength || LIMITS.content,
+    });
+  }
+  return text;
+}
+
+function decodePathValue(value, options = {}) {
+  const raw = api.validateString(value, {
+    field: options.field,
+    path: options.path,
+    trim: false,
+    allowEmpty: false,
+    minLength: 1,
+    maxLength: options.maxLength || LIMITS.basename,
+  });
+  let decoded;
+  try {
+    decoded = decodeURIComponent(raw);
+  } catch {
+    reject(`${options.field || 'path'} has invalid percent encoding`, {
+      code: 'invalid-path-encoding',
+      field: options.field,
+      path: options.path,
+      expected: 'valid percent-encoded path component',
+      rejectedValue: raw,
+      maxLength: options.maxLength || LIMITS.basename,
+    });
+  }
+  if (!decoded.trim() || decoded.trim() !== decoded || /[\0\r\n]/.test(decoded)) {
+    reject(`${options.field || 'path'} is not a valid path component`, {
+      code: 'invalid-path',
+      field: options.field,
+      path: options.path,
+      expected: 'non-blank path component without control characters',
+      rejectedValue: raw,
+      maxLength: options.maxLength || LIMITS.basename,
+    });
+  }
+  return decoded;
+}
+
+function validateSafeBasename(value, options = {}) {
+  const field = options.field || 'name';
+  const decoded = decodePathValue(value, {
+    field,
+    path: options.path,
+    maxLength: options.maxLength || LIMITS.basename,
+  });
+  const unsafe = decoded === '.'
+    || decoded === '..'
+    || decoded.includes('\0')
+    || decoded.includes('/')
+    || decoded.includes('\\')
+    || path.isAbsolute(decoded)
+    || path.win32.isAbsolute(decoded)
+    || path.basename(decoded) !== decoded
+    || path.win32.basename(decoded) !== decoded
+    || WINDOWS_INVALID_FILENAME_PATTERN.test(decoded)
+    || WINDOWS_RESERVED_FILENAME_PATTERN.test(decoded)
+    || /[. ]$/.test(decoded);
+  if (unsafe) {
+    reject(`${field} must be a safe file name`, {
+      code: 'invalid-file-name',
+      field,
+      path: options.path,
+      expected: options.extension ? `safe *${options.extension} basename` : 'safe basename',
+      rejectedValue: value,
+      maxLength: options.maxLength || LIMITS.basename,
+    });
+  }
+  if (options.extension && !decoded.toLowerCase().endsWith(options.extension.toLowerCase())) {
+    reject(`${field} must end with ${options.extension}`, {
+      code: 'invalid-file-name',
+      field,
+      path: options.path,
+      expected: `safe *${options.extension} basename`,
+      rejectedValue: value,
+      maxLength: options.maxLength || LIMITS.basename,
+    });
+  }
+  if (options.baseDir) {
+    try {
+      const resolved = shared.sanitizePath(decoded, options.baseDir);
+      if (path.dirname(resolved) !== path.resolve(options.baseDir)) throw new Error('nested path');
+    } catch {
+      reject(`${field} must be a safe file name`, {
+        code: 'invalid-file-name',
+        field,
+        path: options.path,
+        expected: options.extension ? `safe *${options.extension} basename` : 'safe basename',
+        rejectedValue: value,
+        maxLength: options.maxLength || LIMITS.basename,
+      });
+    }
+  }
+  return decoded;
+}
+
+function validateOptionalSingleLine(value, options = {}) {
+  if (value === undefined || value === '') return options.defaultValue;
+  return validateSingleLine(value, options);
+}
+
+function validateNotesCreate(body) {
+  validateBody(body);
+  const title = validateTitle(body.title);
+  const noteContent = {};
+  for (const field of ['what', 'content', 'description']) {
+    if (hasOwn(body, field)) {
+      noteContent[field] = validateFreeForm(body[field], {
+        field,
+        maxLength: LIMITS.content,
+      });
+    }
+  }
+  let what = '';
+  for (const field of ['what', 'content', 'description']) {
+    if (!hasOwn(noteContent, field)) continue;
+    what = noteContent[field];
+    break;
+  }
+  const why = validateFreeForm(body.why, {
+    field: 'why',
+    maxLength: LIMITS.reason,
+    defaultValue: '',
+  });
+  const author = validateOptionalSingleLine(body.author, {
+    field: 'author',
+    maxLength: LIMITS.author,
+    defaultValue: '',
+  });
+  return { title, what, why, author };
+}
+
+function validateNotesSave(body) {
+  validateBody(body);
+  if (!hasOwn(body, 'content')) {
+    reject('content is required', {
+      code: 'invalid-string',
+      field: 'content',
+      expected: 'string',
+      rejectedValue: undefined,
+      maxLength: LIMITS.content,
+    });
+  }
+  const content = validateFreeForm(body.content, {
+    field: 'content',
+    maxLength: LIMITS.content,
+  });
+  const file = body.file === undefined || body.file === ''
+    ? 'notes.md'
+    : validateSingleLine(body.file, { field: 'file', maxLength: 32 });
+  api.validateEnum(file, {
+    field: 'file',
+    path: ['body', 'file'],
+    values: ['notes.md'],
+  });
+  return { content, file };
+}
+
+function normalizePinLevel(value) {
+  if (value === undefined || value === '') return 'info';
+  return api.validateEnum(value, {
+    field: 'level',
+    path: ['body', 'level'],
+    values: PIN_LEVELS,
+  });
+}
+
+function validatePinnedAdd(body) {
+  validateBody(body);
+  return {
+    title: validateTitle(body.title),
+    content: validateFreeForm(body.content, {
+      field: 'content',
+      required: true,
+      maxLength: LIMITS.content,
+    }),
+    level: normalizePinLevel(body.level),
+  };
+}
+
+function validatePinnedRemove(body) {
+  validateBody(body);
+  return { title: validateTitle(body.title) };
+}
+
+function validatePinnedUpdate(body) {
+  validateBody(body);
+  return {
+    originalTitle: validateTitle(body.originalTitle, { field: 'originalTitle' }),
+    title: validateTitle(body.title),
+    content: validateFreeForm(body.content, {
+      field: 'content',
+      required: true,
+      maxLength: LIMITS.content,
+    }),
+    level: normalizePinLevel(body.level),
+  };
+}
+
+function validatePinKey(value, pathValue) {
+  return validateSingleLine(value, {
+    field: 'key',
+    path: pathValue,
+    maxLength: LIMITS.pinKey,
+  });
+}
+
+function validateKbPinsSet(body) {
+  validateBody(body);
+  api.validateArray(body.pins, {
+    field: 'pins',
+    path: ['body', 'pins'],
+    maxLength: LIMITS.pinCount,
+  });
+  const pins = body.pins.map((value, index) =>
+    validatePinKey(value, ['body', 'pins', index]));
+  return { pins };
+}
+
+function validateKbPinToggle(body) {
+  validateBody(body);
+  return { key: validatePinKey(body.key, ['body', 'key']) };
+}
+
+function validateKnowledgeCategory(value, options = {}) {
+  const category = options.decode
+    ? decodePathValue(value, {
+      field: options.field || 'category',
+      path: options.path,
+      maxLength: 64,
+    })
+    : api.validateString(value, {
+      field: options.field || 'category',
+      path: options.path,
+      trim: false,
+      allowEmpty: false,
+      minLength: 1,
+      maxLength: 64,
+    });
+  const values = options.readable ? shared.KB_READABLE_CATEGORIES : shared.KB_CATEGORIES;
+  if (!values.includes(category)) {
+    reject('invalid category', {
+      code: 'invalid-enum',
+      field: options.field || 'category',
+      path: options.path || ['body', options.field || 'category'],
+      expected: 'enum',
+      rejectedValue: category,
+      allowedValues: values,
+    });
+  }
+  return category;
+}
+
+function validateKnowledgeCreate(body) {
+  validateBody(body);
+  return {
+    category: validateKnowledgeCategory(body.category),
+    title: validateTitle(body.title, { requireSlug: true }),
+    content: validateFreeForm(body.content, {
+      field: 'content',
+      required: true,
+      maxLength: LIMITS.content,
+    }),
+  };
+}
+
+function validateKnowledgeRead(category, file, minionsDir) {
+  const decodedCategory = validateKnowledgeCategory(category, {
+    decode: true,
+    readable: true,
+    path: ['path', 'category'],
+  });
+  const baseDir = path.join(minionsDir, 'knowledge', decodedCategory);
+  return {
+    category: decodedCategory,
+    file: validateSafeBasename(file, {
+      field: 'file',
+      path: ['path', 'file'],
+      extension: '.md',
+      baseDir,
+    }),
+  };
+}
+
+function validateInboxAction(body, minionsDir, options = {}) {
+  validateBody(body);
+  const result = {
+    name: validateSafeBasename(body.name, {
+      field: 'name',
+      path: ['body', 'name'],
+      extension: '.md',
+      baseDir: path.join(minionsDir, 'notes', 'inbox'),
+    }),
+  };
+  if (options.category) result.category = validateKnowledgeCategory(body.category);
+  return result;
+}
+
+function validateKnowledgePinKey(value, index, minionsDir) {
+  const key = validatePinKey(value, ['body', 'pinnedKeys', index]);
+  const parts = key.split('/');
+  if (parts.length !== 3 || parts[0] !== 'knowledge') {
+    reject('pinnedKeys entries must identify knowledge/<category>/<file>', {
+      code: 'invalid-pin-key',
+      field: 'pinnedKeys',
+      path: ['body', 'pinnedKeys', index],
+      expected: 'knowledge/<category>/<file>.md',
+      rejectedValue: value,
+      maxLength: LIMITS.pinKey,
+    });
+  }
+  const category = validateKnowledgeCategory(parts[1], {
+    decode: true,
+    readable: true,
+    field: 'pinnedKeys',
+    path: ['body', 'pinnedKeys', index],
+  });
+  const file = validateSafeBasename(parts[2], {
+    field: 'pinnedKeys',
+    path: ['body', 'pinnedKeys', index],
+    extension: '.md',
+    baseDir: path.join(minionsDir, 'knowledge', category),
+  });
+  return `knowledge/${category}/${file}`;
+}
+
+function validateKnowledgeSweep(body, minionsDir) {
+  validateBody(body);
+  let pinnedKeys;
+  if (body.pinnedKeys !== undefined) {
+    api.validateArray(body.pinnedKeys, {
+      field: 'pinnedKeys',
+      path: ['body', 'pinnedKeys'],
+      maxLength: LIMITS.pinCount,
+    });
+    pinnedKeys = body.pinnedKeys.map((value, index) =>
+      validateKnowledgePinKey(value, index, minionsDir));
+  }
+  const dryRun = body.dryRun === undefined
+    ? undefined
+    : api.validateBoolean(body.dryRun, { field: 'dryRun', path: ['body', 'dryRun'] });
+  return { pinnedKeys, dryRun };
+}
+
+function validateMemorySearch(searchParams) {
+  const query = validateFreeForm(searchParams.get('q'), {
+    field: 'q',
+    path: ['query', 'q'],
+    required: true,
+    maxLength: LIMITS.memoryQuery,
+  }).trim();
+  if (!query) {
+    reject('q is required', {
+      code: 'invalid-string',
+      field: 'q',
+      path: ['query', 'q'],
+      expected: 'non-blank string',
+      rejectedValue: searchParams.get('q'),
+      minLength: 1,
+      maxLength: LIMITS.memoryQuery,
+    });
+  }
+  const statusValue = searchParams.get('status') || 'active';
+  const status = api.validateEnum(statusValue, {
+    field: 'status',
+    path: ['query', 'status'],
+    values: [...memoryStore.STATUSES],
+  });
+  const rawLimit = searchParams.get('limit');
+  let limit = DEFAULT_MEMORY_SEARCH_LIMIT;
+  if (rawLimit !== null && rawLimit !== '') {
+    if (!/^\d+$/.test(rawLimit)) {
+      reject('limit must be an integer', {
+        code: 'invalid-integer',
+        field: 'limit',
+        path: ['query', 'limit'],
+        expected: 'integer',
+        rejectedValue: rawLimit,
+        min: 1,
+        max: LIMITS.memoryLimit,
+      });
+    }
+    limit = api.validateInteger(Number(rawLimit), {
+      field: 'limit',
+      path: ['query', 'limit'],
+    });
+    api.validateRange(limit, {
+      field: 'limit',
+      path: ['query', 'limit'],
+      min: 1,
+      max: LIMITS.memoryLimit,
+    });
+  }
+  return { query, status, limit };
+}
+
+function validateMemoryAction(idValue, body) {
+  const decodedId = decodePathValue(idValue, {
+    field: 'id',
+    path: ['path', 'id'],
+    maxLength: 128,
+  });
+  const id = api.validateIdentifier(decodedId, {
+    field: 'id',
+    path: ['path', 'id'],
+    maxLength: 128,
+    pattern: IDENTIFIER_PATTERN,
+  });
+  validateBody(body);
+  const action = api.validateEnum(body.action, {
+    field: 'action',
+    path: ['body', 'action'],
+    values: [...memoryStore.ACTIONS],
+  });
+  return { id, action };
+}
+
+function validateSkillQuery(searchParams) {
+  const file = validateSafeBasename(searchParams.get('file'), {
+    field: 'file',
+    path: ['query', 'file'],
+  });
+  const dirValue = searchParams.get('dir');
+  const sourceValue = searchParams.get('source');
+  const dir = dirValue === null || dirValue === ''
+    ? null
+    : validateSkillDir(dirValue);
+  const source = sourceValue === null || sourceValue === ''
+    ? ''
+    : validateSingleLine(sourceValue, {
+      field: 'source',
+      path: ['query', 'source'],
+      maxLength: LIMITS.skillSource,
+    });
+  return { file, dir, source };
+}
+
+function validateSkillDir(value) {
+  const decoded = decodePathValue(value, {
+    field: 'dir',
+    path: ['query', 'dir'],
+    maxLength: LIMITS.skillDir,
+  });
+  const segments = decoded.replace(/\\/g, '/').split('/');
+  if (segments.includes('..')) {
+    reject('dir must not contain traversal segments', {
+      code: 'invalid-path',
+      field: 'dir',
+      path: ['query', 'dir'],
+      expected: 'path without traversal segments',
+      rejectedValue: value,
+      maxLength: LIMITS.skillDir,
+    });
+  }
+  return decoded;
+}
+
+module.exports = {
+  LIMITS,
+  PIN_LEVELS,
+  validateNotesCreate,
+  validateNotesSave,
+  validatePinnedAdd,
+  validatePinnedRemove,
+  validatePinnedUpdate,
+  validateKbPinsSet,
+  validateKbPinToggle,
+  validateKnowledgeCreate,
+  validateKnowledgeRead,
+  validateInboxAction,
+  validateKnowledgeSweep,
+  validateMemorySearch,
+  validateMemoryAction,
+  validateSkillQuery,
+};

package/engine/create-pr-worktree.js

@@ -157,9 +157,12 @@ async function prepareCreatePrWorktree({
  * touch a path that doesn't carry the minions ownership marker (so a bad/forged
  * path can never delete an arbitrary directory).
  */
-async function cleanupCreatePrWorktree({ worktreePath, project, projects, _git, _fs } = {}) {
+async function cleanupCreatePrWorktree({
+  worktreePath, project, projects, _git, _fs, _isWorktreePathLive,
+} = {}) {
   const git = _git || ((args, opts) => shared.shellSafeGit(args, opts));
   const fsm = _fs || fs;
+  const isWorktreePathLive = _isWorktreePathLive || shared.isWorktreePathLive;
   if (!worktreePath || typeof worktreePath !== 'string') {
     throw new Error('cleanupCreatePrWorktree: worktreePath required');
   }
@@ -178,6 +181,24 @@ async function cleanupCreatePrWorktree({ worktreePath, project, projects, _git,
   } catch {
     return { ok: false, reason: 'protected-project-overlap' };
   }
+  let marker;
+  try {
+    marker = JSON.parse(fsm.readFileSync(
+      path.join(path.resolve(worktreePath), shared.WORKTREE_OWNER_MARKER),
+      'utf8',
+    ));
+  } catch {
+    return { ok: false, reason: 'invalid-ownership-marker' };
+  }
+  if (!marker || marker.engine !== true || marker.source !== 'cc-create-pr') {
+    return { ok: false, reason: 'not-create-pr-worktree' };
+  }
+  if (project?.name && marker.project !== project.name) {
+    return { ok: false, reason: 'project-ownership-mismatch' };
+  }
+  if (isWorktreePathLive(worktreePath)) {
+    return { ok: false, reason: 'worktree-live' };
+  }
   const fromDir = (project && project.localPath) || worktreePath;
   try {
     await git(['-C', fromDir, 'worktree', 'remove', '--force', worktreePath]);