agentbnb 8.3.2 → 8.4.1

package/dist/chunk-PCQEHIGF.js

@@ -0,0 +1,750 @@
+import {
+  DEFAULT_BUDGET_CONFIG
+} from "./chunk-AZKVGC5T.js";
+import {
+  KNOWN_API_KEYS,
+  buildDraftCard,
+  detectApiKeys,
+  detectOpenPorts
+} from "./chunk-CFHCG5FE.js";
+import {
+  createLedger,
+  loadOrRepairIdentity
+} from "./chunk-WK2QSO4E.js";
+import {
+  DEFAULT_AUTONOMY_CONFIG
+} from "./chunk-G5WKW3ED.js";
+import {
+  bootstrapAgent,
+  getBalance,
+  migrateOwner,
+  openCreditDb
+} from "./chunk-HU46M4JA.js";
+import {
+  getConfigDir,
+  loadConfig,
+  saveConfig
+} from "./chunk-3XPBFF6H.js";
+import {
+  parseSoulMd
+} from "./chunk-VAAEBCMU.js";
+import {
+  attachCanonicalAgentId,
+  insertCard,
+  listCards,
+  openDatabase
+} from "./chunk-COA2D7QM.js";
+import {
+  createAgentRecord,
+  lookupAgent,
+  lookupAgentByOwner,
+  updateAgentRecord
+} from "./chunk-WTHMHNKC.js";
+import {
+  AgentBnBError,
+  CapabilityCardV2Schema
+} from "./chunk-I7KWA7OB.js";
+
+// src/openclaw/soul-sync.ts
+import { randomUUID } from "crypto";
+var SKILL_META_GLOBAL_RE = /(?:^|\s)-\s*(capability_types|requires(?:_capabilities)?|visibility)\s*:\s*([^-][^]*?)(?=\s+-\s+(?:capability_types|requires(?:_capabilities)?|visibility)\s*:|$)/gi;
+function extractSkillMeta(raw) {
+  let capability_types;
+  let requires_capabilities;
+  let visibility;
+  const removedRanges = [];
+  SKILL_META_GLOBAL_RE.lastIndex = 0;
+  let m;
+  while ((m = SKILL_META_GLOBAL_RE.exec(raw)) !== null) {
+    const key = m[1].toLowerCase();
+    const val = m[2].trim();
+    if (key === "capability_types") {
+      capability_types = val.split(",").map((v) => v.trim()).filter(Boolean);
+    } else if (key === "requires" || key === "requires_capabilities") {
+      requires_capabilities = val.split(",").map((v) => v.trim()).filter(Boolean);
+    } else if (key === "visibility") {
+      const vis = val.toLowerCase();
+      if (vis === "public" || vis === "private") {
+        visibility = vis;
+      }
+    }
+    removedRanges.push({ start: m.index, end: m.index + m[0].length });
+  }
+  let description = raw;
+  for (const { start, end } of removedRanges.slice().reverse()) {
+    description = description.slice(0, start) + description.slice(end);
+  }
+  description = description.trim();
+  return { description, capability_types, requires_capabilities, visibility };
+}
+function parseSoulMdV2(content) {
+  const parsed = parseSoulMd(content);
+  const skills = parsed.capabilities.map((cap) => {
+    const sanitizedId = cap.name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    const id = sanitizedId.length > 0 ? sanitizedId : randomUUID();
+    const { description: cleanDesc, capability_types, requires_capabilities, visibility } = extractSkillMeta(cap.description);
+    const finalDescription = (cleanDesc || cap.name).slice(0, 500);
+    const skill = {
+      id,
+      name: cap.name,
+      description: finalDescription,
+      level: 2,
+      inputs: [
+        {
+          name: "input",
+          type: "text",
+          description: "Input for the skill",
+          required: true
+        }
+      ],
+      outputs: [
+        {
+          name: "output",
+          type: "text",
+          description: "Output from the skill",
+          required: true
+        }
+      ],
+      pricing: { credits_per_call: cap.pricing !== void 0 ? cap.pricing : 10 },
+      availability: { online: true }
+    };
+    if (capability_types !== void 0) skill.capability_types = capability_types;
+    if (requires_capabilities !== void 0) skill.requires_capabilities = requires_capabilities;
+    if (visibility !== void 0) skill.visibility = visibility;
+    return skill;
+  });
+  return {
+    agentName: parsed.name || "Unknown Agent",
+    description: parsed.description,
+    skills
+  };
+}
+function publishFromSoulV2(db, soulContent, owner, sharedSkills) {
+  const { agentName, skills: allSkills } = parseSoulMdV2(soulContent);
+  const skills = allSkills.filter((skill) => {
+    if (sharedSkills && sharedSkills.length > 0) {
+      return sharedSkills.includes(skill.id);
+    }
+    return skill.visibility !== "private";
+  });
+  if (skills.length === 0) {
+    throw new AgentBnBError("SOUL.md has no H2 sections", "VALIDATION_ERROR");
+  }
+  const existingCards = listCards(db, owner);
+  const existingV2 = existingCards.find(
+    (c) => c.spec_version === "2.0"
+  );
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cardId = existingV2?.id ?? randomUUID();
+  const card = {
+    spec_version: "2.0",
+    id: cardId,
+    owner,
+    agent_name: agentName,
+    skills,
+    availability: { online: true },
+    created_at: existingV2?.created_at ?? now,
+    updated_at: now
+  };
+  const storedCard = attachCanonicalAgentId(db, card);
+  CapabilityCardV2Schema.parse(storedCard);
+  if (existingV2) {
+    db.prepare(
+      "UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?"
+    ).run(JSON.stringify(storedCard), now, cardId);
+  } else {
+    db.prepare(
+      "INSERT INTO capability_cards (id, owner, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)"
+    ).run(cardId, storedCard.owner, JSON.stringify(storedCard), now, now);
+  }
+  return storedCard;
+}
+
+// src/openclaw/heartbeat-writer.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+var HEARTBEAT_MARKER_START = "<!-- agentbnb:start -->";
+var HEARTBEAT_MARKER_END = "<!-- agentbnb:end -->";
+function generateHeartbeatSection(autonomy, budget) {
+  const t1 = autonomy.tier1_max_credits;
+  const t2 = autonomy.tier2_max_credits;
+  const reserve = budget.reserve_credits;
+  return [
+    HEARTBEAT_MARKER_START,
+    "## AgentBnB Protocol",
+    "",
+    "You are a participant in the AgentBnB capability sharing network.",
+    "",
+    "### Sharing Rules",
+    "- When your idle_rate exceeds 70%, automatically share idle capabilities",
+    "- Accept incoming requests that match your published Capability Card",
+    "- Track credit earnings and report to owner weekly",
+    "",
+    "### Requesting Rules",
+    "- When you encounter a task you cannot complete with local skills:",
+    "  1. Query AgentBnB network for matching capabilities",
+    "  2. If found and credit sufficient, automatically request",
+    "  3. Integrate result into your current workflow",
+    "- Budget limits:",
+    `  - < ${t1} credits: auto-execute, no notification`,
+    `  - ${t1}-${t2} credits: execute, notify owner after`,
+    `  - > ${t2} credits: ask owner before executing`,
+    "",
+    "### Credit Management",
+    `- Maintain minimum balance of ${reserve} credits (reserve for emergencies)`,
+    `- If balance drops below ${reserve}, increase sharing priority`,
+    "- If balance exceeds 500, notify owner of surplus",
+    HEARTBEAT_MARKER_END
+  ].join("\n");
+}
+function injectHeartbeatSection(heartbeatPath, section) {
+  if (!existsSync(heartbeatPath)) {
+    writeFileSync(heartbeatPath, section + "\n", "utf-8");
+    return;
+  }
+  let content = readFileSync(heartbeatPath, "utf-8");
+  const startIdx = content.indexOf(HEARTBEAT_MARKER_START);
+  const endIdx = content.indexOf(HEARTBEAT_MARKER_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    content = content.slice(0, startIdx) + section + content.slice(endIdx + HEARTBEAT_MARKER_END.length);
+  } else {
+    content = content + "\n" + section + "\n";
+  }
+  writeFileSync(heartbeatPath, content, "utf-8");
+}
+
+// src/openclaw/skill.ts
+function getOpenClawStatus(config, db, creditDb) {
+  const autonomy = config.autonomy ?? DEFAULT_AUTONOMY_CONFIG;
+  const budget = config.budget ?? DEFAULT_BUDGET_CONFIG;
+  const balance = getBalance(creditDb, config.owner);
+  const allCards = listCards(db, config.owner);
+  const skills = [];
+  for (const card of allCards) {
+    const anyCard = card;
+    if (anyCard.spec_version !== "2.0" || !Array.isArray(anyCard.skills)) continue;
+    for (const skill of anyCard.skills) {
+      const internal = skill["_internal"] ?? {};
+      const idleRate = typeof internal["idle_rate"] === "number" ? internal["idle_rate"] : null;
+      const availability = skill["availability"];
+      const online = availability?.online ?? false;
+      skills.push({
+        id: String(skill["id"] ?? ""),
+        name: String(skill["name"] ?? ""),
+        idle_rate: idleRate,
+        online
+      });
+    }
+  }
+  return {
+    installed: true,
+    owner: config.owner,
+    gateway_url: config.gateway_url,
+    tier: autonomy,
+    balance,
+    reserve: budget.reserve_credits,
+    skills
+  };
+}
+
+// src/cli/init-action.ts
+import { randomBytes } from "crypto";
+import { join as join2 } from "path";
+import { networkInterfaces } from "os";
+
+// src/onboarding/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+
+// src/onboarding/capability-templates.ts
+var API_PATTERNS = [
+  {
+    pattern: /openai|gpt-4|gpt-3|chatgpt|dall-e/i,
+    capability: { key: "openai", name: "OpenAI Text Generation", category: "Text Gen", credits_per_call: 3, tags: ["llm", "text", "generation"] }
+  },
+  {
+    pattern: /elevenlabs|eleven.?labs/i,
+    capability: { key: "elevenlabs", name: "ElevenLabs TTS", category: "TTS", credits_per_call: 5, tags: ["tts", "audio", "voice"] }
+  },
+  {
+    pattern: /anthropic|claude/i,
+    capability: { key: "anthropic", name: "Anthropic Claude", category: "Text Gen", credits_per_call: 3, tags: ["llm", "text", "generation"] }
+  },
+  {
+    pattern: /recraft/i,
+    capability: { key: "recraft", name: "Recraft V4 Image Gen", category: "Image Gen", credits_per_call: 8, tags: ["image", "generation", "design"] }
+  },
+  {
+    pattern: /kling/i,
+    capability: { key: "kling", name: "Kling AI Video Gen", category: "Video Gen", credits_per_call: 10, tags: ["video", "generation"] }
+  },
+  {
+    pattern: /stable.?diffusion|sdxl|comfyui/i,
+    capability: { key: "stable-diffusion", name: "Stable Diffusion Image Gen", category: "Image Gen", credits_per_call: 6, tags: ["image", "generation", "diffusion"] }
+  },
+  {
+    pattern: /whisper|speech.?to.?text|stt/i,
+    capability: { key: "whisper", name: "Whisper Speech-to-Text", category: "STT", credits_per_call: 3, tags: ["stt", "audio", "transcription"] }
+  },
+  {
+    pattern: /puppeteer|playwright|selenium/i,
+    capability: { key: "puppeteer", name: "Web Scraping & Automation", category: "Web Scraping", credits_per_call: 2, tags: ["scraping", "automation", "browser"] }
+  },
+  {
+    pattern: /ffmpeg/i,
+    capability: { key: "ffmpeg", name: "FFmpeg Media Processing", category: "Media Processing", credits_per_call: 3, tags: ["media", "audio", "video", "processing"] }
+  },
+  {
+    pattern: /tesseract|ocr/i,
+    capability: { key: "tesseract", name: "OCR Text Extraction", category: "OCR", credits_per_call: 4, tags: ["ocr", "text", "extraction"] }
+  }
+];
+var INTERACTIVE_TEMPLATES = [
+  { key: "openai", name: "Text Generation (GPT-4o / Claude / Gemini)", category: "Text Gen", credits_per_call: 3, tags: ["llm", "text", "generation"] },
+  { key: "image-gen", name: "Image Generation (DALL-E / Recraft / Stable Diffusion)", category: "Image Gen", credits_per_call: 8, tags: ["image", "generation"] },
+  { key: "tts", name: "TTS / Voice (ElevenLabs / Google TTS)", category: "TTS", credits_per_call: 5, tags: ["tts", "audio", "voice"] },
+  { key: "video-gen", name: "Video Generation (Kling / Runway)", category: "Video Gen", credits_per_call: 10, tags: ["video", "generation"] },
+  { key: "code-review", name: "Code Review / Analysis", category: "Code", credits_per_call: 3, tags: ["code", "review", "analysis"] },
+  { key: "scraping", name: "Web Scraping / Data Extraction", category: "Web Scraping", credits_per_call: 2, tags: ["scraping", "data", "extraction"] },
+  { key: "translation", name: "Translation", category: "Translation", credits_per_call: 3, tags: ["translation", "language", "text"] },
+  { key: "custom", name: "Custom (describe it)", category: "Custom", credits_per_call: 5, tags: ["custom"] }
+];
+
+// src/onboarding/detect-from-docs.ts
+function detectFromDocs(content) {
+  if (!content || content.trim().length === 0) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const entry of API_PATTERNS) {
+    if (entry.pattern.test(content) && !seen.has(entry.capability.key)) {
+      seen.add(entry.capability.key);
+      results.push({ ...entry.capability });
+    }
+  }
+  return results;
+}
+
+// src/onboarding/interactive.ts
+import { createInterface } from "readline";
+async function interactiveTemplateMenu() {
+  console.log("\nNo capabilities auto-detected.\n");
+  console.log("What can your agent do? Pick from templates:\n");
+  for (let i = 0; i < INTERACTIVE_TEMPLATES.length; i++) {
+    console.log(`  ${i + 1}. ${INTERACTIVE_TEMPLATES[i].name}`);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question("\nSelect [1-8, comma-separated]: ", (ans) => {
+      rl.close();
+      resolve(ans);
+    });
+  });
+  return parseSelection(answer);
+}
+function parseSelection(input) {
+  if (!input || input.trim().length === 0) {
+    return [];
+  }
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  const parts = input.split(",").map((s) => s.trim());
+  for (const part of parts) {
+    const num = parseInt(part, 10);
+    if (isNaN(num) || num < 1 || num > INTERACTIVE_TEMPLATES.length) {
+      continue;
+    }
+    const template = INTERACTIVE_TEMPLATES[num - 1];
+    if (!seen.has(template.key)) {
+      seen.add(template.key);
+      selected.push({ ...template });
+    }
+  }
+  return selected;
+}
+
+// src/onboarding/index.ts
+var DOC_FILES = ["SOUL.md", "CLAUDE.md", "AGENTS.md", "README.md"];
+function detectCapabilities(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (opts.fromFile) {
+    const filePath = opts.fromFile.startsWith("/") ? opts.fromFile : join(cwd, opts.fromFile);
+    if (existsSync2(filePath)) {
+      const content = readFileSync2(filePath, "utf-8");
+      const capabilities = detectFromDocs(content);
+      if (capabilities.length > 0) {
+        return { source: "docs", capabilities, sourceFile: filePath };
+      }
+    }
+    return { source: "none", capabilities: [] };
+  }
+  for (const fileName of DOC_FILES) {
+    const filePath = join(cwd, fileName);
+    if (!existsSync2(filePath)) continue;
+    const content = readFileSync2(filePath, "utf-8");
+    if (fileName === "SOUL.md") {
+      return { source: "soul", capabilities: [], soulContent: content, sourceFile: filePath };
+    }
+    const capabilities = detectFromDocs(content);
+    if (capabilities.length > 0) {
+      return { source: "docs", capabilities, sourceFile: filePath };
+    }
+  }
+  const envKeys = detectApiKeys(KNOWN_API_KEYS);
+  if (envKeys.length > 0) {
+    return { source: "env", capabilities: [], envKeys };
+  }
+  return { source: "none", capabilities: [] };
+}
+function capabilitiesToV2Card(capabilities, owner, agentName) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const skills = capabilities.map((cap) => ({
+    id: cap.key,
+    name: cap.name,
+    description: `${cap.name} capability \u2014 ${cap.category}`,
+    level: 1,
+    category: cap.category.toLowerCase().replace(/\s+/g, "_"),
+    inputs: [{ name: "input", type: "text", required: true }],
+    outputs: [{ name: "output", type: "text", required: true }],
+    pricing: { credits_per_call: cap.credits_per_call },
+    availability: { online: true },
+    metadata: {
+      tags: cap.tags
+    }
+  }));
+  const card = {
+    spec_version: "2.0",
+    id: randomUUID2(),
+    owner,
+    agent_name: agentName ?? owner,
+    skills,
+    availability: { online: true },
+    created_at: now,
+    updated_at: now
+  };
+  return CapabilityCardV2Schema.parse(card);
+}
+
+// src/cli/init-action.ts
+import { createInterface as createInterface2 } from "readline";
+async function confirm(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    return await new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        resolve(answer.trim().toLowerCase() === "y");
+      });
+    });
+  } finally {
+    rl.close();
+  }
+}
+function getLanIp() {
+  const nets = networkInterfaces();
+  for (const ifaces of Object.values(nets)) {
+    for (const iface of ifaces ?? []) {
+      if (iface.family === "IPv4" && !iface.internal) return iface.address;
+    }
+  }
+  return "localhost";
+}
+function loadIdentityAuth(owner) {
+  const configDir = getConfigDir();
+  const { identity, keys } = loadOrRepairIdentity(configDir, owner);
+  return {
+    agentId: identity.agent_id,
+    publicKey: identity.public_key,
+    privateKey: keys.privateKey
+  };
+}
+function syncAgentRecord(db, identity, owner, displayName) {
+  const existingAgent = lookupAgent(db, identity.agent_id) ?? lookupAgentByOwner(db, owner);
+  if (!existingAgent) {
+    createAgentRecord(db, {
+      agent_id: identity.agent_id,
+      display_name: displayName,
+      public_key: identity.public_key,
+      legacy_owner: owner
+    });
+    return;
+  }
+  const updates = {};
+  if (existingAgent.display_name !== displayName) {
+    updates.display_name = displayName;
+  }
+  if (existingAgent.legacy_owner !== owner) {
+    updates.legacy_owner = owner;
+  }
+  if (Object.keys(updates).length > 0) {
+    updateAgentRecord(db, existingAgent.agent_id, updates);
+  }
+}
+async function performInit(opts) {
+  const configDir = getConfigDir();
+  const dbPath = join2(configDir, "registry.db");
+  const creditDbPath = join2(configDir, "credit.db");
+  const port = parseInt(opts.port, 10);
+  const ip = opts.host ?? getLanIp();
+  const yesMode = opts.yes ?? opts.nonInteractive ?? false;
+  const existingConfig = loadConfig();
+  const owner = opts.agentId ?? opts.owner ?? existingConfig?.owner ?? `agent-${randomBytes(4).toString("hex")}`;
+  const config = {
+    ...existingConfig,
+    owner,
+    gateway_url: `http://${ip}:${port}`,
+    gateway_port: port,
+    db_path: dbPath,
+    credit_db_path: creditDbPath,
+    token: existingConfig?.token ?? randomBytes(32).toString("hex"),
+    api_key: existingConfig?.api_key ?? randomBytes(32).toString("hex"),
+    ...existingConfig?.registry ? { registry: existingConfig.registry } : yesMode ? { registry: "https://agentbnb.fly.dev" } : {}
+  };
+  saveConfig(config);
+  const identityMaterial = loadOrRepairIdentity(configDir, owner);
+  const identity = identityMaterial.identity;
+  const keypairStatus = identityMaterial.status === "generated" ? "generated" : "existing";
+  const creditDb = openCreditDb(creditDbPath);
+  const registryDb = openDatabase(dbPath);
+  syncAgentRecord(creditDb, identity, owner, config.display_name ?? owner);
+  syncAgentRecord(registryDb, identity, owner, config.display_name ?? owner);
+  if (existingConfig?.owner && existingConfig.owner !== owner) {
+    migrateOwner(creditDb, existingConfig.owner, owner);
+    const rows = registryDb.prepare("SELECT id, owner, data FROM capability_cards WHERE owner = ?").all(existingConfig.owner);
+    for (const row of rows) {
+      try {
+        const card = JSON.parse(row.data);
+        const updatedCard = attachCanonicalAgentId(registryDb, {
+          ...card,
+          owner
+        });
+        registryDb.prepare("UPDATE capability_cards SET owner = ?, data = ? WHERE id = ?").run(owner, JSON.stringify(updatedCard), row.id);
+      } catch {
+      }
+    }
+    if (!opts.json && rows.length > 0) {
+      console.log(`Migrated ${rows.length} card(s) \u2192 ${owner}`);
+    }
+    const allOwners = creditDb.prepare("SELECT owner FROM credit_balances WHERE owner != ?").all(owner);
+    for (const { owner: oldOwner } of allOwners) {
+      migrateOwner(creditDb, oldOwner, owner);
+    }
+    if (existingConfig.registry) {
+      try {
+        const renameAuth = loadIdentityAuth(owner);
+        const renameLedger = createLedger({
+          registryUrl: existingConfig.registry,
+          ownerPublicKey: renameAuth.publicKey,
+          privateKey: renameAuth.privateKey
+        });
+        await renameLedger.rename(existingConfig.owner, owner);
+        if (!opts.json) {
+          console.log(`Migrated Registry credits: ${existingConfig.owner} \u2192 ${owner}`);
+        }
+      } catch (err) {
+        if (!opts.json) {
+          console.warn(`Warning: could not migrate Registry credits: ${err.message}`);
+        }
+      }
+    }
+    if (!opts.json) {
+      console.log(`Migrated local credits: ${existingConfig.owner} \u2192 ${owner}`);
+    }
+  }
+  if (!config.agent_id || config.agent_id !== identity.agent_id) {
+    config.agent_id = identity.agent_id;
+    saveConfig(config);
+  }
+  bootstrapAgent(creditDb, identity.agent_id, 100);
+  registryDb.close();
+  creditDb.close();
+  let registryBalance;
+  if (config.registry) {
+    try {
+      const identityAuth = loadIdentityAuth(owner);
+      const ledger = createLedger({
+        registryUrl: config.registry,
+        ownerPublicKey: identityAuth.publicKey,
+        privateKey: identityAuth.privateKey
+      });
+      await ledger.grant(owner, 50);
+      registryBalance = await ledger.getBalance(owner);
+    } catch (err) {
+      console.warn(`Warning: could not connect to Registry for credit grant: ${err.message}`);
+    }
+  }
+  const skipDetect = opts.detect === false;
+  const publishedCards = [];
+  let detectedSource = "none";
+  if (!skipDetect) {
+    if (!opts.json) {
+      console.log("\nDetecting capabilities...");
+    }
+    const result = detectCapabilities({ fromFile: opts.from, cwd: process.cwd() });
+    detectedSource = result.source;
+    if (result.source === "soul") {
+      if (!opts.json) {
+        console.log(`  Found SOUL.md \u2014 extracting capabilities...`);
+      }
+      const db = openDatabase(dbPath);
+      try {
+        const card = publishFromSoulV2(db, result.soulContent, owner);
+        publishedCards.push({ id: card.id, name: card.agent_name });
+        if (!opts.json) {
+          console.log(`  Published v2.0 card: ${card.agent_name} (${card.skills.length} skills)`);
+        }
+      } finally {
+        db.close();
+      }
+    } else if (result.source === "docs") {
+      if (!opts.json) {
+        console.log(`  Found ${result.sourceFile ?? "docs"} \u2014 detected ${result.capabilities.length} capabilities:`);
+        for (const cap of result.capabilities) {
+          console.log(`    ${cap.name} (${cap.category}, cr ${cap.credits_per_call}/call)`);
+        }
+      }
+      const card = capabilitiesToV2Card(result.capabilities, owner);
+      if (yesMode) {
+        const db = openDatabase(dbPath);
+        try {
+          const storedCard = attachCanonicalAgentId(db, card);
+          db.prepare(
+            `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?)`
+          ).run(
+            storedCard.id,
+            storedCard.owner,
+            JSON.stringify(storedCard),
+            storedCard.created_at,
+            storedCard.updated_at
+          );
+          publishedCards.push({ id: storedCard.id, name: storedCard.agent_name });
+          if (!opts.json) {
+            console.log(`  Published v2.0 card: ${storedCard.agent_name} (${storedCard.skills.length} skills)`);
+          }
+        } finally {
+          db.close();
+        }
+      } else if (process.stdout.isTTY) {
+        const yes = await confirm(`
+Publish these ${card.skills.length} capabilities? [y/N] `);
+        if (yes) {
+          const db = openDatabase(dbPath);
+          try {
+            const storedCard = attachCanonicalAgentId(db, card);
+            db.prepare(
+              `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?)`
+            ).run(
+              storedCard.id,
+              storedCard.owner,
+              JSON.stringify(storedCard),
+              storedCard.created_at,
+              storedCard.updated_at
+            );
+            publishedCards.push({ id: storedCard.id, name: storedCard.agent_name });
+            console.log(`  Published v2.0 card: ${storedCard.agent_name} (${storedCard.skills.length} skills)`);
+          } finally {
+            db.close();
+          }
+        } else {
+          console.log("  Skipped publishing.");
+        }
+      } else {
+        if (!opts.json) {
+          console.log("  Non-interactive environment. Re-run with --yes to auto-publish.");
+        }
+      }
+    } else if (result.source === "env") {
+      const detectedKeys = result.envKeys ?? [];
+      if (!opts.json) {
+        console.log(`  Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${detectedKeys.join(", ")}`);
+      }
+      const detectedPorts = await detectOpenPorts([7700, 7701, 8080, 3e3, 8e3, 11434]);
+      if (detectedPorts.length > 0 && !opts.json) {
+        console.log(`  Found services on ports: ${detectedPorts.join(", ")}`);
+      }
+      const drafts = detectedKeys.map((key) => buildDraftCard(key, owner)).filter((card) => card !== null);
+      if (yesMode) {
+        const db = openDatabase(dbPath);
+        try {
+          for (const card of drafts) {
+            insertCard(db, card);
+            publishedCards.push({ id: card.id, name: card.name });
+            if (!opts.json) {
+              console.log(`  Published: ${card.name} (${card.id})`);
+            }
+          }
+        } finally {
+          db.close();
+        }
+      } else if (process.stdout.isTTY) {
+        const db = openDatabase(dbPath);
+        try {
+          for (const card of drafts) {
+            const yes = await confirm(`Publish "${card.name}"? [y/N] `);
+            if (yes) {
+              insertCard(db, card);
+              publishedCards.push({ id: card.id, name: card.name });
+              console.log(`  Published: ${card.name} (${card.id})`);
+            } else {
+              console.log(`  Skipped: ${card.name}`);
+            }
+          }
+        } finally {
+          db.close();
+        }
+      } else {
+        if (!opts.json) {
+          console.log("  Non-interactive environment. Re-run with --yes to auto-publish.");
+        }
+      }
+    } else {
+      if (process.stdout.isTTY && !yesMode && !opts.json) {
+        const selected = await interactiveTemplateMenu();
+        if (selected.length > 0) {
+          const card = capabilitiesToV2Card(selected, owner);
+          const db = openDatabase(dbPath);
+          try {
+            const storedCard = attachCanonicalAgentId(db, card);
+            db.prepare(
+              `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?)`
+            ).run(
+              storedCard.id,
+              storedCard.owner,
+              JSON.stringify(storedCard),
+              storedCard.created_at,
+              storedCard.updated_at
+            );
+            publishedCards.push({ id: storedCard.id, name: storedCard.agent_name });
+            console.log(`
+  Published v2.0 card: ${storedCard.agent_name} (${storedCard.skills.length} skills)`);
+          } finally {
+            db.close();
+          }
+        }
+      } else if (!opts.json) {
+        console.log("  No capabilities detected. You can manually publish with `agentbnb publish`.");
+      }
+    }
+  }
+  return {
+    config,
+    owner,
+    configDir,
+    publishedCards,
+    registryBalance,
+    identity: { agent_id: identity.agent_id },
+    keypairStatus,
+    detectedSource
+  };
+}
+
+export {
+  publishFromSoulV2,
+  generateHeartbeatSection,
+  injectHeartbeatSection,
+  getOpenClawStatus,
+  performInit
+};