@agentunion/fastaun-browser 0.5.4 → 0.5.8

package/dist/agent-md.js

@@ -1,8 +1,28 @@
 import { AID } from './aid.js';
 import { certMatchesFingerprint, parseAgentMdTailSignature } from './cert-utils.js';
+import { validateAgentMdDocument, verifyAgentMdUpload } from './agent-md-schema.js';
 import { AUNError, ClientSignatureError, NotFoundError, StateError, ValidationError } from './errors.js';
 import { isJsonObject } from './types.js';
 const DEFAULT_HTTP_TIMEOUT_MS = 30_000;
+export function buildDefaultAgentMd(aid, options = {}) {
+    const target = String(aid ?? '').trim();
+    const type = String(options.type ?? 'agent').trim() || 'agent';
+    const name = String(options.name ?? '').trim() || target.split('.', 1)[0] || target;
+    const normalized = String(options.description ?? '').trim().replace(/\s+/g, ' ') || `AUN ${type} ${name}`;
+    const description = Array.from(normalized).slice(0, 100).join('');
+    return [
+        '---',
+        `aid: ${JSON.stringify(target)}`,
+        `name: ${JSON.stringify(name)}`,
+        `type: ${JSON.stringify(type)}`,
+        'version: "1.0.0"',
+        `description: ${JSON.stringify(description)}`,
+        '---',
+        '',
+        `# ${name}`,
+        '',
+    ].join('\n');
+}
 const HEAD_HTTP_TIMEOUT_MS = 15_000;
 const noopLogger = {
     error: () => { },
@@ -10,7 +30,127 @@ const noopLogger = {
     info: () => { },
     debug: () => { },
 };
+function nodeBuiltin(name) {
+    const processLike = globalThis.process;
+    if (typeof processLike?.getBuiltinModule !== 'function')
+        return null;
+    try {
+        return processLike.getBuiltinModule(name);
+    }
+    catch {
+        return null;
+    }
+}
+function requestHeaders(init) {
+    const out = {};
+    try {
+        new Headers(init.headers).forEach((value, key) => {
+            out[key] = value;
+        });
+    }
+    catch {
+        return out;
+    }
+    return out;
+}
+function requestWithNodeHost(input, init, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let parsed;
+        try {
+            parsed = new URL(input);
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const module = parsed.protocol === 'https:'
+            ? nodeBuiltin('node:https')
+            : nodeBuiltin('node:http');
+        if (!module) {
+            reject(new Error('Node HTTP module is unavailable'));
+            return;
+        }
+        const headers = requestHeaders(init);
+        const options = {
+            method: init.method ?? 'GET',
+            headers,
+            timeout: timeoutMs,
+        };
+        if (parsed.protocol === 'https:') {
+            options.rejectUnauthorized = runtimeEnv('NODE_TLS_REJECT_UNAUTHORIZED') !== '0';
+        }
+        let settled = false;
+        let request = null;
+        const onAbort = () => {
+            request?.destroy(new Error('agent.md request aborted'));
+            finish(() => reject(new AUNError('agent.md request aborted')));
+        };
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            if (init.signal)
+                init.signal.removeEventListener('abort', onAbort);
+            callback();
+        };
+        if (init.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        try {
+            request = module.request(input, options, (response) => {
+                const chunks = [];
+                response.on('data', (chunk) => {
+                    if (chunk instanceof Uint8Array)
+                        chunks.push(chunk);
+                    else
+                        chunks.push(new TextEncoder().encode(String(chunk ?? '')));
+                });
+                response.on('error', (error) => {
+                    finish(() => reject(error instanceof Error ? error : new Error(String(error))));
+                });
+                response.on('end', () => {
+                    const total = chunks.reduce((size, chunk) => size + chunk.byteLength, 0);
+                    const body = new Uint8Array(total);
+                    let offset = 0;
+                    for (const chunk of chunks) {
+                        body.set(chunk, offset);
+                        offset += chunk.byteLength;
+                    }
+                    const responseHeaders = {};
+                    for (const [key, value] of Object.entries(response.headers)) {
+                        if (typeof value === 'string')
+                            responseHeaders[key] = value;
+                        else if (Array.isArray(value))
+                            responseHeaders[key] = value[0] ?? '';
+                    }
+                    finish(() => resolve(new Response(body, {
+                        status: response.statusCode ?? 500,
+                        headers: responseHeaders,
+                    })));
+                });
+            });
+            request.on('error', (error) => {
+                finish(() => reject(error instanceof Error ? error : new Error(String(error))));
+            });
+            request.setTimeout(timeoutMs, () => {
+                request?.destroy();
+                finish(() => reject(new AUNError(`agent.md request timed out after ${timeoutMs}ms`)));
+            });
+            init.signal?.addEventListener('abort', onAbort, { once: true });
+            if (typeof init.body === 'string')
+                request.write(init.body);
+            request.end();
+        }
+        catch (error) {
+            finish(() => reject(error));
+        }
+    });
+}
 async function fetchWithTimeout(input, init, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+    if (new Headers(init.headers).has('host')) {
+        return await requestWithNodeHost(input, init, timeoutMs);
+    }
     const controller = new AbortController();
     const timer = globalThis.setTimeout(() => controller.abort(), timeoutMs);
     try {
@@ -32,12 +172,54 @@ function headerValue(headers, name) {
 function agentMdHttpScheme(gatewayUrl) {
     return String(gatewayUrl ?? '').trim().toLowerCase().startsWith('ws://') ? 'http' : 'https';
 }
+function runtimeEnv(name) {
+    const processLike = globalThis.process;
+    return String(processLike?.env?.[name] ?? '').trim();
+}
+function nameServiceAgentMdUrl(aid, gatewayUrl) {
+    const configuredBase = runtimeEnv('AUN_NAMESERVICE_URL') || runtimeEnv('KITE_NAMESERVICE_URL');
+    if (configuredBase) {
+        try {
+            const parsed = new URL(configuredBase);
+            if (parsed.protocol && parsed.host) {
+                parsed.pathname = `${parsed.pathname.replace(/\/+$/g, '')}/agent.md`;
+                parsed.search = '';
+                parsed.hash = '';
+                return parsed.toString();
+            }
+        }
+        catch {
+            // 无效配置时回退到按 issuer 推导的 NameService 公网地址。
+        }
+    }
+    const target = String(aid ?? '').trim().toLowerCase();
+    const gatewayHost = (() => {
+        try {
+            return new URL(String(gatewayUrl ?? '').trim()).hostname.toLowerCase();
+        }
+        catch {
+            return '';
+        }
+    })();
+    const configuredIssuer = runtimeEnv('AUN_ISSUER_DOMAIN').toLowerCase();
+    const issuer = configuredIssuer
+        || (gatewayHost.startsWith('gateway.') ? gatewayHost.slice('gateway.'.length) : '')
+        || (target.includes('.') ? target.slice(target.indexOf('.') + 1) : '');
+    const host = runtimeEnv('AUN_SERVICE_PUBLIC_HOST_NAMESERVICE') || issuer;
+    if (!host)
+        return '';
+    const scheme = runtimeEnv('AUN_SERVICE_SCHEME_NAMESERVICE') || agentMdHttpScheme(gatewayUrl);
+    const port = runtimeEnv('AUN_SERVICE_PUBLIC_PORT_NAMESERVICE');
+    const hostWithPort = port && !host.includes(':') && !host.endsWith(`:${port}`) ? `${host}:${port}` : host;
+    return `${scheme}://${hostWithPort}/agent.md`;
+}
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 export class AgentMdManager {
     _aunPath;
     _agentMdPath;
+    _uploadViaGatewayHost;
     _tokenStore;
     _log;
     _ownerAidGetter;
@@ -49,12 +231,13 @@ export class AgentMdManager {
     _cache = new Map();
     _memoryStorage = new Map();
     _fetchInflight = new Set();
+    _snapshotLoads = new Map();
     _lock = Promise.resolve();
-    _localAgentMdEtag = '';
-    _remoteAgentMdEtag = '';
+    _storageGeneration = 0;
     constructor(opts) {
         this._aunPath = String(opts.aunPath ?? '');
         this._agentMdPath = this._defaultRoot();
+        this._uploadViaGatewayHost = opts.uploadViaGatewayHost ?? false;
         this._tokenStore = opts.tokenStore;
         this._log = opts.logger ?? noopLogger;
         this._ownerAidGetter = opts.ownerAidGetter;
@@ -73,11 +256,11 @@ export class AgentMdManager {
     }
     setRoot(root) {
         this._agentMdPath = String(root ?? '').trim() || this._defaultRoot();
+        this._storageGeneration += 1;
         this._cache.clear();
         this._memoryStorage.clear();
         this._fetchInflight.clear();
-        this._localAgentMdEtag = '';
-        this._remoteAgentMdEtag = '';
+        this._snapshotLoads.clear();
         return this._agentMdPath;
     }
     async upload(content) {
@@ -103,11 +286,13 @@ export class AgentMdManager {
         if (localContent === null || localContent.length === 0) {
             throw new ValidationError('uploadAgentMd requires local agent.md content');
         }
+        validateAgentMdDocument(localContent, { expectedAid: target });
         const signedResult = await current.signAgentMd(localContent);
         if (!signedResult.ok) {
             throw new ClientSignatureError(signedResult.error.message || 'agent.md signing failed');
         }
         const signed = signedResult.data.signed;
+        await verifyAgentMdUpload(signed, current.certPem, target);
         const result = await this._uploadHttp(target, signed);
         const localEtag = await AgentMdManager.contentEtag(signed);
         const remoteEtag = String(result.etag ?? '').trim();
@@ -135,6 +320,9 @@ export class AgentMdManager {
         const signature = { ...verified.data };
         const statusText = String(signature.status ?? 'invalid');
         const reason = String(signature.reason ?? '').trim();
+        if (statusText === 'invalid') {
+            throw new ClientSignatureError(`agent.md verification failed for ${target}${reason ? `: ${reason}` : ''}`);
+        }
         const verification = { status: statusText };
         if (reason)
             verification.reason = reason;
@@ -152,7 +340,7 @@ export class AgentMdManager {
             last_error: '',
         });
         let inSync = null;
-        if (target === this._ownerAid()) {
+        if (target.toLowerCase() === this._ownerAid().toLowerCase()) {
             const remote = contentResult.etag || String(saved.remote_etag ?? '');
             inSync = localEtag && remote ? localEtag === remote : false;
         }
@@ -255,8 +443,6 @@ export class AgentMdManager {
                 fields.last_modified = remoteLastModified;
             record = await this.saveRecord(target, fields) || record;
         }
-        if (target === this._ownerAid() && remoteEtag)
-            this._remoteAgentMdEtag = remoteEtag;
         await this._scheduleFetchIfMissing(target, record, source);
         this._log.debug(`agent.md meta observed: aid=${target} etag=${remoteEtag || '-'} last_modified=${remoteLastModified || '-'} source=${source || '-'}`);
     }
@@ -266,7 +452,6 @@ export class AgentMdManager {
         const owner = String(ownerAid ?? this._ownerAid() ?? '').trim();
         const etag = String(meta.agent_md_etag ?? '').trim();
         if (etag && owner) {
-            this._remoteAgentMdEtag = etag;
             await this.observeMeta(owner, etag, '', 'rpc.self');
         }
         const etags = meta.agent_md_etags;
@@ -304,33 +489,64 @@ export class AgentMdManager {
             await this.observeMeta(groupAid, String(group.etag ?? '').trim(), String(group.last_modified ?? group.lastModified ?? '').trim(), 'envelope.group');
         }
     }
-    eventSnapshot() {
-        if (!this._localAgentMdEtag && !this._remoteAgentMdEtag)
+    async eventSnapshot(aid) {
+        const target = String(aid ?? this._ownerAid() ?? '').trim();
+        if (!target)
+            return null;
+        const generation = this._storageGeneration;
+        if (!this._cache.has(target)) {
+            let load = this._snapshotLoads.get(target);
+            if (!load) {
+                load = this.loadRecord(target).then((record) => {
+                    if (generation === this._storageGeneration && !this._cache.has(target)) {
+                        this._cache.set(target, record ? { ...record } : { aid: target });
+                    }
+                });
+                this._snapshotLoads.set(target, load);
+            }
+            try {
+                await load;
+            }
+            finally {
+                if (this._snapshotLoads.get(target) === load)
+                    this._snapshotLoads.delete(target);
+            }
+        }
+        if (generation !== this._storageGeneration)
+            return null;
+        const record = this._cache.get(target) ?? { aid: target };
+        const localEtag = String(record.local_etag ?? '').trim();
+        const remoteEtag = String(record.remote_etag ?? record.etag ?? '').trim();
+        if (!localEtag && !remoteEtag)
             return null;
-        return { local_etag: this._localAgentMdEtag, remote_etag: this._remoteAgentMdEtag };
+        return { local_etag: localEtag, remote_etag: remoteEtag };
     }
     async readContent(aid) {
-        return await this._readStorage(this._contentKey(aid));
+        const root = this.root;
+        return await this._readStorage(this._contentKey(aid), root);
     }
     async writeContent(aid, content) {
-        await this._writeStorage(this._contentKey(aid), String(content ?? ''));
+        const root = this.root;
+        await this._writeStorage(this._contentKey(aid), String(content ?? ''), root);
     }
     async loadRecord(aid) {
         const target = String(aid ?? '').trim();
         if (!target)
             return null;
+        const root = this.root;
+        const generation = this._storageGeneration;
         try {
             const loaded = await this._withLock(async () => {
-                const record = await this._readRecordUnlocked(target);
+                const record = await this._readRecordUnlocked(target, root);
                 const next = Object.keys(record).length > 0 ? { ...record, aid: target } : { aid: target };
                 try {
-                    const content = await this.readContent(target);
+                    const content = await this._readStorage(this._contentKey(target), root);
                     if (content !== null) {
                         next.content = content;
                         next.local_etag = await AgentMdManager.contentEtag(content);
                     }
                     else {
-                        const metaRaw = await this._readStorage(this._metaKey(target));
+                        const metaRaw = await this._readStorage(this._metaKey(target), root);
                         if (metaRaw !== null)
                             this._log.warn(`agent.md content read failed: aid=${target}`);
                     }
@@ -342,8 +558,8 @@ export class AgentMdManager {
             });
             if (Object.keys(loaded).length <= 1)
                 return null;
-            this._cache.set(target, { ...loaded });
-            this._refreshOwnerEtags(target, loaded);
+            if (generation === this._storageGeneration)
+                this._cache.set(target, { ...loaded });
             return { ...loaded };
         }
         catch (err) {
@@ -355,12 +571,14 @@ export class AgentMdManager {
         const target = String(aid ?? '').trim();
         if (!target)
             return {};
+        const root = this.root;
+        const generation = this._storageGeneration;
         try {
             const inputFields = { ...fields };
             const hasContent = Object.prototype.hasOwnProperty.call(inputFields, 'content') && inputFields.content !== undefined && inputFields.content !== null;
             if (hasContent) {
                 const text = String(inputFields.content ?? '');
-                await this.writeContent(target, text);
+                await this._writeStorage(this._contentKey(target), text, root);
                 if (!inputFields.local_etag)
                     inputFields.local_etag = await AgentMdManager.contentEtag(text);
                 if (!inputFields.fetched_at)
@@ -368,20 +586,20 @@ export class AgentMdManager {
             }
             delete inputFields.content;
             const record = await this._withLock(async () => {
-                const next = { ...(await this._readRecordUnlocked(target)), aid: target };
+                const next = { ...(await this._readRecordUnlocked(target, root)), aid: target };
                 for (const [key, value] of Object.entries(inputFields)) {
                     if (value !== undefined && value !== null)
                         next[key] = value;
                 }
                 next.updated_at = Date.now();
-                await this._writeRecordUnlocked(target, next);
+                await this._writeRecordUnlocked(target, next, root);
                 return next;
             });
             const loaded = { ...record };
             if (hasContent)
                 loaded.content = String(fields.content ?? '');
-            this._cache.set(target, { ...loaded });
-            this._refreshOwnerEtags(target, loaded);
+            if (generation === this._storageGeneration)
+                this._cache.set(target, { ...loaded });
             return { ...loaded };
         }
         catch (err) {
@@ -447,10 +665,9 @@ export class AgentMdManager {
     async _resolvePeer(aid, certFingerprint) {
         const expectedFp = String(certFingerprint ?? '').trim().toLowerCase();
         const current = this._currentAid();
-        if (current?.aid === aid) {
+        if (current && current.aid.toLowerCase() === aid.toLowerCase()) {
             if (!expectedFp || await certMatchesFingerprint(current.certPem, expectedFp))
                 return current;
-            throw new StateError(`current AID certificate fingerprint mismatch for ${aid}`);
         }
         const peer = await this._peerResolver?.(aid, expectedFp || null);
         if (!(peer instanceof AID)) {
@@ -470,14 +687,48 @@ export class AgentMdManager {
     async _uploadHttp(aid, content) {
         const gatewayUrl = await this._resolveGateway(aid);
         const token = await this._accessToken(aid, gatewayUrl);
-        const response = await fetchWithTimeout(this._url(aid, gatewayUrl), {
-            method: 'PUT',
-            headers: {
-                Authorization: `Bearer ${token}`,
-                'Content-Type': 'text/markdown; charset=utf-8',
-            },
-            body: content,
-        });
+        // 浏览器禁止覆盖 Host；动态 AID URL 由浏览器/Docker 的通配解析路由。
+        const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'text/markdown; charset=utf-8',
+            ...(viaGatewayHost ? { Host: this._safeAid(aid) } : {}),
+        };
+        let url = this._url(aid, gatewayUrl);
+        if (viaGatewayHost) {
+            try {
+                const parsedGateway = new URL(String(gatewayUrl ?? '').trim());
+                const gatewayHost = parsedGateway.hostname;
+                const gatewayPort = parsedGateway.port;
+                if (gatewayHost) {
+                    const host = gatewayPort && gatewayPort !== '443' && gatewayPort !== '20001'
+                        ? `${gatewayHost}:${gatewayPort}`
+                        : gatewayHost;
+                    url = `${agentMdHttpScheme(gatewayUrl)}://${host}/agent.md`;
+                }
+            }
+            catch {
+                // 无效 Gateway 地址时保留目标 AID URL。
+            }
+        }
+        let response;
+        try {
+            response = await fetchWithTimeout(url, { method: 'PUT', headers, body: content });
+        }
+        catch (error) {
+            if (!viaGatewayHost)
+                throw error;
+            const fallbackUrl = nameServiceAgentMdUrl(aid, gatewayUrl);
+            if (!fallbackUrl || fallbackUrl === url)
+                throw error;
+            response = await fetchWithTimeout(fallbackUrl, { method: 'PUT', headers, body: content });
+        }
+        if (response.status === 404 && viaGatewayHost) {
+            const fallbackUrl = nameServiceAgentMdUrl(aid, gatewayUrl);
+            if (fallbackUrl && fallbackUrl !== url) {
+                response = await fetchWithTimeout(fallbackUrl, { method: 'PUT', headers, body: content });
+            }
+        }
         if (response.status === 404) {
             throw new NotFoundError(`agent.md endpoint not found for aid: ${aid}`);
         }
@@ -567,35 +818,36 @@ export class AgentMdManager {
         });
         return data;
     }
-    async _readStorage(logicalKey) {
+    async _readStorage(logicalKey, root = this.root) {
         const key = String(logicalKey ?? '').trim();
         if (!key)
             return null;
         const load = this._tokenStore?.loadAgentMdCache;
         if (typeof load === 'function') {
-            const record = await load.call(this._tokenStore, this.root, key);
+            const record = await load.call(this._tokenStore, root, key);
             if (record && Object.prototype.hasOwnProperty.call(record, 'content')) {
                 return String(record.content ?? '');
             }
             return null;
         }
-        return this._memoryStorage.has(key) ? String(this._memoryStorage.get(key) ?? '') : null;
+        const memoryKey = `${root}\u0000${key}`;
+        return this._memoryStorage.has(memoryKey) ? String(this._memoryStorage.get(memoryKey) ?? '') : null;
     }
-    async _writeStorage(logicalKey, content) {
+    async _writeStorage(logicalKey, content, root = this.root) {
         const key = String(logicalKey ?? '').trim();
         if (!key)
             return;
         const save = this._tokenStore?.upsertAgentMdCache;
         const text = String(content ?? '');
         if (typeof save === 'function') {
-            await save.call(this._tokenStore, this.root, key, {
+            await save.call(this._tokenStore, root, key, {
                 content: text,
                 local_etag: await AgentMdManager.contentEtag(text),
                 fetched_at: Date.now(),
             });
             return;
         }
-        this._memoryStorage.set(key, text);
+        this._memoryStorage.set(`${root}\u0000${key}`, text);
     }
     async _withLock(fn) {
         const previous = this._lock.catch(() => undefined);
@@ -624,17 +876,17 @@ export class AgentMdManager {
         }
         return record;
     }
-    async _writeRecordUnlocked(aid, record) {
+    async _writeRecordUnlocked(aid, record, root = this.root) {
         const payload = {};
         for (const [key, value] of Object.entries(record)) {
             if (key !== 'content' && value !== undefined && value !== null)
                 payload[key] = value;
         }
         payload.aid = this._safeAid(aid);
-        await this._writeStorage(this._metaKey(aid), `${JSON.stringify(payload, null, 2)}\n`);
+        await this._writeStorage(this._metaKey(aid), `${JSON.stringify(payload, null, 2)}\n`, root);
     }
-    async _readRecordUnlocked(aid) {
-        const raw = await this._readStorage(this._metaKey(aid));
+    async _readRecordUnlocked(aid, root = this.root) {
+        const raw = await this._readStorage(this._metaKey(aid), root);
         if (raw === null)
             return {};
         try {
@@ -676,15 +928,5 @@ export class AgentMdManager {
             this._fetchInflight.delete(target);
         }
     }
-    _refreshOwnerEtags(aid, record) {
-        if (aid !== this._ownerAid())
-            return;
-        const localEtag = String(record.local_etag ?? '').trim();
-        const remoteEtag = String(record.remote_etag ?? '').trim();
-        if (localEtag)
-            this._localAgentMdEtag = localEtag;
-        if (remoteEtag)
-            this._remoteAgentMdEtag = remoteEtag;
-    }
 }
 //# sourceMappingURL=agent-md.js.map