@agilno-tech/rivet 0.1.0-alpha.0

package/src/discovery/project.js

@@ -0,0 +1,345 @@
+import * as filesystem from 'node:fs';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+import { isExecutionCompatibleCwd } from '../config/commands.js';
+import {discoverPortableProject} from './portable.js';
+
+const MAX_DISCOVERY_FILE_BYTES = 256 * 1024;
+const MAX_DISCOVERY_AGGREGATE_BYTES = 2 * 1024 * 1024;
+const MAX_DISCOVERY_ENTRIES = 256;
+const MAX_DISCOVERY_MANIFESTS = 64;
+const LOCK_FILES = Object.freeze([
+  ['package-lock.json', 'npm'], ['npm-shrinkwrap.json', 'npm'], ['pnpm-lock.yaml', 'pnpm'],
+  ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun'],
+]);
+const IGNORED_CHILD_DIRECTORIES = new Set([
+  '.git', '.next', 'node_modules', 'vendor', 'dist', 'build', 'out', 'coverage', 'generated',
+]);
+const OPTIONAL_FILES = Object.freeze([
+  'next.config.js', 'next.config.mjs', 'next.config.ts',
+  'playwright.config.js', 'playwright.config.mjs', 'playwright.config.ts',
+  'AGENTS.md', 'CLAUDE.md', 'README.md',
+  '.storybook/main.js', '.storybook/main.mjs', '.storybook/main.ts',
+  '.github/copilot-instructions.md',
+]);
+
+export class ProjectDiscoveryError extends Error {
+  constructor(code, details = {}) {
+    super(code === 'PACKAGE_MANAGER_CONFLICT'
+      ? 'Conflicting package-manager evidence was detected.'
+      : 'Project discovery failed safely.');
+    this.name = 'ProjectDiscoveryError';
+    this.code = code;
+    this.details = Object.freeze({ code, ...details });
+  }
+}
+
+function isWithin(root, candidate) {
+  const path = relative(root, candidate);
+  return path === '' || (!isAbsolute(path) && path !== '..' && !path.startsWith(`..${sep}`));
+}
+
+function safeFile(root, relativePath, fs, required = false) {
+  const components = relativePath.split('/');
+  let path = root;
+  for (let index = 0; index < components.length; index += 1) {
+    path = join(path, components[index]);
+    const metadata = fs.lstatSync(path, { throwIfNoEntry: false });
+    if (!metadata) {
+      if (required) throw new Error(`${relativePath} must be a regular bounded file`);
+      return null;
+    }
+    if (metadata.isSymbolicLink()) {
+      if (index === components.length - 1) {
+        throw new Error(`${relativePath} must be a regular bounded file`);
+      }
+      throw new Error(`${relativePath} has a symbolic link ancestor in an allowlisted path`);
+    }
+    const canonical = fs.realpathSync(path);
+    const canonicalMetadata = fs.statSync(canonical);
+    if (!isWithin(root, canonical) || !sameIdentity(metadata, canonicalMetadata)) {
+      throw new Error(`${relativePath} changed identity outside its allowlisted path`);
+    }
+    if (index < components.length - 1) {
+      if (!metadata.isDirectory()) throw new Error(`${relativePath} has a non-directory allowlisted ancestor`);
+      continue;
+    }
+    if (!metadata.isFile() || metadata.size > MAX_DISCOVERY_FILE_BYTES) {
+      throw new Error(`${relativePath} must be a regular bounded file`);
+    }
+    return {
+      path,
+      relativePath,
+      size: metadata.size,
+      identity: Object.freeze({ dev: metadata.dev, ino: metadata.ino }),
+    };
+  }
+  return null;
+}
+
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+
+export function readStrictBoundedFile(file, fs = filesystem, maxBytes = MAX_DISCOVERY_FILE_BYTES) {
+  const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0);
+  let descriptor;
+  try {
+    descriptor = fs.openSync(file.path, flags);
+    const opened = fs.fstatSync(descriptor);
+    if (!opened.isFile() || !sameIdentity(opened, file.identity)) {
+      throw new Error('Bounded file changed identity before reading');
+    }
+    const chunks = [];
+    let total = 0;
+    while (total <= maxBytes) {
+      const capacity = Math.min(64 * 1024, maxBytes + 1 - total);
+      if (capacity <= 0) break;
+      const buffer = Buffer.allocUnsafe(capacity);
+      const count = fs.readSync(descriptor, buffer, 0, capacity, null);
+      if (count === 0) break;
+      chunks.push(buffer.subarray(0, count));
+      total += count;
+    }
+    if (total > maxBytes) throw new Error('Bounded file exceeds the byte limit');
+    return new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks, total));
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+  }
+}
+
+export function inspectBoundedFile(root, relativePath, fs = filesystem, required = true) {
+  return safeFile(root, relativePath, fs, required);
+}
+
+function slug(value) {
+  const normalized = String(value).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const candidate = /^[a-z]/.test(normalized) ? normalized : `project-${normalized || 'local'}`;
+  return candidate.slice(0, 64).replace(/-+$/g, '');
+}
+
+function safeLockfilePresence(root, relativePath, fs) {
+  const components = relativePath.split('/');
+  let path = root;
+  for (let index = 0; index < components.length; index += 1) {
+    path = join(path, components[index]);
+    const metadata = fs.lstatSync(path, { throwIfNoEntry: false });
+    if (!metadata) return false;
+    if (metadata.isSymbolicLink()) throw new Error('Package-manager evidence must not use symbolic links');
+    const canonical = fs.realpathSync(path);
+    if (!isWithin(root, canonical) || !sameIdentity(metadata, fs.statSync(canonical))) {
+      throw new Error('Package-manager evidence changed identity');
+    }
+    if (index < components.length - 1) {
+      if (!metadata.isDirectory()) throw new Error('Package-manager evidence has a non-directory ancestor');
+    } else if (!metadata.isFile()) {
+      throw new Error('Package-manager evidence must be a regular file');
+    }
+  }
+  return true;
+}
+
+function declaredManager(value) {
+  if (typeof value !== 'string' || value.length > 160) return null;
+  const match = /^(npm|pnpm|yarn|bun)@[^\s@]{1,128}$/.exec(value);
+  return match?.[1] ?? null;
+}
+
+function managerEvidence(root, packages, fs, inspectedFiles) {
+  const evidence = [];
+  for (const item of packages) {
+    const declaration = declaredManager(item.manifest.packageManager);
+    if (declaration) {
+      evidence.push({
+        manager: declaration,
+        relativePath: item.path === '.' ? 'package.json#packageManager' : `${item.path}/package.json#packageManager`,
+      });
+    }
+    for (const [filename, manager] of LOCK_FILES) {
+      const relativePath = item.path === '.' ? filename : `${item.path}/${filename}`;
+      if (safeLockfilePresence(root, relativePath, fs)) {
+        evidence.push({ manager, relativePath });
+        inspectedFiles.add(relativePath);
+      }
+    }
+  }
+  const managers = [...new Set(evidence.map(item => item.manager))];
+  if (managers.length > 1) {
+    throw new ProjectDiscoveryError('PACKAGE_MANAGER_CONFLICT', { managers: managers.sort() });
+  }
+  return managers.length === 1
+    ? [managers[0], evidence.find(item => item.manager === managers[0]).relativePath]
+    : ['npm', 'package.json'];
+}
+
+function scriptsFor(manifest) {
+  return manifest.scripts && typeof manifest.scripts === 'object' && !Array.isArray(manifest.scripts)
+    ? manifest.scripts : {};
+}
+
+function scriptFor(scripts, logicalId) {
+  if (typeof scripts[logicalId] === 'string') return logicalId;
+  if (logicalId === 'typecheck' && typeof scripts['type-check'] === 'string') return 'type-check';
+  return null;
+}
+
+function commandRegistry(packages, manager) {
+  const commands = {};
+  const provenance = {};
+  const unresolved = [];
+  const warnings = [];
+  const root = packages[0];
+  let structured = false;
+  for (const key of ['build', 'test', 'lint', 'typecheck']) {
+    const rootScript = scriptFor(root.scripts, key);
+    let selected = rootScript ? [{ packagePath: '.', script: rootScript }] : packages.slice(1)
+      .map(item => ({ packagePath: item.path, script: scriptFor(item.scripts, key) }))
+      .filter(item => item.script !== null);
+    if (selected.length === 0 && (key === 'build' || key === 'test')) {
+      selected = [{ packagePath: '.', script: key, unresolved: true }];
+      unresolved.push({ command: key, reason: 'no-script-in-supported-scope' });
+    }
+    if (selected.length === 0) continue;
+    if (selected.some(item => item.packagePath !== '.')
+      || (key === 'typecheck' && selected.some(item => item.script === 'type-check'))) structured = true;
+    commands[key] = selected.map(item => ({
+      cwd: item.packagePath,
+      argv: [manager, 'run', item.script],
+      unresolved: item.unresolved === true,
+    }));
+  }
+  for (const item of packages.slice(1)) {
+    const hasCoverageCandidate = scriptFor(item.scripts, 'build') || scriptFor(item.scripts, 'typecheck');
+    if (hasCoverageCandidate && !scriptFor(item.scripts, 'test')) {
+      warnings.push({
+        code: 'package-missing-test',
+        package: item.path,
+        message: `Package '${item.path}' has build/typecheck coverage but no test script.`,
+      });
+    }
+  }
+  const serialized = {};
+  for (const [key, steps] of Object.entries(commands)) {
+    if (structured) {
+      serialized[key] = { steps: steps.map(({ cwd, argv }) => ({ cwd, argv })) };
+      steps.forEach((step, index) => {
+        provenance[`commands.${key}.steps[${index}]`] = step.unresolved
+          ? 'safe-default (script availability requires review)'
+          : `${step.cwd === '.' ? '' : `${step.cwd}/`}package.json#scripts.${step.argv[2]}`;
+      });
+    } else {
+      serialized[key] = steps[0].argv;
+      provenance[`commands.${key}`] = steps[0].unresolved
+        ? 'safe-default (script availability requires review)'
+        : 'package.json#scripts';
+    }
+  }
+  if (!structured && typeof root.scripts.dev === 'string') {
+    serialized.dev = [manager, 'run', 'dev'];
+    provenance['commands.dev'] = 'package.json#scripts.dev';
+  }
+  return { schemaVersion: structured ? 2 : 1, commands: serialized, provenance, unresolved, warnings };
+}
+
+export async function discoverProject(projectRoot, options = {}) {
+  const fs = options.fs ?? filesystem;
+  const lexicalRoot = resolve(projectRoot);
+  const rootMetadata = fs.lstatSync(lexicalRoot, { throwIfNoEntry: false });
+  if (!rootMetadata?.isDirectory() || rootMetadata.isSymbolicLink()) {
+    throw new Error('Project root must be a regular directory');
+  }
+  const root = fs.realpathSync(lexicalRoot);
+  if (!sameIdentity(rootMetadata, fs.statSync(root))) {
+    throw new Error('Project root changed identity during validation');
+  }
+  const manifestFile = safeFile(root, 'package.json', fs, false);
+  if (!manifestFile || options.checks !== undefined) return discoverPortableProject(root, {
+    fs, inspect: inspectBoundedFile, read: readStrictBoundedFile, checks: options.checks,
+  });
+  const files = new Map([['package.json', manifestFile]]);
+  for (const name of OPTIONAL_FILES) {
+    const file = safeFile(root, name, fs);
+    if (file) files.set(name, file);
+  }
+  const entries = fs.readdirSync(root);
+  if (!Array.isArray(entries) || entries.length > MAX_DISCOVERY_ENTRIES) {
+    throw new Error('Project discovery entry limit exceeded');
+  }
+  const packageFiles = [{ path: '.', file: manifestFile }];
+  for (const name of [...entries].sort((left, right) => left < right ? -1 : left > right ? 1 : 0)) {
+    if (name.startsWith('.') || IGNORED_CHILD_DIRECTORIES.has(name) || !isExecutionCompatibleCwd(name)) continue;
+    const metadata = fs.lstatSync(join(root, name), { throwIfNoEntry: false });
+    if (!metadata || metadata.isSymbolicLink() || !metadata.isDirectory()) continue;
+    const canonical = fs.realpathSync(join(root, name));
+    if (!isWithin(root, canonical) || !sameIdentity(metadata, fs.statSync(canonical))) {
+      throw new Error('Child package directory changed identity');
+    }
+    const childManifest = safeFile(root, `${name}/package.json`, fs);
+    if (childManifest) packageFiles.push({ path: name, file: childManifest });
+  }
+  if (packageFiles.length > MAX_DISCOVERY_MANIFESTS) throw new Error('Project discovery manifest limit exceeded');
+  if (packageFiles.reduce((total, item) => total + item.file.size, 0) > MAX_DISCOVERY_AGGREGATE_BYTES) {
+    throw new Error('Project discovery aggregate read limit exceeded');
+  }
+  const packages = [];
+  for (const item of packageFiles) {
+    let parsed;
+    try { parsed = JSON.parse(readStrictBoundedFile(item.file, fs)); }
+    catch { throw new Error(`${item.path === '.' ? '' : `${item.path}/`}package.json must contain valid bounded JSON`); }
+    packages.push({ path: item.path, manifest: parsed, scripts: scriptsFor(parsed) });
+    files.set(item.path === '.' ? 'package.json' : `${item.path}/package.json`, item.file);
+  }
+  const manifest = packages[0].manifest;
+  const inspectedFiles = new Set(files.keys());
+  const [manager, managerSource] = managerEvidence(root, packages, fs, inspectedFiles);
+  const dependencies = Object.assign({}, ...packages.map(item => ({
+    ...(item.manifest.dependencies ?? {}), ...(item.manifest.devDependencies ?? {}),
+  })));
+  const framework = Object.hasOwn(dependencies, 'next') ? 'nextjs' : 'other';
+  const language = Object.hasOwn(dependencies, 'typescript') || files.has('next.config.ts') ? 'typescript' : 'javascript';
+  const registry = commandRegistry(packages, manager);
+  const inferredName = typeof manifest.name === 'string' && manifest.name.trim().length > 0
+    ? manifest.name.trim() : basename(root);
+  const nameSource = typeof manifest.name === 'string' && manifest.name.trim().length > 0
+    ? 'package.json#name' : 'project directory basename';
+  const storybook = Object.keys(dependencies).some(name => name === 'storybook' || name.startsWith('@storybook/'))
+    || [...files.keys()].some(name => name.startsWith('.storybook/'));
+  const playwright = Object.hasOwn(dependencies, '@playwright/test')
+    || [...files.keys()].some(name => name.startsWith('playwright.config.'));
+  const configMetadata = fs.lstatSync(join(root, '.rivet'), { throwIfNoEntry: false });
+  if (configMetadata?.isSymbolicLink()) throw new Error('.rivet must not be a symbolic link');
+  const existingConfig = configMetadata !== undefined;
+  return {
+    root,
+    inspectedFiles: [...inspectedFiles].sort((left, right) => left < right ? -1 : left > right ? 1 : 0),
+    proposal: {
+      schemaVersion: registry.schemaVersion,
+      id: slug(inferredName),
+      name: inferredName.slice(0, 120),
+      stack: { framework, language, packageManager: manager },
+      commands: registry.commands,
+    },
+    features: { storybook, playwright },
+    architectureHints: files.has('AGENTS.md') ? ['AGENTS.md'] : [],
+    existingConfig,
+    warnings: registry.warnings,
+    unresolved: registry.unresolved,
+    provenance: {
+      id: nameSource,
+      name: nameSource,
+      'stack.framework': 'package.json#dependencies',
+      'stack.language': 'package.json#dependencies',
+      'stack.packageManager': managerSource,
+      'features.storybook': storybook ? 'known Storybook dependency/config filename' : 'known-file allowlist',
+      'features.playwright': playwright ? 'known Playwright dependency/config filename' : 'known-file allowlist',
+      ...registry.provenance,
+    },
+  };
+}
+
+export {
+  MAX_DISCOVERY_AGGREGATE_BYTES,
+  MAX_DISCOVERY_ENTRIES,
+  MAX_DISCOVERY_FILE_BYTES,
+  MAX_DISCOVERY_MANIFESTS,
+};

package/src/discovery/tools.js

@@ -0,0 +1,145 @@
+import { spawn } from 'node:child_process';
+
+export const SUPPORTED_NODE_MAJOR = 22;
+export const RECOMMENDED_NODE_MAJOR = 22;
+export const DEFAULT_COMMAND_TIMEOUT_MS = 3_000;
+export const DEFAULT_COMMAND_OUTPUT_BYTES = 16 * 1024;
+
+function safeResult(result = {}) {
+  return {
+    code: Number.isInteger(result.code) ? result.code : 1,
+    stdout: typeof result.stdout === 'string' ? result.stdout : '',
+    stderr: typeof result.stderr === 'string' ? result.stderr : '',
+    timedOut: result.timedOut === true,
+    truncated: {
+      stdout: result.truncated?.stdout === true,
+      stderr: result.truncated?.stderr === true,
+    },
+  };
+}
+
+function decodeValidUtf8Prefix(buffer) {
+  const decoder = new TextDecoder('utf-8', { fatal: true });
+  for (let length = buffer.byteLength; length >= 0; length -= 1) {
+    try {
+      return decoder.decode(buffer.subarray(0, length));
+    } catch {}
+  }
+  return '';
+}
+
+export function runArgv(command, args, options = {}) {
+  if (typeof command !== 'string' || !Array.isArray(args) || args.some(value => typeof value !== 'string')) {
+    throw new TypeError('Command execution requires an executable and argv array');
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_COMMAND_OUTPUT_BYTES;
+  const maxStreamOutputBytes = options.maxStreamOutputBytes ?? maxOutputBytes;
+  return new Promise(resolvePromise => {
+    const output = { stdout: [], stderr: [] };
+    const streamBytes = { stdout: 0, stderr: 0 };
+    const truncated = { stdout: false, stderr: false };
+    let totalBytes = 0;
+    let settled = false;
+    let timedOut = false;
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      shell: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    const finish = result => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise(safeResult({
+        ...result,
+        stdout: decodeValidUtf8Prefix(Buffer.concat(output.stdout)),
+        stderr: decodeValidUtf8Prefix(Buffer.concat(output.stderr)),
+        timedOut,
+        truncated,
+      }));
+    };
+    const collect = stream => chunk => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const available = Math.max(0, Math.min(
+        maxStreamOutputBytes - streamBytes[stream],
+        maxOutputBytes - totalBytes,
+      ));
+      const accepted = buffer.subarray(0, available);
+      if (accepted.byteLength > 0) output[stream].push(accepted);
+      streamBytes[stream] += accepted.byteLength;
+      totalBytes += accepted.byteLength;
+      if (accepted.byteLength < buffer.byteLength) truncated[stream] = true;
+    };
+    child.stdout?.on('data', collect('stdout'));
+    child.stderr?.on('data', collect('stderr'));
+    child.once('error', () => finish({ code: 1, stdout: '' }));
+    child.once('close', code => finish({ code: code ?? 1, stdout: output }));
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGKILL');
+    }, timeoutMs);
+    timer.unref?.();
+  });
+}
+
+function normalizeVersion(stdout) {
+  const match = String(stdout).match(/(?:^|\s)v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  return match ? `${match[1]}.${match[2] ?? '0'}.${match[3] ?? '0'}` : null;
+}
+
+async function inspect(executable, args, runner, cwd) {
+  try {
+    const result = safeResult(await runner(executable, args, {
+      cwd,
+      shell: false,
+      timeoutMs: DEFAULT_COMMAND_TIMEOUT_MS,
+      maxOutputBytes: DEFAULT_COMMAND_OUTPUT_BYTES,
+    }));
+    const version = result.code === 0 ? normalizeVersion(result.stdout) : null;
+    return { present: result.code === 0 && version !== null, version };
+  } catch {
+    return { present: false, version: null };
+  }
+}
+
+export async function discoverTools(context = {}, options = {}) {
+  const runner = options.runner ?? runArgv;
+  const cwd = options.cwd;
+  const packageManager = context.packageManager ?? 'npm';
+  const platform = options.platform ?? process.platform;
+  const managerExecutable = platform === 'win32'
+    ? ({ npm: 'npm.cmd', pnpm: 'pnpm.cmd', yarn: 'yarn.cmd', bun: 'bun.exe' }[packageManager] ?? packageManager)
+    : packageManager;
+  const [node, manager, git] = await Promise.all([
+    inspect('node', ['--version'], runner, cwd),
+    context.runtimeOnly === true ? Promise.resolve(null) : inspect(managerExecutable, ['--version'], runner, cwd),
+    inspect('git', ['--version'], runner, cwd),
+  ]);
+  const nodeMajor = node.version ? Number.parseInt(node.version, 10) : null;
+  node.supported = node.present && nodeMajor >= SUPPORTED_NODE_MAJOR;
+  node.compatible = node.supported;
+  node.recommended = node.present && nodeMajor >= RECOMMENDED_NODE_MAJOR;
+  if(manager) {manager.supported = manager.present;manager.compatible = manager.supported;}
+  git.supported = git.present;
+  git.compatible = git.supported;
+  return {
+    node,
+    ...(manager?{[packageManager]: manager}:{}),
+    git,
+    playwright: {
+      relevant: context.playwright === true,
+      available: context.playwright === true && manager?.present === true,
+    },
+    storybook: {
+      relevant: context.storybook === true,
+      available: context.storybook === true && manager?.present === true,
+    },
+    thresholds: {
+      nodeSupportedMajor: SUPPORTED_NODE_MAJOR,
+      nodeRecommendedMajor: RECOMMENDED_NODE_MAJOR,
+    },
+  };
+}

package/src/evaluations/approval.js

@@ -0,0 +1,20 @@
+import { LiveEvaluationError } from './cost-policy.js';
+
+// A UI callback may ignore cancellation or never settle. Stop waiting on the
+// runner's signal independently; a late answer cannot resume this operation.
+export function waitForApproval(confirm, proposal, signal) {
+ return new Promise((resolve,reject)=>{
+  let settled=false;
+  const finish=(error,value)=>{
+   if(settled)return;settled=true;signal.removeEventListener('abort',abort);
+   if(error)reject(error);else resolve(value);
+  };
+  const abort=()=>finish(new LiveEvaluationError('cancelled'));
+  if(signal.aborted){abort();return;}
+  signal.addEventListener('abort',abort,{once:true});
+  Promise.resolve().then(()=>{
+   if(signal.aborted)throw new LiveEvaluationError('cancelled');
+   return confirm(proposal,{signal});
+  }).then(value=>finish(null,value),error=>finish(error));
+ });
+}

package/src/evaluations/cost-policy.js

@@ -0,0 +1,20 @@
+export class LiveEvaluationError extends Error {
+  constructor(reason) { super(`Live evaluation stopped: ${reason}.`); this.code=`ERR_LIVE_EVAL_${reason.replaceAll('-','_').toUpperCase()}`; this.reason=reason; }
+}
+export function ensure(value,reason='invalid-profile') { if(!value)throw new LiveEvaluationError(reason); }
+export function capture(value,allowed) {
+ ensure(value && typeof value==='object' && !Array.isArray(value) && [Object.prototype,null].includes(Object.getPrototypeOf(value)));
+ const result={};
+ for(const key of Reflect.ownKeys(value)) {
+  const descriptor=Object.getOwnPropertyDescriptor(value,key);
+  ensure(typeof key==='string' && allowed.includes(key) && descriptor?.enumerable && Object.hasOwn(descriptor,'value'));
+  result[key]=descriptor.value;
+ }
+ return result;
+}
+export function resolveCostPolicy(input,provider) {
+ const value=capture(input,['kind','accountPolicy','estimatedCostUsd']);
+ ensure((value.kind==='account-policy'||(value.kind==='local-compute'&&provider==='ollama')) && typeof value.accountPolicy==='string' && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(value.accountPolicy),'account-policy-required');
+ ensure(value.estimatedCostUsd===undefined||value.estimatedCostUsd===null||(Number.isFinite(value.estimatedCostUsd) && value.estimatedCostUsd>0 && value.estimatedCostUsd<=100),'invalid-cost-estimate');
+ return Object.freeze({...value,estimatedCostUsd:value.estimatedCostUsd??null,estimateIsLimit:false,hardDollarCapEnforced:false,providerAdvertisedBudgetsUsd:provider==='claude'?Object.freeze({planning:1,worker:2}):null,actualCostUsd:null});
+}

package/src/evaluations/harness-attempt.js

@@ -0,0 +1,113 @@
+import { mkdtemp,mkdir,writeFile,realpath } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { tmpdir } from 'node:os';
+import { dirname,join,isAbsolute,delimiter } from 'node:path';
+import YAML from 'yaml';
+import { createGitClient } from '../git/client.js';
+import { createFeatureWorkflow } from '../feature/workflow.js';
+import { createFeatureExecutor } from '../feature/runtime-bridge.js';
+import { createAcceptedIntegrationStore } from '../feature/accepted-integration.js';
+import { createVerificationReportStore } from '../feature/verification-report.js';
+import { resolveFeatureRunPaths,acceptedIntegrationPaths,verificationReportPaths } from '../state/paths.js';
+import { discoverHarnesses } from '../runtime/harness-discovery.js';
+import { createClaudeClient,createClaudePlanningClient,CLAUDE_ADAPTER_SYNTAX } from '../clients/claude.js';
+import { createCodexClient,createCodexPlanningClient,CODEX_ADAPTER_SYNTAX } from '../clients/codex.js';
+import { runPublicationProcess } from '../delivery/publication-process.js';
+import { ensure,LiveEvaluationError } from './cost-policy.js';
+import { waitForApproval } from './approval.js';
+
+async function command(executable,args,cwd,env,signal,timeoutMs=15000) {
+ const result=await runPublicationProcess(executable,args,{cwd,env,signal,timeoutMs,maxOutputBytes:262144});
+ ensure(result.code===0&&!result.reason,'fixture-command-failed');return result.stdout.trim();
+}
+async function createFixture(scenario,profile,signal) {
+ const workspace=await realpath(await mkdtemp(join(tmpdir(),'rivet-live-eval-')));
+ const root=join(workspace,'project'),remote=join(workspace,'origin.git'),empty=join(workspace,'empty-template');
+ const env={PATH:`${dirname(process.execPath)}:/usr/bin:/bin`,HOME:workspace,GIT_CONFIG_NOSYSTEM:'1',GIT_CONFIG_GLOBAL:'/dev/null',GIT_CONFIG_SYSTEM:'/dev/null',GIT_NO_REPLACE_OBJECTS:'1',GIT_TERMINAL_PROMPT:'0',NPM_CONFIG_USERCONFIG:join(workspace,'user.npmrc'),NPM_CONFIG_GLOBALCONFIG:join(workspace,'global.npmrc'),NPM_CONFIG_CACHE:join(workspace,'cache'),NPM_CONFIG_OFFLINE:'true',NPM_CONFIG_IGNORE_SCRIPTS:'true'};
+ await mkdir(root);await mkdir(empty);await mkdir(join(root,'.rivet'));
+ for(const [path,content]of Object.entries(scenario.files)){await mkdir(dirname(join(root,path)),{recursive:true});await writeFile(join(root,path),content,{flag:'wx'});}
+ await writeFile(join(root,'package.json'),JSON.stringify({name:'rivet-evaluation-fixture',private:true,type:'module',scripts:{build:'node --check src/solution.js',test:'node public-check.mjs'}}));
+ const config={};
+ for(const name of ['project','providers','orchestration','quality'])config[name]=YAML.parse(scenario.configurationTemplates[name]);
+ config.project.id='live-evaluation';config.project.name='Live evaluation';config.project.stack={framework:'node',language:'javascript',packageManager:'npm'};
+ config.project.repository.defaultBranch='main';config.project.repository.sensitivePaths=['package.json','public-check.mjs','request.md'];config.project.commands={build:['npm','run','build'],test:['npm','run','test']};
+ config.orchestration.roles.forEach(role=>{role.budget={timeMinutes:5,tokenLimit:20000,costUsd:3,taskLimit:1};role.capacity=1});
+ for(const [name,value]of Object.entries(config))await writeFile(join(root,'.rivet',`${name}.yaml`),YAML.stringify(value));
+ const git=(...args)=>command('/usr/bin/git',args,root,env,signal);
+ await git('init','--quiet',`--template=${empty}`,'--initial-branch=main');await git('config','user.name','Rivet evaluation');await git('config','user.email','evaluation@example.invalid');
+ await git('add','.');await git('commit','--quiet','-m','Fixed evaluation baseline');
+ await git('init','--quiet','--bare',`--template=${empty}`,remote);await git('remote','add','origin',remote);await git('push','--quiet','-u','origin','main');
+ const baseline=await git('rev-parse','HEAD'),remoteBefore=await git('ls-remote','--refs','origin');
+ return {workspace,root,remote,env,git,baseline,remoteBefore};
+}
+async function installedClients(profile,root,environment,signal) {
+ const selected=(await discoverHarnesses({env:environment,projectRoot:root,signal})).find(item=>item.kind===profile.id&&item.executable);
+ ensure(selected,'harness-unavailable');
+ const clientEnvironment=Object.fromEntries(['PATH','LANG','LC_ALL','TZ','TERM','TMPDIR','HOME','USER','LOGNAME','SHELL'].filter(key=>typeof environment[key]==='string').map(key=>[key,environment[key]]));
+ const settings={executable:selected.executable,...(selected.interpreter?{interpreter:selected.interpreter}:{}),expectedVersion:selected.version,environment:clientEnvironment,maxOutputBytes:profile.limits.maxOutputBytes};
+ const planning=(profile.id==='claude'?createClaudePlanningClient:createCodexPlanningClient)({...settings,worktree:root,timeoutMs:Math.min(profile.limits.timeoutMs,profile.limits.planningTimeoutMs)});
+ const args=profile.id==='claude'?[...CLAUDE_ADAPTER_SYNTAX.args.slice(0,-1),'--model','sonnet','--effort','low','--permission-mode','acceptEdits','{stdin}']:[...CODEX_ADAPTER_SYNTAX.args.slice(0,-1),'--sandbox','workspace-write',...(profile.models.worker==='harness-default'?[]:['--model',profile.models.worker]),'{stdin}'];
+ const worker=(profile.id==='claude'?createClaudeClient:createCodexClient)({...settings,args,timeoutMs:profile.limits.timeoutMs});
+ return {planning,worker,version:selected.version};
+}
+function acceptanceProgram(scenario,path) {
+ const checks=scenario.id==='feature'?[
+  `["normalization",()=>assert.deepEqual(solution.normalizeTags([' Foo ','BAR']),['foo','bar'])]`,
+  `["stable-deduplication",()=>assert.deepEqual(solution.normalizeTags([' B ','a','b','',' A ','  ']),['b','a'])]`,
+  `["empty-input",()=>assert.deepEqual(solution.normalizeTags([]),[])]`,
+  `["input-preservation",()=>{const input=[' A ','a'];solution.normalizeTags(input);assert.deepEqual(input,[' A ','a'])}]`,
+ ]:[
+  `["inclusive-boundaries",()=>{assert.equal(solution.countInRange([1,3],1,3),2);assert.equal(solution.countInRange([2,2,3],2,2),2)}]`,
+  `["duplicate-matches",()=>assert.equal(solution.countInRange([0,1,1,2,3,4],1,3),4)]`,
+  `["finite-numbers",()=>assert.equal(solution.countInRange(['2',NaN,Infinity,-Infinity,2],-Infinity,Infinity),1)]`,
+  `["input-preservation",()=>{const input=[3,1,2];assert.equal(solution.countInRange([],1,3),0);solution.countInRange(input,1,3);assert.deepEqual(input,[3,1,2])}]`,
+ ];
+ return `const assert=require('node:assert/strict');const {pathToFileURL}=require('node:url');(async()=>{const solution=await import(pathToFileURL(${JSON.stringify(join(path,'src/solution.js'))}).href);const checks=[${checks.join(',')}].map(([id,check])=>{try{check();return{id,passed:true}}catch{return{id,passed:false}}});process.stdout.write(JSON.stringify(checks))})().catch(()=>process.exitCode=1);`;
+}
+export async function runHarnessAttempt({profile,scenario,environment,signal,confirmActivation,clients,assertCurrent=()=>{}}) {
+ ensure(typeof confirmActivation==='function','activation-approval-required');
+ const fixture=await createFixture(scenario,profile,signal);
+ const evidence={workspace:fixture.workspace,baselineCommit:fixture.baseline,sourcePreserved:null,remotePreserved:null,changedPaths:[],modelCalls:{planning:0,worker:0}};
+ let usage=null,harness=null,gates=[],acceptance={total:scenario.acceptanceIds.length,passed:null,checks:[]};
+ const check=()=>{ensure(!signal.aborted,'cancelled');assertCurrent()};
+ try {
+  check();const selected=clients??await installedClients(profile,fixture.root,environment,signal);
+  ensure(selected.planning&&typeof selected.planning.propose==='function'&&selected.worker&&selected.worker.provider===profile.id&&typeof selected.worker.launch==='function','invalid-clients');
+  harness={name:profile.id,version:selected.version??null};
+  let gitClient;
+  for(const directory of String(environment.PATH??'').split(delimiter).filter(isAbsolute)) {
+   try{gitClient=await createGitClient({gitExecutable:await realpath(join(directory,'git'))});break}catch{}
+  }
+  ensure(gitClient,'git-unavailable');
+  const npm=await realpath(join(dirname(process.execPath),'npm'));
+  const executor=createFeatureExecutor({gitClient,now:()=>new Date().toISOString(),environment:fixture.env,resolveCommandExecutable:async runner=>{ensure(runner==='npm');return npm},clientFor:async()=>({provider:profile.id,async launch(contract,options){check();ensure(evidence.modelCalls.worker===0,'automatic-retry-blocked');evidence.modelCalls.worker++;
+   const result=await selected.worker.launch(contract,options);usage=result.usage??null;return result;
+  }})});
+  const workflow=createFeatureWorkflow({gitClient,protocolsFor:async()=>[],planningClientFor:async()=>({async propose(contract,options){check();ensure(evidence.modelCalls.planning===0,'automatic-retry-blocked');evidence.modelCalls.planning++;return selected.planning.propose(contract,options)}}),executeFeature:executor});
+  const proposed=await workflow.propose({project:fixture.root,source:{kind:'file',value:join(fixture.root,'request.md')},client:profile.id},{signal});
+  check();const workers=proposed.featurePlan.nodes.filter(node=>node.role==='worker');
+  ensure(workers.length===1&&workers[0].ownedPaths.length===1&&workers[0].ownedPaths[0]==='src/solution.js','proposal-outside-fixture-scope');
+  ensure(await waitForApproval(confirmActivation,Object.freeze({scenario:scenario.id,runId:proposed.runId,proposalDigest:proposed.proposalDigest,plan:proposed.featurePlan,workspace:fixture.workspace}),signal)===true,'activation-declined');check();
+  const approved=await workflow.start({project:fixture.root,runId:proposed.runId,expectedVersion:proposed.version,proposalDigest:proposed.proposalDigest});
+  const outcome=await workflow.resume({project:fixture.root,runId:proposed.runId,expectedVersion:approved.version},{signal,confirmDependencyInstall:async()=>false});
+  evidence.runId=proposed.runId;evidence.workflowStatus=outcome.status;
+  const paths=await resolveFeatureRunPaths(fixture.root,proposed.runId);
+  const accepted=await createAcceptedIntegrationStore(await acceptedIntegrationPaths(paths)).readOnly();
+  const report=await createVerificationReportStore(await verificationReportPaths(paths)).readOnly();
+  if(report)evidence.verificationFailure=report.failure;
+  if(report)gates=report.checks.map(({id,status,executionStatus,exitCode})=>({id,status,executionStatus,exitCode}));
+  if(accepted){evidence.acceptedCommit=accepted.commitSha;evidence.integrationPath=accepted.path;evidence.changedPaths=await gitClient.changedPaths(accepted.path,fixture.baseline,accepted.commitSha);
+   evidence.diffSha256=createHash('sha256').update(await fixture.git('diff','--no-ext-diff','--no-textconv',fixture.baseline,accepted.commitSha,'--')).digest('hex');
+   check();const result=await runPublicationProcess(process.execPath,['-e',acceptanceProgram(scenario,accepted.path)],{cwd:accepted.path,env:fixture.env,signal,timeoutMs:5000,maxOutputBytes:16384});
+   if(result.code===0&&!result.reason){let checks;try{checks=JSON.parse(result.stdout)}catch{};
+    if(Array.isArray(checks)&&checks.length===scenario.acceptanceIds.length&&checks.every((item,index)=>item.id===scenario.acceptanceIds[index]&&typeof item.passed==='boolean'))acceptance={total:checks.length,passed:checks.filter(item=>item.passed).length,checks};
+   }
+   evidence.acceptanceCleanup=result.cleanup;
+   const after=await gitClient.inspectRepository(accepted.path);ensure(!after.dirty&&after.headSha===accepted.commitSha,'integration-changed-during-acceptance');
+  }
+  evidence.sourcePreserved=(await fixture.git('rev-parse','HEAD'))===fixture.baseline&&(await fixture.git('status','--porcelain'))==='';
+  evidence.remotePreserved=(await fixture.git('ls-remote','--refs','origin'))===fixture.remoteBefore;
+  const passed=outcome.status==='awaiting-final-approval'&&gates.length===2&&gates.every(item=>item.status==='passed')&&acceptance.passed===acceptance.total&&evidence.sourcePreserved&&evidence.remotePreserved&&JSON.stringify(evidence.changedPaths)==='["src/solution.js"]';
+  return {outcome:passed?'passed':'failed',harness,usage:{provenance:usage?'agent-result-self-report':'not-observed',value:usage},gates,acceptance,evidence};
+ }catch(error){return {outcome:signal.aborted?'cancelled':'failed',reason:error instanceof LiveEvaluationError?error.reason:typeof error.code==='string'?error.code:'harness-attempt-failed',harness,usage:{provenance:usage?'agent-result-self-report':'not-observed',value:usage},gates,acceptance,evidence};}
+}