@agilno-tech/rivet 0.1.0-alpha.0

package/src/config/commands.js

@@ -0,0 +1,206 @@
+const SAFE_COMMAND_RUNNERS = new Set([
+  'npm', 'npm.cmd', 'pnpm', 'pnpm.cmd', 'yarn', 'yarn.cmd', 'bun',
+]);
+const LOGICAL_COMMANDS = Object.freeze(['build', 'test', 'lint', 'typecheck']);
+const LEGACY_COMMANDS = Object.freeze([...LOGICAL_COMMANDS, 'dev']);
+const WINDOWS_RESERVED = /^(?:con|prn|aux|nul|conin\$|conout\$|com[1-9]|lpt[1-9])(?:\..*)?$/i;
+const SCRIPT = /^(?!.*\.\.)[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_STEPS = 32;
+const MAX_QUALITY_STEPS = 64;
+
+export class CommandConfigurationError extends Error {
+  constructor(path, reason) {
+    super('Project command configuration is invalid.');
+    this.name = 'CommandConfigurationError';
+    this.path = path;
+    this.reason = reason;
+  }
+}
+
+function fail(path, reason) {
+  throw new CommandConfigurationError(path, reason);
+}
+
+export function isExecutionCompatibleCwd(value) {
+  if (value === '.') return true;
+  if (typeof value !== 'string' || value.length < 1 || value.length > 300
+    || value.normalize('NFKC') !== value || /[\\:\u0000-\u001f\u007f]/.test(value)
+    || value.startsWith('-') || value.startsWith('/') || value.endsWith('/') || value.includes('//')) return false;
+  const parts = value.split('/');
+  if (parts.some(part => !part || part === '.' || part === '..' || part.endsWith('.') || part.endsWith(' ')
+    || WINDOWS_RESERVED.test(part) || part.toLowerCase() === '.git')) return false;
+  return true;
+}
+
+function validCwd(value, path) {
+  if (!isExecutionCompatibleCwd(value)) fail(path, 'unsafe-path');
+  return value;
+}
+
+function validArgv(value, logicalId, path, allowTypeCheckAlias) {
+  if (!Array.isArray(value) || value.length !== 3
+    || Reflect.ownKeys(value).length !== 4) fail(path, 'command-grammar');
+  const argv = value.map((item, index) => {
+    if (typeof item !== 'string') fail(`${path}/${index}`, 'command-grammar');
+    return item;
+  });
+  const [runner, verb, script] = argv;
+  if (!SAFE_COMMAND_RUNNERS.has(runner.toLowerCase())) fail(`${path}/0`, 'unsafe-executable');
+  if (verb !== 'run' || !SCRIPT.test(script)) fail(path, 'command-grammar');
+  if (script !== logicalId && !(allowTypeCheckAlias && logicalId === 'typecheck' && script === 'type-check')) {
+    fail(`${path}/2`, 'command-script-binding');
+  }
+  return Object.freeze(argv);
+}
+
+// Schema 3 grants execution only to these exact reviewed argv values.
+const DIRECT_EXECUTABLE = /^[A-Za-z][A-Za-z0-9._+-]{0,127}$/;
+const SHELL_EXECUTABLE = /^(?:sh|bash|dash|mksh|yash|zsh|fish|nu|elvish|cmd|powershell|pwsh|env|sudo)(?:\.exe|\.cmd)?$/i;
+export function isProjectExecutable(value) {
+  return typeof value === 'string' && value.startsWith('./') && value.length > 2
+    && isExecutionCompatibleCwd(value.slice(2))
+    && !SHELL_EXECUTABLE.test(value.split('/').at(-1));
+}
+
+export function commandToolKey(runner, cwd = '.') {
+  return runner.startsWith('./') ? JSON.stringify([cwd, runner]) : runner;
+}
+
+function directArgv(value, path) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 257
+    || Reflect.ownKeys(value).length !== value.length + 1) fail(path, 'command-grammar');
+  const argv = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor?.enumerable || !Object.hasOwn(descriptor, 'value')
+      || typeof descriptor.value !== 'string' || descriptor.value.length > 4096
+      || /[\u0000-\u001f\u007f-\u009f]/.test(descriptor.value)) fail(path, 'command-grammar');
+    argv.push(descriptor.value);
+  }
+  if ((!DIRECT_EXECUTABLE.test(argv[0]) && !isProjectExecutable(argv[0])) || SHELL_EXECUTABLE.test(argv[0])) fail(path, 'unsafe-executable');
+  return Object.freeze(argv);
+}
+
+function compiledGroup(logicalId, rawSteps, path, allowTypeCheckAlias, direct = false) {
+  if (!Array.isArray(rawSteps) || rawSteps.length < 1 || rawSteps.length > MAX_STEPS
+    || Reflect.ownKeys(rawSteps).length !== rawSteps.length + 1) fail(path, 'command-step-count');
+  const seen = new Set();
+  const multiple = rawSteps.length > 1;
+  const steps = rawSteps.map((raw, index) => {
+    const stepPath = `${path}/${index}`;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)
+      || ![Object.prototype, null].includes(Object.getPrototypeOf(raw))) fail(stepPath, 'command-step');
+    const keys = Reflect.ownKeys(raw);
+    if (keys.length !== 2 || !keys.includes('cwd') || !keys.includes('argv')
+      || keys.some(key => typeof key !== 'string')) fail(stepPath, 'command-step');
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(raw, key);
+      if (!descriptor?.enumerable || !Object.hasOwn(descriptor, 'value')) fail(stepPath, 'command-step');
+    }
+    const cwd = validCwd(raw.cwd, `${stepPath}/cwd`);
+    const argv = direct ? directArgv(raw.argv, `${stepPath}/argv`)
+      : validArgv(raw.argv, logicalId, `${stepPath}/argv`, allowTypeCheckAlias);
+    const identity = JSON.stringify([cwd, ...argv]);
+    if (seen.has(identity)) fail(stepPath, 'duplicate-step');
+    seen.add(identity);
+    return Object.freeze({ id: multiple ? `${logicalId}-${index + 1}` : logicalId, cwd, argv, ...(direct ? { execution: 'argv' } : {}) });
+  });
+  return Object.freeze({ logicalId, steps: Object.freeze(steps) });
+}
+
+export function compileProjectDependencies(project) {
+  if (!project || typeof project !== 'object' || Array.isArray(project)) fail('/project', 'project');
+  const descriptor = Object.getOwnPropertyDescriptor(project, 'dependencies');
+  if (!descriptor) return undefined;
+  if (project.schemaVersion !== 3 || !descriptor.enumerable || !Object.hasOwn(descriptor, 'value')) {
+    fail('/project/dependencies', 'dependencies');
+  }
+  const value = descriptor.value;
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail('/project/dependencies', 'dependencies');
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== 3 || keys.some(key => !['inputs', 'provides', 'steps'].includes(key))) fail('/project/dependencies', 'dependencies');
+  for (const key of keys) {
+    const field = Object.getOwnPropertyDescriptor(value, key);
+    if (!field?.enumerable || !Object.hasOwn(field, 'value')) fail(`/project/dependencies/${key}`, 'dependencies');
+  }
+  const bounded = (array, key) => {
+    if (!Array.isArray(array) || array.length > 16 || Reflect.ownKeys(array).length !== array.length + 1) fail(`/project/dependencies/${key}`, 'dependency-count');
+    for (let index = 0; index < array.length; index += 1) {
+      const item = Object.getOwnPropertyDescriptor(array, String(index));
+      if (!item?.enumerable || !Object.hasOwn(item, 'value')) fail(`/project/dependencies/${key}`, 'dependencies');
+    }
+    return array;
+  };
+  const inputs = bounded(value.inputs, 'inputs').map(path => {
+    if (path === '.' || !isExecutionCompatibleCwd(path)) fail('/project/dependencies/inputs', 'unsafe-path');
+    return path;
+  });
+  const provides = bounded(value.provides, 'provides').map(path => {
+    if (!isProjectExecutable(path)) fail('/project/dependencies/provides', 'unsafe-path');
+    return path;
+  });
+  if (new Set(inputs).size !== inputs.length || new Set(provides).size !== provides.length) fail('/project/dependencies', 'duplicate-step');
+  const steps = compiledGroup('install', bounded(value.steps, 'steps'), '/project/dependencies/steps', false, true).steps;
+  return Object.freeze({ inputs: Object.freeze(inputs), provides: Object.freeze(provides), steps });
+}
+
+export function compileProjectCommands(project) {
+  if (!project || typeof project !== 'object' || Array.isArray(project)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(project))) fail('/project', 'project');
+  const version = project.schemaVersion;
+  if (version !== 1 && version !== 2 && version !== 3) fail('/project/schemaVersion', 'schema-version');
+  const commands = project.commands;
+  if (!commands || typeof commands !== 'object' || Array.isArray(commands)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(commands))) fail('/project/commands', 'commands');
+  const allowed = version === 1 ? LEGACY_COMMANDS : version === 3 ? [...LOGICAL_COMMANDS, 'check'] : LOGICAL_COMMANDS;
+  const expectedManager = typeof project.stack?.packageManager === 'string'
+    ? project.stack.packageManager : null;
+  const keys = Reflect.ownKeys(commands);
+  if (keys.some(key => typeof key !== 'string' || !allowed.includes(key))) fail('/project/commands', 'command-key');
+  const output = Object.create(null);
+  for (const logicalId of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(commands, logicalId);
+    if (!descriptor?.enumerable || !Object.hasOwn(descriptor, 'value')) fail(`/project/commands/${logicalId}`, 'command');
+    if (version === 1) {
+      output[logicalId] = compiledGroup(logicalId, [{ cwd: '.', argv: descriptor.value }], `/project/commands/${logicalId}`, false);
+      continue;
+    }
+    const group = descriptor.value;
+    if (!group || typeof group !== 'object' || Array.isArray(group)
+      || ![Object.prototype, null].includes(Object.getPrototypeOf(group))) fail(`/project/commands/${logicalId}`, 'command-group');
+    const groupKeys = Reflect.ownKeys(group);
+    const steps = Object.getOwnPropertyDescriptor(group, 'steps');
+    if (groupKeys.length !== 1 || groupKeys[0] !== 'steps' || !steps?.enumerable
+      || !Object.hasOwn(steps, 'value')) fail(`/project/commands/${logicalId}`, 'command-group');
+    output[logicalId] = compiledGroup(logicalId, steps.value, `/project/commands/${logicalId}/steps`, true, version === 3);
+    if (version === 2 && expectedManager && output[logicalId].steps.some(step => (
+      step.argv[0].toLowerCase().replace(/\.cmd$/, '') !== expectedManager
+    ))) fail(`/project/commands/${logicalId}/steps`, 'package-manager-mismatch');
+  }
+  return Object.freeze(output);
+}
+
+export function compileQualitySteps(config) {
+  const commands = compileProjectCommands(config.project);
+  const expanded = config.quality.commandGates.flatMap(gate => commands[gate.command].steps.map((step, index, steps) => {
+    const id = steps.length === 1 ? gate.id : `${gate.id}-${index + 1}`;
+    if (id.length > 64) fail(`/quality/commandGates/${gate.id}/id`, 'expanded-command-id');
+    return Object.freeze({
+      ...step,
+      id,
+      logicalId: gate.command,
+      required: gate.required,
+    });
+  }));
+  if (expanded.length > MAX_QUALITY_STEPS) fail('/quality/commandGates', 'expanded-command-count');
+  const ids = new Set();
+  for (const step of expanded) {
+    const id = step.id.toLowerCase();
+    if (ids.has(id)) fail(`/quality/commandGates/${step.id}/id`, 'expanded-command-id-duplicate');
+    ids.add(id);
+  }
+  return Object.freeze(expanded);
+}
+
+export { LOGICAL_COMMANDS, MAX_QUALITY_STEPS, MAX_STEPS, SAFE_COMMAND_RUNNERS };

package/src/config/defaults.js

@@ -0,0 +1,55 @@
+function deepFreeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+export const CONFIG_DIRECTORY = '.rivet';
+export const PROTOCOL_DIRECTORY = 'protocols';
+export const MAX_CONFIG_FILE_BYTES = 256 * 1024;
+
+export const CONFIG_FILES = deepFreeze({
+  project: 'project.yaml',
+  providers: 'providers.yaml',
+  orchestration: 'orchestration.yaml',
+  quality: 'quality.yaml',
+});
+
+export const SCHEMA_FILES = deepFreeze({
+  project: 'project.schema.json',
+  providers: 'providers.schema.json',
+  orchestration: 'orchestration.schema.json',
+  quality: 'quality.schema.json',
+  goalGraph: 'goal-graph.schema.json',
+  event: 'event.schema.json',
+  evidence: 'evidence.schema.json',
+});
+
+export const EVIDENCE_TYPES = deepFreeze([
+  'commit',
+  'test',
+  'journey',
+  'screenshot',
+  'report',
+  'review',
+  'human-approval',
+  'external-update',
+]);
+
+export const DEFAULT_CONFIG = deepFreeze({
+  orchestration: {
+    enabled: false,
+  },
+  externalWrites: {
+    enabled: false,
+    requireHumanApproval: true,
+  },
+  activation: {
+    automatic: false,
+    requireHumanApproval: true,
+  },
+});
+
+export { deepFreeze };

package/src/config/load.js

@@ -0,0 +1,230 @@
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  readdirSync,
+  statSync,
+} from 'node:fs';
+import { join, resolve } from 'node:path';
+
+import { parseAllDocuments, visit } from 'yaml';
+
+import {
+  CONFIG_DIRECTORY,
+  CONFIG_FILES,
+  DEFAULT_CONFIG,
+  MAX_CONFIG_FILE_BYTES,
+  PROTOCOL_DIRECTORY,
+  deepFreeze,
+} from './defaults.js';
+import { ConfigurationError, validateProjectConfiguration } from './validate.js';
+
+const DEFAULT_FILE_SYSTEM = Object.freeze({
+  closeSync,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  readdirSync,
+  statSync,
+});
+
+function parseYaml(source, filename) {
+  let documents;
+  try {
+    documents = parseAllDocuments(source, {
+      maxAliasCount: 0,
+      prettyErrors: false,
+      strict: true,
+      uniqueKeys: true,
+      version: '1.2',
+    });
+  } catch {
+    throw new ConfigurationError(`/${filename}`, 'yaml-parse');
+  }
+  if (documents.length !== 1) throw new ConfigurationError(`/${filename}`, 'yaml-document-count');
+  const [document] = documents;
+  if (document.errors.length || document.warnings.length) throw new ConfigurationError(`/${filename}`, 'yaml-parse');
+
+  let unsafe = false;
+  visit(document, {
+    Alias() {
+      unsafe = true;
+      return visit.BREAK;
+    },
+    Pair(_key, pair) {
+      if (pair.key?.value === '<<') {
+        unsafe = true;
+        return visit.BREAK;
+      }
+      return undefined;
+    },
+  });
+  if (unsafe) throw new ConfigurationError(`/${filename}`, 'yaml-alias');
+
+  let value;
+  try {
+    value = document.toJS({ maxAliasCount: 0, mapAsMap: false });
+  } catch {
+    throw new ConfigurationError(`/${filename}`, 'yaml-conversion');
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new ConfigurationError(`/${filename}`, 'yaml-root');
+  return value;
+}
+
+function sameIdentity(first, second) {
+  return first.dev === second.dev && first.ino === second.ino;
+}
+
+function readRegularConfigFile(filename, fs) {
+  let metadata;
+  try {
+    metadata = fs.lstatSync(filename);
+  } catch {
+    throw new ConfigurationError(`/${filename}`, 'missing-file');
+  }
+  if (metadata.isSymbolicLink() || !metadata.isFile()) throw new ConfigurationError(`/${filename}`, 'not-regular-file');
+  if (metadata.size > MAX_CONFIG_FILE_BYTES) throw new ConfigurationError(`/${filename}`, 'file-too-large');
+
+  let descriptor;
+  try {
+    descriptor = fs.openSync(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const openedMetadata = fs.fstatSync(descriptor);
+    if (!sameIdentity(metadata, openedMetadata)) {
+      throw new ConfigurationError(`/${filename}`, 'file-identity-changed');
+    }
+    if (!openedMetadata.isFile() || openedMetadata.size > MAX_CONFIG_FILE_BYTES) {
+      throw new ConfigurationError(`/${filename}`, 'invalid-opened-file');
+    }
+    const data = Buffer.alloc(MAX_CONFIG_FILE_BYTES + 1);
+    let offset = 0;
+    while (offset < data.length) {
+      const bytesRead = fs.readSync(descriptor, data, offset, data.length - offset, null);
+      if (!Number.isInteger(bytesRead) || bytesRead < 0 || bytesRead > data.length - offset) {
+        throw new ConfigurationError(`/${filename}`, 'invalid-read');
+      }
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    if (offset > MAX_CONFIG_FILE_BYTES) throw new ConfigurationError(`/${filename}`, 'file-too-large');
+    return data.subarray(0, offset).toString('utf8');
+  } catch (error) {
+    if (error instanceof ConfigurationError) throw error;
+    throw new ConfigurationError(`/${filename}`, 'read-failed');
+  } finally {
+    if (descriptor !== undefined) {
+      try {
+        fs.closeSync(descriptor);
+      } catch {
+        throw new ConfigurationError(`/${filename}`, 'close-failed');
+      }
+    }
+  }
+}
+
+function readTrackedConfiguration(configRoot, fs) {
+  let configRootMetadata;
+  try {
+    configRootMetadata = fs.lstatSync(configRoot);
+  } catch {
+    throw new ConfigurationError(`/${CONFIG_DIRECTORY}`, 'missing-directory');
+  }
+  if (configRootMetadata.isSymbolicLink() || !configRootMetadata.isDirectory()) {
+    throw new ConfigurationError(`/${CONFIG_DIRECTORY}`, 'invalid-directory');
+  }
+
+  const originalCwd = process.cwd();
+  let changedDirectory = false;
+  try {
+    process.chdir(configRoot);
+    changedDirectory = true;
+    const anchoredMetadata = fs.statSync('.');
+    if (!anchoredMetadata.isDirectory() || !sameIdentity(configRootMetadata, anchoredMetadata)) {
+      throw new ConfigurationError(`/${CONFIG_DIRECTORY}`, 'directory-identity-changed');
+    }
+    const expectedFiles = Object.values(CONFIG_FILES).sort();
+    const actualFiles = fs.readdirSync('.').sort();
+    const unexpected = actualFiles.filter(entry => !expectedFiles.includes(entry) && entry !== PROTOCOL_DIRECTORY);
+    if (unexpected.length > 0) {
+      throw new ConfigurationError(`/${CONFIG_DIRECTORY}`, 'unexpected-entry');
+    }
+    const protocolDirectory = fs.lstatSync(PROTOCOL_DIRECTORY, { throwIfNoEntry: false });
+    if (protocolDirectory && (protocolDirectory.isSymbolicLink() || !protocolDirectory.isDirectory())) {
+      throw new ConfigurationError(`/${CONFIG_DIRECTORY}/${PROTOCOL_DIRECTORY}`, 'invalid-directory');
+    }
+    const parsed = {};
+    for (const [name, filename] of Object.entries(CONFIG_FILES)) {
+      parsed[name] = parseYaml(readRegularConfigFile(filename, fs), filename);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof ConfigurationError) throw error;
+    throw new ConfigurationError(`/${CONFIG_DIRECTORY}`, 'directory-read-failed');
+  } finally {
+    if (changedDirectory) {
+      try {
+        process.chdir(originalCwd);
+      } catch {
+        throw new ConfigurationError(`/${CONFIG_DIRECTORY}`, 'cwd-restore-failed');
+      }
+    }
+  }
+}
+
+function normalize(config) {
+  return {
+    project: {
+      ...config.project,
+      repository: {
+        sensitivePaths: [],
+        ...config.project.repository,
+      },
+    },
+    providers: config.providers,
+    orchestration: {
+      enabled: DEFAULT_CONFIG.orchestration.enabled,
+      ...config.orchestration,
+    },
+    quality: config.quality,
+  };
+}
+
+export async function loadProjectConfig(projectRoot, options = {}) {
+  if (typeof projectRoot !== 'string' || projectRoot.length === 0 || projectRoot.includes('\0')) {
+    throw new ConfigurationError('/', 'project-root');
+  }
+  const configRoot = join(resolve(projectRoot), CONFIG_DIRECTORY);
+  const fs = Object.freeze({ ...DEFAULT_FILE_SYSTEM, ...(options.fs ?? {}) });
+  const parsed = readTrackedConfiguration(configRoot, fs);
+  const normalized = normalize(parsed);
+  validateProjectConfiguration(normalized);
+  return deepFreeze(normalized);
+}
+
+export function providerCredentialStatus(config, environment = process.env) {
+  try {
+    const providers = config?.providers?.providers;
+    if (!Array.isArray(providers) || !environment || typeof environment !== 'object' || Array.isArray(environment)) {
+      throw new TypeError();
+    }
+    return deepFreeze(providers.flatMap(provider => Object.entries(provider.credentials ?? {})
+      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+      .map(([, name]) => {
+        if (typeof name !== 'string' || !/^[A-Z][A-Z0-9_]{1,127}$/.test(name)) throw new TypeError();
+        const value = environment[name];
+        return {
+          provider: provider.id,
+          name,
+          present: typeof value === 'string' && value.length > 0,
+          required: (!provider.projectIds?.length || provider.projectIds.includes(config.project?.id)) && provider.mode !== 'disabled' && provider.transport !== 'harness-mcp' && provider.transport !== 'local-cli',
+        };
+      })));
+  } catch {
+    throw new ConfigurationError('/providers/providers', 'credential-reference');
+  }
+}
+
+export const loadConfig = loadProjectConfig;