@matuto-ai/opencode-broker-connector 0.1.1 → 0.4.0

package/vendor/broker/reference/inbox.mjs

@@ -2,7 +2,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { mkdirSync, lstatSync, statfsSync, readdirSync, chmodSync, realpathSync } from 'node:fs';
 import { resolve, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { canonical, digest, validateEnvelope, validateUuid, validateSend, validateIdempotencyKey, TYPES } from '../src/protocol.mjs';
+import { canonical, digest, validateEnvelope, validateUuid, validateSend, validateIdempotencyKey, validateResend, TYPES } from '../src/protocol.mjs';
 import { LocalError } from './errors.mjs';
 
 export function newSessionIdentity(clientType) {
@@ -68,6 +68,12 @@ export class Inbox {
           key TEXT PRIMARY KEY, digest TEXT NOT NULL, request TEXT NOT NULL,
           created_at INTEGER NOT NULL, retry_until INTEGER NOT NULL, result TEXT);
         PRAGMA user_version=1;`);
+      if(!this.db.prepare('PRAGMA table_info(outgoing)').all().some(c=>c.name==='kind'))this.db.exec("ALTER TABLE outgoing ADD COLUMN kind TEXT NOT NULL DEFAULT 'send'");
+      for(const [name,type] of [['failure','TEXT'],['uncertain','INTEGER NOT NULL DEFAULT 0'],['operation_id','TEXT']]){
+        if(!this.db.prepare('PRAGMA table_info(outgoing)').all().some(c=>c.name===name))this.db.exec(`ALTER TABLE outgoing ADD COLUMN ${name} ${type}`);
+      }
+      this.db.exec('CREATE UNIQUE INDEX IF NOT EXISTS outgoing_operation ON outgoing(operation_id) WHERE operation_id IS NOT NULL');
+      this.db.exec('CREATE INDEX IF NOT EXISTS outgoing_recovery ON outgoing(retry_until,created_at,key) WHERE result IS NULL AND failure IS NULL');
       const stored = this.getState('identity');
       if (stored && canonical(stored) !== canonical(this.identity)) throw new LocalError('session_mismatch');
       if (!stored) this.setState('identity', this.identity);
@@ -234,33 +240,62 @@ export class Inbox {
     });
   }
 
-  prepareSend(rawRequest, { key = randomUUID(), retryWindowSeconds = 86400 } = {}) {
-    key = validateIdempotencyKey(key);
-    const request = validateSend(rawRequest);
+  prepareSend(rawRequest, options = {}) {
+    return this.prepareOperation('send',validateSend(rawRequest),options);
+  }
+
+  prepareResend(messageId, input = {}, options = {}) {
+    const validated=validateResend(input);
+    return this.prepareOperation('resend',{message_id:validateUuid(messageId),...(input.ttl_seconds===undefined?{}:validated)},options);
+  }
+
+  prepareOperation(kind, request, { key, operationId, issuedAt=this.now(), retryUntil, retryWindowSeconds = 86400 } = {}) {
+    if(operationId!==undefined&&(typeof operationId!=='string'||!/^[a-f0-9]{64}$/.test(operationId)))throw new LocalError('invalid_configuration');
+    const mapped=operationId?this.outgoingForOperation(operationId):null;
+    key = validateIdempotencyKey(key??mapped?.key??`op_${issuedAt}_${randomUUID().replaceAll('-','')}`);
     const encoded = canonical(request);
     const hash = digest(request);
     const existing = this.outgoing(key);
     if (existing) {
-      if (existing.digest !== hash) throw new LocalError('send_conflict');
+      if (existing.digest !== hash || existing.kind !== kind) throw new LocalError('send_conflict');
       return key;
     }
+    const started=/^op_([0-9]{13})_/.exec(key);
+    if(started&&issuedAt-Number(started[1])>=retryWindowSeconds*1000)throw new LocalError('retry_window_elapsed',{effect:'unknown'});
+    if(retryUntil!==undefined&&(!Number.isSafeInteger(retryUntil)||retryUntil<=this.now()))throw new LocalError('retry_window_elapsed',{effect:'unknown'});
     if (!Number.isSafeInteger(retryWindowSeconds) || retryWindowSeconds < 1) throw new LocalError('invalid_configuration');
     this.transaction(() => {
+      this.db.prepare('DELETE FROM outgoing WHERE key IN (SELECT key FROM outgoing WHERE (result IS NOT NULL OR failure IS NOT NULL) AND retry_until<? LIMIT 100)').run(this.now());
       if (this.db.prepare('SELECT COUNT(*) AS n FROM outgoing').get().n >= this.limits.maxOutgoingCount) throw new LocalError('inbox_full');
-      this.db.prepare('INSERT INTO outgoing(key,digest,request,created_at,retry_until) VALUES(?,?,?,?,?)').run(key, hash, encoded, this.now(), this.now() + retryWindowSeconds * 1000);
+      this.db.prepare('INSERT INTO outgoing(key,digest,request,created_at,retry_until,kind,operation_id) VALUES(?,?,?,?,?,?,?)').run(key, hash, encoded, this.now(), Math.min(retryUntil??Infinity,this.now()+retryWindowSeconds*1000),kind,operationId??null);
     }, { growth: Buffer.byteLength(encoded) * 3 + 8192 });
     return key;
   }
 
+  outgoingForOperation(operationId) {
+    const row=this.db.prepare('SELECT key FROM outgoing WHERE operation_id=?').get(operationId);
+    return row?this.outgoing(row.key):null;
+  }
+
   outgoing(key) {
     this.assertUsable();
     const row = this.db.prepare('SELECT * FROM outgoing WHERE key=?').get(key);
-    return row ? { ...row, request: JSON.parse(row.request), result: row.result ? JSON.parse(row.result) : null } : null;
+    return row ? { ...row, request: JSON.parse(row.request), result: row.result ? JSON.parse(row.result) : null, failure: row.failure ? JSON.parse(row.failure) : null } : null;
   }
 
   unresolvedSends() {
     this.assertUsable();
-    return this.db.prepare('SELECT key,created_at,retry_until FROM outgoing WHERE result IS NULL ORDER BY created_at LIMIT 100').all().map(row => ({ ...row }));
+    return this.db.prepare('SELECT key,created_at,retry_until FROM outgoing WHERE result IS NULL AND failure IS NULL ORDER BY created_at LIMIT 100').all().map(row => ({ ...row }));
+  }
+
+  outgoingRecovery(limit = 10, now = this.now()) {
+    this.assertUsable();
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(now)) throw new LocalError('invalid_configuration');
+    // Filter before LIMIT: retained, expired unknowns must never starve live retries.
+    // Earliest deadline first uses the partial index without sorting/scanning old rows.
+    const operations = this.db.prepare('SELECT key,created_at,retry_until FROM outgoing WHERE result IS NULL AND failure IS NULL AND retry_until>? ORDER BY retry_until,created_at,key LIMIT ?').all(now, limit).map(row => ({ ...row }));
+    const expiredCount = this.db.prepare('SELECT count(*) AS n FROM outgoing WHERE result IS NULL AND failure IS NULL AND retry_until<=?').get(now).n;
+    return { operations, expiredCount };
   }
 
   recordSendResult(key, result) {
@@ -268,15 +303,25 @@ export class Inbox {
     if (Buffer.byteLength(encoded) > 16384) throw new LocalError('invalid_response', { effect: 'unknown' });
     this.transaction(() => {
       if (!this.outgoing(key)) throw new LocalError('invalid_configuration');
-      this.db.prepare('UPDATE outgoing SET result=? WHERE key=?').run(encoded, key);
+      this.db.prepare('UPDATE outgoing SET result=?,failure=NULL,uncertain=0 WHERE key=?').run(encoded, key);
     }, { growth: Buffer.byteLength(encoded) * 2 + 8192 });
   }
 
+  markOutgoingAttempt(key) {
+    this.transaction(()=>this.db.prepare('UPDATE outgoing SET uncertain=1 WHERE key=?').run(key));
+  }
+
+  recordSendFailure(key, failure) {
+    const encoded=canonical(failure);
+    if(Buffer.byteLength(encoded)>16384)throw new LocalError('invalid_response',{effect:'unknown'});
+    this.transaction(()=>this.db.prepare('UPDATE outgoing SET failure=?,uncertain=0 WHERE key=? AND result IS NULL').run(encoded,key),{growth:Buffer.byteLength(encoded)*2+8192});
+  }
+
   collect(limit = 100) {
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000) throw new LocalError('invalid_configuration');
     return this.transaction(() => {
       const removedInbox = this.db.prepare("DELETE FROM inbox WHERE message_id IN (SELECT message_id FROM inbox WHERE state='consumed' AND retain_until<? ORDER BY retain_until LIMIT ?)").run(this.now(), limit).changes;
-      const removedSends = this.db.prepare('DELETE FROM outgoing WHERE key IN (SELECT key FROM outgoing WHERE result IS NOT NULL AND retry_until<? ORDER BY retry_until LIMIT ?)').run(this.now(), limit).changes;
+      const removedSends = this.db.prepare('DELETE FROM outgoing WHERE key IN (SELECT key FROM outgoing WHERE (result IS NOT NULL OR failure IS NOT NULL) AND retry_until<? ORDER BY retry_until LIMIT ?)').run(this.now(), limit).changes;
       return { removed_inbox: removedInbox, removed_sends: removedSends };
     });
   }

package/vendor/broker/reference/mcp-stdio.mjs

@@ -13,8 +13,12 @@ const metadata = object({ name: text(128), model, project: { type: ['string', 'n
 
 export const TOOL_DEFINITIONS = Object.freeze([
   { name: 'broker_list_clients', description: 'List authorized exact session addresses. Names and models are descriptive, not routing authority.', inputSchema: object({ connected: { type: 'boolean' }, client_type: { enum: ['pi', 'antigravity-cli', 'claude-code', 'opencode'] }, name: text(128), project: text(256), cursor: text(256), limit: { type: 'integer', minimum: 1, maximum: 100 } }) },
-  { name: 'broker_send', description: 'Send opaque untrusted AGENT text to one exact client_id. Acceptance means broker storage only; preserve send_key on uncertain results.', inputSchema: object({ recipient_id: uuid, text: text(65536), ttl_seconds: { type: 'integer', minimum: 60, maximum: 604800 }, correlation_id: text(128), reply_to_message_id: uuid, send_key: text(128) }, ['recipient_id', 'text']) },
+  { name: 'broker_send', description: 'Send opaque untrusted AGENT text to one exact client_id. Acceptance means broker storage only; internal operation identity handles technical retries.', inputSchema: object({ recipient_id: uuid, text: text(65536), ttl_seconds: { type: 'integer', minimum: 60, maximum: 604800 }, correlation_id: text(128), reply_to_message_id: uuid }, ['recipient_id', 'text']) },
   { name: 'broker_update_metadata', description: 'CAS update of descriptive name/model/project only. Metadata does not grant access or change identity.', inputSchema: object({ metadata_patch: metadata, expected_metadata_revision: { type: 'integer', minimum: 1 } }, ['metadata_patch', 'expected_metadata_revision']) },
+  { name: 'broker_sent_history', description: 'Read only this exact session’s outgoing metadata, newest first. Default 10, maximum 100, 32768-byte cap. No content. Preserve filters on continuation; restart on history_changed.', inputSchema: object({ recipient_id: uuid, status: { enum: ['queued','claimed','delivered','expired','failed','cancelled'] }, accepted_after: text(24), accepted_before: text(24), cursor: text(1024), limit: { type: 'integer', minimum: 1, maximum: 100 } }) },
+  { name: 'broker_message_content', description: 'Explicitly retrieve the original content and current transport receipt of one owned outgoing message.', inputSchema: object({ message_id: uuid }, ['message_id']) },
+  { name: 'broker_resend', description: 'Explicit new delivery of an owned retained message, with a new message ID. May duplicate a prior delivery; never an automatic technical retry.', inputSchema: object({ message_id: uuid, ttl_seconds: { type: 'integer', minimum: 60, maximum: 604800 } }, ['message_id']) },
+  { name: 'broker_cancel', description: 'Stop further pending delivery of one owned message. Cannot undo inbox content; inspect uncertainty and cancel_result.', inputSchema: object({ message_id: uuid }, ['message_id']) },
   { name: 'broker_message_status', description: 'Read broker delivery state, never model progress or task completion.', inputSchema: object({ message_id: uuid }, ['message_id']) },
   { name: 'broker_receive', description: 'Cooperatively peek at the oldest durable AGENT inbox item during this tool call. No unsolicited wakeup or native-consumption receipt; the item remains pending.', inputSchema: object() },
 ]);

package/vendor/broker/reference/tools.mjs

@@ -1,15 +1,25 @@
+import { digest } from '../src/protocol.mjs';
 import { LocalError, safeError } from './errors.mjs';
 import { provenance } from './runtime.mjs';
 
 /** Native host tool facade, not an MCP transport or a generic TUI injection API. */
 export function createTools({ client, inbox = client?.inbox, observeMetadata = null, cooperativeBoundary = null }) {
   if (!client || !inbox) throw new LocalError('invalid_configuration');
+  const internalOperation=(kind,context)=>{
+    if(context?.operationId!==undefined){
+      if(typeof context.operationId!=='string'||!context.operationId||context.operationId.length>1024)throw new LocalError('invalid_configuration');
+      const operationId=digest({kind,operation_id:context.operationId}),existing=inbox.outgoingForOperation(operationId);
+      return {operationId,...(existing?{key:existing.key}:{}),...(context.operationStartedAt===undefined?{}:{operationStartedAt:context.operationStartedAt})};
+    }
+    return {};
+  };
+  const publicResult=value=>{const {send_key,...result}=value;return result;};
   return {
-    async broker_list_clients(arguments_ = {}) { return client.listClients(arguments_); },
-    async broker_send(arguments_) {
+    async broker_list_clients(arguments_ = {}, context = {}) { return client.listClients(arguments_,{signal:context.signal}); },
+    async broker_send(arguments_, context = {}) {
       if (!arguments_ || typeof arguments_ !== 'object' || Array.isArray(arguments_)
-        || Object.keys(arguments_).some(key => !['recipient_id', 'text', 'ttl_seconds', 'correlation_id', 'reply_to_message_id', 'send_key'].includes(key))) throw new LocalError('invalid_configuration');
-      let key = arguments_.send_key;
+        || Object.keys(arguments_).some(key => !['recipient_id', 'text', 'ttl_seconds', 'correlation_id', 'reply_to_message_id'].includes(key))) throw new LocalError('invalid_configuration');
+      const operation=internalOperation('send',context);let key=operation.key;
       try {
         const request = { recipient_id: arguments_.recipient_id, content: { type: 'text/plain', text: arguments_.text } };
         for (const field of ['ttl_seconds', 'correlation_id', 'reply_to_message_id']) if (Object.hasOwn(arguments_, field)) request[field] = arguments_[field];
@@ -21,21 +31,35 @@ export function createTools({ client, inbox = client?.inbox, observeMetadata = n
         } else if (!original && observeMetadata) {
           const observed = await observeMetadata();
           if (observed) {
-            await client.refreshOwnedMetadata();
+            await client.refreshOwnedMetadata({signal:context.signal});
             request.metadata_patch = observed; request.expected_metadata_revision = client.attachment.metadata_revision;
           }
         }
-        key = client.prepareSend(request, key ? { key } : {});
-        return await client.sendPrepared(key);
-      } catch (error) { return { ...safeError(error), send_key: key ?? null }; }
+        key = client.prepareSend(request,operation);
+        return publicResult(await client.sendPrepared(key,{signal:context.signal}));
+      } catch (error) { return safeError(error); }
     },
-    async broker_update_metadata(arguments_) {
+    async broker_update_metadata(arguments_, context = {}) {
       if (!arguments_ || Object.keys(arguments_).some(key => !['metadata_patch', 'expected_metadata_revision'].includes(key))) throw new LocalError('invalid_configuration');
-      return client.updateMetadata(arguments_.metadata_patch, { expectedRevision: arguments_.expected_metadata_revision });
+      return client.updateMetadata(arguments_.metadata_patch, { expectedRevision: arguments_.expected_metadata_revision, signal:context.signal });
+    },
+    async broker_sent_history(arguments_ = {}, context = {}) { return client.sentHistory(arguments_,{signal:context.signal}); },
+    async broker_resend(arguments_, context = {}) {
+      if(!arguments_||Object.keys(arguments_).some(key=>!['message_id','ttl_seconds'].includes(key)))throw new LocalError('invalid_configuration');
+      const operation=internalOperation('resend',context),{message_id,...input}=arguments_;
+      return publicResult(await client.resendPrepared(client.prepareResend(message_id,input,operation),{signal:context.signal}));
+    },
+    async broker_cancel(arguments_, context = {}) {
+      if(!arguments_||Object.keys(arguments_).join(',')!=='message_id')throw new LocalError('invalid_configuration');
+      return client.cancelMessage(arguments_.message_id,{signal:context.signal});
+    },
+    async broker_message_content(arguments_, context = {}) {
+      if(!arguments_||Object.keys(arguments_).join(',')!=='message_id') throw new LocalError('invalid_configuration');
+      return client.messageContent(arguments_.message_id,{signal:context.signal});
     },
-    async broker_message_status(arguments_) {
+    async broker_message_status(arguments_, context = {}) {
       if (!arguments_ || Object.keys(arguments_).join(',') !== 'message_id') throw new LocalError('invalid_configuration');
-      return client.messageStatus(arguments_.message_id);
+      return client.messageStatus(arguments_.message_id,{signal:context.signal});
     },
     async broker_receive(arguments_ = {}) {
       if (Object.keys(arguments_).length || typeof cooperativeBoundary !== 'function') throw new LocalError('unsafe_boundary');
@@ -52,8 +76,8 @@ export function createTools({ client, inbox = client?.inbox, observeMetadata = n
   };
 }
 
-export async function invokeTool(tools, name, arguments_) {
+export async function invokeTool(tools, name, arguments_, context = {}) {
   if (!Object.hasOwn(tools, name) || typeof tools[name] !== 'function') return new LocalError('unknown_tool').toJSON();
-  try { return await tools[name](arguments_); }
+  try { return await tools[name](arguments_,context); }
   catch (error) { return safeError(error); }
 }

package/vendor/broker/src/protocol.mjs

@@ -17,6 +17,9 @@ const ERROR_TEXT = Object.freeze({
   forbidden: ['This operation is not authorized.', 'Check the enrolled adapter permissions.'],
   recipient_not_found: ['The recipient is not available.', 'Select an exact authorized client ID from discovery.'],
   message_not_found: ['The message is not available.', 'Use a message ID owned by this principal.'],
+  retry_window_elapsed: ['The operation recovery record has expired.', 'Reconcile the existing receipt; only an explicit new send or resend may create another delivery.'],
+  history_changed: ['History changed while paging.', 'Restart the listing without a cursor; no continuation was silently skipped.'],
+  content_unavailable: ['The original content is no longer retained.', 'Use the receipt; unavailable content cannot be reconstructed.'],
   identity_conflict: ['The session identity conflicts with an existing registration.', 'Do not adopt another session; verify the local session identity.'],
   stale_lease_epoch: ['Reconnect this session before retrying.', 'Read owned registration state and reconnect; do not blindly replay a mutation.'],
   idempotency_conflict: ['This key was already used for a different request.', 'Reconcile the original request; do not change an uncertain request.'],
@@ -297,3 +300,19 @@ export function canonical(value) {
 export function digest(value) {
   return createHash('sha256').update(canonical(value), 'utf8').digest('hex');
 }
+
+export function validateResend(value, { limits = {} } = {}) {
+  object(value, ['ttl_seconds'], [], 'body');
+  const merged = { ...DEFAULTS, ...limits };
+  return { ttl_seconds: value.ttl_seconds === undefined ? merged.default_ttl_seconds : integer(value.ttl_seconds, Math.max(60, merged.min_ttl_seconds), Math.min(604800, merged.max_ttl_seconds), 'body.ttl_seconds') };
+}
+
+/** New internal keys carry a timestamp; legacy keys retain their bounded v1 guarantee. */
+export function validateOperationTime(key, now, retryWindowSeconds) {
+  if(!key.startsWith('op_'))return;
+  const match=/^op_([0-9]{13})_([A-Za-z0-9_-]{16,96})$/.exec(key);
+  if(!match)throw new ApiError(400,'invalid_request','headers.Idempotency-Key');
+  const started=Number(match[1]);
+  if(started>now+300000)throw new ApiError(400,'invalid_request','headers.Idempotency-Key');
+  if(now-started>=retryWindowSeconds*1000)throw new ApiError(410,'retry_window_elapsed','headers.Idempotency-Key');
+}

package/vendor/enrollment/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno Orsolon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/enrollment/ORIGIN.md

@@ -0,0 +1,20 @@
+# Shared enrollment helper
+
+Unmodified `reference/enrollment.mjs` from `matuto-ai/psst` commit `3e908e79966d886a02d372c103e31dec6e900c1a`, independently compared byte-for-byte with the remote committed source. Upstream PR #18 is pending review/merge; this commit pin is not a deployment or release claim.
+
+SHA-256: `afeab00d7c2d6768d3537bd7c350e249768897bf81eff9b4ae9796f7c3f9dbe9`.
+
+Runtime hash checked by `src/enrollment.mjs` before import. MIT license copied alongside. The existing pinned broker transport/runtime remains unchanged at its separate origin.
+
+Source: https://github.com/matuto-ai/psst/blob/3e908e79966d886a02d372c103e31dec6e900c1a/reference/enrollment.mjs
+Operator guide at that commit: https://github.com/matuto-ai/psst/blob/3e908e79966d886a02d372c103e31dec6e900c1a/docs/pairing-operator.md
+
+## URL-only approval helper
+
+`approval.mjs` is vendored byte-for-byte from `matuto-ai/psst` commit
+`72f5d2d1b834e02cfb6b2f7dc11c6f1a55729344`, path `reference/approval.mjs`,
+Git blob `8e6128c22835e66c0ab50aa15c27ff16d33e1169`, SHA-256
+`a60c3a0ccd7deb50556586cd67841bb89a300ea3c7f1af3a91d437f856b7a2d5`.
+This is the explicit broker PR #22 dependency, not a claim of a deployed release.
+The connector checks the digest before importing it. The old enrollment helper
+remains unchanged for legacy bundles/receipts.

package/vendor/enrollment/approval.mjs

@@ -0,0 +1,181 @@
+// Single-file helper deliberately vendorable by native connectors. Never emits secrets.
+import { randomBytes, randomUUID, createHash } from 'node:crypto';
+import { openSync, closeSync, fstatSync, readFileSync, writeFileSync, fsyncSync, renameSync, unlinkSync, mkdirSync, lstatSync, realpathSync, readdirSync, constants } from 'node:fs';
+import { resolve, dirname, join, isAbsolute } from 'node:path';
+import https from 'node:https';
+import { DatabaseSync } from 'node:sqlite';
+
+const TYPES = ['pi','claude-code','opencode','antigravity-cli'];
+const fail = (code, effect = 'not_applied', retryable=false, retryAfterMs=2000) => { const e = new Error(code); Object.assign(e,{code,effect,retryable,...(retryable?{retryAfterMs:Math.max(1000,Math.min(300000,Math.ceil(retryAfterMs)))}:{})}); throw e; };
+const hash = value => createHash('sha256').update(value).digest('hex');
+function privateDir(path) {
+  if (!isAbsolute(path)) fail('private_directory_required');
+  mkdirSync(path, {recursive:true, mode:0o700});
+  const s = lstatSync(path);
+  if (!s.isDirectory() || s.isSymbolicLink() || realpathSync(path) !== resolve(path) || (s.mode & 0o077) || (process.getuid && s.uid !== process.getuid())) fail('private_directory_required');
+}
+function privateRead(path) {
+  if (!isAbsolute(path) || realpathSync(dirname(path)) !== resolve(dirname(path))) fail('private_file_required');
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const s = fstatSync(fd);
+    if (!s.isFile() || s.size > 65536 || (s.mode & 0o077) || (process.getuid && s.uid !== process.getuid())) fail('private_file_required');
+    return readFileSync(fd,'utf8');
+  } finally { closeSync(fd); }
+}
+function save(path, text) {
+  // Reject unsafe existing destinations rather than silently repairing their mode.
+  try { privateRead(path); } catch(e) { if(e.code !== 'ENOENT') throw e; }
+  const temp = `${path}.${randomUUID()}.tmp`;
+  const fd = openSync(temp, constants.O_WRONLY|constants.O_CREAT|constants.O_EXCL|constants.O_NOFOLLOW,0o600);
+  try { writeFileSync(fd,text); fsyncSync(fd); } finally { closeSync(fd); }
+  renameSync(temp,path);
+  const d = openSync(dirname(path),constants.O_RDONLY);try { fsyncSync(d); } finally { closeSync(d); }
+}
+function origin(value) {
+  let u; try { u = new URL(value); } catch { fail('https_origin_required'); }
+  if (typeof value !== 'string' || /[\u0000-\u0020\u007f]/u.test(value) || u.protocol !== 'https:' || u.username || u.password || u.pathname !== '/' || u.search || u.hash) fail('https_origin_required');
+  return u.origin;
+}
+const stateNames=['pending','approved','denied','expired','revoked'];
+const uuid=/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function locations({brokerUrl,directory,clientType}) {
+  if(!TYPES.includes(clientType))fail('invalid_client_type');
+  if(!isAbsolute(directory))fail('private_directory_required');
+  const broker=origin(brokerUrl),root=join(directory,'approvals',hash(broker+'\0'+clientType));
+  return {broker,root,current:join(root,'current.json'),clientType};
+}
+function load(loc) {
+  let pointer;try{pointer=JSON.parse(privateRead(loc.current));}catch(e){if(e.code==='ENOENT')return null;throw e;}
+  if(!pointer||!uuid.test(pointer.requestId))fail('invalid_approval_state');
+  const dir=join(loc.root,pointer.requestId),state=JSON.parse(privateRead(join(dir,'attempt.json')));
+  if(state.requestId!==pointer.requestId||state.brokerUrl!==loc.broker||state.clientType!==loc.clientType
+    ||!/^[A-Za-z0-9_-]{43}$/.test(state.token)||!stateNames.includes(state.state)
+    ||typeof state.label!=='string'||state.label.length>80)fail('invalid_approval_state');
+  return {state,dir};
+}
+function visible({state,dir}) {
+  const result={requestId:state.requestId,approvalUrl:state.brokerUrl+'/admin',state:state.state,requestExpiresAt:state.requestExpiresAt??null};
+  if(state.state==='approved'){
+    if(!state.credential||Date.parse(state.credential.expires_at)<=Date.now())return {...result,state:'expired'};
+    result.connectionFile=join(dir,'connection.json');
+    Object.assign(result,readEnrollmentReceipt({connectionFile:result.connectionFile,clientType:state.clientType}));
+  }
+  return result;
+}
+function sanitized(e) {
+  if(e.effect&&/^[a-z_]+$/.test(e.code))throw e;
+  fail('approval_local_error','unknown');
+}
+export function readApprovalState(options) {
+  try{const item=load(locations(options));return item?visible(item):null;}catch(e){sanitized(e);}
+}
+function request(broker,method,path,token,input) {
+  return new Promise((resolvePromise,reject)=>{
+    const body=input===undefined?undefined:JSON.stringify(input);
+    const transportError=()=>Object.assign(new Error('approval_transport_error'),{code:'approval_transport_error',effect:'unknown',retryable:true,retryAfterMs:2000});
+    const req=https.request(new URL(path,broker),{method,headers:{Authorization:`Enrollment ${token}`,...(body?{'Content-Type':'application/json','Content-Length':Buffer.byteLength(body)}:{})}},res=>{
+      let size=0;const chunks=[];
+      res.on('data',chunk=>{size+=chunk.length;if(size>16384)res.destroy();else chunks.push(chunk);});
+      res.on('error',()=>reject(transportError()));
+      res.on('end',()=>{try{resolvePromise({status:res.statusCode,retryAfter:res.headers['retry-after'],body:JSON.parse(Buffer.concat(chunks).toString('utf8'))});}catch{reject(Object.assign(new Error('invalid_response'),{code:'invalid_response',effect:'unknown',retryable:false}));}});
+    });
+    const timer=setTimeout(()=>req.destroy(),10000);req.on('close',()=>clearTimeout(timer));
+    req.on('error',()=>reject(transportError()));req.end(body);
+  });
+}
+function publish(item,result,broker,clientType){
+  const {state,dir}=item;
+  if(!result||result.request_id!==state.requestId||!stateNames.includes(result.state)
+    ||!Number.isFinite(Date.parse(result.request_expires_at)))fail('invalid_response','unknown');
+  if(result.state==='approved'){
+    const c=result.credential;
+    if(!c||c.protocol_version!=='1'||c.client_type!==clientType||!/^enrolled-[0-9a-f-]{36}$/.test(c.credential_id)
+      ||!/^installation-[0-9a-f-]{36}$/.test(c.adapter_id)||!Array.isArray(c.scopes)||!c.scopes.length||c.scopes.length>32
+      ||c.scopes.some(s=>typeof s!=='string'||!/^[-a-zA-Z0-9_.]{1,128}$/.test(s))||!Number.isFinite(Date.parse(c.expires_at)))fail('invalid_response','unknown');
+    if(Date.parse(c.expires_at)<=Date.now())fail('credential_expired');
+    save(join(dir,'token'),state.token+'\n');
+    save(join(dir,'enrollment.json'),JSON.stringify({format:'psst-enrollment-receipt-v1',broker_url:broker,...c,token_sha256:hash(state.token)})+'\n');
+    save(join(dir,'connection.json'),JSON.stringify({format:'broker-client-bundle-v1',protocol_version:'1',broker_url:broker,token_file:'token',enrollment_receipt_file:'enrollment.json',file_paths_relative_to:'connection_file_directory',authorization_header:'Authorization',authorization_scheme:'Bearer',insecure_development:false,allowed_client_types:[clientType],scope:c.scopes[0]})+'\n');
+    state.credential=c;
+  }
+  state.state=result.state;state.requestExpiresAt=result.request_expires_at;
+  save(join(dir,'attempt.json'),JSON.stringify(state)+'\n');return visible(item);
+}
+async function operate(options,begin,{transport=request,pollIntervalMs=2000}={}) {
+  let lock;
+  try {
+    const loc=locations(options);
+    if(!begin&&!load(loc))fail('approval_setup_required');
+    privateDir(options.directory);privateDir(join(options.directory,'approvals'));privateDir(loc.root);
+    const lockPath=join(loc.root,'.owner.sqlite');
+    try{privateRead(lockPath);}catch(e){if(e.code!=='ENOENT')throw e;}
+    const fd=openSync(lockPath,constants.O_WRONLY|constants.O_CREAT|constants.O_NOFOLLOW,0o600);closeSync(fd);
+    try{lock=new DatabaseSync(lockPath);lock.exec('PRAGMA journal_mode=DELETE; PRAGMA locking_mode=EXCLUSIVE; BEGIN EXCLUSIVE; CREATE TABLE IF NOT EXISTS owner(id INTEGER);');}
+    catch{fail('approval_busy','not_applied',true);}
+    let item=load(loc);
+    if(begin){
+      const replacement=options.replaceRequestId;
+      if(replacement!==undefined&&(!uuid.test(replacement)||!item))fail('selection_conflict');
+      if(replacement!==undefined&&item.state.requestId!==replacement&&item.state.parentRequestId!==replacement)fail('selection_conflict');
+      if(replacement!==undefined&&item.state.requestId===replacement&&item.state.state==='pending')fail('selection_conflict');
+      if(!item||(replacement!==undefined&&item.state.requestId===replacement)){
+        if(readdirSync(loc.root).length>=130)fail('approval_capacity');
+        const label=options.label??options.clientType;
+        if(typeof label!=='string'||label.length>80||/[\u0000-\u001f\u007f]/u.test(label))fail('invalid_request');
+        const state={requestId:randomUUID(),parentRequestId:replacement??null,brokerUrl:loc.broker,clientType:options.clientType,label,token:randomBytes(32).toString('base64url'),state:'pending'};
+        const dir=join(loc.root,state.requestId);privateDir(dir);
+        save(join(dir,'attempt.json'),JSON.stringify(state)+'\n');
+        save(loc.current,JSON.stringify({requestId:state.requestId})+'\n');item={state,dir};
+      }
+    }
+    if(!item)fail('approval_setup_required');
+    if(item.state.state!=='pending')return visible(item);
+    const s=item.state;
+    if(Number.isFinite(s.retryAt)&&s.retryAt>Date.now()&&s.retryAt-Date.now()<=300000)fail(s.retryCode??'rate_limited',s.retryEffect??'unknown',true,s.retryAt-Date.now());
+    if(!begin){
+      const now=Date.now();
+      if(Number.isFinite(s.lastPollAt)&&now>=s.lastPollAt&&now-s.lastPollAt<pollIntervalMs)return visible(item);
+      s.lastPollAt=now;save(join(item.dir,'attempt.json'),JSON.stringify(s)+'\n');
+    }
+    const path=begin?'/v1/enrollment-requests':`/v1/enrollment-requests/${s.requestId}`;
+    const response=await transport(loc.broker,begin?'POST':'GET',path,s.token,begin?{request_id:s.requestId,client_type:s.clientType,label:s.label}:undefined);
+    if(![200,201].includes(response.status)){
+      const code=response.body?.error?.code;
+      let retryAfterMs=response.status===429?60000:5000;
+      if(typeof response.retryAfter==='string'){
+        const seconds=/^[0-9]{1,6}$/.test(response.retryAfter)?Number(response.retryAfter):NaN;
+        const parsed=Number.isFinite(seconds)?seconds*1000:Date.parse(response.retryAfter)-Date.now();
+        if(Number.isFinite(parsed))retryAfterMs=Math.max(1000,Math.min(300000,Math.ceil(parsed)));
+      }
+      if([429,503].includes(response.status)){s.retryAt=Date.now()+retryAfterMs;s.retryCode=code==='not_ready'||code==='storage_unavailable'?code:'rate_limited';s.retryEffect=response.body?.error?.effect==='not_applied'?'not_applied':'unknown';save(join(item.dir,'attempt.json'),JSON.stringify(s)+'\n');}
+      fail(['unauthenticated','forbidden','invalid_request','idempotency_conflict','rate_limited','not_ready','storage_unavailable'].includes(code)?code:'invalid_response',response.body?.error?.effect==='not_applied'?'not_applied':'unknown',[429,503].includes(response.status),retryAfterMs);
+    }
+    delete s.retryAt;delete s.retryCode;delete s.retryEffect;
+    return publish(item,response.body,loc.broker,options.clientType);
+  }catch(e){sanitized(e);}finally{try{lock?.close();}catch{}}
+}
+export const beginApproval=(options,testOptions)=>operate(options,true,testOptions);
+export const pollApproval=(options,testOptions)=>operate(options,false,testOptions);
+
+/** Read only for a helper-enrolled bundle. Missing/corrupt receipt is not a legacy fallback. */
+export function readEnrollmentReceipt({connectionFile,clientType}) {
+  try {
+    if(!TYPES.includes(clientType))fail('invalid_client_type');
+    const bundle=JSON.parse(privateRead(connectionFile));
+    const receipt=JSON.parse(privateRead(join(dirname(connectionFile),'enrollment.json')));
+    const token=privateRead(join(dirname(connectionFile),'token')).trim();
+    if(bundle?.format!=='broker-client-bundle-v1'||bundle.protocol_version!=='1'||bundle.token_file!=='token'||bundle.enrollment_receipt_file!=='enrollment.json'
+      ||bundle.authorization_scheme!=='Bearer'||bundle.authorization_header!=='Authorization'||bundle.insecure_development!==false
+      ||!Array.isArray(bundle.allowed_client_types)||bundle.allowed_client_types.length!==1||bundle.allowed_client_types[0]!==clientType
+      ||receipt?.format!=='psst-enrollment-receipt-v1'||receipt.protocol_version!=='1'||receipt.client_type!==clientType
+      ||receipt.broker_url!==origin(bundle.broker_url)||!/^[A-Za-z0-9_-]{43}$/.test(token)||receipt.token_sha256!==hash(token)
+      ||!/^enrolled-[0-9a-f-]{36}$/.test(receipt.credential_id)||!/^installation-[0-9a-f-]{36}$/.test(receipt.adapter_id)
+      ||!Array.isArray(receipt.scopes)||!receipt.scopes.length||receipt.scopes[0]!==bundle.scope||!Number.isFinite(Date.parse(receipt.expires_at)))fail('invalid_enrollment_receipt');
+    if(Date.parse(receipt.expires_at)<=Date.now())fail('credential_expired');
+    return {credentialId:receipt.credential_id,expiresAt:receipt.expires_at};
+  } catch(e) {
+    if(e.effect&&/^[a-z_]+$/.test(e.code))throw e;
+    fail('invalid_enrollment_receipt');
+  }
+}

package/vendor/enrollment/enrollment.mjs

@@ -0,0 +1,137 @@
+// Single-file helper deliberately vendorable by native connectors. Never emits secrets.
+import { randomBytes, randomUUID, createHash } from 'node:crypto';
+import { openSync, closeSync, fstatSync, readFileSync, writeFileSync, fsyncSync, renameSync, unlinkSync, mkdirSync, lstatSync, realpathSync, readdirSync, constants } from 'node:fs';
+import { resolve, dirname, join, isAbsolute } from 'node:path';
+import https from 'node:https';
+import { DatabaseSync } from 'node:sqlite';
+
+const TYPES = ['pi','claude-code','opencode','antigravity-cli'];
+const fail = (code, effect = 'not_applied') => { const e = new Error(code); e.code = code; e.effect = effect; throw e; };
+const hash = value => createHash('sha256').update(value).digest('hex');
+function privateDir(path) {
+  if (!isAbsolute(path)) fail('private_directory_required');
+  mkdirSync(path, {recursive:true, mode:0o700});
+  const s = lstatSync(path);
+  if (!s.isDirectory() || s.isSymbolicLink() || realpathSync(path) !== resolve(path) || (s.mode & 0o077) || (process.getuid && s.uid !== process.getuid())) fail('private_directory_required');
+}
+function privateRead(path) {
+  if (!isAbsolute(path) || realpathSync(dirname(path)) !== resolve(dirname(path))) fail('private_file_required');
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const s = fstatSync(fd);
+    if (!s.isFile() || s.size > 65536 || (s.mode & 0o077) || (process.getuid && s.uid !== process.getuid())) fail('private_file_required');
+    return readFileSync(fd,'utf8');
+  } finally { closeSync(fd); }
+}
+function save(path, text) {
+  // Reject unsafe existing destinations rather than silently repairing their mode.
+  try { privateRead(path); } catch(e) { if(e.code !== 'ENOENT') throw e; }
+  const temp = `${path}.${randomUUID()}.tmp`;
+  const fd = openSync(temp, constants.O_WRONLY|constants.O_CREAT|constants.O_EXCL|constants.O_NOFOLLOW,0o600);
+  try { writeFileSync(fd,text); fsyncSync(fd); } finally { closeSync(fd); }
+  renameSync(temp,path);
+  const d = openSync(dirname(path),constants.O_RDONLY);try { fsyncSync(d); } finally { closeSync(d); }
+}
+function origin(value) {
+  let u; try { u = new URL(value); } catch { fail('https_origin_required'); }
+  if (typeof value !== 'string' || /[\u0000-\u0020\u007f]/u.test(value) || u.protocol !== 'https:' || u.username || u.password || u.pathname !== '/' || u.search || u.hash) fail('https_origin_required');
+  return u.origin;
+}
+function post(url, secret, body) {
+  return new Promise((resolvePromise,reject) => {
+    const request = https.request(new URL('/v1/enrollments',url), {method:'POST',headers:{Authorization:`Pairing ${secret}`,'Content-Type':'application/json','Content-Length':Buffer.byteLength(body)}, timeout:10000}, response => {
+      let size=0;const chunks=[];
+      response.on('data',chunk=>{size+=chunk.length;if(size>16384)response.destroy(new Error('invalid_response'));else chunks.push(chunk);});
+      response.on('error',()=>reject(Object.assign(new Error('enrollment_transport_error'),{code:'enrollment_transport_error',effect:'unknown'})));
+      response.on('end',()=>{
+        try { resolvePromise({status:response.statusCode,body:JSON.parse(Buffer.concat(chunks).toString('utf8'))}); }
+        catch { reject(Object.assign(new Error('invalid_response'),{code:'invalid_response',effect:'unknown'})); }
+      });
+    });
+    const deadline=setTimeout(()=>request.destroy(),10000);
+    request.on('close',()=>clearTimeout(deadline));
+    request.on('timeout',()=>request.destroy());
+    request.on('error',()=>reject(Object.assign(new Error('enrollment_transport_error'),{code:'enrollment_transport_error',effect:'unknown'})));
+    request.end(body);
+  });
+}
+/** Explicit connect only. The optional transport is a test seam, never a user configuration field. */
+export async function connectPairingFile({pairingFile,directory,clientType,brokerUrl}, {transport = post} = {}) {
+  let lock, lockPath;
+  try {
+    if (!TYPES.includes(clientType)) fail('invalid_client_type');
+    const pair = JSON.parse(privateRead(pairingFile));
+    if (!pair || pair.format !== 'psst-pairing-v1' || pair.client_type !== clientType || typeof pair.pairing_secret !== 'string'
+      || !/^[A-Za-z0-9_-]{43}$/.test(pair.pairing_secret) || !Number.isFinite(Date.parse(pair.expires_at))) fail('invalid_pairing_file');
+    const broker = origin(pair.broker_url);
+    if (brokerUrl !== undefined && origin(brokerUrl) !== broker) fail('broker_origin_mismatch');
+    privateDir(directory);
+    lockPath = join(directory,'.enrollment-owner.sqlite');
+    // Kernel-held SQLite lock survives no process crash; no stale PID or lock deletion.
+    try { privateRead(lockPath); } catch(e) { if(e.code!=='ENOENT')throw e; }
+    const ownerFd=openSync(lockPath,constants.O_WRONLY|constants.O_CREAT|constants.O_NOFOLLOW,0o600);closeSync(ownerFd);
+    try {
+      lock = new DatabaseSync(lockPath);
+      lock.exec('PRAGMA journal_mode=DELETE; PRAGMA locking_mode=EXCLUSIVE; BEGIN EXCLUSIVE; CREATE TABLE IF NOT EXISTS owner (id INTEGER);');
+    } catch { try{lock?.close();}catch{}lock=undefined;fail('enrollment_busy'); }
+    // Per-grant attempts preserve old credentials for uncertain recovery and explicit replacement.
+    const attempts = join(directory,'enrollments');privateDir(attempts);
+    const key = hash(pair.pairing_secret), attemptDir = join(attempts,key);
+    if (!readdirSync(attempts).includes(key) && readdirSync(attempts).length >= 64) fail('enrollment_capacity');
+    privateDir(attemptDir);
+    const stateFile = join(attemptDir,'attempt.json');
+    let state;
+    try { state = JSON.parse(privateRead(stateFile)); }
+    catch(e) {
+      if(e.code !== 'ENOENT')throw e;
+      state = {broker_url:broker,client_type:clientType,enrollment_id:randomUUID(),token:randomBytes(32).toString('base64url')};
+      save(stateFile,JSON.stringify(state)+'\n'); // fsync before any issuance can happen
+    }
+    if (state.broker_url !== broker || state.client_type !== clientType || !/^[A-Za-z0-9_-]{43}$/.test(state.token)
+      || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(state.enrollment_id)) fail('invalid_enrollment_state');
+    const response = await transport(broker,pair.pairing_secret,JSON.stringify({enrollment_id:state.enrollment_id,client_type:clientType,token_sha256:hash(state.token)}));
+    if (![200,201].includes(response.status)) {
+      const code = response.body?.error?.code;
+      fail(['unauthenticated','forbidden','invalid_request','idempotency_conflict','rate_limited','not_ready','storage_unavailable'].includes(code)?code:'invalid_response',response.body?.error?.effect==='not_applied'?'not_applied':'unknown');
+    }
+    const result = response.body;
+    if (!result || result.protocol_version !== '1' || result.client_type !== clientType || !/^enrolled-[0-9a-f-]{36}$/.test(result.credential_id)
+      || !/^installation-[0-9a-f-]{36}$/.test(result.adapter_id) || !Array.isArray(result.scopes) || !result.scopes.length || result.scopes.length>32
+      || result.scopes.some(s=>typeof s!=='string'||!/^[-a-zA-Z0-9_.]{1,128}$/.test(s)) || !Number.isFinite(Date.parse(result.expires_at))) fail('invalid_response','unknown');
+    if(Date.parse(result.expires_at)<=Date.now())fail('credential_expired','unknown');
+    save(join(attemptDir,'token'),state.token+'\n');
+    const bundle = {format:'broker-client-bundle-v1',protocol_version:'1',broker_url:broker,token_file:'token',enrollment_receipt_file:'enrollment.json',file_paths_relative_to:'connection_file_directory',authorization_header:'Authorization',authorization_scheme:'Bearer',insecure_development:false,allowed_client_types:[clientType],scope:result.scopes[0]};
+    const connectionFile = join(attemptDir,'connection.json');
+    // Publish receipt before bundle: the returned bundle always has its token-bound receipt.
+    save(join(attemptDir,'enrollment.json'),JSON.stringify({format:'psst-enrollment-receipt-v1',broker_url:broker,...result,token_sha256:hash(state.token)})+'\n');
+    save(connectionFile,JSON.stringify(bundle,null,2)+'\n');
+    return {connectionFile,credentialId:result.credential_id,expiresAt:result.expires_at};
+  } catch(e) {
+    if (e.effect && /^[a-z_]+$/.test(e.code)) throw e;
+    fail('enrollment_local_error','unknown');
+  } finally {
+    if (lock !== undefined) { try { lock.close(); } catch { /* Never replace a sanitized result with raw filesystem details. */ } }
+  }
+}
+
+/** Read only for a helper-enrolled bundle. Missing/corrupt receipt is not a legacy fallback. */
+export function readEnrollmentReceipt({connectionFile,clientType}) {
+  try {
+    if(!TYPES.includes(clientType))fail('invalid_client_type');
+    const bundle=JSON.parse(privateRead(connectionFile));
+    const receipt=JSON.parse(privateRead(join(dirname(connectionFile),'enrollment.json')));
+    const token=privateRead(join(dirname(connectionFile),'token')).trim();
+    if(bundle?.format!=='broker-client-bundle-v1'||bundle.protocol_version!=='1'||bundle.token_file!=='token'||bundle.enrollment_receipt_file!=='enrollment.json'
+      ||bundle.authorization_scheme!=='Bearer'||bundle.authorization_header!=='Authorization'||bundle.insecure_development!==false
+      ||!Array.isArray(bundle.allowed_client_types)||bundle.allowed_client_types.length!==1||bundle.allowed_client_types[0]!==clientType
+      ||receipt?.format!=='psst-enrollment-receipt-v1'||receipt.protocol_version!=='1'||receipt.client_type!==clientType
+      ||receipt.broker_url!==origin(bundle.broker_url)||!/^[A-Za-z0-9_-]{43}$/.test(token)||receipt.token_sha256!==hash(token)
+      ||!/^enrolled-[0-9a-f-]{36}$/.test(receipt.credential_id)||!/^installation-[0-9a-f-]{36}$/.test(receipt.adapter_id)
+      ||!Array.isArray(receipt.scopes)||!receipt.scopes.length||receipt.scopes[0]!==bundle.scope||!Number.isFinite(Date.parse(receipt.expires_at)))fail('invalid_enrollment_receipt');
+    if(Date.parse(receipt.expires_at)<=Date.now())fail('credential_expired');
+    return {credentialId:receipt.credential_id,expiresAt:receipt.expires_at};
+  } catch(e) {
+    if(e.effect&&/^[a-z_]+$/.test(e.code))throw e;
+    fail('invalid_enrollment_receipt');
+  }
+}