@toon-protocol/rig 2.8.0 → 2.9.0

package/dist/cli/rig.js

@@ -532,8 +532,97 @@ function emitCliError(io2, json, command, err) {
 }
 
 // src/cli/push.ts
+import { createHash } from "crypto";
 import { parseArgs as parseArgs2 } from "util";
 
+// src/rig-pointer.ts
+var DEFAULT_RIG_WEB_BUNDLE = {
+  manifestTx: "Iy8sHYVnoevSpwDC2lqUoIg8BWdes9NmMbgmPd81UpU",
+  entryJs: "assets/index-BuKzYubR.js",
+  entryCss: "assets/index-H5D6cmfa.css"
+};
+var RIG_WEB_TX_ENV = "RIG_WEB_TX";
+var RIG_WEB_ENTRY_JS_ENV = "RIG_WEB_ENTRY_JS";
+var RIG_WEB_ENTRY_CSS_ENV = "RIG_WEB_ENTRY_CSS";
+var DEFAULT_RIG_WEB_URL = "https://toon-protocol.github.io/toon-client";
+var RIG_WEB_URL_ENV = "RIG_WEB_URL";
+function repoHashRoute(options) {
+  const { relay, ownerNpub, repoId } = options;
+  return `#/${encodeURIComponent(ownerNpub)}/${encodeURIComponent(repoId)}?relay=${encodeURIComponent(relay)}`;
+}
+function rigWebRoute(options) {
+  return `${options.rigWebUrl.replace(/\/+$/, "")}/${repoHashRoute(options)}`;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateRigPointerHtml(options) {
+  const gateway = options.gateway.replace(/\/+$/, "");
+  const base = `${gateway}/${options.bundle.manifestTx}`;
+  const cssHref = `${base}/${options.bundle.entryCss}`;
+  const jsSrc = `${base}/${options.bundle.entryJs}`;
+  const fallback = rigWebRoute(options);
+  const safeFallback = escapeHtml(fallback);
+  const title = escapeHtml(`${options.repoId} \u2014 Rig`);
+  const config = JSON.stringify({
+    relay: options.relay,
+    owner: options.ownerNpub,
+    repo: options.repoId
+  }).replace(/</g, "\\u003c");
+  const hashRoute = JSON.stringify(repoHashRoute(options)).replace(
+    /</g,
+    "\\u003c"
+  );
+  return `<!DOCTYPE html>
+<html lang="en"><head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="description" content="Decentralized Git on Nostr &amp; TOON Protocol">
+  <title>${title}</title>
+  <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>&#x2692;</text></svg>">
+  <script>window.__RIG_CONFIG__=${config};if(!location.hash||location.hash==="#")location.replace(${hashRoute})</script>
+  <link rel="stylesheet" href="${escapeHtml(cssHref)}">
+  <script type="module" crossorigin src="${escapeHtml(jsSrc)}"></script>
+</head><body>
+  <div id="app"></div>
+  <noscript><p>JavaScript is off \u2014 open <a href="${safeFallback}">${title}</a> in the hosted Rig.</p></noscript>
+  <p hidden data-fallback>If nothing loads, open <a href="${safeFallback}">${title}</a> in the hosted Rig.</p>
+  <script>setTimeout(function(){var p=document.querySelector("[data-fallback]");var app=document.getElementById("app");if(p&&(!app||!app.childElementCount))p.hidden=false},8000)</script>
+</body></html>
+`;
+}
+
+// src/cli/rig-pointer-record.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var RIG_POINTER_FILENAME = "rig-pointers.json";
+function storeDir(env) {
+  return env["TOON_CLIENT_HOME"] ?? join(homedir(), ".toon-client");
+}
+function storePath(env) {
+  return join(storeDir(env), RIG_POINTER_FILENAME);
+}
+function readAll(env) {
+  try {
+    const parsed = JSON.parse(readFileSync(storePath(env), "utf8"));
+    if (parsed && typeof parsed === "object") return parsed;
+    return {};
+  } catch {
+    return {};
+  }
+}
+function readRigPointerRecord(env, repoId) {
+  return readAll(env)[repoId];
+}
+function writeRigPointerRecord(env, record) {
+  const all = readAll(env);
+  all[record.repoId] = record;
+  mkdirSync(storeDir(env), { recursive: true });
+  writeFileSync(storePath(env), `${JSON.stringify(all, null, 2)}
+`);
+}
+
 // src/cli/render.ts
 function formatNumber(value) {
   return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
@@ -1001,10 +1090,18 @@ remote name it is the remote; otherwise it is a refspec and the remote
 defaults to origin. Refspecs are branch/tag names or full refnames; default
 is the current branch.
 
+Every push also keeps the repo's RIG PAGE current: a permanent Arweave
+page that RENDERS this repo in place \u2014 it boots the FULL Rig (rig-web)
+from its Arweave deployment with this repo pinned, everything served from
+Arweave + the relay. The pointer is content-addressed, so it is paid for
+once and reused for free until the relay or Rig deployment changes.
+--no-rig-page skips it.
+
 Options:
   --force            allow non-fast-forward ref updates (overwrites remote history)
   --all              push all local branches
   --tags             push all local tags
+  --no-rig-page      skip the Rig-page pointer upload for this push
   --yes              skip the fee confirmation (required when not a TTY)
   --json             machine-readable plan/receipts; without --yes it is a pure
                      estimate (nothing executed)
@@ -1077,6 +1174,7 @@ function parsePushArgs(args) {
       force: { type: "boolean", default: false },
       all: { type: "boolean", default: false },
       tags: { type: "boolean", default: false },
+      "no-rig-page": { type: "boolean", default: false },
       yes: { type: "boolean", default: false },
       json: { type: "boolean", default: false },
       relay: { type: "string", multiple: true },
@@ -1089,6 +1187,7 @@ function parsePushArgs(args) {
     force: values.force ?? false,
     all: values.all ?? false,
     tags: values.tags ?? false,
+    rigPage: !(values["no-rig-page"] ?? false),
     yes: values.yes ?? false,
     json: values.json ?? false,
     relay: values.relay ?? [],
@@ -1099,6 +1198,46 @@ function parsePushArgs(args) {
   if (repoId !== void 0) flags.repoId = repoId;
   return flags;
 }
+function pointerGateway(env) {
+  return (env["RIG_ARWEAVE_GATEWAY"] ?? "https://arweave.net").replace(
+    /\/+$/,
+    ""
+  );
+}
+function planRigPointer(args) {
+  const html = generateRigPointerHtml({
+    bundle: {
+      manifestTx: args.env[RIG_WEB_TX_ENV] ?? DEFAULT_RIG_WEB_BUNDLE.manifestTx,
+      entryJs: args.env[RIG_WEB_ENTRY_JS_ENV] ?? DEFAULT_RIG_WEB_BUNDLE.entryJs,
+      entryCss: args.env[RIG_WEB_ENTRY_CSS_ENV] ?? DEFAULT_RIG_WEB_BUNDLE.entryCss
+    },
+    gateway: pointerGateway(args.env),
+    rigWebUrl: args.env[RIG_WEB_URL_ENV] ?? DEFAULT_RIG_WEB_URL,
+    relay: args.relay,
+    ownerNpub: hexToNpub(args.ownerPubkey),
+    repoId: args.repoId
+  });
+  const contentHash = createHash("sha256").update(html).digest("hex");
+  const bytes = Buffer.byteLength(html);
+  const record = readRigPointerRecord(args.env, args.repoId);
+  if (record && record.contentHash === contentHash && record.owner === args.ownerPubkey) {
+    return {
+      action: "unchanged",
+      html,
+      contentHash,
+      bytes,
+      fee: 0n,
+      recordedTxId: record.pointerTxId
+    };
+  }
+  return {
+    action: "upload",
+    html,
+    contentHash,
+    bytes,
+    fee: BigInt(bytes) * args.uploadFeePerByte
+  };
+}
 async function runPush(args, deps) {
   const { io: io2 } = deps;
   let flags;
@@ -1175,6 +1314,8 @@ async function runPush(args, deps) {
     }
     let plan;
     let execute;
+    let pointerPlan;
+    let rigPageSkipDetail;
     if (session.path === "standalone") {
       const ctx = session.ctx;
       const remoteState = await ctx.fetchRemote({
@@ -1202,6 +1343,21 @@ async function runPush(args, deps) {
           relayUrls: relaysUsed
         })
       );
+      if (!flags.rigPage) {
+        rigPageSkipDetail = "skipped (--no-rig-page)";
+      } else if (relaysUsed[0] === void 0) {
+        rigPageSkipDetail = "skipped (no relay resolved for the pointer)";
+      } else if (!ctx.publisher.uploadBlob) {
+        rigPageSkipDetail = "skipped (the active publisher cannot upload raw blobs)";
+      } else {
+        pointerPlan = planRigPointer({
+          env: deps.env,
+          ownerPubkey: ctx.ownerPubkey,
+          repoId,
+          relay: relaysUsed[0],
+          uploadFeePerByte: feeRates.uploadFeePerByte
+        });
+      }
     } else {
       const client = session.client;
       plan = await client.gitEstimate({
@@ -1219,9 +1375,100 @@ async function runPush(args, deps) {
         relayUrls: relaysUsed,
         confirm: true
       });
+      rigPageSkipDetail = "skipped on the daemon path (refreshes on the next standalone push)";
     }
+    const gateway = pointerGateway(deps.env);
+    const publishPointer = async (pointer) => {
+      try {
+        const ctx = standaloneCtx;
+        const receipt = await ctx.publisher.uploadBlob({
+          body: Buffer.from(pointer.html, "utf8"),
+          contentType: "text/html",
+          repoId
+        });
+        writeRigPointerRecord(deps.env, {
+          repoId,
+          owner: identity.pubkey,
+          pointerTxId: receipt.txId,
+          contentHash: pointer.contentHash,
+          updatedAt: Date.now()
+        });
+        return {
+          status: "published",
+          txId: receipt.txId,
+          url: `${gateway}/${receipt.txId}`,
+          feePaid: receipt.feePaid.toString()
+        };
+      } catch (err) {
+        return {
+          status: "skipped",
+          detail: `pointer upload failed (push itself succeeded; the next push retries): ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    };
+    const printRigPage = (rigPage2) => {
+      if (rigPage2.url) {
+        io2.out(
+          `Rig page: ${rigPage2.url}` + (rigPage2.status === "published" ? `  paid ${rigPage2.feePaid}` : "") + "  (renders this repo from Arweave)"
+        );
+      } else if (rigPage2.detail) {
+        io2.err(`rig page: ${rigPage2.detail}`);
+      }
+    };
     const upToDate = plan.refUpdates.every((u) => u.kind === "up-to-date");
     if (upToDate) {
+      if (pointerPlan?.action !== "upload") {
+        if (flags.json) {
+          io2.emitJson({
+            command: "push",
+            repoId,
+            path,
+            identity,
+            executed: false,
+            upToDate: true,
+            plan
+          });
+        } else {
+          io2.out("Everything up-to-date \u2014 nothing to push (and nothing paid).");
+        }
+        return 0;
+      }
+      if (!flags.json) {
+        io2.out(
+          "Everything up-to-date \u2014 refs unchanged, but the Rig page is stale (new Rig build, relay, or gateway):"
+        );
+        io2.out(`  rig page  ${pointerPlan.bytes} bytes   ${pointerPlan.fee}`);
+        io2.out(renderIdentityLine(identity));
+      }
+      if (!flags.yes) {
+        if (flags.json) {
+          io2.emitJson({
+            command: "push",
+            repoId,
+            path,
+            identity,
+            executed: false,
+            upToDate: true,
+            plan,
+            hint: "refs up-to-date; the Rig page is stale \u2014 re-run with --yes to refresh it (or --no-rig-page to skip)"
+          });
+          return 0;
+        }
+        if (!io2.isInteractive) {
+          io2.err(
+            "refusing to spend channel funds without confirmation in a non-interactive session \u2014 re-run with --yes (or --no-rig-page to skip the refresh)"
+          );
+          return 1;
+        }
+        const proceed = await io2.confirm(
+          `Refresh the Rig page (total ${pointerPlan.fee} base units)? [y/N] `
+        );
+        if (!proceed) {
+          io2.err("aborted \u2014 nothing was uploaded or published.");
+          return 1;
+        }
+      }
+      const rigPage2 = await publishPointer(pointerPlan);
       if (flags.json) {
         io2.emitJson({
           command: "push",
@@ -1230,15 +1477,23 @@ async function runPush(args, deps) {
           identity,
           executed: false,
           upToDate: true,
-          plan
+          plan,
+          rigPage: rigPage2
         });
       } else {
-        io2.out("Everything up-to-date \u2014 nothing to push (and nothing paid).");
+        printRigPage(rigPage2);
       }
       return 0;
     }
+    const confirmTotal = BigInt(plan.estimate.totalFee) + (pointerPlan?.fee ?? 0n);
     if (!flags.json) {
       for (const line of renderPlan(plan)) io2.out(line);
+      if (pointerPlan?.action === "upload") {
+        io2.out(
+          `  rig page  ${pointerPlan.bytes} bytes   ${pointerPlan.fee} (repo page \u2014 paid once, reused until relay/rig-web changes)`
+        );
+        io2.out(`  total with rig page     ${confirmTotal}`);
+      }
       io2.out(renderIdentityLine(identity));
     }
     if (!flags.yes) {
@@ -1262,7 +1517,7 @@ async function runPush(args, deps) {
         return 1;
       }
       const proceed = await io2.confirm(
-        `Proceed with paid push (total ${plan.estimate.totalFee} base units)? [y/N] `
+        `Proceed with paid push (total ${confirmTotal} base units)? [y/N] `
       );
       if (!proceed) {
         io2.err("aborted \u2014 nothing was uploaded or published.");
@@ -1270,6 +1525,18 @@ async function runPush(args, deps) {
       }
     }
     const result = await execute();
+    let rigPage;
+    if (!pointerPlan) {
+      rigPage = { status: "skipped", ...rigPageSkipDetail ? { detail: rigPageSkipDetail } : {} };
+    } else if (pointerPlan.action === "unchanged") {
+      rigPage = {
+        status: "unchanged",
+        txId: pointerPlan.recordedTxId,
+        url: `${gateway}/${pointerPlan.recordedTxId}`
+      };
+    } else {
+      rigPage = await publishPointer(pointerPlan);
+    }
     if (flags.json) {
       io2.emitJson({
         command: "push",
@@ -1279,10 +1546,12 @@ async function runPush(args, deps) {
         executed: true,
         upToDate: false,
         plan,
-        result
+        result,
+        rigPage
       });
     } else {
       for (const line of renderResult(result)) io2.out(line);
+      printRigPage(rigPage);
     }
     return 0;
   } catch (err) {
@@ -1896,7 +2165,7 @@ async function stopQuietly(ctx) {
 
 // src/cli/clone.ts
 import { mkdtemp, mkdir, readdir, rename, rm, rmdir } from "fs/promises";
-import { basename, dirname, join, resolve } from "path";
+import { basename, dirname, join as join2, resolve } from "path";
 import { parseArgs as parseArgs5 } from "util";
 var CLONE_USAGE = `Usage: rig clone <relay-url> <owner>/<repo-id> [dir] [options]
 
@@ -2067,7 +2336,7 @@ async function runClone(args, deps) {
     }
     const parent = dirname(dest);
     await mkdir(parent, { recursive: true });
-    tempDir = await mkdtemp(join(parent, `.${basename(dest)}.rig-clone-`));
+    tempDir = await mkdtemp(join2(parent, `.${basename(dest)}.rig-clone-`));
     await runGit(tempDir, [
       "init",
       "--quiet",
@@ -3533,9 +3802,9 @@ async function runFetch(args, deps) {
 }
 
 // src/cli/fund.ts
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
 import { parseArgs as parseArgs9 } from "util";
 var DEVNET_FAUCET_URL = "https://faucet.devnet.toonprotocol.dev";
 var CHAINS = ["evm", "solana", "mina"];
@@ -3625,11 +3894,11 @@ function noFaucetGuidance(network, devnetOrigin) {
   return `${head}. If you meant the shared devnet, set TOON_CLIENT_NETWORK=devnet and re-run \`rig fund\` \u2014 no faucet URL is needed there. If this is a self-hosted network with its own faucet, set TOON_CLIENT_FAUCET_URL (or the faucetUrl config field). ${external}`;
 }
 function readFundConfig(env) {
-  const dir = env["TOON_CLIENT_HOME"] ?? join2(homedir(), ".toon-client");
-  const configPath = join2(dir, "config.json");
+  const dir = env["TOON_CLIENT_HOME"] ?? join3(homedir2(), ".toon-client");
+  const configPath = join3(dir, "config.json");
   try {
     return {
-      file: JSON.parse(readFileSync(configPath, "utf8")),
+      file: JSON.parse(readFileSync2(configPath, "utf8")),
       configPath
     };
   } catch (err) {
@@ -3862,7 +4131,7 @@ var runGitPassthrough = (argv2, options = {}) => {
 };
 
 // src/cli/identity-cmd.ts
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 import { createInterface } from "readline/promises";
 import { parseArgs as parseArgs10 } from "util";
@@ -3914,7 +4183,7 @@ async function prepareKeystoreTarget(input) {
   const envPassword = input.env["TOON_CLIENT_KEYSTORE_PASSWORD"]?.trim() || void 0;
   const autoPassword = envPassword === void 0;
   const password = envPassword ?? DEFAULT_KEYSTORE_PASSWORD;
-  mkdirSync(dirname2(keystorePath), { recursive: true });
+  mkdirSync2(dirname2(keystorePath), { recursive: true });
   return { keystorePath, password, autoPassword, existing, keyOps };
 }
 function readAccountIndex(env) {
@@ -5391,22 +5660,22 @@ function buildArweaveManifest(entries, indexPath = DEFAULT_INDEX, fallbackTxId)
 }
 
 // src/cli/site-record.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 var SITE_MANIFEST_FILENAME = "site-manifests.json";
-function storeDir(env) {
-  return env["TOON_CLIENT_HOME"] ?? join3(homedir2(), ".toon-client");
+function storeDir2(env) {
+  return env["TOON_CLIENT_HOME"] ?? join4(homedir3(), ".toon-client");
 }
-function storePath(env) {
-  return join3(storeDir(env), SITE_MANIFEST_FILENAME);
+function storePath2(env) {
+  return join4(storeDir2(env), SITE_MANIFEST_FILENAME);
 }
 function keyOf(repoId, ref) {
   return `${repoId}\0${ref}`;
 }
 function readFile2(env) {
   try {
-    const parsed = JSON.parse(readFileSync2(storePath(env), "utf8"));
+    const parsed = JSON.parse(readFileSync3(storePath2(env), "utf8"));
     if (parsed && typeof parsed === "object") return parsed;
     return {};
   } catch {
@@ -5417,11 +5686,11 @@ function readSiteRecord(env, repoId, ref) {
   return readFile2(env)[keyOf(repoId, ref)];
 }
 function writeSiteRecord(env, record) {
-  const dir = storeDir(env);
-  mkdirSync2(dir, { recursive: true });
+  const dir = storeDir2(env);
+  mkdirSync3(dir, { recursive: true });
   const file = readFile2(env);
   file[keyOf(record.repoId, record.ref)] = record;
-  writeFileSync(storePath(env), `${JSON.stringify(file, null, 2)}
+  writeFileSync2(storePath2(env), `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }