joinhive 2.0.0

package/daemon/engines/cli.mjs

@@ -0,0 +1,25 @@
+// Legacy `claude -p`-style subprocess engine — laptop back-compat only.
+// Cloud bees never use this (the supervisor's config validation forbids it).
+// Keeps the two quirks the old daemon needed:
+//   - strip CLAUDECODE/CLAUDE_CODE_* so a daemon launched from inside a
+//     Claude Code session isn't refused as a nested session
+//   - close stdin (headless CLIs block on open stdin pipes)
+import { execFile } from 'node:child_process';
+
+export const cliCall = (cfg, kind, prompt, tier) => new Promise((resolve) => {
+  const env = { ...process.env };
+  for (const k of Object.keys(env)) if (k === 'CLAUDECODE' || k.startsWith('CLAUDE_CODE_')) delete env[k];
+  let args = cfg.engine_args || [];
+  // compute (and settle/offer) use the stronger model, mirroring the old
+  // per-call --model override.
+  const modelOverride = kind === 'compute' ? cfg.compute_model : null;
+  if (modelOverride) {
+    const i = args.indexOf('--model');
+    args = i >= 0 ? args.map((a, k) => (k === i + 1 ? modelOverride : a)) : [...args, '--model', modelOverride];
+  }
+  const child = execFile(cfg.engine || 'claude', [...args, prompt], { timeout: Math.max(tier.timeoutMs, 120_000), maxBuffer: 4 * 1024 * 1024, env },
+    (err, stdout, stderr) => resolve(err
+      ? `engine-error: exit=${err.code ?? err.signal} stderr=${String(stderr).slice(0, 400)}`
+      : stdout.toString().trim()));
+  child.stdin?.end();
+});

package/daemon/engines/index.mjs

@@ -0,0 +1,84 @@
+// daemon/engines — provider-agnostic LLM engine.
+//
+// Replaces the `claude -p` subprocess (which billed the operator's personal
+// Claude Code subscription via the macOS Keychain and cannot exist on a
+// server). Each bee thinks with ITS MEMBER'S OWN API KEY.
+//
+// Contract (the daemon's bail logic depends on it — keep exact):
+//   - extract/compute/selftest resolve a STRING, never throw
+//   - failures resolve to a string starting with "engine-error: "
+//   - `echo` provider returns "echo-engine: <first 120 chars>" (test seam)
+//
+// Usage accounting: every API call appends one JSONL line to
+// $HIVE_HOME/usage.jsonl: {ts, kind, provider, model, tokens_in, tokens_out, ms, ok}.
+import { appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { anthropicCall } from './anthropic.mjs';
+import { openaiCall } from './openai.mjs';
+import { cliCall } from './cli.mjs';
+
+const TIER = { extract: { timeoutMs: 30_000, maxTokens: 400 }, compute: { timeoutMs: 90_000, maxTokens: 1200 }, selftest: { timeoutMs: 20_000, maxTokens: 16 } };
+const RETRIABLE = new Set([408, 409, 429, 500, 502, 503, 504, 529]);
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// One attempt loop shared by both HTTP providers. call(model, prompt, opts)
+// must return {ok, text, status?, retryAfterMs?, tokens_in?, tokens_out?, error?}.
+const withRetry = async (call, model, prompt, opts) => {
+  let last = null;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    last = await call(model, prompt, opts);
+    if (last.ok) return last;
+    const retriable = last.status ? RETRIABLE.has(last.status) : last.network === true;
+    if (!retriable || attempt === 2) return last;
+    await sleep(last.retryAfterMs ?? (1000 * (attempt + 1) + Math.floor(Math.random() * 400)));
+  }
+  return last;
+};
+
+export const createEngine = (cfg, secrets = {}, { home, log = () => {} } = {}) => {
+  const provider = cfg.provider || 'cli';
+
+  const record = (kind, model, res, ms) => {
+    if (!home) return;
+    try {
+      appendFileSync(join(home, 'usage.jsonl'), JSON.stringify({
+        ts: Math.floor(Date.now() / 1000), kind, provider, model,
+        tokens_in: res.tokens_in ?? null, tokens_out: res.tokens_out ?? null,
+        ms, ok: !!res.ok,
+      }) + '\n');
+    } catch {}
+  };
+
+  const run = async (kind, prompt) => {
+    const tier = TIER[kind] || TIER.compute;
+    if (provider === 'echo') return 'echo-engine: ' + prompt.slice(0, 120);
+    if (provider === 'cli') return cliCall(cfg, kind, prompt, tier);
+
+    const model = kind === 'extract' || kind === 'selftest' ? cfg.model_extract : cfg.model_compute;
+    if (!model) return `engine-error: no model configured for ${kind} (provider ${provider})`;
+    const apiKey = secrets.llm_api_key;
+    if (!apiKey) return 'engine-error: no LLM API key configured for this bee';
+
+    const call = provider === 'anthropic' ? anthropicCall : openaiCall;
+    const started = Date.now();
+    const res = await withRetry(call, model, prompt, { apiKey, baseUrl: cfg.base_url, timeoutMs: tier.timeoutMs, maxTokens: kind === 'selftest' ? TIER.selftest.maxTokens : tier.maxTokens });
+    record(kind === 'selftest' ? 'selftest' : kind, model, res, Date.now() - started);
+    if (!res.ok) {
+      const detail = res.error || `http=${res.status}`;
+      log(`engine ${provider}/${model} failed: ${String(detail).slice(0, 160)}`);
+      return `engine-error: ${String(detail).slice(0, 300)}`;
+    }
+    return (res.text || '').trim();
+  };
+
+  return {
+    extract: (prompt) => run('extract', prompt),
+    compute: (prompt) => run('compute', prompt),
+    selftest: async () => {
+      if (provider === 'echo') return 'echo-engine: OK';
+      const out = await run('selftest', 'Reply with exactly: OK');
+      return out;
+    },
+  };
+};

package/daemon/engines/openai.mjs

@@ -0,0 +1,42 @@
+// OpenAI-compatible /chat/completions via native fetch. One file covers three
+// providers by base_url: OpenAI, OpenRouter, and Hermes (Nous Research).
+//
+// Token-limit param drift: OpenAI's current models want max_completion_tokens;
+// OpenRouter/Hermes (and most compatible shims) take max_tokens. Send the one
+// that matches the base_url.
+
+export const openaiCall = async (model, prompt, { apiKey, baseUrl, timeoutMs, maxTokens }) => {
+  const base = String(baseUrl || 'https://api.openai.com/v1').replace(/\/$/, '');
+  const isOpenAI = /api\.openai\.com/.test(base);
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${base}/chat/completions`, {
+      method: 'POST',
+      signal: ctl.signal,
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        ...(isOpenAI ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens }),
+      }),
+    });
+    const retryAfter = Number(res.headers.get('retry-after'));
+    if (!res.ok) {
+      let msg = `${isOpenAI ? 'openai' : 'openai-compat'} http=${res.status}`;
+      try { const j = await res.json(); msg += ` ${String(j?.error?.message || j?.error || '').slice(0, 160)}`; } catch {}
+      return { ok: false, status: res.status, error: msg.trim(), retryAfterMs: Number.isFinite(retryAfter) ? retryAfter * 1000 : undefined };
+    }
+    const j = await res.json();
+    const text = j.choices?.[0]?.message?.content ?? '';
+    return { ok: true, text: typeof text === 'string' ? text : '', tokens_in: j.usage?.prompt_tokens ?? null, tokens_out: j.usage?.completion_tokens ?? null };
+  } catch (e) {
+    const aborted = e?.name === 'AbortError';
+    return { ok: false, network: !aborted, error: aborted ? `timeout after ${timeoutMs}ms (${base})` : `network: ${String(e?.message || e).slice(0, 160)} (${base})` };
+  } finally {
+    clearTimeout(t);
+  }
+};

package/daemon/fanout.mjs

@@ -0,0 +1,47 @@
+// daemon/fanout — who answers a broadcast intent when 15 bees all see it.
+//
+// Without this, every bee answers every intent: O(N) result spam per ask and
+// N engine bills for one question. Policy:
+//   1. Your OWN bee always serves you (beneficiary === owner_pubkey).
+//   2. Otherwise a bee is eligible only if a protocol matched OR the intent
+//      overlaps its profile's interests (whole-token match, words > 3 chars).
+//   3. Among eligible bees, a deterministic election picks top_k: rank =
+//      sha256(intent_event_id + bee_pubkey). No coordination messages, stable
+//      under retries, uniformly random per intent. Needs the bee roster —
+//      supervisor-written registry.json (HIVE_REGISTRY). Solo laptop
+//      endpoints have no registry and stay always-eligible (old behavior).
+// Local caps (results/tick, results/day) are enforced by the caller.
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+const sha = (s) => createHash('sha256').update(s).digest('hex');
+
+// Registry shape: { [nostr_pubkey]: {name, evm?, is_bee?, bee_of?} }
+export const loadRoster = (registryPath) => {
+  if (!registryPath) return null;
+  try {
+    const reg = JSON.parse(readFileSync(registryPath, 'utf8'));
+    const bees = Object.entries(reg).filter(([, v]) => v && v.is_bee).map(([pk]) => pk);
+    return bees.length ? bees : null;
+  } catch { return null; }
+};
+
+const STOPWORDS = new Set(['what', 'this', 'that', 'with', 'from', 'about', 'have', 'want', 'need', 'like', 'find', 'some', 'should', 'would', 'could', 'recommend', 'recommendations']);
+
+export const profileOverlap = (intent, profileText) => {
+  const words = String(intent).toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 3 && !STOPWORDS.has(w));
+  if (!words.length) return false;
+  const prof = ` ${String(profileText).toLowerCase()} `;
+  return words.some((w) => prof.includes(` ${w} `) || prof.includes(`${w},`) || prof.includes(`${w}.`));
+};
+
+// -> {respond: bool, reason: string}
+export const shouldAnswer = ({ intentEventId, intent, beneficiary, selfPubkey, ownerPubkey, matchedProtocols, profileText, topK, roster }) => {
+  if (beneficiary === ownerPubkey && ownerPubkey) return { respond: true, reason: 'own-owner' };
+  const eligible = (matchedProtocols && matchedProtocols.length > 0) || profileOverlap(intent, profileText || '');
+  if (!eligible) return { respond: false, reason: 'not-eligible' };
+  if (!roster || roster.length <= topK) return { respond: true, reason: 'eligible' };
+  const ranked = [...roster].sort((a, b) => sha(intentEventId + a).localeCompare(sha(intentEventId + b)));
+  const inTopK = ranked.slice(0, topK).includes(selfPubkey);
+  return { respond: inTopK, reason: inTopK ? 'elected' : 'not-elected' };
+};