@entrorove/skill 0.1.67 → 0.1.69

package/scope-context-state.mjs

@@ -0,0 +1,88 @@
+import { constants, promises as fs } from 'node:fs';
+import { createPrivateKey, createPublicKey } from 'node:crypto';
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { scopeRoot, scopePath } from './local-scope-files.mjs';
+import { mutationHome14, mutationFile14, readMutationJson14, atomicMutationJson14,
+  privateMutationDirectory14 } from './local-mutation-files.mjs';
+import { trustedOrigin } from './remote-transport.mjs';
+import { contextExact, contextFail, contextList, validateContextAuthority } from './scope-context-wire.mjs';
+import { hydrateCloudMutationAuthority, bootstrapCloudMutationAuthority } from './cloud-mutation-authority.mjs';
+
+export async function contextPrivate(file, final = 'file', maximumBytes = 8_000_000) {
+  const item = await mutationFile14(file, { final });
+  if (process.getuid && item.stat.uid !== process.getuid() || process.platform !== 'win32' && item.stat.mode & 0o077
+    || final === 'file' && (item.stat.nlink !== 1 || item.stat.size > maximumBytes)) contextFail('Context recovery controls must be bounded private files owned by this OS account');
+  return item;
+}
+async function privateText(file) {
+  const before = await contextPrivate(file, 'file', 1_000_000);
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = await handle.stat(), text = await handle.readFile('utf8'), after = await handle.stat(), latest = await contextPrivate(file);
+    if ([opened, after, latest.stat].some(stat => ['dev', 'ino', 'size', 'mtimeMs', 'ctimeMs', 'mode'].some(field => stat[field] !== before.stat[field]))) contextFail('Original context signer changed while reading');
+    return text;
+  } finally { await handle.close(); }
+}
+export async function scopeContextLocation(repositoryRoot, flowId, dependencies) {
+  const root = await scopeRoot(repositoryRoot), home = await mutationHome14(dependencies.home), apiOrigin = trustedOrigin(dependencies.apiOrigin());
+  const relative = path.relative(root, home);
+  if (!relative || relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) contextFail('Context controls must remain outside the observed repository');
+  const stateRoot = path.join(home, '.entrorove'), base = path.join(stateRoot, 'scope-runners', sha256(`${apiOrigin}:${flowId}:${root}`)), controls = path.join(base, 'identity');
+  for (const directory of [stateRoot, path.dirname(base), base, controls]) await contextPrivate(directory, 'directory');
+  const binding = JSON.parse(await privateText(path.join(controls, 'binding.json')));
+  contextExact(binding, ['schemaVersion', 'flowId', 'repositoryRoot', 'apiOrigin', 'targetPaths', 'importContexts', 'runnerId', 'repositoryId', 'publicKey', 'keyId']);
+  if (binding.schemaVersion !== 'entrorove.local-scope-binding/1.0' || binding.flowId !== flowId || binding.repositoryRoot !== root || binding.apiOrigin !== apiOrigin
+    || !Array.isArray(binding.targetPaths) || !binding.targetPaths.length
+    || canonical(binding.targetPaths) !== canonical([...new Set(binding.targetPaths.map(scopePath))].sort())) contextFail('The original context task binding is unavailable');
+  contextList(binding.importContexts);
+  const signerConfigPath = path.join(controls, 'signer.json'), config = JSON.parse(await privateText(signerConfigPath));
+  contextExact(config, ['schemaVersion', 'privateKeyPath', 'keyId', 'receiptTtlMs']);
+  if (config.schemaVersion !== 'entrorove.scope-signer/1.0' || config.privateKeyPath !== path.join(controls, 'private.pem') || config.keyId !== binding.keyId
+    || !Number.isSafeInteger(config.receiptTtlMs) || config.receiptTtlMs < 1 || config.receiptTtlMs > 300_000) contextFail('Original context signer configuration changed');
+  const key = createPrivateKey(await privateText(config.privateKeyPath)), der = createPublicKey(key).export({ type: 'spki', format: 'der' });
+  if (key.asymmetricKeyType !== 'ed25519' || der.toString('base64') !== binding.publicKey || sha256(der) !== binding.keyId) contextFail('Original context signing key changed');
+  return { root, home, apiOrigin, stateRoot, base, binding, key, signerConfigPath, localBindingDigest: sha256(canonical(binding)),
+    directory: path.join(base, 'context-recovery'), file: path.join(base, 'context-recovery', 'journal.json') };
+}
+export async function effectiveScopeContexts(location) {
+  const directory = path.join(location.base, 'context-authority');
+  try { await contextPrivate(directory, 'directory'); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  const names = (await fs.readdir(directory)).sort(); let current = null;
+  if (names.length > 100 || names.some(name => !/^\d{6}-[a-f0-9]{64}\.json$/.test(name))) contextFail('Context authority history is invalid');
+  for (const name of names) {
+    const file = path.join(directory, name); await contextPrivate(file, 'file', 1_000_000);
+    const saved = await readMutationJson14(file), checked = validateContextAuthority(saved.record, location, current);
+    if (saved.revisionDigest !== checked.revisionDigest || name !== `${String(checked.record.revision).padStart(6, '0')}-${checked.revisionDigest}.json`) contextFail('Context history checksum or order changed');
+    current = checked;
+  }
+  return current;
+}
+export async function boundScopeContexts(base, binding, dependencies) {
+  try { await contextPrivate(path.join(base, 'context-authority'), 'directory'); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  if (!await hydrateCloudMutationAuthority(dependencies.home, dependencies.apiOrigin())) await bootstrapCloudMutationAuthority(dependencies);
+  return effectiveScopeContexts({ base, binding, localBindingDigest: sha256(canonical(binding)) });
+}
+export async function retainContextAuthority(location, effective) {
+  const current = await effectiveScopeContexts(location);
+  if (current?.revisionDigest === effective?.revisionDigest && canonical(current.record) === canonical(effective.record)) return current;
+  const checked = validateContextAuthority(effective?.record, location, current);
+  if (effective.revisionDigest !== checked.revisionDigest) contextFail('Applied context authority checksum changed');
+  const directory = path.join(location.base, 'context-authority'), file = path.join(directory, `${String(checked.record.revision).padStart(6, '0')}-${checked.revisionDigest}.json`);
+  await atomicMutationJson14(file, checked, { privateFrom: location.stateRoot }); return checked;
+}
+export async function readContextJournal(location, input) {
+  try {
+    await contextPrivate(location.file);
+    const value = await readMutationJson14(location.file);
+    if (value.schemaVersion !== 'entrorove.scope-context-journal/1.0' || value.localBindingDigest !== location.localBindingDigest) contextFail('Context journal cannot replace its original identity');
+    if (value.pending && canonical(value.input) !== canonical(input)) contextFail('Recover the original pending context request before another operation');
+    return canonical(value.input) === canonical(input) ? value : { previous: value };
+  } catch (error) { if (error.code === 'ENOENT') return {}; throw error; }
+}
+export async function saveContextJournal(location, state) {
+  if (Buffer.byteLength(canonical(state)) > 8_000_000) contextFail('Context journal exceeds its bounded state limit');
+  await privateMutationDirectory14(location.directory, { privateFrom: location.stateRoot });
+  return atomicMutationJson14(location.file, state, { replace: true, privateFrom: location.stateRoot });
+}

package/scope-context-wire.mjs

@@ -0,0 +1,84 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { scopeFail, scopePath } from './local-scope-files.mjs';
+import { scopeRevisionAuthority } from './scope-amendment-wire.mjs';
+
+const id = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
+const hash = /^[a-f0-9]{64}$/;
+export const contextFail = message => scopeFail('ENTROROVE_SCOPE_CONTEXT_BINDING', message);
+export function contextExact(value, fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || canonical(Object.keys(value).sort()) !== canonical([...fields].sort())) contextFail('Scope context fields are invalid');
+}
+export function contextList(values) {
+  if (!Array.isArray(values) || values.length > 100
+    || new Set(values.map(value => value?.sourcePrefix)).size !== values.length) contextFail('Scope contexts require unique source prefixes and at most 100 configurations');
+  for (const value of values) {
+    contextExact(value, ['sourcePrefix', 'configPath']); scopePath(value.sourcePrefix); scopePath(value.configPath);
+    if (!/(?:^|\/)(?:ts|js)config(?:\.[^/]+)?\.json$/.test(value.configPath)) contextFail('A context requires an actual tsconfig or jsconfig path');
+  }
+  return values;
+}
+export function retainedContexts(original, values) {
+  contextList(values);
+  if (original.some(prior => !values.some(value => canonical(value) === canonical(prior)))) {
+    contextFail('Context correction must retain every original build context unchanged');
+  }
+}
+function contextEvidence(values) {
+  if (!Array.isArray(values) || values.length > 200 || new Set(values.map(value => value?.path)).size !== values.length) contextFail('Context build evidence is invalid');
+  for (const value of values) {
+    contextExact(value, ['path', 'sha256']); scopePath(value.path);
+    if (!hash.test(value.sha256 ?? '')) contextFail('Context build evidence requires actual file hashes');
+  }
+}
+export function contextInput(input) {
+  const common = ['flowId', 'action'];
+  if (input?.action === 'review') common.push('importContexts', 'evidencePaths', 'reason');
+  else if (input?.action === 'apply') common.push('proposalId', 'proposalDigest');
+  else if (input?.action !== 'status') contextFail('Expected scope-context review, apply or status');
+  contextExact(input, common);
+  if (!id.test(input.flowId ?? '')) contextFail('Context recovery requires its original flow');
+  if (input.action === 'apply' && (!id.test(input.proposalId ?? '') || !hash.test(input.proposalDigest ?? ''))) contextFail('Context apply requires the original exact proposal');
+  if (input.action === 'review') {
+    contextList(input.importContexts);
+    if (!Array.isArray(input.evidencePaths) || !input.evidencePaths.length || input.evidencePaths.length > 100
+      || new Set(input.evidencePaths).size !== input.evidencePaths.length
+      || typeof input.reason !== 'string' || !input.reason.trim() || input.reason.length > 2000) contextFail('Context review requires actual bounded build evidence and a reason');
+    input.evidencePaths.forEach(scopePath);
+  }
+  return input;
+}
+export const originalContextDigest = location => sha256(canonical({ localBindingDigest: location.localBindingDigest,
+  importContexts: location.binding.importContexts }));
+export function validateContextAuthority(value, location, previous) {
+  const record = scopeRevisionAuthority(value, 'entrorove.scope-context-authority/1.0');
+  const expectedRevision = (previous?.record.revision ?? 0) + 1;
+  if (['flowId', 'runnerId', 'repositoryId', 'keyId'].some(field => record[field] !== location.binding[field])
+    || record.localBindingDigest !== location.localBindingDigest || record.revision !== expectedRevision
+    || record.previousDigest !== (previous?.revisionDigest ?? originalContextDigest(location))
+    || canonical(record.originalImportContexts) !== canonical(location.binding.importContexts)
+    || canonical(record.targetPaths) !== canonical(location.binding.targetPaths)
+    || !id.test(record.ownerId ?? '') || !hash.test(record.taskDigest ?? '') || !hash.test(record.chainDigest ?? '')
+    || !id.test(record.proposalId ?? '') || !hash.test(record.proposalDigest ?? '')) contextFail('Context authority replaced its original signer, paths or revision chain');
+  retainedContexts(previous?.record.importContexts ?? location.binding.importContexts, record.importContexts);
+  contextEvidence(record.evidence);
+  if (previous && ['ownerId', 'taskDigest', 'chainDigest'].some(field => record[field] !== previous.record[field])
+    || record.importContexts.some(context => !record.evidence.some(file => file.path === context.configPath))) contextFail('Context authority lost its original task or actual configuration evidence');
+  return { record, revisionDigest: sha256(canonical(record)) };
+}
+export function contextChallenge(value, location, proposal, { allowExpired = false } = {}) {
+  const challenge = scopeRevisionAuthority(value, 'entrorove.scope-context-challenge/1.0');
+  if (['flowId', 'runnerId', 'repositoryId', 'keyId'].some(field => challenge[field] !== location.binding[field])
+    || challenge.localBindingDigest !== location.localBindingDigest
+    || ['proposalId', 'proposalDigest', 'expectedRevision', 'previousDigest', 'ownerId', 'taskDigest', 'chainDigest'].some(field => challenge[field] !== proposal[field])
+    || canonical(challenge.targetPaths) !== canonical(location.binding.targetPaths)
+    || canonical(challenge.importContexts) !== canonical(proposal.importContexts)
+    || canonical(challenge.evidence) !== canonical(proposal.evidence)
+    || ['stepId', 'challengeId', 'challenge'].some(field => !id.test(challenge[field] ?? '')) || !challenge.task) contextFail('Context challenge differs from its exact original proposal');
+  retainedContexts(location.binding.importContexts, challenge.importContexts);
+  contextEvidence(challenge.evidence);
+  const issued = Date.parse(challenge.issuedAt), expires = Date.parse(challenge.expiresAt);
+  if (!Number.isFinite(issued) || !Number.isFinite(expires) || issued > Date.now() + 5000
+    || expires <= issued || expires - issued > 90_000 || !allowExpired && expires <= Date.now()) contextFail('Context challenge is expired');
+  return challenge;
+}

package/scope-runner-client.mjs

@@ -7,6 +7,7 @@ import { withStateLock } from './local-state-lock.mjs';
 import { snapshotPlan, snapshotVerify } from './local-execution.mjs';
 import { probe } from './local-probe.mjs';
 import { invokeRemoteResult } from './remote-client.mjs';
+import { boundScopeContexts } from './scope-context-state.mjs';
 
 async function privateDirectory(directory) {
   await fs.mkdir(directory, { recursive: true, mode: 0o700 });
@@ -23,7 +24,7 @@ async function readPrivate(file) {
   const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
   try { return await handle.readFile('utf8'); } finally { await handle.close(); }
 }
-async function signer(directory, identity) {
+async function signer(directory, identity, dependencies) {
   const controls = path.join(directory, 'identity'), file = path.join(controls, 'binding.json');
   let binding;
   try { binding = JSON.parse(await readPrivate(file)); }
@@ -41,7 +42,9 @@ async function signer(directory, identity) {
       await fs.rename(stage, controls);
     } finally { await fs.rm(stage, { recursive: true, force: true }); }
   }
-  if (Object.keys(identity).some(field => canonical(binding[field]) !== canonical(identity[field]))) {
+  const contextAuthority = await boundScopeContexts(directory, binding, dependencies);
+  if (Object.keys(identity).filter(field => field !== 'importContexts').some(field => canonical(binding[field]) !== canonical(identity[field]))
+    || canonical(contextAuthority?.record.importContexts ?? binding.importContexts) !== canonical(identity.importContexts)) {
     scopeFail('ENTROROVE_SCOPE_REPLACEMENT', 'The original local task signer, repository and path set cannot be replaced');
   }
   await privateDirectory(controls);
@@ -49,7 +52,7 @@ async function signer(directory, identity) {
   if (key.asymmetricKeyType !== 'ed25519' || sha256(createPublicKey(key).export({ type: 'spki', format: 'der' })) !== binding.keyId) {
     scopeFail('ENTROROVE_SCOPE_STATE', 'Original scope signer key identity changed');
   }
-  return { binding, key, signerConfigPath: path.join(controls, 'signer.json') };
+  return { binding, key, signerConfigPath: path.join(controls, 'signer.json'), contextAuthority };
 }
 async function remote(operation, input, dependencies) {
   const { response, result } = await invokeRemoteResult({ operation, input }, dependencies);
@@ -60,7 +63,7 @@ async function remote(operation, input, dependencies) {
   return result.output;
 }
 async function connect(identity, directory, dependencies) {
-  const { binding, key, signerConfigPath } = await signer(directory, identity);
+  const { binding, key, signerConfigPath, contextAuthority } = await signer(directory, identity, dependencies);
   const prepared = await remote('scope-runner-prepare', { flowId: identity.flowId, attemptId: randomUUID(), runnerId: binding.runnerId,
     repositoryId: binding.repositoryId, publicKey: binding.publicKey, targetPaths: identity.targetPaths }, dependencies);
   const enrollment = prepared.enrollment;
@@ -76,7 +79,8 @@ async function connect(identity, directory, dependencies) {
     scopeFail('ENTROROVE_SCOPE_BINDING', 'Cloud scope challenge differs from the original account and accepted task');
   }
   const input = { repositoryRoot: identity.repositoryRoot, home: dependencies.home, flowId: identity.flowId,
-    stepId: challenge.stepId, paths: identity.targetPaths, snapshotId: `snapshot-${randomUUID()}`, importContexts: identity.importContexts };
+    stepId: challenge.stepId, paths: identity.targetPaths, snapshotId: `snapshot-${randomUUID()}`, importContexts: identity.importContexts,
+    ...(contextAuthority ? { contextRevisionDigest: contextAuthority.revisionDigest, contextEvidence: contextAuthority.record.evidence } : {}) };
   const planned = await snapshotPlan(input), verified = await snapshotVerify(input);
   if (verified.verified !== true || verified.receipt.snapshotDigest !== planned.snapshotDigest) scopeFail('ENTROROVE_SCOPE_SNAPSHOT', 'Actual copied snapshot did not verify');
   const observed = await probe({ ...input, ownerId: challenge.ownerId, task: challenge.task, taskDigest: challenge.taskDigest,