agentbnb 9.1.0 → 9.2.0

package/dist/skills/agentbnb/bootstrap.js

@@ -1,13 +1,3 @@
-import {
-  createLedger,
-  deriveAgentId,
-  ensureIdentity,
-  executeCapabilityBatch,
-  executeCapabilityRequest,
-  identityAuthPlugin,
-  loadOrRepairIdentity,
-  syncCreditsFromRegistry
-} from "../../chunk-PYZGF5QH.js";
 import {
   AutoRequestor,
   BudgetController,
@@ -26,7 +16,19 @@ import {
   requestViaTemporaryRelay,
   resolvePendingRequest,
   verifyUCAN
-} from "../../chunk-DBO2335D.js";
+} from "../../chunk-MQIT2F5V.js";
+import {
+  createLedger,
+  deriveAgentId,
+  ensureIdentity,
+  executeCapabilityBatch,
+  executeCapabilityRequest,
+  identityAuthPlugin,
+  loadOrRepairIdentity,
+  notifyProviderEvent,
+  syncCreditsFromRegistry,
+  tryVerifyIdentity
+} from "../../chunk-CMGJ52SX.js";
 import {
   NETWORK_FEE_RATE,
   bootstrapAgent,
@@ -47,18 +49,49 @@ import {
   releaseEscrow,
   searchCards,
   settleEscrow
-} from "../../chunk-XL5XD3IG.js";
+} from "../../chunk-MPS4RE7T.js";
+import {
+  attachCanonicalAgentId,
+  getCard,
+  getCardsBySkillCapability,
+  getEvolutionHistory,
+  getFeedbackForProvider,
+  getFeedbackForSkill,
+  getLatestEvolution,
+  insertCard,
+  insertEvolution,
+  insertFeedback,
+  listCards,
+  openDatabase,
+  updateCard,
+  updateSkillAvailability,
+  updateSkillIdleRate
+} from "../../chunk-BPPFY72X.js";
+import {
+  getActivityFeed,
+  getRequestLog,
+  getSkillRequestCount,
+  insertRequestLog
+} from "../../chunk-4XTYT4JW.js";
+import {
+  emitProviderEvent
+} from "../../chunk-GZUTU6IZ.js";
 import "../../chunk-6QMDJVMS.js";
+import "../../chunk-EE3V3DXK.js";
 import {
   requestCapability,
   requestViaRelay
-} from "../../chunk-W6LOCBWQ.js";
+} from "../../chunk-IWAK4WHK.js";
 import {
   generateKeyPair,
   loadKeyPair,
   signEscrowReceipt,
   verifyEscrowReceipt
-} from "../../chunk-YNBZLXYS.js";
+} from "../../chunk-65GNX2KC.js";
+import {
+  AgentBnBError,
+  AnyCardSchema
+} from "../../chunk-UVCNMRPS.js";
 import {
   RelayClient,
   RelayMessageSchema,
@@ -78,38 +111,10 @@ import {
   getConfigDir,
   loadConfig
 } from "../../chunk-IVOYM3WG.js";
-import {
-  attachCanonicalAgentId,
-  getCard,
-  getCardsBySkillCapability,
-  getEvolutionHistory,
-  getFeedbackForProvider,
-  getFeedbackForSkill,
-  getLatestEvolution,
-  insertCard,
-  insertEvolution,
-  insertFeedback,
-  listCards,
-  openDatabase,
-  updateCard,
-  updateSkillAvailability,
-  updateSkillIdleRate
-} from "../../chunk-VJ2Q33AP.js";
-import {
-  getActivityFeed,
-  getRequestLog,
-  getSkillRequestCount,
-  insertRequestLog
-} from "../../chunk-4XTYT4JW.js";
-import "../../chunk-EE3V3DXK.js";
-import {
-  AgentBnBError,
-  AnyCardSchema
-} from "../../chunk-UVCNMRPS.js";
 import "../../chunk-3RG5ZIWI.js";
 
 // skills/agentbnb/bootstrap.ts
-import { join as join6, basename as basename2, dirname as dirname4 } from "path";
+import { join as join6, basename as basename3, dirname as dirname4 } from "path";
 import { existsSync as existsSync7, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import { exec } from "child_process";
@@ -287,7 +292,7 @@ function isPidFileContent(value) {
 }
 
 // src/runtime/agent-runtime.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
 
 // src/skills/executor.ts
 function buildTimeoutError(skillId, timeoutMs) {
@@ -1100,7 +1105,30 @@ var OpenClawBridge = class {
 
 // src/skills/command-executor.ts
 import { spawn } from "child_process";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { basename, extname } from "path";
 var KILL_GRACE_MS = 5e3;
+var MAX_INLINE_FILE_BYTES = 5 * 1024 * 1024;
+var MIME_TYPES = {
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv"
+};
+function guessMimeType(filePath) {
+  return MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
 function shellEscape2(value) {
   return "'" + value.replace(/'/g, "'\\''") + "'";
 }
@@ -1316,8 +1344,34 @@ var CommandExecutor = class {
           };
         }
       }
-      case "file":
-        return { success: true, result: { file_path: rawOutput } };
+      case "file": {
+        try {
+          const stats = statSync(rawOutput);
+          if (stats.size > MAX_INLINE_FILE_BYTES) {
+            return {
+              success: false,
+              error: `File too large for inline return: ${stats.size} bytes (max ${MAX_INLINE_FILE_BYTES})`
+            };
+          }
+          const buffer = readFileSync2(rawOutput);
+          return {
+            success: true,
+            result: {
+              file: {
+                name: basename(rawOutput),
+                mime_type: guessMimeType(rawOutput),
+                size_bytes: stats.size,
+                data_base64: buffer.toString("base64")
+              },
+              // Keep file_path for backward compat (local workflows)
+              file_path: rawOutput
+            }
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { success: false, error: `Failed to read file "${rawOutput}": ${msg}` };
+        }
+      }
       default:
         return {
           success: false,
@@ -1446,13 +1500,13 @@ var AgentRuntime = class {
     }
     let configs = [];
     if (hasSkillsYaml) {
-      const yamlContent = readFileSync2(this.skillsYamlPath, "utf8");
+      const yamlContent = readFileSync3(this.skillsYamlPath, "utf8");
       configs = parseSkillsFile(yamlContent);
     }
     const modes = /* @__PURE__ */ new Map();
     if (this.conductorEnabled) {
-      const { ConductorMode } = await import("../../conductor-mode-KKPSNN7V.js");
-      const { registerConductorCard, CONDUCTOR_OWNER } = await import("../../card-VVT3XBOI.js");
+      const { ConductorMode } = await import("../../conductor-mode-66IITI4I.js");
+      const { registerConductorCard, CONDUCTOR_OWNER } = await import("../../card-U2HQRPYN.js");
       const { loadPeers: loadPeers2 } = await import("../../peers-IOVCBWAI.js");
       registerConductorCard(this.registryDb);
       const resolveAgentUrl = (owner) => {
@@ -2517,12 +2571,14 @@ var SessionManager = class {
   escrow;
   config;
   sendToAgent;
+  registryDb;
   /** Maps agent connection key → set of session IDs they participate in. */
   agentSessions = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.escrow = new SessionEscrow(opts.creditDb);
     this.config = opts.config ?? loadSessionConfig();
     this.sendToAgent = opts.sendToAgent;
+    this.registryDb = opts.registryDb ?? null;
   }
   /**
    * Open a new session between requester and provider.
@@ -2581,6 +2637,15 @@ var SessionManager = class {
     }
     this.resetIdleTimer(session.id);
     this.startDurationTimer(session.id);
+    this.emitEvent({
+      event_type: "session.opened",
+      skill_id: session.skill_id,
+      session_id: session.id,
+      requester: session.requester_id,
+      credits: session.budget,
+      duration_ms: 0,
+      metadata: { engine: "session", pricing_model: session.pricing_model }
+    });
     return session;
   }
   /**
@@ -2641,6 +2706,15 @@ var SessionManager = class {
       content: msg.content,
       metadata: msg.metadata
     });
+    this.emitEvent({
+      event_type: "session.message",
+      skill_id: session.skill_id,
+      session_id: session.id,
+      requester: session.requester_id,
+      credits: session.spent,
+      duration_ms: Date.now() - new Date(session.created_at).getTime(),
+      metadata: { message_count: session.messages.length, running_cost: session.spent, sender: msg.sender }
+    });
     this.resetIdleTimer(session.id);
   }
   /**
@@ -2684,6 +2758,19 @@ var SessionManager = class {
     this.durationTimers.clear();
   }
   // -------------------------------------------------------------------------
+  // Event emission
+  // -------------------------------------------------------------------------
+  /** Emit a provider event + Telegram notification. Silently no-ops on failure. */
+  emitEvent(event) {
+    if (!this.registryDb) return;
+    try {
+      const emitted = emitProviderEvent(this.registryDb, event);
+      notifyProviderEvent(emitted).catch(() => {
+      });
+    } catch {
+    }
+  }
+  // -------------------------------------------------------------------------
   // Internal helpers
   // -------------------------------------------------------------------------
   endSessionInternal(session, reason) {
@@ -2707,6 +2794,27 @@ var SessionManager = class {
     };
     session.status = "settled";
     session.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    const isFailed = reason === "error";
+    const eventMetadata = {
+      total_messages: session.messages.length,
+      reason,
+      refunded: session.budget - session.spent
+    };
+    if (isFailed) {
+      eventMetadata["last_messages"] = session.messages.slice(-3).map((m) => ({
+        sender: m.sender,
+        content: m.content.slice(0, 200)
+      }));
+    }
+    this.emitEvent({
+      event_type: isFailed ? "session.failed" : "session.ended",
+      skill_id: session.skill_id,
+      session_id: session.id,
+      requester: session.requester_id,
+      credits: session.spent,
+      duration_ms: durationMs,
+      metadata: eventMetadata
+    });
     this.sendToAgent(session.requester_id, settledMsg);
     this.sendToAgent(session.provider_id, settledMsg);
     session.status = "closed";
@@ -3669,6 +3777,75 @@ function initiateGithubAuth() {
   };
 }
 
+// src/registry/hub-identities.ts
+import { randomBytes as randomBytes2, createHash } from "crypto";
+var HUB_IDENTITIES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS hub_identities (
+    email TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL UNIQUE,
+    public_key TEXT NOT NULL,
+    encrypted_private_key TEXT NOT NULL,
+    kdf_salt TEXT NOT NULL,
+    display_name TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_hub_identities_agent_id
+    ON hub_identities(agent_id);
+`;
+var CHALLENGES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS hub_challenges (
+    challenge TEXT PRIMARY KEY,
+    expires_at TEXT NOT NULL,
+    consumed_at TEXT
+  );
+`;
+function ensureHubIdentitiesTables(db) {
+  db.exec(HUB_IDENTITIES_SCHEMA);
+  db.exec(CHALLENGES_SCHEMA);
+}
+function deriveAgentId2(publicKeyHex) {
+  const hash = createHash("sha256").update(publicKeyHex, "hex").digest("hex");
+  return `agent-${hash.slice(0, 16)}`;
+}
+var CHALLENGE_TTL_MS = 10 * 60 * 1e3;
+function createChallenge(db) {
+  const challenge = randomBytes2(32).toString("hex");
+  const expires_at = new Date(Date.now() + CHALLENGE_TTL_MS).toISOString();
+  db.prepare("INSERT INTO hub_challenges (challenge, expires_at) VALUES (?, ?)").run(challenge, expires_at);
+  return { challenge, expires_at };
+}
+function consumeChallenge(db, challenge) {
+  const row = db.prepare("SELECT expires_at, consumed_at FROM hub_challenges WHERE challenge = ?").get(challenge);
+  if (!row) return false;
+  if (row.consumed_at) return false;
+  if (new Date(row.expires_at).getTime() < Date.now()) return false;
+  const consumed_at = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE hub_challenges SET consumed_at = ? WHERE challenge = ?").run(consumed_at, challenge);
+  return true;
+}
+function pruneChallenges(db) {
+  const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+  db.prepare("DELETE FROM hub_challenges WHERE expires_at < ? OR consumed_at IS NOT NULL").run(cutoff);
+}
+function registerHubIdentity(db, input) {
+  const agent_id = deriveAgentId2(input.public_key);
+  const created_at = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    INSERT INTO hub_identities (email, agent_id, public_key, encrypted_private_key, kdf_salt, display_name, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(input.email, agent_id, input.public_key, input.encrypted_private_key, input.kdf_salt, input.display_name, created_at);
+  return { ...input, agent_id, created_at };
+}
+function getHubIdentityByEmail(db, email) {
+  const row = db.prepare("SELECT * FROM hub_identities WHERE email = ?").get(email);
+  return row ?? null;
+}
+function getHubIdentityByAgentId(db, agent_id) {
+  const row = db.prepare("SELECT * FROM hub_identities WHERE agent_id = ?").get(agent_id);
+  return row ?? null;
+}
+
 // src/registry/free-tier.ts
 function initFreeTierTable(db) {
   db.exec(`
@@ -5698,6 +5875,121 @@ function createRegistryServer(opts) {
         throw err;
       }
     });
+    ensureHubIdentitiesTables(db);
+    try {
+      pruneChallenges(db);
+    } catch {
+    }
+    api.get("/api/agents/challenge", {
+      schema: {
+        tags: ["hub-auth"],
+        summary: "Get a registration challenge",
+        response: {
+          200: {
+            type: "object",
+            properties: {
+              challenge: { type: "string" },
+              expires_at: { type: "string" }
+            }
+          }
+        }
+      }
+    }, async (_request, reply) => {
+      const { challenge, expires_at } = createChallenge(db);
+      return reply.send({ challenge, expires_at });
+    });
+    api.post("/api/agents/register", {
+      schema: {
+        tags: ["hub-auth"],
+        summary: "Register a new Hub-managed agent identity",
+        body: {
+          type: "object",
+          required: ["email", "public_key", "encrypted_private_key", "kdf_salt", "display_name", "challenge", "signature"],
+          properties: {
+            email: { type: "string", format: "email" },
+            public_key: { type: "string" },
+            encrypted_private_key: { type: "string" },
+            kdf_salt: { type: "string" },
+            display_name: { type: "string" },
+            challenge: { type: "string" },
+            signature: { type: "string" }
+          }
+        },
+        response: {
+          201: { type: "object", additionalProperties: true },
+          400: { type: "object", properties: { error: { type: "string" } } },
+          409: { type: "object", properties: { error: { type: "string" } } }
+        }
+      }
+    }, async (request, reply) => {
+      const body = request.body;
+      if (!consumeChallenge(db, body.challenge)) {
+        return reply.code(400).send({ error: "Invalid or expired challenge" });
+      }
+      if (!/^[0-9a-fA-F]+$/.test(body.public_key) || body.public_key.length % 2 !== 0) {
+        return reply.code(400).send({ error: "Invalid public_key format" });
+      }
+      try {
+        const { verifyEscrowReceipt: verifyEscrowReceipt2 } = await import("../../signing-AQTKYJDB.js");
+        const publicKeyBuffer = Buffer.from(body.public_key, "hex");
+        const valid = verifyEscrowReceipt2({ challenge: body.challenge }, body.signature, publicKeyBuffer);
+        if (!valid) {
+          return reply.code(400).send({ error: "Invalid signature" });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return reply.code(400).send({ error: `Signature verification failed: ${msg}` });
+      }
+      const existing = getHubIdentityByEmail(db, body.email.toLowerCase());
+      if (existing) {
+        return reply.code(409).send({ error: "Email already registered" });
+      }
+      const agent_id = deriveAgentId2(body.public_key);
+      const existingByAgentId = getHubIdentityByAgentId(db, agent_id);
+      if (existingByAgentId) {
+        return reply.code(409).send({ error: "Agent already registered" });
+      }
+      const identity = registerHubIdentity(db, {
+        email: body.email.toLowerCase(),
+        public_key: body.public_key,
+        encrypted_private_key: body.encrypted_private_key,
+        kdf_salt: body.kdf_salt,
+        display_name: body.display_name
+      });
+      return reply.code(201).send({
+        agent_id: identity.agent_id,
+        did: `did:agentbnb:${identity.agent_id}`,
+        created_at: identity.created_at
+      });
+    });
+    api.post("/api/agents/login", {
+      schema: {
+        tags: ["hub-auth"],
+        summary: "Fetch encrypted identity blob for login",
+        body: {
+          type: "object",
+          required: ["email"],
+          properties: { email: { type: "string", format: "email" } }
+        },
+        response: {
+          200: { type: "object", additionalProperties: true },
+          404: { type: "object", properties: { error: { type: "string" } } }
+        }
+      }
+    }, async (request, reply) => {
+      const body = request.body;
+      const identity = getHubIdentityByEmail(db, body.email.toLowerCase());
+      if (!identity) {
+        return reply.code(404).send({ error: "Identity not found" });
+      }
+      return reply.send({
+        agent_id: identity.agent_id,
+        public_key: identity.public_key,
+        encrypted_private_key: identity.encrypted_private_key,
+        kdf_salt: identity.kdf_salt,
+        display_name: identity.display_name
+      });
+    });
     api.post("/api/identity/link", {
       schema: {
         tags: ["identity"],
@@ -5997,7 +6289,7 @@ function createRegistryServer(opts) {
               });
               await relayClient.connect();
             }
-            const { requestViaRelay: requestViaRelay2 } = await import("../../client-XOSXFC7Q.js");
+            const { requestViaRelay: requestViaRelay2 } = await import("../../client-KL67WZVJ.js");
             return requestViaRelay2(relayClient, {
               targetOwner: target.owner,
               cardId: target.cardId,
@@ -6016,12 +6308,24 @@ function createRegistryServer(opts) {
       const ownerApiKey = opts.ownerApiKey;
       const ownerName = opts.ownerName;
       void api.register(async (ownerRoutes) => {
-        ownerRoutes.addHook("onRequest", async (request, reply) => {
+        ownerRoutes.addHook("preHandler", async (request, reply) => {
           const auth = request.headers.authorization;
           const token = auth?.startsWith("Bearer ") ? auth.slice(7).trim() : null;
-          if (!token || token !== ownerApiKey) {
-            return reply.status(401).send({ error: "Unauthorized" });
+          if (token === ownerApiKey) {
+            request.agentId = ownerName;
+            return;
+          }
+          const didResult = await tryVerifyIdentity(request, {});
+          if (didResult.valid) {
+            const hubIdentity = getHubIdentityByAgentId(db, didResult.agentId);
+            if (!hubIdentity) {
+              return reply.status(401).send({ error: "Agent not registered on this Hub" });
+            }
+            request.agentId = didResult.agentId;
+            request.agentPublicKey = didResult.publicKey;
+            return;
           }
+          return reply.status(401).send({ error: "Unauthorized" });
         });
         ownerRoutes.get("/me", {
           schema: {
@@ -6032,13 +6336,14 @@ function createRegistryServer(opts) {
               200: { type: "object", properties: { owner: { type: "string" }, balance: { type: "number" } } }
             }
           }
-        }, async (_request, reply) => {
+        }, async (request, reply) => {
+          const identity = request.agentId ?? ownerName;
           let balance = 0;
           if (opts.creditDb) {
             const ledger = createLedger({ db: opts.creditDb });
-            balance = await ledger.getBalance(ownerName);
+            balance = await ledger.getBalance(identity);
           }
-          return reply.send({ owner: ownerName, balance });
+          return reply.send({ owner: identity, balance });
         });
         ownerRoutes.get("/requests", {
           schema: {
@@ -6225,6 +6530,62 @@ function createRegistryServer(opts) {
           const items = await ledger.getHistory(ownerName, limit);
           return reply.send({ items, limit });
         });
+        ownerRoutes.get("/me/events", {
+          schema: {
+            tags: ["owner"],
+            summary: "Provider event stream",
+            security: [{ bearerAuth: [] }],
+            querystring: {
+              type: "object",
+              properties: {
+                limit: { type: "integer", description: "Max entries (default 50)" },
+                since: { type: "string", description: "ISO timestamp for cursor-based polling" },
+                event_type: { type: "string", description: "Filter by event type" }
+              }
+            }
+          }
+        }, async (request, reply) => {
+          const { getProviderEvents: getEvents } = await import("../../provider-events-GTTJPYHS.js");
+          const query = request.query;
+          const limit = query.limit ? parseInt(query.limit, 10) : void 0;
+          const events = getEvents(db, {
+            limit,
+            since: query.since,
+            event_type: query.event_type
+          });
+          return reply.send({ events });
+        });
+        ownerRoutes.get("/me/stats", {
+          schema: {
+            tags: ["owner"],
+            summary: "Aggregated provider stats",
+            security: [{ bearerAuth: [] }],
+            querystring: {
+              type: "object",
+              properties: { period: { type: "string", enum: ["24h", "7d", "30d"] } }
+            }
+          }
+        }, async (request, reply) => {
+          const { getProviderStats: getStats } = await import("../../provider-events-GTTJPYHS.js");
+          const query = request.query;
+          const period = query.period ?? "7d";
+          const stats = getStats(db, period);
+          if (opts.creditDb) {
+            const periodMs = { "24h": 864e5, "7d": 6048e5, "30d": 2592e6 }[period];
+            const cutoff = new Date(Date.now() - periodMs).toISOString();
+            try {
+              const row = opts.creditDb.prepare(`
+              SELECT COALESCE(SUM(CASE WHEN amount < 0 AND reason IN ('escrow_hold', 'voucher_hold', 'network_fee') THEN -amount ELSE 0 END), 0) as spent
+              FROM credit_transactions
+              WHERE owner = ? AND created_at >= ?
+            `).get(ownerName, cutoff);
+              stats.total_spending = row?.spent ?? 0;
+              stats.net_pnl = stats.total_earnings - stats.total_spending;
+            } catch {
+            }
+          }
+          return reply.send(stats);
+        });
       });
     }
     api.get("/api/providers/:owner/reliability", {
@@ -6469,7 +6830,7 @@ import { execFileSync } from "child_process";
 import { existsSync as existsSync4, realpathSync } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname3, isAbsolute, join as join3, resolve } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute, join as join3, resolve } from "path";
 function resolveSelfCli() {
   const require2 = createRequire(import.meta.url);
   return resolveSelfCliWithDeps({
@@ -6587,7 +6948,7 @@ function getPnpmGlobalCandidates(platform, homeDir) {
 }
 function looksLikeAgentbnbCli(path) {
   const normalized = path.replace(/\\/g, "/").toLowerCase();
-  const fileName = basename(normalized);
+  const fileName = basename2(normalized);
   if (fileName === "agentbnb" || fileName === "agentbnb.cmd" || fileName === "agentbnb.exe") {
     return true;
   }
@@ -6600,7 +6961,7 @@ function extractErrorMessage(err) {
 
 // src/runtime/service-coordinator.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { join as join4 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 import { Cron as Cron2 } from "croner";
@@ -6775,7 +7136,7 @@ var ServiceCoordinator = class {
       console.log("Conductor mode enabled \u2014 orchestrate/plan skills available via gateway");
     }
     if (opts.conductorEnabled && this.config.conductor?.public) {
-      const { buildConductorCard } = await import("../../card-VVT3XBOI.js");
+      const { buildConductorCard } = await import("../../card-U2HQRPYN.js");
       const conductorCard = attachCanonicalAgentId(
         this.runtime.registryDb,
         buildConductorCard(this.config.owner)
@@ -6852,7 +7213,7 @@ var ServiceCoordinator = class {
     }
     if (opts.registryUrl && opts.relay) {
       const { RelayClient: RelayClient2 } = await import("../../websocket-client-RT4KLJL4.js");
-      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("../../execute-IEQ3RV7I.js");
+      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("../../execute-YBNCDAOX.js");
       const localCards = listCards(this.runtime.registryDb, this.config.owner);
       const { primaryCard, additionalCards } = buildRelayRegistrationCards(this.config.owner, localCards);
       if (this.config.conductor?.public) {
@@ -7113,7 +7474,7 @@ function loadPersistedRuntime(configDir) {
   const runtimePath = join4(configDir, "runtime.json");
   if (!existsSync5(runtimePath)) return null;
   try {
-    const raw = readFileSync3(runtimePath, "utf8");
+    const raw = readFileSync4(runtimePath, "utf8");
     const parsed = JSON.parse(raw);
     const nodeExec = parsed["node_exec"];
     if (typeof nodeExec !== "string" || nodeExec.trim().length === 0) {
@@ -7530,7 +7891,7 @@ function isNetworkError(err) {
 }
 
 // skills/agentbnb/openclaw-tools.ts
-import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
 import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 
@@ -8119,7 +8480,7 @@ function buildMcpContext(toolCtx) {
       `AgentBnB not initialized at ${configDir}. Run \`agentbnb init\` or activate the plugin first.`
     );
   }
-  const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+  const config = JSON.parse(readFileSync5(configPath, "utf-8"));
   const identity = ensureIdentity(configDir, config.owner);
   const ctx = { configDir, config, identity };
   contextCache.set(configDir, ctx);
@@ -8358,7 +8719,7 @@ async function runCommand(cmd, env) {
   return execAsync(cmd, { env });
 }
 function deriveAgentName(configDir) {
-  const parent = basename2(dirname4(configDir));
+  const parent = basename3(dirname4(configDir));
   if (parent && parent !== "." && parent !== ".agentbnb" && parent !== homedir4().split("/").pop()) {
     return parent;
   }