@fiber-pay/cli 0.1.0-rc.7 → 0.1.1

package/dist/cli.js

@@ -1,167 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { join as join9 } from "path";
-import { Command as Command14 } from "commander";
+import { join as join11 } from "path";
+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 {
@@ -485,96 +332,21 @@ function printPeerListHuman(peers) {
   }
 }
 
-// src/commands/binary.ts
-function showProgress(progress) {
-  const percent = progress.percent !== void 0 ? ` (${progress.percent}%)` : "";
-  process.stdout.write(`\r[${progress.phase}]${percent} ${progress.message}`.padEnd(80));
-  if (progress.phase === "installing") {
-    console.log();
-  }
-}
-function createBinaryCommand(config) {
-  const binary = new Command("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;
-    try {
-      installDir = getBinaryManagerInstallDirOrThrow(resolvedBinary);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (options.json) {
-        printJsonError({
-          code: "BINARY_PATH_INCOMPATIBLE",
-          message,
-          recoverable: true,
-          suggestion: "Use `fiber-pay config profile unset binaryPath` or set binaryPath to a standard fnn filename in the target directory."
-        });
-      } else {
-        console.error(`\u274C ${message}`);
-      }
-      process.exit(1);
-    }
-    const info = await downloadFiberBinary({
-      installDir,
-      version: options.version,
-      force: Boolean(options.force),
-      onProgress: options.json ? void 0 : showProgress
-    });
-    if (options.json) {
-      printJsonSuccess({
-        ...info,
-        source: resolvedBinary.source,
-        resolvedPath: resolvedBinary.binaryPath
-      });
-    } else {
-      console.log("\n\u2705 Binary installed successfully!");
-      console.log(`  Path:    ${info.path}`);
-      console.log(`  Version: ${info.version}`);
-      console.log(`  Ready:   ${info.ready ? "yes" : "no"}`);
-    }
-  });
-  binary.command("info").option("--json").action(async (options) => {
-    const { resolvedBinary, info } = await getBinaryDetails(config);
-    if (options.json) {
-      printJsonSuccess({
-        ...info,
-        source: resolvedBinary.source,
-        resolvedPath: resolvedBinary.binaryPath
-      });
-    } else {
-      console.log(info.ready ? "\u2705 Binary is ready" : "\u274C Binary not found or not executable");
-      console.log(`  Path:    ${info.path}`);
-      console.log(`  Version: ${info.version}`);
-    }
-  });
-  return binary;
-}
-
-// src/commands/channel.ts
-import { randomUUID } from "crypto";
-import { ckbToShannons as ckbToShannons2 } from "@fiber-pay/sdk";
-import { Command as Command2 } 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";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
 function getPidFilePath(dataDir) {
-  return join2(dataDir, "fiber.pid");
+  return join(dataDir, "fiber.pid");
 }
 function writePidFile(dataDir, pid) {
   writeFileSync(getPidFilePath(dataDir), String(pid));
 }
 function readPidFile(dataDir) {
   const pidPath = getPidFilePath(dataDir);
-  if (!existsSync2(pidPath)) return null;
+  if (!existsSync(pidPath)) return null;
   try {
     return parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
   } catch {
@@ -583,7 +355,7 @@ function readPidFile(dataDir) {
 }
 function removePidFile(dataDir) {
   const pidPath = getPidFilePath(dataDir);
-  if (existsSync2(pidPath)) {
+  if (existsSync(pidPath)) {
     unlinkSync(pidPath);
   }
 }
@@ -597,20 +369,20 @@ function isProcessRunning(pid) {
 }
 
 // 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";
+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 join3(dataDir, "runtime.pid");
+  return join2(dataDir, "runtime.pid");
 }
 function getRuntimeMetaFilePath(dataDir) {
-  return join3(dataDir, "runtime.meta.json");
+  return join2(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;
+  if (!existsSync2(pidPath)) return null;
   try {
     return Number.parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
   } catch {
@@ -622,7 +394,7 @@ function writeRuntimeMeta(dataDir, meta) {
 }
 function readRuntimeMeta(dataDir) {
   const metaPath = getRuntimeMetaFilePath(dataDir);
-  if (!existsSync3(metaPath)) return null;
+  if (!existsSync2(metaPath)) return null;
   try {
     return JSON.parse(readFileSync2(metaPath, "utf-8"));
   } catch {
@@ -632,10 +404,10 @@ function readRuntimeMeta(dataDir) {
 function removeRuntimeFiles(dataDir) {
   const pidPath = getRuntimePidFilePath(dataDir);
   const metaPath = getRuntimeMetaFilePath(dataDir);
-  if (existsSync3(pidPath)) {
+  if (existsSync2(pidPath)) {
     unlinkSync2(pidPath);
   }
-  if (existsSync3(metaPath)) {
+  if (existsSync2(metaPath)) {
     unlinkSync2(metaPath);
   }
 }
@@ -664,32 +436,808 @@ function resolveRuntimeProxyUrl(config) {
   if (runtimeMeta.proxyListen.startsWith("http://") || runtimeMeta.proxyListen.startsWith("https://")) {
     return runtimeMeta.proxyListen;
   }
-  return `http://${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
+function showProgress(progress) {
+  const percent = progress.percent !== void 0 ? ` (${progress.percent}%)` : "";
+  process.stdout.write(`\r[${progress.phase}]${percent} ${progress.message}`.padEnd(80));
+  if (progress.phase === "installing") {
+    console.log();
+  }
 }
-function createRpcClient(config) {
-  const resolved = resolveRpcEndpoint(config);
-  return new FiberRpcClient({
-    url: resolved.url,
-    biscuitToken: config.rpcBiscuitToken
+function createBinaryCommand(config) {
+  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;
+    try {
+      installDir = getBinaryManagerInstallDirOrThrow(resolvedBinary);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (options.json) {
+        printJsonError({
+          code: "BINARY_PATH_INCOMPATIBLE",
+          message,
+          recoverable: true,
+          suggestion: "Use `fiber-pay config profile unset binaryPath` or set binaryPath to a standard fnn filename in the target directory."
+        });
+      } else {
+        console.error(`\u274C ${message}`);
+      }
+      process.exit(1);
+    }
+    const info = await downloadFiberBinary({
+      installDir,
+      version: options.version,
+      force: Boolean(options.force),
+      onProgress: options.json ? void 0 : showProgress
+    });
+    if (options.json) {
+      printJsonSuccess({
+        ...info,
+        source: resolvedBinary.source,
+        resolvedPath: resolvedBinary.binaryPath
+      });
+    } else {
+      console.log("\n\u2705 Binary installed successfully!");
+      console.log(`  Path:    ${info.path}`);
+      console.log(`  Version: ${info.version}`);
+      console.log(`  Ready:   ${info.ready ? "yes" : "no"}`);
+    }
   });
+  binary.command("info").option("--json").action(async (options) => {
+    const { resolvedBinary, info } = await getBinaryDetails(config);
+    if (options.json) {
+      printJsonSuccess({
+        ...info,
+        source: resolvedBinary.source,
+        resolvedPath: resolvedBinary.binaryPath
+      });
+    } else {
+      console.log(info.ready ? "\u2705 Binary is ready" : "\u274C Binary not found or not executable");
+      console.log(`  Path:    ${info.path}`);
+      console.log(`  Version: ${info.version}`);
+    }
+  });
+  return binary;
 }
-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/commands/channel.ts
+import { randomUUID } from "crypto";
+import { ckbToShannons as ckbToShannons2 } 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/runtime-jobs.ts
@@ -979,7 +1527,7 @@ function registerChannelRebalanceCommand(parent, config) {
 
 // src/commands/channel.ts
 function createChannelCommand(config) {
-  const channel = new Command2("channel").description("Channel lifecycle and status commands");
+  const channel = new Command3("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 rpc = await createReadyRpcClient(config);
     const stateFilter = parseChannelState(options.state);
@@ -1400,12 +1948,14 @@ function createChannelCommand(config) {
 }
 
 // src/commands/config.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { Command as Command3 } from "commander";
+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 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
@@ -1603,7 +2153,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;
@@ -1659,7 +2209,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;
@@ -1828,7 +2378,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
@@ -1864,7 +2414,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)"
@@ -1958,7 +2508,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({
@@ -2099,7 +2649,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"];
@@ -2123,6 +2673,56 @@ function createConfigCommand(_config) {
       }
     }
   });
+  profile.command("list").description("List all available Fiber profiles").option("--json").action(async (options) => {
+    const homeDir = homedir();
+    const profilesDir = join5(homeDir, ".fiber-pay", "profiles");
+    const defaultDir = join5(homeDir, ".fiber-pay");
+    const defaultConfigPath = join5(defaultDir, "config.yml");
+    const profiles = [];
+    const hasDefaultConfig = existsSync5(defaultConfigPath);
+    if (hasDefaultConfig) {
+      profiles.push("default");
+    }
+    if (existsSync5(profilesDir)) {
+      try {
+        const entries = readdirSync(profilesDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name !== "default") {
+            profiles.push(entry.name);
+          }
+        }
+      } catch (error) {
+        if (options.json) {
+          printJsonError({
+            code: "PROFILE_LIST_ERROR",
+            message: `Failed to read profiles directory: ${error instanceof Error ? error.message : String(error)}`,
+            recoverable: true
+          });
+          process.exit(1);
+        } else {
+          console.error(
+            `Warning: Could not read profiles directory: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    profiles.sort((a, b) => {
+      if (a === "default") return -1;
+      if (b === "default") return 1;
+      return a.localeCompare(b);
+    });
+    if (options.json) {
+      printJsonSuccess({ profiles, count: profiles.length });
+    } else {
+      if (profiles.length === 0) {
+        console.log("No profiles found.");
+      } else {
+        for (const profileName of profiles) {
+          console.log(profileName);
+        }
+      }
+    }
+  });
   profile.command("set").description("Set a profile key").argument("<key>", `One of: ${PROFILE_KEYS.join(", ")}`).argument("<value>").option("--json").action(async (key, value, options) => {
     if (!PROFILE_KEYS.includes(key)) {
       const msg = `Unknown profile key: ${key}. Valid keys: ${PROFILE_KEYS.join(", ")}`;
@@ -2179,7 +2779,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.");
@@ -2221,7 +2821,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)));
@@ -2261,9 +2861,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);
@@ -2479,21 +3079,162 @@ 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 {
-  appendFileSync,
   closeSync,
   createReadStream,
   existsSync as existsSync6,
   mkdirSync as mkdirSync2,
   openSync,
-  readdirSync,
+  readdirSync as readdirSync2,
   readSync,
   statSync
 } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
+
+// src/lib/log-writer.ts
+import { createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname as dirname2, join as join6 } from "path";
+var LogWriter = class {
+  constructor(baseDir, filename) {
+    this.baseDir = baseDir;
+    this.filename = filename;
+  }
+  stream = null;
+  pendingWrites = 0;
+  lastErrorTime = 0;
+  errorRateLimitMs = 1e3;
+  isClosing = false;
+  waitingForDrain = false;
+  currentDate = null;
+  async append(text) {
+    if (this.isClosing) {
+      throw new Error("Cannot append to closing LogWriter");
+    }
+    await this.ensureStream();
+    if (!this.stream) {
+      throw new Error("Failed to create write stream");
+    }
+    const stream = this.stream;
+    return new Promise((resolve2, reject) => {
+      if (this.waitingForDrain) {
+        const onDrain = () => {
+          this.waitingForDrain = false;
+          stream.off("drain", onDrain);
+          stream.off("error", onError);
+          this.performWrite(text, resolve2, reject);
+        };
+        const onError = (err) => {
+          this.waitingForDrain = false;
+          stream.off("drain", onDrain);
+          stream.off("error", onError);
+          this.handleError(err);
+          reject(err);
+        };
+        stream.once("drain", onDrain);
+        stream.once("error", onError);
+        return;
+      }
+      this.performWrite(text, resolve2, reject);
+    });
+  }
+  async flush() {
+    if (this.isClosing || !this.stream) {
+      return;
+    }
+    this.isClosing = true;
+    while (this.pendingWrites > 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 10));
+    }
+    return new Promise((resolve2, reject) => {
+      if (!this.stream) {
+        resolve2();
+        return;
+      }
+      const stream = this.stream;
+      stream.once("finish", () => {
+        this.stream = null;
+        resolve2();
+      });
+      stream.once("error", (err) => {
+        this.handleError(err);
+        this.stream = null;
+        reject(err);
+      });
+      stream.end();
+    });
+  }
+  async ensureStream() {
+    this.isClosing = false;
+    const today = this.todayDateString();
+    if (this.stream && this.currentDate !== today && !this.isClosing) {
+      await this.flush();
+      this.stream = null;
+    }
+    if (this.stream && !this.isClosing) {
+      return;
+    }
+    this.currentDate = today;
+    const logPath = this.resolveLogPath();
+    await this.ensureDirectory(logPath);
+    this.stream = createWriteStream(logPath, {
+      flags: "a",
+      highWaterMark: 16 * 1024
+    });
+    this.stream.on("error", (err) => {
+      this.handleError(err);
+      this.stream = null;
+      this.isClosing = true;
+    });
+    this.isClosing = false;
+  }
+  performWrite(text, resolve2, reject) {
+    if (!this.stream) {
+      reject(new Error("Stream is not available"));
+      return;
+    }
+    this.pendingWrites += 1;
+    const canContinue = this.stream.write(text, (err) => {
+      this.pendingWrites -= 1;
+      if (err) {
+        this.handleError(err);
+        reject(err);
+      } else {
+        resolve2();
+      }
+    });
+    if (!canContinue) {
+      this.waitingForDrain = true;
+    }
+  }
+  async ensureDirectory(filePath) {
+    const dir = dirname2(filePath);
+    await mkdir(dir, { recursive: true });
+  }
+  resolveLogPath() {
+    const dateStr = this.todayDateString();
+    return join6(this.baseDir, "logs", dateStr, this.filename);
+  }
+  todayDateString() {
+    const now = /* @__PURE__ */ new Date();
+    const y = now.getUTCFullYear();
+    const m = String(now.getUTCMonth() + 1).padStart(2, "0");
+    const d = String(now.getUTCDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+  }
+  handleError(error) {
+    const now = Date.now();
+    if (now - this.lastErrorTime >= this.errorRateLimitMs) {
+      this.lastErrorTime = now;
+      console.error(`[LogWriter] ${error.message}`);
+    }
+  }
+};
+
+// src/lib/log-files.ts
 var DATE_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
 function todayDateString() {
   const now = /* @__PURE__ */ new Date();
@@ -2517,11 +3258,11 @@ function resolveLogDirForDate(dataDir, date) {
 }
 function resolveLogDirForDateWithOptions(dataDir, date, options) {
   const dateStr = date ?? todayDateString();
-  const logsBaseDir = options.logsBaseDir ?? join5(dataDir, "logs");
+  const logsBaseDir = options.logsBaseDir ?? join7(dataDir, "logs");
   if (date !== void 0) {
     validateLogDate(dateStr);
   }
-  const dir = join5(logsBaseDir, dateStr);
+  const dir = join7(logsBaseDir, dateStr);
   const ensureExists = options.ensureExists ?? true;
   if (ensureExists) {
     mkdirSync2(dir, { recursive: true });
@@ -2529,16 +3270,16 @@ function resolveLogDirForDateWithOptions(dataDir, date, options) {
   return dir;
 }
 function resolvePersistedLogPaths(dataDir, meta, date) {
-  const logsBaseDir = meta?.logsBaseDir ?? join5(dataDir, "logs");
+  const logsBaseDir = meta?.logsBaseDir ?? join7(dataDir, "logs");
   if (date) {
     const dir2 = resolveLogDirForDateWithOptions(dataDir, date, {
       logsBaseDir,
       ensureExists: false
     });
     return {
-      runtimeAlerts: join5(dir2, "runtime.alerts.jsonl"),
-      fnnStdout: join5(dir2, "fnn.stdout.log"),
-      fnnStderr: join5(dir2, "fnn.stderr.log")
+      runtimeAlerts: join7(dir2, "runtime.alerts.jsonl"),
+      fnnStdout: join7(dir2, "fnn.stdout.log"),
+      fnnStderr: join7(dir2, "fnn.stderr.log")
     };
   }
   if (meta?.alertLogFilePath || meta?.fnnStdoutLogPath || meta?.fnnStderrLogPath) {
@@ -2547,9 +3288,9 @@ function resolvePersistedLogPaths(dataDir, meta, date) {
       ensureExists: false
     });
     return {
-      runtimeAlerts: meta.alertLogFilePath ?? join5(defaultDir, "runtime.alerts.jsonl"),
-      fnnStdout: meta.fnnStdoutLogPath ?? join5(defaultDir, "fnn.stdout.log"),
-      fnnStderr: meta.fnnStderrLogPath ?? join5(defaultDir, "fnn.stderr.log")
+      runtimeAlerts: meta.alertLogFilePath ?? join7(defaultDir, "runtime.alerts.jsonl"),
+      fnnStdout: meta.fnnStdoutLogPath ?? join7(defaultDir, "fnn.stdout.log"),
+      fnnStderr: meta.fnnStderrLogPath ?? join7(defaultDir, "fnn.stderr.log")
     };
   }
   const dir = resolveLogDirForDateWithOptions(dataDir, void 0, {
@@ -2557,24 +3298,35 @@ function resolvePersistedLogPaths(dataDir, meta, date) {
     ensureExists: false
   });
   return {
-    runtimeAlerts: join5(dir, "runtime.alerts.jsonl"),
-    fnnStdout: join5(dir, "fnn.stdout.log"),
-    fnnStderr: join5(dir, "fnn.stderr.log")
+    runtimeAlerts: join7(dir, "runtime.alerts.jsonl"),
+    fnnStdout: join7(dir, "fnn.stdout.log"),
+    fnnStderr: join7(dir, "fnn.stderr.log")
   };
 }
 function listLogDates(dataDir, logsBaseDir) {
-  const logsDir = logsBaseDir ?? join5(dataDir, "logs");
+  const logsDir = logsBaseDir ?? join7(dataDir, "logs");
   if (!existsSync6(logsDir)) {
     return [];
   }
-  const entries = readdirSync(logsDir, { withFileTypes: true });
+  const entries = readdirSync2(logsDir, { withFileTypes: true });
   const dates = entries.filter((entry) => entry.isDirectory() && DATE_DIR_PATTERN.test(entry.name)).map((entry) => entry.name);
   dates.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
   return dates;
 }
-function appendToTodayLog(dataDir, filename, text) {
-  const dir = resolveLogDirForDate(dataDir);
-  appendFileSync(join5(dir, filename), text, "utf-8");
+var logWriters = /* @__PURE__ */ new Map();
+function getLogWriter(dataDir, filename) {
+  const key = `${dataDir}:${filename}`;
+  if (!logWriters.has(key)) {
+    logWriters.set(key, new LogWriter(dataDir, filename));
+  }
+  return logWriters.get(key);
+}
+async function appendToTodayLog(dataDir, filename, text) {
+  const writer = getLogWriter(dataDir, filename);
+  await writer.append(text);
+}
+async function flushPendingLogs() {
+  await Promise.all(Array.from(logWriters.values()).map((w) => w.flush()));
 }
 function resolvePersistedLogTargets(paths, source) {
   const all = [
@@ -2681,7 +3433,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);
@@ -3011,11 +3763,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 join6 } from "path";
+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",
@@ -3048,7 +3952,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);
@@ -3069,7 +3973,7 @@ function createLogsCommand(config) {
       process.exit(1);
     }
     if (listDates) {
-      const logsDir = meta?.logsBaseDir ?? join6(config.dataDir, "logs");
+      const logsDir = meta?.logsBaseDir ?? join8(config.dataDir, "logs");
       const dates = listLogDates(config.dataDir, logsDir);
       if (json) {
         printJsonSuccess({ dates, logsDir });
@@ -3303,7 +4207,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) {
@@ -3467,9 +4371,9 @@ 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 join7 } from "path";
+import { join as join9 } from "path";
 import {
   createKeyManager,
   ensureFiberBinary,
@@ -3478,12 +4382,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 [];
@@ -3512,7 +4416,7 @@ async function autoConnectBootnodes(rpc, bootnodes) {
 }
 
 // src/lib/node-migration.ts
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 import { BinaryManager as BinaryManager2, MigrationManager } from "@fiber-pay/node";
 
 // src/lib/migration-utils.ts
@@ -3536,7 +4440,7 @@ async function runMigrationGuard(opts) {
     return { checked: false, skippedReason: "store does not exist" };
   }
   const storePath = MigrationManager.resolveStorePath(dataDir);
-  const binaryDir = dirname2(binaryPath);
+  const binaryDir = dirname3(binaryPath);
   const bm = new BinaryManager2(binaryDir);
   const migrateBinPath = bm.getMigrateBinaryPath();
   let migrationCheck;
@@ -3738,7 +4642,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(),
@@ -3796,8 +4700,8 @@ async function runNodeStartCommand(config, options) {
     options.runtimeProxyListen ?? config.runtimeProxyListen ?? "127.0.0.1:8229"
   );
   const proxyListenSource = options.runtimeProxyListen ? "cli" : config.runtimeProxyListen ? "profile" : "default";
-  const runtimeStateFilePath = join7(config.dataDir, "runtime-state.json");
-  const logsBaseDir = join7(config.dataDir, "logs");
+  const runtimeStateFilePath = join9(config.dataDir, "runtime-state.json");
+  const logsBaseDir = join9(config.dataDir, "logs");
   mkdirSync3(logsBaseDir, { recursive: true });
   resolveLogDirForDate(config.dataDir);
   const resolvedBinary = resolveBinaryPath(config);
@@ -3872,11 +4776,13 @@ async function runNodeStartCommand(config, options) {
     removePidFile(config.dataDir);
   });
   processManager.on("stdout", (text) => {
-    appendToTodayLog(config.dataDir, "fnn.stdout.log", text);
+    appendToTodayLog(config.dataDir, "fnn.stdout.log", text).catch(() => {
+    });
     emitFnnLog("stdout", text);
   });
   processManager.on("stderr", (text) => {
-    appendToTodayLog(config.dataDir, "fnn.stderr.log", text);
+    appendToTodayLog(config.dataDir, "fnn.stderr.log", text).catch(() => {
+    });
     emitFnnLog("stderr", text);
   });
   await processManager.start();
@@ -3970,7 +4876,7 @@ async function runNodeStartCommand(config, options) {
         alerts: [{ type: "stdout" }, { type: "daily-file", baseLogsDir: logsBaseDir }],
         jobs: {
           enabled: true,
-          dbPath: join7(config.dataDir, "runtime-jobs.db")
+          dbPath: join9(config.dataDir, "runtime-jobs.db")
         }
       });
       const runtimeStatus = runtime.service.getStatus();
@@ -3982,9 +4888,9 @@ async function runNodeStartCommand(config, options) {
         fiberRpcUrl: runtimeStatus.targetUrl,
         proxyListen: runtimeStatus.proxyListen,
         stateFilePath: runtimeStateFilePath,
-        alertLogFilePath: join7(todayLogDir, "runtime.alerts.jsonl"),
-        fnnStdoutLogPath: join7(todayLogDir, "fnn.stdout.log"),
-        fnnStderrLogPath: join7(todayLogDir, "fnn.stderr.log"),
+        alertLogFilePath: join9(todayLogDir, "runtime.alerts.jsonl"),
+        fnnStdoutLogPath: join9(todayLogDir, "fnn.stdout.log"),
+        fnnStderrLogPath: join9(todayLogDir, "fnn.stderr.log"),
         logsBaseDir,
         daemon: false
       });
@@ -4055,7 +4961,7 @@ async function runNodeStartCommand(config, options) {
     process.exit(1);
   }
   emitStage("rpc_ready", "ok", { rpcUrl: config.rpcUrl });
-  const bootnodes = nodeConfig.configFilePath ? extractBootnodeAddrs(nodeConfig.configFilePath) : extractBootnodeAddrs(join7(config.dataDir, "config.yml"));
+  const bootnodes = nodeConfig.configFilePath ? extractBootnodeAddrs(nodeConfig.configFilePath) : extractBootnodeAddrs(join9(config.dataDir, "config.yml"));
   if (bootnodes.length > 0) {
     await autoConnectBootnodes(rpc, bootnodes);
   }
@@ -4117,6 +5023,23 @@ async function runNodeStartCommand(config, options) {
     if (!json) {
       console.log("\n\u{1F6D1} Shutting down...");
     }
+    let flushTimeout;
+    try {
+      await Promise.race([
+        flushPendingLogs(),
+        new Promise((_, reject) => {
+          flushTimeout = setTimeout(() => reject(new Error("Flush timeout")), 5e3);
+        })
+      ]);
+    } catch (_err) {
+      if (!json) {
+        console.log("\u26A0\uFE0F Log flush timed out, continuing shutdown...");
+      }
+    } finally {
+      if (flushTimeout !== void 0) {
+        clearTimeout(flushTimeout);
+      }
+    }
     if (runtimeDaemon) {
       stopRuntimeDaemonFromNode({ dataDir: config.dataDir, rpcUrl: config.rpcUrl });
     } else if (runtime) {
@@ -5003,7 +5926,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);
   });
@@ -5033,9 +5956,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);
@@ -5369,7 +6292,7 @@ function getJobFailure(job) {
 }
 
 // src/commands/peer.ts
-import { Command as Command10 } from "commander";
+import { Command as Command12 } from "commander";
 function extractPeerIdFromMultiaddr(address) {
   const match = address.match(/\/p2p\/([^/]+)$/);
   return match?.[1];
@@ -5386,7 +6309,7 @@ async function waitForPeerConnected(rpc, peerId, timeoutMs) {
   return false;
 }
 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();
@@ -5432,8 +6355,8 @@ function createPeerCommand(config) {
 }
 
 // src/commands/runtime.ts
-import { spawn as spawn2 } from "child_process";
-import { join as join8, resolve } from "path";
+import { spawn as spawn3 } from "child_process";
+import { join as join10, resolve } from "path";
 import {
   alertPriorityOrder,
   formatRuntimeAlert as formatRuntimeAlert2,
@@ -5441,7 +6364,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) {
@@ -5512,7 +6435,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)"
@@ -5570,7 +6493,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(),
@@ -5662,7 +6585,7 @@ function createRuntimeCommand(config) {
         logsBaseDir,
         ensureExists: false
       });
-      const effectiveAlertLogPath = alertLogsBaseDir ? join8(todayLogDir, "runtime.alerts.jsonl") : alertLogFile ?? join8(todayLogDir, "runtime.alerts.jsonl");
+      const effectiveAlertLogPath = alertLogsBaseDir ? join10(todayLogDir, "runtime.alerts.jsonl") : alertLogFile ?? join10(todayLogDir, "runtime.alerts.jsonl");
       writeRuntimePid(config.dataDir, process.pid);
       writeRuntimeMeta(config.dataDir, {
         pid: process.pid,
@@ -5671,8 +6594,8 @@ function createRuntimeCommand(config) {
         proxyListen: status.proxyListen,
         stateFilePath: runtimeConfig.storage?.stateFilePath,
         alertLogFilePath: effectiveAlertLogPath,
-        fnnStdoutLogPath: join8(todayLogDir, "fnn.stdout.log"),
-        fnnStderrLogPath: join8(todayLogDir, "fnn.stderr.log"),
+        fnnStdoutLogPath: join10(todayLogDir, "fnn.stdout.log"),
+        fnnStderrLogPath: join10(todayLogDir, "fnn.stderr.log"),
         logsBaseDir,
         daemon: daemon || isRuntimeChild
       });
@@ -5921,15 +6844,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-rc.7";
-var CLI_COMMIT = "f71c561d8f423b9c88b79f5568dc1c6f9fbc93e3";
+var CLI_VERSION = "0.1.1";
+var CLI_COMMIT = "4b099d434842d019d12ba4df4031314860de25be";
 
 // 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
@@ -5944,7 +6867,7 @@ function createVersionCommand() {
 }
 
 // src/commands/wallet.ts
-import { Command as Command13 } from "commander";
+import { Command as Command15, Option } from "commander";
 
 // src/lib/wallet-address.ts
 import { scriptToAddress as scriptToAddress2 } from "@fiber-pay/sdk";
@@ -5959,6 +6882,14 @@ async function runWalletAddressCommand(config, options) {
     printJsonSuccess({ address });
     return;
   }
+  if (options.qrcode) {
+    const qrcode = await import("qrcode");
+    console.log("\u2705 Funding address retrieved\n");
+    const qrString = await qrcode.toString(address, { type: "terminal", small: true });
+    console.log(qrString);
+    console.log(`  ${truncateMiddle(address, 8, 6)}`);
+    return;
+  }
   console.log("\u2705 Funding address retrieved");
   console.log(`  Address: ${address}`);
 }
@@ -5991,8 +6922,8 @@ async function runWalletBalanceCommand(config, options) {
 
 // src/commands/wallet.ts
 function createWalletCommand(config) {
-  const wallet = new Command13("wallet").description("Wallet management");
-  wallet.command("address").description("Display the funding address").option("--json").action(async (options) => {
+  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);
   });
   wallet.command("balance").description("Display the CKB balance").option("--json").action(async (options) => {
@@ -6138,7 +7069,7 @@ function applyGlobalOverrides(argv) {
   }
   if (!explicitDataDir && profileName) {
     const homeDir = process.env.HOME ?? process.cwd();
-    process.env.FIBER_DATA_DIR = join9(homeDir, ".fiber-pay", "profiles", profileName);
+    process.env.FIBER_DATA_DIR = join11(homeDir, ".fiber-pay", "profiles", profileName);
   }
 }
 function printFatal(error) {
@@ -6166,7 +7097,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({
@@ -6178,6 +7109,7 @@ async function main() {
     }
   });
   program.addCommand(createNodeCommand(config));
+  program.addCommand(createAgentCommand(config));
   program.addCommand(createChannelCommand(config));
   program.addCommand(createInvoiceCommand(config));
   program.addCommand(createPaymentCommand(config));
@@ -6187,6 +7119,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));