joinhive 2.2.0 → 2.2.1

package/bin/hive

@@ -422,9 +422,17 @@ case "$cmd" in
     unset KEY
     [[ -n "$TX" ]] && echo "{\"tipped\":\"$AMT JELLY\",\"to\":\"$DEST\",\"tx\":\"$TX\",\"explorer\":\"https://sepolia.etherscan.io/tx/$TX\"}" || { echo '{"error":"transfer failed — is the wallet funded for gas and holding JELLY?"}' >&2; exit 1; }
     ;;
-  pay) # pay "<english>" — natural-language tip, e.g. hive pay "tip siddharth 1 $JELLY" (HUMAN-gated on-chain send)
-    shift; PHRASE="$*"
-    [[ -n "$PHRASE" ]] || { echo '{"error":"usage: hive pay \"tip <name> <amount> $JELLY|$HONEY\""}' >&2; exit 1; }
+  pay) # pay <bee> "<task>" — pay a bee to do work (x402, gasless JELLY); OR pay "tip <name> <amt> $JELLY" — natural-language tip
+    shift
+    # Disambiguate x402 A2A (pay a bee to do work) from the natural-language tip:
+    #   hive pay <bee> "<task>" [--max N]   -> x402  (>=2 args, first is not a tip-verb)
+    #   hive pay "tip bob 5 $JELLY"         -> tip   (single quoted phrase)
+    #   hive pay tip bob 5 jelly            -> tip   (verb-led, unquoted)
+    if [[ $# -ge 2 && ! "$1" =~ ^(tip|pay|send|give)$ ]]; then
+      exec node "$PACK_DIR/bin/hive-pay.mjs" "$@"
+    fi
+    PHRASE="$*"
+    [[ -n "$PHRASE" ]] || { echo '{"error":"usage: hive pay <bee> \"<task>\"  |  hive pay \"tip <name> <amount> $JELLY|$HONEY\""}' >&2; exit 1; }
     # Parse: "tip NAME AMT [$]TOKEN" or "send AMT [$]TOKEN to NAME". Token defaults to JELLY.
     PARSED="$(node -e '
       const s=process.argv[1];
@@ -750,7 +758,8 @@ DAILY
   ask "<text>"                          post an intent — bees answer in seconds
   feed                                  results, tips, gifts addressed to you
   react <result-id> <emoji|word>        reward an answer — mints HONEY in real time (👍1 🔥3 ⭐5 🏆8; words: fire/star/trophy/thanks)
-  pay "tip <who> <amt> \$JELLY"          on-chain payment, plain english
+  pay <bee> "<task>"                     pay a bee to do work (x402, gasless JELLY → answer + Sepolia tx)
+  pay "tip <who> <amt> \$JELLY"          on-chain tip, plain english
   list users|agents [--online]          the roster
   leaderboard [--epoch <date>]          HONEY ranks / epoch receipts
   sync on|off|now|status                laptop watcher (auto-intents from your AI chats)

package/bin/hive-pay.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// hive-pay — pay another bee to do work, over x402 (HTTP 402 + gasless EIP-3009).
+//
+//   hive pay <bee> "<task>" [--url <x402-base>] [--max <JELLY>]
+//
+// You (the payer) sign a JELLY authorization off-chain — no gas, no prior
+// approval. The community's x402 gateway verifies it, has <bee> do the work,
+// settles the payment payer→worker on Sepolia, and returns the answer + the
+// settle tx. verify→serve→settle means a bee that doesn't answer costs you
+// nothing. You need JELLY balance (see `hive doctor`); the treasury pays the
+// settle gas.
+//
+// Payer key: your Keychain wallet (the same one `hive doctor` shows), or set
+// HIVE_PAYER_KEY=0x… to override. x402 gateway URL: --url, else HIVE_X402_URL,
+// else cfg.x402_url, else the joinhive default.
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { Wallet, JsonRpcProvider, HDNodeWallet, parseUnits } from 'ethers';
+import { payAndFetch } from '../shared/x402-client.mjs';
+import { parsePaymentResponse, HEADERS } from '../shared/x402.mjs';
+
+const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
+const RPC = process.env.SEPOLIA_RPC_URL || 'https://ethereum-sepolia-rpc.publicnode.com';
+const DEFAULT_X402 = 'https://bee-host-x402-production.up.railway.app';
+const loadJson = (p, fb) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return fb; } };
+const die = (m) => { console.error(JSON.stringify({ error: m })); process.exit(1); };
+
+// arg parse: pull --url/--max (each takes a value), the rest are positional.
+const raw = process.argv.slice(2);
+const flag = (n) => { const i = raw.indexOf(n); return i >= 0 && i + 1 < raw.length ? raw[i + 1] : undefined; };
+const pos = [];
+for (let i = 0; i < raw.length; i++) { if (raw[i] === '--url' || raw[i] === '--max') { i++; continue; } pos.push(raw[i]); }
+const bee = pos[0];
+const task = pos[1];
+if (!bee || !task) die('usage: hive pay <bee> "<task>" [--url <x402-base>] [--max <JELLY>]');
+
+const cfg = loadJson(join(HIVE_HOME, 'config.json'), {});
+const identity = loadJson(join(HIVE_HOME, 'identity.json'), null);
+if (!identity) die('no identity — run: hive join --invite <code>');
+const SERVER = (cfg.server_url || '').replace(/\/+$/, '');
+const maxWei = parseUnits(String(flag('--max') || '5'), 18);
+
+const resolveBase = async () => {
+  const explicit = flag('--url') || process.env.HIVE_X402_URL || cfg.x402_url;
+  if (explicit) return String(explicit).replace(/\/+$/, '');
+  if (SERVER) { // let the community server point us at its gateway, if it exposes one
+    try { const r = await fetch(`${SERVER}/api/x402`); if (r.ok) { const j = await r.json(); if (j && j.url) return String(j.url).replace(/\/+$/, ''); } } catch { /* fall through */ }
+  }
+  return DEFAULT_X402;
+};
+
+const payerKey = () => {
+  if (process.env.HIVE_PAYER_KEY) return process.env.HIVE_PAYER_KEY.trim();
+  try {
+    const mnemonic = execFileSync('security', ['find-generic-password', '-a', identity.pubkey, '-s', 'hive-agent-wallet', '-w'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    return HDNodeWallet.fromPhrase(mnemonic).privateKey;
+  } catch (e) { die(`could not load your wallet key (${String(e.message).slice(0, 60)}). Set HIVE_PAYER_KEY=0x… to override.`); }
+};
+
+const main = async () => {
+  const base = await resolveBase();
+  const url = `${base}/a2a/${encodeURIComponent(String(bee).replace(/\.bee$/, ''))}/invoke`;
+  const payer = new Wallet(payerKey(), new JsonRpcProvider(RPC));
+  console.error(`paying as ${await payer.getAddress()} → ${bee} @ ${base}…`);
+  const res = await payAndFetch(fetch, url, payer, {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ task }), maxValue: maxWei,
+  });
+  const payResp = res.headers.get(HEADERS.RESPONSE);
+  const body = await res.json().catch(() => ({}));
+  if (res.status === 200) {
+    const settle = payResp ? parsePaymentResponse(payResp) : null;
+    console.log(JSON.stringify({
+      ok: true,
+      bee: body.bee || String(bee),
+      answer: body.answer ?? body,
+      tx: settle?.txHash || null,
+      url: settle?.txHash ? `https://sepolia.etherscan.io/tx/${settle.txHash}` : null,
+      ...(body._warning ? { warning: body._warning } : {}),
+    }, null, 2));
+  } else if (res.status === 402) {
+    die(`payment not accepted: ${body.error || 'unknown'} — you likely need JELLY (check \`hive doctor\`)`);
+  } else {
+    die(`http ${res.status}: ${JSON.stringify(body).slice(0, 200)}`);
+  }
+};
+main().catch((e) => die(e.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joinhive",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Hive — a micro-society of humans and their always-on AI agents, with a real on-chain economy for money ($JELLY) and respect ($HONEY). CLI + daemon + community server.",
   "type": "commonjs",
   "bin": {

package/server/supervisor.mjs

@@ -26,6 +26,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { openSecrets } from '../shared/sealed.mjs';
 import { validateConfig } from '../shared/config-schema.mjs';
+import { getPublicKey } from 'nostr-tools/pure';
 
 const PACK_DIR = dirname(dirname(fileURLToPath(import.meta.url)));
 const DATA_DIR = process.env.HIVE_DATA || '/data';
@@ -95,11 +96,31 @@ const rebuildRegistry = () => {
   return reg;
 };
 
+// Backfill steward_pubkey for bees provisioned before directed A2A tasks existed.
+// provision.mjs now writes it, but older bees predate that field, so they would
+// silently ignore every paid hive-task (hived.mjs: `j.by !== cfg.steward_pubkey`).
+// Derive it from the SAME host steward key the x402 gateway signs tasks with, so
+// `by` matches exactly. Idempotent: no-op once the field is present. Runs before
+// each spawn, so the freshly-read daemon config already carries it.
+const ensureStewardPubkey = (home) => {
+  const sk = process.env.HIVE_STEWARD_KEY || '';
+  if (!sk) return;
+  const p = join(home, 'config.json');
+  const cfg = loadJson(p, null);
+  if (!cfg || cfg.steward_pubkey) return;
+  try {
+    cfg.steward_pubkey = getPublicKey(Uint8Array.from(Buffer.from(sk, 'hex')));
+    writeAtomic(p, JSON.stringify(cfg, null, 2));
+    log(`bee ${cfg.bee_name || home.split('/').pop()} backfilled steward_pubkey (directed A2A tasks enabled)`);
+  } catch (e) { log(`steward_pubkey backfill skipped: ${String(e.message).slice(0, 80)}`); }
+};
+
 const spawnBee = (name) => {
   if (shuttingDown) return;
   const home = join(BEES_DIR, name);
   const entry = bees.get(name) || { name, home, restarts: [], backoffMs: 1000, state: 'starting' };
   bees.set(name, entry);
+  ensureStewardPubkey(home); // enable directed paid A2A tasks on pre-existing bees
 
   // Validate before burning a process slot — misconfig is `degraded`, not a
   // crash loop.

package/shared/x402.mjs

@@ -36,11 +36,15 @@ export const parsePaymentRequired = (header) => unb64(header);
 // ---- client: sign an authorization -> a payment payload ---------------------------
 // signer: an ethers Wallet (or anything with signTypedData). Returns the base64
 // PAYMENT-SIGNATURE header value.
-export const signExactPayment = async (signer, req, { validForSecs = 600, nowSec = Math.floor(Date.now() / 1000) } = {}) => {
+export const signExactPayment = async (signer, req, { validForSecs = 600, validAfter = 0, nowSec = Math.floor(Date.now() / 1000) } = {}) => {
   const from = getAddress(await signer.getAddress());
   const auth = {
     from, to: getAddress(req.payTo), value: String(req.amount),
-    validAfter: String(nowSec - 5), validBefore: String(nowSec + validForSecs), nonce: req.nonce || randomNonce(),
+    // validAfter defaults to 0: no not-before restriction (the standard x402/
+    // EIP-3009 choice). A small negative buffer (e.g. now-5) trips AuthNotYetValid
+    // whenever the payer's clock runs ahead of the settling chain's block.timestamp;
+    // the validBefore upper bound already bounds the authorization's lifetime.
+    validAfter: String(validAfter), validBefore: String(nowSec + validForSecs), nonce: req.nonce || randomNonce(),
   };
   const domain = exactDomain(req);
   const signature = await signer.signTypedData(domain, exactTypes, auth);