agentbnb 8.2.0 → 8.2.1

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "8.2.0",
+  "version": "8.2.1",
   "description": "P2P Agent Capability Sharing Protocol — Airbnb for AI agent pipelines",
   "type": "module",
   "main": "dist/index.js",
@@ -32,17 +32,6 @@
       "import": "./dist/identity/index.js"
     }
   },
-  "scripts": {
-    "build": "tsup",
-    "build:hub": "cd hub && pnpm install && pnpm build",
-    "build:all": "pnpm build && pnpm build:hub",
-    "dev": "tsx watch src/cli/index.ts",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "lint": "eslint src/",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "pnpm run build && pnpm run typecheck && pnpm run test:run"
-  },
   "keywords": [
     "ai",
     "agent",
@@ -81,6 +70,7 @@
     "fastify": "^5.1.0",
     "js-yaml": "^4.1.1",
     "typed-emitter": "^2.1.0",
+    "undici": "^7.24.6",
     "ws": "^8.19.0",
     "zod": "^3.24.0"
   },
@@ -92,9 +82,15 @@
   "engines": {
     "node": ">=20.0.0"
   },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "better-sqlite3"
-    ]
+  "scripts": {
+    "build": "tsup",
+    "build:hub": "cd hub && pnpm install && pnpm build",
+    "build:all": "pnpm build && pnpm build:hub",
+    "dev": "tsx watch src/cli/index.ts",
+    "test": "vitest run",
+    "test:run": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/skills/agentbnb/bootstrap.test.ts

@@ -110,7 +110,9 @@ describe('bootstrap activate/deactivate lifecycle', () => {
   it('activate() throws INIT_FAILED when CLI not found and config missing', async () => {
     mockLoadConfig.mockReturnValue(null);
     const deps: OnboardDeps = {
-      findCli: () => null,
+      resolveSelfCli: () => {
+        throw new Error('not found');
+      },
       runCommand: vi.fn(),
     };
 
@@ -126,15 +128,15 @@ describe('bootstrap activate/deactivate lifecycle', () => {
     mockLoadConfig.mockReturnValueOnce(null).mockReturnValue(MINIMAL_CONFIG as ReturnType<typeof loadConfig>);
     const mockRun = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
     const deps: OnboardDeps = {
-      findCli: () => '/usr/local/bin/agentbnb',
+      resolveSelfCli: () => '/usr/local/bin/agentbnb',
       runCommand: mockRun,
     };
 
     ctx = await activate({}, deps);
 
     expect(mockRun).toHaveBeenCalledTimes(2);
-    expect(mockRun.mock.calls[0][0]).toMatch(/agentbnb init --owner .* --yes --no-detect/);
-    expect(mockRun.mock.calls[1][0]).toBe('agentbnb openclaw sync');
+    expect(mockRun.mock.calls[0][0]).toMatch(/^'\/usr\/local\/bin\/agentbnb' init --owner .* --yes --no-detect$/);
+    expect(mockRun.mock.calls[1][0]).toBe('\'/usr/local/bin/agentbnb\' openclaw sync');
   });
 
   // ---------------------------------------------------------------------------
@@ -146,7 +148,7 @@ describe('bootstrap activate/deactivate lifecycle', () => {
       .mockResolvedValueOnce({ stdout: '', stderr: '' })
       .mockRejectedValueOnce(new Error('SOUL.md not found'));
     const deps: OnboardDeps = {
-      findCli: () => '/usr/local/bin/agentbnb',
+      resolveSelfCli: () => '/usr/local/bin/agentbnb',
       runCommand: mockRun,
     };
 
@@ -161,7 +163,7 @@ describe('bootstrap activate/deactivate lifecycle', () => {
   it('activate() skips auto-onboard when config already exists', async () => {
     const mockRun = vi.fn();
     const deps: OnboardDeps = {
-      findCli: () => '/usr/local/bin/agentbnb',
+      resolveSelfCli: () => '/usr/local/bin/agentbnb',
       runCommand: mockRun,
     };
 

package/skills/agentbnb/bootstrap.ts

@@ -11,7 +11,7 @@
 import { join, basename, dirname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { spawnSync, exec } from 'node:child_process';
+import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { randomUUID } from 'node:crypto';
 
@@ -51,6 +51,7 @@ import { getConfigDir, loadConfig } from '../../src/cli/config.js';
 import { AgentBnBError } from '../../src/types/index.js';
 import { ProcessGuard } from '../../src/runtime/process-guard.js';
 import { ServiceCoordinator } from '../../src/runtime/service-coordinator.js';
+import { resolveSelfCli } from '../../src/runtime/resolve-self-cli.js';
 import type { ServiceOptions, ServiceStatus } from '../../src/runtime/service-coordinator.js';
 import { AgentBnBService } from '../../src/app/agentbnb-service.js';
 import { openDatabase } from '../../src/registry/store.js';
@@ -174,15 +175,15 @@ function registerDecomposerCard(configDir: string, owner: string): void {
 }
 
 /**
- * Checks if the `agentbnb` CLI is available in PATH.
- * @returns Absolute path to the CLI, or null if not found.
+ * Checks if the `agentbnb` CLI can be resolved to an absolute executable path.
+ * @returns Absolute path to the CLI, or null if resolution fails.
  */
 export function findCli(): string | null {
-  const result = spawnSync('which', ['agentbnb'], { encoding: 'utf-8', stdio: 'pipe' });
-  if (result.status === 0 && result.stdout.trim()) {
-    return result.stdout.trim();
+  try {
+    return resolveSelfCli();
+  } catch {
+    return null;
   }
-  return null;
 }
 
 /**
@@ -222,32 +223,35 @@ function deriveAgentName(configDir: string): string {
  */
 /** Injectable dependencies for autoOnboard (test seam). */
 export interface OnboardDeps {
-  findCli: () => string | null;
+  resolveSelfCli: () => string;
   runCommand: (cmd: string, env: Record<string, string | undefined>) => Promise<{ stdout: string; stderr: string }>;
 }
 
 /** Default production dependencies. */
-const defaultDeps: OnboardDeps = { findCli, runCommand };
+const defaultDeps: OnboardDeps = { resolveSelfCli, runCommand };
 
 async function autoOnboard(configDir: string, deps: OnboardDeps = defaultDeps): Promise<import('./../../src/cli/config.js').AgentBnBConfig> {
   process.stderr.write('[agentbnb] First-time setup: initializing agent identity...\n');
 
   // Step 0: Check CLI exists
-  const cliPath = deps.findCli();
-  if (!cliPath) {
+  let cliPath: string;
+  try {
+    cliPath = deps.resolveSelfCli();
+  } catch {
     process.stderr.write('[agentbnb] CLI not found. Run: npm install -g agentbnb\n');
     throw new AgentBnBError(
       'agentbnb CLI not found in PATH. Install with: npm install -g agentbnb',
       'INIT_FAILED',
     );
   }
+  const quotedCliPath = quoteShellArg(cliPath);
 
   const env = { ...process.env, AGENTBNB_DIR: configDir };
   const agentName = deriveAgentName(configDir);
 
   // Step 1: Initialize identity (keypair + config.json + credit bootstrap)
   try {
-    await deps.runCommand(`agentbnb init --owner "${agentName}" --yes --no-detect`, env);
+    await deps.runCommand(`${quotedCliPath} init --owner "${agentName}" --yes --no-detect`, env);
     process.stderr.write(`[agentbnb] Agent "${agentName}" initialized.\n`);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -256,7 +260,7 @@ async function autoOnboard(configDir: string, deps: OnboardDeps = defaultDeps):
 
   // Step 2: Publish capabilities from SOUL.md (if it exists)
   try {
-    await deps.runCommand('agentbnb openclaw sync', env);
+    await deps.runCommand(`${quotedCliPath} openclaw sync`, env);
     process.stderr.write('[agentbnb] Capabilities published from SOUL.md.\n');
   } catch {
     // Non-fatal: SOUL.md may not exist yet, or sync may fail for other reasons.
@@ -276,6 +280,10 @@ async function autoOnboard(configDir: string, deps: OnboardDeps = defaultDeps):
   return config;
 }
 
+function quoteShellArg(input: string): string {
+  return `'${input.replace(/'/g, `'\\''`)}'`;
+}
+
 /**
  * Brings an AgentBnB node online (idempotent — safe to call when already running).
  * Registers SIGTERM/SIGINT handlers that conditionally stop the node on process exit.

package/dist/chunk-64AK4FJM.js

@@ -1,84 +0,0 @@
-import {
-  signEscrowReceipt
-} from "./chunk-CUONY5TO.js";
-import {
-  AgentBnBError
-} from "./chunk-WVY2W7AA.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 ?? {},
-      requester: opts.requester,
-      escrowReceipt: opts.escrowReceipt,
-      timeoutMs: opts.timeoutMs
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes("timeout")) {
-      throw new AgentBnBError(message, "TIMEOUT");
-    }
-    if (message.includes("offline")) {
-      throw new AgentBnBError(message, "AGENT_OFFLINE");
-    }
-    throw new AgentBnBError(message, "RELAY_ERROR");
-  }
-}
-
-export {
-  requestCapability,
-  requestViaRelay
-};

package/dist/chunk-OH7BP5NP.js

@@ -1,96 +0,0 @@
-import {
-  generateKeyPair,
-  loadKeyPair,
-  saveKeyPair
-} from "./chunk-CUONY5TO.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) {
-    if (existing.owner !== owner) {
-      existing.owner = owner;
-      saveIdentity(configDir, existing);
-    }
-    return existing;
-  }
-  return createIdentity(configDir, owner);
-}
-
-export {
-  deriveAgentId,
-  ensureIdentity
-};