@entrorove/skill 0.1.64 → 0.1.67

package/rollback-runner.mjs

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFail14, mutationRead14, mutationTarget14 } from './local-mutation-files.mjs';
+import { archiveFormat } from './package-archive.mjs';
+import { assertPackageReplacement } from './package-replacement.mjs';
+import { assertRollbackCandidate, rememberRollbackBaseline } from './rollback-history.mjs';
+
+const rollbackVerbs = new Set(['reset', 'restore', 'revert', 'checkout', 'switch']);
+function gitOperation(args) {
+  for (let index = 0; index < args.length; index++) {
+    const value = args[index];
+    if (['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env'].includes(value)) { index++; continue; }
+    if (value.startsWith('-')) continue;
+    return value;
+  }
+  return '';
+}
+export function assertNoBlindRollback(policy) {
+  const executable = path.basename(policy.executable).replace(/\.exe$/i, '').toLowerCase(), args = policy.args ?? [];
+  const direct = executable === 'git' && rollbackVerbs.has(gitOperation(args));
+  const shell = ['sh', 'bash', 'zsh', 'dash', 'cmd', 'powershell', 'pwsh'].includes(executable);
+  const script = args.join(' ');
+  const indirect = shell && /(?:^|[;&|\n\s])(?:\S*\/)?git\s+(?:(?:-C|-c|--git-dir|--work-tree)\s+\S+\s+)*(?:reset|restore|revert|checkout|switch)(?:\s|$)/i.test(script);
+  if (direct || indirect) mutationFail14('ENTROROVE_ROLLBACK_PROOF_REQUIRED',
+    'Direct rollback commands cannot run through an ordinary validation plan; use the independently signed exact-image rollback entry, preserving original transaction and failure records');
+  if (shell && /(?:^|[;&|\n\s])(?:\S*\/)?(?:npm|pnpm|yarn|bun)\s+(?:i|install|add|update|upgrade|ci|exec|dlx)(?:\s|$)/i.test(script)) {
+    mutationFail14('ENTROROVE_PACKAGE_PROVENANCE_REQUIRED', 'Shell-wrapped package replacement cannot prove its destination or frozen inputs; use a direct frozen package-manager plan or the managed installer');
+  }
+}
+function assertFrozenInstall(authority) {
+  const policy = authority.plan.policy, executable = path.basename(policy.executable).replace(/\.(?:exe|cmd)$/i, '').toLowerCase();
+  const args = policy.args ?? [], operation = args.find(value => ['i', 'install', 'add', 'update', 'upgrade', 'ci', 'exec', 'dlx'].includes(value));
+  if (!['npm', 'pnpm', 'yarn', 'bun'].includes(executable) || !operation) return;
+  const install = ['install', 'i', 'ci'].includes(operation);
+  const frozen = executable === 'npm' ? operation === 'ci' : args.includes('--frozen-lockfile') || executable === 'yarn' && args.includes('--immutable');
+  const files = authority.plan.files ?? [], manifest = files.some(file => file.path === 'package.json');
+  const lock = files.some(file => (executable === 'npm' ? ['package-lock.json', 'npm-shrinkwrap.json']
+    : executable === 'pnpm' ? ['pnpm-lock.yaml'] : executable === 'yarn' ? ['yarn.lock'] : ['bun.lock', 'bun.lockb']).includes(file.path));
+  const positional = args.slice(args.indexOf(operation) + 1).filter((value, index, rest) => !value.startsWith('-') && !(index && rest[index - 1].startsWith('--')));
+  if (!install || !frozen || !manifest || !lock || positional.length || args.some(value => /^(?:--prefix|--dir|--cwd|--global|-g|--force)(?:=|$)/.test(value))) {
+    mutationFail14('ENTROROVE_PACKAGE_PROVENANCE_REQUIRED', 'Ordinary runner package installation requires its actual frozen manifest/lock in the original tested source set and no supplied package or destination override; use the managed installer for skill updates');
+  }
+}
+const packagePath = target => /(?:^|\/)(?:package|manifest)\.json$/i.test(target) || archiveFormat(target, Buffer.alloc(0));
+export async function replacementRunnerBefore(input, authority) {
+  assertNoBlindRollback(authority.plan.policy);
+  assertFrozenInstall(authority);
+  const originals = new Map(), writes = authority.plan.policy.discipline?.writes ?? [];
+  for (const write of writes) {
+    const current = await mutationTarget14(authority.root, write.targetPath, true);
+    if (current.exists) {
+      if (current.stat.size > 64 * 1024 * 1024) {
+        if (packagePath(write.targetPath)) mutationFail14('ENTROROVE_PACKAGE_VERSION_UNKNOWN', 'Package baseline exceeds bounded inspection; no process was started');
+        continue;
+      }
+      const bytes = (await mutationRead14(input, authority.root, write.targetPath)).content;
+      if (packagePath(write.targetPath) || archiveFormat(write.targetPath, bytes)) originals.set(write.targetPath, bytes);
+    }
+  }
+  return originals;
+}
+export async function replacementRunnerAfter(input, authority, before, after, changed, originals) {
+  const proof = { kind: 'approved-process-comparison', authorityDigest: authority.planFile?.sha256 ?? sha256(canonical(authority.plan)),
+    baselineManifestDigest: sha256(canonical(before)) };
+  for (const target of changed) {
+    const previous = before.files.find(file => file.path === target), current = after.files.find(file => file.path === target);
+    if (!previous || !current || previous.kind !== 'file' || current.kind !== 'file') continue;
+    await assertRollbackCandidate(input, authority.root, target, previous.sha256, current.sha256);
+    if (previous.sha256 !== current.sha256 && (packagePath(target) || originals.has(target))) {
+      if (!originals.has(target)) mutationFail14('ENTROROVE_PACKAGE_VERSION_UNKNOWN', 'Process replaced an undeclared package without a verifiable original image; preserve this failed run and unknown effects');
+      const state = await mutationTarget14(authority.root, target);
+      if (state.stat.size > 64 * 1024 * 1024) mutationFail14('ENTROROVE_PACKAGE_VERSION_UNKNOWN', 'Replacement exceeds bounded package inspection');
+      assertPackageReplacement(target, originals.get(target), (await mutationRead14(input, authority.root, target)).content);
+    }
+    await rememberRollbackBaseline(input, authority.root, target, previous.sha256, proof);
+  }
+}

package/version.mjs

@@ -1,8 +1,25 @@
+// SemVer 2 precedence, without Number rounding or lexical version ordering.
+export function versionParts(value) {
+  const match = typeof value === 'string' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/.exec(value);
+  if (!match || match[4]?.split('.').some(part => /^\d+$/.test(part) && part.length > 1 && part[0] === '0')) {
+    throw Object.assign(new Error('Package version must be an unambiguous SemVer value'), { code: 'ENTROROVE_PACKAGE_VERSION_UNKNOWN' });
+  }
+  return { core: match.slice(1, 4).map(BigInt), pre: match[4]?.split('.') ?? [] };
+}
 export function compareVersions(left, right) {
-  const a = left.split('.').map(Number);
-  const b = right.split('.').map(Number);
+  const a = versionParts(left), b = versionParts(right);
   for (let index = 0; index < 3; index += 1) {
-    if (a[index] !== b[index]) return a[index] - b[index];
+    if (a.core[index] !== b.core[index]) return a.core[index] > b.core[index] ? 1 : -1;
+  }
+  if (!a.pre.length || !b.pre.length) return a.pre.length === b.pre.length ? 0 : a.pre.length ? -1 : 1;
+  for (let index = 0; index < Math.max(a.pre.length, b.pre.length); index += 1) {
+    const x = a.pre[index], y = b.pre[index];
+    if (x === y) continue;
+    if (x === undefined || y === undefined) return x === undefined ? -1 : 1;
+    const numericX = /^\d+$/.test(x), numericY = /^\d+$/.test(y);
+    if (numericX && numericY) return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (numericX !== numericY) return numericX ? -1 : 1;
+    return x > y ? 1 : -1;
   }
   return 0;
 }

package/workflow-local-runner.mjs

@@ -312,6 +312,15 @@ export async function observeWorkflowLocalStep(rawInput) {
     return { ...structuredClone(state.result), cached: true };
   }));
 }
+export function verifyOriginalWorkflowPlan(value) {
+  const configured = publicKey(process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY?.trim(), 'ENTROROVE_WORKFLOW_AUTHORITY_KEY');
+  const plan = validatePlan(verifyAuthority(value, configured));
+  lifetime(plan.acceptedAt, plan.expiresAt, MAX_PLAN_MS, Date.now());
+  return plan;
+}
+export function verifyOriginalWorkflowAuthority(value) {
+  return verifyAuthority(value, publicKey(process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY?.trim(), 'ENTROROVE_WORKFLOW_AUTHORITY_KEY'));
+}
 export async function runWorkflowLocalStep(rawInput) {
   let input; try { input = structuredClone(rawInput); } catch { fail('ENTROROVE_WORKFLOW_JSON', 'workflow values must be finite JSON'); }
   const authority = await prepare(input);