@nibgate/sdk 0.2.0 → 0.2.2

package/src/browser/rating-ui.js

@@ -0,0 +1,161 @@
+import { normalizeResource, normalizeContentType } from '../core/resource.js';
+import { normalizeRating, ratingMessage } from '../core/rating.js';
+import { emit } from './events.js';
+import { browserWindow } from './env.js';
+import { rateContentOnchain } from './reputation.js';
+import { createGate } from './gate.js';
+
+export function rateResource(resource, rating = {}, extra = {}) {
+  const normalized = normalizeResource(resource);
+  const normalizedRating = normalizeRating(rating);
+  const payload = {
+    ...extra,
+    ...normalizedRating,
+    ratingMessage: extra.ratingMessage || rating.message || rating.ratingMessage || ratingMessage(normalized, normalizedRating, extra),
+    ratingSignature: extra.ratingSignature || rating.signature || rating.ratingSignature || undefined,
+    resource: normalized
+  };
+  return emit('content_rating', payload);
+}
+
+export function createOnchainRating(resource, options = {}) {
+  const item = createGate(resource, options.gateOptions || {});
+  const win = browserWindow();
+  const statusTarget = typeof options.status === 'string' ? win?.document.querySelector(options.status) : options.status;
+  const ratingTarget = typeof options.ratingTarget === 'string' ? win?.document.querySelector(options.ratingTarget) : options.ratingTarget;
+  const buttonSelector = options.ratingButtons || options.buttons || '[data-nibgate-rating-value], [data-rating]';
+  const explicitButtons = Array.isArray(options.buttons)
+    ? options.buttons
+    : typeof options.buttons === 'string'
+      ? Array.from(win?.document.querySelectorAll(options.buttons) || [])
+      : options.buttons
+        ? [options.buttons]
+        : null;
+  const buttons = explicitButtons || Array.from(win?.document.querySelectorAll(buttonSelector) || []);
+  const source = options.source || 'nibgate-onchain-rating';
+
+  let busy = false;
+  let payment = options.payment || null;
+
+  function setStatus(message) {
+    if (typeof options.onStatus === 'function') options.onStatus(message);
+    if (statusTarget) statusTarget.textContent = message || '';
+  }
+
+  function setBusy(value) {
+    busy = Boolean(value);
+    buttons.forEach((button) => {
+      if (button && 'disabled' in button) button.disabled = busy;
+    });
+  }
+
+  function setPayment(nextPayment = null) {
+    payment = nextPayment || null;
+    return payment;
+  }
+
+  function setVisible(isVisible) {
+    if (!ratingTarget) return Boolean(isVisible);
+    if ('hidden' in ratingTarget) ratingTarget.hidden = !isVisible;
+    ratingTarget.setAttribute('aria-hidden', isVisible ? 'false' : 'true');
+    return Boolean(isVisible);
+  }
+
+  function valueFromButton(button) {
+    const raw = button?.dataset?.nibgateRatingValue || button?.dataset?.rating || button?.value || button?.textContent;
+    const numeric = Number.parseFloat(String(raw || '').replace(/[^\d.]/g, ''));
+    return Number.isFinite(numeric) ? numeric : Number(options.rating || options.stars || 0);
+  }
+
+  async function rate(input = {}) {
+    setBusy(true);
+    try {
+      const rating = Number.parseFloat(input.rating ?? input.stars ?? input.value ?? options.rating ?? options.stars);
+      if (!Number.isFinite(rating)) throw new Error('Choose a rating before sending.');
+      const paymentId = input.paymentId || options.paymentId || (typeof options.getPaymentId === 'function' ? options.getPaymentId() : payment?.paymentId);
+      const unlockRef = input.unlockRef || options.unlockRef
+        || (typeof options.getUnlockRef === 'function' ? options.getUnlockRef() : null)
+        || paymentId || payment?.txHash || payment?.transactionHash || '';
+
+      setStatus(options.pendingMessage || 'Send the onchain rating transaction...');
+      const result = await rateContentOnchain(item.resource, { ...options, ...input, rating, paymentId, unlockRef, source });
+      setStatus(options.successMessage || 'Rating sent to Nibgate reputation.');
+      if (typeof options.onRated === 'function') options.onRated(result);
+      return result;
+    } catch (error) {
+      const message = error?.message || options.errorMessage || 'Rating failed.';
+      setStatus(message);
+      if (typeof options.onError === 'function') options.onError(error);
+      throw error;
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  function mount() {
+    buttons.forEach((button) => {
+      button?.addEventListener?.('click', () => rate({ rating: valueFromButton(button) }).catch(() => null));
+    });
+    if (options.visible !== undefined) setVisible(Boolean(options.visible));
+    return controller;
+  }
+
+  const controller = { resource: item.resource, rate, mount, setPayment, setVisible };
+  if (options.autoMount !== false) mount();
+  return controller;
+}
+
+export function mountRatingUI(resource, options = {}) {
+  const item = createGate(resource, options.gateOptions || {});
+  const win = browserWindow();
+  if (!win) return null;
+  const target = typeof options.target === 'string' ? win.document.querySelector(options.target) : options.target;
+  if (!target) return null;
+
+  const stars = [1, 2, 3, 4, 5];
+  let selectedRating = 0;
+
+  const container = win.document.createElement('div');
+  container.className = 'nibgate-rating-ui';
+  container.style.cssText = 'display:flex;align-items:center;gap:4px;padding:8px 0';
+
+  const starButtons = stars.map((value) => {
+    const btn = win.document.createElement('button');
+    btn.type = 'button';
+    btn.dataset.nibgateRatingValue = String(value);
+    btn.setAttribute('aria-label', `${value} star${value > 1 ? 's' : ''}`);
+    btn.innerHTML = '☆';
+    btn.style.cssText = 'background:none;border:none;font-size:24px;cursor:pointer;color:#ccc;transition:color 0.15s;padding:2px;line-height:1';
+    btn.addEventListener('mouseenter', () => {
+      starButtons.forEach((b, i) => b.style.color = i < value ? '#f5b342' : '#ccc');
+    });
+    btn.addEventListener('mouseleave', () => {
+      starButtons.forEach((b, i) => b.style.color = i < selectedRating ? '#f5b342' : '#ccc');
+    });
+    btn.addEventListener('click', () => {
+      selectedRating = value;
+      starButtons.forEach((b, i) => b.style.color = i < value ? '#f5b342' : '#ccc');
+      rateResource(item.resource, { rating: value }).catch(() => {});
+    });
+    container.appendChild(btn);
+    return btn;
+  });
+
+  const statusEl = win.document.createElement('span');
+  statusEl.style.cssText = 'font-size:13px;color:#888;margin-left:8px';
+  statusEl.textContent = options.label || 'Rate this content';
+  container.appendChild(statusEl);
+
+  target.appendChild(container);
+
+  function rate(r, input = {}) {
+    return item.rate({ ...input, rating: r });
+  }
+
+  function setRating(value) {
+    selectedRating = value;
+    starButtons.forEach((b, i) => b.style.color = i < value ? '#f5b342' : '#ccc');
+  }
+
+  return { resource: item.resource, container, setRating, rate };
+}

package/src/browser/track.js

@@ -0,0 +1,45 @@
+import { validateResourceMetadata } from '../core/resource.js';
+import { browserWindow } from './env.js';
+import { createGate } from './gate.js';
+import { checkResourceAccess } from './access.js';
+
+export function trackResourcePage(resource, options = {}) {
+  const item = createGate(resource, options.gateOptions || {});
+  const validation = validateResourceMetadata(item.resource, options.validation || {});
+  if ((validation.warnings.length || validation.errors.length) && options.warn !== false && browserWindow()?.console?.warn) {
+    browserWindow().console.warn('Nibgate content metadata needs attention', validation);
+  }
+  item.content({ source: options.source, metadataQuality: { score: validation.score, warnings: validation.warnings, errors: validation.errors }, ...(options.content || {}) });
+  item.view({
+    source: options.source,
+    path: options.path || browserWindow()?.location?.pathname || item.resource.path,
+    referrer: options.referrer ?? browserWindow()?.document?.referrer ?? '',
+    ...(options.view || {})
+  });
+  return item;
+}
+
+export function setupResourcePage(resource, options = {}) {
+  const item = trackResourcePage(resource, options);
+  const win = browserWindow();
+  if (!win) return item;
+
+  const button = typeof options.button === 'string' ? win.document.querySelector(options.button) : options.button;
+  const statusElement = typeof options.status === 'string' ? win.document.querySelector(options.status) : options.status;
+  const setStatus = options.onStatus || ((message) => {
+    if (statusElement) statusElement.textContent = message || '';
+  });
+
+  if (button) {
+    button.addEventListener('click', async () => {
+      button.disabled = true;
+      try {
+        await checkResourceAccess(resource, { ...options, onStatus: setStatus });
+      } finally {
+        button.disabled = false;
+      }
+    });
+  }
+
+  return item;
+}

package/src/server/access.js

@@ -75,13 +75,8 @@ export function createNibgateServer(options = {}) {
 
       if (access.blocked) {
         return jsonResponse({
-          status: 403,
-          error: `${access.actor} access is blocked for this resource`,
-          nibgate: {
-            contentId: resource.id,
-            actor: access.actor,
-            access: resource.access
-          }
+          ok: false, error: `${access.actor} access is blocked for this resource`,
+          nibgate: { contentId: resource.id, actor: access.actor, access: resource.access }
         }, { status: 403 });
       }
 
@@ -96,11 +91,7 @@ export function createNibgateServer(options = {}) {
 
     if (!access.allowed) {
       if (access.blocked) {
-        return jsonResponse({
-          status: 403,
-          error: `${access.actor} access is blocked for this resource`,
-          resource
-        }, { status: 403 });
+        return jsonResponse({ ok: false, error: `${access.actor} access is blocked for this resource`, resource }, { status: 403 });
       }
 
       const rail = normalizePaymentRail(resource.paymentRail || routeOptions.paymentRail || options.paymentRail || routeOptions.paymentMode || options.paymentMode);
@@ -109,7 +100,10 @@ export function createNibgateServer(options = {}) {
         if (gateway.handled) return gateway.response;
         const result = await unlock(resource, gateway.payment);
         if (result.ok) {
-          return jsonResponse({ ok: true, resource, payment: gateway.payment, unlockProof: result.unlockProof, expiresInSeconds: result.expiresInSeconds });
+          const response = jsonResponse({ ok: true, resource, payment: gateway.payment, unlockProof: result.unlockProof, expiresInSeconds: result.expiresInSeconds });
+          emitHubEvent('payment_completed', resource, { ...options, ...routeOptions, payload: gateway.payment }).catch(() => {});
+          emitHubEvent('unlock_completed', resource, { ...options, ...routeOptions, payload: gateway.payment }).catch(() => {});
+          return response;
         }
       }
 
@@ -117,7 +111,7 @@ export function createNibgateServer(options = {}) {
         const txHash = request.headers?.get?.('x-nibgate-transfer-tx') || request.headers?.get?.('x-transfer-tx') || '';
         if (txHash) {
           if (!verifyTransfer) {
-            return jsonResponse({ error: 'Transfer verification is not configured', detail: 'Pass verifyTransfer({ resource, txHash, request }) to createNibgateServer/createCircleGatewayServer before using paymentRail: transfer.' }, { status: 501 });
+            return jsonResponse({ ok: false, error: 'Transfer verification is not configured. Pass verifyTransfer to createNibgateServer before using paymentRail: transfer.' }, { status: 501 });
           }
           const transferPayment = {
             paymentProvider: 'direct-transfer',
@@ -130,7 +124,7 @@ export function createNibgateServer(options = {}) {
             network: routeOptions.network || options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002'
           };
           const verified = await verifyTransfer({ resource, txHash, payment: transferPayment, request });
-          if (!verified) return jsonResponse({ error: 'Transfer verification failed' }, { status: 402 });
+          if (!verified) return jsonResponse({ ok: false, error: 'Transfer verification failed' }, { status: 402 });
           const result = await unlock(resource, { ...transferPayment, verified: true });
           if (result.ok) return jsonResponse({ ok: true, resource, payment: { ...transferPayment, verified: true }, unlockProof: result.unlockProof, expiresInSeconds: result.expiresInSeconds });
         }
@@ -157,18 +151,14 @@ export function createNibgateServer(options = {}) {
       if (!gatewayResult.ok) return jsonResponse(gatewayResult, { status: gatewayResult.status || 500 });
       payment = gatewayResult.payment;
     } else {
-      return jsonResponse({
-        success: false,
-        error: 'Real payments are required',
-        detail: 'Set NIBGATE_PAYMENT_MODE=circle-gateway for real local payment tests.'
-      }, { status: 400 });
+      return jsonResponse({ ok: false, error: 'Real payments are required', detail: 'Set NIBGATE_PAYMENT_MODE=circle-gateway for real local payment tests.' }, { status: 400 });
     }
 
     const result = await unlock(resource, payment);
-    if (!result.ok) return jsonResponse({ success: false, ...result }, { status: result.status || 402 });
+    if (!result.ok) return jsonResponse({ ok: false, ...result }, { status: result.status || 402 });
 
     const response = jsonResponse({
-      success: true,
+      ok: true,
       unlockProof: result.unlockProof,
       expiresInSeconds: result.expiresInSeconds,
       payment,
@@ -218,10 +208,12 @@ export function protect(resource, handler, options = {}) {
 
 export function verifyPayment(options = {}) {
   return async function verifyPaymentMiddleware(req, res, next) {
-    const proofHeader = req.headers?.['x-nibgate-payment-proof'] || req.get?.('x-nibgate-payment-proof') || '';
+    const contentId = req.params?.id || req.body?.resourceId || '';
+
+    const proofHeader = req.headers?.['x-nibgate-payment-proof'] || '';
     if (proofHeader) {
       const nibgate = createNibgateServer(options);
-      const payload = nibgate.verifyUnlockToken(proofHeader, { id: req.params?.id || req.body?.resourceId || '' });
+      const payload = nibgate.verifyUnlockToken(proofHeader, { id: contentId });
       if (payload) {
         req.nibgate = { unlock: payload, verified: true };
         return next();
@@ -229,11 +221,11 @@ export function verifyPayment(options = {}) {
     }
 
     if ((options.paymentMode || process.env.NIBGATE_PAYMENT_MODE) === 'circle-gateway') {
-      const sigHeader = req.headers?.['payment-signature'] || req.get?.('payment-signature') || '';
+      const sigHeader = req.headers?.['payment-signature'] || '';
       if (sigHeader) {
-        const resource = options.resource || { id: req.params?.id || '', price: req.body?.price || '0' };
+        const resource = options.resource || { id: contentId, price: req.body?.price || '0' };
         const gateway = await runCircleGatewayRequirement(
-          { headers: new Map(Object.entries(req.headers || {})), method: req.method, url: req.originalUrl || req.url },
+          { headers: req.headers, method: req.method || 'GET', url: req.originalUrl || req.url || '/' },
           resource,
           options
         );
@@ -241,13 +233,11 @@ export function verifyPayment(options = {}) {
           req.nibgate = { payment: gateway.payment, verified: true };
           return next();
         }
-        return res.status(402).json({ error: 'Payment verification failed', detail: 'The payment signature could not be verified.' });
+        return res.status(402).json({ ok: false, error: 'Payment verification failed', detail: 'The payment signature could not be verified.' });
       }
     }
 
-    return res.status(402).json({
-      error: 'Payment required',
-      challenge: createPaymentChallenge(options.resource || { id: req.params?.id || '', price: req.body?.price || '0' }, options)
-    });
+    const errBody = createPaymentChallenge(options.resource || { id: contentId, price: req.body?.price || '0' }, options);
+    return res.status(402).json(errBody);
   };
 }

package/src/server/admin-page.html

@@ -0,0 +1,168 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${TITLE}</title>
+<style>
+  *,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+  body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;background:#f5f5f0;color:#1a1a18;padding:24px;max-width:960px;margin:0 auto}
+  h1{font-size:28px;font-weight:700;margin-bottom:8px}
+  p.sub{color:#666;margin-bottom:24px}
+  .card{background:#fff;border-radius:12px;padding:20px;margin-bottom:16px;box-shadow:0 1px 3px rgba(0,0,0,0.08)}
+  .card-header{display:flex;justify-content:space-between;align-items:center;margin-bottom:12px}
+  .card-header h3{font-size:18px;font-weight:600}
+  .status{font-size:12px;padding:3px 10px;border-radius:99px;font-weight:600}
+  .status-gated{background:#fef3c7;color:#92400e}
+  .status-open{background:#d1fae5;color:#065f46}
+  .status-hidden{background:#fce4ec;color:#c62828}
+  .field-row{display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:12px}
+  .field{display:flex;flex-direction:column;gap:4px}
+  .field label{font-size:12px;font-weight:600;text-transform:uppercase;letter-spacing:0.05em;color:#555}
+  .field input,.field select{font-size:14px;padding:8px 10px;border:1px solid #ddd;border-radius:6px;background:#fff}
+  .field input:focus,.field select:focus{outline:2px solid #7c9a6d;border-color:transparent}
+  .field .checkbox-row{display:flex;align-items:center;gap:8px;padding-top:6px}
+  .field .checkbox-row input[type="checkbox"]{width:18px;height:18px}
+  .empty{text-align:center;padding:48px;color:#888}
+  .toast{position:fixed;bottom:24px;right:24px;background:#1a1a18;color:#fff;padding:12px 20px;border-radius:8px;font-size:14px;opacity:0;transition:opacity 0.3s;z-index:100}
+  .toast.show{opacity:1}
+  .toast.error{background:#c62828}
+  .header-bar{display:flex;justify-content:space-between;align-items:center;margin-bottom:24px}
+  .header-bar a{color:#7c9a6d;text-decoration:none;font-size:14px;font-weight:600}
+  .header-bar a:hover{text-decoration:underline}
+  .help-text{font-size:12px;color:#888;margin-top:2px}
+</style>
+</head>
+<body>
+<div class="header-bar">
+  <div>
+    <h1>Nibgate Admin</h1>
+    <p class="sub">Manage gating, pricing, and settings for your content.</p>
+  </div>
+  <a href="/nibgate.json" target="_blank">View manifest →</a>
+</div>
+<div id="app"><div class="empty">Loading resources...</div></div>
+<div id="toast" class="toast"></div>
+<script>
+const API = '${API_BASE}';
+let fields = [];
+let items = [];
+
+async function load() {
+  try {
+    const res = await fetch(API + '/resources');
+    const data = await res.json();
+    if (!data.ok) throw new Error(data.error || 'Failed to load');
+    fields = data.fields || [];
+    items = data.items || [];
+    render();
+  } catch (err) {
+    document.getElementById('app').innerHTML = '<div class="empty">Error loading: ' + err.message + '</div>';
+  }
+}
+
+function statusLabel(item) {
+  if (item.humanAccess === 'paid') return '<span class="status status-gated">Gated</span>';
+  if (item.humanAccess === 'blocked') return '<span class="status status-hidden">Blocked</span>';
+  return '<span class="status status-open">Open</span>';
+}
+
+function render() {
+  const app = document.getElementById('app');
+  if (!items.length) {
+    app.innerHTML = '<div class="empty">No resources configured yet. Add resources through the Nibgate SDK and they will appear here after the next manifest sync.</div>';
+    return;
+  }
+  app.innerHTML = items.map(function(item) {
+    return '<div class="card" data-id="' + item.id + '">' +
+      '<div class="card-header">' +
+        '<h3>' + escapeHtml(item.title || item.id) + '</h3>' +
+        statusLabel(item) +
+      '</div>' +
+      '<div class="field-row">' +
+        selectField('humanAccess', 'Human access', ['free','paid','blocked'], item.humanAccess) +
+        selectField('agentAccess', 'Agent access', ['free','paid','blocked'], item.agentAccess) +
+      '</div>' +
+      '<div class="field-row">' +
+        selectField('unlockMode', 'Unlock mode', ['one_time'], item.unlockMode) +
+        selectField('paymentRail', 'Payment rail', ['gateway','transfer'], item.paymentRail || 'gateway') +
+      '</div>' +
+      '<div class="field-row">' +
+        textField('price', 'Price (' + (item.currency || 'USDC') + ')', item.price) +
+        textField('currency', 'Currency', item.currency || 'USDC') +
+      '</div>' +
+      '<div class="field-row">' +
+        textField('recipient', 'Recipient wallet', item.recipient || '') +
+        checkboxField('ratingsEnabled', 'Enable onchain ratings', item.ratingsEnabled !== false) +
+      '</div>' +
+      '<div class="field-row">' +
+        selectField('type', 'Content type', ['article','music','video','image'], item.type || 'article') +
+        checkboxField('publishToNibgate', 'Publish to discovery', item.publishToNibgate !== false) +
+      '</div>' +
+      '<div><button class="save-btn" onclick="save(this)">Save</button></div>' +
+    '</div>';
+  }).join('');
+}
+
+function textField(name, label, value) {
+  return '<div class="field"><label>' + label + '</label><input type="text" name="' + name + '" value="' + escapeAttr(value || '') + '" /></div>';
+}
+
+function selectField(name, label, options, value) {
+  const opts = (options || []).map(function(o) { return '<option value="' + o + '"' + (o === value ? ' selected' : '') + '>' + o + '</option>'; }).join('');
+  return '<div class="field"><label>' + label + '</label><select name="' + name + '">' + opts + '</select></div>';
+}
+
+function checkboxField(name, label, checked) {
+  return '<div class="field"><label>' + label + '</label><div class="checkbox-row"><input type="checkbox" name="' + name + '"' + (checked ? ' checked' : '') + ' /></div></div>';
+}
+
+function escapeHtml(str) {
+  var div = document.createElement('div');
+  div.textContent = str;
+  return div.innerHTML;
+}
+
+function escapeAttr(str) {
+  return String(str).replace(/"/g,'&quot;').replace(/'/g,'&#39;');
+}
+
+async function save(btn) {
+  var card = btn.closest('.card');
+  var id = card.dataset.id;
+  var inputs = card.querySelectorAll('[name]');
+  var body = {};
+  inputs.forEach(function(inp) {
+    if (inp.type === 'checkbox') body[inp.name] = inp.checked;
+    else body[inp.name] = inp.value;
+  });
+  btn.disabled = true;
+  btn.textContent = 'Saving...';
+  try {
+    var res = await fetch(API + '/resources/' + encodeURIComponent(id), {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+    var data = await res.json();
+    if (!data.ok) throw new Error(data.error || 'Save failed');
+    toast('Saved ' + (data.item.title || id), 'success');
+    load();
+  } catch (err) {
+    toast(err.message, 'error');
+    btn.disabled = false;
+    btn.textContent = 'Save';
+  }
+}
+
+function toast(msg, type) {
+  var el = document.getElementById('toast');
+  el.textContent = msg;
+  el.className = 'toast ' + (type==='error'?'error':'') + ' show';
+  setTimeout(function() { el.classList.remove('show'); }, 3000);
+}
+
+load();
+</script>
+</body>
+</html>