agentbnb 8.2.0 → 8.2.1

package/dist/{chunk-TBJ3FZKZ.js → chunk-7Q2XUXSA.js}

@@ -1,6 +1,6 @@
 import {
   insertCard
-} from "./chunk-O2OYBAVR.js";
+} from "./chunk-SRBVKO2V.js";
 import {
   CapabilityCardSchema
 } from "./chunk-WVY2W7AA.js";

package/dist/{chunk-LJM7FHPM.js → chunk-BZOJ7HBT.js}

@@ -1,6 +1,6 @@
 import {
   getFeedbackForProvider
-} from "./chunk-O2OYBAVR.js";
+} from "./chunk-SRBVKO2V.js";
 
 // src/feedback/reputation.ts
 var QUALITY_SCORES = {
@@ -49,7 +49,37 @@ function getReputationScore(db, agentId) {
 }
 
 // src/registry/matcher.ts
+var CACHE_MAX_ENTRIES = 100;
+var CACHE_TTL_MS = 3e4;
+var dbCaches = /* @__PURE__ */ new WeakMap();
+function getDbCache(db) {
+  let cache = dbCaches.get(db);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    dbCaches.set(db, cache);
+  }
+  return cache;
+}
+function cacheKey(query, filters) {
+  return `${query}|${filters.level ?? ""}|${filters.online ?? ""}|${(filters.apis_used ?? []).join(",")}|${filters.min_reputation ?? ""}`;
+}
+function evictCache(cache) {
+  const now = Date.now();
+  for (const [key, entry] of cache) {
+    if (entry.expiresAt <= now) cache.delete(key);
+  }
+  while (cache.size > CACHE_MAX_ENTRIES) {
+    const firstKey = cache.keys().next().value;
+    cache.delete(firstKey);
+  }
+}
 function searchCards(db, query, filters = {}) {
+  const cache = getDbCache(db);
+  const key = cacheKey(query, filters);
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.results;
+  }
   const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
   if (words.length === 0) return [];
   const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
@@ -87,6 +117,8 @@ function searchCards(db, query, filters = {}) {
   if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
     filtered = applyReputationFilter(db, filtered, filters.min_reputation);
   }
+  evictCache(cache);
+  cache.set(key, { results: filtered, expiresAt: Date.now() + CACHE_TTL_MS });
   return filtered;
 }
 function filterCards(db, filters) {

package/dist/{chunk-FTZTEHYG.js → chunk-DEWY7OQK.js}

@@ -1,6 +1,9 @@
 import {
   searchCards
-} from "./chunk-LJM7FHPM.js";
+} from "./chunk-BZOJ7HBT.js";
+import {
+  AgentBnBError
+} from "./chunk-WVY2W7AA.js";
 
 // src/registry/pricing.ts
 function getPricingStats(db, query) {
@@ -105,14 +108,137 @@ async function stopAnnouncement() {
   }
   const instance = bonjourInstance;
   bonjourInstance = null;
-  await new Promise((resolve) => {
+  await new Promise((resolve2) => {
     instance.unpublishAll(() => {
       instance.destroy();
-      resolve();
+      resolve2();
     });
   });
 }
 
+// src/runtime/resolve-self-cli.ts
+import { execFileSync } from "child_process";
+import { existsSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { basename, isAbsolute, join, resolve } from "path";
+function resolveSelfCli() {
+  const require2 = createRequire(import.meta.url);
+  return resolveSelfCliWithDeps({
+    argv1: process.argv[1],
+    cwd: process.cwd(),
+    platform: process.platform,
+    homeDir: homedir(),
+    envPath: process.env["PATH"],
+    exists: existsSync,
+    realpath: realpathSync,
+    runWhich: (pathEnv) => execFileSync("which", ["agentbnb"], {
+      encoding: "utf8",
+      env: { ...process.env, PATH: pathEnv }
+    }).trim(),
+    requireResolve: (id) => require2.resolve(id)
+  });
+}
+function resolveSelfCliWithDeps(deps) {
+  const tried = [];
+  const tryCandidate = (rawPath, label, requireCliShape = false) => {
+    if (!rawPath || rawPath.trim().length === 0) {
+      tried.push(`${label}: <empty>`);
+      return null;
+    }
+    const maybeAbsolute = isAbsolute(rawPath) ? rawPath : resolve(deps.cwd, rawPath);
+    tried.push(`${label}: ${maybeAbsolute}`);
+    if (!deps.exists(maybeAbsolute)) return null;
+    const resolvedPath = safeRealpath(deps.realpath, maybeAbsolute);
+    if (requireCliShape && !looksLikeAgentbnbCli(resolvedPath)) return null;
+    return resolvedPath;
+  };
+  const argvPath = tryCandidate(deps.argv1, "process.argv[1]", true);
+  if (argvPath) return argvPath;
+  const fullPathEnv = buildFullPathEnv(deps.envPath, deps.homeDir);
+  tried.push(`which agentbnb PATH=${fullPathEnv}`);
+  try {
+    const whichPath = tryCandidate(deps.runWhich(fullPathEnv), "which agentbnb");
+    if (whichPath) return whichPath;
+  } catch (err) {
+    tried.push(`which agentbnb failed: ${extractErrorMessage(err)}`);
+  }
+  const npmGlobalCandidates = ["/usr/local/bin/agentbnb", "/opt/homebrew/bin/agentbnb"];
+  for (const candidate of npmGlobalCandidates) {
+    const resolvedPath = tryCandidate(candidate, "npm-global");
+    if (resolvedPath) return resolvedPath;
+  }
+  const pnpmCandidates = getPnpmGlobalCandidates(deps.platform, deps.homeDir);
+  for (const candidate of pnpmCandidates) {
+    const resolvedPath = tryCandidate(candidate, "pnpm-global");
+    if (resolvedPath) return resolvedPath;
+  }
+  try {
+    const requireResolved = deps.requireResolve("agentbnb/dist/cli/index.js");
+    const resolvedPath = tryCandidate(requireResolved, "require.resolve(agentbnb/dist/cli/index.js)");
+    if (resolvedPath) return resolvedPath;
+  } catch (err) {
+    tried.push(`require.resolve(agentbnb/dist/cli/index.js) failed: ${extractErrorMessage(err)}`);
+  }
+  throw new AgentBnBError(
+    `Unable to resolve absolute path to agentbnb CLI.
+Paths tried:
+${tried.map((item) => `- ${item}`).join("\n")}`,
+    "CLI_ENTRY_NOT_FOUND"
+  );
+}
+function buildFullPathEnv(pathEnv, homeDir) {
+  const values = /* @__PURE__ */ new Set();
+  for (const item of (pathEnv ?? "").split(":")) {
+    if (item.trim()) values.add(item.trim());
+  }
+  for (const extra of [
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+    join(homeDir, ".local", "bin"),
+    join(homeDir, "Library", "pnpm"),
+    join(homeDir, ".local", "share", "pnpm")
+  ]) {
+    values.add(extra);
+  }
+  return [...values].join(":");
+}
+function safeRealpath(realpath, path) {
+  try {
+    return realpath(path);
+  } catch {
+    return path;
+  }
+}
+function getPnpmGlobalCandidates(platform, homeDir) {
+  const candidates = /* @__PURE__ */ new Set();
+  if (platform === "darwin") {
+    candidates.add(join(homeDir, "Library", "pnpm", "agentbnb"));
+  }
+  if (platform === "linux") {
+    candidates.add(join(homeDir, ".local", "share", "pnpm", "agentbnb"));
+  }
+  candidates.add(join(homeDir, "Library", "pnpm", "agentbnb"));
+  candidates.add(join(homeDir, ".local", "share", "pnpm", "agentbnb"));
+  return [...candidates];
+}
+function looksLikeAgentbnbCli(path) {
+  const normalized = path.replace(/\\/g, "/").toLowerCase();
+  const fileName = basename(normalized);
+  if (fileName === "agentbnb" || fileName === "agentbnb.cmd" || fileName === "agentbnb.exe") {
+    return true;
+  }
+  return normalized.includes("/agentbnb/dist/cli/index.") || normalized.endsWith("/dist/cli/index.js") || normalized.endsWith("/dist/cli/index.mjs") || normalized.endsWith("/dist/cli/index.cjs");
+}
+function extractErrorMessage(err) {
+  if (err instanceof Error && err.message) return err.message;
+  return String(err);
+}
+
 // src/cli/onboarding.ts
 import { randomUUID } from "crypto";
 import { createConnection } from "net";
@@ -234,20 +360,20 @@ function detectApiKeys(knownKeys) {
   return knownKeys.filter((key) => key in process.env);
 }
 async function isPortOpen(port, host = "127.0.0.1", timeoutMs = 300) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const socket = createConnection({ port, host });
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve(false);
+      resolve2(false);
     }, timeoutMs);
     socket.on("connect", () => {
       clearTimeout(timer);
       socket.destroy();
-      resolve(true);
+      resolve2(true);
     });
     socket.on("error", () => {
       clearTimeout(timer);
-      resolve(false);
+      resolve2(false);
     });
   });
 }
@@ -290,5 +416,6 @@ export {
   KNOWN_API_KEYS,
   detectApiKeys,
   detectOpenPorts,
-  buildDraftCard
+  buildDraftCard,
+  resolveSelfCli
 };

package/dist/{chunk-CUONY5TO.js → chunk-EJKW57ZV.js}

@@ -35,7 +35,25 @@ function loadKeyPair(configDir) {
   };
 }
 function canonicalJson(data) {
-  return JSON.stringify(data, Object.keys(data).sort());
+  return JSON.stringify(sortForCanonicalJson(data));
+}
+function sortForCanonicalJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortForCanonicalJson(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      const input = value;
+      const output = {};
+      const sortedKeys = Object.keys(input).sort();
+      for (const key of sortedKeys) {
+        output[key] = sortForCanonicalJson(input[key]);
+      }
+      return output;
+    }
+  }
+  return value;
 }
 function signEscrowReceipt(data, privateKey) {
   const message = Buffer.from(canonicalJson(data), "utf-8");

package/dist/chunk-EZVOG7QS.js

@@ -0,0 +1,161 @@
+import {
+  signEscrowReceipt
+} from "./chunk-EJKW57ZV.js";
+import {
+  AgentBnBError
+} from "./chunk-WVY2W7AA.js";
+
+// src/gateway/client.ts
+import { randomUUID } from "crypto";
+import { Agent } from "undici";
+var gatewayAgent = new Agent({
+  keepAliveTimeout: 3e4,
+  keepAliveMaxTimeout: 6e4,
+  connections: 10,
+  pipelining: 1
+});
+async function requestCapability(opts) {
+  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
+  const id = randomUUID();
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    method: "capability.execute",
+    params: {
+      card_id: cardId,
+      ...params,
+      ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
+    }
+  };
+  const headers = { "Content-Type": "application/json" };
+  if (identity) {
+    const signature = signEscrowReceipt(payload, identity.privateKey);
+    headers["X-Agent-Id"] = identity.agentId;
+    headers["X-Agent-Public-Key"] = identity.publicKey;
+    headers["X-Agent-Signature"] = signature;
+  } else if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+      // undici dispatcher for connection pooling (Node.js 20+)
+      dispatcher: gatewayAgent
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  if (body.error) {
+    throw new AgentBnBError(body.error.message, `RPC_ERROR_${body.error.code}`);
+  }
+  return body.result;
+}
+async function requestCapabilityBatch(gatewayUrl, token, items, opts = {}) {
+  if (items.length === 0) return /* @__PURE__ */ new Map();
+  if (items.length === 1) {
+    const item = items[0];
+    const result = await requestCapability({
+      gatewayUrl,
+      token,
+      cardId: item.cardId,
+      params: item.params,
+      escrowReceipt: item.escrowReceipt,
+      timeoutMs: opts.timeoutMs,
+      identity: opts.identity
+    });
+    return /* @__PURE__ */ new Map([[item.id, result]]);
+  }
+  const { timeoutMs = 3e5, identity } = opts;
+  const batchPayload = items.map((item) => ({
+    jsonrpc: "2.0",
+    id: item.id,
+    method: "capability.execute",
+    params: {
+      card_id: item.cardId,
+      ...item.params,
+      ...item.escrowReceipt ? { escrow_receipt: item.escrowReceipt } : {}
+    }
+  }));
+  const headers = { "Content-Type": "application/json" };
+  if (identity) {
+    const signature = signEscrowReceipt(batchPayload, identity.privateKey);
+    headers["X-Agent-Id"] = identity.agentId;
+    headers["X-Agent-Public-Key"] = identity.publicKey;
+    headers["X-Agent-Signature"] = signature;
+  } else if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(batchPayload),
+      signal: controller.signal,
+      dispatcher: gatewayAgent
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Batch request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  const results = /* @__PURE__ */ new Map();
+  for (const resp of body) {
+    if (resp.error) {
+      results.set(resp.id, new AgentBnBError(resp.error.message, `RPC_ERROR_${resp.error.code}`));
+    } else {
+      results.set(resp.id, resp.result);
+    }
+  }
+  return results;
+}
+async function requestViaRelay(relay, opts) {
+  try {
+    return await relay.request({
+      targetOwner: opts.targetOwner,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      requester: opts.requester,
+      escrowReceipt: opts.escrowReceipt,
+      timeoutMs: opts.timeoutMs
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("timeout")) {
+      throw new AgentBnBError(message, "TIMEOUT");
+    }
+    if (message.includes("offline")) {
+      throw new AgentBnBError(message, "AGENT_OFFLINE");
+    }
+    throw new AgentBnBError(message, "RELAY_ERROR");
+  }
+}
+
+export {
+  requestCapability,
+  requestCapabilityBatch,
+  requestViaRelay
+};