@jaw.id/cli 0.1.26 → 0.2.1

package/dist/commands/session/revoke.js

@@ -1,11 +1,11 @@
 import { Command, Flags } from '@oclif/core';
-import * as fs from 'fs';
+import * as fs5 from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as crypto from 'crypto';
 import WebSocket from 'ws';
 
-// src/base-command.ts
+// src/commands/session/revoke.ts
 var JAW_DIR = path.join(os.homedir(), ".jaw");
 var PATHS = {
   root: JAW_DIR,
@@ -13,7 +13,9 @@ var PATHS = {
   session: path.join(JAW_DIR, "session.json"),
   relay: path.join(JAW_DIR, "relay.json"),
   keystore: path.join(JAW_DIR, "keystore.json"),
-  sessionConfig: path.join(JAW_DIR, "session-config.json")
+  sessionConfig: path.join(JAW_DIR, "session-config.json"),
+  x402Log: path.join(JAW_DIR, "x402-log.jsonl"),
+  paymentLock: path.join(JAW_DIR, "x402-payment.lock")
 };
 
 // src/lib/validation.ts
@@ -41,8 +43,8 @@ function isValidRelayUrl(url) {
 
 // src/lib/config.ts
 function ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs.chmodSync(dir, 448);
+  fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs5.chmodSync(dir, 448);
 }
 function migrateConfig(config) {
   if (config.paymasterUrl && !config.paymasters) {
@@ -54,10 +56,10 @@ function migrateConfig(config) {
   return config;
 }
 function loadConfig() {
-  if (!fs.existsSync(PATHS.config)) {
+  if (!fs5.existsSync(PATHS.config)) {
     return {};
   }
-  const raw = fs.readFileSync(PATHS.config, "utf-8");
+  const raw = fs5.readFileSync(PATHS.config, "utf-8");
   try {
     const config = JSON.parse(raw);
     return migrateConfig(config);
@@ -69,7 +71,7 @@ function loadConfig() {
 }
 function saveConfig(config) {
   ensureDir(PATHS.root);
-  fs.writeFileSync(PATHS.config, JSON.stringify(config, null, 2) + "\n", {
+  fs5.writeFileSync(PATHS.config, JSON.stringify(config, null, 2) + "\n", {
     encoding: "utf-8",
     mode: 384
   });
@@ -223,7 +225,18 @@ function bufferToBase64(buf) {
 }
 
 // src/lib/ws-bridge.ts
+function buildInitPayload(config) {
+  return {
+    type: "init",
+    apiKey: config.apiKey,
+    chainId: config.chainId,
+    ens: config.ens,
+    paymasterUrl: config.paymasterUrl,
+    ...config.paymasterUrl && config.paymasterContext ? { paymasterContext: config.paymasterContext } : {}
+  };
+}
 var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
 var MAX_MESSAGE_BYTES = 5 * 1024 * 1024;
 var BROWSER_REOPEN_COOLDOWN_MS = 5e3;
 var MAX_RECONNECT_ATTEMPTS = 3;
@@ -232,6 +245,7 @@ var WSBridge = class {
   relayUrl;
   session;
   timeout;
+  connectTimeout;
   config;
   privateKeyHex;
   publicKeyHex;
@@ -253,6 +267,7 @@ var WSBridge = class {
     this.relayUrl = options.relayUrl;
     this.session = options.session;
     this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT_MS;
     this.config = options.config;
     this.privateKeyHex = options.privateKeyHex;
     this.publicKeyHex = options.publicKeyHex;
@@ -281,17 +296,16 @@ var WSBridge = class {
       let expectingKeyExchange = !this.peerPublicKeyHex;
       const timer = setTimeout(() => {
         ws.close();
-        reject(new Error("Browser did not connect in time.\nRun `jaw disconnect` then try again."));
-      }, 3e4);
+        reject(
+          new Error(
+            `Browser did not connect within ${Math.round(this.connectTimeout / 1e3)}s.
+Run \`jaw disconnect\` then try again, or raise JAW_BRIDGE_TIMEOUT_MS.`
+          )
+        );
+      }, this.connectTimeout);
       const sendEncryptedInit = async () => {
         if (!this.sharedSecret) return;
-        const envelope = await encryptMessage(this.sharedSecret, {
-          type: "init",
-          apiKey: this.config.apiKey,
-          chainId: this.config.chainId,
-          ens: this.config.ens,
-          paymasterUrl: this.config.paymasterUrl
-        });
+        const envelope = await encryptMessage(this.sharedSecret, buildInitPayload(this.config));
         this.sendRaw(ws, JSON.stringify({ type: "encrypted", ...envelope }));
       };
       const waitForReady = () => {
@@ -539,8 +553,8 @@ function safeParse(data) {
 }
 function loadRelaySession() {
   try {
-    if (!fs.existsSync(PATHS.relay)) return null;
-    const raw = fs.readFileSync(PATHS.relay, "utf-8");
+    if (!fs5.existsSync(PATHS.relay)) return null;
+    const raw = fs5.readFileSync(PATHS.relay, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.session || !parsed.relayUrl || !parsed.privateKey || !parsed.publicKey) {
       return null;
@@ -552,14 +566,14 @@ function loadRelaySession() {
 }
 function saveRelaySession(info) {
   ensureDir(PATHS.root);
-  fs.writeFileSync(PATHS.relay, JSON.stringify(info, null, 2) + "\n", {
+  fs5.writeFileSync(PATHS.relay, JSON.stringify(info, null, 2) + "\n", {
     encoding: "utf-8",
     mode: 384
   });
 }
 function deleteRelaySession() {
   try {
-    if (fs.existsSync(PATHS.relay)) fs.unlinkSync(PATHS.relay);
+    if (fs5.existsSync(PATHS.relay)) fs5.unlinkSync(PATHS.relay);
   } catch {
   }
 }
@@ -569,6 +583,10 @@ var DEFAULT_KEYS_URL = "https://keys.jaw.id";
 var DEFAULT_RELAY_URL = "wss://relay.jaw.id";
 async function getBridge(options) {
   const config = loadConfig();
+  const envTimeout = Number(process.env["JAW_BRIDGE_TIMEOUT_MS"]);
+  const fromEnv = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : void 0;
+  const timeout = options.timeout ?? fromEnv;
+  const connectTimeout = options.connectTimeout ?? fromEnv;
   const keysUrl = options.keysUrl ?? config.keysUrl ?? DEFAULT_KEYS_URL;
   const relayUrl = options.relayUrl ?? config.relayUrl ?? DEFAULT_RELAY_URL;
   const chainId = options.chainId ?? config.defaultChain ?? 1;
@@ -581,7 +599,7 @@ async function getBridge(options) {
   let relaySession = loadRelaySession();
   if (relaySession && relaySession.relayUrl === relayUrl && relaySession.peerPublicKey) {
     try {
-      return await connectBridge(relaySession, options, chainId, keysUrl, relayUrl, false);
+      return await connectBridge({ ...options, timeout }, relaySession, chainId, keysUrl, relayUrl, false);
     } catch {
       deleteRelaySession();
       relaySession = null;
@@ -591,7 +609,7 @@ async function getBridge(options) {
   }
   const session = await createNewSession(relayUrl);
   saveRelaySession(session);
-  return await connectBridge(session, options, chainId, keysUrl, relayUrl, true);
+  return await connectBridge({ ...options, timeout, connectTimeout }, session, chainId, keysUrl, relayUrl, true);
 }
 async function createNewSession(relayUrl) {
   const kp = await generateKeyPair();
@@ -606,17 +624,20 @@ async function createNewSession(relayUrl) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function connectBridge(relaySession, options, chainId, keysUrl, relayUrl, openBrowser) {
+async function connectBridge(options, relaySession, chainId, keysUrl, relayUrl, openBrowser) {
   const config = loadConfig();
+  const paymaster = config.paymasters?.[chainId];
   const bridge = new WSBridge({
     relayUrl,
     session: relaySession.session,
     timeout: options.timeout,
+    connectTimeout: options.connectTimeout,
     config: {
       apiKey: options.apiKey,
       chainId,
       ens: options.ens ?? config.ens,
-      paymasterUrl: options.paymasterUrl ?? config.paymasters?.[chainId]?.url
+      paymasterUrl: paymaster?.url,
+      paymasterContext: paymaster?.context
     },
     privateKeyHex: relaySession.privateKey,
     publicKeyHex: relaySession.publicKey,
@@ -626,6 +647,12 @@ async function connectBridge(relaySession, options, chainId, keysUrl, relayUrl,
     // onBrowserNeeded — only open a browser for new sessions
     openBrowser ? async () => {
       const bridgeUrl = buildBridgeUrl(keysUrl, relaySession.session, relayUrl, relaySession.publicKey);
+      if (process.env["JAW_NO_BROWSER"]) {
+        process.stderr.write(`Open this URL to approve:
+${bridgeUrl}
+`);
+        return;
+      }
       const { default: open } = await import('open');
       await open(bridgeUrl);
     } : void 0,
@@ -645,35 +672,77 @@ function buildBridgeUrl(keysUrl, session, relayUrl, cliPublicKeyHex) {
   return url.toString();
 }
 function deleteKeystore() {
-  if (fs.existsSync(PATHS.keystore)) {
-    fs.unlinkSync(PATHS.keystore);
+  if (fs5.existsSync(PATHS.keystore)) {
+    fs5.unlinkSync(PATHS.keystore);
   }
 }
 function keystoreExists() {
-  return fs.existsSync(PATHS.keystore);
+  return fs5.existsSync(PATHS.keystore);
+}
+function liveOrphans(orphans, now = Date.now() / 1e3) {
+  return (orphans ?? []).filter((orphan) => orphan.expiry > now);
+}
+function writeSessionConfig(config) {
+  ensureDir(PATHS.root);
+  const temp = `${PATHS.sessionConfig}.${process.pid}.tmp`;
+  fs5.writeFileSync(temp, JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  fs5.chmodSync(temp, 384);
+  fs5.renameSync(temp, PATHS.sessionConfig);
+}
+function saveRevokeProgress(config, progress) {
+  const next = { ...tryLoadSessionConfig() ?? config };
+  if (progress.orphans.length > 0) next.orphanedPermissions = progress.orphans;
+  else delete next.orphanedPermissions;
+  if (progress.ownPermissionRevoked) next.permissionRevoked = true;
+  writeSessionConfig(next);
 }
 function loadSessionConfig() {
-  if (!fs.existsSync(PATHS.sessionConfig)) {
+  if (!fs5.existsSync(PATHS.sessionConfig)) {
     throw new Error("No session configured. Run `jaw session setup` first.");
   }
-  const raw = fs.readFileSync(PATHS.sessionConfig, "utf-8");
+  const raw = fs5.readFileSync(PATHS.sessionConfig, "utf-8");
   try {
     return JSON.parse(raw);
   } catch {
     throw new Error(`Session config at ${PATHS.sessionConfig} is corrupted. Run \`jaw session setup\` to recreate it.`);
   }
 }
+function tryLoadSessionConfig() {
+  try {
+    return loadSessionConfig();
+  } catch {
+    return null;
+  }
+}
 function deleteSessionConfig() {
-  if (fs.existsSync(PATHS.sessionConfig)) {
-    fs.unlinkSync(PATHS.sessionConfig);
+  if (fs5.existsSync(PATHS.sessionConfig)) {
+    fs5.unlinkSync(PATHS.sessionConfig);
   }
 }
 
+// src/lib/terminal.ts
+var INVISIBLE_AND_BIDI = /[\u200B-\u200F\u2028\u2029\u202A-\u202E\u2066-\u2069\uFEFF]/g;
+var LINE_CONTROLS = /[\u0000-\u001F\u007F-\u009F]/g;
+var REPLACEMENT = "\uFFFD";
+var DEFAULT_LINE_LENGTH = 200;
+function bound(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}\u2026 (${text.length - maxLength} more characters)`;
+}
+function sanitizeLine(value, maxLength = DEFAULT_LINE_LENGTH) {
+  const text = typeof value === "string" ? value : String(value);
+  return bound(text.replace(LINE_CONTROLS, REPLACEMENT).replace(INVISIBLE_AND_BIDI, REPLACEMENT), maxLength);
+}
+
 // src/commands/session/revoke.ts
 var SessionRevoke = class _SessionRevoke extends BaseCommand {
   static description = "Revoke on-chain permission and delete local session key.";
   static flags = {
-    ...BaseCommand.baseFlags
+    ...BaseCommand.baseFlags,
+    force: Flags.boolean({
+      description: "Delete the local session even if some permissions could not be revoked. They stay live on chain until they expire, and their ids are printed because deleting the session is what loses them.",
+      default: false
+    })
   };
   async run() {
     const { flags } = await this.parse(_SessionRevoke);
@@ -683,12 +752,20 @@ var SessionRevoke = class _SessionRevoke extends BaseCommand {
       return;
     }
     const sessionConfig = loadSessionConfig();
-    const isExpired = sessionConfig.expiry <= Date.now() / 1e3;
-    if (isExpired) {
+    const now = Date.now() / 1e3;
+    const orphans = liveOrphans(sessionConfig.orphanedPermissions, now);
+    const own = (
+      // `permissionRevoked` is set by an earlier run that got this far and then
+      // failed on something else. Revoking is not idempotent, so attempting it
+      // again spends a browser round trip that can only fail.
+      !sessionConfig.permissionRevoked && sessionConfig.expiry > now ? { id: sessionConfig.permissionId, chainId: sessionConfig.chainId, expiry: sessionConfig.expiry } : null
+    );
+    const total = orphans.length + (own ? 1 : 0);
+    if (total === 0) {
       deleteKeystore();
       deleteSessionConfig();
       if (format === "json") {
-        this.outputResult({ revoked: true, skippedOnChain: true }, format);
+        this.outputResult({ revoked: true, skippedOnChain: true, revokedIds: [], failed: [] }, format);
       } else {
         this.log("Session already expired. Cleaned up local files.");
       }
@@ -696,31 +773,81 @@ var SessionRevoke = class _SessionRevoke extends BaseCommand {
     }
     const config = loadConfig();
     const apiKey = this.resolveApiKey(flags);
-    const pm = config.paymasters?.[sessionConfig.chainId];
-    if (!flags.quiet) {
-      this.log("Opening browser to revoke permission...");
+    if (!flags.quiet && format !== "json") {
+      this.log(
+        total === 1 ? "Opening browser to revoke permission..." : `Opening browser to revoke ${total} permissions...`
+      );
     }
-    const bridge = await getBridge({
-      keysUrl: config.keysUrl,
-      apiKey,
-      chainId: sessionConfig.chainId,
-      ens: config.ens,
-      paymasterUrl: pm?.url
-    });
-    try {
-      await bridge.request("wallet_revokePermissions", [{ id: sessionConfig.permissionId }]);
-    } finally {
-      bridge.close();
+    const revokedIds = [];
+    const failed = [];
+    let remaining = orphans;
+    let ownRevoked = false;
+    const revokeOn = async (chainId, targets) => {
+      let bridge;
+      try {
+        bridge = await getBridge({ keysUrl: config.keysUrl, apiKey, chainId, ens: config.ens });
+      } catch (err) {
+        for (const target of targets) failed.push({ id: target.id, reason: describe(err) });
+        return;
+      }
+      try {
+        for (const target of targets) {
+          try {
+            await bridge.request("wallet_revokePermissions", [{ id: target.id }]);
+            revokedIds.push(target.id);
+            if (target === own) ownRevoked = true;
+            else remaining = remaining.filter((orphan) => orphan.id !== target.id);
+            saveRevokeProgress(sessionConfig, { orphans: remaining, ownPermissionRevoked: ownRevoked });
+          } catch (err) {
+            failed.push({ id: target.id, reason: describe(err) });
+          }
+        }
+      } finally {
+        bridge.close();
+      }
+    };
+    for (const chainId of [...new Set(orphans.map((orphan) => orphan.chainId))]) {
+      await revokeOn(
+        chainId,
+        orphans.filter((orphan) => orphan.chainId === chainId)
+      );
+    }
+    if (own) await revokeOn(own.chainId, [own]);
+    const cleanedUp = failed.length === 0 || flags.force;
+    if (cleanedUp) {
+      deleteKeystore();
+      deleteSessionConfig();
     }
-    deleteKeystore();
-    deleteSessionConfig();
     if (format === "json") {
-      this.outputResult({ revoked: true, skippedOnChain: false }, format);
-    } else {
+      this.outputResult(
+        { revoked: failed.length === 0, skippedOnChain: false, revokedIds, failed, localSessionDeleted: cleanedUp },
+        format
+      );
+    } else if (failed.length === 0) {
       this.log("Session revoked. On-chain permission removed and local keys deleted.");
+      if (revokedIds.length > 1) {
+        this.log(`Revoked ${revokedIds.length} permissions this key was holding.`);
+      }
+    } else {
+      if (revokedIds.length > 0) this.log(`Revoked ${revokedIds.length} of ${total} permissions.`);
+      for (const failure of failed) {
+        this.log(`  could not revoke ${failure.id}: ${failure.reason}`);
+      }
+      this.log(
+        flags.force ? "\nLocal session deleted anyway, as asked. Those permissions stay live until they expire, and the ids above are the only record left of them." : "\nLocal session files were kept so the rest can be retried. Run this again, or pass --force to delete the local session anyway if one of these was already revoked elsewhere."
+      );
+    }
+    if (failed.length > 0 && !flags.force) {
+      this.error(
+        `${failed.length} of ${total} permissions could not be revoked. One already revoked elsewhere will keep failing, since the record it is read from is gone.`,
+        { exit: 1 }
+      );
     }
   }
 };
+function describe(err) {
+  return sanitizeLine(err instanceof Error ? err.message : String(err), 200);
+}
 
 export { SessionRevoke as default };
 //# sourceMappingURL=revoke.js.map