openzoo 0.50.0 → 0.50.2

package/lib/voiceserve.js

@@ -0,0 +1,84 @@
+/**
+ * The local voice endpoint — what the browser extension talks to.
+ *
+ * WHY A LOCAL SERVER AND NOT A DIRECT CALL FROM THE EXTENSION: the rewrite
+ * needs the wallet (x402 settles from ~/.openzoo/wallet.json), the local
+ * leCore daemon (scored recall over your bound turns), and the style card
+ * on disk. None of those belong in a browser extension — shipping a
+ * keypair into an extension's storage is how you lose it. The extension
+ * stays dumb: it POSTs text to 127.0.0.1 and gets text back.
+ *
+ * Bound to loopback only, and CORS is restricted to the X origins. The
+ * threat model is "a random page in your browser can't spend your wallet",
+ * which loopback + origin allowlist covers.
+ */
+
+import http from 'node:http';
+import { voiceText } from './voice.js';
+
+const ALLOWED_ORIGINS = new Set([
+  'https://x.com',
+  'https://twitter.com',
+  'https://mobile.x.com',
+  'https://mobile.twitter.com',
+  ...(process.env.OPENZOO_VOICE_ORIGINS || '').split(',').map((s) => s.trim()).filter(Boolean),
+]);
+
+export const VOICE_PORT = Number(process.env.OPENZOO_VOICE_PORT || 8403);
+
+function cors(req, res) {
+  const origin = req.headers.origin || '';
+  if (ALLOWED_ORIGINS.has(origin)) {
+    res.setHeader('access-control-allow-origin', origin);
+    res.setHeader('access-control-allow-headers', 'content-type');
+    res.setHeader('access-control-allow-methods', 'POST, OPTIONS');
+    return true;
+  }
+  return false;
+}
+
+export async function runVoiceServe(args = []) {
+  const port = Number(args[0]) || VOICE_PORT;
+  const log = (m) => console.error(`  ${m}`);
+
+  const server = http.createServer(async (req, res) => {
+    const ok = cors(req, res);
+    if (req.method === 'OPTIONS') { res.writeHead(ok ? 204 : 403).end(); return; }
+    if (req.url === '/health') {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, service: 'openzoo voice' }));
+      return;
+    }
+    if (req.method !== 'POST' || req.url !== '/voice') { res.writeHead(404).end(); return; }
+    // An unlisted origin is refused BEFORE the wallet is touched: a rewrite
+    // is a paid call, so an open endpoint is an open tab away from spending
+    // your money on someone else's page.
+    if (!ok && req.headers.origin) { res.writeHead(403).end('origin not allowed'); return; }
+
+    let body = '';
+    req.on('data', (c) => { body += c; if (body.length > 100_000) req.destroy(); });
+    req.on('end', async () => {
+      try {
+        const { text, kind } = JSON.parse(body || '{}');
+        if (!text || typeof text !== 'string') { res.writeHead(400).end('no text'); return; }
+        const started = Date.now();
+        const r = await voiceText(text, { kind });
+        log(`${kind || 'post'}: ${text.length} → ${r.text.length} chars · ${((Date.now() - started) / 1000).toFixed(1)}s · ${r.receipt}`);
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ text: r.text, receipt: r.receipt, stage: r.stage }));
+      } catch (e) {
+        // NEVER block a post on our failure: the extension falls back to
+        // sending the draft as typed when this errors.
+        log(`voice failed: ${e.message?.slice(0, 160)}`);
+        res.writeHead(500, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: String(e.message || e) }));
+      }
+    });
+  });
+
+  await new Promise((resolve) => server.listen(port, '127.0.0.1', resolve));
+  console.error(`openzoo voice serve: http://127.0.0.1:${port}/voice (loopback only)`);
+  console.error('  load the extension from the openzoo checkout: extension/  (chrome://extensions → Load unpacked)');
+  console.error('  then post on x.com as usual — drafts are revised before they publish');
+  await new Promise(() => {});
+}

package/lib/voicewatch.js

@@ -0,0 +1,127 @@
+/**
+ * The Telegram PREHOOK — as close to one as the platform allows.
+ *
+ * Telegram's Bot API cannot see your own outgoing messages, but an MTProto
+ * USERBOT logged in as you can: it receives everything you send, in every
+ * chat, the moment you send it — and can edit your message in place. So
+ * the intercept is: you type raw, this watcher rewrites it into your voice
+ * (openzoo voice, paid x402 per message) and edits it ~a second later.
+ *
+ * Honest tradeoffs, stated up front:
+ *  - readers can glimpse the raw version before the edit lands
+ *  - edited messages show Telegram's "edited" tag
+ *  - a userbot is ToS-gray; self-editing sits at the tolerated end, but
+ *    this is YOUR account — keep the watcher's behavior boring
+ *
+ * Escapes: a message starting with "." is never touched (the raw marker);
+ * neither are /commands, forwards, media captions, or anything under
+ * OPENZOO_VOICE_MIN_CHARS. OPENZOO_VOICE_WATCH_CHATS (comma-separated
+ * chat ids) restricts the watcher to an allowlist.
+ *
+ * There is NO X equivalent: the X API has no edit endpoint and no
+ * pre-publish hook — the nearest X flows are composing THROUGH the bot,
+ * or delete-and-repost (which destroys replies; not built by default).
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+
+const SESSION_FILE = process.env.OPENZOO_VOICE_TG_SESSION
+  || path.join(os.homedir(), '.openzoo', 'voice-telegram.session');
+
+const MIN_CHARS = Number(process.env.OPENZOO_VOICE_MIN_CHARS || 12);
+
+function ask(q, { hidden = false } = {}) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(q, (answer) => { rl.close(); resolve(answer.trim()); });
+    if (hidden) rl._writeToOutput = () => {};
+  });
+}
+
+async function makeClient() {
+  let TelegramClient, StringSession;
+  try {
+    ({ TelegramClient } = await import('telegram'));
+    ({ StringSession } = await import('telegram/sessions/index.js'));
+  } catch {
+    throw new Error("the Telegram userbot needs the 'telegram' package — npm i telegram (in the openzoo checkout) and retry");
+  }
+  const apiId = Number(process.env.TELEGRAM_APP_ID || 0);
+  const apiHash = process.env.TELEGRAM_APP_HASH || '';
+  if (!apiId || !apiHash) {
+    throw new Error('set TELEGRAM_APP_ID and TELEGRAM_APP_HASH (create an app at https://my.telegram.org/apps) — these are YOUR user-account API credentials, not a bot token');
+  }
+  let saved = '';
+  try { saved = fs.readFileSync(SESSION_FILE, 'utf8').trim(); } catch { /* first run */ }
+  const client = new TelegramClient(new StringSession(saved), apiId, apiHash, { connectionRetries: 5 });
+  return { client, saved };
+}
+
+async function login(client) {
+  await client.start({
+    phoneNumber: () => ask('phone number (intl format): '),
+    phoneCode: () => ask('code from Telegram: '),
+    password: () => ask('2FA password (blank if none): ', { hidden: true }),
+    onError: (e) => console.error(`  login error: ${e.message}`),
+  });
+  fs.mkdirSync(path.dirname(SESSION_FILE), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(SESSION_FILE, client.session.save() + '\n', { mode: 0o600 });
+  console.error(`  session saved to ${SESSION_FILE} (0600) — 'openzoo voice watch' now runs headless`);
+}
+
+export async function runVoiceWatch(cmd, _args = []) {
+  const { client, saved } = await makeClient();
+
+  if (cmd === 'login') {
+    await login(client);
+    await client.disconnect();
+    return;
+  }
+
+  if (!saved) {
+    throw new Error("no userbot session yet — run 'openzoo voice login' once (interactive) first");
+  }
+  await client.connect();
+  const me = await client.getMe();
+  console.error(`openzoo voice watch: logged in as ${me.username ? '@' + me.username : me.firstName} — intercepting outgoing messages`);
+  console.error(`  escape hatch: start a message with "." to send it raw · min ${MIN_CHARS} chars · Ctrl-C to stop`);
+
+  const allow = (process.env.OPENZOO_VOICE_WATCH_CHATS || '')
+    .split(',').map((s) => s.trim()).filter(Boolean);
+
+  const { NewMessage } = await import('telegram/events/index.js');
+  const { voiceText } = await import('./voice.js');
+
+  client.addEventHandler(async (event) => {
+    const m = event.message;
+    try {
+      const text = String(m?.message || '');
+      if (!m?.out || !text) return;                       // only MY outgoing text
+      if (m.fwdFrom || m.viaBotId || m.media) return;     // forwards/inline/media stay raw
+      if (text.startsWith('.') || text.startsWith('/')) return;
+      if (text.length < MIN_CHARS) return;
+      const chatId = String(m.chatId ?? '');
+      if (allow.length && !allow.includes(chatId)) return;
+
+      const { text: revised, receipt } = await voiceText(text);
+      const same = revised.replace(/\s+/g, ' ').trim().toLowerCase()
+        === text.replace(/\s+/g, ' ').trim().toLowerCase();
+      if (!revised || same) {
+        console.error(`  [${chatId}] already in voice — untouched · ${receipt}`);
+        return;
+      }
+      await m.edit({ text: revised });
+      console.error(`  [${chatId}] revised (${text.length} → ${revised.length} chars) · ${receipt}`);
+    } catch (e) {
+      // Never let a rewrite failure eat a message: the raw text is already
+      // sent and stays; the watcher just reports and moves on.
+      console.error(`  watch: ${e.message?.slice(0, 120)}`);
+    }
+  }, new NewMessage({ outgoing: true }));
+
+  // Run until killed.
+  await new Promise(() => {});
+}

package/lib/x402.js

@@ -161,9 +161,26 @@ export function evmChainId(network) {
  */
 export function orderAccepts(body, preferredSymbol, { allowRH = false, forceRail = null } = {}) {
   const rows = parse402(body).accepts.filter((a) => a?.scheme === 'exact');
+  // CHEAPEST FIRST, AFTER AN EXPLICIT PREFERENCE.
+  //
+  // The 402 no longer prices every rail the same. Since 2026-08-26 the gateway
+  // bills $TOKEN/$LEOS at 2x its cost and USDC/USDG at 4x, so two rows for the
+  // SAME call differ by exactly 2x. This function ordered purely by rail and
+  // then by preferredSymbol, so the shim would have paid the stable row and
+  // silently thrown away half — a discount our own client could not see.
+  //
+  // An explicit preferredSymbol still wins: that is the caller saying which
+  // asset they intend to spend, and price is not a reason to override intent.
+  // Everything after it goes cheapest-first. Rows without a usable billedUsd
+  // sort last rather than first, so a missing price can never masquerade as
+  // free and jump the queue.
+  const priceOf = (a) => {
+    const v = Number(a?.extra?.billedUsd);
+    return Number.isFinite(v) && v > 0 ? v : Infinity;
+  };
   const bySym = (list) => [
     ...list.filter((a) => a?.extra?.symbol === preferredSymbol),
-    ...list.filter((a) => a?.extra?.symbol !== preferredSymbol),
+    ...list.filter((a) => a?.extra?.symbol !== preferredSymbol).sort((x, y) => priceOf(x) - priceOf(y)),
   ];
   if (forceRail) {
     const want = String(forceRail).toLowerCase();
@@ -181,9 +198,9 @@ export function orderAccepts(body, preferredSymbol, { allowRH = false, forceRail
   }
   const out = [
     ...bySym(rows.filter((a) => railOf(a) === 'solana')),
-    ...rows.filter((a) => railOf(a) === 'base'),
-    ...rows.filter((a) => railOf(a) === 'evm'),
-    ...(allowRH ? rows.filter((a) => railOf(a) === 'robinhood') : []),
+    ...bySym(rows.filter((a) => railOf(a) === 'base')),
+    ...bySym(rows.filter((a) => railOf(a) === 'evm')),
+    ...(allowRH ? bySym(rows.filter((a) => railOf(a) === 'robinhood')) : []),
   ];
   if (!out.length) {
     throw new Error(rows.some((a) => railOf(a) === 'robinhood')