@agentunion/fastaun 0.5.27 → 0.5.29

package/dist/aid-store.js

@@ -9,6 +9,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { AID } from './aid.js';
+import { RiskController } from './risk-control.js';
 import * as codes from './error-codes.js';
 import { certCommonName, certMatchesFingerprint, certTimeError, parseAgentMdTailSignature, publicKeyMatchesFingerprint, signBytes, signDocument, verifyDocument, verifySignatureWithCert } from './cert-utils.js';
 import { certFingerprint as _certFingerprint } from './cert-utils.js';
@@ -20,11 +21,12 @@ import { GatewayDiscovery } from './discovery.js';
 import { DnsResilientNet } from './net.js';
 import { AUNLogger } from './logger.js';
 import { getDeviceId, normalizeSlotId } from './config.js';
-import { AUNError, ClientSignatureError, IdentityConflictError, NotFoundError, ValidationError } from './errors.js';
+import { AUNError, ClientSignatureError, IdentityConflictError, NotFoundError, StateError, ValidationError } from './errors.js';
 import { AgentMdManager, buildDefaultAgentMd } from './agent-md.js';
 import { parseFileFrontmatter, validateAgentMdCertificate, validateAgentMdDocument, validateAgentMdReadDocument } from './agent-md-schema.js';
 import { LocalTokenStore } from './keystore/local-token-store.js';
 import { AuthFlow } from './auth.js';
+import { isJsonObject } from './types.js';
 import { ownershipFailure } from './ownership-v21.js';
 import { validateAIDFormat } from './validators.js';
 function resultError(r) {
@@ -98,6 +100,66 @@ export class AIDStore {
     _agentMdManager;
     _ownershipInflight = new WeakMap();
     _peerAuth;
+    _riskControllers = new Map();
+    _liveRiskControllers = new Map();
+    _riskLoads = new Map();
+    _riskPersistedStates = new Map();
+    _ownedRiskControllers = new Set();
+    setRiskController(aid, controller) { this._liveRiskControllers.set(aid, controller); }
+    async _riskForAid(aid) {
+        const live = await this._liveRiskControllers.get(aid)?.();
+        if (live)
+            return live;
+        const existing = this._riskControllers.get(aid);
+        const stored = this._tokenStore._loadMetadataStrict(aid)?.[`risk_state_v1:${this.deviceId}`];
+        const raw = stored ? (typeof stored === 'string' ? stored : JSON.stringify(stored)) : '';
+        if (existing && this._riskPersistedStates.get(aid) === raw)
+            return existing;
+        const loading = this._riskLoads.get(aid);
+        if (loading)
+            return await loading;
+        const task = this._loadRiskForAid(aid, raw);
+        this._riskLoads.set(aid, task);
+        try {
+            return await task;
+        }
+        finally {
+            if (this._riskLoads.get(aid) === task)
+                this._riskLoads.delete(aid);
+        }
+    }
+    async _loadRiskForAid(aid, raw) {
+        const controller = new RiskController({ persist: async (state) => {
+                const saved = JSON.stringify(state);
+                this._tokenStore.saveMetadata(aid, { ...(this._tokenStore._loadMetadataStrict(aid) ?? {}), [`risk_state_v1:${this.deviceId}`]: state });
+                this._riskPersistedStates.set(aid, saved);
+            } });
+        this._riskPersistedStates.set(aid, raw);
+        if (raw) {
+            const state = JSON.parse(raw);
+            if (!isJsonObject(state))
+                throw new StateError('persisted risk state is unavailable', { stringCode: 'risk_state_unavailable' });
+            await controller.restorePinned(state, { aid, device_id: this.deviceId, slot_id: this.slotId, connection_id: '' });
+        }
+        const previous = this._riskControllers.get(aid);
+        if (previous && this._ownedRiskControllers.has(previous)) {
+            previous.close();
+            this._ownedRiskControllers.delete(previous);
+        }
+        this._riskControllers.set(aid, controller);
+        this._ownedRiskControllers.add(controller);
+        return controller;
+    }
+    async _riskFetchForAid(aid, url, init, perform, scope) {
+        const controller = await this._riskForAid(aid);
+        const release = controller.acquire(scope);
+        try {
+            return await perform(url, init);
+        }
+        finally {
+            release();
+        }
+    }
     async sign(aid, input, options = {}) {
         try {
             if (!['text', 'file'].includes(options.inputType ?? 'text') || !['raw', 'document'].includes(options.format ?? 'raw'))
@@ -262,32 +324,41 @@ export class AIDStore {
         });
     }
     close() {
+        for (const controller of this._ownedRiskControllers)
+            controller.close();
+        this._ownedRiskControllers.clear();
         this._keystore.close();
         this._tokenStore.close();
         const net = this._net;
         if (typeof net.close === 'function')
             net.close();
     }
-    async _resolveAgentMdPeerCertificate(target, certFingerprint, signedAt) {
+    _riskPeerAuth(actorAid) {
+        const auth = new AuthFlow({ tokenStore: this._tokenStore, crypto: this._crypto, deviceId: this.deviceId, slotId: this.slotId, verifySsl: this._verifySsl, rootCaPath: this._rootCaPath, logger: this._log.for('aun_core.auth'), net: this._net });
+        auth.setHttpHandler((url, init, perform) => this._riskFetchForAid(actorAid, url, init, perform, 'http:gateway:pki'));
+        return auth;
+    }
+    async _resolveAgentMdPeerCertificate(target, certFingerprint, signedAt, actorAid) {
+        const auth = actorAid ? this._riskPeerAuth(actorAid) : this._peerAuth;
         const fp = String(certFingerprint ?? '').trim().toLowerCase();
         const cachedCert = this._keystore.loadCert(target, fp || undefined);
         if (cachedCert && (!fp || certMatchesFingerprint(cachedCert, fp) || publicKeyMatchesFingerprint(cachedCert, fp))) {
             if (signedAt !== undefined)
-                await this._verifyDownloadedPeerCertificate(await this._resolveGateway(target), target, cachedCert, fp, signedAt);
+                await this._verifyDownloadedPeerCertificate(await this._resolveGateway(target, actorAid), target, cachedCert, fp, signedAt, auth);
             return AID._create({ aid: target, aunPath: this.aunPath, certPem: cachedCert, privateKeyPem: null, certValid: true, privateKeyValid: false, deviceId: this.deviceId, slotId: this.slotId, verifySsl: this._verifySsl, rootCaPath: this._rootCaPath, debug: this._debug });
         }
         if (fp) {
-            const gatewayUrl = await this._resolveGateway(target);
-            const certPem = await this._net.httpGetText(pkiCertUrl(gatewayUrl, target, fp), 10_000);
-            await this._verifyDownloadedPeerCertificate(gatewayUrl, target, certPem, fp, signedAt);
+            const gatewayUrl = await this._resolveGateway(target, actorAid);
+            const certPem = actorAid ? await auth._fetchRiskText(pkiCertUrl(gatewayUrl, target, fp)) : await this._net.httpGetText(pkiCertUrl(gatewayUrl, target, fp), 10_000);
+            await this._verifyDownloadedPeerCertificate(gatewayUrl, target, certPem, fp, signedAt, auth);
             this._keystore.saveCert(target, certPem, _certFingerprint(certPem), { makeActive: false });
             return AID._create({ aid: target, aunPath: this.aunPath, certPem, privateKeyPem: null, certValid: true, privateKeyValid: false });
         }
-        const gatewayUrl = await this._resolveGateway(target);
-        const certPem = await this._registerFlow.fetchPeerCert(gatewayUrl, target);
+        const gatewayUrl = await this._resolveGateway(target, actorAid);
+        const certPem = actorAid ? await auth._fetchRiskText(pkiCertUrl(gatewayUrl, target)) : await this._registerFlow.fetchPeerCert(gatewayUrl, target);
         if (!certPem)
             throw new Error(`certificate not found for aid: ${target}`);
-        await this._verifyDownloadedPeerCertificate(gatewayUrl, target, certPem, undefined, signedAt);
+        await this._verifyDownloadedPeerCertificate(gatewayUrl, target, certPem, undefined, signedAt, auth);
         this._keystore.saveCert(target, certPem);
         return AID._create({ aid: target, aunPath: this.aunPath, certPem, privateKeyPem: null, certValid: true, privateKeyValid: false });
     }
@@ -412,6 +483,11 @@ export class AIDStore {
     }
     // ── 联网方法 ──────────────────────────────────────────────────
     async register(aid, options) {
+        if (['group', 'org'].includes(String(options?.type ?? '').trim()))
+            return resultErr(codes.INVALID_AID_FORMAT, 'group/org must use their dedicated creation flow');
+        return this._registerIdentity(aid, options);
+    }
+    async _registerIdentity(aid, options) {
         const target = String(aid ?? '').trim();
         this._log.for('aun_core.aid_store').debug(`register enter: aid=${target || '-'}`);
         try {
@@ -420,8 +496,8 @@ export class AIDStore {
             const entity = ['group', 'org'].includes(type);
             if (entity && !owner)
                 throw new ValidationError('group/org registration requires owner');
-            if (!type || type === 'human' && owner)
-                throw new ValidationError('register requires type; human forbids owner');
+            if (!type || type === 'human' && owner || type !== 'human' && !owner)
+                throw new ValidationError('register requires type; human forbids owner; other types require owner');
             if (owner)
                 validateAIDFormat(owner, 'owner');
             const exttype = String(options?.exttype ?? '').trim();
@@ -437,9 +513,11 @@ export class AIDStore {
                 curve: result.curve,
             });
             if (!entity) {
-                const initialized = await this._createInitialRegistrationAgentMd(target, type, exttype);
-                if (!initialized.ok)
-                    return initialized;
+                if (type === 'human') {
+                    const initialized = await this._createInitialRegistrationAgentMd(target, type, exttype);
+                    if (!initialized.ok)
+                        return initialized;
+                }
                 if (owner) {
                     await this._bindRegistrationOwner(target, owner);
                 }
@@ -469,6 +547,7 @@ export class AIDStore {
         const client = new AUNClient(AID._create({ aid: target, aunPath: this.aunPath, certPem: identity.certPem, privateKeyPem: identity.privateKeyPem,
             certValid: identity.isCertValid(), privateKeyValid: identity.isPrivateKeyValid(), deviceId: this.deviceId, slotId: `ownership-${randomUUID()}`,
             verifySsl: this._verifySsl, rootCaPath: this._rootCaPath, debug: this._debug, aidStore: this }));
+        client._ownershipOperation = true;
         try {
             await client.connect({ connection_kind: 'short', background_sync: false, auto_reconnect: false });
             const result = await client.bindOwneraid(owner);
@@ -588,48 +667,44 @@ export class AIDStore {
             const record = this._agentMdManager.loadRecord(target);
             if (data.agent_md?.etag !== undefined && data.agent_md.etag !== String(record?.remote_etag ?? ''))
                 throw new Error('displayed agent.md ETag does not match the current observation');
-            const cached = record?.ownership_snapshot;
             const content = data.agent_md?.content ?? record?.content;
             const hash = typeof content === 'string' ? AgentMdManager.contentEtag(content).slice(1, -1) : '';
             const bypass = opts.ownershipTtlMs !== undefined && opts.ownershipTtlMs <= 0;
-            if (!bypass && record?.remote_etag && cached?.agent_md_etag === record.remote_etag && cached.sub_aid === target && cached.status !== 'unavailable' && hash && cached.agent_md_sha256 === hash) {
-                data.ownership = { ...JSON.parse(JSON.stringify(cached)), cached: true };
+            const observedHash = typeof record?.content === 'string' ? AgentMdManager.contentEtag(record.content).slice(1, -1) : '';
+            const observation = { root: this._agentMdManager.root, etag: String(record?.remote_etag ?? ''), version: Number(record?.observation_version ?? 0), content_hash: observedHash };
+            const key = JSON.stringify([target, observation, hash]);
+            let flights = this._ownershipInflight.get(opts.ownership);
+            if (!flights)
+                this._ownershipInflight.set(opts.ownership, flights = new Map());
+            let pending = bypass ? undefined : flights.get(key);
+            if (!pending) {
+                pending = (async () => {
+                    const checker = opts.ownership;
+                    const checked = bypass && typeof checker._checkOwnershipConsensusFresh === 'function'
+                        ? await checker._checkOwnershipConsensusFresh.call(opts.ownership, target)
+                        : await opts.ownership.checkOwnershipConsensus(target);
+                    if (['consensus', 'single_sided', 'released', 'unbound'].includes(checked.status) && (checked.sub_aid !== target || checked.agent_md_etag !== observation.etag || checked.agent_md_sha256 !== hash || observedHash !== hash))
+                        throw new Error('ownership snapshot does not match the observed agent.md');
+                    const snapshot = { ...JSON.parse(JSON.stringify(checked)), checked_at: Date.now(), cached: false };
+                    delete snapshot.owner_md;
+                    delete snapshot.owner_md_sha256;
+                    if (!this._agentMdManager.cacheOwnershipSnapshot(target, snapshot, observation))
+                        throw new Error('agent.md observation changed during ownership check');
+                    return snapshot;
+                })();
+                if (!bypass)
+                    flights.set(key, pending);
             }
-            else {
-                const observedHash = typeof record?.content === 'string' ? AgentMdManager.contentEtag(record.content).slice(1, -1) : '';
-                const observation = { root: this._agentMdManager.root, etag: String(record?.remote_etag ?? ''), version: Number(record?.observation_version ?? 0), content_hash: observedHash };
-                const key = JSON.stringify([target, observation, hash]);
-                let flights = this._ownershipInflight.get(opts.ownership);
-                if (!flights)
-                    this._ownershipInflight.set(opts.ownership, flights = new Map());
-                let pending = bypass ? undefined : flights.get(key);
-                if (!pending) {
-                    pending = (async () => {
-                        const checker = opts.ownership;
-                        const checked = bypass && typeof checker._checkOwnershipConsensusFresh === 'function'
-                            ? await checker._checkOwnershipConsensusFresh.call(opts.ownership, target)
-                            : await opts.ownership.checkOwnershipConsensus(target);
-                        if (['consensus', 'single_sided', 'released', 'unbound'].includes(checked.status) && (checked.sub_aid !== target || checked.agent_md_etag !== observation.etag || checked.agent_md_sha256 !== hash || observedHash !== hash))
-                            throw new Error('ownership snapshot does not match the observed agent.md');
-                        const snapshot = { ...JSON.parse(JSON.stringify(checked)), checked_at: Date.now(), cached: false };
-                        if (!this._agentMdManager.cacheOwnershipSnapshot(target, snapshot, observation))
-                            throw new Error('agent.md observation changed during ownership check');
-                        return snapshot;
-                    })();
-                    if (!bypass)
-                        flights.set(key, pending);
-                }
-                try {
-                    data.ownership = JSON.parse(JSON.stringify(await pending));
-                }
-                finally {
-                    if (flights.get(key) === pending)
-                        flights.delete(key);
-                }
+            try {
+                data.ownership = JSON.parse(JSON.stringify(await pending));
+            }
+            finally {
+                if (flights.get(key) === pending)
+                    flights.delete(key);
             }
         }
         catch (error) {
-            data.ownership = { status: 'unavailable', sub_aid: target, owner_aid: null, relation_version: 0, lock: 'unlocked', agent_md_etag: '', agent_md_sha256: '', owner_md_sha256: '', code: 'unavailable', reason: error instanceof Error ? error.message : String(error), retryable: true, checked_at: Date.now(), cached: false };
+            data.ownership = { status: 'unavailable', sub_aid: target, owner_aid: null, relation_version: 0, lock: 'unlocked', agent_md_etag: '', agent_md_sha256: '', code: 'unavailable', reason: error instanceof Error ? error.message : String(error), retryable: true, checked_at: Date.now(), cached: false };
         }
         return resultOk(data);
     }
@@ -649,16 +724,16 @@ export class AIDStore {
             return agentMdFailure(exc);
         }
     }
-    async _verifyDownloadedPeerCertificate(gatewayUrl, aid, certPem, certFingerprint = '', signedAt) {
+    async _verifyDownloadedPeerCertificate(gatewayUrl, aid, certPem, certFingerprint = '', signedAt, auth = this._peerAuth) {
         const expectedFp = String(certFingerprint ?? '').trim().toLowerCase();
         if (expectedFp && !certMatchesFingerprint(certPem, expectedFp) && !(signedAt !== undefined && publicKeyMatchesFingerprint(certPem, expectedFp))) {
             throw new ValidationError(`certificate fingerprint mismatch for aid: ${aid}`);
         }
         if (signedAt === undefined)
-            await this._peerAuth.verifyPeerCertificate(gatewayUrl, certPem, aid);
+            await auth.verifyPeerCertificate(gatewayUrl, certPem, aid);
         else {
             validateAgentMdCertificate(certPem, aid, signedAt, { requireCurrentValidity: false, readCompatibility: true });
-            await this._peerAuth._verifyAuthCertChain(gatewayUrl, new X509Certificate(certPem), aid, signedAt);
+            await auth._verifyAuthCertChain(gatewayUrl, new X509Certificate(certPem), aid, signedAt);
         }
     }
     _authIdentityFromAid(aid) {
@@ -670,6 +745,7 @@ export class AIDStore {
         };
     }
     async _uploadAgentMdToken(aid, gatewayUrl) {
+        const risk = await this._riskForAid(aid.aid);
         const auth = new AuthFlow({
             tokenStore: this._tokenStore,
             crypto: this._crypto,
@@ -681,6 +757,8 @@ export class AIDStore {
             logger: this._log.for('aun_core.auth'),
             net: this._net,
         });
+        auth.setRequestAdmission((request) => risk.acquire(request));
+        auth.setHttpHandler((url, init, perform) => this._riskFetchForAid(aid.aid, url, init, perform, 'http:gateway:pki'));
         auth.setIdentity(this._authIdentityFromAid(aid));
         const result = await auth.authenticate(gatewayUrl, { aid: aid.aid });
         const token = String(result.access_token ?? result.token ?? result.kite_token ?? '').trim();
@@ -689,6 +767,9 @@ export class AIDStore {
         return token;
     }
     async uploadAgentMd(aid, content, options = {}) {
+        return this._uploadAgentMd(aid, content, options);
+    }
+    async _uploadAgentMd(aid, content, options, onCommitted) {
         const target = String(aid ?? '').trim();
         try {
             this._registerFlow.validateAidName(target);
@@ -700,7 +781,7 @@ export class AIDStore {
             const current = loaded.data.aid;
             const pending = content === undefined || content === null ? this._agentMdManager.pendingUpload(target) : null;
             const raw = pending?.content ?? content ?? (String((this._agentMdManager._loadRecord?.(target, true) ?? this._agentMdManager.loadRecord(target))?.local_draft_content ?? '') || this._agentMdManager.readContent(target));
-            const parsed = validateAgentMdDocument(raw, { expectedAid: target, validateOwnership: false });
+            const parsed = validateAgentMdDocument(raw, { expectedAid: target, validateOwnership: false, forUpload: true });
             const meta = parsed.frontmatter;
             const entity = ['group', 'org'].includes(String(meta.type));
             const uploaderTarget = String(options.uploaderAid ?? options.uploader_aid ?? (entity ? meta.owner : target)).trim();
@@ -727,22 +808,40 @@ export class AIDStore {
                 uploadViaGatewayHost: true,
                 ownerAidGetter: () => entity ? uploaderTarget : target,
                 currentAidGetter: () => entity ? uploader : current,
+                onCommitted: onCommitted ? (value, notice) => onCommitted(value, notice, manager) : (async (value, notice) => {
+                    const { AUNClient } = await import('./client.js');
+                    const client = new AUNClient(AID._create({ aid: uploader.aid, aunPath: this.aunPath, certPem: uploader.certPem, privateKeyPem: uploader.privateKeyPem,
+                        certValid: uploader.isCertValid(), privateKeyValid: uploader.isPrivateKeyValid(), deviceId: this.deviceId, slotId: `agent-md-${randomUUID()}`,
+                        verifySsl: this._verifySsl, rootCaPath: this._rootCaPath, debug: this._debug, aidStore: this }));
+                    client._ownershipOperation = true;
+                    try {
+                        await client.connect({ connection_kind: 'short', background_sync: false, auto_reconnect: false });
+                        await client._getAgentMdChanges().committed(value, notice, manager);
+                    }
+                    finally {
+                        await client.close();
+                    }
+                }),
                 entityIdentityGetter: options.entityIdentityGetter ?? (async (value, type) => {
-                    const gateway = await this._resolveGateway(value);
-                    const material = await this._peerAuth.resolveCurrentEntityCertificate(gateway, value, type ?? 'org');
+                    const gateway = await this._resolveGateway(value, uploaderTarget);
+                    const material = await this._riskPeerAuth(uploaderTarget).resolveCurrentEntityCertificate(gateway, value, type ?? 'org');
                     const certPem = material.cert_pem;
                     return AID._create({ aid: value, aunPath: this.aunPath, certPem, certValid: true, privateKeyPem: null, privateKeyValid: false });
                 }),
                 entitySignerResolver: async (value, fingerprint) => {
-                    const material = await this._peerAuth.resolveOwnershipCertificate(await this._resolveGateway(value), value, fingerprint, 'signing');
+                    const material = await this._riskPeerAuth(uploaderTarget).resolveOwnershipCertificate(await this._resolveGateway(value, uploaderTarget), value, fingerprint, 'signing');
                     return AID._create({ aid: value, aunPath: this.aunPath, certPem: material.cert_pem, certValid: true, privateKeyPem: null, privateKeyValid: false });
                 },
                 entityOwnerResolver: options.entityOwnerResolver,
-                peerResolver: (value, fingerprint, signedAt) => this._resolveAgentMdPeerCertificate(value, fingerprint, signedAt),
-                gatewayResolver: (value) => this._resolveGateway(value),
-                accessTokenResolver: async () => this._uploadAgentMdToken(uploader, await this._resolveGateway(uploaderTarget)),
+                peerResolver: (value, fingerprint, signedAt) => this._resolveAgentMdPeerCertificate(value, fingerprint, signedAt, uploaderTarget),
+                gatewayResolver: (value) => this._resolveGateway(value, uploaderTarget),
+                accessTokenResolver: async () => this._uploadAgentMdToken(uploader, await this._resolveGateway(uploaderTarget, uploaderTarget)),
                 aidValidator: (value) => this._registerFlow.validateAidName(value),
             });
+            manager.setHttpHandler((url, init, perform) => {
+                const headers = new Headers(init.headers);
+                return this._riskFetchForAid(uploaderTarget, url, init, perform, headers.has('X-AUN-Ownership-Check') || headers.has('X-AUN-Ownership-Stage') ? 'http:nameservice:ownership' : 'http:nameservice:agent_md');
+            });
             if (pending) {
                 await manager.resumePendingUpload(target, current);
                 const record = manager.loadRecord(target);
@@ -1011,7 +1110,7 @@ export class AIDStore {
         return Promise.resolve(this.importGroupIdentity(aidOrOptions, options));
     }
     // ── 内部辅助 ──────────────────────────────────────────────────
-    async _resolveGateway(aid) {
+    async _resolveGateway(aid, actorAid) {
         const target = String(aid ?? '').trim();
         if (!target)
             throw new ValidationError('AIDStore requires non-empty aid to resolve gateway');
@@ -1024,10 +1123,13 @@ export class AIDStore {
             `https://${target}/.well-known/aun-gateway`,
             `https://gateway.${issuerDomain}/.well-known/aun-gateway`,
         ];
+        const discovery = actorAid ? new GatewayDiscovery({ verifySsl: this._verifySsl, logger: this._log.for('aun_core.discovery'), net: this._net }) : this._discovery;
+        if (actorAid)
+            discovery.setHttpHandler((url, init, perform) => this._riskFetchForAid(actorAid, url, init, perform, 'http:discovery:gateway'));
         let lastError = null;
         for (const url of candidates) {
             try {
-                const discovered = await this._discovery.discover(url);
+                const discovered = await discovery.discover(url);
                 this._gatewayCache.set(issuerDomain, discovered);
                 return discovered;
             }