@agentunion/fastaun 0.5.26 → 0.5.28

package/dist/agent-md.js

@@ -193,10 +193,26 @@ function requestText(url, opts) {
     });
 }
 export class AgentMdManager {
+    static _commitListeners = new Map();
+    static _commitRoot(aunPath) {
+        const root = path.resolve(aunPath, 'AIDs');
+        return process.platform === 'win32' ? root.toLowerCase() : root;
+    }
+    static subscribeCommits(aunPath, callback) {
+        const root = this._commitRoot(aunPath), listeners = this._commitListeners.get(root) ?? new Set();
+        listeners.add(callback);
+        this._commitListeners.set(root, listeners);
+        return () => {
+            listeners.delete(callback);
+            if (!listeners.size && this._commitListeners.get(root) === listeners)
+                this._commitListeners.delete(root);
+        };
+    }
     _aunPath;
     _verifySsl;
     _log;
     _onChanged;
+    _onCommitted;
     _discoveryPort;
     _uploadViaGatewayHost;
     _ownerAidGetter;
@@ -214,11 +230,24 @@ export class AgentMdManager {
     _autoDownloadRetry = new Map();
     _downloadActive = 0;
     _downloadWaiters = [];
+    _httpHandler = null;
+    setHttpHandler(handler) { this._httpHandler = handler; }
+    async _requestText(url, opts) {
+        if (!this._httpHandler)
+            return requestText(url, opts);
+        const perform = async () => {
+            const result = await requestText(url, opts);
+            return new Response(opts.method === 'HEAD' || [204, 205, 304].includes(result.status) ? null : result.text, { status: result.status, headers: result.headers });
+        };
+        const response = await this._httpHandler(url, { method: opts.method, headers: opts.headers, body: opts.body }, perform);
+        return { status: response.status, headers: Object.fromEntries(response.headers), text: await response.text() };
+    }
     constructor(opts) {
         this._aunPath = String(opts.aunPath ?? '');
         this._verifySsl = opts.verifySsl ?? true;
         this._log = opts.logger ?? noopLogger;
         this._onChanged = opts.onChanged;
+        this._onCommitted = opts.onCommitted;
         this._discoveryPort = opts.discoveryPort ?? null;
         this._uploadViaGatewayHost = opts.uploadViaGatewayHost ?? false;
         this._ownerAidGetter = opts.ownerAidGetter;
@@ -307,16 +336,41 @@ export class AgentMdManager {
     loadRecord(aid) {
         return this._loadRecord(aid);
     }
+    listRecordedAids() {
+        return fs.readdirSync(this.root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && fs.existsSync(path.join(this.root, entry.name, 'agentmd.json'))).map((entry) => this.safeAid(entry.name));
+    }
+    updateRecord(aid, change) {
+        const target = this.safeAid(aid);
+        this._withRecordLock(target, () => {
+            const record = this._readRecordUnlocked(target, true);
+            change(record);
+            record.updated_at = Date.now();
+            this._writeRecordUnlocked(target, record);
+        });
+        this._cache.delete(target);
+    }
+    setOnCommitted(callback) { this._onCommitted = callback; }
     _saveRecord(aid, fields, strict = false, observation) {
         const target = String(aid ?? '').trim();
         if (!target)
             return {};
+        let completedNotice = false;
         try {
             const inputFields = { ...fields };
             const hasContent = Object.prototype.hasOwnProperty.call(inputFields, 'content') && inputFields.content !== undefined && inputFields.content !== null;
             let savedTo = '';
             const record = this._withRecordLock(target, () => {
                 const next = { ...this._readRecordUnlocked(target, true), aid: target };
+                if (inputFields.pending_operation === '' && next.pending_operation === 'replace' && isJsonObject(next.pending_agent_md_notice)
+                    && typeof fields.content === 'string' && fields.content === next.pending_content) {
+                    const notice = { ...next.pending_agent_md_notice, etag: String(inputFields.remote_etag ?? '') || AgentMdManager.contentEtag(fields.content) };
+                    const outbox = Array.isArray(next.agent_md_change_outbox) ? [...next.agent_md_change_outbox] : [];
+                    if (notice.owner_aid && notice.sender_aid && !outbox.some((item) => item.message_id === notice.message_id))
+                        outbox.push(notice);
+                    inputFields.agent_md_change_outbox = outbox;
+                    inputFields.pending_agent_md_notice = {};
+                    completedNotice = true;
+                }
                 if (observation && (this.root !== observation.root || String(next.remote_etag ?? '') !== observation.etag || Number(next.observation_version ?? 0) !== observation.version))
                     throw ownershipFailure('unavailable', 'agent.md observation changed during download', true);
                 if (hasContent) {
@@ -348,6 +402,17 @@ export class AgentMdManager {
                     loaded.content = current.content;
             }
             this._cache.set(target, { ...loaded });
+            if (completedNotice) {
+                const listeners = new Set(AgentMdManager._commitListeners.get(AgentMdManager._commitRoot(this._aunPath)));
+                if (this._onCommitted)
+                    listeners.add(this._onCommitted);
+                for (const callback of listeners) {
+                    try {
+                        callback(target);
+                    }
+                    catch { }
+                }
+            }
             return { ...loaded };
         }
         catch (err) {
@@ -399,7 +464,7 @@ export class AgentMdManager {
         const rawContent = content === undefined || content === null ? String(this._loadRecord(target, true)?.local_draft_content ?? '') || this.readContent(target) : String(content);
         if (!rawContent.trim())
             throw new ValidationError('uploadAgentMd requires non-empty content');
-        const parsed = validateAgentMdDocument(rawContent, { expectedAid: target, validateOwnership: false });
+        const parsed = validateAgentMdDocument(rawContent, { expectedAid: target, validateOwnership: false, forUpload: true });
         if (['group', 'org'].includes(String(parsed.frontmatter.type)))
             return await this.uploadAs(target, rawContent, current);
         if (parseAgentMdTailSignature(rawContent).signatures.length > 1) {
@@ -417,7 +482,7 @@ export class AgentMdManager {
     }
     async readAgentMdFresh(aid) {
         const target = this.safeAid(aid), gateway = await this._resolveGateway(target);
-        const response = await requestText(this._url(target, gateway, this._uploadViaGatewayHost), {
+        const response = await this._requestText(this._url(target, gateway, this._uploadViaGatewayHost), {
             method: 'GET', verifySsl: this._verifySsl,
             headers: { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown', 'Cache-Control': 'no-cache', ...(this._uploadViaGatewayHost ? { Host: target } : {}) },
             timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true,
@@ -520,7 +585,7 @@ export class AgentMdManager {
         if (viaGateway)
             headers.Host = target;
         const request = (url) => { if (method === 'PUT')
-            assertActive?.(); return requestText(url, { method, verifySsl: this._verifySsl, headers, body: raw, timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true }); };
+            assertActive?.(); return this._requestText(url, { method, verifySsl: this._verifySsl, headers, body: raw, timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true }); };
         const primary = this._url(target, gatewayUrl, viaGateway);
         let response = await request(primary);
         if (response.status === 404 && !headerValue(response.headers, 'X-AUN-Ownership-Protocol') && headerValue(response.headers, 'X-AUN-Ownership-Status') !== 'not_applicable') {
@@ -537,7 +602,7 @@ export class AgentMdManager {
         const rawContent = String(content ?? '');
         if (!rawContent.trim())
             throw new ValidationError('uploadAgentMd requires non-empty content');
-        const parsed = validateAgentMdDocument(rawContent, { expectedAid: target, validateOwnership: false });
+        const parsed = validateAgentMdDocument(rawContent, { expectedAid: target, validateOwnership: false, forUpload: true });
         if (['group', 'org'].includes(String(parsed.frontmatter.type)) && parsed.signature) {
             const identity = await this._entitySigningIdentity(target, parsed.frontmatter, parsed.signature, signer);
             await this._verifyDocument(rawContent, target, identity, true);
@@ -580,7 +645,7 @@ export class AgentMdManager {
         const condition = pending.condition;
         if (!condition || Object.keys(condition).length !== 1 || !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*'))
             throw ownershipFailure('persistence_unavailable', 'pending agent.md requires its original document condition');
-        const parsed = validateAgentMdDocument(pending.content, { expectedAid: aid, validateOwnership: false });
+        const parsed = validateAgentMdDocument(pending.content, { expectedAid: aid, validateOwnership: false, forUpload: true });
         const meta = parsed.frontmatter;
         try {
             if (pending.relation?.legacy === true)
@@ -669,7 +734,7 @@ export class AgentMdManager {
         }
     }
     async _uploadPrepared(target, signedContent, signer, originalCondition) {
-        const meta = validateAgentMdDocument(signedContent, { expectedAid: target, validateOwnership: false }).frontmatter;
+        const meta = validateAgentMdDocument(signedContent, { expectedAid: target, validateOwnership: false, forUpload: true }).frontmatter;
         const entity = ['group', 'org'].includes(String(meta.type));
         const legacy = legacyRelationship(meta);
         const draftStrict = !originalCondition || !this._pendingUpload(target, true);
@@ -698,7 +763,13 @@ export class AgentMdManager {
         }
         const uploader = this._currentAid();
         const entityAuthorization = '';
-        const pending = this._saveRecord(target, { pending_operation: 'replace', pending_target_aid: target, pending_content: signedContent, pending_content_etag: AgentMdManager.contentEtag(signedContent), pending_error: '', pending_condition: condition, pending_relation: relation, pending_authorization: entityAuthorization }, draftStrict);
+        const existing = this._loadRecord(target, true);
+        const ownership = isJsonObject(meta.ownership) ? meta.ownership : {};
+        const statement = isJsonObject(ownership.statement) ? ownership.statement : {};
+        const noticeOwner = String(statement.owner_aid ?? ownership.owner_aid ?? meta.owner ?? '').trim();
+        const previousNotice = existing?.pending_content === signedContent && isJsonObject(existing.pending_agent_md_notice) ? existing.pending_agent_md_notice : null;
+        const notice = previousNotice ?? { sender_aid: uploader?.aid ?? this._ownerAid(), owner_aid: noticeOwner, aid: target, document_type: String(meta.type ?? 'agent'), message_id: crypto.randomUUID() };
+        const pending = this._saveRecord(target, { pending_operation: 'replace', pending_target_aid: target, pending_content: signedContent, pending_content_etag: AgentMdManager.contentEtag(signedContent), pending_error: '', pending_condition: condition, pending_relation: relation, pending_authorization: entityAuthorization, pending_agent_md_notice: notice }, draftStrict);
         const savedCondition = pending.pending_condition;
         if (pending.pending_content !== signedContent || savedCondition?.if_match !== condition.if_match || savedCondition?.if_none_match !== condition.if_none_match || pending.pending_authorization !== entityAuthorization || legacy && !isDeepStrictEqual(pending.pending_relation, relation))
             throw new StateError('agent.md pending upload persistence failed');
@@ -754,7 +825,7 @@ export class AgentMdManager {
         else
             verifyAgentMdBodyUpdate(pending.content, identity.certPem, target);
         const base = await this._verifyLegacyBodyContent(target, relation.base_content);
-        const candidate = validateAgentMdDocument(pending.content, { expectedAid: target, validateOwnership: false });
+        const candidate = validateAgentMdDocument(pending.content, { expectedAid: target, validateOwnership: false, forUpload: true });
         if (!isDeepStrictEqual(legacyRelationship(base.frontmatter), relation.fields) || !isDeepStrictEqual(relationshipFields(candidate.frontmatter), relation.fields))
             throw ownershipFailure('persistence_unavailable', 'pending legacy relationship material changed');
         const remote = await this._readLegacyBodyBase(target);
@@ -775,10 +846,13 @@ export class AgentMdManager {
     async _readEntityFresh(target) {
         const gateway = await this._resolveGateway(target);
         const headers = { 'X-AUN-Ownership-Check': '1', 'X-AUN-Signature-Format': 'multi-v1', 'Cache-Control': 'no-cache', ...(this._uploadViaGatewayHost ? { Host: target } : {}) };
-        const request = (url) => requestText(url, { method: 'GET', verifySsl: this._verifySsl, headers, timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true });
+        const request = (url) => this._requestText(url, { method: 'GET', verifySsl: this._verifySsl, headers, timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true });
         const response = await request(this._url(target, gateway, this._uploadViaGatewayHost));
         if (response.status !== 200 && response.status !== 404)
             throw ownershipFailure('unavailable', `entity agent.md fresh read failed: HTTP ${response.status}`, true);
+        if (response.status === 404 && ['X-AUN-Ownership-Status', 'X-AUN-Entity-Verification-Status', 'X-AUN-Entity-Owner-AID', 'X-AUN-Entity-Cert-Fingerprint'].every((field) => !headerValue(response.headers, field))) {
+            return { exists: false, content: '', etag: '', owner_aid: '', entity_cert_fingerprint: '', initial_missing: true };
+        }
         if (headerValue(response.headers, 'X-AUN-Ownership-Status') !== 'not_applicable' || !['current', 'stale'].includes(headerValue(response.headers, 'X-AUN-Entity-Verification-Status')))
             throw ownershipFailure('unavailable', 'entity authority status metadata is unavailable', true);
         const etag = headerValue(response.headers, 'ETag');
@@ -788,6 +862,8 @@ export class AgentMdManager {
     }
     async readEntityAuthorityFresh(target) {
         const observed = await this._readEntityFresh(this.safeAid(target));
+        if (observed.initial_missing)
+            throw new StateError('entity owner authority metadata is unavailable', { stringCode: 'unavailable', retryable: true, data: { http_status: 404 } });
         try {
             ownershipAid(observed.owner_aid, 'owner_aid');
         }
@@ -827,7 +903,7 @@ export class AgentMdManager {
     async _verifyDocument(content, target, identity, current = false, bodyUpdate = false) {
         const certificates = new Map();
         const parsed = parseAgentMdTailSignature(content, !current);
-        const meta = validateAgentMdReadDocument(content, { expectedAid: target }).frontmatter;
+        const meta = current ? validateAgentMdDocument(content, { expectedAid: target, forUpload: true }).frontmatter : validateAgentMdReadDocument(content, { expectedAid: target }).frontmatter;
         const historicalEntityOwner = !current && ['group', 'org'].includes(String(meta.type)) && parsed.signatures.length === 1 && parsed.fields?.signer_aid !== undefined && parsed.fields.signer_aid === meta.owner && parsed.fields.signer_aid !== meta.aid;
         const readCompatibility = !current && (!['group', 'org'].includes(String(meta.type)) || meta.type === 'group' && !Object.hasOwn(meta, 'entity_cert_fingerprint') && parsed.signatures.length === 1 && (parsed.fields?.signer_aid === undefined || parsed.fields.signer_aid === meta.aid));
         for (const item of parsed.signatures.slice(1)) {
@@ -897,7 +973,7 @@ export class AgentMdManager {
             throw ownershipFailure('persistence_unavailable', 'agent.md upload requires its original document condition');
         const gatewayUrl = await this._resolveGateway(target);
         const authorization = String(ownerAuthorization ?? '').trim();
-        const meta = validateAgentMdDocument(signedContent, { expectedAid: target, validateOwnership: false }).frontmatter;
+        const meta = validateAgentMdDocument(signedContent, { expectedAid: target, validateOwnership: false, forUpload: true }).frontmatter;
         const entity = ['group', 'org'].includes(String(meta.type));
         const uploadHeaders = {
             'X-AUN-Signature-Format': 'multi-v1',
@@ -910,7 +986,7 @@ export class AgentMdManager {
             const token = await this._uploadAccessToken(entity ? this._ownerAid() : target, gatewayUrl);
             uploadHeaders.Authorization = `Bearer ${token}`;
         }
-        const uploadRequest = (url) => requestText(url, {
+        const uploadRequest = (url) => this._requestText(url, {
             method: 'PUT',
             verifySsl: this._verifySsl,
             headers: uploadHeaders,
@@ -1199,7 +1275,7 @@ export class AgentMdManager {
     async _head(aid) {
         const target = this.safeAid(aid);
         const gatewayUrl = await this._resolveGateway(target);
-        const response = await requestText(this._url(target, gatewayUrl), {
+        const response = await this._requestText(this._url(target, gatewayUrl), {
             method: 'HEAD',
             verifySsl: this._verifySsl,
             headers: { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown' },
@@ -1243,7 +1319,7 @@ export class AgentMdManager {
         const headers = { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown' };
         const etag = String(cached.remote_etag ?? cached.etag ?? cached.local_etag ?? '').trim();
         const lastModified = String(cached.last_modified ?? '').trim();
-        let response = await requestText(this._url(target, gatewayUrl), {
+        let response = await this._requestText(this._url(target, gatewayUrl), {
             method: 'GET',
             verifySsl: this._verifySsl,
             headers,
@@ -1265,7 +1341,7 @@ export class AgentMdManager {
             };
         }
         else if (response.status === 304) {
-            response = await requestText(this._url(target, gatewayUrl), {
+            response = await this._requestText(this._url(target, gatewayUrl), {
                 method: 'GET',
                 verifySsl: this._verifySsl,
                 headers: { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown' },