@agentmesh-p2p/sdk 0.0.0-stage → 0.1.0

package/dist/sync.d.ts

@@ -0,0 +1,41 @@
+import { type Timestamp } from "@bufbuild/protobuf/wkt";
+import { MeshEvent_Type, type MeshEvent } from "./gen/agentmesh_pb.ts";
+/** The GossipSub topic the control plane publishes mesh events on (api.GossipEvents). */
+export declare const GOSSIP_EVENTS_TOPIC = "/mesh/events/v1";
+/** How far an event's timestamp may be from now; older or later ones are ignored. */
+export declare const EVENT_FRESHNESS_MS: number;
+/**
+ * The peers the control plane has banned, with when each ban was learned.
+ * A ban recorded at or after the instant a /info answer was requested is
+ * kept when that answer omits it: the answer predates the ban and cannot
+ * speak to it.
+ */
+export declare class BanSet {
+    #private;
+    has(peerId: string): boolean;
+    get size(): number;
+    peers(): string[];
+    /** Records a ban; returns false when the ban was already known. */
+    add(peerId: string, atMs: number): boolean;
+    /**
+     * Makes the set match the control plane's ban set as of fetchedAt.
+     * Returns the peers newly banned and the peers whose ban was lifted.
+     */
+    reconcile(bannedPeerIds: string[], fetchedAt: Date): {
+        banned: string[];
+        unbanned: string[];
+    };
+}
+/** A MeshEvent that verified: signed by a trusted key and carrying a fresh event_time. */
+/** A MeshEvent that verified: signed by a trusted key, carrying a fresh event_time, its peer id in canonical form. */
+export type VerifiedMeshEvent = MeshEvent & {
+    eventTime: Timestamp;
+};
+/**
+ * Verifies a MeshEvent as agentmesh-node's verifyEvent does: the signature covers
+ * the deterministic encoding of the event with the signature cleared, under
+ * any trusted control plane key. Returns the event, or undefined when it
+ * does not verify, is not fresh, or bans something that is not a peer ID.
+ */
+export declare function verifyMeshEvent(data: Uint8Array, trustedKeys: Uint8Array[], now?: Date): VerifiedMeshEvent | undefined;
+export { MeshEvent_Type };

package/dist/sync.js

@@ -0,0 +1,111 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// What a member keeps in step with the control plane while it runs, as
+// agentmesh-node's controlplane_sync.go: the ban set, reconciled from /info, and
+// the gossip events that bring the next pull forward.
+import { fromBinary, toBinary } from "@bufbuild/protobuf";
+import { timestampMs } from "@bufbuild/protobuf/wkt";
+import { canonicalPeerId, verifyEd25519 } from "./identity.js";
+import { MeshEvent_Type, MeshEventSchema } from "./gen/agentmesh_pb.js";
+/** The GossipSub topic the control plane publishes mesh events on (api.GossipEvents). */
+export const GOSSIP_EVENTS_TOPIC = "/mesh/events/v1";
+/** How far an event's timestamp may be from now; older or later ones are ignored. */
+export const EVENT_FRESHNESS_MS = 5 * 60 * 1000;
+/**
+ * The peers the control plane has banned, with when each ban was learned.
+ * A ban recorded at or after the instant a /info answer was requested is
+ * kept when that answer omits it: the answer predates the ban and cannot
+ * speak to it.
+ */
+export class BanSet {
+    #bannedAt = new Map();
+    has(peerId) {
+        return this.#bannedAt.has(peerId);
+    }
+    get size() {
+        return this.#bannedAt.size;
+    }
+    peers() {
+        return [...this.#bannedAt.keys()].sort();
+    }
+    /** Records a ban; returns false when the ban was already known. */
+    add(peerId, atMs) {
+        if (this.#bannedAt.has(peerId)) {
+            return false;
+        }
+        this.#bannedAt.set(peerId, atMs);
+        return true;
+    }
+    /**
+     * Makes the set match the control plane's ban set as of fetchedAt.
+     * Returns the peers newly banned and the peers whose ban was lifted.
+     */
+    reconcile(bannedPeerIds, fetchedAt) {
+        const fetchedAtMs = fetchedAt.getTime();
+        const current = new Set(bannedPeerIds);
+        const unbanned = [];
+        for (const [peerId, at] of this.#bannedAt) {
+            if (current.has(peerId) || at >= fetchedAtMs) {
+                continue;
+            }
+            this.#bannedAt.delete(peerId);
+            unbanned.push(peerId);
+        }
+        const banned = [];
+        for (const peerId of current) {
+            if (this.add(peerId, fetchedAtMs)) {
+                banned.push(peerId);
+            }
+        }
+        return { banned, unbanned };
+    }
+}
+/**
+ * Verifies a MeshEvent as agentmesh-node's verifyEvent does: the signature covers
+ * the deterministic encoding of the event with the signature cleared, under
+ * any trusted control plane key. Returns the event, or undefined when it
+ * does not verify, is not fresh, or bans something that is not a peer ID.
+ */
+export function verifyMeshEvent(data, trustedKeys, now = new Date()) {
+    let event;
+    try {
+        event = fromBinary(MeshEventSchema, data);
+    }
+    catch {
+        return undefined;
+    }
+    const signature = event.signature;
+    const unsigned = toBinary(MeshEventSchema, { ...event, signature: new Uint8Array() });
+    if (!trustedKeys.some((key) => verifyEd25519(key, unsigned, signature))) {
+        return undefined;
+    }
+    if (event.eventTime === undefined) {
+        return undefined;
+    }
+    const skew = Math.abs(now.getTime() - timestampMs(event.eventTime));
+    if (skew > EVENT_FRESHNESS_MS) {
+        return undefined;
+    }
+    if (event.type === MeshEvent_Type.BANNED) {
+        // Canonicalized after the signature check, which covers the bytes as sent.
+        try {
+            return { ...event, peerId: canonicalPeerId(event.peerId) };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return event;
+}
+export { MeshEvent_Type };

package/dist/tar.d.ts

@@ -0,0 +1,25 @@
+import { type MessageInitShape } from "@bufbuild/protobuf";
+import { TaskAuthorizationRuleSchema, type TaskAuthorizationRule, type TaskRule } from "./gen/agentmesh_pb.ts";
+export declare function validateServicePattern(s: string): void;
+export declare function validateHTTPGrantPath(p: string): void;
+export declare function validateTaskRule(r: TaskRule): void;
+export declare function validateTaskAuthorizationRule(rule: TaskAuthorizationRule, requireNonEmptyRules: boolean): void;
+export declare function encodeTARBlockPayload(ruleInput: MessageInitShape<typeof TaskAuthorizationRuleSchema>): string;
+export declare function encodeTARBlockFact(ruleInput: MessageInitShape<typeof TaskAuthorizationRuleSchema>): string;
+export declare function decodeTARBlockPayload(b64Payload: string): TaskAuthorizationRule;
+export declare function parseTARBlockSource(blockSource: string): TaskAuthorizationRule;
+export declare function effectiveTARExpiration(authorityExpiration: Date, rules: TaskAuthorizationRule[]): Date;
+export interface TaskRequestContext {
+    serviceType: string;
+    serviceName: string;
+    hasHttp: boolean;
+    method: string;
+    path: string;
+    mcpTool: string;
+    allowMCPStreamInit: boolean;
+}
+export declare function matchServicePattern(pattern: string, serviceType: string, serviceName: string): boolean;
+export declare function isSafeRequestHTTPPath(reqPath: string): boolean;
+export declare function matchHTTPPath(pattern: string, reqPath: string): boolean;
+export declare function matchTaskRule(rule: TaskRule, req: TaskRequestContext): boolean;
+export declare function evaluateTaskRules(chain: TaskAuthorizationRule[], req: TaskRequestContext, now: Date): void;

package/dist/tar.js

@@ -0,0 +1,406 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { timestampDate } from "@bufbuild/protobuf/wkt";
+import { fromBase64Url, toBase64Url } from "./bytes.js";
+import { isServiceType } from "./discovery.js";
+import { BASELINE_DATALOG } from "./gen/datalog.js";
+import { TaskAuthorizationRuleSchema } from "./gen/agentmesh_pb.js";
+const TAR_BLOCK_SOURCE_RE = new RegExp(BASELINE_DATALOG.tar_block_source_pattern);
+const HTTP_METHOD_RE = new RegExp(BASELINE_DATALOG.http_method_syntax);
+const DNS_NAME_RE = /^(?:(?:\*\.)?[a-zA-Z0-9_](?:[a-zA-Z0-9_-]{0,61}[a-zA-Z0-9_])?(?:\.[a-zA-Z0-9_](?:[a-zA-Z0-9_-]{0,61}[a-zA-Z0-9_])?)*(?:\.\*)?|\*)$/;
+const TEXT_ENCODER = new TextEncoder();
+function utf8Length(s) {
+    return TEXT_ENCODER.encode(s).length;
+}
+function isPrintableASCII(s) {
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code < 0x20 || code > 0x7e) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasASCIIControl(s) {
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code < 0x20 || code === 0x7f) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasEncodedPathTraversal(p) {
+    for (let i = 0; i < p.length; i++) {
+        const code = p.charCodeAt(i);
+        if (code < 0x20 || code === 0x7f || p[i] === "\\" || p[i] === '"') {
+            return true;
+        }
+        if (p[i] === "%" && i + 2 < p.length) {
+            const hex = p.slice(i + 1, i + 3).toLowerCase();
+            if (hex === "2e" || hex === "2f" || hex === "5c" || hex === "00") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function countChar(s, ch) {
+    let count = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === ch) {
+            count++;
+        }
+    }
+    return count;
+}
+export function validateServicePattern(s) {
+    if (s === "") {
+        throw new Error("allowed_services entry cannot be empty");
+    }
+    if (utf8Length(s) > BASELINE_DATALOG.max_tar_name_length) {
+        throw new Error(`allowed_services entry "${s}" exceeds max length ${BASELINE_DATALOG.max_tar_name_length}`);
+    }
+    if (s === "*") {
+        return;
+    }
+    const idx = s.indexOf("://");
+    if (idx <= 0) {
+        throw new Error(`invalid service format: ${s}`);
+    }
+    const serviceType = s.slice(0, idx);
+    const target = s.slice(idx + 3);
+    if (!isServiceType(serviceType) && serviceType !== "http" && serviceType !== "system") {
+        throw new Error(`invalid service type "${serviceType}" in ${s}`);
+    }
+    if (target === "" || target.includes("/") || target.includes("?") || target.includes("#") || target.includes("@") || countChar(target, "*") > 1) {
+        throw new Error(`invalid service target "${target}" in ${s}`);
+    }
+    if (target !== "*" && !DNS_NAME_RE.test(target)) {
+        throw new Error(`invalid service format "${s}": "${target}" is not a valid DNS name`);
+    }
+    if (serviceType === "egress" && target !== target.toLowerCase()) {
+        throw new Error(`invalid egress service "${s}": hostname must be lowercase`);
+    }
+    if (target.includes("*") && target !== "*") {
+        const validSuffix = target.startsWith("*.") && !target.endsWith(".*") && target.slice(2).length > 0;
+        const validPrefix = target.endsWith(".*") && !target.startsWith("*.") && target.slice(0, -2).length > 0;
+        if (!validSuffix && !validPrefix) {
+            throw new Error(`wildcard in "${s}" must be '*', '*.<suffix>' or '<prefix>.*'`);
+        }
+    }
+}
+export function validateHTTPGrantPath(p) {
+    if (utf8Length(p) > BASELINE_DATALOG.max_tar_name_length) {
+        throw new Error(`path ${JSON.stringify(p)} exceeds max length ${BASELINE_DATALOG.max_tar_name_length}`);
+    }
+    if (!p.startsWith("/")) {
+        throw new Error(`path ${JSON.stringify(p)} must start with '/'`);
+    }
+    if (p.includes("?") || p.includes("#")) {
+        throw new Error(`path ${JSON.stringify(p)} must not contain '?' or '#'`);
+    }
+    if (hasEncodedPathTraversal(p)) {
+        throw new Error(`path ${JSON.stringify(p)} must not contain encoded traversal sequences or control characters`);
+    }
+    const stars = countChar(p, "*");
+    if (stars > 1 || (stars === 1 && !p.endsWith("*"))) {
+        throw new Error(`path ${JSON.stringify(p)}: '*' is only valid once, at the end`);
+    }
+    for (const seg of p.replace(/\*$/, "").split("/")) {
+        if (seg === "." || seg === "..") {
+            throw new Error(`path ${JSON.stringify(p)} must not contain '.' or '..' segments`);
+        }
+    }
+}
+function validateTARStringList(fieldName, values, checkElem) {
+    if (values.length > BASELINE_DATALOG.max_entries_per_tar_list) {
+        throw new Error(`TaskRule.${fieldName} has ${values.length} entries; maximum is ${BASELINE_DATALOG.max_entries_per_tar_list}`);
+    }
+    for (const [i, val] of values.entries()) {
+        try {
+            checkElem(val);
+        }
+        catch (err) {
+            throw new Error(`TaskRule.${fieldName}[${i}]: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+export function validateTaskRule(r) {
+    if (utf8Length(r.description) > BASELINE_DATALOG.max_tar_description_length) {
+        throw new Error(`TaskRule.description exceeds ${BASELINE_DATALOG.max_tar_description_length} bytes`);
+    }
+    if (hasASCIIControl(r.description)) {
+        throw new Error("TaskRule.description must not contain control characters");
+    }
+    if (r.allowedServices.length === 0) {
+        throw new Error("TaskRule.allowed_services must not be empty");
+    }
+    validateTARStringList("allowed_services", r.allowedServices, validateServicePattern);
+    validateTARStringList("allowed_resources", r.allowedResources, (res) => {
+        if (res === "") {
+            throw new Error("resource must not be empty");
+        }
+        if (utf8Length(res) > BASELINE_DATALOG.max_tar_resource_length) {
+            throw new Error(`resource exceeds ${BASELINE_DATALOG.max_tar_resource_length} bytes`);
+        }
+        if (hasASCIIControl(res)) {
+            throw new Error("resource must not contain control characters");
+        }
+    });
+    if (r.operation !== undefined) {
+        const op = r.operation;
+        validateTARStringList("operation.allowed_tools", op.allowedTools, (tool) => {
+            if (tool === "" ||
+                utf8Length(tool) > BASELINE_DATALOG.max_tar_name_length ||
+                /[/\?# \t\r\n]/.test(tool) ||
+                !isPrintableASCII(tool)) {
+                throw new Error(`invalid tool name ${JSON.stringify(tool)} in allowed_tools`);
+            }
+        });
+        validateTARStringList("operation.allowed_methods", op.allowedMethods, (m) => {
+            if (!HTTP_METHOD_RE.test(m)) {
+                throw new Error(`invalid HTTP method ${JSON.stringify(m)}`);
+            }
+        });
+        validateTARStringList("operation.allowed_paths", op.allowedPaths, validateHTTPGrantPath);
+        validateTARStringList("operation.allowed_permissions", op.allowedPermissions, (perm) => {
+            if (perm === "" ||
+                utf8Length(perm) > BASELINE_DATALOG.max_tar_name_length ||
+                /[ \t\r\n]/.test(perm) ||
+                !isPrintableASCII(perm)) {
+                throw new Error(`invalid permission ${JSON.stringify(perm)} in allowed_permissions`);
+            }
+        });
+    }
+}
+export function validateTaskAuthorizationRule(rule, requireNonEmptyRules) {
+    if (utf8Length(rule.name) > BASELINE_DATALOG.max_tar_name_length) {
+        throw new Error(`TaskAuthorizationRule.name exceeds ${BASELINE_DATALOG.max_tar_name_length} bytes`);
+    }
+    if (!isPrintableASCII(rule.name)) {
+        throw new Error("TaskAuthorizationRule.name must contain only printable ASCII characters");
+    }
+    if (utf8Length(rule.displayName) > BASELINE_DATALOG.max_tar_description_length) {
+        throw new Error(`TaskAuthorizationRule.display_name exceeds ${BASELINE_DATALOG.max_tar_description_length} bytes`);
+    }
+    if (hasASCIIControl(rule.displayName)) {
+        throw new Error("TaskAuthorizationRule.display_name must not contain control characters");
+    }
+    if (rule.expireTime !== undefined) {
+        const { seconds, nanos } = rule.expireTime;
+        if (nanos < 0 || nanos >= 1_000_000_000) {
+            throw new Error("TaskAuthorizationRule.expire_time has invalid nanos");
+        }
+        if (seconds <= 0n || seconds > 253402300799n) {
+            throw new Error("TaskAuthorizationRule.expire_time must be after the Unix epoch");
+        }
+    }
+    if (requireNonEmptyRules && rule.rules.length === 0) {
+        throw new Error("TaskAuthorizationRule.rules must not be empty");
+    }
+    if (rule.rules.length > BASELINE_DATALOG.max_rules_per_tar) {
+        throw new Error(`TaskAuthorizationRule.rules has ${rule.rules.length} entries; maximum is ${BASELINE_DATALOG.max_rules_per_tar}`);
+    }
+    for (const [i, r] of rule.rules.entries()) {
+        try {
+            validateTaskRule(r);
+        }
+        catch (err) {
+            throw new Error(`TaskAuthorizationRule.rules[${i}]: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+function hasUnknownWireFields(rule) {
+    const unknownOf = (msg) => {
+        if (typeof msg !== "object" || msg === null) {
+            return false;
+        }
+        const unk = msg.$unknown;
+        return Array.isArray(unk) && unk.length > 0;
+    };
+    if (unknownOf(rule) || unknownOf(rule.expireTime)) {
+        return true;
+    }
+    for (const r of rule.rules) {
+        if (unknownOf(r) || unknownOf(r.operation)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function encodeTARBlockPayload(ruleInput) {
+    const rule = create(TaskAuthorizationRuleSchema, ruleInput);
+    validateTaskAuthorizationRule(rule, true);
+    const raw = toBinary(TaskAuthorizationRuleSchema, rule);
+    if (raw.length > BASELINE_DATALOG.max_tar_bytes) {
+        throw new Error(`TaskAuthorizationRule serialized size ${raw.length} exceeds ${BASELINE_DATALOG.max_tar_bytes} bytes`);
+    }
+    return toBase64Url(raw);
+}
+export function encodeTARBlockFact(ruleInput) {
+    const b64 = encodeTARBlockPayload(ruleInput);
+    return `${BASELINE_DATALOG.fact_tar_block}(${JSON.stringify(b64)})`;
+}
+export function decodeTARBlockPayload(b64Payload) {
+    if (b64Payload === "") {
+        throw new Error("empty tar_block payload");
+    }
+    let raw;
+    try {
+        raw = fromBase64Url(b64Payload);
+    }
+    catch (err) {
+        throw new Error(`invalid base64url in tar_block: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (toBase64Url(raw) !== b64Payload) {
+        throw new Error("non-canonical base64url in tar_block");
+    }
+    if (raw.length === 0 || raw.length > BASELINE_DATALOG.max_tar_bytes) {
+        throw new Error(`tar_block decoded payload size ${raw.length} out of bounds [1, ${BASELINE_DATALOG.max_tar_bytes}]`);
+    }
+    let rule;
+    try {
+        rule = fromBinary(TaskAuthorizationRuleSchema, raw);
+    }
+    catch (err) {
+        throw new Error(`invalid TaskAuthorizationRule protobuf in tar_block: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (hasUnknownWireFields(rule)) {
+        throw new Error("TaskAuthorizationRule in tar_block contains unknown protobuf wire fields");
+    }
+    validateTaskAuthorizationRule(rule, false);
+    return rule;
+}
+export function parseTARBlockSource(blockSource) {
+    const m = TAR_BLOCK_SOURCE_RE.exec(blockSource.trim());
+    if (!m || m[1] === undefined) {
+        throw new Error(`non-authority block does not match single tar_block("<base64url>") grammar`);
+    }
+    return decodeTARBlockPayload(m[1]);
+}
+export function effectiveTARExpiration(authorityExpiration, rules) {
+    let effective = authorityExpiration;
+    for (const r of rules) {
+        if (r.expireTime !== undefined) {
+            const exp = timestampDate(r.expireTime);
+            if (exp.getTime() < effective.getTime()) {
+                effective = exp;
+            }
+        }
+    }
+    return effective;
+}
+export function matchServicePattern(pattern, serviceType, serviceName) {
+    if (serviceType === "" || serviceName === "" || pattern === "") {
+        return false;
+    }
+    if (pattern === "*") {
+        return true;
+    }
+    const idx = pattern.indexOf("://");
+    if (idx <= 0) {
+        return false;
+    }
+    const patType = pattern.slice(0, idx);
+    const patTarget = pattern.slice(idx + 3);
+    if (patType !== serviceType || patTarget === "") {
+        return false;
+    }
+    if (patTarget === "*") {
+        return true;
+    }
+    if (patTarget.startsWith("*.") && !patTarget.endsWith(".*")) {
+        return serviceName.endsWith(patTarget.slice(1));
+    }
+    if (patTarget.endsWith(".*") && !patTarget.startsWith("*.")) {
+        return serviceName.startsWith(patTarget.slice(0, -1));
+    }
+    return serviceName === patTarget;
+}
+export function isSafeRequestHTTPPath(reqPath) {
+    if (!reqPath.startsWith("/") || reqPath.includes("?") || reqPath.includes("#") || hasEncodedPathTraversal(reqPath)) {
+        return false;
+    }
+    for (const seg of reqPath.split("/")) {
+        if (seg === "." || seg === "..") {
+            return false;
+        }
+    }
+    return true;
+}
+export function matchHTTPPath(pattern, reqPath) {
+    if (pattern === "" || !isSafeRequestHTTPPath(reqPath)) {
+        return false;
+    }
+    if (pattern.endsWith("*")) {
+        return reqPath.startsWith(pattern.slice(0, -1));
+    }
+    return reqPath === pattern;
+}
+export function matchTaskRule(rule, req) {
+    if (rule.allowedServices.length === 0) {
+        return false;
+    }
+    if (!rule.allowedServices.some((pat) => matchServicePattern(pat, req.serviceType, req.serviceName))) {
+        return false;
+    }
+    // Note: rule.allowedResources and operation.allowedPermissions are opaque to
+    // the wire PEP and consumed by CloudTokenExchanger at egress.
+    if (rule.operation !== undefined) {
+        const op = rule.operation;
+        if (op.allowedTools.length > 0) {
+            if (req.serviceType !== "mcp") {
+                return false;
+            }
+            if (req.mcpTool === "") {
+                if (!req.allowMCPStreamInit) {
+                    return false;
+                }
+            }
+            else if (!op.allowedTools.includes(req.mcpTool)) {
+                return false;
+            }
+        }
+        if (op.allowedMethods.length > 0 || op.allowedPaths.length > 0) {
+            if (!req.hasHttp || req.method === "" || req.method === "CONNECT" || !isSafeRequestHTTPPath(req.path)) {
+                return false;
+            }
+            if (op.allowedMethods.length > 0 && !op.allowedMethods.includes(req.method)) {
+                return false;
+            }
+            if (op.allowedPaths.length > 0 && !op.allowedPaths.some((pat) => matchHTTPPath(pat, req.path))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function evaluateTaskRules(chain, req, now) {
+    for (const [i, tar] of chain.entries()) {
+        if (tar.expireTime !== undefined) {
+            const exp = timestampDate(tar.expireTime);
+            if (now.getTime() > exp.getTime()) {
+                throw new Error(`TaskAuthorizationRule block ${i + 1} (${JSON.stringify(tar.name)}) is expired`);
+            }
+        }
+        if (tar.rules.length === 0) {
+            throw new Error(`TaskAuthorizationRule block ${i + 1} (${JSON.stringify(tar.name)}) has no rules (fail-closed)`);
+        }
+        if (!tar.rules.some((rule) => matchTaskRule(rule, req))) {
+            throw new Error(`request denied by TaskAuthorizationRule block ${i + 1} (${JSON.stringify(tar.name)})`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@agentmesh-p2p/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Native SDK for joining an Agent Mesh from a Node.js agent process or a browser page",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/google/agentmesh.git",
+    "directory": "sdk/js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "browser": {
+    "./dist/platform/ingress.js": "./dist/platform/ingress.browser.js",
+    "./dist/platform/state.js": "./dist/platform/state.browser.js",
+    "./dist/platform/transports.js": "./dist/platform/transports.browser.js",
+    "./dist/platform/wasm.js": "./dist/platform/wasm.browser.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "examples": "tsc -p tsconfig.examples.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "pretest": "tsc -p tsconfig.test.json",
+    "test": "node --test 'build/**/*.test.js'",
+    "bundle:browser": "node scripts/bundle-browser.mjs"
+  },
+  "dependencies": {
+    "@biscuit-auth/biscuit-wasm": "^0.6.0",
+    "@bufbuild/protobuf": "^2.16.0",
+    "@chainsafe/libp2p-noise": "^17.0.0",
+    "@chainsafe/libp2p-yamux": "^8.0.1",
+    "@libp2p/circuit-relay-v2": "^4.2.13",
+    "@libp2p/crypto": "^5.1.23",
+    "@libp2p/gossipsub": "^17.1.2",
+    "@libp2p/identify": "^4.1.14",
+    "@libp2p/interface": "^3.3.0",
+    "@libp2p/peer-id": "^6.0.15",
+    "@libp2p/ping": "^3.1.13",
+    "@libp2p/tcp": "^11.0.28",
+    "@libp2p/tls": "^3.1.10",
+    "@libp2p/utils": "^7.4.1",
+    "@libp2p/websockets": "^10.1.21",
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@multiformats/multiaddr": "^13.0.3",
+    "@noble/curves": "^2.0.1",
+    "libp2p": "^3.3.11",
+    "multiformats": "^14.0.5",
+    "uint8arrays": "^6.1.1",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@a2a-js/sdk": "^1.3.0",
+    "@bufbuild/protoc-gen-es": "^2.16.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.6.4",
+    "esbuild": "^0.28.2",
+    "express": "^5.2.1",
+    "typescript": "^7.0.2"
+  }
+}