agentbnb 3.1.6 → 4.0.1

package/dist/{chunk-IZZ4FP45.js → chunk-6K5WUVF3.js}

@@ -1,16 +1,22 @@
+import {
+  fetchRemoteCards,
+  searchCards
+} from "./chunk-QJEOCKVF.js";
+import {
+  requestCapability
+} from "./chunk-KJG2UJV5.js";
 import {
   findPeer
-} from "./chunk-BEI5MTNZ.js";
+} from "./chunk-5AH3CMOX.js";
 import {
   getBalance,
   holdEscrow,
   releaseEscrow,
-  settleEscrow,
-  signEscrowReceipt
-} from "./chunk-QHQPXO67.js";
+  settleEscrow
+} from "./chunk-XQHN6ITI.js";
 import {
   AgentBnBError
-} from "./chunk-XA63SD4T.js";
+} from "./chunk-FNKBHBYK.js";
 
 // src/autonomy/tiers.ts
 import { randomUUID } from "crypto";
@@ -93,116 +99,10 @@ var BudgetManager = class {
   }
 };
 
-// src/registry/matcher.ts
-function searchCards(db, query, filters = {}) {
-  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 ");
-  const conditions = [];
-  const params = [ftsQuery];
-  if (filters.level !== void 0) {
-    conditions.push(`json_extract(cc.data, '$.level') = ?`);
-    params.push(filters.level);
-  }
-  if (filters.online !== void 0) {
-    conditions.push(`json_extract(cc.data, '$.availability.online') = ?`);
-    params.push(filters.online ? 1 : 0);
-  }
-  const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
-  const sql = `
-    SELECT cc.data
-    FROM capability_cards cc
-    JOIN cards_fts ON cc.rowid = cards_fts.rowid
-    WHERE cards_fts MATCH ?
-      ${whereClause}
-    ORDER BY bm25(cards_fts)
-    LIMIT 50
-  `;
-  const stmt = db.prepare(sql);
-  const rows = stmt.all(...params);
-  const results = rows.map((row) => JSON.parse(row.data));
-  if (filters.apis_used && filters.apis_used.length > 0) {
-    const requiredApis = filters.apis_used;
-    return results.filter((card) => {
-      const cardApis = card.metadata?.apis_used ?? [];
-      return requiredApis.every((api) => cardApis.includes(api));
-    });
-  }
-  return results;
-}
-function filterCards(db, filters) {
-  const conditions = [];
-  const params = [];
-  if (filters.level !== void 0) {
-    conditions.push(`json_extract(data, '$.level') = ?`);
-    params.push(filters.level);
-  }
-  if (filters.online !== void 0) {
-    conditions.push(`json_extract(data, '$.availability.online') = ?`);
-    params.push(filters.online ? 1 : 0);
-  }
-  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const sql = `SELECT data FROM capability_cards ${whereClause}`;
-  const stmt = db.prepare(sql);
-  const rows = stmt.all(...params);
-  return rows.map((row) => JSON.parse(row.data));
-}
-
-// src/gateway/client.ts
-import { randomUUID as randomUUID2 } from "crypto";
-async function requestCapability(opts) {
-  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e4, escrowReceipt, identity } = opts;
-  const id = randomUUID2();
-  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
-    });
-  } 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;
-}
-
 // src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function createPendingRequest(db, opts) {
-  const id = randomUUID3();
+  const id = randomUUID2();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paramsJson = opts.params !== void 0 ? JSON.stringify(opts.params) : null;
   db.prepare(`
@@ -277,6 +177,7 @@ var AutoRequestor = class {
   creditDb;
   autonomyConfig;
   budgetManager;
+  registryUrl;
   /**
    * Creates a new AutoRequestor.
    *
@@ -288,6 +189,7 @@ var AutoRequestor = class {
     this.creditDb = opts.creditDb;
     this.autonomyConfig = opts.autonomyConfig;
     this.budgetManager = opts.budgetManager;
+    this.registryUrl = opts.registryUrl;
   }
   /**
    * Executes an autonomous capability request.
@@ -308,7 +210,23 @@ var AutoRequestor = class {
    * @returns The result of the auto-request attempt.
    */
   async requestWithAutonomy(need) {
-    const cards = searchCards(this.registryDb, need.query, { online: true });
+    let cards = searchCards(this.registryDb, need.query, { online: true });
+    if (cards.length === 0 && this.registryUrl) {
+      try {
+        cards = await fetchRemoteCards(this.registryUrl, { q: need.query, online: true });
+      } catch {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request_failed",
+          card_id: "none",
+          skill_id: "none",
+          tier_invoked: 3,
+          credits: 0,
+          peer: "none",
+          reason: `Remote registry fallback failed for query "${need.query}"`
+        });
+        cards = [];
+      }
+    }
     const candidates = [];
     for (const card of cards) {
       const cardAsV2 = card;
@@ -429,65 +347,14 @@ var AutoRequestor = class {
   }
 };
 
-// src/utils/interpolation.ts
-function resolvePath(obj, path) {
-  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((s) => s.length > 0);
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0) {
-      return void 0;
-    }
-    if (typeof current !== "object") {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function interpolate(template, context) {
-  return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
-    const resolved = resolvePath(context, expression.trim());
-    if (resolved === void 0 || resolved === null) {
-      return "";
-    }
-    if (typeof resolved === "object") {
-      return JSON.stringify(resolved);
-    }
-    return String(resolved);
-  });
-}
-function interpolateObject(obj, context) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[key] = interpolateValue(value, context);
-  }
-  return result;
-}
-function interpolateValue(value, context) {
-  if (typeof value === "string") {
-    return interpolate(value, context);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => interpolateValue(item, context));
-  }
-  if (value !== null && typeof value === "object") {
-    return interpolateObject(value, context);
-  }
-  return value;
-}
-
 export {
   DEFAULT_AUTONOMY_CONFIG,
   getAutonomyTier,
   insertAuditEvent,
   DEFAULT_BUDGET_CONFIG,
   BudgetManager,
-  searchCards,
-  filterCards,
-  requestCapability,
   listPendingRequests,
   resolvePendingRequest,
   scorePeers,
-  AutoRequestor,
-  interpolateObject
+  AutoRequestor
 };

package/dist/chunk-75OC6E4F.js

@@ -0,0 +1,33 @@
+// src/cli/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  return process.env["AGENTBNB_DIR"] ?? join(homedir(), ".agentbnb");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) return null;
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+
+export {
+  getConfigDir,
+  loadConfig,
+  saveConfig
+};

package/dist/chunk-DVAS2443.js

@@ -0,0 +1,63 @@
+import {
+  AgentBnBError
+} from "./chunk-FNKBHBYK.js";
+
+// src/credit/signing.ts
+import { generateKeyPairSync, sign, verify, createPublicKey, createPrivateKey } from "crypto";
+import { writeFileSync, readFileSync, existsSync, chmodSync } from "fs";
+import { join } from "path";
+function generateKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" }
+  });
+  return {
+    publicKey: Buffer.from(publicKey),
+    privateKey: Buffer.from(privateKey)
+  };
+}
+function saveKeyPair(configDir, keys) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  writeFileSync(privatePath, keys.privateKey);
+  chmodSync(privatePath, 384);
+  writeFileSync(publicPath, keys.publicKey);
+}
+function loadKeyPair(configDir) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  if (!existsSync(privatePath) || !existsSync(publicPath)) {
+    throw new AgentBnBError("Keypair not found. Run `agentbnb init` to generate one.", "KEYPAIR_NOT_FOUND");
+  }
+  return {
+    publicKey: readFileSync(publicPath),
+    privateKey: readFileSync(privatePath)
+  };
+}
+function canonicalJson(data) {
+  return JSON.stringify(data, Object.keys(data).sort());
+}
+function signEscrowReceipt(data, privateKey) {
+  const message = Buffer.from(canonicalJson(data), "utf-8");
+  const keyObject = createPrivateKey({ key: privateKey, format: "der", type: "pkcs8" });
+  const signature = sign(null, message, keyObject);
+  return signature.toString("base64url");
+}
+function verifyEscrowReceipt(data, signature, publicKey) {
+  try {
+    const message = Buffer.from(canonicalJson(data), "utf-8");
+    const keyObject = createPublicKey({ key: publicKey, format: "der", type: "spki" });
+    const sigBuffer = Buffer.from(signature, "base64url");
+    return verify(null, message, keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+
+export {
+  generateKeyPair,
+  saveKeyPair,
+  loadKeyPair,
+  signEscrowReceipt,
+  verifyEscrowReceipt
+};

package/dist/{chunk-XA63SD4T.js → chunk-FNKBHBYK.js}

@@ -123,7 +123,10 @@ var AgentBnBError = class extends Error {
 };
 
 export {
+  IOSchemaSchema,
+  PoweredBySchema,
   CapabilityCardSchema,
+  SkillSchema,
   CapabilityCardV2Schema,
   AnyCardSchema,
   AgentBnBError

package/dist/{websocket-client-5TIQDYQ4.js → chunk-JOY533UH.js}

@@ -1,6 +1,6 @@
 import {
   RelayMessageSchema
-} from "./chunk-3Y36WQDV.js";
+} from "./chunk-QT7TEVNV.js";
 
 // src/relay/websocket-client.ts
 import WebSocket from "ws";
@@ -36,7 +36,8 @@ var RelayClient = class {
           type: "register",
           owner: this.opts.owner,
           token: this.opts.token,
-          card: this.opts.card
+          card: this.opts.card,
+          ...this.opts.cards && this.opts.cards.length > 0 ? { cards: this.opts.cards } : {}
         });
       });
       this.ws.on("message", (raw) => {
@@ -101,13 +102,13 @@ var RelayClient = class {
       throw new Error("Not connected to registry relay");
     }
     const id = randomUUID();
-    const timeoutMs = opts.timeoutMs ?? 3e4;
+    const timeoutMs = opts.timeoutMs ?? 3e5;
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new Error("Relay request timeout"));
       }, timeoutMs);
-      this.pendingRequests.set(id, { resolve, reject, timeout });
+      this.pendingRequests.set(id, { resolve, reject, timeout, timeoutMs, onProgress: opts.onProgress });
       this.send({
         type: "relay_request",
         id,
@@ -120,6 +121,22 @@ var RelayClient = class {
       });
     });
   }
+  /**
+   * Send a relay_progress message to the relay server for a given request.
+   * Used by the onRequest handler to forward SkillExecutor progress updates
+   * to the requesting agent so it can reset its timeout window.
+   *
+   * @param requestId - The relay request ID to associate progress with.
+   * @param info - Progress details (step, total, message).
+   */
+  sendProgress(requestId, info) {
+    this.send({
+      type: "relay_progress",
+      id: requestId,
+      progress: Math.round(info.step / info.total * 100),
+      message: info.message
+    });
+  }
   /** Whether the client is connected and registered */
   get isConnected() {
     return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.registered;
@@ -166,6 +183,9 @@ var RelayClient = class {
       case "error":
         this.handleError(msg);
         break;
+      case "relay_progress":
+        this.handleProgress(msg);
+        break;
       default:
         break;
     }
@@ -211,6 +231,19 @@ var RelayClient = class {
       }
     }
   }
+  handleProgress(msg) {
+    const pending = this.pendingRequests.get(msg.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    const newTimeout = setTimeout(() => {
+      this.pendingRequests.delete(msg.id);
+      pending.reject(new Error("Relay request timeout"));
+    }, pending.timeoutMs);
+    pending.timeout = newTimeout;
+    if (pending.onProgress) {
+      pending.onProgress({ id: msg.id, progress: msg.progress, message: msg.message });
+    }
+  }
   send(msg) {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(msg));
@@ -270,6 +303,7 @@ var RelayClient = class {
     }, delay);
   }
 };
+
 export {
   RelayClient
 };

package/dist/chunk-KJG2UJV5.js

@@ -0,0 +1,83 @@
+import {
+  signEscrowReceipt
+} from "./chunk-DVAS2443.js";
+import {
+  AgentBnBError
+} from "./chunk-FNKBHBYK.js";
+
+// src/gateway/client.ts
+import { randomUUID } from "crypto";
+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
+    });
+  } 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 requestViaRelay(relay, opts) {
+  try {
+    return await relay.request({
+      targetOwner: opts.targetOwner,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      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,
+  requestViaRelay
+};

package/dist/chunk-M3G5NR2Z.js

@@ -0,0 +1,90 @@
+import {
+  generateKeyPair,
+  loadKeyPair,
+  saveKeyPair
+} from "./chunk-DVAS2443.js";
+
+// src/identity/identity.ts
+import { z } from "zod";
+import { createHash } from "crypto";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+var AgentIdentitySchema = z.object({
+  /** Deterministic ID derived from public key: sha256(hex).slice(0, 16). */
+  agent_id: z.string().min(1),
+  /** Human-readable owner name (from config or init). */
+  owner: z.string().min(1),
+  /** Hex-encoded Ed25519 public key. */
+  public_key: z.string().min(1),
+  /** ISO 8601 timestamp of identity creation. */
+  created_at: z.string().datetime(),
+  /** Optional guarantor info if linked to a human. */
+  guarantor: z.object({
+    github_login: z.string().min(1),
+    verified_at: z.string().datetime()
+  }).optional()
+});
+var AgentCertificateSchema = z.object({
+  identity: AgentIdentitySchema,
+  /** ISO 8601 timestamp of certificate issuance. */
+  issued_at: z.string().datetime(),
+  /** ISO 8601 timestamp of certificate expiry. */
+  expires_at: z.string().datetime(),
+  /** Hex-encoded public key of the issuer (same as identity for self-signed). */
+  issuer_public_key: z.string().min(1),
+  /** Base64url Ed25519 signature over { identity, issued_at, expires_at, issuer_public_key }. */
+  signature: z.string().min(1)
+});
+var IDENTITY_FILENAME = "identity.json";
+function deriveAgentId(publicKeyHex) {
+  return createHash("sha256").update(publicKeyHex, "hex").digest("hex").slice(0, 16);
+}
+function createIdentity(configDir, owner) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  let keys;
+  try {
+    keys = loadKeyPair(configDir);
+  } catch {
+    keys = generateKeyPair();
+    saveKeyPair(configDir, keys);
+  }
+  const publicKeyHex = keys.publicKey.toString("hex");
+  const agentId = deriveAgentId(publicKeyHex);
+  const identity = {
+    agent_id: agentId,
+    owner,
+    public_key: publicKeyHex,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveIdentity(configDir, identity);
+  return identity;
+}
+function loadIdentity(configDir) {
+  const filePath = join(configDir, IDENTITY_FILENAME);
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return AgentIdentitySchema.parse(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function saveIdentity(configDir, identity) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const filePath = join(configDir, IDENTITY_FILENAME);
+  writeFileSync(filePath, JSON.stringify(identity, null, 2), "utf-8");
+}
+function ensureIdentity(configDir, owner) {
+  const existing = loadIdentity(configDir);
+  if (existing) return existing;
+  return createIdentity(configDir, owner);
+}
+
+export {
+  deriveAgentId,
+  ensureIdentity
+};