@entrorove/skill 0.1.64 → 0.1.68

package/rollback-history.mjs

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { atomicMutationJson14, mutationFail14, mutationFile14, mutationPath14, mutationStateRoot14,
+  privateMutationDirectory14, readMutationJson14 } from './local-mutation-files.mjs';
+
+const SHA = /^[a-f0-9]{64}$/;
+async function location(input, root, target, digest) {
+  mutationPath14(target);
+  if (!SHA.test(digest)) mutationFail14('ENTROROVE_ROLLBACK_HISTORY_INVALID', 'Rollback comparison requires exact file digests');
+  const state = await mutationStateRoot14(input), repositoryDigest = sha256(root);
+  const directory = path.join(state, 'rollback-baselines', repositoryDigest, sha256(target));
+  return { state, directory, file: path.join(directory, `${digest}.json`), repositoryDigest };
+}
+async function read(loc, target, digest) {
+  let info;
+  try { info = await mutationFile14(loc.file); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  if (info.stat.size > 8192) mutationFail14('ENTROROVE_ROLLBACK_HISTORY_INVALID', 'Rollback baseline record exceeds its bounded schema');
+  const record = await readMutationJson14(loc.file), { recordDigest, ...body } = record;
+  if (body.schemaVersion !== 'entrorove.rollback-baseline/1.0' || body.repositoryDigest !== loc.repositoryDigest
+    || body.targetPath !== target || body.baselineDigest !== digest || sha256(canonical(body)) !== recordDigest
+    || !['mutation-snapshot', 'approved-process-comparison'].includes(body.proof?.kind)
+    || !SHA.test(body.proof.authorityDigest ?? '') || !SHA.test(body.proof.baselineManifestDigest ?? '')
+    || body.claimsCompletedWrite !== false || body.grantsRollbackAuthority !== false) {
+    mutationFail14('ENTROROVE_ROLLBACK_HISTORY_INVALID', 'Rollback baseline record is invalid; preserve the record and original failure');
+  }
+  return record;
+}
+export async function assertRollbackCandidate(input, root, target, current, candidate) {
+  if (current === candidate) return;
+  const loc = await location(input, root, target, candidate);
+  if (await read(loc, target, candidate)) mutationFail14('ENTROROVE_ROLLBACK_PROOF_REQUIRED',
+    'Candidate restores an actually observed historical file image; use the original independently signed rollback with exact current/restore hashes and transaction records');
+}
+// These immutable observations prove only earlier bytes. They never claim a
+// pending process finished, revive old write authority, or authorize rollback.
+export async function rememberRollbackBaseline(input, root, target, digest, proof) {
+  const loc = await location(input, root, target, digest);
+  if (await read(loc, target, digest)) return;
+  const body = { schemaVersion: 'entrorove.rollback-baseline/1.0', repositoryDigest: loc.repositoryDigest,
+    targetPath: target, baselineDigest: digest, proof, claimsCompletedWrite: false, grantsRollbackAuthority: false };
+  await privateMutationDirectory14(loc.directory, { privateFrom: loc.state });
+  try { await atomicMutationJson14(loc.file, { ...body, recordDigest: sha256(canonical(body)) }, { privateFrom: loc.state }); }
+  catch (error) { if (error.code !== 'ENTROROVE_STATE_EXISTS' || !await read(loc, target, digest)) throw error; }
+}
+export async function rememberMutationBaselines(input, value, before) {
+  const proof = { kind: 'mutation-snapshot', authorityDigest: sha256(canonical(value.pass)),
+    baselineManifestDigest: value.pass.snapshotManifestDigest };
+  for (const file of before) if (file.exists) {
+    await rememberRollbackBaseline(input, value.binding.root, file.path, file.sha256, proof);
+  }
+}

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);