openzoo 0.48.89 → 0.48.94

package/lib/mcp.js

@@ -8,6 +8,7 @@ import { tokenBalance } from './x402.js';
 import { askWithContext, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import { listContexts } from './contexts.js';
 import { withNamespace } from './namespace.js';
+import { subscriptionPublicView } from './subscription.js';
 
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 // The model zoo_ask uses when the caller does not name one. Opus 5 by default:
@@ -383,6 +384,7 @@ export function buildMcpServer() {
       fundHint: 'send a few cents of a listed asset to the address for that rail — Solana assets to solanaAddress, Base assets to evmAddress. The shim converts to whatever the 402 quotes, at payment time. Force a rail with OPENZOO_RAIL=solana|base|robinhood.',
       balances,
       receipts: client.receipts.map((r) => ({ at: r.at, line: r.line })),
+      subscription: subscriptionPublicView(),
     });
   });
 

package/lib/pay.js

@@ -13,6 +13,7 @@ import { withNamespace } from './namespace.js';
 import {
   resolvePool, poolState, depositForShares, buildWrapInstructions, sendWrap,
 } from './wrap.js';
+import { applySubscriptionHeaders, loadSubscription, stripAuthorization } from './subscription.js';
 
 export class QuoteTooHighError extends Error {
   constructor(billedUsd, quote) {
@@ -333,8 +334,15 @@ export class PayClient {
     // Contexts are tenanted by this namespace server-side — a request without
     // it cannot see corpora this wallet bound.
     init = { ...init, headers: withNamespace(init.headers || {}) };
+    // Subscription key · no x402. A stored Stripe key is a bearer on the zoo
+    // API (same as the public /billing/done snippet). Wallet/x402 stays if
+    // there is no key, or if the gateway still answers 402.
+    const sub = loadSubscription();
+    if (sub?.key) init = { ...init, headers: applySubscriptionHeaders(init.headers, sub) };
     const first = await fetch(url, init);
-    if (first.status !== 402) return { response: first, paid: false };
+    if (first.status !== 402) {
+      return { response: first, paid: false, subscription: Boolean(sub?.key && first.ok) };
+    }
 
     const quote = parse402(await first.json());
     // config.rail (OPENZOO_RAIL) steers every front — proxy, demo, MCP — since
@@ -394,7 +402,7 @@ export class PayClient {
     onStage?.('paying');
     const response = await fetch(url, {
       ...init,
-      headers: { ...(init.headers || {}), 'X-PAYMENT': payment.header },
+      headers: { ...stripAuthorization(init.headers || {}), 'X-PAYMENT': payment.header },
     });
     const settle = decodeSettleHeader(response.headers.get('x-payment-response'))
       || { signature: payment.ownerSignature };

package/lib/proxy.js

@@ -24,6 +24,7 @@ import { anthropicToOpenAI, openAIToAnthropic, streamOpenAIToAnthropic, writeAnt
 import { responsesToChat, chatToResponses, writeResponsesSse } from './responses.js';
 import { loadSessionSpend, saveSessionSpend } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
+import { subscriptionPublicView } from './subscription.js';
 import { priceHoldings } from './livestatus.js';
 
 const HOP_BY_HOP = new Set([
@@ -891,6 +892,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       res.end(JSON.stringify({
         spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls,
         creditUsd, chainUsd: money.chainUsd,
+        subscription: subscriptionPublicView(),
       }));
       return;
     }
@@ -914,6 +916,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         creditUsd,
         chainUsd: money.chainUsd,
         holdings: money.holdings,
+        subscription: subscriptionPublicView(),
       }));
       return;
     }
@@ -1021,7 +1024,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           },
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
-          payment: 'x402 per request from the operator\'s local burner wallet — no API key, no account',
+          payment: subscriptionPublicView().active
+            ? 'subscription key � no x402 � wallet/x402 remains the other method'
+            : 'x402 per request from the operator\'s local burner wallet � no API key, no account',
           auth: viaTunnel
             ? 'this public URL requires the oz_… bearer for paid endpoints; /v1/models and /v1/hrr/bind are free'
             : 'localhost is keyless',

package/lib/subscription.js

@@ -0,0 +1,207 @@
+/**
+ * Stripe subscription keys for the zoo API — the other pay lane next to
+ * wallet/x402. The live billing API is zoo.openzoo.fun; this file does not
+ * invent a second backend.
+ *
+ * After checkout the site lands on /billing/done?session=<cs_…> and polls
+ * GET /api/billing/key?session=… until Stripe confirms. That response is how
+ * a desktop client receives the key (no Stripe cookie on Electron). A user
+ * who already subscribed can paste the same key, or that success URL.
+ *
+ * Use: Authorization: Bearer <key> against x402-tokens.fly.dev — no 402
+ * signing. Wallet/x402 stays if no key is stored.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const BILLING_ORIGIN = 'https://zoo.openzoo.fun';
+export const SUBSCRIPTIONS_PAGE = 'https://zoo.openzoo.fun/subscriptions';
+
+export function subscriptionFile(home = os.homedir()) {
+  return process.env.OPENZOO_SUBSCRIPTION_PATH
+    || path.join(home, '.openzoo', 'subscription.json');
+}
+
+function titleCase(id) {
+  const s = String(id || '').trim();
+  if (!s) return '';
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+function asKey(v) {
+  return String(v || '').trim();
+}
+
+/** Persist a subscription key (chmod 600). Never log the value. */
+export function saveSubscription(rec, file = subscriptionFile()) {
+  const key = asKey(rec?.key);
+  if (!key) return null;
+  const payload = {
+    key,
+    tier: rec.tier ? String(rec.tier) : null,
+    tierName: rec.tierName ? String(rec.tierName) : (rec.tier ? titleCase(rec.tier) : null),
+    sessionId: rec.sessionId ? String(rec.sessionId) : null,
+    savedAt: Date.now(),
+  };
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const tmp = `${file}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(payload), { mode: 0o600 });
+  fs.renameSync(tmp, file);
+  cached = { file, mtime: fs.statSync(file).mtimeMs, data: payload };
+  return payload;
+}
+
+export function clearSubscription(file = subscriptionFile()) {
+  try { fs.unlinkSync(file); } catch { /* already gone */ }
+  if (cached.file === file) cached = { file: '', mtime: 0, data: null };
+}
+
+let cached = { file: '', mtime: 0, data: null };
+
+export function loadSubscription(file = subscriptionFile()) {
+  const envKey = asKey(process.env.OPENZOO_SUBSCRIPTION_KEY);
+  if (envKey) {
+    return {
+      key: envKey,
+      tier: process.env.OPENZOO_SUBSCRIPTION_TIER || null,
+      tierName: process.env.OPENZOO_SUBSCRIPTION_TIER
+        ? titleCase(process.env.OPENZOO_SUBSCRIPTION_TIER)
+        : null,
+      sessionId: null,
+      source: 'env',
+    };
+  }
+  try {
+    const st = fs.statSync(file);
+    if (cached.file === file && cached.mtime === st.mtimeMs && cached.data) return cached.data;
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!asKey(data?.key)) {
+      cached = { file, mtime: st.mtimeMs, data: null };
+      return null;
+    }
+    const rec = {
+      key: asKey(data.key),
+      tier: data.tier || null,
+      tierName: data.tierName || (data.tier ? titleCase(data.tier) : null),
+      sessionId: data.sessionId || null,
+      source: 'file',
+    };
+    cached = { file, mtime: st.mtimeMs, data: rec };
+    return rec;
+  } catch {
+    return null;
+  }
+}
+
+/** Public HUD/wallet view — never includes the secret. */
+export function subscriptionPublicView(sub = loadSubscription()) {
+  if (!asKey(sub?.key)) return { active: false };
+  const name = String(sub.tierName || titleCase(sub.tier) || '').trim();
+  return {
+    active: true,
+    tier: sub.tier || null,
+    tierName: name || null,
+    label: name ? `${name} · no x402` : 'Subscription key · no x402',
+  };
+}
+
+/**
+ * A paste is either the bearer key itself, or the site's success URL
+ * (`/billing/done?session=cs_…`). session_id is accepted too — Stripe's
+ * default query name — but the live page uses `session`.
+ */
+export function parseSubscriptionPaste(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return { error: 'empty' };
+  let session = '';
+  try {
+    if (/^https?:\/\//i.test(raw) || raw.includes('session=')) {
+      const url = new URL(raw, BILLING_ORIGIN);
+      session = url.searchParams.get('session') || url.searchParams.get('session_id') || '';
+    }
+  } catch { /* not a URL */ }
+  if (!session) {
+    const m = /(?:session_id|session)=([A-Za-z0-9_]+)/.exec(raw);
+    if (m) session = m[1];
+  }
+  if (session) return { session };
+  if (/^https?:\/\//i.test(raw)) return { error: 'no session in URL' };
+  if (raw.length < 8 || /\s/.test(raw)) return { error: 'not a key' };
+  return { key: raw };
+}
+
+export function applySubscriptionHeaders(headers = {}, sub = loadSubscription()) {
+  const key = asKey(sub?.key);
+  if (!key) return headers;
+  return { ...headers, authorization: `Bearer ${key}` };
+}
+
+export function stripAuthorization(headers = {}) {
+  const out = { ...headers };
+  delete out.authorization;
+  delete out.Authorization;
+  return out;
+}
+
+async function billingJson(url, init) {
+  const r = await fetch(url, init);
+  const body = await r.json().catch(() => ({}));
+  return { http: r.status, body };
+}
+
+export async function billingTiers() {
+  const { http, body } = await billingJson(`${BILLING_ORIGIN}/api/billing/tiers`);
+  if (!body?.ok || !Array.isArray(body.tiers)) {
+    throw new Error(body?.error || `tiers HTTP ${http}`);
+  }
+  return body;
+}
+
+export async function billingCheckout(tier) {
+  const id = String(tier || '').trim();
+  if (!id) throw new Error('tier required');
+  const { http, body } = await billingJson(`${BILLING_ORIGIN}/api/billing/checkout`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ tier: id }),
+  });
+  if (!body?.ok || !body.url) {
+    throw new Error(body?.error || `checkout HTTP ${http}`);
+  }
+  return { ok: true, url: body.url, sessionId: body.sessionId || null, tier: id };
+}
+
+/** Poll the same endpoint the public /billing/done page uses. */
+export async function fetchBillingKey(session) {
+  const sid = String(session || '').trim();
+  if (!sid) return { ok: false, error: 'session required' };
+  const { body } = await billingJson(
+    `${BILLING_ORIGIN}/api/billing/key?session=${encodeURIComponent(sid)}`,
+  );
+  return body && typeof body === 'object' ? body : { ok: false, error: 'empty key response' };
+}
+
+/**
+ * If the live key endpoint returned a key, persist it and return a public
+ * view (the secret stays on disk). Pending/error bodies pass through.
+ */
+export function ingestBillingKeyResponse(body, extra = {}, file = subscriptionFile()) {
+  const key = asKey(body?.key);
+  if (!key) {
+    if (body?.pending) return { ok: true, pending: true, saved: false };
+    return {
+      ok: false,
+      pending: false,
+      saved: false,
+      error: body?.error || 'no key yet',
+    };
+  }
+  const rec = saveSubscription({
+    key,
+    tier: body.tier || extra.tier || null,
+    tierName: body.tierName || body.name || extra.tierName || null,
+    sessionId: extra.sessionId || extra.session || null,
+  }, file);
+  return { ok: true, pending: false, saved: true, ...subscriptionPublicView(rec) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.89",
+  "version": "0.48.94",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",