openzoo 0.50.0 → 0.50.2

package/bin/openzoo.js

@@ -113,6 +113,15 @@ usage:
                               and launches Grok Bot with Node TLS override (sudo required;
                               ctrl-c restores /etc/hosts).
                               --no-takeover plain launch · --no-launch config only
+  npx openzoo voice      write like YOU — your own exports, paid per call
+                         voice ingest --telegram <telegram_messages.txt> --twitter <archive dir>
+                               parse your history into turns and bind the tier cascade
+                               (cream / all telegram / all twitter) to the gateway + leCore
+                         voice card --telegram <file>   distil the style card (one paid call)
+                         voice say "draft"              rewrite a draft in your voice
+                         voice login / voice watch      PREHOOK your own outgoing Telegram
+                               messages: type raw, the watcher revises in place (userbot;
+                               "." prefix sends raw). X has no edit API — no equivalent.
   npx openzoo openclaw   write the zoo into ~/.openclaw/openclaw.json as a model
                          provider WITH REAL PRICES (OpenClaw's own custom-provider
                          path hard-codes $0.00 and ignores /v1/models pricing)
@@ -171,6 +180,23 @@ async function main() {
     case 'openclaw':
       await (await import('../lib/openclaw.js')).setupOpenClaw(process.argv.slice(3));
       break;
+    case 'voice':
+      await (await import('../lib/voice.js')).runVoice(process.argv.slice(3));
+      break;
+    case 'sonar':
+      await (await import('../lib/sonar.js')).runSonar(process.argv.slice(3));
+      break;
+    // @openzoobot. runXBot was only ever reachable as a library export, so the
+    // obvious `openzoo xbot` printed usage and did nothing.
+    case 'xbot': {
+      const a = process.argv.slice(3);
+      await (await import('../lib/xbot.js')).runXBot({
+        once: a.includes('--once'),
+        dryRun: a.includes('--dry-run') || a.includes('--dry'),
+        seed: a.includes('--seed'),
+      });
+      break;
+    }
     case 'mcp':
       await (await import('../lib/mcp.js')).startMcp();
       break;

package/lib/dotenv.js

@@ -0,0 +1,37 @@
+/**
+ * The smallest possible .env loader — no dependency, no magic.
+ *
+ * WHY IT EXISTS: credentialed URLs and tokens were being pasted onto
+ * every command line, which puts them in shell history, in process
+ * listings, and eventually in a screenshot. A file the repo ignores is
+ * the right place for them.
+ *
+ * NEVER OVERRIDES a value already in the environment: an explicit
+ * `FOO=bar node ...` must win over a stale line in a file, or debugging
+ * becomes guesswork about which value is live.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+
+export function loadDotenv(file = path.join(HERE, '..', '.env')) {
+  let raw;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch { return {}; }
+  const loaded = {};
+  for (const line of raw.split('\n')) {
+    const t = line.trim();
+    if (!t || t.startsWith('#')) continue;
+    const eq = t.indexOf('=');
+    if (eq < 1) continue;
+    const key = t.slice(0, eq).trim();
+    let val = t.slice(eq + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    if (process.env[key] === undefined) { process.env[key] = val; loaded[key] = true; }
+  }
+  return loaded;
+}

package/lib/pay.js

@@ -305,8 +305,22 @@ export class PayClient {
       ...init,
       headers: { ...stripAuthorization(init.headers || {}), ...paymentHeaders(payment.header) },
     });
-    const settle = decodeSettleHeader(response.headers.get('x-payment-response'))
-      || { signature: payment.ownerSignature };
+    // NEVER PRESENT OUR OWN SIGNATURE AS THE TRANSACTION.
+    //
+    // This fell back to `{ signature: payment.ownerSignature }`, and on Solana
+    // that signature CANNOT EXIST ON CHAIN: the facilitator is fee payer, so it
+    // re-signs the payload before submitting and the resulting transaction has
+    // a different signature entirely. MEASURED 2026-08-25 — the receipt printed
+    // `tx 4wJ42z5dtnt2h7NZpKM5…`, which getTransaction reports as NOT FOUND,
+    // for a payment that really settled as `2YgJg97DnK4cuvhE1jhCiwYS…`
+    // (slot 441794097, 0.147837 TOKEN moved). The gateway's chat path did not
+    // send `x-payment-response` at the time, so this fired on EVERY call: every
+    // Solana receipt a customer could check came back "not found", which reads
+    // as "I was never charged" when they were.
+    //
+    // No settle header now means no tx line, not a plausible-looking wrong one.
+    // An absent id is honest; an unverifiable id is worse than useless.
+    const settle = decodeSettleHeader(response.headers.get('x-payment-response')) || null;
     const receipt = {
       at: new Date().toISOString(),
       line: receiptLine(accept, settle),

package/lib/proxy.js

@@ -794,14 +794,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     );
     console.log(`openzoo v${version}  ->  ${config.apiBase}`);
     console.log(`listening on   http://localhost:${config.port}/v1`);
-    // LAND THEM IN THE APP. Never in CI/agents (no TTY), never twice, opt out
-    // with OPENZOO_NO_OPEN=1.
-    if (process.stdout.isTTY && !process.env.OPENZOO_NO_OPEN) {
-      const opener = process.platform === 'darwin' ? 'open'
-        : process.platform === 'win32' ? 'start' : 'xdg-open';
-      import('node:child_process').then(({ exec }) =>
-        exec(`${opener} http://localhost:${config.port}/`, () => {}));
-    }
+    // The chat GUI still lives at GET / — but it is never auto-opened.
     console.log('');
     if (client.walletCreated) console.log(`new burner wallet created at ${client.walletPath} (chmod 600)`);
     console.log(`wallet (fund me) · solana: ${client.address}`);

package/lib/receipts.js

@@ -0,0 +1,139 @@
+/**
+ * The receipt ledger — every paid call, kept.
+ *
+ * WHY ON DISK: the receipt is the product. A line that scrolls past in a
+ * terminal proves nothing an hour later, and "59x cheaper than OpenRouter"
+ * is a claim anyone can ask you to back up. This is the backing: an
+ * append-only JSONL of every call the shim has paid for, with both the
+ * billed price and what the SAME tokens on the SAME model would have cost
+ * buying direct, so the multiple is arithmetic rather than marketing.
+ *
+ * Append-only and never rewritten: a ledger you can edit is not evidence.
+ * 0600, local, never uploaded — it contains what you wrote and what it
+ * cost, which is nobody's business but yours.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const RECEIPTS_FILE = process.env.OPENZOO_RECEIPTS
+  || path.join(os.homedir(), '.openzoo', 'receipts.jsonl');
+
+/**
+ * Record one paid call. Never throws: a ledger write must not be able to
+ * fail the thing it is recording.
+ *
+ * `input`/`output` are kept because a before/after pair is the only part
+ * of a receipt anyone actually enjoys reading. OPENZOO_RECEIPTS_NO_TEXT=1
+ * stores lengths only.
+ */
+export function recordReceipt(rec) {
+  try {
+    const keepText = process.env.OPENZOO_RECEIPTS_NO_TEXT !== '1';
+    const row = {
+      at: new Date().toISOString(),
+      kind: rec.kind || 'call',
+      model: rec.model || 'unknown',
+      billedUsd: Number(rec.billedUsd || 0),
+      directUsd: Number(rec.directUsd || 0),
+      seconds: Number(rec.seconds || 0),
+      inChars: Number(rec.inChars || (rec.input ? rec.input.length : 0)),
+      outChars: Number(rec.outChars || (rec.output ? rec.output.length : 0)),
+      ...(rec.stage ? { stage: rec.stage } : {}),
+      ...(rec.tool ? { tool: rec.tool } : {}),
+      ...(keepText && rec.input ? { input: rec.input } : {}),
+      ...(keepText && rec.output ? { output: rec.output } : {}),
+    };
+    fs.mkdirSync(path.dirname(RECEIPTS_FILE), { recursive: true, mode: 0o700 });
+    fs.appendFileSync(RECEIPTS_FILE, JSON.stringify(row) + '\n', { mode: 0o600 });
+    return row;
+  } catch {
+    return null;
+  }
+}
+
+export function readReceipts(file = RECEIPTS_FILE) {
+  try {
+    return fs.readFileSync(file, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function usd(n) {
+  if (!(n > 0)) return '$0';
+  if (n >= 0.01) return `$${n.toFixed(4)}`;
+  if (n >= 0.000001) return `$${n.toFixed(6)}`;
+  return `$${n.toExponential(1)}`;
+}
+
+/**
+ * Roll the ledger up into the numbers worth quoting.
+ *
+ * The headline multiple is TOTAL direct over TOTAL billed, not the mean of
+ * per-call multiples: averaging ratios lets one cheap call with a big
+ * multiple dominate a hundred expensive ones, which would be the exact
+ * kind of flattering-but-wrong number this ledger exists to avoid.
+ * Calls the gateway reported no direct price for are excluded from the
+ * comparison and counted separately, never silently treated as 1x.
+ */
+export function summarizeReceipts(rows = readReceipts()) {
+  const comparable = rows.filter((r) => r.billedUsd > 0 && r.directUsd > 0);
+  const billed = rows.reduce((n, r) => n + r.billedUsd, 0);
+  const cmpBilled = comparable.reduce((n, r) => n + r.billedUsd, 0);
+  const cmpDirect = comparable.reduce((n, r) => n + r.directUsd, 0);
+  const best = comparable
+    .map((r) => ({ ...r, x: r.directUsd / r.billedUsd }))
+    .sort((a, b) => b.x - a.x)[0] || null;
+  const byKind = {};
+  for (const r of rows) {
+    const k = byKind[r.kind] ||= { calls: 0, billed: 0, direct: 0, seconds: 0 };
+    k.calls += 1; k.billed += r.billedUsd; k.direct += r.directUsd; k.seconds += r.seconds;
+  }
+  return {
+    calls: rows.length,
+    since: rows[0]?.at ?? null,
+    billedUsd: billed,
+    comparable: comparable.length,
+    freeOrUnpriced: rows.length - comparable.length,
+    directUsd: cmpDirect,
+    savedUsd: Math.max(0, cmpDirect - cmpBilled),
+    multiple: cmpBilled > 0 ? cmpDirect / cmpBilled : 0,
+    avgSeconds: rows.length ? rows.reduce((n, r) => n + r.seconds, 0) / rows.length : 0,
+    best,
+    byKind,
+  };
+}
+
+/** The boast, printable. */
+export function formatSummary(s = summarizeReceipts()) {
+  if (!s.calls) return 'no receipts yet — nothing has been paid for.';
+  const lines = [
+    `openzoo receipts — ${s.calls} paid call${s.calls === 1 ? '' : 's'} since ${String(s.since).slice(0, 10)}`,
+    '',
+    `  spent          ${usd(s.billedUsd)}`,
+    `  same calls direct on OpenRouter  ${usd(s.directUsd)}   (over ${s.comparable} comparable call${s.comparable === 1 ? '' : 's'})`,
+    `  saved          ${usd(s.savedUsd)}${s.multiple >= 1.05 ? `  —  ${s.multiple.toFixed(1)}× cheaper overall` : ''}`,
+    `  avg latency    ${s.avgSeconds.toFixed(1)}s`,
+  ];
+  if (s.freeOrUnpriced) {
+    lines.push(`  (${s.freeOrUnpriced} call${s.freeOrUnpriced === 1 ? '' : 's'} had no comparable direct price — cached or unpriced, excluded above)`);
+  }
+  const kinds = Object.entries(s.byKind).sort((a, b) => b[1].calls - a[1].calls);
+  if (kinds.length > 1) {
+    lines.push('', '  by kind:');
+    for (const [k, v] of kinds) lines.push(`    ${k.padEnd(10)} ${String(v.calls).padStart(4)} calls  ${usd(v.billed)}`);
+  }
+  if (s.best) {
+    lines.push('', `  best single call: ${s.best.x.toFixed(1)}× — ${s.best.model} ${usd(s.best.billedUsd)} vs ${usd(s.best.directUsd)} direct`);
+    if (s.best.input) lines.push(`    in:  ${String(s.best.input).replace(/\s+/g, ' ').slice(0, 100)}`);
+    if (s.best.output) lines.push(`    out: ${String(s.best.output).replace(/\s+/g, ' ').slice(0, 100)}`);
+  }
+  lines.push('', `  ledger: ${RECEIPTS_FILE}`);
+  return lines.join('\n');
+}