agentbnb 4.0.1 → 4.0.2

package/dist/{server-2LWHL24P.js → server-365V3GYD.js}

@@ -1,14 +1,14 @@
 import {
   ensureIdentity
-} from "./chunk-M3G5NR2Z.js";
+} from "./chunk-QITOPASZ.js";
 import {
   createLedger
-} from "./chunk-ODBGCCEH.js";
+} from "./chunk-HH24WMFN.js";
 import {
   fetchRemoteCards,
   mergeResults,
   searchCards
-} from "./chunk-QJEOCKVF.js";
+} from "./chunk-FF226TIV.js";
 import {
   getConfigDir,
   loadConfig
@@ -16,17 +16,17 @@ import {
 import {
   insertCard,
   openDatabase
-} from "./chunk-TLU7ALCZ.js";
+} from "./chunk-T7NS2J2B.js";
 import {
   getBalance,
   openCreditDb
-} from "./chunk-XQHN6ITI.js";
+} from "./chunk-DNWT5FZQ.js";
 import {
   loadKeyPair
-} from "./chunk-DVAS2443.js";
+} from "./chunk-5KFI5X7B.js";
 import {
   AnyCardSchema
-} from "./chunk-FNKBHBYK.js";
+} from "./chunk-WGZ5AGOX.js";
 
 // src/mcp/server.ts
 import { createRequire } from "module";
@@ -273,9 +273,9 @@ async function startMcpServer() {
   registerDiscoverTool(server, ctx);
   registerStatusTool(server, ctx);
   registerPublishTool(server, ctx);
-  const { registerRequestTool } = await import("./request-CNZ3XIVX.js");
-  const { registerConductTool } = await import("./conduct-CW62HBPT.js");
-  const { registerServeSkillTool } = await import("./serve-skill-SUOGUM7N.js");
+  const { registerRequestTool } = await import("./request-4GQSSM4B.js");
+  const { registerConductTool } = await import("./conduct-N52JX7RT.js");
+  const { registerServeSkillTool } = await import("./serve-skill-TPHZH6BS.js");
   registerRequestTool(server, ctx);
   registerConductTool(server, ctx);
   registerServeSkillTool(server, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbnb",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "P2P Agent Capability Sharing Protocol — Airbnb for AI agent pipelines",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,8 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "skills"
   ],
   "exports": {
     ".": {
@@ -25,10 +26,6 @@
     "./identity": {
       "types": "./dist/identity/index.d.ts",
       "import": "./dist/identity/index.js"
-    },
-    "./adapters/claude-code": {
-      "types": "./dist/adapters/claude-code/index.d.ts",
-      "import": "./dist/adapters/claude-code/index.js"
     }
   },
   "scripts": {

package/skills/agentbnb/HEARTBEAT.rules.md

@@ -0,0 +1,47 @@
+# AgentBnB Autonomy Rules — HEARTBEAT.md Template (v3.0)
+
+This file contains the autonomy rules block for the AgentBnB OpenClaw skill.
+
+**How to use:**
+- Copy the content between the markers directly into your `HEARTBEAT.md` file, OR
+- Run `agentbnb openclaw rules` to generate a rules block with your *actual configured thresholds*
+
+**Note:** The values shown below are example defaults (Tier 1: 10 credits, Tier 2: 50 credits,
+reserve: 20 credits). The `agentbnb openclaw rules` command outputs rules using the owner's
+real configured thresholds from `~/.agentbnb/config.json`.
+
+**Identity:** On activation, the agent's Ed25519 identity is verified via `~/.agentbnb/identity.json`.
+This identity is used for escrow receipt signing and P2P verification.
+
+---
+
+<!-- agentbnb: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:
+  - < 10 credits: auto-execute, no notification (Tier 1)
+  - 10-50 credits: execute, notify owner after (Tier 2)
+  - > 50 credits: ask owner before executing (Tier 3)
+
+### Credit Management
+- Maintain minimum balance of 20 credits (reserve for emergencies)
+- If balance drops below 20, increase sharing priority
+- If balance exceeds 500, notify owner of surplus
+
+### Autonomy Configuration
+- Default: Tier 3 (ask before all actions) until owner configures thresholds
+- Configure via: `agentbnb config set tier1 <credits>` and `agentbnb config set tier2 <credits>`
+- Reserve floor: `agentbnb config set reserve <credits>` (default 20)
+<!-- agentbnb:end -->

package/skills/agentbnb/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: agentbnb
+description: "P2P capability sharing for AI agents — earn credits by sharing idle APIs, spend credits to request capabilities from peer agents. Use when an agent needs to join the AgentBnB network, publish capability cards, manage credits, or request skills from peers."
+license: MIT
+compatibility: "Requires Node.js >= 20 and pnpm. Designed for OpenClaw agents. Compatible with Claude Code, Gemini CLI, and other AgentSkills-compatible tools."
+on_install: auto
+metadata:
+  author: "Cheng Wen Chen"
+  version: "3.0.0"
+  tags: "ai-agent-skill,claude-code,agent-skills,p2p,capability-sharing"
+---
+
+This skill connects your agent to the AgentBnB P2P capability sharing network.
+
+## Quick Start
+
+**Step 1: Run the install script.**
+
+```bash
+bash install.sh
+```
+
+This installs the AgentBnB CLI, initializes `~/.agentbnb/` config, and syncs your SOUL.md if present.
+
+**Step 2: Import `activate()` from `bootstrap.ts` and bring your agent online.**
+
+```typescript
+import { activate, deactivate } from './bootstrap.js';
+
+const ctx = await activate({
+  owner: 'your-agent-id',
+  soulMdPath: './SOUL.md',
+  registryDbPath: './registry.db',  // omit to use ~/.agentbnb/registry.db
+  creditDbPath: './credit.db',       // omit to use ~/.agentbnb/credit.db
+  gatewayPort: 7700,
+  gatewayToken: 'your-bearer-token', // omit to auto-generate
+  silent: false,
+});
+
+// ctx.runtime   — AgentRuntime (DB handles + background jobs)
+// ctx.gateway   — Fastify HTTP server on gatewayPort
+// ctx.idleMonitor — IdleMonitor polling on 60s cadence
+// ctx.card      — Published CapabilityCardV2 from SOUL.md
+```
+
+**Step 3: When done, call `deactivate()` to clean up all resources.**
+
+```typescript
+await deactivate(ctx);
+// Closes gateway, stops cron jobs, closes DB handles. Idempotent.
+```
+
+## On Install
+
+`install.sh` performs the following steps automatically:
+
+1. Checks Node.js >= 20 is available (exits with error if not).
+2. Checks pnpm is available; falls back to npm if not.
+3. Runs `pnpm install -g agentbnb` (or `npm install -g agentbnb`).
+4. Runs `agentbnb init --yes` to create `~/.agentbnb/` with default config.
+5. Runs `agentbnb openclaw sync` if SOUL.md is found in the current or parent directory.
+6. Prints a success summary with next steps.
+
+## Programmatic API
+
+Use `activate()` and `deactivate()` from `bootstrap.ts` for full lifecycle control.
+
+### `activate(config: BootstrapConfig): Promise<BootstrapContext>`
+
+Brings an agent fully online in order: Runtime → publishCard → gateway.listen → IdleMonitor.
+
+**BootstrapConfig fields:**
+
+| Field | Type | Default | Purpose |
+|---|---|---|---|
+| `owner` | `string` | required | Agent owner identifier |
+| `soulMdPath` | `string` | required | Absolute path to SOUL.md |
+| `registryDbPath` | `string` | `~/.agentbnb/registry.db` | Registry SQLite path |
+| `creditDbPath` | `string` | `~/.agentbnb/credit.db` | Credit SQLite path |
+| `gatewayPort` | `number` | `7700` | HTTP port for incoming capability requests |
+| `gatewayToken` | `string` | auto `randomUUID()` | Bearer token for gateway auth |
+| `handlerUrl` | `string` | `http://localhost:{gatewayPort}` | URL for capability forwarding |
+| `autonomyConfig` | `AutonomyConfig` | `DEFAULT_AUTONOMY_CONFIG` (Tier 3) | Tier thresholds |
+| `silent` | `boolean` | `false` | Suppress gateway logs |
+
+Throws `AgentBnBError` with code `FILE_NOT_FOUND` if `soulMdPath` does not exist.
+
+**BootstrapContext fields:**
+
+| Field | Type | Description |
+|---|---|---|
+| `runtime` | `AgentRuntime` | DB handles + background job registry |
+| `gateway` | `FastifyInstance` | HTTP gateway accepting capability requests |
+| `idleMonitor` | `IdleMonitor` | Cron job monitoring idle rates every 60s |
+| `card` | `CapabilityCardV2` | Published card derived from SOUL.md |
+
+### `deactivate(ctx: BootstrapContext): Promise<void>`
+
+Tears down all active components: `gateway.close()` then `runtime.shutdown()`.
+Idempotent — safe to call multiple times without throwing.
+
+## Autonomy Rules
+
+Full rules block is in `HEARTBEAT.rules.md`. Copy into your `HEARTBEAT.md`, or run:
+
+```bash
+agentbnb openclaw rules
+```
+
+This outputs a rules block using your actual configured thresholds (not the example defaults).
+
+**Summary of the 3 tiers:**
+
+- **Tier 1** (< tier1 credits): Auto-execute, no notification.
+- **Tier 2** (tier1–tier2 credits): Execute and notify owner after.
+- **Tier 3** (> tier2 credits): Ask owner before executing. (Default on fresh installs.)
+
+**Reserve floor:** Maintain a minimum credit balance (default 20). When balance ≤ reserve, auto-request is blocked. Increase sharing priority to recover.
+
+**Idle sharing:** When a skill's `idle_rate` exceeds 70%, `IdleMonitor` auto-shares it according to the active tier.
+
+Configure thresholds:
+
+```bash
+agentbnb config set tier1 10    # auto-execute under 10 credits
+agentbnb config set tier2 50    # notify-after under 50 credits
+agentbnb config set reserve 20  # keep 20 credit reserve
+```
+
+## CLI Reference
+
+```bash
+agentbnb serve                    # Start accepting incoming capability requests
+agentbnb openclaw sync            # Parse SOUL.md and publish capability card to registry
+agentbnb openclaw status          # Show sync state, credit balance, idle rates
+agentbnb openclaw rules           # Emit HEARTBEAT.md rules block with real thresholds
+agentbnb config set tier1 <N>     # Set Tier 1 credit threshold
+agentbnb config set tier2 <N>     # Set Tier 2 credit threshold
+agentbnb config set reserve <N>   # Set minimum credit reserve floor
+agentbnb discover                 # Find peers on the local network via mDNS
+agentbnb request --query "..."    # Manually request a capability from the network
+```
+
+## Adapters
+
+Use individual adapters if you need custom wiring. `bootstrap.ts` composes all of these.
+
+| Adapter | Export | Purpose |
+|---|---|---|
+| `gateway.ts` | `AgentRuntime`, `createGatewayServer` | HTTP gateway for receiving requests |
+| `auto-share.ts` | `IdleMonitor` | Per-skill idle rate polling + auto-share |
+| `auto-request.ts` | `AutoRequestor` | Peer scoring + budget-gated capability requests |
+| `credit-mgr.ts` | `BudgetManager`, `getBalance` | Credit reserve floor + balance queries |
+
+```typescript
+// Example: use IdleMonitor directly without full bootstrap
+import { IdleMonitor } from './auto-share.js';
+
+const monitor = new IdleMonitor({
+  owner: 'my-agent',
+  db: runtime.registryDb,
+  autonomyConfig: config.autonomy,
+});
+const job = monitor.start();
+runtime.registerJob(job);
+```

package/skills/agentbnb/auto-request.ts

@@ -0,0 +1,14 @@
+/**
+ * AgentBnB Auto-Request adapter for OpenClaw skill integration.
+ * Delegates to AutoRequestor from src/autonomy/.
+ * This is a thin re-export wrapper — no business logic lives here.
+ */
+import { AutoRequestor } from '../../src/autonomy/auto-request.js';
+import type {
+  AutoRequestOptions,
+  CapabilityNeed,
+  AutoRequestResult,
+} from '../../src/autonomy/auto-request.js';
+
+export { AutoRequestor };
+export type { AutoRequestOptions, CapabilityNeed, AutoRequestResult };

package/skills/agentbnb/auto-share.ts

@@ -0,0 +1,10 @@
+/**
+ * AgentBnB Auto-Share adapter for OpenClaw skill integration.
+ * Delegates to IdleMonitor from src/autonomy/.
+ * This is a thin re-export wrapper — no business logic lives here.
+ */
+import { IdleMonitor } from '../../src/autonomy/idle-monitor.js';
+import type { IdleMonitorOptions } from '../../src/autonomy/idle-monitor.js';
+
+export { IdleMonitor };
+export type { IdleMonitorOptions };

package/skills/agentbnb/bootstrap.test.ts

@@ -0,0 +1,323 @@
+/**
+ * Integration test for bootstrap.ts activate()/deactivate() lifecycle.
+ *
+ * Tests the full lifecycle using real implementations with in-memory DBs:
+ *   activate() -> runtime + card published + gateway listening + IdleMonitor running
+ *   deactivate() -> gateway closed + runtime shutdown + resources cleaned up
+ *
+ * No mocks — this is an end-to-end integration test.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { activate, deactivate } from './bootstrap.js';
+import type { BootstrapContext } from './bootstrap.js';
+import { IdleMonitor } from '../../src/autonomy/idle-monitor.js';
+import { loadIdentity } from '../../src/identity/identity.js';
+
+// ---------------------------------------------------------------------------
+// Test fixture: minimal SOUL.md with 2 skills
+// ---------------------------------------------------------------------------
+const SOUL_MD_CONTENT = `# Test Agent
+
+A test agent for integration testing.
+
+## Code Review
+Reviews code for quality and bugs.
+
+## Translation
+Translates text between languages.
+`;
+
+// ---------------------------------------------------------------------------
+// Test suite
+// ---------------------------------------------------------------------------
+
+describe('bootstrap activate/deactivate lifecycle', () => {
+  let tmpDir: string | undefined;
+  let ctx: BootstrapContext | undefined;
+
+  /**
+   * Create a fresh temp dir with a SOUL.md file.
+   * Returns the absolute path to the SOUL.md file.
+   */
+  function setupSoulMd(): string {
+    tmpDir = mkdtempSync(join(tmpdir(), 'agentbnb-test-'));
+    const path = join(tmpDir, 'SOUL.md');
+    writeFileSync(path, SOUL_MD_CONTENT, 'utf8');
+    return path;
+  }
+
+  // Ensure all resources are torn down after every test
+  afterEach(async () => {
+    if (ctx) {
+      await deactivate(ctx).catch(() => undefined);
+      ctx = undefined;
+    }
+    if (tmpDir) {
+      rmSync(tmpDir, { recursive: true, force: true });
+      tmpDir = undefined;
+    }
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 1: activate() returns BootstrapContext with all components
+  // ---------------------------------------------------------------------------
+  it('activate() returns BootstrapContext with all components', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // runtime has both DB handles
+    expect(ctx.runtime).toBeDefined();
+    expect(ctx.runtime.registryDb).toBeDefined();
+    expect(ctx.runtime.creditDb).toBeDefined();
+
+    // gateway is a Fastify instance (has inject method)
+    expect(ctx.gateway).toBeDefined();
+    expect(typeof ctx.gateway.inject).toBe('function');
+
+    // idleMonitor is an IdleMonitor instance
+    expect(ctx.idleMonitor).toBeInstanceOf(IdleMonitor);
+
+    // card has correct structure: spec_version 2.0, 2 skills
+    expect(ctx.card.spec_version).toBe('2.0');
+    expect(Array.isArray(ctx.card.skills)).toBe(true);
+    expect(ctx.card.skills!.length).toBe(2);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 2: activate() publishes card from SOUL.md into registry
+  // ---------------------------------------------------------------------------
+  it('activate() publishes card from SOUL.md into registry', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // Query the registry DB for capability_cards owned by this agent
+    const rows = ctx.runtime.registryDb
+      .prepare('SELECT id, owner, data FROM capability_cards WHERE owner = ?')
+      .all('test-agent') as Array<{ id: string; owner: string; data: string }>;
+
+    expect(rows.length).toBe(1);
+    expect(rows[0].owner).toBe('test-agent');
+
+    // Parse the card data and verify both skills are present
+    const cardData = JSON.parse(rows[0].data) as {
+      skills?: Array<{ name: string }>;
+    };
+    const skillNames = (cardData.skills ?? []).map((s) => s.name);
+    expect(skillNames).toContain('Code Review');
+    expect(skillNames).toContain('Translation');
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 3: activate() starts gateway that responds to health check
+  // ---------------------------------------------------------------------------
+  it('activate() starts gateway that responds to health check', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // Use Fastify inject — no real HTTP connection needed
+    const response = await ctx.gateway.inject({
+      method: 'GET',
+      url: '/health',
+    });
+
+    expect(response.statusCode).toBe(200);
+    const body = JSON.parse(response.body) as { status: string };
+    expect(body.status).toBe('ok');
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 4: activate() registers IdleMonitor job in runtime.jobs
+  // ---------------------------------------------------------------------------
+  it('activate() registers IdleMonitor job in runtime.jobs', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // At least one cron job registered (the IdleMonitor's polling job)
+    expect(ctx.runtime.jobs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 5: deactivate() sets runtime.isDraining to true
+  // ---------------------------------------------------------------------------
+  it('deactivate() sets runtime.isDraining to true', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    expect(ctx.runtime.isDraining).toBe(false);
+
+    await deactivate(ctx);
+    // Clear so afterEach doesn't double-deactivate
+    const savedCtx = ctx;
+    ctx = undefined;
+
+    expect(savedCtx.runtime.isDraining).toBe(true);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 6: deactivate() closes DB handles
+  // ---------------------------------------------------------------------------
+  it('deactivate() closes DB handles', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // Capture reference before clearing ctx
+    const runtime = ctx.runtime;
+    await deactivate(ctx);
+    ctx = undefined;
+
+    // Queries should throw after DB handles are closed
+    expect(() => {
+      runtime.registryDb.prepare('SELECT 1').get();
+    }).toThrow();
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 7: deactivate() is idempotent
+  // ---------------------------------------------------------------------------
+  it('deactivate() is idempotent', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    await deactivate(ctx);
+    // Second call must not throw
+    await expect(deactivate(ctx)).resolves.not.toThrow();
+
+    ctx = undefined;
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 8: activate() throws when SOUL.md does not exist
+  // ---------------------------------------------------------------------------
+  it('activate() throws when SOUL.md does not exist', async () => {
+    await expect(
+      activate({
+        owner: 'test-agent',
+        soulMdPath: '/nonexistent/path/SOUL.md',
+        registryDbPath: ':memory:',
+        creditDbPath: ':memory:',
+        gatewayPort: 0,
+        silent: true,
+      }),
+    ).rejects.toThrow();
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 9: activate() with identityRequired creates identity.json
+  // ---------------------------------------------------------------------------
+  it('activate() with identityRequired creates identity.json', async () => {
+    const soulMdPath = setupSoulMd();
+    const identityDir = mkdtempSync(join(tmpdir(), 'agentbnb-identity-'));
+
+    // Temporarily override HOME so identity writes to temp dir
+    const origHome = process.env['HOME'];
+    process.env['HOME'] = identityDir;
+
+    try {
+      ctx = await activate({
+        owner: 'identity-agent',
+        soulMdPath,
+        registryDbPath: ':memory:',
+        creditDbPath: ':memory:',
+        gatewayPort: 0,
+        silent: true,
+        identityRequired: true,
+      });
+
+      // identity should be populated
+      expect(ctx.identity).not.toBeNull();
+      expect(ctx.identity!.owner).toBe('identity-agent');
+      expect(ctx.identity!.agent_id).toBeTruthy();
+
+      // identity.json should exist on disk
+      const identityPath = join(identityDir, '.agentbnb', 'identity.json');
+      expect(existsSync(identityPath)).toBe(true);
+
+      const loaded = loadIdentity(join(identityDir, '.agentbnb'));
+      expect(loaded).not.toBeNull();
+      expect(loaded!.agent_id).toBe(ctx.identity!.agent_id);
+    } finally {
+      process.env['HOME'] = origHome;
+      rmSync(identityDir, { recursive: true, force: true });
+    }
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 10: activate() without identityRequired skips identity creation
+  // ---------------------------------------------------------------------------
+  it('activate() without identityRequired skips identity creation', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+      identityRequired: false,
+    });
+
+    expect(ctx.identity).toBeNull();
+  });
+});