@entrorove/skill 0.1.32 → 0.1.34

package/remote-client.mjs

@@ -2,6 +2,8 @@ import { createHash } from 'node:crypto';
 import Ajv from 'ajv';
 import { parseTransportResponse, requestTransport, trustedOrigin } from './remote-transport.mjs';
 import { appendInvocation } from './local-invocations.mjs';
+import { verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
+import { ideClientHeaders, presentInvocationNotices } from './ide-presentation.mjs';
 
 export const apiUrl = 'https://entrorove.com/api/skill/invoke';
 
@@ -33,11 +35,17 @@ export function buildInvocation(operation, input) {
   if (!['capabilities', 'task-describe', 'message-route', 'message-accept', 'task-resume', 'task-checkpoint',
     'message-status', 'message-delivery-start', 'message-delivery-report', 'message-resolve', 'message-complete',
     'handoff-prepare', 'handoff-release', 'handoff-claim', 'handoff-status', 'handoff-resume', 'handoff-execution-authority', 'mutation-snapshot-challenge', 'mutation-pass-issue',
+    'scope-runner-prepare', 'scope-runner-register', 'scope-runner-challenge', 'scope-runner-attest',
     'start', 'continue'].includes(operation)) throw new Error('Invalid entrorove operation');
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Input must be a JSON object');
   const id = requestId(operation, input);
   return { url: apiUrl, requestId: id, body: { schemaVersion: 'entrorove.skill.request/2.0', requestId: id, operation, input } };
 }
+function requiresAutomaticFeedback(operation, input, capabilities) {
+  const actual = operation === 'continue' ? input.operation : operation;
+  return capabilities?.responseExtensions?.automaticFeedback === 'entrorove.automatic-feedback/1.0'
+    && !capabilities.responseExtensions.automaticFeedbackObservations?.includes(actual);
+}
 
 export function validateDiscoveredChecks(input, checks = []) {
   for (const check of checks) {
@@ -62,25 +70,35 @@ export async function invokeRemote(data, dependencies) {
     process.exitCode = 2;
     return;
   }
-  const call = { ...buildInvocation(data.operation, data.input), url: `${trustedOrigin(apiOrigin())}/api/skill/invoke` };
   const token = await readCredential(home);
+  const { response, result } = await invokeDiscovered(data, token, { home, apiOrigin });
+  process.stdout.write(JSON.stringify(presentInvocationNotices(result,dependencies.onIdeEvent)) + '\n');
+  if (!response.ok || result.output.status === 'blocked' || result.output.status === 'failed'
+    || result.output.status === 'incomplete') process.exitCode = 2;
+}
+
+export async function invokeRemoteResult(data, dependencies) {
+  const token = await machineCredential(dependencies);
+  return invokeDiscovered(data, token, dependencies);
+}
+async function invokeDiscovered(data, token, { home, apiOrigin }) {
+  const call = { ...buildInvocation(data.operation, data.input), url: `${trustedOrigin(apiOrigin())}/api/skill/invoke` };
+  let feedbackRequired = false;
   if (data.operation !== 'capabilities') {
     const discovery = await postInvocation({ ...buildInvocation('capabilities', {}), url: call.url }, token, home);
     if (!discovery.response.ok || discovery.result.output.status !== 'succeeded') throw new Error(`Capability discovery failed: HTTP ${discovery.response.status}`);
     const capabilities = discovery.result.output.capabilities;
+    feedbackRequired = requiresAutomaticFeedback(data.operation,data.input,capabilities);
     const schema = capabilities?.operationSchemas?.[data.operation];
     if (!capabilities?.operations?.includes(data.operation) || !schema) throw new Error(`Capability discovery does not support ${data.operation}`);
     const validate = discoveredAjv().compile(schema);
     if (!validate(data.input)) throw new Error(`Invalid ${data.operation} input: ${validate.errors.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ')}`);
     validateDiscoveredChecks(data.input, capabilities.inputChecks?.[data.operation]);
   }
-  const { response, result } = await postInvocation(call, token, home);
-  process.stdout.write(JSON.stringify(result) + '\n');
-  if (!response.ok || result.output.status === 'blocked' || result.output.status === 'failed'
-    || result.output.status === 'incomplete') process.exitCode = 2;
+  return postInvocation(call, token, home,feedbackRequired);
 }
 
-async function postInvocation(call, token, home) {
+async function postInvocation(call, token, home, feedbackRequired = false) {
   const metadata = { kind: 'remote', operation: call.body.operation, requestId: call.requestId };
   const logged = async value => {
     try { return await appendInvocation({ ...metadata, ...value }, home); }
@@ -91,7 +109,7 @@ async function postInvocation(call, token, home) {
   try {
     response = await requestTransport(new URL(call.url).origin, '/api/skill/invoke', {
       method: 'POST', timeoutMs: 135_000,
-      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` }, body: JSON.stringify(call.body),
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}`,...ideClientHeaders() }, body: JSON.stringify(call.body),
     });
   } catch (cause) {
     if (cause.established) await logged({ event: 'outcome-unknown' });
@@ -113,6 +131,10 @@ async function postInvocation(call, token, home) {
     await logged({ event: 'outcome-unknown' }); throw unknownInvocation(call.requestId);
   }
   await logged({ event: response.ok ? 'completed' : 'rejected', usage: result.usage ?? [] });
+  if (result.feedback) verifyAutomaticFeedback(result.feedback,call.requestId,call.requestId);
+  else if (feedbackRequired && !['running','pending'].includes(result.output.status)) {
+    throw new Error(`Automatic feedback receipt is missing; query feedback ${call.requestId}. Do not repeat the invocation.`);
+  }
   return { response, result };
 }
 
@@ -149,13 +171,16 @@ export function createTaskMessageClient(dependencies) {
     async invoke(operation, input) {
       const original = buildInvocation(operation, input);
       const token = await machineCredential(dependencies); const origin = machineOrigin(dependencies);
+      let feedbackRequired = false;
       if (operation !== 'capabilities') {
         const discovery = buildInvocation('capabilities', {});
         const discovered = await postInvocation({ ...discovery, url: `${origin}/api/skill/invoke` }, token, dependencies.home);
         if (!discovered.response.ok || discovered.result.output.status !== 'succeeded') throw new Error('Task message capability discovery failed');
         validateMachineCapability(operation, input, discovered.result.output.capabilities);
+        feedbackRequired = requiresAutomaticFeedback(operation,input,discovered.result.output.capabilities);
       }
-      const { response, result } = await postInvocation({ ...original, url: `${origin}/api/skill/invoke` }, token, dependencies.home);
+      const { response, result } = await postInvocation({ ...original, url: `${origin}/api/skill/invoke` }, token, dependencies.home,feedbackRequired);
+      presentInvocationNotices(result,dependencies.onIdeEvent);
       if (stoppedOriginalResume(response, result.output, operation, input)) return result.output;
       if (!response.ok || ['blocked', 'failed', 'incomplete'].includes(result.output.status)) {
         throw new Error(`Task message invocation was rejected: HTTP ${response.status}; requestId=${original.requestId}`);
@@ -169,6 +194,8 @@ export function createTaskMessageClient(dependencies) {
         { authorization: `Bearer ${token}` }, 'original task message status');
       const result = await readResponse(response, 'task message status');
       if (!response.ok || !result?.output || result.output.requestId !== id) throw new Error('Original task message status is unavailable or invalid');
+      if (result.feedback) verifyAutomaticFeedback(result.feedback,id);
+      presentInvocationNotices(result,dependencies.onIdeEvent);
       await appendInvocation({ kind: 'remote', operation: 'status', requestId: id, event: 'status', usage: result.usage ?? [] }, dependencies.home);
       return result.output;
     },
@@ -182,7 +209,8 @@ export async function queryStatus(requestId, dependencies) {
   const result = await readResponse(response, 'status');
   if (!response.ok || result?.output?.requestId !== requestId) throw new Error(`entrorove status failed: HTTP ${response.status}; requestId=${requestId}`);
   await appendInvocation({ kind: 'remote', operation: 'status', requestId, event: 'status', usage: result.usage ?? [] }, dependencies.home);
-  process.stdout.write(JSON.stringify(result) + '\n');
+  if (result.feedback) verifyAutomaticFeedback(result.feedback,requestId);
+  process.stdout.write(JSON.stringify(presentInvocationNotices(result,dependencies.onIdeEvent)) + '\n');
 }
 
 export async function queryFlows(dependencies) {

package/scope-runner-client.mjs

@@ -0,0 +1,125 @@
+import { createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from 'node:crypto';
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { scopeFail, scopePath, scopeRoot, scopeTarget } from './local-scope-files.mjs';
+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';
+
+async function privateDirectory(directory) {
+  await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  const stat = await fs.lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.getuid && stat.uid !== process.getuid()) {
+    scopeFail('ENTROROVE_SCOPE_STATE', 'Scope signer storage must belong to the current OS account');
+  }
+  if (process.platform !== 'win32') await fs.chmod(directory, 0o700);
+}
+async function readPrivate(file) {
+  const stat = await fs.lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || process.getuid && stat.uid !== process.getuid()
+    || process.platform !== 'win32' && (stat.mode & 0o077)) scopeFail('ENTROROVE_SCOPE_STATE', 'Scope signer files must be private regular files');
+  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) {
+  const controls = path.join(directory, 'identity'), file = path.join(controls, 'binding.json');
+  let binding;
+  try { binding = JSON.parse(await readPrivate(file)); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  if (!binding) {
+    const keys = generateKeyPairSync('ed25519'), publicDer = keys.publicKey.export({ type: 'spki', format: 'der' });
+    binding = { schemaVersion: 'entrorove.local-scope-binding/1.0', ...identity, runnerId: `local-scope-${randomUUID()}`,
+      repositoryId: `local-repository-${sha256(identity.repositoryRoot).slice(0, 32)}`, publicKey: publicDer.toString('base64'), keyId: sha256(publicDer) };
+    const stage = path.join(directory, `.signer-${randomUUID()}`); await privateDirectory(stage);
+    try {
+      await fs.writeFile(path.join(stage, 'private.pem'), keys.privateKey.export({ type: 'pkcs8', format: 'pem' }), { flag: 'wx', mode: 0o600 });
+      await fs.writeFile(path.join(stage, 'signer.json'), `${JSON.stringify({ schemaVersion: 'entrorove.scope-signer/1.0',
+        privateKeyPath: path.join(controls, 'private.pem'), keyId: binding.keyId, receiptTtlMs: 60_000 })}\n`, { flag: 'wx', mode: 0o600 });
+      await fs.writeFile(path.join(stage, 'binding.json'), `${JSON.stringify(binding)}\n`, { flag: 'wx', mode: 0o600 });
+      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]))) {
+    scopeFail('ENTROROVE_SCOPE_REPLACEMENT', 'The original local task signer, repository and path set cannot be replaced');
+  }
+  await privateDirectory(controls);
+  const key = createPrivateKey(await readPrivate(path.join(controls, 'private.pem')));
+  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') };
+}
+async function remote(operation, input, dependencies) {
+  const { response, result } = await invokeRemoteResult({ operation, input }, dependencies);
+  if (!response.ok || result.output.status !== 'succeeded') {
+    throw Object.assign(new Error(result.output.message ?? `Scope connection blocked at ${operation}`),
+      { code: result.output.code ?? 'ENTROROVE_SCOPE_BLOCKED', output: result.output });
+  }
+  return result.output;
+}
+async function connect(identity, directory, dependencies) {
+  const { binding, key, signerConfigPath } = await signer(directory, identity);
+  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;
+  if (enrollment.flowId !== identity.flowId || enrollment.runnerId !== binding.runnerId || enrollment.keyId !== binding.keyId
+    || canonical(enrollment.targetPaths) !== canonical(identity.targetPaths)) scopeFail('ENTROROVE_SCOPE_BINDING', 'Cloud enrollment differs from the original local task signer');
+  await remote('scope-runner-register', { flowId: identity.flowId, enrollmentId: enrollment.enrollmentId,
+    signature: sign(null, Buffer.from(canonical(enrollment)), key).toString('base64url') }, dependencies);
+  const issued = await remote('scope-runner-challenge', { flowId: identity.flowId, receiverId: binding.runnerId, attemptId: randomUUID() }, dependencies);
+  const challenge = issued.challenge;
+  if (challenge.flowId !== identity.flowId || challenge.ownerId !== enrollment.ownerId || challenge.runnerId !== binding.runnerId
+    || challenge.repositoryId !== binding.repositoryId || challenge.taskDigest !== enrollment.taskDigest
+    || challenge.chainDigest !== enrollment.chainDigest || canonical(challenge.targetPaths) !== canonical(identity.targetPaths)) {
+    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 };
+  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,
+    chainDigest: challenge.chainDigest, repositoryId: challenge.repositoryId, challenge: challenge.challenge, signerConfigPath });
+  const accepted = await remote('scope-runner-attest', { flowId: identity.flowId, attestation: observed.attestation }, dependencies);
+  return { schemaVersion: 'entrorove.scope-connection/1.0', status: 'succeeded', flowId: identity.flowId,
+    runnerId: binding.runnerId, scopeEvidence: accepted.scopeEvidence, grantsExecutionAuthority: false,
+    nextOperation: 'workflow-gate' };
+}
+export async function connectScopeRunner(repositoryRoot, input, dependencies) {
+  if (!input || Object.keys(input).some(field => !['flowId', 'paths', 'importContexts'].includes(field))
+    || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(input.flowId ?? '') || !Array.isArray(input.paths) || !input.paths.length) {
+    scopeFail('ENTROROVE_SCOPE_INPUT', 'Expected {flowId,paths} for the original task and concrete existing source files');
+  }
+  const root = await scopeRoot(repositoryRoot), targetPaths = [...new Set(input.paths.map(scopePath))].sort();
+  if (targetPaths.length !== input.paths.length) scopeFail('ENTROROVE_SCOPE_INPUT', 'Scope paths must be unique');
+  for (const relative of targetPaths) {
+    const target = await scopeTarget(root, relative);
+    if (!target.stat.isFile()) scopeFail('ENTROROVE_SCOPE_INPUT', 'Scope connection requires concrete existing source files');
+  }
+  const importContexts = input.importContexts ?? [];
+  if (!Array.isArray(importContexts) || importContexts.length > 100 || new Set(importContexts.map(context => context?.sourcePrefix)).size !== importContexts.length) {
+    scopeFail('ENTROROVE_SCOPE_INPUT', 'Import contexts require unique source prefixes and at most 100 actual build configurations');
+  }
+  for (const context of importContexts) {
+    if (!context || Object.keys(context).sort().join(',') !== 'configPath,sourcePrefix') scopeFail('ENTROROVE_SCOPE_INPUT', 'Each import context requires sourcePrefix and configPath');
+    scopePath(context.sourcePrefix); scopePath(context.configPath);
+  }
+  const identity = { flowId: input.flowId, repositoryRoot: root, apiOrigin: dependencies.apiOrigin(), targetPaths, importContexts };
+  const parent = path.join(dependencies.home, '.entrorove');
+  await privateDirectory(parent);
+  const runners = path.join(parent, 'scope-runners'); await privateDirectory(runners);
+  const directory = path.join(runners, sha256(`${identity.apiOrigin}:${input.flowId}:${root}`)); await privateDirectory(directory);
+  return withStateLock(path.join(directory, 'connection'), () => connect(identity, directory, dependencies));
+}
+
+export async function runScopeConnect(repositoryRoot, input, dependencies) {
+  await dependencies.install();
+  if (!await dependencies.agreementAccepted(dependencies.home)) return dependencies.agreementRequired(dependencies.home);
+  try { return await connectScopeRunner(repositoryRoot, input, dependencies); }
+  catch (error) {
+    if (error.outcomeUnknown || !error.code?.startsWith('ENTROROVE_')) throw error;
+    return { schemaVersion: 'entrorove.scope-connection/1.0', status: 'blocked', flowId: input?.flowId,
+      code: error.code, message: error.message, ...(error.output ? { output: error.output } : {}) };
+  }
+}