@fiber-pay/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -2,166 +2,13 @@
 
 // src/index.ts
 import { join as join11 } from "path";
-import { Command as Command14 } from "commander";
+import { Command as Command16 } from "commander";
 
-// src/commands/binary.ts
-import { DEFAULT_FIBER_VERSION, downloadFiberBinary } from "@fiber-pay/node";
+// src/commands/agent.ts
 import { Command } from "commander";
 
-// src/lib/binary-path.ts
-import { dirname, join } from "path";
-import { BinaryManager, getFiberBinaryInfo } from "@fiber-pay/node";
-
-// src/lib/node-runtime-daemon.ts
-import { spawnSync } from "child_process";
-import { existsSync } from "fs";
-function getCustomBinaryState(binaryPath) {
-  const exists = existsSync(binaryPath);
-  if (!exists) {
-    return { path: binaryPath, ready: false, version: "unknown" };
-  }
-  try {
-    const result = spawnSync(binaryPath, ["--version"], { encoding: "utf-8" });
-    if (result.status !== 0) {
-      return { path: binaryPath, ready: false, version: "unknown" };
-    }
-    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-    const firstLine = output.split("\n").find((line) => line.trim().length > 0) ?? "unknown";
-    return { path: binaryPath, ready: true, version: firstLine.trim() };
-  } catch {
-    return { path: binaryPath, ready: false, version: "unknown" };
-  }
-}
-function getBinaryVersion(binaryPath) {
-  try {
-    const result = spawnSync(binaryPath, ["--version"], { encoding: "utf-8" });
-    if (result.status !== 0) {
-      return "unknown";
-    }
-    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-    if (!output) {
-      return "unknown";
-    }
-    const firstLine = output.split("\n").find((line) => line.trim().length > 0);
-    return firstLine?.trim() ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function getCliEntrypoint() {
-  const entrypoint = process.argv[1];
-  if (!entrypoint) {
-    throw new Error("Unable to resolve CLI entrypoint path");
-  }
-  return entrypoint;
-}
-function startRuntimeDaemonFromNode(params) {
-  const cliEntrypoint = getCliEntrypoint();
-  const result = spawnSync(
-    process.execPath,
-    [
-      cliEntrypoint,
-      "--data-dir",
-      params.dataDir,
-      "--rpc-url",
-      params.rpcUrl,
-      "runtime",
-      "start",
-      "--daemon",
-      "--fiber-rpc-url",
-      params.rpcUrl,
-      "--proxy-listen",
-      params.proxyListen,
-      "--state-file",
-      params.stateFilePath,
-      "--alert-logs-base-dir",
-      params.alertLogsBaseDir,
-      "--json"
-    ],
-    { encoding: "utf-8" }
-  );
-  if (result.status === 0) {
-    return { ok: true };
-  }
-  const stderr = (result.stderr ?? "").trim();
-  const stdout = (result.stdout ?? "").trim();
-  const details = stderr || stdout || `exit code ${result.status ?? "unknown"}`;
-  return { ok: false, message: details };
-}
-function stopRuntimeDaemonFromNode(params) {
-  const cliEntrypoint = getCliEntrypoint();
-  spawnSync(
-    process.execPath,
-    [
-      cliEntrypoint,
-      "--data-dir",
-      params.dataDir,
-      "--rpc-url",
-      params.rpcUrl,
-      "runtime",
-      "stop",
-      "--json"
-    ],
-    { encoding: "utf-8" }
-  );
-}
-
-// src/lib/binary-path.ts
-function getProfileBinaryInstallDir(dataDir) {
-  return join(dataDir, "bin");
-}
-function getProfileManagedBinaryPath(dataDir) {
-  return new BinaryManager(getProfileBinaryInstallDir(dataDir)).getBinaryPath();
-}
-function validateConfiguredBinaryPath(binaryPath) {
-  const value = binaryPath.trim();
-  if (!value) {
-    throw new Error("Configured binaryPath cannot be empty");
-  }
-  if (value.includes("\0")) {
-    throw new Error("Configured binaryPath contains an invalid null byte");
-  }
-  return value;
-}
-function resolveBinaryPath(config) {
-  const managedPath = getProfileManagedBinaryPath(config.dataDir);
-  if (config.binaryPath) {
-    const binaryPath2 = validateConfiguredBinaryPath(config.binaryPath);
-    const installDir2 = dirname(binaryPath2);
-    const expectedPath = new BinaryManager(installDir2).getBinaryPath();
-    const managedByBinaryManager = expectedPath === binaryPath2;
-    const source = binaryPath2 === managedPath ? "profile-managed" : "configured-path";
-    return {
-      binaryPath: binaryPath2,
-      installDir: managedByBinaryManager ? installDir2 : null,
-      managedPath,
-      managedByBinaryManager,
-      source
-    };
-  }
-  const installDir = getProfileBinaryInstallDir(config.dataDir);
-  const binaryPath = managedPath;
-  return {
-    binaryPath,
-    installDir,
-    managedPath,
-    managedByBinaryManager: true,
-    source: "profile-managed"
-  };
-}
-function getBinaryManagerInstallDirOrThrow(resolvedBinary) {
-  if (resolvedBinary.installDir) {
-    return resolvedBinary.installDir;
-  }
-  throw new Error(
-    `Configured binaryPath "${resolvedBinary.binaryPath}" is incompatible with BinaryManager-managed path naming. BinaryManager expects "${new BinaryManager(dirname(resolvedBinary.binaryPath)).getBinaryPath()}". Set binaryPath to a standard managed name (fnn/fnn.exe) in the target directory, or unset binaryPath to use the profile-managed binary.`
-  );
-}
-async function getBinaryDetails(config) {
-  const resolvedBinary = resolveBinaryPath(config);
-  const info = resolvedBinary.installDir ? await getFiberBinaryInfo(resolvedBinary.installDir) : getCustomBinaryState(resolvedBinary.binaryPath);
-  return { resolvedBinary, info };
-}
+// src/lib/agent-call.ts
+import { readFileSync as readFileSync3 } from "fs";
 
 // src/lib/format.ts
 import {
@@ -300,8 +147,8 @@ function formatChannel(channel) {
   return {
     channelId: channel.channel_id,
     channelIdShort: truncateMiddle(channel.channel_id, 10, 8),
-    peerId: channel.peer_id,
-    peerIdShort: truncateMiddle(channel.peer_id, 10, 8),
+    peerId: channel.pubkey,
+    peerIdShort: truncateMiddle(channel.pubkey, 10, 8),
     state: channel.state.state_name,
     stateLabel: stateLabel(channel.state.state_name),
     stateFlags: channel.state.state_flags,
@@ -338,10 +185,10 @@ function extractInvoiceMetadata(invoice) {
   let description;
   let expirySeconds;
   for (const attr of invoice.data.attrs) {
-    if ("Description" in attr) description = attr.Description;
-    if ("ExpiryTime" in attr) {
+    if ("description" in attr) description = attr.description;
+    if ("expiry_time" in attr) {
       try {
-        expirySeconds = Number(BigInt(attr.ExpiryTime));
+        expirySeconds = Number(BigInt(attr.expiry_time));
       } catch {
       }
     }
@@ -388,7 +235,7 @@ function printChannelDetailHuman(channel) {
   const capacity = local + remote;
   console.log("Channel");
   console.log(`  ID:            ${channel.channel_id}`);
-  console.log(`  Peer:          ${channel.peer_id}`);
+  console.log(`  Peer:          ${channel.pubkey}`);
   console.log(
     `  State:         ${stateLabel(channel.state.state_name)} (${channel.state.state_name})`
   );
@@ -461,7 +308,7 @@ function printChannelListHuman(channels) {
   );
   for (const channel of channels) {
     const id = truncateMiddle(channel.channel_id, 10, 8).padEnd(22, " ");
-    const peer = truncateMiddle(channel.peer_id, 10, 8).padEnd(22, " ");
+    const peer = truncateMiddle(channel.pubkey, 10, 8).padEnd(22, " ");
     const state = channel.state.state_name.padEnd(24, " ");
     const local = `${shannonsToCkb(channel.local_balance)}`.padStart(8, " ");
     const remote = `${shannonsToCkb(channel.remote_balance)}`.padStart(8, " ");
@@ -476,13 +323,845 @@ function printPeerListHuman(peers) {
   }
   console.log(`Peers: ${peers.length}`);
   console.log("");
-  console.log("PEER ID                 PUBKEY                  ADDRESS");
-  console.log("--------------------------------------------------------------------------");
+  console.log("PUBKEY                  ADDRESS");
+  console.log("----------------------------------------------------------");
   for (const peer of peers) {
-    const peerId = truncateMiddle(peer.peer_id, 10, 8).padEnd(22, " ");
     const pubkey = truncateMiddle(peer.pubkey, 10, 8).padEnd(22, " ");
-    console.log(`${peerId} ${pubkey} ${peer.address}`);
+    console.log(`${pubkey} ${peer.address}`);
+  }
+}
+
+// src/lib/rpc.ts
+import { FiberRpcClient } from "@fiber-pay/sdk";
+
+// src/lib/pid.ts
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+function getPidFilePath(dataDir) {
+  return join(dataDir, "fiber.pid");
+}
+function writePidFile(dataDir, pid) {
+  writeFileSync(getPidFilePath(dataDir), String(pid));
+}
+function readPidFile(dataDir) {
+  const pidPath = getPidFilePath(dataDir);
+  if (!existsSync(pidPath)) return null;
+  try {
+    return parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+  } catch {
+    return null;
+  }
+}
+function removePidFile(dataDir) {
+  const pidPath = getPidFilePath(dataDir);
+  if (existsSync(pidPath)) {
+    unlinkSync(pidPath);
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/runtime-meta.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function getRuntimePidFilePath(dataDir) {
+  return join2(dataDir, "runtime.pid");
+}
+function getRuntimeMetaFilePath(dataDir) {
+  return join2(dataDir, "runtime.meta.json");
+}
+function writeRuntimePid(dataDir, pid) {
+  writeFileSync2(getRuntimePidFilePath(dataDir), String(pid));
+}
+function readRuntimePid(dataDir) {
+  const pidPath = getRuntimePidFilePath(dataDir);
+  if (!existsSync2(pidPath)) return null;
+  try {
+    return Number.parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+  } catch {
+    return null;
+  }
+}
+function writeRuntimeMeta(dataDir, meta) {
+  writeFileSync2(getRuntimeMetaFilePath(dataDir), JSON.stringify(meta, null, 2));
+}
+function readRuntimeMeta(dataDir) {
+  const metaPath = getRuntimeMetaFilePath(dataDir);
+  if (!existsSync2(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync2(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function removeRuntimeFiles(dataDir) {
+  const pidPath = getRuntimePidFilePath(dataDir);
+  const metaPath = getRuntimeMetaFilePath(dataDir);
+  if (existsSync2(pidPath)) {
+    unlinkSync2(pidPath);
+  }
+  if (existsSync2(metaPath)) {
+    unlinkSync2(metaPath);
+  }
+}
+
+// src/lib/rpc.ts
+function normalizeUrl(url) {
+  try {
+    const normalized = new URL(url).toString();
+    return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+  } catch {
+    return url.endsWith("/") ? url.slice(0, -1) : url;
+  }
+}
+function resolveRuntimeProxyUrl(config) {
+  const runtimeMeta = readRuntimeMeta(config.dataDir);
+  const runtimePid = readRuntimePid(config.dataDir);
+  if (!runtimeMeta || !runtimePid || !isProcessRunning(runtimePid)) {
+    return void 0;
+  }
+  if (!runtimeMeta.proxyListen || !runtimeMeta.fiberRpcUrl) {
+    return void 0;
+  }
+  if (normalizeUrl(runtimeMeta.fiberRpcUrl) !== normalizeUrl(config.rpcUrl)) {
+    return void 0;
+  }
+  if (runtimeMeta.proxyListen.startsWith("http://") || runtimeMeta.proxyListen.startsWith("https://")) {
+    return runtimeMeta.proxyListen;
+  }
+  return `http://${runtimeMeta.proxyListen}`;
+}
+function createRpcClient(config) {
+  const resolved = resolveRpcEndpoint(config);
+  return new FiberRpcClient({
+    url: resolved.url,
+    biscuitToken: config.rpcBiscuitToken
+  });
+}
+function resolveRpcEndpoint(config) {
+  const runtimeProxyUrl = resolveRuntimeProxyUrl(config);
+  if (runtimeProxyUrl) {
+    return {
+      url: runtimeProxyUrl,
+      target: "runtime-proxy"
+    };
+  }
+  return {
+    url: config.rpcUrl,
+    target: "node-rpc"
+  };
+}
+async function createReadyRpcClient(config, options = {}) {
+  const rpc = createRpcClient(config);
+  await rpc.waitForReady({ timeout: options.timeout ?? 3e3, interval: options.interval ?? 500 });
+  return rpc;
+}
+
+// src/lib/agent-call.ts
+function formatDuration(durationMs) {
+  if (typeof durationMs !== "number" || Number.isNaN(durationMs)) {
+    return "unknown";
+  }
+  return `${durationMs}ms`;
+}
+function printFriendlySuccess(result, options) {
+  const agent = typeof result.agent === "string" ? result.agent : "unknown";
+  const duration = formatDuration(result.durationMs);
+  const response = typeof result.response === "string" ? result.response : JSON.stringify(result.response, null, 2);
+  console.log("Agent call succeeded");
+  console.log(`  Agent:         ${agent}`);
+  console.log(`  Duration:      ${duration}`);
+  console.log(`  Payment:       ${options.paymentRequired ? "required" : "not required"}`);
+  if (options.paymentHash) {
+    console.log(`  Payment hash:  ${options.paymentHash}`);
+  }
+  console.log("");
+  console.log("Agent response:");
+  console.log(response ?? "");
+}
+async function runAgentCallCommand(config, url, options) {
+  const asJson = Boolean(options.json);
+  const timeoutMs = parseInt(options.timeout, 10) * 1e3;
+  let prompt = options.prompt;
+  if (!prompt && options.file) {
+    try {
+      prompt = readFileSync3(options.file, "utf-8").trim();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (asJson) {
+        printJsonError({
+          code: "AGENT_CALL_FILE_READ_ERROR",
+          message: `Failed to read prompt file: ${message}`,
+          recoverable: true,
+          suggestion: "Check the file path and try again."
+        });
+      } else {
+        console.error(`Error: Failed to read prompt file: ${message}`);
+      }
+      process.exit(1);
+    }
+  }
+  if (!prompt) {
+    if (!process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      prompt = Buffer.concat(chunks).toString("utf-8").trim();
+    }
+  }
+  if (!prompt) {
+    if (asJson) {
+      printJsonError({
+        code: "AGENT_CALL_NO_PROMPT",
+        message: "No prompt provided.",
+        recoverable: true,
+        suggestion: "Use --prompt <text>, --file <path>, or pipe via stdin."
+      });
+    } else {
+      console.error("Error: No prompt provided.");
+      console.error("  Use --prompt <text>, --file <path>, or pipe via stdin.");
+    }
+    process.exit(1);
+  }
+  const targetUrl = url.endsWith("/") ? url : `${url}/`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    if (!asJson) {
+      console.log(`Calling agent at ${targetUrl}...`);
+    }
+    const initialResponse = await fetch(targetUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt }),
+      signal: controller.signal
+    });
+    if (initialResponse.ok) {
+      const body = await initialResponse.json();
+      clearTimeout(timer);
+      if (asJson) {
+        printJsonSuccess(body);
+      } else {
+        printFriendlySuccess(body, { paymentRequired: false });
+      }
+      return;
+    }
+    if (initialResponse.status !== 402 && initialResponse.status !== 401) {
+      const body = await initialResponse.text();
+      clearTimeout(timer);
+      if (asJson) {
+        printJsonError({
+          code: "AGENT_CALL_UNEXPECTED_STATUS",
+          message: `Unexpected status ${initialResponse.status} from agent.`,
+          recoverable: false,
+          details: { body: body.slice(0, 500) }
+        });
+      } else {
+        console.error(`Error: Unexpected status ${initialResponse.status}`);
+        console.error(body.slice(0, 500));
+      }
+      process.exit(1);
+    }
+    const challengeBody = await initialResponse.json();
+    const macaroon = challengeBody.macaroon;
+    const invoiceAddress = challengeBody.invoice;
+    if (!macaroon || !invoiceAddress) {
+      clearTimeout(timer);
+      if (asJson) {
+        printJsonError({
+          code: "AGENT_CALL_INVALID_CHALLENGE",
+          message: "Invalid L402 challenge: missing macaroon or invoice.",
+          recoverable: false
+        });
+      } else {
+        console.error("Error: Invalid L402 challenge response (missing macaroon or invoice).");
+      }
+      process.exit(1);
+    }
+    if (!asJson) {
+      console.log("Payment required. Paying invoice via Fiber...");
+    }
+    const rpcClient = await createReadyRpcClient(config);
+    const paymentResult = await rpcClient.sendPayment({
+      invoice: invoiceAddress
+    });
+    if (!asJson) {
+      console.log(
+        `Payment sent (hash: ${paymentResult.payment_hash}). Waiting for confirmation...`
+      );
+    }
+    const finalPayment = await rpcClient.waitForPayment(paymentResult.payment_hash, {
+      timeout: timeoutMs,
+      interval: 2e3
+    });
+    if (finalPayment.status !== "Success") {
+      clearTimeout(timer);
+      if (asJson) {
+        printJsonError({
+          code: "AGENT_CALL_PAYMENT_FAILED",
+          message: `Payment failed: ${finalPayment.failed_error ?? finalPayment.status}`,
+          recoverable: false
+        });
+      } else {
+        console.error(`Error: Payment failed: ${finalPayment.failed_error ?? finalPayment.status}`);
+      }
+      process.exit(1);
+    }
+    if (!asJson) {
+      console.log("Payment confirmed. Retrying request with L402 token...");
+    }
+    const retryResponse = await fetch(targetUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `L402 ${macaroon}`,
+        "X-L402-Payment-Hash": paymentResult.payment_hash
+      },
+      body: JSON.stringify({ prompt }),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!retryResponse.ok) {
+      const errBody = await retryResponse.text();
+      if (asJson) {
+        printJsonError({
+          code: "AGENT_CALL_RETRY_FAILED",
+          message: `Agent returned ${retryResponse.status} after payment.`,
+          recoverable: false,
+          details: { body: errBody.slice(0, 500) }
+        });
+      } else {
+        console.error(`Error: Agent returned ${retryResponse.status} after payment.`);
+        console.error(errBody.slice(0, 500));
+      }
+      process.exit(1);
+    }
+    const result = await retryResponse.json();
+    if (asJson) {
+      printJsonSuccess({
+        ...result,
+        paymentHash: paymentResult.payment_hash
+      });
+    } else {
+      printFriendlySuccess(result, {
+        paymentRequired: true,
+        paymentHash: paymentResult.payment_hash
+      });
+    }
+  } catch (error) {
+    clearTimeout(timer);
+    const message = error instanceof Error ? error.message : String(error);
+    const isTimeout = error instanceof Error && error.name === "AbortError";
+    if (asJson) {
+      printJsonError({
+        code: isTimeout ? "AGENT_CALL_TIMEOUT" : "AGENT_CALL_ERROR",
+        message: isTimeout ? "Request timed out." : message,
+        recoverable: !isTimeout
+      });
+    } else {
+      console.error(`Error: ${isTimeout ? "Request timed out." : message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/lib/agent-serve.ts
+import { execFileSync, spawn } from "child_process";
+import { createServer } from "http";
+import { createL402Middleware, FiberRpcClient as FiberRpcClient2 } from "@fiber-pay/sdk";
+import express from "express";
+function getClientIp(req) {
+  const forwarded = req.headers["x-forwarded-for"];
+  const forwardedValue = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+  if (typeof forwardedValue === "string" && forwardedValue.trim().length > 0) {
+    return forwardedValue.split(",")[0]?.trim() || "unknown";
+  }
+  return req.ip || req.socket.remoteAddress || "unknown";
+}
+function summarizeL402Status(req) {
+  if (req.l402?.valid) {
+    if (req.l402.paymentHash) {
+      return `payment-verified:${req.l402.paymentHash.slice(0, 14)}...`;
+    }
+    if (req.l402.preimage) {
+      return "payment-verified:preimage";
+    }
+    return "payment-verified";
+  }
+  return "no-l402-token";
+}
+function getRequestId(req) {
+  return req._fiberPayRequestId ?? 0;
+}
+function runAcpx(agent, prompt, options) {
+  return new Promise((resolve2) => {
+    const args = ["--format", "quiet"];
+    if (options.approveAll) {
+      args.push("--approve-all");
+    }
+    if (options.cwd) {
+      args.push("--cwd", options.cwd);
+    }
+    if (options.timeoutSeconds > 0) {
+      args.push("--timeout", String(options.timeoutSeconds));
+    }
+    args.push(agent, "exec", prompt);
+    const child = spawn("acpx", args, {
+      cwd: options.cwd || process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const killTimer = setTimeout(
+      () => {
+        child.kill("SIGKILL");
+      },
+      (options.timeoutSeconds + 30) * 1e3
+    );
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      resolve2({ stdout, stderr, exitCode: code ?? 1 });
+    });
+    child.on("error", (err) => {
+      clearTimeout(killTimer);
+      resolve2({ stdout: "", stderr: err.message, exitCode: 1 });
+    });
+  });
+}
+async function runAgentServeCommand(config, options) {
+  const asJson = Boolean(options.json);
+  const port = parseInt(options.port, 10);
+  const host = options.host;
+  const priceCkb = parseFloat(options.price);
+  const expirySeconds = parseInt(options.expiry, 10);
+  const timeoutSeconds = parseInt(options.timeout, 10);
+  const rootKey = options.rootKey || process.env.L402_ROOT_KEY;
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    if (asJson) {
+      printJsonError({
+        code: "AGENT_SERVE_INVALID_PORT",
+        message: `Invalid port: ${options.port}`,
+        recoverable: true,
+        suggestion: "Provide a valid port number between 1 and 65535."
+      });
+    } else {
+      console.error(`Error: Invalid port: ${options.port}`);
+    }
+    process.exit(1);
+  }
+  if (Number.isNaN(priceCkb) || priceCkb <= 0) {
+    if (asJson) {
+      printJsonError({
+        code: "AGENT_SERVE_INVALID_PRICE",
+        message: `Invalid price: ${options.price}`,
+        recoverable: true,
+        suggestion: "Provide a positive CKB amount, e.g. --price 0.1"
+      });
+    } else {
+      console.error(`Error: Invalid price: ${options.price}`);
+    }
+    process.exit(1);
+  }
+  if (!rootKey) {
+    if (asJson) {
+      printJsonError({
+        code: "AGENT_SERVE_MISSING_ROOT_KEY",
+        message: "L402 root key is required.",
+        recoverable: true,
+        suggestion: "Provide --root-key <64-hex-chars> or set L402_ROOT_KEY env var. Generate with: openssl rand -hex 32"
+      });
+    } else {
+      console.error("Error: L402 root key is required.");
+      console.error("  Provide --root-key <64-hex-chars> or set L402_ROOT_KEY env var.");
+      console.error("  Generate one with: openssl rand -hex 32");
+    }
+    process.exit(1);
+  }
+  try {
+    execFileSync("acpx", ["--version"], { stdio: "ignore" });
+  } catch {
+    if (asJson) {
+      printJsonError({
+        code: "AGENT_SERVE_ACPX_NOT_FOUND",
+        message: "acpx is not installed or not in PATH.",
+        recoverable: true,
+        suggestion: "Install acpx globally: npm install -g acpx"
+      });
+    } else {
+      console.error("Error: acpx is not installed or not in PATH.");
+      console.error("  Install it with: npm install -g acpx");
+      console.error("  See: https://github.com/openclaw/acpx");
+    }
+    process.exit(1);
+  }
+  const rpcClient = new FiberRpcClient2({
+    url: config.rpcUrl,
+    biscuitToken: config.rpcBiscuitToken
+  });
+  const currency = config.network === "mainnet" ? "Fibb" : "Fibt";
+  const app = express();
+  app.use(express.json());
+  let requestCounter = 0;
+  app.use((req, res, next) => {
+    const requestId = ++requestCounter;
+    req._fiberPayRequestId = requestId;
+    const startTime = Date.now();
+    const clientIp = getClientIp(req);
+    if (!asJson) {
+      console.log(
+        `[REQ ${requestId}] ${req.method} ${req.path} from ${clientIp} (auth=${req.headers.authorization ? "present" : "none"})`
+      );
+    }
+    res.on("finish", () => {
+      if (asJson) {
+        return;
+      }
+      const durationMs = Date.now() - startTime;
+      const l402State = summarizeL402Status(req);
+      if (res.statusCode === 402 || res.statusCode === 401) {
+        console.log(
+          `[REQ ${requestId}] challenge-issued status=${res.statusCode} duration=${durationMs}ms`
+        );
+        return;
+      }
+      console.log(
+        `[REQ ${requestId}] completed status=${res.statusCode} duration=${durationMs}ms l402=${l402State}`
+      );
+    });
+    next();
+  });
+  app.use(
+    createL402Middleware({
+      rootKey,
+      priceCkb,
+      expirySeconds,
+      rpcClient,
+      currency
+    })
+  );
+  app.post("/", async (req, res) => {
+    const requestId = getRequestId(req);
+    const prompt = req.body?.prompt;
+    if (!prompt || typeof prompt !== "string") {
+      if (!asJson) {
+        console.log(`[REQ ${requestId}] invalid request body: missing string prompt`);
+      }
+      res.status(400).json({
+        error: 'Missing or invalid "prompt" field in request body.'
+      });
+      return;
+    }
+    const startTime = Date.now();
+    try {
+      if (!asJson) {
+        console.log(
+          `[REQ ${requestId}] payment accepted, invoking agent=${options.agent} promptChars=${prompt.length}`
+        );
+      }
+      const result = await runAcpx(options.agent, prompt, {
+        cwd: options.cwd,
+        approveAll: options.approveAll,
+        timeoutSeconds
+      });
+      const durationMs = Date.now() - startTime;
+      if (result.exitCode !== 0) {
+        if (!asJson) {
+          console.log(
+            `[REQ ${requestId}] agent failed exit=${result.exitCode} duration=${durationMs}ms`
+          );
+        }
+        res.status(502).json({
+          error: "Agent execution failed.",
+          agent: options.agent,
+          stderr: result.stderr.slice(0, 1e3),
+          durationMs
+        });
+        return;
+      }
+      if (!asJson) {
+        console.log(`[REQ ${requestId}] agent completed duration=${durationMs}ms`);
+      }
+      res.json({
+        response: result.stdout.trim(),
+        agent: options.agent,
+        durationMs
+      });
+    } catch (error) {
+      if (!asJson) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(`[REQ ${requestId}] agent execution error: ${message}`);
+      }
+      res.status(500).json({
+        error: "Internal server error.",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", agent: options.agent });
+  });
+  const server = createServer(app);
+  await new Promise((resolve2, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        if (asJson) {
+          printJsonError({
+            code: "AGENT_SERVE_PORT_IN_USE",
+            message: `Port ${port} is already in use.`,
+            recoverable: true,
+            suggestion: "Use a different port with --port <port>."
+          });
+        } else {
+          console.error(`Error: Port ${port} is already in use.`);
+        }
+        process.exit(1);
+      }
+      reject(err);
+    });
+    server.listen(port, host, () => {
+      resolve2();
+    });
+  });
+  const listenUrl = `http://${host}:${port}`;
+  if (asJson) {
+    printJsonSuccess({
+      status: "running",
+      listen: listenUrl,
+      agent: options.agent,
+      priceCkb,
+      expirySeconds,
+      currency,
+      fiberRpcUrl: config.rpcUrl
+    });
+  } else {
+    console.log("Agent service started");
+    console.log(`  Listen:     ${listenUrl}`);
+    console.log(`  Agent:      ${options.agent}`);
+    console.log(`  Price:      ${priceCkb} CKB per request`);
+    console.log(`  Expiry:     ${expirySeconds}s`);
+    console.log(`  Timeout:    ${timeoutSeconds}s per agent call`);
+    console.log(`  Currency:   ${currency}`);
+    console.log(`  Fiber RPC:  ${config.rpcUrl}`);
+    console.log("");
+    console.log("Endpoint:");
+    console.log(`  POST ${listenUrl}/  {"prompt": "your question"}`);
+    console.log("");
+    console.log("Press Ctrl+C to stop.");
+  }
+  const shutdown = () => {
+    if (!asJson) {
+      console.log("\nStopping agent service...");
+    }
+    server.close(() => {
+      if (asJson) {
+        printJsonSuccess({ status: "stopped" });
+      } else {
+        console.log("Agent service stopped.");
+      }
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(0), 5e3);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+
+// src/commands/agent.ts
+function createAgentCommand(config) {
+  const agent = new Command("agent").description("AI agent service with L402 payment");
+  agent.command("serve").description("Start an L402-gated AI agent HTTP service").requiredOption(
+    "--agent <name>",
+    "Agent to use (common values: codex, claude, opencode, gemini, pi; see acpx docs for full list)"
+  ).option("--port <port>", "Listen port", "8402").option("--host <host>", "Listen host", "127.0.0.1").option("--price <ckb>", "Price per request in CKB", "0.1").option("--root-key <hex>", "Macaroon root key (32-byte hex, or set L402_ROOT_KEY env)").option("--expiry <seconds>", "Token expiry in seconds", "3600").option("--cwd <path>", "Working directory for agent execution").option("--approve-all", "Auto-approve all agent tool calls").option("--timeout <seconds>", "Max agent execution time per request", "300").option("--json").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  fiber-pay agent serve --agent codex --price 0.1 --root-key <hex>",
+      "  fiber-pay agent serve --agent claude --price 0.2 --port 8402"
+    ].join("\n")
+  ).action(async (options) => {
+    await runAgentServeCommand(config, options);
+  });
+  agent.command("call").description("Call a remote L402-gated agent service (auto-pay via Fiber)").argument("<url>", "Agent service URL (e.g. http://host:8402)").option("--prompt <text>", "Prompt text to send").option("--file <path>", "Read prompt from file").option("--timeout <seconds>", "Request timeout in seconds", "300").option("--json").action(async (url, options) => {
+    await runAgentCallCommand(config, url, options);
+  });
+  return agent;
+}
+
+// src/commands/binary.ts
+import { DEFAULT_FIBER_VERSION, downloadFiberBinary } from "@fiber-pay/node";
+import { Command as Command2 } from "commander";
+
+// src/lib/binary-path.ts
+import { dirname, join as join3 } from "path";
+import { BinaryManager, getFiberBinaryInfo } from "@fiber-pay/node";
+
+// src/lib/node-runtime-daemon.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+function getCustomBinaryState(binaryPath) {
+  const exists = existsSync3(binaryPath);
+  if (!exists) {
+    return { path: binaryPath, ready: false, version: "unknown" };
+  }
+  try {
+    const result = spawnSync(binaryPath, ["--version"], { encoding: "utf-8" });
+    if (result.status !== 0) {
+      return { path: binaryPath, ready: false, version: "unknown" };
+    }
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    const firstLine = output.split("\n").find((line) => line.trim().length > 0) ?? "unknown";
+    return { path: binaryPath, ready: true, version: firstLine.trim() };
+  } catch {
+    return { path: binaryPath, ready: false, version: "unknown" };
+  }
+}
+function getBinaryVersion(binaryPath) {
+  try {
+    const result = spawnSync(binaryPath, ["--version"], { encoding: "utf-8" });
+    if (result.status !== 0) {
+      return "unknown";
+    }
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    if (!output) {
+      return "unknown";
+    }
+    const firstLine = output.split("\n").find((line) => line.trim().length > 0);
+    return firstLine?.trim() ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getCliEntrypoint() {
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    throw new Error("Unable to resolve CLI entrypoint path");
+  }
+  return entrypoint;
+}
+function startRuntimeDaemonFromNode(params) {
+  const cliEntrypoint = getCliEntrypoint();
+  const result = spawnSync(
+    process.execPath,
+    [
+      cliEntrypoint,
+      "--data-dir",
+      params.dataDir,
+      "--rpc-url",
+      params.rpcUrl,
+      "runtime",
+      "start",
+      "--daemon",
+      "--fiber-rpc-url",
+      params.rpcUrl,
+      "--proxy-listen",
+      params.proxyListen,
+      "--state-file",
+      params.stateFilePath,
+      "--alert-logs-base-dir",
+      params.alertLogsBaseDir,
+      "--json"
+    ],
+    { encoding: "utf-8" }
+  );
+  if (result.status === 0) {
+    return { ok: true };
+  }
+  const stderr = (result.stderr ?? "").trim();
+  const stdout = (result.stdout ?? "").trim();
+  const details = stderr || stdout || `exit code ${result.status ?? "unknown"}`;
+  return { ok: false, message: details };
+}
+function stopRuntimeDaemonFromNode(params) {
+  const cliEntrypoint = getCliEntrypoint();
+  spawnSync(
+    process.execPath,
+    [
+      cliEntrypoint,
+      "--data-dir",
+      params.dataDir,
+      "--rpc-url",
+      params.rpcUrl,
+      "runtime",
+      "stop",
+      "--json"
+    ],
+    { encoding: "utf-8" }
+  );
+}
+
+// src/lib/binary-path.ts
+function getProfileBinaryInstallDir(dataDir) {
+  return join3(dataDir, "bin");
+}
+function getProfileManagedBinaryPath(dataDir) {
+  return new BinaryManager(getProfileBinaryInstallDir(dataDir)).getBinaryPath();
+}
+function validateConfiguredBinaryPath(binaryPath) {
+  const value = binaryPath.trim();
+  if (!value) {
+    throw new Error("Configured binaryPath cannot be empty");
+  }
+  if (value.includes("\0")) {
+    throw new Error("Configured binaryPath contains an invalid null byte");
+  }
+  return value;
+}
+function resolveBinaryPath(config) {
+  const managedPath = getProfileManagedBinaryPath(config.dataDir);
+  if (config.binaryPath) {
+    const binaryPath2 = validateConfiguredBinaryPath(config.binaryPath);
+    const installDir2 = dirname(binaryPath2);
+    const expectedPath = new BinaryManager(installDir2).getBinaryPath();
+    const managedByBinaryManager = expectedPath === binaryPath2;
+    const source = binaryPath2 === managedPath ? "profile-managed" : "configured-path";
+    return {
+      binaryPath: binaryPath2,
+      installDir: managedByBinaryManager ? installDir2 : null,
+      managedPath,
+      managedByBinaryManager,
+      source
+    };
+  }
+  const installDir = getProfileBinaryInstallDir(config.dataDir);
+  const binaryPath = managedPath;
+  return {
+    binaryPath,
+    installDir,
+    managedPath,
+    managedByBinaryManager: true,
+    source: "profile-managed"
+  };
+}
+function getBinaryManagerInstallDirOrThrow(resolvedBinary) {
+  if (resolvedBinary.installDir) {
+    return resolvedBinary.installDir;
   }
+  throw new Error(
+    `Configured binaryPath "${resolvedBinary.binaryPath}" is incompatible with BinaryManager-managed path naming. BinaryManager expects "${new BinaryManager(dirname(resolvedBinary.binaryPath)).getBinaryPath()}". Set binaryPath to a standard managed name (fnn/fnn.exe) in the target directory, or unset binaryPath to use the profile-managed binary.`
+  );
+}
+async function getBinaryDetails(config) {
+  const resolvedBinary = resolveBinaryPath(config);
+  const info = resolvedBinary.installDir ? await getFiberBinaryInfo(resolvedBinary.installDir) : getCustomBinaryState(resolvedBinary.binaryPath);
+  return { resolvedBinary, info };
 }
 
 // src/commands/binary.ts
@@ -494,7 +1173,7 @@ function showProgress(progress) {
   }
 }
 function createBinaryCommand(config) {
-  const binary = new Command("binary").description("Fiber binary management");
+  const binary = new Command2("binary").description("Fiber binary management");
   binary.command("download").option("--version <version>", "Fiber binary version", DEFAULT_FIBER_VERSION).option("--force", "Force re-download").option("--json").action(async (options) => {
     const resolvedBinary = resolveBinaryPath(config);
     let installDir;
@@ -552,146 +1231,14 @@ function createBinaryCommand(config) {
 
 // src/commands/channel.ts
 import { randomUUID } from "crypto";
-import { ckbToShannons as ckbToShannons2 } from "@fiber-pay/sdk";
-import { Command as Command2 } from "commander";
+import { ckbToShannons as ckbToShannons2, nodeIdToPeerId } from "@fiber-pay/sdk";
+import { Command as Command3 } from "commander";
 
 // src/lib/async.ts
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-// src/lib/rpc.ts
-import { FiberRpcClient } from "@fiber-pay/sdk";
-
-// src/lib/pid.ts
-import { existsSync as existsSync2, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
-function getPidFilePath(dataDir) {
-  return join2(dataDir, "fiber.pid");
-}
-function writePidFile(dataDir, pid) {
-  writeFileSync(getPidFilePath(dataDir), String(pid));
-}
-function readPidFile(dataDir) {
-  const pidPath = getPidFilePath(dataDir);
-  if (!existsSync2(pidPath)) return null;
-  try {
-    return parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
-  } catch {
-    return null;
-  }
-}
-function removePidFile(dataDir) {
-  const pidPath = getPidFilePath(dataDir);
-  if (existsSync2(pidPath)) {
-    unlinkSync(pidPath);
-  }
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/lib/runtime-meta.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
-function getRuntimePidFilePath(dataDir) {
-  return join3(dataDir, "runtime.pid");
-}
-function getRuntimeMetaFilePath(dataDir) {
-  return join3(dataDir, "runtime.meta.json");
-}
-function writeRuntimePid(dataDir, pid) {
-  writeFileSync2(getRuntimePidFilePath(dataDir), String(pid));
-}
-function readRuntimePid(dataDir) {
-  const pidPath = getRuntimePidFilePath(dataDir);
-  if (!existsSync3(pidPath)) return null;
-  try {
-    return Number.parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
-  } catch {
-    return null;
-  }
-}
-function writeRuntimeMeta(dataDir, meta) {
-  writeFileSync2(getRuntimeMetaFilePath(dataDir), JSON.stringify(meta, null, 2));
-}
-function readRuntimeMeta(dataDir) {
-  const metaPath = getRuntimeMetaFilePath(dataDir);
-  if (!existsSync3(metaPath)) return null;
-  try {
-    return JSON.parse(readFileSync2(metaPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function removeRuntimeFiles(dataDir) {
-  const pidPath = getRuntimePidFilePath(dataDir);
-  const metaPath = getRuntimeMetaFilePath(dataDir);
-  if (existsSync3(pidPath)) {
-    unlinkSync2(pidPath);
-  }
-  if (existsSync3(metaPath)) {
-    unlinkSync2(metaPath);
-  }
-}
-
-// src/lib/rpc.ts
-function normalizeUrl(url) {
-  try {
-    const normalized = new URL(url).toString();
-    return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-  } catch {
-    return url.endsWith("/") ? url.slice(0, -1) : url;
-  }
-}
-function resolveRuntimeProxyUrl(config) {
-  const runtimeMeta = readRuntimeMeta(config.dataDir);
-  const runtimePid = readRuntimePid(config.dataDir);
-  if (!runtimeMeta || !runtimePid || !isProcessRunning(runtimePid)) {
-    return void 0;
-  }
-  if (!runtimeMeta.proxyListen || !runtimeMeta.fiberRpcUrl) {
-    return void 0;
-  }
-  if (normalizeUrl(runtimeMeta.fiberRpcUrl) !== normalizeUrl(config.rpcUrl)) {
-    return void 0;
-  }
-  if (runtimeMeta.proxyListen.startsWith("http://") || runtimeMeta.proxyListen.startsWith("https://")) {
-    return runtimeMeta.proxyListen;
-  }
-  return `http://${runtimeMeta.proxyListen}`;
-}
-function createRpcClient(config) {
-  const resolved = resolveRpcEndpoint(config);
-  return new FiberRpcClient({
-    url: resolved.url,
-    biscuitToken: config.rpcBiscuitToken
-  });
-}
-function resolveRpcEndpoint(config) {
-  const runtimeProxyUrl = resolveRuntimeProxyUrl(config);
-  if (runtimeProxyUrl) {
-    return {
-      url: runtimeProxyUrl,
-      target: "runtime-proxy"
-    };
-  }
-  return {
-    url: config.rpcUrl,
-    target: "node-rpc"
-  };
-}
-async function createReadyRpcClient(config, options = {}) {
-  const rpc = createRpcClient(config);
-  await rpc.waitForReady({ timeout: options.timeout ?? 3e3, interval: options.interval ?? 500 });
-  return rpc;
-}
-
 // src/lib/runtime-jobs.ts
 async function tryCreateRuntimePaymentJob(runtimeUrl, body) {
   try {
@@ -785,7 +1332,7 @@ async function executeRebalance(config, params) {
     }
     process.exit(1);
   }
-  const selfPubkey = (await rpc.nodeInfo()).node_id;
+  const selfPubkey = (await rpc.nodeInfo()).pubkey;
   const amount = ckbToShannons(amountCkb);
   const isManual = manualHops.length > 0;
   let routeHopCount;
@@ -920,7 +1467,7 @@ function registerChannelRebalanceCommand(parent, config) {
         }
         process.exit(1);
       }
-      if (fromChannel.peer_id === toChannel.peer_id) {
+      if (fromChannel.pubkey === toChannel.pubkey) {
         const message = "Source and target channels point to the same peer; choose two different channel peers.";
         if (json) {
           printJsonError({
@@ -931,7 +1478,7 @@ function registerChannelRebalanceCommand(parent, config) {
             details: {
               fromChannel: fromChannelId,
               toChannel: toChannelId,
-              peerId: fromChannel.peer_id
+              peerId: fromChannel.pubkey
             }
           });
         } else {
@@ -939,24 +1486,21 @@ function registerChannelRebalanceCommand(parent, config) {
         }
         process.exit(1);
       }
-      const peers = (await rpc.listPeers()).peers;
-      const pubkeyByPeerId = new Map(peers.map((peer) => [peer.peer_id, peer.pubkey]));
-      const fromPubkey = pubkeyByPeerId.get(fromChannel.peer_id);
-      const toPubkey = pubkeyByPeerId.get(toChannel.peer_id);
+      const fromPubkey = fromChannel.pubkey;
+      const toPubkey = toChannel.pubkey;
       if (!fromPubkey || !toPubkey) {
-        const message = "Unable to resolve selected channel peer_id to pubkey for guided rebalance route.";
+        const message = "Unable to resolve selected channel pubkey for guided rebalance route.";
         if (json) {
           printJsonError({
             code: "CHANNEL_REBALANCE_INPUT_INVALID",
             message,
             recoverable: true,
-            suggestion: "Ensure both peers are connected (`peer list --json`) and retry guided mode, or use `payment rebalance --hops`.",
+            suggestion: "Ensure channel details are up to date and retry guided mode, or use `payment rebalance --hops`.",
             details: {
               fromChannel: fromChannelId,
               toChannel: toChannelId,
-              fromPeerId: fromChannel.peer_id,
-              toPeerId: toChannel.peer_id,
-              resolvedPeers: peers.length
+              fromPeerId: fromChannel.pubkey,
+              toPeerId: toChannel.pubkey
             }
           });
         } else {
@@ -978,13 +1522,42 @@ function registerChannelRebalanceCommand(parent, config) {
 }
 
 // src/commands/channel.ts
+function extractPeerIdFromMultiaddr(address) {
+  const match = address.match(/\/p2p\/([^/]+)$/);
+  return match?.[1];
+}
+async function resolvePeerPubkeyFromMultiaddr(rpc, address, timeoutMs) {
+  const expectedPeerId = extractPeerIdFromMultiaddr(address);
+  if (!expectedPeerId) {
+    throw new Error("Invalid peer multiaddr: missing /p2p/<peerId> suffix");
+  }
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const peers = await rpc.listPeers();
+    for (const peer of peers.peers) {
+      if (extractPeerIdFromMultiaddr(peer.address) === expectedPeerId) {
+        return peer.pubkey;
+      }
+      try {
+        if (await nodeIdToPeerId(peer.pubkey) === expectedPeerId) {
+          return peer.pubkey;
+        }
+      } catch {
+      }
+    }
+    await sleep(500);
+  }
+  throw new Error(
+    `connect_peer accepted but peer pubkey not resolved within ${Math.floor(timeoutMs / 1e3)}s (${expectedPeerId})`
+  );
+}
 function createChannelCommand(config) {
-  const channel = new Command2("channel").description("Channel lifecycle and status commands");
-  channel.command("list").option("--state <state>").option("--peer <peerId>").option("--include-closed").option("--json").action(async (options) => {
+  const channel = new Command3("channel").description("Channel lifecycle and status commands");
+  channel.command("list").option("--state <state>").option("--peer <pubkey>").option("--include-closed").option("--json").action(async (options) => {
     const rpc = await createReadyRpcClient(config);
     const stateFilter = parseChannelState(options.state);
     const response = await rpc.listChannels(
-      options.peer ? { peer_id: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
+      options.peer ? { pubkey: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
     );
     const channels = stateFilter ? response.channels.filter((item) => item.state.state_name === stateFilter) : response.channels;
     if (options.json) {
@@ -1017,7 +1590,7 @@ function createChannelCommand(config) {
       printChannelDetailHuman(found);
     }
   });
-  channel.command("watch").option("--interval <seconds>", "Refresh interval", "5").option("--timeout <seconds>").option("--on-timeout <behavior>", "fail | success", "fail").option("--channel <channelId>").option("--peer <peerId>").option("--state <state>").option("--until <state>").option("--include-closed").option("--no-clear").option("--json").action(async (options) => {
+  channel.command("watch").option("--interval <seconds>", "Refresh interval", "5").option("--timeout <seconds>").option("--on-timeout <behavior>", "fail | success", "fail").option("--channel <channelId>").option("--peer <pubkey>").option("--state <state>").option("--until <state>").option("--include-closed").option("--no-clear").option("--json").action(async (options) => {
     const intervalSeconds = parseInt(options.interval, 10);
     const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : void 0;
     const onTimeout = String(options.onTimeout ?? "fail").trim().toLowerCase();
@@ -1046,7 +1619,7 @@ function createChannelCommand(config) {
     const previousStates = /* @__PURE__ */ new Map();
     while (true) {
       const response = await rpc.listChannels(
-        options.peer ? { peer_id: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
+        options.peer ? { pubkey: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
       );
       let channels = response.channels;
       if (options.channel) {
@@ -1128,7 +1701,7 @@ function createChannelCommand(config) {
       await sleep(intervalSeconds * 1e3);
     }
   });
-  channel.command("open").requiredOption("--peer <peerIdOrMultiaddr>").requiredOption("--funding <ckb>").option("--private").option(
+  channel.command("open").requiredOption("--peer <pubkeyOrMultiaddr>").requiredOption("--funding <ckb>").option("--private").option(
     "--idempotency-key <key>",
     "Reuse this key only when retrying the exact same open intent"
   ).option("--json").action(async (options) => {
@@ -1136,21 +1709,23 @@ function createChannelCommand(config) {
     const json = Boolean(options.json);
     const peerInput = options.peer;
     const fundingCkb = parseFloat(options.funding);
-    let peerId = peerInput;
+    let peerPubkey = peerInput;
     if (peerInput.includes("/")) {
       await rpc.connectPeer({ address: peerInput });
-      const peerIdMatch = peerInput.match(/\/p2p\/([^/]+)/);
-      if (peerIdMatch) peerId = peerIdMatch[1];
+      peerPubkey = await resolvePeerPubkeyFromMultiaddr(rpc, peerInput, 8e3);
     }
-    const idempotencyKey = typeof options.idempotencyKey === "string" && options.idempotencyKey.trim().length > 0 ? options.idempotencyKey.trim() : `open:${peerId}:${randomUUID()}`;
+    if (!peerPubkey.startsWith("0x")) {
+      throw new Error(`Invalid peer pubkey: ${peerPubkey}`);
+    }
+    const idempotencyKey = typeof options.idempotencyKey === "string" && options.idempotencyKey.trim().length > 0 ? options.idempotencyKey.trim() : `open:${peerPubkey}:${randomUUID()}`;
     const endpoint = resolveRpcEndpoint(config);
     if (endpoint.target === "runtime-proxy") {
       const created = await tryCreateRuntimeChannelJob(endpoint.url, {
         params: {
           action: "open",
-          peerId,
+          peerId: peerPubkey,
           openChannelParams: {
-            peer_id: peerId,
+            pubkey: peerPubkey,
             funding_amount: ckbToShannons2(fundingCkb),
             public: !options.private
           },
@@ -1165,7 +1740,7 @@ function createChannelCommand(config) {
         const payload2 = {
           jobId: created.id,
           jobState: created.state,
-          peer: peerId,
+          peer: peerPubkey,
           fundingCkb,
           idempotencyKey
         };
@@ -1183,11 +1758,15 @@ function createChannelCommand(config) {
       }
     }
     const result = await rpc.openChannel({
-      peer_id: peerId,
+      pubkey: peerPubkey,
       funding_amount: ckbToShannons2(fundingCkb),
       public: !options.private
     });
-    const payload = { temporaryChannelId: result.temporary_channel_id, peer: peerId, fundingCkb };
+    const payload = {
+      temporaryChannelId: result.temporary_channel_id,
+      peer: peerPubkey,
+      fundingCkb
+    };
     if (json) {
       printJsonSuccess(payload);
     } else {
@@ -1400,14 +1979,14 @@ function createChannelCommand(config) {
 }
 
 // src/commands/config.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { homedir } from "os";
 import { join as join5 } from "path";
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 import { parseDocument, stringify as yamlStringify } from "yaml";
 
 // src/lib/config.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join4 } from "path";
 
 // src/lib/config-templates.ts
@@ -1605,7 +2184,7 @@ function loadProfileConfig(dataDir) {
   const profilePath = getProfilePath(dataDir);
   if (!existsSync4(profilePath)) return void 0;
   try {
-    const raw = readFileSync3(profilePath, "utf-8");
+    const raw = readFileSync4(profilePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return void 0;
@@ -1661,7 +2240,7 @@ function getEffectiveConfig(explicitFlags2) {
   const dataDirSource = explicitFlags2?.has("dataDir") ? "cli" : process.env.FIBER_DATA_DIR ? "env" : "default";
   const configPath = getConfigPath(dataDir);
   const configExists = existsSync4(configPath);
-  const configContent = configExists ? readFileSync3(configPath, "utf-8") : void 0;
+  const configContent = configExists ? readFileSync4(configPath, "utf-8") : void 0;
   const profile = loadProfileConfig(dataDir);
   const cliNetwork = explicitFlags2?.has("network") ? process.env.FIBER_NETWORK : void 0;
   const envNetwork = !explicitFlags2?.has("network") ? process.env.FIBER_NETWORK : void 0;
@@ -1830,7 +2409,7 @@ function normalizeHexScalarsForMutation(content) {
   );
 }
 function parseConfigDocumentForMutation(configPath) {
-  const raw = readFileSync4(configPath, "utf-8");
+  const raw = readFileSync5(configPath, "utf-8");
   const normalized = normalizeHexScalarsForMutation(raw);
   return parseDocument(normalized, {
     keepSourceTokens: true
@@ -1866,7 +2445,7 @@ function collectConfigPaths(value, prefix = "") {
   return prefix ? [prefix] : [];
 }
 function createConfigCommand(_config) {
-  const config = new Command3("config").description("Single source configuration management");
+  const config = new Command4("config").description("Single source configuration management");
   config.command("init").option(
     "--data-dir <path>",
     "Target data directory (overrides FIBER_DATA_DIR for this command)"
@@ -1960,7 +2539,7 @@ function createConfigCommand(_config) {
       }
       process.exit(1);
     }
-    const content = readFileSync4(effective.config.configPath, "utf-8");
+    const content = readFileSync5(effective.config.configPath, "utf-8");
     const fileNetwork = parseNetworkFromConfig(content) || "unknown";
     if (options.json) {
       printJsonSuccess({
@@ -2101,7 +2680,7 @@ function createConfigCommand(_config) {
       }
     }
   });
-  const profile = new Command3("profile").description(
+  const profile = new Command4("profile").description(
     "Manage profile.json settings (CLI-only overrides)"
   );
   const PROFILE_KEYS = ["binaryPath", "keyPassword", "runtimeProxyListen"];
@@ -2231,7 +2810,7 @@ function createConfigCommand(_config) {
 
 // src/commands/graph.ts
 import { shannonsToCkb as shannonsToCkb3, toHex as toHex2 } from "@fiber-pay/sdk";
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 function printGraphNodeListHuman(nodes) {
   if (nodes.length === 0) {
     console.log("No nodes found in the graph.");
@@ -2242,7 +2821,7 @@ function printGraphNodeListHuman(nodes) {
   console.log("NODE ID                ALIAS                VERSION    MIN FUNDING    AGE");
   console.log("---------------------------------------------------------------------------------");
   for (const node of nodes) {
-    const nodeId = truncateMiddle(node.node_id, 10, 8).padEnd(22, " ");
+    const nodeId = truncateMiddle(node.pubkey, 10, 8).padEnd(22, " ");
     const alias = (node.node_name || "(unnamed)").slice(0, 20).padEnd(20, " ");
     const version = (node.version || "?").slice(0, 10).padEnd(10, " ");
     const minFunding = shannonsToCkb3(node.auto_accept_min_ckb_funding_amount).toString().padStart(12, " ");
@@ -2273,7 +2852,7 @@ function printGraphChannelListHuman(channels) {
   }
 }
 function createGraphCommand(config) {
-  const graph = new Command4("graph").description("Network graph queries (nodes & channels)");
+  const graph = new Command5("graph").description("Network graph queries (nodes & channels)");
   graph.command("nodes").option("--limit <n>", "Maximum number of nodes to return", "50").option("--after <cursor>", "Pagination cursor from a previous query").option("--json").action(async (options) => {
     const rpc = await createReadyRpcClient(config);
     const limit = toHex2(BigInt(parseInt(options.limit, 10)));
@@ -2313,9 +2892,9 @@ Next cursor: ${result.last_cursor}`);
 
 // src/commands/invoice.ts
 import { ckbToShannons as ckbToShannons3, randomBytes32, shannonsToCkb as shannonsToCkb4, toHex as toHex3 } from "@fiber-pay/sdk";
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 function createInvoiceCommand(config) {
-  const invoice = new Command5("invoice").description("Invoice lifecycle and status commands");
+  const invoice = new Command6("invoice").description("Invoice lifecycle and status commands");
   invoice.command("create").argument("[amount]").option("--amount <ckb>").option("--description <text>").option("--expiry <minutes>").option("--json").action(async (amountArg, options) => {
     const rpc = await createReadyRpcClient(config);
     const json = Boolean(options.json);
@@ -2531,7 +3110,7 @@ function createInvoiceCommand(config) {
 
 // src/commands/job.ts
 import { existsSync as existsSync7 } from "fs";
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/lib/log-files.ts
 import {
@@ -2570,8 +3149,8 @@ var LogWriter = class {
     if (!this.stream) {
       throw new Error("Failed to create write stream");
     }
+    const stream = this.stream;
     return new Promise((resolve2, reject) => {
-      const stream = this.stream;
       if (this.waitingForDrain) {
         const onDrain = () => {
           this.waitingForDrain = false;
@@ -2885,7 +3464,7 @@ async function readAppendedLines(filePath, offset, remainder = "") {
 
 // src/commands/job.ts
 function createJobCommand(config) {
-  const job = new Command6("job").description("Runtime job management commands");
+  const job = new Command7("job").description("Runtime job management commands");
   job.command("list").option("--state <state>", "Filter by job state").option("--type <type>", "Filter by job type (payment|invoice|channel)").option("--limit <n>", "Limit number of jobs").option("--offset <n>", "Offset for pagination").option("--json").action(async (options) => {
     const json = Boolean(options.json);
     const runtimeUrl = getRuntimeUrlOrExit(config, json);
@@ -3215,11 +3794,163 @@ ${title}: ${filePath}`);
   }
 }
 
+// src/commands/l402.ts
+import { Command as Command8 } from "commander";
+
+// src/lib/l402-proxy.ts
+import { createServer as createServer2 } from "http";
+import { createL402Middleware as createL402Middleware2, FiberRpcClient as FiberRpcClient3 } from "@fiber-pay/sdk";
+import express2 from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+async function runL402ProxyCommand(config, options) {
+  const asJson = Boolean(options.json);
+  const port = parseInt(options.port, 10);
+  const host = options.host;
+  const priceCkb = parseFloat(options.price);
+  const expirySeconds = parseInt(options.expiry, 10);
+  const rootKey = options.rootKey || process.env.L402_ROOT_KEY;
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    if (asJson) {
+      printJsonError({
+        code: "L402_PROXY_INVALID_PORT",
+        message: `Invalid port: ${options.port}`,
+        recoverable: true,
+        suggestion: "Provide a valid port number between 1 and 65535."
+      });
+    } else {
+      console.error(`Error: Invalid port: ${options.port}`);
+    }
+    process.exit(1);
+  }
+  if (Number.isNaN(priceCkb) || priceCkb <= 0) {
+    if (asJson) {
+      printJsonError({
+        code: "L402_PROXY_INVALID_PRICE",
+        message: `Invalid price: ${options.price}`,
+        recoverable: true,
+        suggestion: "Provide a positive CKB amount, e.g. --price 0.1"
+      });
+    } else {
+      console.error(`Error: Invalid price: ${options.price}`);
+    }
+    process.exit(1);
+  }
+  if (!rootKey) {
+    if (asJson) {
+      printJsonError({
+        code: "L402_PROXY_MISSING_ROOT_KEY",
+        message: "L402 root key is required.",
+        recoverable: true,
+        suggestion: "Provide --root-key <64-hex-chars> or set L402_ROOT_KEY environment variable. Generate one with: openssl rand -hex 32"
+      });
+    } else {
+      console.error("Error: L402 root key is required.");
+      console.error("  Provide --root-key <64-hex-chars> or set L402_ROOT_KEY env var.");
+      console.error("  Generate one with: openssl rand -hex 32");
+    }
+    process.exit(1);
+  }
+  const rpcClient = new FiberRpcClient3({
+    url: config.rpcUrl,
+    biscuitToken: config.rpcBiscuitToken
+  });
+  const currency = config.network === "mainnet" ? "Fibb" : "Fibt";
+  const app = express2();
+  app.use(
+    createL402Middleware2({
+      rootKey,
+      priceCkb,
+      expirySeconds,
+      rpcClient,
+      currency
+    })
+  );
+  app.use(
+    createProxyMiddleware({
+      target: options.target,
+      changeOrigin: true
+    })
+  );
+  const server = createServer2(app);
+  await new Promise((resolve2, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        if (asJson) {
+          printJsonError({
+            code: "L402_PROXY_PORT_IN_USE",
+            message: `Port ${port} is already in use.`,
+            recoverable: true,
+            suggestion: `Use a different port with --port <port>.`
+          });
+        } else {
+          console.error(`Error: Port ${port} is already in use.`);
+        }
+        process.exit(1);
+      }
+      reject(err);
+    });
+    server.listen(port, host, () => {
+      resolve2();
+    });
+  });
+  const listenUrl = `http://${host}:${port}`;
+  if (asJson) {
+    printJsonSuccess({
+      status: "running",
+      listen: listenUrl,
+      target: options.target,
+      priceCkb,
+      expirySeconds,
+      currency,
+      fiberRpcUrl: config.rpcUrl
+    });
+  } else {
+    console.log("L402 proxy started");
+    console.log(`  Listen:     ${listenUrl}`);
+    console.log(`  Target:     ${options.target}`);
+    console.log(`  Price:      ${priceCkb} CKB per request`);
+    console.log(`  Expiry:     ${expirySeconds}s`);
+    console.log(`  Currency:   ${currency}`);
+    console.log(`  Fiber RPC:  ${config.rpcUrl}`);
+    console.log("");
+    console.log("Press Ctrl+C to stop.");
+  }
+  const shutdown = () => {
+    if (!asJson) {
+      console.log("\nStopping L402 proxy...");
+    }
+    server.close(() => {
+      if (asJson) {
+        printJsonSuccess({ status: "stopped" });
+      } else {
+        console.log("L402 proxy stopped.");
+      }
+      process.exit(0);
+    });
+    setTimeout(() => {
+      process.exit(0);
+    }, 5e3);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+
+// src/commands/l402.ts
+function createL402Command(config) {
+  const l402 = new Command8("l402").description("L402 payment protocol commands");
+  l402.command("proxy").description("Start a reverse proxy with L402 payment gating").requiredOption("--target <url>", "Upstream server URL to forward paid requests to").option("--port <port>", "Listen port", "8402").option("--host <host>", "Listen host", "127.0.0.1").option("--price <ckb>", "Price per request in CKB", "0.1").option("--root-key <hex>", "Macaroon root key (32-byte hex, or set L402_ROOT_KEY env)").option("--expiry <seconds>", "Token expiry in seconds", "3600").option("--json").action(async (options) => {
+    await runL402ProxyCommand(config, options);
+  });
+  return l402;
+}
+
 // src/commands/logs.ts
 import { existsSync as existsSync8, statSync as statSync2 } from "fs";
 import { join as join8 } from "path";
 import { formatRuntimeAlert } from "@fiber-pay/runtime";
-import { Command as Command7 } from "commander";
+import { Command as Command9 } from "commander";
 var ALLOWED_SOURCES = /* @__PURE__ */ new Set([
   "all",
   "runtime",
@@ -3252,7 +3983,7 @@ function coerceJsonLineForOutput(source, line) {
   return parseRuntimeAlertLine(line) ?? line;
 }
 function createLogsCommand(config) {
-  return new Command7("logs").alias("log").description("View persisted runtime/fnn logs").option("--source <source>", "Log source: all|runtime|fnn-stdout|fnn-stderr", "all").option("--tail <n>", "Number of recent lines per source", "80").option("--date <YYYY-MM-DD>", "Date of log directory to read (default: today UTC)").option("--list-dates", "List available log dates and exit").option("--follow", "Keep streaming appended log lines (human output mode only)").option("--interval-ms <ms>", "Polling interval for --follow mode", "1000").option("--json").action(async (options) => {
+  return new Command9("logs").alias("log").description("View persisted runtime/fnn logs").option("--source <source>", "Log source: all|runtime|fnn-stdout|fnn-stderr", "all").option("--tail <n>", "Number of recent lines per source", "80").option("--date <YYYY-MM-DD>", "Date of log directory to read (default: today UTC)").option("--list-dates", "List available log dates and exit").option("--follow", "Keep streaming appended log lines (human output mode only)").option("--interval-ms <ms>", "Polling interval for --follow mode", "1000").option("--json").action(async (options) => {
     const json = Boolean(options.json);
     const follow = Boolean(options.follow);
     const listDates = Boolean(options.listDates);
@@ -3507,7 +4238,7 @@ function inferDateFromPaths(paths) {
 }
 
 // src/commands/node.ts
-import { Command as Command8 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/lib/node-info.ts
 async function runNodeInfoCommand(config, options) {
@@ -3520,7 +4251,7 @@ async function runNodeInfoCommand(config, options) {
   console.log("\u2705 Node info retrieved");
   console.log(`  Version: ${nodeInfo.version}`);
   console.log(`  Commit: ${nodeInfo.commit_hash}`);
-  console.log(`  Node ID: ${nodeInfo.node_id}`);
+  console.log(`  Node Pubkey: ${nodeInfo.pubkey}`);
   if (nodeInfo.features.length > 0) {
     console.log("  Features:");
     for (const feature of nodeInfo.features) {
@@ -3572,11 +4303,7 @@ async function runNodeNetworkCommand(config, options) {
   ]);
   const graphNodesMap = /* @__PURE__ */ new Map();
   for (const node of graphNodes.nodes) {
-    graphNodesMap.set(node.node_id, node);
-  }
-  const peerIdToNodeIdMap = /* @__PURE__ */ new Map();
-  for (const peer of localPeers.peers) {
-    peerIdToNodeIdMap.set(peer.peer_id, peer.pubkey);
+    graphNodesMap.set(node.pubkey, node);
   }
   const graphChannelsMap = /* @__PURE__ */ new Map();
   for (const channel of graphChannels.channels) {
@@ -3590,8 +4317,7 @@ async function runNodeNetworkCommand(config, options) {
     nodeInfo: graphNodesMap.get(peer.pubkey)
   }));
   const enrichedChannels = localChannels.channels.map((channel) => {
-    const nodeId = peerIdToNodeIdMap.get(channel.peer_id) || channel.peer_id;
-    const peerNodeInfo = graphNodesMap.get(nodeId);
+    const peerNodeInfo = graphNodesMap.get(channel.pubkey);
     let graphChannelInfo;
     if (channel.channel_outpoint) {
       const outpointKey = `${channel.channel_outpoint.tx_hash}:${channel.channel_outpoint.index}`;
@@ -3610,7 +4336,7 @@ async function runNodeNetworkCommand(config, options) {
   }, 0n);
   const totalChannelCapacity = formatShannonsAsCkb(totalChannelCapacityShannons, 1);
   const networkData = {
-    localNodeId: nodeInfo.node_id,
+    localNodeId: nodeInfo.pubkey,
     peers: enrichedPeers,
     channels: enrichedChannels,
     graphNodes: graphNodes.nodes,
@@ -3637,16 +4363,16 @@ function printNodeNetworkHuman(data) {
   console.log("");
   if (data.peers.length > 0) {
     console.log("Peers:");
-    console.log("  PEER_ID                ALIAS                ADDRESS                    VERSION");
+    console.log("  PUBKEY                 ALIAS                ADDRESS                    VERSION");
     console.log(
       "  --------------------------------------------------------------------------------"
     );
     for (const peer of data.peers) {
-      const peerId = truncateMiddle(peer.peer_id, 10, 8).padEnd(22, " ");
+      const pubkey = truncateMiddle(peer.pubkey, 10, 8).padEnd(22, " ");
       const alias = sanitizeForTerminal(peer.nodeInfo?.node_name || "(unnamed)").slice(0, 20).padEnd(20, " ");
       const address = truncateMiddle(sanitizeForTerminal(peer.address), 15, 8).padEnd(25, " ");
       const version = sanitizeForTerminal(peer.nodeInfo?.version || "?").slice(0, 8).padEnd(8, " ");
-      console.log(`  ${peerId} ${alias} ${address} ${version}`);
+      console.log(`  ${pubkey} ${alias} ${address} ${version}`);
     }
     console.log("");
   }
@@ -3671,7 +4397,7 @@ function printNodeNetworkHuman(data) {
 }
 
 // src/lib/node-start.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { mkdirSync as mkdirSync3 } from "fs";
 import { join as join9 } from "path";
 import {
@@ -3682,12 +4408,12 @@ import {
 import { startRuntimeService } from "@fiber-pay/runtime";
 
 // src/lib/bootnode.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml } from "yaml";
 function extractBootnodeAddrs(configFilePath) {
   if (!existsSync9(configFilePath)) return [];
   try {
-    const content = readFileSync5(configFilePath, "utf-8");
+    const content = readFileSync6(configFilePath, "utf-8");
     const doc = parseYaml(content);
     const addrs = doc?.fiber?.bootnode_addrs;
     if (!Array.isArray(addrs)) return [];
@@ -3942,7 +4668,7 @@ async function runNodeStartCommand(config, options) {
       process.exit(1);
     }
     const childArgs = process.argv.slice(2).filter((arg) => arg !== "--daemon");
-    const child = spawn(process.execPath, [cliEntrypoint, ...childArgs], {
+    const child = spawn2(process.execPath, [cliEntrypoint, ...childArgs], {
       detached: true,
       stdio: "ignore",
       cwd: process.cwd(),
@@ -4331,7 +5057,7 @@ async function runNodeStartCommand(config, options) {
           flushTimeout = setTimeout(() => reject(new Error("Flush timeout")), 5e3);
         })
       ]);
-    } catch (err) {
+    } catch (_err) {
       if (!json) {
         console.log("\u26A0\uFE0F Log flush timed out, continuing shutdown...");
       }
@@ -4402,7 +5128,7 @@ import {
   buildMultiaddrFromNodeId,
   buildMultiaddrFromRpcUrl,
   ChannelState as ChannelState2,
-  nodeIdToPeerId,
+  nodeIdToPeerId as nodeIdToPeerId2,
   scriptToAddress
 } from "@fiber-pay/sdk";
 
@@ -4596,21 +5322,21 @@ async function runNodeStatusCommand(config, options) {
       const nodeInfo = await rpc.nodeInfo();
       const channels = await rpc.listChannels({ include_closed: false });
       rpcResponsive = true;
-      nodeId = nodeInfo.node_id;
+      nodeId = nodeInfo.pubkey;
       nodeName = nodeInfo.node_name;
       addresses = nodeInfo.addresses;
       chainHash = nodeInfo.chain_hash;
       version = nodeInfo.version;
       peersCount = parseInt(nodeInfo.peers_count, 16);
       try {
-        peerId = await nodeIdToPeerId(nodeInfo.node_id);
+        peerId = await nodeIdToPeerId2(nodeInfo.pubkey);
       } catch (error) {
         peerIdError = error instanceof Error ? error.message : String(error);
       }
       const baseAddress = nodeInfo.addresses[0];
       if (baseAddress) {
         try {
-          multiaddr = await buildMultiaddrFromNodeId(baseAddress, nodeInfo.node_id);
+          multiaddr = await buildMultiaddrFromNodeId(baseAddress, nodeInfo.pubkey);
         } catch (error) {
           multiaddrError = error instanceof Error ? error.message : String(error);
         }
@@ -5148,7 +5874,12 @@ async function runMigrationAndReport(opts) {
     }
     process.exit(0);
   }
-  if (!migrationCheck.needed) {
+  const precheckUnsupported = migrationCheck.precheckUnsupported;
+  if (precheckUnsupported && forceMigrateAttempt && !json) {
+    console.log("\u26A0\uFE0F  Migration pre-check is unavailable for this fnn-migrate version.");
+    console.log("   --force-migrate is set, so migration will be attempted directly.");
+  }
+  if (!migrationCheck.needed && !(precheckUnsupported && forceMigrateAttempt)) {
     if (!json) console.log("   Store is compatible, no migration needed.");
     return normalizeMigrationCheck(migrationCheck);
   }
@@ -5226,7 +5957,7 @@ async function runMigrationAndReport(opts) {
 
 // src/commands/node.ts
 function createNodeCommand(config) {
-  const node = new Command8("node").description("Node management");
+  const node = new Command10("node").description("Node management");
   node.command("start").option("--daemon", "Start node in detached background mode (node + runtime)").option("--runtime-proxy-listen <host:port>", "Runtime monitor proxy listen address").option("--event-stream <format>", "Event stream format for --json mode (jsonl)", "jsonl").option("--quiet-fnn", "Do not mirror fnn stdout/stderr to console; keep file persistence").option("--json").action(async (options) => {
     await runNodeStartCommand(config, options);
   });
@@ -5256,9 +5987,9 @@ function createNodeCommand(config) {
 
 // src/commands/payment.ts
 import { ckbToShannons as ckbToShannons4, shannonsToCkb as shannonsToCkb6 } from "@fiber-pay/sdk";
-import { Command as Command9 } from "commander";
+import { Command as Command11 } from "commander";
 function createPaymentCommand(config) {
-  const payment = new Command9("payment").description("Payment lifecycle and status commands");
+  const payment = new Command11("payment").description("Payment lifecycle and status commands");
   payment.command("send").argument("[invoice]").option("--invoice <invoice>").option("--to <nodeId>").option("--amount <ckb>").option("--max-fee <ckb>").option("--wait", "Wait for runtime job terminal status when runtime proxy is active").option("--timeout <seconds>", "Wait timeout for --wait mode", "120").option("--json").action(async (invoiceArg, options) => {
     const rpc = await createReadyRpcClient(config);
     const json = Boolean(options.json);
@@ -5592,24 +6323,40 @@ function getJobFailure(job) {
 }
 
 // src/commands/peer.ts
-import { Command as Command10 } from "commander";
-function extractPeerIdFromMultiaddr(address) {
+import { nodeIdToPeerId as nodeIdToPeerId3 } from "@fiber-pay/sdk";
+import { Command as Command12 } from "commander";
+function extractPeerIdFromMultiaddr2(address) {
   const match = address.match(/\/p2p\/([^/]+)$/);
   return match?.[1];
 }
-async function waitForPeerConnected(rpc, peerId, timeoutMs) {
+async function findPeerByPeerId(rpc, expectedPeerId) {
+  const peers = await rpc.listPeers();
+  for (const peer of peers.peers) {
+    if (extractPeerIdFromMultiaddr2(peer.address) === expectedPeerId) {
+      return peer;
+    }
+    try {
+      if (await nodeIdToPeerId3(peer.pubkey) === expectedPeerId) {
+        return peer;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function waitForPeerConnected(rpc, expectedPeerId, timeoutMs) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const peers = await rpc.listPeers();
-    if (peers.peers.some((peer) => peer.peer_id === peerId)) {
-      return true;
+    const match = await findPeerByPeerId(rpc, expectedPeerId);
+    if (match) {
+      return { pubkey: match.pubkey, address: match.address };
     }
     await new Promise((resolve2) => setTimeout(resolve2, 500));
   }
-  return false;
+  return void 0;
 }
 function createPeerCommand(config) {
-  const peer = new Command10("peer").description("Peer management");
+  const peer = new Command12("peer").description("Peer management");
   peer.command("list").option("--json").action(async (options) => {
     const rpc = await createReadyRpcClient(config);
     const peers = await rpc.listPeers();
@@ -5621,41 +6368,47 @@ function createPeerCommand(config) {
   });
   peer.command("connect").argument("<multiaddr>").option("--timeout <sec>", "Wait timeout for peer to appear in peer list", "8").option("--json").action(async (address, options) => {
     const rpc = await createReadyRpcClient(config);
-    const peerId = extractPeerIdFromMultiaddr(address);
-    if (!peerId) {
+    const expectedPeerId = extractPeerIdFromMultiaddr2(address);
+    if (!expectedPeerId) {
       throw new Error("Invalid multiaddr: missing /p2p/<peerId> suffix");
     }
     await rpc.connectPeer({ address });
     const timeoutMs = Math.max(1, Number.parseInt(String(options.timeout), 10) || 8) * 1e3;
-    const connected = await waitForPeerConnected(rpc, peerId, timeoutMs);
+    const connected = await waitForPeerConnected(rpc, expectedPeerId, timeoutMs);
     if (!connected) {
       throw new Error(
-        `connect_peer accepted but peer not found in list within ${Math.floor(timeoutMs / 1e3)}s (${peerId})`
+        `connect_peer accepted but peer not found in list within ${Math.floor(timeoutMs / 1e3)}s (${expectedPeerId})`
       );
     }
     if (options.json) {
-      printJsonSuccess({ address, peerId, message: "Connected" });
+      printJsonSuccess({
+        address,
+        peerId: expectedPeerId,
+        pubkey: connected.pubkey,
+        message: "Connected"
+      });
     } else {
       console.log("\u2705 Connected to peer");
       console.log(`  Address: ${address}`);
-      console.log(`  Peer ID: ${peerId}`);
+      console.log(`  Peer ID: ${expectedPeerId}`);
+      console.log(`  Peer Pubkey: ${connected.pubkey}`);
     }
   });
-  peer.command("disconnect").argument("<peerId>").option("--json").action(async (peerId, options) => {
+  peer.command("disconnect").argument("<pubkey>").option("--json").action(async (pubkey, options) => {
     const rpc = await createReadyRpcClient(config);
-    await rpc.disconnectPeer({ peer_id: peerId });
+    await rpc.disconnectPeer({ pubkey });
     if (options.json) {
-      printJsonSuccess({ peerId, message: "Disconnected" });
+      printJsonSuccess({ pubkey, message: "Disconnected" });
     } else {
       console.log("\u2705 Disconnected peer");
-      console.log(`  Peer ID: ${peerId}`);
+      console.log(`  Peer Pubkey: ${pubkey}`);
     }
   });
   return peer;
 }
 
 // src/commands/runtime.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { join as join10, resolve } from "path";
 import {
   alertPriorityOrder,
@@ -5664,7 +6417,7 @@ import {
   isAlertType,
   startRuntimeService as startRuntimeService2
 } from "@fiber-pay/runtime";
-import { Command as Command11 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/lib/parse-options.ts
 function parseIntegerOption(value, name) {
@@ -5735,7 +6488,7 @@ function resolveRuntimeRecoveryListen(config) {
   return meta?.proxyListen ?? config.runtimeProxyListen ?? "127.0.0.1:8229";
 }
 function createRuntimeCommand(config) {
-  const runtime = new Command11("runtime").description("Polling monitor and alert runtime service");
+  const runtime = new Command13("runtime").description("Polling monitor and alert runtime service");
   runtime.command("start").description("Start runtime monitor service in foreground").option("--daemon", "Start runtime monitor in detached background mode").option("--fiber-rpc-url <url>", "Target fiber rpc URL (defaults to --rpc-url/global config)").option("--proxy-listen <host:port>", "Monitor proxy listen address").option("--channel-poll-ms <ms>", "Channel polling interval in milliseconds").option("--invoice-poll-ms <ms>", "Invoice polling interval in milliseconds").option("--payment-poll-ms <ms>", "Payment polling interval in milliseconds").option("--peer-poll-ms <ms>", "Peer polling interval in milliseconds").option("--health-poll-ms <ms>", "RPC health polling interval in milliseconds").option("--include-closed <bool>", "Monitor closed channels (true|false)").option("--completed-ttl-seconds <seconds>", "TTL for completed invoices/payments in tracker").option("--state-file <path>", "State file path for snapshots and history").option("--alert-log-file <path>", "Path to runtime alert JSONL log file (legacy static path)").option("--alert-logs-base-dir <dir>", "Base logs directory for daily-rotated alert files").option("--flush-ms <ms>", "State flush interval in milliseconds").option("--webhook <url>", "Webhook URL to receive alert POST payloads").option("--websocket <host:port>", "WebSocket alert broadcast listen address").option(
     "--log-min-priority <priority>",
     "Minimum runtime log priority (critical|high|medium|low)"
@@ -5793,7 +6546,7 @@ function createRuntimeCommand(config) {
       }
       if (daemon && !isRuntimeChild) {
         const childArgv = process.argv.filter((arg) => arg !== "--daemon");
-        const child = spawn2(process.execPath, childArgv.slice(1), {
+        const child = spawn3(process.execPath, childArgv.slice(1), {
           detached: true,
           stdio: "ignore",
           cwd: process.cwd(),
@@ -6144,15 +6897,15 @@ function createRuntimeCommand(config) {
 }
 
 // src/commands/version.ts
-import { Command as Command12 } from "commander";
+import { Command as Command14 } from "commander";
 
 // src/lib/build-info.ts
-var CLI_VERSION = "0.1.0";
-var CLI_COMMIT = "a3f2219ee96693b1cb80808f401ba5ee660f556b";
+var CLI_VERSION = "0.2.0";
+var CLI_COMMIT = "f9635524f49ce13667b606fcb9a0d1aef35bcb2d";
 
 // src/commands/version.ts
 function createVersionCommand() {
-  return new Command12("version").description("Show CLI version and commit id").option("--json", "Output JSON").action((options) => {
+  return new Command14("version").description("Show CLI version and commit id").option("--json", "Output JSON").action((options) => {
     const payload = {
       version: CLI_VERSION,
       commit: CLI_COMMIT
@@ -6167,7 +6920,7 @@ function createVersionCommand() {
 }
 
 // src/commands/wallet.ts
-import { Command as Command13, Option } from "commander";
+import { Command as Command15, Option } from "commander";
 
 // src/lib/wallet-address.ts
 import { scriptToAddress as scriptToAddress2 } from "@fiber-pay/sdk";
@@ -6222,7 +6975,7 @@ async function runWalletBalanceCommand(config, options) {
 
 // src/commands/wallet.ts
 function createWalletCommand(config) {
-  const wallet = new Command13("wallet").description("Wallet management");
+  const wallet = new Command15("wallet").description("Wallet management");
   wallet.command("address").description("Display the funding address").addOption(new Option("--json", "Output as JSON").conflicts("qrcode")).option("--qrcode", "Display address as QR code in terminal").action(async (options) => {
     await runWalletAddressCommand(config, options);
   });
@@ -6397,7 +7150,7 @@ async function main() {
   }
   applyGlobalOverrides(argv);
   const config = getEffectiveConfig(explicitFlags).config;
-  const program = new Command14();
+  const program = new Command16();
   program.name("fiber-pay").description("AI Agent Payment SDK for CKB Lightning Network").option("--profile <name>", "Use profile at ~/.fiber-pay/profiles/<name>").option("--data-dir <path>", "Override data directory for all commands").option("--rpc-url <url>", "Override RPC URL for all commands").option("--rpc-biscuit-token <token>", "Set RPC Authorization Bearer token for all commands").option("--network <network>", "Override network for all commands (testnet|mainnet)").option("--key-password <password>", "Override key password for all commands").option("--binary-path <path>", "Override fiber binary path for all commands").showHelpAfterError().showSuggestionAfterError();
   program.exitOverride();
   program.configureOutput({
@@ -6409,6 +7162,7 @@ async function main() {
     }
   });
   program.addCommand(createNodeCommand(config));
+  program.addCommand(createAgentCommand(config));
   program.addCommand(createChannelCommand(config));
   program.addCommand(createInvoiceCommand(config));
   program.addCommand(createPaymentCommand(config));
@@ -6418,6 +7172,7 @@ async function main() {
   program.addCommand(createGraphCommand(config));
   program.addCommand(createBinaryCommand(config));
   program.addCommand(createConfigCommand(config));
+  program.addCommand(createL402Command(config));
   program.addCommand(createRuntimeCommand(config));
   program.addCommand(createVersionCommand());
   program.addCommand(createWalletCommand(config));