javascript-solid-server 0.0.129 → 0.0.131

package/.claude/settings.local.json

@@ -342,7 +342,8 @@
       "Bash(sed -i 's/\"currency\": \"sats\"/\"currency\": \"tbtc4\"/g' /home/melvin/articles/solid-402.html /home/melvin/articles/solid-pay.html /home/melvin/articles/solid-balance.html)",
       "Bash(sed -i 's/\"currency\":\"sats\"/\"currency\":\"tbtc4\"/g' /home/melvin/articles/solid-402.html /home/melvin/articles/solid-pay.html /home/melvin/articles/solid-balance.html)",
       "WebFetch(domain:lists.w3.org)",
-      "Bash(git:*)"
+      "Bash(git:*)",
+      "Bash(npm publish:*)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.129",
+  "version": "0.0.131",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",

package/src/auth/middleware.js

@@ -104,7 +104,7 @@ export async function authorize(request, reply, options = {}) {
   }
 
   // Check WAC permissions
-  const { allowed, wacAllow, paymentRequired } = await checkAccess({
+  const { allowed, wacAllow, paymentRequired, paid, balance, currency } = await checkAccess({
     resourceUrl: checkUrl,
     resourcePath: checkPath,
     isContainer: checkIsContainer,
@@ -112,7 +112,7 @@ export async function authorize(request, reply, options = {}) {
     requiredMode
   });
 
-  return { authorized: allowed, webId, wacAllow, authError, paymentRequired };
+  return { authorized: allowed, webId, wacAllow, authError, paymentRequired, paid, balance, currency };
 }
 
 /**

package/src/ldp/headers.js

@@ -96,7 +96,7 @@ export function getCorsHeaders(origin) {
     'Access-Control-Allow-Origin': origin || '*',
     'Access-Control-Allow-Methods': 'GET, HEAD, POST, PUT, DELETE, PATCH, OPTIONS',
     'Access-Control-Allow-Headers': 'Accept, Authorization, Content-Type, DPoP, If-Match, If-None-Match, Link, Range, Slug, Origin',
-    'Access-Control-Expose-Headers': 'Accept-Patch, Accept-Post, Accept-Ranges, Allow, Content-Length, Content-Range, Content-Type, ETag, Link, Location, Updates-Via, WAC-Allow',
+    'Access-Control-Expose-Headers': 'Accept-Patch, Accept-Post, Accept-Ranges, Allow, Content-Length, Content-Range, Content-Type, ETag, Link, Location, Updates-Via, WAC-Allow, X-Cost, X-Balance, X-Pay-Currency',
     'Access-Control-Allow-Credentials': 'true',
     'Access-Control-Max-Age': '86400'
   };

package/src/server.js

@@ -448,7 +448,7 @@ export function createServer(options = {}) {
       return;
     }
 
-    const { authorized, webId, wacAllow, authError, paymentRequired } = await authorize(request, reply);
+    const { authorized, webId, wacAllow, authError, paymentRequired, paid, balance, currency } = await authorize(request, reply);
 
     // Store webId and wacAllow on request for handlers to use
     request.webId = webId;
@@ -457,6 +457,13 @@ export function createServer(options = {}) {
     // Set WAC-Allow header for all responses (handlers may override)
     reply.header('WAC-Allow', wacAllow);
 
+    // Set payment headers for paid access
+    if (paid !== undefined) {
+      reply.header('X-Cost', String(paid));
+      reply.header('X-Balance', String(balance));
+      if (currency) reply.header('X-Pay-Currency', currency);
+    }
+
     // Handle payment-gated resources
     if (paymentRequired) {
       return reply.code(402).send({

package/src/token.js

@@ -187,33 +187,34 @@ async function broadcastTx(rawTxHex, mempoolUrl) {
 }
 
 // --- Trail persistence ---
-function trailDir() {
-  return path.join(process.env.DATA_ROOT || './data', '.well-known', 'token');
+function trailDir(root) {
+  return path.join(root || process.env.DATA_ROOT || './data', '.well-known', 'token');
 }
 
-function trailPath(ticker) {
-  return path.join(trailDir(), `${ticker.toLowerCase()}.json`);
+function trailPath(ticker, root) {
+  return path.join(trailDir(root), `${ticker.toLowerCase()}.json`);
 }
 
-export async function loadTrail(ticker) {
+export async function loadTrail(ticker, root) {
   try {
-    const data = await fs.readFile(trailPath(ticker), 'utf8');
+    const data = await fs.readFile(trailPath(ticker, root), 'utf8');
     return JSON.parse(data);
   } catch { return null; }
 }
 
-async function saveTrail(trail) {
-  await fs.ensureDir(trailDir());
-  await fs.writeFile(trailPath(trail.ticker), JSON.stringify(trail, null, 2));
+async function saveTrail(trail, root) {
+  await fs.ensureDir(trailDir(root));
+  await fs.writeFile(trailPath(trail.ticker, root), JSON.stringify(trail, null, 2));
 }
 
-export async function listTrails() {
+export async function listTrails(root) {
   try {
-    const files = await fs.readdir(trailDir());
+    const dir = trailDir(root);
+    const files = await fs.readdir(dir);
     const trails = [];
     for (const f of files) {
       if (f.endsWith('.json')) {
-        const data = await fs.readFile(path.join(trailDir(), f), 'utf8');
+        const data = await fs.readFile(path.join(dir, f), 'utf8');
         trails.push(JSON.parse(data));
       }
     }
@@ -235,14 +236,14 @@ export function parseTxoUri(uri) {
 }
 
 // --- Mint: create genesis MRC20 token ---
-export async function mintToken({ ticker, name, supply, voucher, mempoolUrl = 'https://mempool.space/testnet4', network = 'testnet4' }) {
+export async function mintToken({ ticker, name, supply, voucher, mempoolUrl = 'https://mempool.space/testnet4', network = 'testnet4', root }) {
   const txo = parseTxoUri(voucher);
   const privkeyBytes = hexToU8(txo.privkey);
   const pubkeyBase = new Uint8Array(secp256k1.getPublicKey(privkeyBytes, true));
   const pubkeyBaseHex = bytesToHex(pubkeyBase);
 
   // Check if token already exists
-  const existing = await loadTrail(ticker);
+  const existing = await loadTrail(ticker, root);
   if (existing) throw new Error(`Token ${ticker} already exists`);
 
   // Create genesis MRC20 state
@@ -300,14 +301,14 @@ export async function mintToken({ ticker, name, supply, voucher, mempoolUrl = 'h
     network,
     dateCreated: new Date().toISOString()
   };
-  await saveTrail(trail);
+  await saveTrail(trail, root);
 
   return { trail, txid: newTxid, address: genesisAddr };
 }
 
 // --- Transfer: send tokens to an address ---
-export async function transferToken({ ticker, from, to, amount, mempoolUrl = 'https://mempool.space/testnet4' }) {
-  const trail = await loadTrail(ticker);
+export async function transferToken({ ticker, from, to, amount, mempoolUrl = 'https://mempool.space/testnet4', root }) {
+  const trail = await loadTrail(ticker, root);
   if (!trail) throw new Error(`Token ${ticker} not found`);
 
   const privkeyBytes = hexToU8(trail.privkey);
@@ -382,14 +383,14 @@ export async function transferToken({ ticker, from, to, amount, mempoolUrl = 'ht
   trail.currentTxid = newTxid;
   trail.currentVout = 0;
   trail.currentAmount = outputAmount;
-  await saveTrail(trail);
+  await saveTrail(trail, root);
 
   return { trail, txid: newTxid, address: newAddr, state: newState, prevState: currentState };
 }
 
 // --- Info: show token state ---
-export async function tokenInfo(ticker) {
-  const trail = await loadTrail(ticker);
+export async function tokenInfo(ticker, { root } = {}) {
+  const trail = await loadTrail(ticker, root);
   if (!trail) throw new Error(`Token ${ticker} not found`);
 
   const currentState = trail.states[trail.states.length - 1];

package/src/wac/checker.js

@@ -49,7 +49,7 @@ export async function checkAccess({
   // Calculate WAC-Allow header
   const wacAllow = calculateWacAllow(authorizations, resourceUrl, agentWebId, isDefault);
 
-  return { allowed: result.allowed, wacAllow, paymentRequired: result.paymentRequired || null };
+  return { allowed: result.allowed, wacAllow, paymentRequired: result.paymentRequired || null, paid: result.paid, balance: result.balance, currency: result.currency };
 }
 
 /**
@@ -183,10 +183,10 @@ async function checkAuthorizations(authorizations, targetUrl, agentWebId, requir
             // Paid access: check balance and deduct
             const balance = getBalance(ledger, agentWebId, currency);
             if (cost > 0 && balance >= cost) {
-              debit(ledger, agentWebId, cost, currency);
+              const result = debit(ledger, agentWebId, cost, currency);
               const { writeLedger } = await import('../webledger.js');
               await writeLedger(ledger);
-              return { allowed: true, paid: cost };
+              return { allowed: true, paid: cost, balance: result.balance, currency };
             }
           } catch (e) {
             // Ledger read failed — fall through to payment required