@tapepack/core 0.1.1 → 0.2.0

package/README.md

@@ -7,25 +7,29 @@
 ## 一条命令部署
 
 ```bash
-export TAPEPACK_PRIVATE_KEY=0x…        # 容器持有人钱包的私钥，只从环境变量读
 npx -p @tapepack/core tapepack deploy ./dist --site 1.2.344
 ```
 
-流程依次是：
+不需要私钥，流程依次是：
 
 1. **读链上现有档案作增量基准**：只把变化的文件打成增量卷。
 2. **与链上逐文件比对**：只传变化的文件。
-3. **报价**：列出链上费用、服务费和预估合计，确认后才执行。非交互环境加 `--yes`；只看报价用 `--dry-run`，不需要私钥。
-4. **操作员模式上传**，与网页版同一套：
-   - 主钱包只签两笔：给临时钱包充值（含服务费），授权它写入 2 小时。
-   - 临时钱包流水线写入，写完转服务费，剩余余额退回主钱包，最后读链复核。
-   - 按 Ctrl-C 会在当前这笔确认后停止，并照常退款。中途停止不收服务费。
+3. **报价**：列出链上费用、服务费和预估合计。只看报价用 `--dry-run`。
+4. **浏览器授权**：
+   - 本机生成一个临时钱包，并给出它的地址。
+   - 自动在浏览器打开本机授权页（只监听 127.0.0.1，带随机口令）。页面列出站点、容器、要授权的临时钱包、费用和服务费收款地址。
+   - 用持有人钱包（浏览器扩展）连接，钱包依次弹出两笔确认：给临时钱包充值（含服务费），授权它写入 2 小时。
+5. **拿到授权后上传**，与网页版同一套：
+   - 临时钱包流水线写入，进度同步显示在授权页上。
+   - 写完转服务费，剩余余额退回持有人，最后读链复核。
+   - 钱包拒签则中止，余额不动。按 Ctrl-C 会在当前这笔确认后停止，并照常退款。中途停止不收服务费。
 
 | 选项 | 说明 |
 |---|---|
 | `--site <名字>` | 链上站点名，如 `1.2.344`；用容器地址时另加 `--chain bnb\|xlayer\|base` |
 | `--dry-run` | 只报价 |
-| `--yes` | 不再询问，直接执行 |
+| `--no-open` | 不自动打开浏览器，只打印授权页地址 |
+| `--key env:<变量名>` | CI 等无浏览器环境：改用本地私钥签名（只从环境变量读）；配 `--yes` 跳过确认 |
 | `--full` | 不做增量，整体重打 |
 | `--remove-leftovers` | 删除链上有、本地没有的文件（`.well-known/` 等点目录除外） |
 | `--out <目录>` | 保留产物（缺省用临时目录） |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapepack/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "description": "TapePack：把静态站点压缩后部署到 DeWEB（TapeOut）链上，上链 Gas 直降——压缩、估算、增量更新、一条命令部署",
   "license": "MIT",

package/src/cli.mjs

@@ -5,9 +5,11 @@
 //                [--strategy auto|speed|gas]  加载策略：auto 按多花的 gas 占比为每个站点自动选（缺省）/ speed 加载优先 / gas 省钱优先
 //                [--no-lazy]  不分延后卷（首屏等全部档案）  [--no-embed]  首屏档案不内嵌进入口（多读一次链、省一点 gas）
 //   tapepack estimate <dir> [--chain all|bnb,xlayer,base] [--native-usd bnb=600,base=3500]
-//   tapepack deploy <siteDir> --site <站点名> [--dry-run 只报价] [--yes] [--key env:TAPEPACK_PRIVATE_KEY] [--out <产物目录>] [--full] [--remove-leftovers]
+//   tapepack deploy <siteDir> --site <站点名> [--dry-run 只报价] [--no-open] [--out <产物目录>] [--full] [--remove-leftovers]
 //                [--preset ...] [--strategy ...] [--chain <链>（站点用容器地址时必填）] [--rpc <url>]
-//       打包（以链上现有档案为增量基准）→ 比对 → 报价（链上费用 + 服务费）→ 确认后操作员模式上传；私钥只从环境变量读
+//                [--key env:<变量名> [--yes]]  CI 等无浏览器环境：用本地私钥代替浏览器授权
+//       打包（以链上现有档案为增量基准）→ 比对 → 报价（链上费用 + 服务费）→ 给出临时钱包地址、打开浏览器授权页，
+//       持有人在钱包里确认充值与授权 → 拿到授权后临时钱包上传、写完退款
 //   tapepack refund --chain <链> [--to 0x...]   # 退回上次中断留在临时钱包的余额
 //   tapepack plan <outDir> --container 0x... [--chain xlayer] [--src <源站点目录>]
 //   tapepack inspect <链上名字|容器地址>
@@ -84,9 +86,11 @@ async function confirm(question) {
   return /^y(es)?$/i.test(ans.trim());
 }
 
+/** --key env:<变量名>：CI 用本地私钥；缺省浏览器授权（返回 null） */
 const privateKeyArg = () => {
-  const keyRef = arg('--key') || 'env:TAPEPACK_PRIVATE_KEY';
-  if (!keyRef.startsWith('env:')) throw new Error('私钥只从环境变量读：--key env:<变量名>（默认 TAPEPACK_PRIVATE_KEY），不要写在命令行里');
+  const keyRef = arg('--key');
+  if (!keyRef) return null;
+  if (!keyRef.startsWith('env:')) throw new Error('私钥只从环境变量读：--key env:<变量名>，不要写在命令行里');
   const pk = process.env[keyRef.slice(4)];
   if (!pk) throw new Error(`没有找到私钥：请设置环境变量 ${keyRef.slice(4)}（容器持有人钱包的私钥）`);
   return pk;
@@ -94,8 +98,10 @@ const privateKeyArg = () => {
 
 function progress(e) {
   const w = (s) => console.error(s);
-  if (e.t === 'operator:fund') w(`${e.topUp ? '补充' : '充值'}临时钱包 ${e.address}：${Number(e.amount) / 1e18}`);
-  else if (e.t === 'operator:authorise') w(`授权临时钱包写入 ${e.ttl / 3600} 小时`);
+  if (e.t === 'operator:fund') w(`${e.topUp ? '补充' : '充值'}临时钱包 ${e.address}：${Number(e.amount) / 1e18}（等钱包确认）`);
+  else if (e.t === 'operator:funded') w(`充值已到账 ${e.hash}`);
+  else if (e.t === 'operator:authorise') w(`授权临时钱包写入 ${e.ttl / 3600} 小时（等钱包确认）`);
+  else if (e.t === 'operator:authorised') w(`授权已生效 ${e.hash}，开始写入`);
   else if (e.t === 'file') w(`上传 ${e.done}/${e.total} ${e.path}`);
   else if (e.t === 'fee:paid') w(`服务费已支付：${e.hash}`);
   else if (e.t === 'fee:failed') w(`服务费转账失败（随余额退回，不收）：${e.error}`);
@@ -145,8 +151,8 @@ if (cmd === 'pack' && a && b) {
   const site = arg('--site');
   if (!site) throw new Error('--site <站点名> required（如 1.2.344；用容器地址时另加 --chain）');
   if (fs.existsSync(path.join(a, 'tpack-manifest.json'))) throw new Error('deploy 需要源站点目录（含 index.html），不是 TapePack 产物目录：会在部署时自动压缩');
-  const { quoteDeploy, quoteJson, runDeploy, keyWallet } = await import('./deploy-run.mjs');
-  const dryRun = flag('--dry-run'); // 只报价，不需要私钥
+  const { quoteDeploy, quoteJson, runDeploy, deployViaBrowser, keyWallet } = await import('./deploy-run.mjs');
+  const dryRun = flag('--dry-run'); // 只报价
   const privateKey = dryRun ? null : privateKeyArg();
   const chainKey = arg('--chain');
   const rpcUrls = arg('--rpc') ? [arg('--rpc')] : undefined;
@@ -163,12 +169,22 @@ if (cmd === 'pack' && a && b) {
     console.log(JSON.stringify({ site: summary.site, chain: summary.chain, nothingToDo: true, message: '链上已是最新，无需上传' }, null, 2));
   } else if (dryRun) {
     console.log(JSON.stringify({ ...summary, deployed: false }, null, 2));
-  } else if (await confirm(`用 ${from} 部署？(y/N) `)) {
+  } else if (!privateKey || await confirm(`用 ${from} 部署？(y/N) `)) {
+    // 浏览器授权：钱包里的确认就是同意，终端不再多问
     const ac = new AbortController();
     process.once('SIGINT', () => { console.error('\n收到中断：当前这笔确认后停止并退款（再按一次强制退出，余额可用 tapepack refund 找回）'); ac.abort(); process.once('SIGINT', () => process.exit(130)); });
-    const r = await runDeploy(q, { privateKey, onEvent: progress, signal: ac.signal });
+    const r = privateKey
+      ? await runDeploy(q, { privateKey, onEvent: progress, signal: ac.signal })
+      : await deployViaBrowser(q, {
+        open: !flag('--no-open'), onEvent: progress, signal: ac.signal,
+        onUrl: (url, operator) => console.error([
+          `临时钱包 ${operator}：将被授权写入 ${summary.site || summary.container}（2 小时后自动失效，写完余额退回持有人）`,
+          `请在浏览器里用持有人钱包${summary.holder ? ` ${summary.holder} ` : ''}确认充值与授权${flag('--no-open') ? '，打开' : '（已自动打开；没打开就手动访问）'}：`,
+          `  ${url}`,
+        ].join('\n')),
+      });
     console.log(JSON.stringify(r, null, 2));
-    if (!r.completed || !r.verified) process.exitCode = 1;
+    if (!r.nothingToDo && (!r.completed || !r.verified)) process.exitCode = 1;
   } else {
     console.log(JSON.stringify({ ...summary, deployed: false }, replacer, 2));
     process.exitCode = 2;

package/src/deploy-run.mjs

@@ -1,7 +1,8 @@
 // 命令行 / MCP 部署（Node）：打包（以链上现有档案为增量基准）→ 与链上逐文件比对 → 服务费报价 →
-// 操作员模式上传。上传、续传、退款、服务费收取与网页版是同一套（onchain.uploadWithOperator），
-// 主钱包换成本地私钥：私钥只来自调用方（命令行读环境变量），不落盘；临时钱包钥匙存在 ~/.tapepack（0600），
-// 中断后下次部署接着用其中的余额，或用 refund 退回。
+// 操作员模式上传。上传、续传、退款、服务费收取与网页版是同一套（onchain.uploadWithOperator）。
+// 主钱包缺省用浏览器授权（wallet-bridge.mjs）：给出临时钱包地址、打开本机授权页，持有人在浏览器钱包里确认
+// 充值与授权，拿到授权后再上传——不碰主钱包私钥。CI 等无浏览器环境可改用本地私钥（只从环境变量读，不落盘）。
+// 临时钱包钥匙存在 ~/.tapepack（0600），中断后下次部署接着用其中的余额，或用 refund 退回。
 //
 // 服务费与网页版一致（fee.mjs）：节省额 × 20%，封顶 $2，节省不到 $0.10 免费；取不到实时币价时不收。
 
@@ -10,7 +11,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { Wallet, Transaction, getAddress } from 'ethers';
 import { pack, readSite, outputsFromDir } from './pack.mjs';
-import { chainContext, chainKeyOf, resolveContainer, fetchBase, planUpload, uploadWithOperator, refundOperator, operatorStatus, gasPriceOf } from './onchain.mjs';
+import { chainContext, chainKeyOf, resolveContainer, fetchBase, planUpload, uploadWithOperator, refundOperator, operatorStatus, gasPriceOf, INTERFACES, OPERATOR_TTL } from './onchain.mjs';
+import { startWalletBridge, openInBrowser } from './wallet-bridge.mjs';
 import { serviceFee, FEE_TO, FEE_CAP_USD, FEE_FREE_BELOW_USD, FEE_RATE_BP } from './fee.mjs';
 import { fetchLivePrices } from './prices.mjs';
 
@@ -55,6 +57,11 @@ export function fileKeyStore({ dir = process.env.TAPEPACK_HOME || path.join(os.h
       fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
       fs.writeFileSync(file(chainId), JSON.stringify({ pk, holder, at: new Date().toISOString() }), { mode: 0o600 });
     },
+    /** 浏览器授权时临时钱包先建、持有人连上钱包后才知道：补记，供找回余额 */
+    setHolder: (chainId, h) => {
+      const j = readJson(chainId);
+      if (j) fs.writeFileSync(file(chainId), JSON.stringify({ ...j, holder: h }), { mode: 0o600 });
+    },
     clear: (chainId) => fs.rmSync(file(chainId), { force: true }),
   };
 }
@@ -155,18 +162,21 @@ export function quoteJson(q) {
 }
 
 /**
- * 执行部署：本地私钥作主钱包，走操作员模式（主钱包签 1~2 笔：充值含服务费、授权 2 小时）。
+ * 执行部署：走操作员模式（主钱包签 1~2 笔：充值含服务费、授权 2 小时）。
+ * 主钱包二选一：浏览器授权（authorizeInBrowser 给出的 wallet + holder，缺省做法）或本地私钥（privateKey，CI 用）。
  * @returns {Promise<object>} JSON 友好的结果
  */
-export async function runDeploy(q, { privateKey, keys, onEvent = () => {}, signal, window = 8 } = {}) {
+export async function runDeploy(q, { privateKey, wallet, holder, keys, onEvent = () => {}, signal, window = 8 } = {}) {
   const { ctx, target, plan, svc } = q;
   if (!plan.calls.length) return { site: target.name, chain: ctx.key, nothingToDo: true, message: '链上已是最新，无需上传' };
-  const wallet = keyWallet(ctx, privateKey);
-  if (target.holder && wallet.address !== getAddress(target.holder)) throw new Error(`钱包 ${wallet.address} 不是 ${target.name} 的持有人（持有人 ${target.holder}）`);
-  keys = keys || fileKeyStore({ holder: wallet.address });
+  if (privateKey) { wallet = keyWallet(ctx, privateKey); holder = wallet.address; }
+  if (!wallet || !holder) throw new Error('需要主钱包：浏览器授权或私钥');
+  holder = getAddress(holder);
+  if (target.holder && holder !== getAddress(target.holder)) throw new Error(`钱包 ${holder} 不是 ${target.name} 的持有人（持有人 ${target.holder}）`);
+  keys = keys || fileKeyStore({ holder });
   // 本链留着别的主钱包中断时的临时钱包：先把余额退给它，再为本次新建
   const prev = keys.holderOf?.(ctx.chainId);
-  if (prev && getAddress(prev) !== wallet.address) await refundOperator({ ctx, keys, to: prev, onEvent });
+  if (prev && getAddress(prev) !== holder) await refundOperator({ ctx, keys, to: prev, onEvent });
   // 收款地址与金额上限再核对一次（与网页版签名前核对一致）：不符即中止
   let fee = null;
   if (svc && svc.feeWei > 0n) {
@@ -174,7 +184,7 @@ export async function runDeploy(q, { privateKey, keys, onEvent = () => {}, signa
     if (svc.price && svc.feeUsd > FEE_CAP_USD * 1.0001) throw new Error('服务费超过封顶，已中止');
     fee = { to: svc.to, wei: svc.feeWei };
   }
-  const r = await uploadWithOperator({ ctx, wallet, holder: wallet.address, plan, keys, onEvent, signal, fee, refundOnError: true, window });
+  const r = await uploadWithOperator({ ctx, wallet, holder, plan, keys, onEvent, signal, fee, refundOnError: true, window });
   const price = svc?.price ?? null;
   return {
     site: target.name, chain: ctx.key, container: target.container,
@@ -187,6 +197,86 @@ export async function runDeploy(q, { privateKey, keys, onEvent = () => {}, signa
   };
 }
 
+const nativeText = (wei, cur) => `${native(wei)} ${cur}`;
+
+/**
+ * 浏览器授权：先定下临时钱包（地址展示在授权页上），在本机起授权页并打开浏览器，等持有人钱包连上。
+ * 之后上传流程里主钱包要签的（充值含服务费、授权临时钱包、补充余额）都由页面转给钱包确认。
+ * @param {object} [opts]
+ * @param {boolean} [opts.open=true] 自动打开浏览器
+ * @param {(url: string, operator: string) => void} [opts.onUrl] 授权页地址（打不开浏览器时让用户手动打开）
+ * @returns {Promise<{ bridge, wallet, holder: string, operator: string, keys }>}
+ */
+export async function authorizeInBrowser(q, { keys, open = true, onUrl = () => {}, timeoutMs = 15 * 60_000, signal } = {}) {
+  const { ctx, target } = q;
+  keys = keys || fileKeyStore({ holder: target.holder });
+  // 本链留着别的持有人中断时的临时钱包：先把余额退给它（只用临时钱包签名），本次另建
+  const prev = keys.holderOf?.(ctx.chainId);
+  if (prev && target.holder && getAddress(prev) !== getAddress(target.holder)) await refundOperator({ ctx, keys, to: prev });
+  // 沿用本链未清理的临时钱包（上次中断的余额接着用），否则新建并先存盘（进程被杀也能找回余额）
+  let pk = await keys.load(ctx.chainId);
+  if (!pk) { pk = Wallet.createRandom().privateKey; await keys.save(ctx.chainId, pk); }
+  const operator = new Wallet(pk).address;
+  const bridge = await startWalletBridge({
+    info: { site: target.name, chain: ctx.key, chainName: ctx.name, currency: ctx.currency, container: target.container, holder: target.holder, operator, ttlHours: OPERATOR_TTL / 3600, quote: quoteJson(q) },
+    accept: async (account) => {
+      let a;
+      try { a = getAddress(account); } catch { return '钱包地址无效'; }
+      if (target.holder) return a === getAddress(target.holder) ? null : `请切换到持有人钱包 ${target.holder}（当前连接的是 ${a}）`;
+      const data = INTERFACES.registry.encodeFunctionData('canEdit', [target.container, a]);
+      const can = INTERFACES.registry.decodeFunctionResult('canEdit', await ctx.rpc.call('eth_call', [{ to: ctx.registry, data }, 'latest']))[0];
+      return can ? null : `${a} 不能编辑这个容器，请换持有人钱包`;
+    },
+  });
+  onUrl(bridge.url, operator);
+  if (open) openInBrowser(bridge.url);
+  let timer;
+  try {
+    const holder = await Promise.race([
+      bridge.connected,
+      new Promise((_, rej) => { timer = setTimeout(() => rej(new Error('等待浏览器钱包连接超时')), timeoutMs); }),
+      new Promise((_, rej) => signal?.addEventListener('abort', () => rej(new Error('已取消')))),
+    ]);
+    keys.setHolder?.(ctx.chainId, getAddress(holder));
+    return { bridge, wallet: bridge.wallet, holder: getAddress(holder), operator, keys };
+  } catch (e) {
+    bridge.fail(String(e.message || e));
+    await bridge.close(1500);
+    throw e;
+  } finally { clearTimeout(timer); }
+}
+
+/** 上传进度 → 授权页（下一笔钱包请求的说明、进度日志） */
+function mirrorToPage(bridge, q, e) {
+  const { ctx, target, svc } = q;
+  const fee = svc && svc.feeWei > 0n ? `，含服务费 ${nativeText(svc.feeWei, ctx.currency)}` : '';
+  if (e.t === 'operator:fund') bridge.label(e.topUp ? `补充临时钱包余额（实际 gas 高于预估）` : `给临时钱包充值（链上费用 + 余量${fee}；用不完的写完后退回）`);
+  else if (e.t === 'operator:authorise') bridge.label(`授权临时钱包 ${e.address} 写入 ${target.name || target.container}（${e.ttl / 3600} 小时后自动失效）`);
+  else if (e.t === 'operator:authorised') bridge.log({ text: '授权已生效，开始写入', cls: 'ok' });
+  else if (e.t === 'file') bridge.log({ text: `上传 ${e.done}/${e.total}  ${e.path}` });
+  else if (e.t === 'fee:paid') bridge.log({ text: `服务费已支付 ${e.hash}` });
+  else if (e.t === 'fee:failed') bridge.log({ text: '服务费转账失败（随余额退回，不收）', cls: 'bad' });
+  else if (e.t === 'refund') bridge.log({ text: `余额已退回 ${nativeText(e.amount, ctx.currency)}` });
+  else if (e.t === 'cancelled') bridge.log({ text: '已停止：等在途交易落定后退款', cls: 'bad' });
+}
+
+/** 浏览器授权部署（命令行 / MCP 缺省做法）：authorizeInBrowser → runDeploy，进度同步到授权页 */
+export async function deployViaBrowser(q, { keys, open, onUrl, onEvent = () => {}, signal, window, timeoutMs } = {}) {
+  if (!q.plan.calls.length) return runDeploy(q, {});
+  const auth = await authorizeInBrowser(q, { keys, open, onUrl, signal, timeoutMs });
+  try {
+    const r = await runDeploy(q, { wallet: auth.wallet, holder: auth.holder, keys: auth.keys, signal, window, onEvent: (e) => { mirrorToPage(auth.bridge, q, e); onEvent(e); } });
+    auth.bridge.finish({
+      text: r.completed && r.verified ? `部署完成，读链复核通过：${r.url || r.container}。可以关闭本页。` : '未全部完成：余额已退回，重新运行部署会只传剩下的文件。',
+      completed: r.completed, verified: r.verified,
+    });
+    return { ...r, holder: auth.holder };
+  } catch (e) {
+    auth.bridge.fail('部署中止：' + String(e.message || e) + '。余额已自动退回持有人。');
+    throw e;
+  } finally { await auth.bridge.close(3000); }
+}
+
 /** 找回临时钱包余额（上次中断留下的）：退回到当初充值的主钱包 */
 export async function refundLeftover({ chainKey, rpcUrls, keys, to }) {
   const ctx = chainContext(chainKey, { rpcUrls: rpcOf(rpcUrls) });

package/src/wallet-bridge.mjs

@@ -0,0 +1,234 @@
+// 浏览器授权桥（Node）：命令行 / MCP 部署不碰主钱包私钥——本机起一个只监听 127.0.0.1、带随机口令的小服务，
+// 打开授权页；页面连接用户的浏览器钱包（扩展），把上传流程（onchain.uploadWithOperator）里主钱包要签的请求
+// （充值临时钱包、授权临时钱包写入、中途补充余额）转给钱包确认，结果交回本进程。
+// 对 uploadWithOperator 来说它就是一个 EIP-1193 主钱包；只转发白名单里的方法。
+// 页面只是展示 + 转发：上传由本进程的临时钱包完成，关掉页面不影响已授权后的写入（补充余额时才需要它）。
+
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+
+const FORWARD = new Set(['eth_chainId', 'eth_sendTransaction', 'wallet_switchEthereumChain', 'wallet_addEthereumChain']);
+
+/** 用系统默认浏览器打开 */
+export function openInBrowser(url) {
+  const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
+    : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]] : ['xdg-open', [url]];
+  try { spawn(cmd, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref(); return true; } catch { return false; }
+}
+
+/**
+ * @param {object} p
+ * @param {object} p.info 页面展示：{ site, chain, chainName, currency, container, holder, operator, ttlHours, quote }
+ * @param {(account: string) => Promise<string|null>} p.accept 页面连上钱包时校验账户：返回 null 通过，否则返回原因
+ * @param {number} [p.port=0] 端口（0 = 随机）
+ * @returns {Promise<{ url, wallet, connected: Promise<string>, label(s), log(entry), finish(result), close() }>}
+ */
+export async function startWalletBridge({ info, accept, port = 0 }) {
+  const token = randomBytes(16).toString('hex');
+  const state = { info, account: null, pending: null, history: [], log: [], done: null, error: null };
+  let seq = 0, label = '';
+  const waiters = new Map(); // id → { resolve, reject }
+  let onConnected;
+  const connected = new Promise((r) => { onConnected = r; });
+
+  const wallet = {
+    request({ method, params = [] }) {
+      if (!FORWARD.has(method)) return Promise.reject(new Error('unsupported wallet method: ' + method));
+      if (method === 'eth_chainId' && state.chainId) return Promise.resolve(state.chainId); // 页面连接时已报，切链后会更新
+      const id = ++seq;
+      state.pending = { id, method, params, label: method === 'eth_sendTransaction' ? label : '切换钱包网络' };
+      return new Promise((resolve, reject) => waiters.set(id, { resolve, reject }));
+    },
+  };
+
+  const json = (res, code, obj) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }); res.end(JSON.stringify(obj)); };
+  const body = (req) => new Promise((resolve) => { let s = ''; req.on('data', (d) => { s += d; if (s.length > 65536) req.destroy(); }); req.on('end', () => { try { resolve(JSON.parse(s || '{}')); } catch { resolve({}); } }); });
+
+  const server = http.createServer(async (req, res) => {
+    const u = new URL(req.url, 'http://127.0.0.1');
+    if (u.searchParams.get('t') !== token) { res.writeHead(403).end('forbidden'); return; }
+    if (req.method === 'GET' && u.pathname === '/') {
+      // 不加 CSP：部分钱包扩展靠往页面注入脚本工作，严格 CSP 会把它们挡掉（页面只在本机、凭随机口令访问）
+      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', 'referrer-policy': 'no-referrer' });
+      res.end(PAGE); return;
+    }
+    if (req.method === 'GET' && u.pathname === '/api/state') {
+      const { pending } = state;
+      return json(res, 200, { info: state.info, account: state.account, pending: pending && { id: pending.id, method: pending.method, params: pending.params, label: pending.label }, history: state.history, log: state.log.slice(-200), done: state.done, error: state.error });
+    }
+    if (req.method === 'POST' && u.pathname === '/api/connect') {
+      const b = await body(req);
+      const why = await accept(String(b.account || '')).catch((e) => String(e.message || e));
+      if (why) return json(res, 200, { ok: false, reason: why });
+      state.account = b.account; state.chainId = b.chainId || null;
+      onConnected(b.account);
+      return json(res, 200, { ok: true });
+    }
+    if (req.method === 'POST' && u.pathname === '/api/chain') { const b = await body(req); state.chainId = b.chainId || null; return json(res, 200, { ok: true }); }
+    if (req.method === 'POST' && u.pathname === '/api/result') {
+      const b = await body(req);
+      const w = waiters.get(b.id);
+      if (!w || state.pending?.id !== b.id) return json(res, 200, { ok: false });
+      waiters.delete(b.id);
+      const p = state.pending; state.pending = null;
+      if (b.error) {
+        state.history.push({ label: p.label, method: p.method, error: b.error.message || '钱包拒绝' });
+        w.reject(Object.assign(new Error(b.error.message || '钱包拒绝'), { code: b.error.code }));
+      } else {
+        if (p.method === 'wallet_switchEthereumChain' || p.method === 'wallet_addEthereumChain') state.chainId = p.params?.[0]?.chainId || state.chainId;
+        if (p.method === 'eth_sendTransaction') state.history.push({ label: p.label, method: p.method, hash: b.result });
+        w.resolve(b.result);
+      }
+      return json(res, 200, { ok: true });
+    }
+    res.writeHead(404).end();
+  });
+  await new Promise((r) => server.listen(port, '127.0.0.1', r));
+  const url = `http://127.0.0.1:${server.address().port}/?t=${token}`;
+
+  return {
+    url, wallet, connected,
+    /** 下一笔钱包请求在页面上的说明 */
+    label: (s) => { label = s; },
+    /** 进度（页面日志） */
+    log: (entry) => { state.log.push({ at: Date.now(), ...entry }); },
+    finish: (result) => { state.done = result; },
+    fail: (message) => {
+      state.error = message;
+      for (const [id, w] of waiters) { w.reject(new Error(message)); waiters.delete(id); }
+      state.pending = null;
+    },
+    /** 页面还能拉到最终结果：稍等再关 */
+    close: (delayMs = 0) => new Promise((r) => setTimeout(() => { server.closeAllConnections?.(); server.close(() => r()); }, delayMs)),
+  };
+}
+
+const PAGE = `<!doctype html>
+<html lang="zh"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>TapePack 部署授权</title>
+<style>
+:root{--fg:#141414;--dim:#6b6b6b;--line:#e6e2da;--bg:#faf8f4;--card:#fff;--acc:#d9481b;--ok:#0a7a2f;--bad:#b3261e}
+@media (prefers-color-scheme:dark){:root{--fg:#eee;--dim:#9a9a9a;--line:#333;--bg:#151515;--card:#1e1e1e;--ok:#5fcf86;--bad:#ff8a80}}
+*{box-sizing:border-box}
+body{font:15px/1.65 -apple-system,"PingFang SC","Microsoft YaHei",sans-serif;background:var(--bg);color:var(--fg);max-width:760px;margin:0 auto;padding:28px 16px 60px}
+h1{font-size:22px;margin:0 0 4px}.sub{color:var(--dim);margin:0 0 18px}
+.card{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:14px 16px;margin:14px 0}
+table{border-collapse:collapse;width:100%}td{padding:5px 0;vertical-align:top}td:first-child{color:var(--dim);width:7.5em;padding-right:10px}
+.mono{font-family:ui-monospace,Menlo,monospace;font-size:13px;word-break:break-all}
+button,select{font:inherit;padding:9px 16px;border-radius:8px;border:1px solid var(--line);background:var(--card);color:var(--fg)}
+button.primary{background:var(--acc);border-color:var(--acc);color:#fff}button:disabled{opacity:.5}
+.step{display:flex;gap:10px;padding:8px 0;border-top:1px solid var(--line)}.step:first-child{border-top:0}
+.st{min-width:4.5em}.ok{color:var(--ok)}.bad{color:var(--bad)}.dim{color:var(--dim)}
+#log{max-height:260px;overflow:auto;font-size:13px}
+.hl{border-color:var(--acc)}
+</style></head><body>
+<h1>TapePack 部署授权</h1>
+<p class="sub" id="sub">命令行发起的部署，需要容器持有人的钱包确认。</p>
+
+<div class="card"><table id="info"></table></div>
+
+<div class="card" id="connectCard">
+  <div style="display:flex;gap:10px;flex-wrap:wrap;align-items:center">
+    <select id="wallet"><option value="">检测钱包中…</option></select>
+    <button class="primary" id="connect">连接钱包</button>
+  </div>
+  <p class="dim" id="connectMsg" style="margin:8px 0 0">请用持有人钱包连接。连接后，钱包会依次弹出要确认的交易。</p>
+</div>
+
+<div class="card"><b>需要钱包确认</b><div id="steps" style="margin-top:6px"><div class="dim">连接钱包后，命令行会发起：① 给临时钱包充值（含服务费）② 授权临时钱包写入。</div></div></div>
+<div class="card"><b>上传进度</b><div id="log" class="mono" style="margin-top:6px"><span class="dim">授权完成后，命令行用临时钱包逐笔写入。</span></div></div>
+
+<script>
+const T = new URLSearchParams(location.search).get('t');
+const api = (p, body) => fetch(p + '?t=' + T, body ? { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) } : {}).then((r) => r.json());
+const $ = (id) => document.getElementById(id);
+const esc = (s) => String(s ?? '').replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+const fmt = (wei, cur) => (Number(BigInt(wei)) / 1e18).toFixed(6).replace(/0+$/, '').replace(/\\.$/, '') + ' ' + cur;
+
+// —— 钱包发现：EIP-6963 + 旧式注入 ——
+const WALLETS = [];
+function addWallet(name, provider) {
+  if (!provider || WALLETS.some((x) => x.provider === provider)) return;
+  WALLETS.push({ name, provider });
+  $('wallet').innerHTML = WALLETS.map((x, i) => '<option value="' + i + '">' + esc(x.name) + '</option>').join('');
+}
+window.addEventListener('eip6963:announceProvider', (e) => addWallet(e.detail.info.name, e.detail.provider));
+window.dispatchEvent(new Event('eip6963:requestProvider'));
+function legacy() {
+  if (window.okxwallet) addWallet('OKX Wallet', window.okxwallet);
+  if (window.ethereum) addWallet(window.ethereum.isOkxWallet ? 'OKX Wallet' : window.ethereum.isMetaMask ? 'MetaMask' : '浏览器钱包', window.ethereum);
+}
+setTimeout(() => { legacy(); if (!WALLETS.length) $('wallet').innerHTML = '<option value="">未检测到钱包扩展</option>'; }, 600);
+
+let provider = null, account = null, busy = 0, info = null;
+$('connect').onclick = async () => {
+  legacy();
+  provider = (WALLETS[Number($('wallet').value)] || WALLETS[0] || {}).provider || null;
+  if (!provider) { $('connectMsg').innerHTML = '<span class="bad">未检测到浏览器钱包：请确认扩展已启用、已解锁，并刷新本页。</span>'; return; }
+  try {
+    const [a] = await provider.request({ method: 'eth_requestAccounts' });
+    const chainId = await provider.request({ method: 'eth_chainId' });
+    const r = await api('/api/connect', { account: a, chainId });
+    if (!r.ok) { $('connectMsg').innerHTML = '<span class="bad">' + esc(r.reason) + '</span>'; return; }
+    account = a;
+    $('connectMsg').innerHTML = '<span class="ok">已连接 ' + esc(a) + '</span>，请留意钱包弹窗。';
+    $('connect').disabled = true;
+    provider.on?.('chainChanged', (c) => api('/api/chain', { chainId: c }));
+  } catch (e) { $('connectMsg').innerHTML = '<span class="bad">连接失败：' + esc(e && e.message || e) + '</span>'; }
+};
+
+async function forward(p) {
+  if (busy === p.id) return;
+  busy = p.id;
+  try {
+    const result = await provider.request({ method: p.method, params: p.params });
+    await api('/api/result', { id: p.id, result });
+  } catch (e) {
+    await api('/api/result', { id: p.id, error: { code: e && e.code, message: (e && e.message) || String(e) } });
+  }
+}
+
+function render(s) {
+  info = s.info;
+  const i = s.info, q = i.quote || {};
+  const rows = [
+    ['站点', esc(i.site || '') + '（' + esc(i.chainName) + '）'],
+    ['容器', '<span class="mono">' + esc(i.container) + '</span>'],
+    ['持有人', '<span class="mono">' + esc(i.holder || '（连接的钱包须能编辑该容器）') + '</span>'],
+    ['授权给', '<span class="mono">' + esc(i.operator) + '</span><br><span class="dim">本次部署的临时钱包，只能写本容器的网站文件，' + esc(i.ttlHours) + ' 小时后自动失效；写完余额退回持有人</span>'],
+  ];
+  if (q.upload) rows.push(['上传', q.upload.files.length + ' 个文件，' + q.upload.txs + ' 笔写入']);
+  if (q.chainCost) rows.push(['链上费用', q.chainCost.native + ' ' + esc(q.chainCost.currency) + (q.chainCost.usd != null ? '（约 $' + q.chainCost.usd + '）' : '')]);
+  if (q.serviceFee) rows.push(['服务费', q.serviceFee.free ? '免费' : q.serviceFee.native + ' ' + esc(q.chainCost.currency) + '（$' + q.serviceFee.usd + '，转 <span class="mono">' + esc(q.serviceFee.to) + '</span>）']);
+  $('info').innerHTML = rows.map(([k, v]) => '<tr><td>' + k + '</td><td>' + v + '</td></tr>').join('');
+  $('sub').textContent = '命令行正在部署 ' + (i.site || i.container) + '，需要持有人钱包确认。';
+
+  const steps = s.history.map((h) => '<div class="step"><span class="st ' + (h.error ? 'bad">已拒绝' : 'ok">已确认') + '</span><span>' + esc(h.label) + (h.hash ? '<br><span class="mono dim">' + esc(h.hash) + '</span>' : '') + (h.error ? '<br><span class="bad">' + esc(h.error) + '</span>' : '') + '</span></div>');
+  if (s.pending) {
+    const p = s.pending, tx = p.params && p.params[0] || {};
+    const val = tx.value && BigInt(tx.value) > 0n ? '，金额 ' + fmt(tx.value, i.currency) : '';
+    steps.push('<div class="step"><span class="st">请确认</span><span>' + esc(p.label) + esc(val) + '<br><span class="dim">请在钱包弹窗里确认</span> <button id="retry" style="padding:3px 10px;font-size:13px">没看到弹窗？重新发起</button></span></div>');
+  }
+  if (steps.length) $('steps').innerHTML = steps.join('');
+  const r = document.getElementById('retry'); if (r) r.onclick = () => { busy = 0; if (s.pending && provider) forward(s.pending); };
+
+  if (s.log.length) $('log').innerHTML = s.log.map((l) => '<div class="' + (l.cls || '') + '">' + esc(l.text) + '</div>').join('');
+  if (s.done) $('log').insertAdjacentHTML('beforeend', '<div class="ok" style="margin-top:6px;font-weight:600">' + esc(s.done.text) + '</div>');
+  if (s.error) $('log').insertAdjacentHTML('beforeend', '<div class="bad" style="margin-top:6px">' + esc(s.error) + '</div>');
+}
+
+let stopped = false;
+async function tick() {
+  try {
+    const s = await api('/api/state');
+    render(s);
+    if (s.pending && provider && account) forward(s.pending);
+    if (s.done || s.error) stopped = true;
+  } catch { if (stopped) return; }
+  if (!stopped) setTimeout(tick, 1000);
+}
+tick();
+</script>
+</body></html>`;