@fiber-pay/cli 0.1.0-rc.1

package/dist/cli.js

@@ -0,0 +1,4647 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { join as join7 } from "path";
+import { Command as Command13 } from "commander";
+
+// src/commands/binary.ts
+import {
+  DEFAULT_FIBER_VERSION,
+  downloadFiberBinary,
+  getFiberBinaryInfo
+} from "@fiber-pay/node";
+import { Command } from "commander";
+
+// src/lib/format.ts
+import {
+  ChannelState,
+  shannonsToCkb,
+  toHex
+} from "@fiber-pay/sdk";
+function truncateMiddle(value, start = 10, end = 8) {
+  if (!value || value.length <= start + end + 3) {
+    return value;
+  }
+  return `${value.slice(0, start)}...${value.slice(-end)}`;
+}
+function parseHexTimestampMs(hexTimestamp) {
+  if (!hexTimestamp) return null;
+  try {
+    const raw = Number(BigInt(hexTimestamp));
+    if (!Number.isFinite(raw) || raw <= 0) return null;
+    return raw > 1e12 ? raw : raw * 1e3;
+  } catch {
+    return null;
+  }
+}
+function formatAge(whenMs) {
+  if (!whenMs) return "unknown";
+  const diff = Date.now() - whenMs;
+  if (diff < 0) return "just now";
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ${minutes % 60}m ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ${hours % 24}h ago`;
+}
+function stateLabel(state) {
+  switch (state) {
+    case ChannelState.NegotiatingFunding:
+      return "\u{1F504} Negotiating Funding";
+    case ChannelState.CollaboratingFundingTx:
+      return "\u{1F9E9} Collaborating Funding Tx";
+    case ChannelState.SigningCommitment:
+      return "\u270D\uFE0F Signing Commitment";
+    case ChannelState.AwaitingTxSignatures:
+      return "\u23F3 Awaiting Tx Signatures";
+    case ChannelState.AwaitingChannelReady:
+      return "\u23F3 Awaiting Channel Ready";
+    case ChannelState.ChannelReady:
+      return "\u2705 Channel Ready";
+    case ChannelState.ShuttingDown:
+      return "\u{1F6D1} Shutting Down";
+    case ChannelState.Closed:
+      return "\u274C Closed";
+    default:
+      return state;
+  }
+}
+function parseChannelState(input) {
+  if (!input) return void 0;
+  const trimmed = input.trim();
+  const legacy = trimmed.toUpperCase();
+  const normalizedInput = trimmed.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+  const legacyMap = {
+    NEGOTIATING_FUNDING: ChannelState.NegotiatingFunding,
+    COLLABORATING_FUNDING_TX: ChannelState.CollaboratingFundingTx,
+    SIGNING_COMMITMENT: ChannelState.SigningCommitment,
+    AWAITING_TX_SIGNATURES: ChannelState.AwaitingTxSignatures,
+    AWAITING_CHANNEL_READY: ChannelState.AwaitingChannelReady,
+    CHANNEL_READY: ChannelState.ChannelReady,
+    SHUTTING_DOWN: ChannelState.ShuttingDown,
+    CLOSED: ChannelState.Closed
+  };
+  if (legacy in legacyMap) return legacyMap[legacy];
+  for (const value of Object.values(ChannelState)) {
+    const normalizedValue = value.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+    if (normalizedValue === normalizedInput) return value;
+  }
+  return void 0;
+}
+function formatChannel(channel) {
+  const local = BigInt(channel.local_balance);
+  const remote = BigInt(channel.remote_balance);
+  const capacity = local + remote;
+  const localPct = capacity > 0n ? Number(local * 100n / capacity) : 0;
+  const remotePct = capacity > 0n ? 100 - localPct : 0;
+  return {
+    channelId: channel.channel_id,
+    channelIdShort: truncateMiddle(channel.channel_id, 10, 8),
+    peerId: channel.peer_id,
+    peerIdShort: truncateMiddle(channel.peer_id, 10, 8),
+    state: channel.state.state_name,
+    stateLabel: stateLabel(channel.state.state_name),
+    stateFlags: channel.state.state_flags,
+    localBalanceCkb: shannonsToCkb(channel.local_balance),
+    remoteBalanceCkb: shannonsToCkb(channel.remote_balance),
+    capacityCkb: shannonsToCkb(toHex(capacity)),
+    balanceRatio: `${localPct}/${remotePct}`,
+    pendingTlcs: channel.pending_tlcs.length,
+    enabled: channel.enabled,
+    isPublic: channel.is_public,
+    age: formatAge(parseHexTimestampMs(channel.created_at))
+  };
+}
+function getChannelSummary(channels) {
+  let totalLocal = 0n;
+  let totalRemote = 0n;
+  let active = 0;
+  for (const channel of channels) {
+    totalLocal += BigInt(channel.local_balance);
+    totalRemote += BigInt(channel.remote_balance || "0x0");
+    if (channel.state.state_name === ChannelState.ChannelReady) {
+      active++;
+    }
+  }
+  return {
+    count: channels.length,
+    activeCount: active,
+    totalLocalCkb: shannonsToCkb(toHex(totalLocal)),
+    totalRemoteCkb: shannonsToCkb(toHex(totalRemote)),
+    totalCapacityCkb: shannonsToCkb(toHex(totalLocal + totalRemote))
+  };
+}
+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) {
+      try {
+        expirySeconds = Number(BigInt(attr.ExpiryTime));
+      } catch {
+      }
+    }
+  }
+  const createdMs = parseHexTimestampMs(invoice.data.timestamp);
+  const expiresAt = createdMs && expirySeconds ? new Date(createdMs + expirySeconds * 1e3).toISOString() : void 0;
+  return {
+    description,
+    expirySeconds,
+    expiresAt,
+    age: formatAge(createdMs)
+  };
+}
+function formatPaymentResult(payment) {
+  const createdAtMs = parseHexTimestampMs(payment.created_at);
+  const updatedAtMs = parseHexTimestampMs(payment.last_updated_at);
+  return {
+    paymentHash: payment.payment_hash,
+    status: payment.status,
+    feeCkb: shannonsToCkb(payment.fee),
+    failureReason: payment.failed_error,
+    createdAt: createdAtMs ? new Date(createdAtMs).toISOString() : payment.created_at,
+    updatedAt: updatedAtMs ? new Date(updatedAtMs).toISOString() : payment.last_updated_at,
+    routeCount: payment.routers?.length ?? 0,
+    routers: payment.routers
+  };
+}
+function printJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+function printJsonSuccess(data) {
+  printJson({ success: true, data });
+}
+function printJsonError(error) {
+  printJson({ success: false, error });
+}
+function printJsonEvent(event, data, ts = (/* @__PURE__ */ new Date()).toISOString()) {
+  process.stdout.write(`${JSON.stringify({ event, ts, data })}
+`);
+}
+function printChannelDetailHuman(channel) {
+  const local = shannonsToCkb(channel.local_balance);
+  const remote = shannonsToCkb(channel.remote_balance);
+  const capacity = local + remote;
+  console.log("Channel");
+  console.log(`  ID:            ${channel.channel_id}`);
+  console.log(`  Peer:          ${channel.peer_id}`);
+  console.log(
+    `  State:         ${stateLabel(channel.state.state_name)} (${channel.state.state_name})`
+  );
+  console.log(`  Enabled:       ${channel.enabled ? "yes" : "no"}`);
+  console.log(`  Public:        ${channel.is_public ? "yes" : "no"}`);
+  console.log(
+    `  Balance:       local ${local} CKB | remote ${remote} CKB | capacity ${capacity} CKB`
+  );
+  console.log(`  Pending TLCs:  ${channel.pending_tlcs.length}`);
+  console.log(`  Age:           ${formatAge(parseHexTimestampMs(channel.created_at))}`);
+  console.log(
+    `  Outpoint:      ${channel.channel_outpoint ? `${channel.channel_outpoint.tx_hash}:${channel.channel_outpoint.index}` : "n/a"}`
+  );
+  console.log(`  Commitment Tx: ${channel.latest_commitment_transaction_hash ?? "n/a"}`);
+  console.log(`  Shutdown Tx:   ${channel.shutdown_transaction_hash ?? "n/a"}`);
+}
+function printInvoiceDetailHuman(data) {
+  console.log("Invoice");
+  console.log(`  Payment Hash:  ${data.paymentHash}`);
+  console.log(`  Status:        ${data.status}`);
+  console.log(
+    `  Amount:        ${data.amountCkb ?? "n/a"} ${data.amountCkb !== void 0 ? "CKB" : ""}`.trim()
+  );
+  console.log(`  Currency:      ${data.currency}`);
+  console.log(`  Description:   ${data.description ?? "n/a"}`);
+  console.log(`  Created At:    ${data.createdAt}`);
+  console.log(`  Expires At:    ${data.expiresAt ?? "n/a"}`);
+  console.log(`  Age:           ${data.age}`);
+  console.log(`  Invoice:       ${data.invoice}`);
+}
+function printPaymentDetailHuman(payment) {
+  const createdAtMs = parseHexTimestampMs(payment.created_at);
+  const updatedAtMs = parseHexTimestampMs(payment.last_updated_at);
+  console.log("Payment");
+  console.log(`  Hash:          ${payment.payment_hash}`);
+  console.log(`  Status:        ${payment.status}`);
+  console.log(`  Fee:           ${shannonsToCkb(payment.fee)} CKB`);
+  console.log(`  Failure:       ${payment.failed_error ?? "n/a"}`);
+  console.log(
+    `  Created At:    ${createdAtMs ? new Date(createdAtMs).toISOString() : payment.created_at}`
+  );
+  console.log(
+    `  Updated At:    ${updatedAtMs ? new Date(updatedAtMs).toISOString() : payment.last_updated_at}`
+  );
+  const routers = payment.routers ?? [];
+  console.log(`  Routes:        ${routers.length}`);
+  if (routers.length > 0) {
+    for (let i = 0; i < routers.length; i++) {
+      const hops = routers[i].nodes.map((node) => truncateMiddle(node.pubkey, 8, 8)).join(" -> ");
+      console.log(`    #${i + 1}: ${hops}`);
+    }
+  }
+}
+function printChannelListHuman(channels) {
+  if (channels.length === 0) {
+    console.log("No channels found.");
+    return;
+  }
+  const summary = getChannelSummary(channels);
+  console.log(`Channels: ${summary.count} total, ${summary.activeCount} ready`);
+  console.log(
+    `Liquidity: local ${summary.totalLocalCkb} CKB | remote ${summary.totalRemoteCkb} CKB | capacity ${summary.totalCapacityCkb} CKB`
+  );
+  console.log("");
+  console.log(
+    "ID                     PEER                   STATE                     LOCAL      REMOTE     TLC"
+  );
+  console.log(
+    "---------------------------------------------------------------------------------------------------"
+  );
+  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 state = channel.state.state_name.padEnd(24, " ");
+    const local = `${shannonsToCkb(channel.local_balance)}`.padStart(8, " ");
+    const remote = `${shannonsToCkb(channel.remote_balance)}`.padStart(8, " ");
+    const tlcs = `${channel.pending_tlcs.length}`.padStart(4, " ");
+    console.log(`${id} ${peer} ${state} ${local} ${remote} ${tlcs}`);
+  }
+}
+function printPeerListHuman(peers) {
+  if (peers.length === 0) {
+    console.log("No connected peers.");
+    return;
+  }
+  console.log(`Peers: ${peers.length}`);
+  console.log("");
+  console.log("PEER ID                 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}`);
+  }
+}
+function printNodeInfoHuman(data) {
+  console.log("Node Info");
+  console.log(`  Node ID:              ${data.nodeId}`);
+  console.log(`  Version:              ${data.version}`);
+  console.log(`  Chain Hash:           ${data.chainHash}`);
+  console.log(`  Funding Address:      ${data.fundingAddress}`);
+  console.log(`  Channels:             ${data.channelCount} (${data.pendingChannelCount} pending)`);
+  console.log(`  Peers:                ${data.peersCount}`);
+  if (data.addresses.length > 0) {
+    console.log("  Addresses:");
+    for (const addr of data.addresses) {
+      console.log(`    - ${addr}`);
+    }
+  }
+}
+
+// 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 info = await downloadFiberBinary({
+      installDir: `${config.dataDir}/bin`,
+      version: options.version,
+      force: Boolean(options.force),
+      onProgress: options.json ? void 0 : showProgress
+    });
+    if (options.json) {
+      printJsonSuccess(info);
+    } 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 info = await getFiberBinaryInfo(`${config.dataDir}/bin`);
+    if (options.json) {
+      printJsonSuccess(info);
+    } 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 } 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, 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 });
+}
+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 {
+    const response = await fetch(`${runtimeUrl}/jobs/payment`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function tryCreateRuntimeChannelJob(runtimeUrl, body) {
+  try {
+    const response = await fetch(`${runtimeUrl}/jobs/channel`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function tryCreateRuntimeInvoiceJob(runtimeUrl, body) {
+  try {
+    const response = await fetch(`${runtimeUrl}/jobs/invoice`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function waitForRuntimeJobTerminal(runtimeUrl, jobId, timeoutSeconds) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutSeconds * 1e3) {
+    const response = await fetch(`${runtimeUrl}/jobs/${jobId}`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch runtime job ${jobId}: ${response.status}`);
+    }
+    const job = await response.json();
+    if (job.state === "succeeded" || job.state === "failed" || job.state === "cancelled") {
+      return job;
+    }
+    await sleep(500);
+  }
+  throw new Error(`Timed out waiting for runtime job ${jobId}`);
+}
+
+// src/commands/channel.ts
+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("--raw").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) }
+    );
+    const channels = stateFilter ? response.channels.filter((item) => item.state.state_name === stateFilter) : response.channels;
+    if (options.raw || options.json) {
+      printJsonSuccess({ channels, count: channels.length });
+    } else {
+      printChannelListHuman(channels);
+    }
+  });
+  channel.command("get").argument("<channelId>").option("--raw").option("--json").action(async (channelId, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const response = await rpc.listChannels({ include_closed: true });
+    const found = response.channels.find((item) => item.channel_id === channelId);
+    if (!found) {
+      if (options.json) {
+        printJsonError({
+          code: "CHANNEL_NOT_FOUND",
+          message: `Channel not found: ${channelId}`,
+          recoverable: true,
+          suggestion: "List channels first and retry with a valid channel id.",
+          details: { channelId }
+        });
+      } else {
+        console.error(`Error: Channel not found: ${channelId}`);
+      }
+      process.exit(1);
+    }
+    if (options.raw || options.json) {
+      printJsonSuccess(found);
+    } else {
+      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) => {
+    const intervalSeconds = parseInt(options.interval, 10);
+    const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : void 0;
+    const onTimeout = String(options.onTimeout ?? "fail").trim().toLowerCase();
+    const stateFilter = parseChannelState(options.state);
+    const untilState = parseChannelState(options.until);
+    const noClear = Boolean(options.noClear);
+    const json = Boolean(options.json);
+    if (!["fail", "success"].includes(onTimeout)) {
+      if (json) {
+        printJsonError({
+          code: "CHANNEL_WATCH_INPUT_INVALID",
+          message: `Invalid --on-timeout value: ${options.onTimeout}. Expected fail or success`,
+          recoverable: true,
+          suggestion: "Use `--on-timeout fail` or `--on-timeout success`.",
+          details: { provided: options.onTimeout, expected: ["fail", "success"] }
+        });
+      } else {
+        console.error(
+          `Error: Invalid --on-timeout value: ${options.onTimeout}. Expected fail or success`
+        );
+      }
+      process.exit(1);
+    }
+    const rpc = await createReadyRpcClient(config);
+    const startedAt = Date.now();
+    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) }
+      );
+      let channels = response.channels;
+      if (options.channel) {
+        channels = channels.filter((item) => item.channel_id === options.channel);
+      }
+      if (stateFilter) {
+        channels = channels.filter((item) => item.state.state_name === stateFilter);
+      }
+      const stateChanges = [];
+      for (const ch of channels) {
+        const prev = previousStates.get(ch.channel_id);
+        if (prev && prev !== ch.state.state_name) {
+          stateChanges.push({ channelId: ch.channel_id, from: prev, to: ch.state.state_name });
+        }
+        previousStates.set(ch.channel_id, ch.state.state_name);
+      }
+      if (json) {
+        printJsonEvent("snapshot", {
+          channels: channels.map(formatChannel),
+          summary: getChannelSummary(channels)
+        });
+        for (const change of stateChanges) {
+          printJsonEvent("state_change", {
+            channelId: change.channelId,
+            from: change.from,
+            to: change.to
+          });
+        }
+      } else {
+        if (!noClear) {
+          console.clear();
+        }
+        console.log(`\u23F1\uFE0F  Channel monitor - ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        console.log(
+          `   Refresh: ${intervalSeconds}s${timeoutSeconds ? ` | Timeout: ${timeoutSeconds}s` : ""}${untilState ? ` | Until: ${untilState}` : ""}`
+        );
+        if (stateChanges.length > 0) {
+          console.log("\n\u{1F514} State changes:");
+          for (const change of stateChanges) {
+            console.log(`   ${truncateMiddle(change.channelId)}: ${change.from} -> ${change.to}`);
+          }
+        }
+        printChannelListHuman(channels);
+      }
+      if (untilState && channels.some((item) => item.state.state_name === untilState)) {
+        if (json) {
+          printJsonEvent("terminal", { reason: "target_state_reached", untilState });
+        } else {
+          console.log(`
+\u2705 Target state reached: ${untilState}`);
+        }
+        return;
+      }
+      if (timeoutSeconds !== void 0 && Date.now() - startedAt >= timeoutSeconds * 1e3) {
+        if (onTimeout === "success") {
+          if (json) {
+            printJsonEvent("terminal", {
+              reason: "timeout",
+              timeoutSeconds
+            });
+          } else {
+            console.log("\n\u23F0 Monitor timeout reached (treated as success).");
+          }
+          return;
+        }
+        if (json) {
+          printJsonError({
+            code: "CHANNEL_WATCH_TIMEOUT",
+            message: `Channel monitor timed out after ${timeoutSeconds}s`,
+            recoverable: true,
+            suggestion: "Increase timeout or continue monitoring with another watch run.",
+            details: { timeoutSeconds }
+          });
+          process.exit(1);
+        }
+        console.log("\n\u23F0 Monitor timeout reached.");
+        return;
+      }
+      await sleep(intervalSeconds * 1e3);
+    }
+  });
+  channel.command("open").requiredOption("--peer <peerIdOrMultiaddr>").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) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const peerInput = options.peer;
+    const fundingCkb = parseFloat(options.funding);
+    let peerId = peerInput;
+    if (peerInput.includes("/")) {
+      await rpc.connectPeer({ address: peerInput });
+      const peerIdMatch = peerInput.match(/\/p2p\/([^/]+)/);
+      if (peerIdMatch) peerId = peerIdMatch[1];
+    }
+    const idempotencyKey = typeof options.idempotencyKey === "string" && options.idempotencyKey.trim().length > 0 ? options.idempotencyKey.trim() : `open:${peerId}:${randomUUID()}`;
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeChannelJob(endpoint.url, {
+        params: {
+          action: "open",
+          peerId,
+          openChannelParams: {
+            peer_id: peerId,
+            funding_amount: ckbToShannons(fundingCkb),
+            public: !options.private
+          },
+          waitForReady: false
+        },
+        options: {
+          idempotencyKey,
+          reuseTerminal: false
+        }
+      });
+      if (created) {
+        const payload2 = {
+          jobId: created.id,
+          jobState: created.state,
+          peer: peerId,
+          fundingCkb,
+          idempotencyKey
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log("Channel open job submitted");
+          console.log(`  Job:                  ${payload2.jobId}`);
+          console.log(`  Job State:            ${payload2.jobState}`);
+          console.log(`  Peer:                 ${payload2.peer}`);
+          console.log(`  Funding:              ${payload2.fundingCkb} CKB`);
+          console.log(`  Idempotency Key:      ${payload2.idempotencyKey}`);
+        }
+        return;
+      }
+    }
+    const result = await rpc.openChannel({
+      peer_id: peerId,
+      funding_amount: ckbToShannons(fundingCkb),
+      public: !options.private
+    });
+    const payload = { temporaryChannelId: result.temporary_channel_id, peer: peerId, fundingCkb };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log("Channel open initiated");
+      console.log(`  Temporary Channel ID: ${payload.temporaryChannelId}`);
+      console.log(`  Peer:                 ${payload.peer}`);
+      console.log(`  Funding:              ${payload.fundingCkb} CKB`);
+    }
+  });
+  channel.command("accept").argument("<temporaryChannelId>").requiredOption("--funding <ckb>").option("--json").action(async (temporaryChannelId, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const fundingCkb = parseFloat(options.funding);
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeChannelJob(endpoint.url, {
+        params: {
+          action: "accept",
+          acceptChannelParams: {
+            temporary_channel_id: temporaryChannelId,
+            funding_amount: ckbToShannons(fundingCkb)
+          }
+        },
+        options: {
+          idempotencyKey: `accept:temporary:${temporaryChannelId}`
+        }
+      });
+      if (created) {
+        const payload2 = {
+          jobId: created.id,
+          jobState: created.state,
+          temporaryChannelId,
+          fundingCkb
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log("Channel accept job submitted");
+          console.log(`  Job:                  ${payload2.jobId}`);
+          console.log(`  Job State:            ${payload2.jobState}`);
+          console.log(`  Temporary Channel ID: ${payload2.temporaryChannelId}`);
+          console.log(`  Funding:              ${payload2.fundingCkb} CKB`);
+        }
+        return;
+      }
+    }
+    const result = await rpc.acceptChannel({
+      temporary_channel_id: temporaryChannelId,
+      funding_amount: ckbToShannons(fundingCkb)
+    });
+    const payload = { channelId: result.channel_id, temporaryChannelId, fundingCkb };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log("Channel accepted");
+      console.log(`  Channel ID:           ${payload.channelId}`);
+      console.log(`  Temporary Channel ID: ${payload.temporaryChannelId}`);
+      console.log(`  Funding:              ${payload.fundingCkb} CKB`);
+    }
+  });
+  channel.command("close").argument("<channelId>").option("--force").option("--json").action(async (channelId, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeChannelJob(endpoint.url, {
+        params: {
+          action: "shutdown",
+          channelId,
+          shutdownChannelParams: {
+            channel_id: channelId,
+            force: Boolean(options.force)
+          },
+          waitForClosed: false
+        },
+        options: {
+          idempotencyKey: `shutdown:channel:${channelId}`
+        }
+      });
+      if (created) {
+        const payload2 = {
+          jobId: created.id,
+          jobState: created.state,
+          channelId,
+          force: Boolean(options.force),
+          message: options.force ? "Channel force close job submitted" : "Channel close job submitted"
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log(payload2.message);
+          console.log(`  Job:        ${payload2.jobId}`);
+          console.log(`  Job State:  ${payload2.jobState}`);
+          console.log(`  Channel ID: ${payload2.channelId}`);
+        }
+        return;
+      }
+    }
+    await rpc.shutdownChannel({
+      channel_id: channelId,
+      force: Boolean(options.force)
+    });
+    const payload = {
+      channelId,
+      force: Boolean(options.force),
+      message: options.force ? "Channel force close initiated" : "Channel close initiated"
+    };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log(payload.message);
+      console.log(`  Channel ID: ${payload.channelId}`);
+    }
+  });
+  channel.command("abandon").argument("<channelId>").option("--json").action(async (channelId, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeChannelJob(endpoint.url, {
+        params: {
+          action: "abandon",
+          channelId,
+          abandonChannelParams: {
+            channel_id: channelId
+          }
+        },
+        options: {
+          idempotencyKey: `abandon:channel:${channelId}`
+        }
+      });
+      if (created) {
+        const payload2 = {
+          jobId: created.id,
+          jobState: created.state,
+          channelId,
+          message: "Channel abandon job submitted."
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log(payload2.message);
+          console.log(`  Job:        ${payload2.jobId}`);
+          console.log(`  Job State:  ${payload2.jobState}`);
+          console.log(`  Channel ID: ${payload2.channelId}`);
+        }
+        return;
+      }
+    }
+    await rpc.abandonChannel({ channel_id: channelId });
+    const payload = { channelId, message: "Channel abandoned." };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log(payload.message);
+      console.log(`  Channel ID: ${payload.channelId}`);
+    }
+  });
+  channel.command("update").argument("<channelId>").option("--enabled <enabled>").option("--tlc-expiry-delta <ms>").option("--tlc-minimum-value <shannonsHex>").option("--tlc-fee-proportional-millionths <value>").option("--json").action(async (channelId, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const updateParams = {
+      channel_id: channelId,
+      enabled: options.enabled !== void 0 ? options.enabled === "true" : void 0,
+      tlc_expiry_delta: options.tlcExpiryDelta,
+      tlc_minimum_value: options.tlcMinimumValue,
+      tlc_fee_proportional_millionths: options.tlcFeeProportionalMillionths
+    };
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeChannelJob(endpoint.url, {
+        params: {
+          action: "update",
+          channelId,
+          updateChannelParams: updateParams
+        },
+        options: {
+          reuseTerminal: false
+        }
+      });
+      if (created) {
+        const payload2 = {
+          jobId: created.id,
+          jobState: created.state,
+          channelId,
+          message: "Channel update job submitted."
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log(payload2.message);
+          console.log(`  Job:        ${payload2.jobId}`);
+          console.log(`  Job State:  ${payload2.jobState}`);
+          console.log(`  Channel ID: ${payload2.channelId}`);
+        }
+        return;
+      }
+    }
+    await rpc.updateChannel(updateParams);
+    const payload = { channelId, message: "Channel updated." };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log(payload.message);
+      console.log(`  Channel ID: ${payload.channelId}`);
+    }
+  });
+  return channel;
+}
+
+// src/commands/config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { Command as Command3 } from "commander";
+import { parseDocument, stringify as yamlStringify } from "yaml";
+
+// src/lib/config.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/lib/config-templates.ts
+var TESTNET_CONFIG_TEMPLATE_V061 = `# This configuration file only contains the necessary configurations for the testnet deployment.
+# All options' descriptions can be found via \`fnn --help\` and be overridden by command line arguments or environment variables.
+fiber:
+  listening_addr: "/ip4/127.0.0.1/tcp/8228"
+  bootnode_addrs:
+    - "/ip4/54.179.226.154/tcp/8228/p2p/Qmes1EBD4yNo9Ywkfe6eRw9tG1nVNGLDmMud1xJMsoYFKy"
+    - "/ip4/54.179.226.154/tcp/18228/p2p/QmdyQWjPtbK4NWWsvy8s69NGJaQULwgeQDT5ZpNDrTNaeV"
+  announce_listening_addr: true
+  announced_addrs:
+    # If you want to announce your fiber node public address to the network, you need to add the address here, please change the ip to your public ip accordingly.
+    # - "/ip4/YOUR-FIBER-NODE-PUBLIC-IP/tcp/8228"
+  chain: testnet
+  # lock script configurations related to fiber network
+  # https://github.com/nervosnetwork/fiber-scripts/blob/main/deployment/testnet/migrations/2025-02-28-111246.json
+  scripts:
+    - name: FundingLock
+      script:
+        code_hash: "0x6c67887fe201ee0c7853f1682c0b77c0e6214044c156c7558269390a8afa6d7c"
+        hash_type: type
+        args: "0x"
+      cell_deps:
+        - type_id:
+            code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            hash_type: type
+            args: "0x3cb7c0304fe53f75bb5727e2484d0beae4bd99d979813c6fc97c3cca569f10f6"
+        - cell_dep:
+            out_point:
+              tx_hash: "0x12c569a258dd9c5bd99f632bb8314b1263b90921ba31496467580d6b79dd14a7" # ckb_auth
+              index: 0x0
+            dep_type: code
+    - name: CommitmentLock
+      script:
+        code_hash: "0x740dee83f87c6f309824d8fd3fbdd3c8380ee6fc9acc90b1a748438afcdf81d8"
+        hash_type: type
+        args: "0x"
+      cell_deps:
+        - type_id:
+            code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            hash_type: type
+            args: "0xf7e458887495cf70dd30d1543cad47dc1dfe9d874177bf19291e4db478d5751b"
+        - cell_dep:
+            out_point:
+              tx_hash: "0x12c569a258dd9c5bd99f632bb8314b1263b90921ba31496467580d6b79dd14a7" #ckb_auth
+              index: 0x0
+            dep_type: code
+
+rpc:
+  # By default RPC only binds to localhost, thus it only allows accessing from the same machine.
+  # Allowing arbitrary machines to access the JSON-RPC port is dangerous and strongly discouraged.
+  # Please strictly limit the access to only trusted machines.
+  listening_addr: "127.0.0.1:8227"
+
+ckb:
+  rpc_url: "https://testnet.ckbapp.dev/"
+  udt_whitelist:
+    - name: RUSD
+      script:
+        code_hash: "0x1142755a044bf2ee358cba9f2da187ce928c91cd4dc8692ded0337efa677d21a"
+        hash_type: type
+        args: "0x878fcc6f1f08d48e87bb1c3b3d5083f23f8a39c5d5c764f253b55b998526439b"
+      cell_deps:
+        - type_id:
+            code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            hash_type: type
+            args: "0x97d30b723c0b2c66e9cb8d4d0df4ab5d7222cbb00d4a9a2055ce2e5d7f0d8b0f"
+      auto_accept_amount: 1000000000
+
+services:
+  - fiber
+  - rpc
+  - ckb
+`;
+var MAINNET_CONFIG_TEMPLATE_V061 = `# This configuration file only contains the necessary configurations for the mainnet deployment.
+# All options' descriptions can be found via \`fnn --help\` and be overridden by command line arguments or environment variables.
+fiber:
+  listening_addr: "/ip4/0.0.0.0/tcp/8228"
+  bootnode_addrs:
+    - "/ip4/43.199.24.44/tcp/8228/p2p/QmZ2gCTfEF6vKsiYFF2STPeA2rRLRim9nMtzfwiE7uMQ4v"
+    - "/ip4/54.255.71.126/tcp/8228/p2p/QmcMLnWraRyxd7PFRgvn1QeYRQS2DGsP6fPFCQjtfMs5b2"
+  announce_listening_addr: true
+  announced_addrs:
+    # If you want to announce your fiber node public address to the network, you need to add the address here.
+    # Please change the ip to your public ip accordingly, and make sure the port is open and reachable from the internet.
+    # - "/ip4/YOUR-FIBER-NODE-PUBLIC-IP/tcp/8228"
+  chain: mainnet
+  # lock script configurations related to fiber network
+  # https://github.com/nervosnetwork/fiber-scripts/blob/main/deployment/mainnet/migrations/2025-02-28-114908.json
+  scripts:
+    - name: FundingLock
+      script:
+        code_hash: "0xe45b1f8f21bff23137035a3ab751d75b36a981deec3e7820194b9c042967f4f1"
+        hash_type: type
+        args: "0x"
+      cell_deps:
+        - type_id:
+            code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            hash_type: type
+            args: "0x64818d82a372312fb007c480391e1b9759d21b2c7f7959b9c177d72cdc243394"
+        - cell_dep:
+            out_point:
+              tx_hash: "0x95006eee7b4c0c8ad66e0514c88ed0ae43fc8db27793427de86a348ec720b9d6" # ckb_auth
+              index: 0x0
+            dep_type: code
+    - name: CommitmentLock
+      script:
+        code_hash: "0x2d45c4d3ed3e942f1945386ee82a5d1b7e4bb16d7fe1ab015421174ab747406c"
+        hash_type: type
+        args: "0x"
+      cell_deps:
+        - type_id:
+            code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            hash_type: type
+            args: "0xdb16e6dcb17f670e5fb7c556d81e522ec5edb069ad2fa3e898e7ccea6c26a39f"
+        - cell_dep:
+            out_point:
+              tx_hash: "0x95006eee7b4c0c8ad66e0514c88ed0ae43fc8db27793427de86a348ec720b9d6" #ckb_auth
+              index: 0x0
+            dep_type: code
+
+rpc:
+  # By default RPC only binds to localhost, thus it only allows accessing from the same machine.
+  # Allowing arbitrary machines to access the JSON-RPC port is dangerous and strongly discouraged.
+  # Please strictly limit the access to only trusted machines.
+  listening_addr: "127.0.0.1:8227"
+
+ckb:
+  # Please use a trusted CKB RPC node, the node should be able to provide the correct data and should be stable.
+  rpc_url: "http://127.0.0.1:8114/"
+  udt_whitelist:
+    ## https://github.com/CKBFansDAO/xudtlogos/blob/f2557839ecde0409ba674516a62ae6752bc0daa9/public/tokens/token_list.json#L548
+    - name: USDI
+      script:
+        code_hash: "0xbfa35a9c38a676682b65ade8f02be164d48632281477e36f8dc2f41f79e56bfc"
+        hash_type: type
+        args: "0xd591ebdc69626647e056e13345fd830c8b876bb06aa07ba610479eb77153ea9f"
+      cell_deps:
+        - type_id:
+            code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            hash_type: type
+            args: "0x9105ea69838511ca609518d27855c53fed1b5ffaff4cfb334f58b40627d211c4"
+      auto_accept_amount: 10000000
+
+services:
+  - fiber
+  - rpc
+  - ckb
+`;
+function getConfigTemplate(network) {
+  return network === "mainnet" ? MAINNET_CONFIG_TEMPLATE_V061 : TESTNET_CONFIG_TEMPLATE_V061;
+}
+
+// src/lib/config.ts
+var DEFAULT_DATA_DIR = `${process.env.HOME}/.fiber-pay`;
+var DEFAULT_RPC_URL = "http://127.0.0.1:8227";
+var DEFAULT_NETWORK = "testnet";
+function getConfigPath(dataDir) {
+  return join3(dataDir, "config.yml");
+}
+function parseNetworkFromConfig(configContent) {
+  const match = configContent.match(/^\s*chain:\s*(testnet|mainnet)\s*$/m);
+  if (!match) return void 0;
+  return match[1];
+}
+function parseRpcUrlFromConfig(configContent) {
+  const rpcSectionMatch = configContent.match(
+    /(^|\n)rpc:\n([\s\S]*?)(\n[a-zA-Z_]+:|\nservices:|$)/
+  );
+  const rpcSection = rpcSectionMatch?.[2];
+  if (!rpcSection) return void 0;
+  const match = rpcSection.match(/^\s*listening_addr:\s*"?([^"\n]+)"?\s*$/m);
+  if (!match) return void 0;
+  const listeningAddr = match[1].trim();
+  if (!listeningAddr) return void 0;
+  if (listeningAddr.startsWith("http://") || listeningAddr.startsWith("https://")) {
+    return listeningAddr;
+  }
+  return `http://${listeningAddr}`;
+}
+function parseCkbRpcUrlFromConfig(configContent) {
+  const ckbSectionMatch = configContent.match(
+    /(^|\n)ckb:\n([\s\S]*?)(\n[a-zA-Z_]+:|\nservices:|$)/
+  );
+  const ckbSection = ckbSectionMatch?.[2];
+  if (!ckbSection) return void 0;
+  const match = ckbSection.match(/^\s*rpc_url:\s*"?([^"\n]+)"?\s*$/m);
+  return match?.[1]?.trim() || void 0;
+}
+function getProfilePath(dataDir) {
+  return join3(dataDir, "profile.json");
+}
+function loadProfileConfig(dataDir) {
+  const profilePath = getProfilePath(dataDir);
+  if (!existsSync3(profilePath)) return void 0;
+  try {
+    const raw = readFileSync3(profilePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function saveProfileConfig(dataDir, profile) {
+  if (!existsSync3(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  const profilePath = getProfilePath(dataDir);
+  writeFileSync3(profilePath, `${JSON.stringify(profile, null, 2)}
+`, "utf-8");
+}
+function writeNetworkConfigFile(dataDir, network, options = {}) {
+  const configPath = getConfigPath(dataDir);
+  const alreadyExists = existsSync3(configPath);
+  if (alreadyExists && !options.force) {
+    return { path: configPath, created: false, overwritten: false };
+  }
+  if (!existsSync3(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  let content = getConfigTemplate(network);
+  if (options.rpcPort !== void 0 || options.p2pPort !== void 0) {
+    const lines = content.split("\n");
+    let section = null;
+    for (let i = 0; i < lines.length; i++) {
+      const sectionMatch = lines[i].match(/^([a-zA-Z_]+):\s*$/);
+      if (sectionMatch) {
+        section = sectionMatch[1];
+        continue;
+      }
+      if (section === "fiber" && options.p2pPort !== void 0 && /^\s*listening_addr:\s*/.test(lines[i])) {
+        lines[i] = `  listening_addr: "/ip4/127.0.0.1/tcp/${options.p2pPort}"`;
+      } else if (section === "rpc" && options.rpcPort !== void 0 && /^\s*listening_addr:\s*/.test(lines[i])) {
+        lines[i] = `  listening_addr: "127.0.0.1:${options.rpcPort}"`;
+      }
+    }
+    content = lines.join("\n");
+  }
+  writeFileSync3(configPath, content, "utf-8");
+  return { path: configPath, created: !alreadyExists, overwritten: alreadyExists };
+}
+function ensureNodeConfigFile(dataDir, network) {
+  const configPath = getConfigPath(dataDir);
+  if (!existsSync3(configPath)) {
+    writeNetworkConfigFile(dataDir, network);
+  }
+  return configPath;
+}
+function getEffectiveConfig(explicitFlags2) {
+  const dataDir = process.env.FIBER_DATA_DIR || DEFAULT_DATA_DIR;
+  const dataDirSource = explicitFlags2?.has("dataDir") ? "cli" : process.env.FIBER_DATA_DIR ? "env" : "default";
+  const configPath = getConfigPath(dataDir);
+  const configExists = existsSync3(configPath);
+  const configContent = configExists ? readFileSync3(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;
+  const fileNetwork = configContent ? parseNetworkFromConfig(configContent) : void 0;
+  const network = cliNetwork || envNetwork || fileNetwork || DEFAULT_NETWORK;
+  const networkSource = cliNetwork ? "cli" : envNetwork ? "env" : fileNetwork ? "config" : "default";
+  const cliRpcUrl = explicitFlags2?.has("rpcUrl") ? process.env.FIBER_RPC_URL : void 0;
+  const envRpcUrl = !explicitFlags2?.has("rpcUrl") ? process.env.FIBER_RPC_URL : void 0;
+  const fileRpcUrl = configContent ? parseRpcUrlFromConfig(configContent) : void 0;
+  const rpcUrl = cliRpcUrl || envRpcUrl || fileRpcUrl || DEFAULT_RPC_URL;
+  const rpcUrlSource = cliRpcUrl ? "cli" : envRpcUrl ? "env" : fileRpcUrl ? "config" : "default";
+  const cliBinaryPath = explicitFlags2?.has("binaryPath") ? process.env.FIBER_BINARY_PATH : void 0;
+  const profileBinaryPath = profile?.binaryPath;
+  const envBinaryPath = !explicitFlags2?.has("binaryPath") ? process.env.FIBER_BINARY_PATH : void 0;
+  const binaryPath = cliBinaryPath || profileBinaryPath || envBinaryPath || void 0;
+  const cliKeyPassword = explicitFlags2?.has("keyPassword") ? process.env.FIBER_KEY_PASSWORD : void 0;
+  const profileKeyPassword = profile?.keyPassword;
+  const envKeyPassword = !explicitFlags2?.has("keyPassword") ? process.env.FIBER_KEY_PASSWORD : void 0;
+  const keyPassword = cliKeyPassword || profileKeyPassword || envKeyPassword || void 0;
+  const envCkbRpcUrl = process.env.FIBER_CKB_RPC_URL;
+  const fileCkbRpcUrl = configContent ? parseCkbRpcUrlFromConfig(configContent) : void 0;
+  const ckbRpcUrl = envCkbRpcUrl || fileCkbRpcUrl || void 0;
+  const ckbRpcUrlSource = envCkbRpcUrl ? "env" : fileCkbRpcUrl ? "config" : "unset";
+  const DEFAULT_RUNTIME_PROXY_LISTEN = "127.0.0.1:8229";
+  const cliRuntimeProxyListen = explicitFlags2?.has("runtimeProxyListen") ? process.env.FIBER_RUNTIME_PROXY_LISTEN : void 0;
+  const envRuntimeProxyListen = !explicitFlags2?.has("runtimeProxyListen") ? process.env.FIBER_RUNTIME_PROXY_LISTEN : void 0;
+  const profileRuntimeProxyListen = profile?.runtimeProxyListen;
+  const runtimeProxyListen = cliRuntimeProxyListen || envRuntimeProxyListen || profileRuntimeProxyListen || DEFAULT_RUNTIME_PROXY_LISTEN;
+  const runtimeProxyListenSource = cliRuntimeProxyListen ? "cli" : envRuntimeProxyListen ? "env" : profileRuntimeProxyListen ? "profile" : "default";
+  return {
+    configExists,
+    config: {
+      binaryPath,
+      dataDir,
+      configPath,
+      network,
+      rpcUrl,
+      keyPassword,
+      ckbRpcUrl,
+      runtimeProxyListen
+    },
+    sources: {
+      dataDir: dataDirSource,
+      configPath: "derived",
+      network: networkSource,
+      rpcUrl: rpcUrlSource,
+      ckbRpcUrl: ckbRpcUrlSource,
+      runtimeProxyListen: runtimeProxyListenSource
+    }
+  };
+}
+
+// src/commands/config.ts
+function parseNetworkInput(input) {
+  if (!input) return "testnet";
+  if (input === "testnet" || input === "mainnet") return input;
+  throw new Error(`Invalid network: ${input}. Expected one of: testnet, mainnet`);
+}
+function parsePortInput(input, label) {
+  if (input === void 0) return void 0;
+  const parsed = Number.parseInt(input, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+    throw new Error(`Invalid ${label}: ${input}. Expected integer in range 1-65535.`);
+  }
+  return parsed;
+}
+function resolvePort(optionValue, envValue, label) {
+  if (optionValue !== void 0) {
+    return { value: parsePortInput(optionValue, label), source: "option" };
+  }
+  if (envValue !== void 0) {
+    return { value: parsePortInput(envValue, label), source: "env" };
+  }
+  return { value: void 0, source: "unset" };
+}
+var LEGACY_PATH_ALIASES = {
+  chain: "fiber.chain"
+};
+function resolveConfigPathAlias(path) {
+  return LEGACY_PATH_ALIASES[path] ?? path;
+}
+function parseConfigPath(path) {
+  const normalized = resolveConfigPathAlias(path).trim();
+  if (!normalized) {
+    throw new Error("Config path cannot be empty.");
+  }
+  const segments = [];
+  const re = /([^.[\]]+)|\[(\d+)\]/g;
+  for (const match of normalized.matchAll(re)) {
+    if (match[1]) {
+      segments.push(match[1]);
+    } else if (match[2]) {
+      segments.push(Number.parseInt(match[2], 10));
+    }
+  }
+  if (segments.length === 0) {
+    throw new Error(`Invalid config path: ${path}`);
+  }
+  return segments;
+}
+function parseTypedValue(raw, valueType) {
+  if (valueType === "string") return raw;
+  if (valueType === "null") return null;
+  if (valueType === "number") {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+      throw new Error(`Invalid number value: ${raw}`);
+    }
+    return parsed;
+  }
+  if (valueType === "boolean") {
+    const lowered2 = raw.toLowerCase();
+    if (lowered2 === "true") return true;
+    if (lowered2 === "false") return false;
+    throw new Error(`Invalid boolean value: ${raw}. Expected true or false.`);
+  }
+  if (valueType === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new Error(`Invalid JSON value: ${raw}`);
+    }
+  }
+  const lowered = raw.toLowerCase();
+  if (lowered === "true") return true;
+  if (lowered === "false") return false;
+  if (lowered === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(raw)) {
+    return Number(raw);
+  }
+  if (raw.startsWith("{") && raw.endsWith("}") || raw.startsWith("[") && raw.endsWith("]")) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function ensureConfigFileOrExit(configPath, json) {
+  if (!existsSync4(configPath)) {
+    const msg = `Config file not found: ${configPath}. Run \`fiber-pay config init\` first.`;
+    if (json) {
+      printJsonError({
+        code: "CONFIG_NOT_FOUND",
+        message: msg,
+        recoverable: true,
+        suggestion: "Run `fiber-pay config init --network testnet` and retry."
+      });
+    } else {
+      console.error(`Error: ${msg}`);
+    }
+    process.exit(1);
+  }
+}
+function normalizeHexScalarsForMutation(content) {
+  return content.replace(
+    /^(\s*)(code_hash|tx_hash|args):\s*(0x[0-9a-fA-F]+)(\s*(#.*))?$/gm,
+    (_match, indent, key, value, tail = "") => `${indent}${key}: "${value}"${tail}`
+  );
+}
+function parseConfigDocumentForMutation(configPath) {
+  const raw = readFileSync4(configPath, "utf-8");
+  const normalized = normalizeHexScalarsForMutation(raw);
+  return parseDocument(normalized, {
+    keepSourceTokens: true
+  });
+}
+function collectConfigPaths(value, prefix = "") {
+  if (value === null || value === void 0) {
+    return prefix ? [prefix] : [];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return prefix ? [prefix] : [];
+    }
+    const result = [];
+    for (let index = 0; index < value.length; index++) {
+      const childPrefix = `${prefix}[${index}]`;
+      result.push(...collectConfigPaths(value[index], childPrefix));
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return prefix ? [prefix] : [];
+    }
+    const result = [];
+    for (const [key, child] of entries) {
+      const childPrefix = prefix ? `${prefix}.${key}` : key;
+      result.push(...collectConfigPaths(child, childPrefix));
+    }
+    return result;
+  }
+  return prefix ? [prefix] : [];
+}
+function createConfigCommand(_config) {
+  const config = new Command3("config").description("Single source configuration management");
+  config.command("init").option(
+    "--data-dir <path>",
+    "Target data directory (overrides FIBER_DATA_DIR for this command)"
+  ).option("--network <network>", "testnet | mainnet").option("--rpc-port <port>", "Override rpc.listening_addr port in generated config").option("--p2p-port <port>", "Override fiber.listening_addr port in generated config").option("--proxy-port <port>", "Set runtime proxy port and persist in profile.json").option("--force", "Overwrite existing config file").option("--json").action(async (options) => {
+    const effective = getEffectiveConfig();
+    const dataDir = options.dataDir ?? effective.config.dataDir;
+    const selectedNetwork = options.network ? parseNetworkInput(options.network) : effective.config.network;
+    const rpcPort = resolvePort(options.rpcPort, process.env.FIBER_RPC_PORT, "rpc-port");
+    const p2pPort = resolvePort(options.p2pPort, process.env.FIBER_P2P_PORT, "p2p-port");
+    const result = writeNetworkConfigFile(dataDir, selectedNetwork, {
+      force: Boolean(options.force),
+      rpcPort: rpcPort.value,
+      p2pPort: p2pPort.value
+    });
+    let proxyPort;
+    if (options.proxyPort !== void 0) {
+      proxyPort = parsePortInput(options.proxyPort, "proxy-port");
+      const existing = loadProfileConfig(dataDir) ?? {};
+      existing.runtimeProxyListen = `127.0.0.1:${proxyPort}`;
+      saveProfileConfig(dataDir, existing);
+    }
+    const payload = {
+      configPath: result.path,
+      dataDir,
+      network: selectedNetwork,
+      rpcPort: rpcPort.value,
+      rpcPortSource: rpcPort.source,
+      p2pPort: p2pPort.value,
+      p2pPortSource: p2pPort.source,
+      proxyPort: proxyPort ?? null,
+      created: result.created,
+      overwritten: result.overwritten,
+      skipped: !result.created && !result.overwritten
+    };
+    if (options.json) {
+      printJsonSuccess(payload);
+    } else {
+      if (result.created) {
+        console.log(`\u2705 Config initialized: ${result.path}`);
+      } else if (result.overwritten) {
+        console.log(`\u2705 Config overwritten: ${result.path}`);
+      } else {
+        console.log(`\u2139\uFE0F  Config already exists: ${result.path}`);
+        console.log("   Use --force to overwrite.");
+      }
+      if (options.dataDir !== void 0) {
+        console.log(`   Data Dir: ${dataDir} (option)`);
+      } else {
+        console.log(`   Data Dir: ${dataDir} (${effective.sources.dataDir})`);
+      }
+      console.log(`   Network: ${selectedNetwork}`);
+      if (rpcPort.value !== void 0)
+        console.log(`   RPC Port: ${rpcPort.value} (${rpcPort.source})`);
+      if (p2pPort.value !== void 0)
+        console.log(`   P2P Port: ${p2pPort.value} (${p2pPort.source})`);
+      if (proxyPort !== void 0) console.log(`   Proxy Port: ${proxyPort} (profile.json)`);
+    }
+  });
+  config.command("show").option("--effective", "Debug resolved values and value source").option("--json").action(async (options) => {
+    const effective = getEffectiveConfig();
+    if (options.effective) {
+      const payload = {
+        config: effective.config,
+        sources: effective.sources,
+        configExists: effective.configExists
+      };
+      if (options.json) {
+        printJsonSuccess(payload);
+      } else {
+        console.log("Effective Config");
+        console.log(`  Data Dir:    ${effective.config.dataDir} (${effective.sources.dataDir})`);
+        console.log(`  Config Path: ${effective.config.configPath}`);
+        console.log(`  Network:     ${effective.config.network} (${effective.sources.network})`);
+        console.log(`  RPC URL:     ${effective.config.rpcUrl} (${effective.sources.rpcUrl})`);
+        console.log(`  Exists:      ${effective.configExists ? "yes" : "no"}`);
+      }
+      return;
+    }
+    if (!effective.configExists) {
+      if (options.json) {
+        printJsonError({
+          code: "CONFIG_NOT_FOUND",
+          message: `Config file not found: ${effective.config.configPath}`,
+          recoverable: true,
+          suggestion: "Run `fiber-pay config init --network testnet` and retry.",
+          details: { configPath: effective.config.configPath }
+        });
+      } else {
+        console.error(`Error: Config file not found: ${effective.config.configPath}`);
+        console.error("Run: fiber-pay config init --network testnet");
+      }
+      process.exit(1);
+    }
+    const content = readFileSync4(effective.config.configPath, "utf-8");
+    const fileNetwork = parseNetworkFromConfig(content) || "unknown";
+    if (options.json) {
+      printJsonSuccess({
+        path: effective.config.configPath,
+        network: fileNetwork,
+        content
+      });
+    } else {
+      console.log(`# ${effective.config.configPath} (${fileNetwork})`);
+      console.log(content);
+    }
+  });
+  config.command("get").description("Get config value by path (e.g. fiber.chain, ckb.udt_whitelist[0].name)").argument("<path>", "Config path").option("--json").action(async (path, options) => {
+    const effective = getEffectiveConfig();
+    const json = Boolean(options.json);
+    const configPath = effective.config.configPath;
+    ensureConfigFileOrExit(configPath, json);
+    const doc = parseConfigDocumentForMutation(configPath);
+    const segments = parseConfigPath(path);
+    const value = doc.getIn(segments);
+    if (value === void 0) {
+      const msg = `Config path not found: ${resolveConfigPathAlias(path)}`;
+      if (json) {
+        printJsonError({
+          code: "CONFIG_PATH_NOT_FOUND",
+          message: msg,
+          recoverable: true,
+          suggestion: "Use `fiber-pay config list` to inspect available paths."
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    if (json) {
+      printJsonSuccess({ path: resolveConfigPathAlias(path), value });
+    } else if (typeof value === "object") {
+      console.log(yamlStringify(value).trimEnd());
+    } else {
+      console.log(String(value));
+    }
+  });
+  config.command("set").description("Set config value by path (supports nested keys and array indexes)").argument("<path>", "Config path").argument("<value>", "New value").option("--type <type>", "auto|string|number|boolean|null|json", "auto").option("--json").action(async (path, value, options) => {
+    const effective = getEffectiveConfig();
+    const json = Boolean(options.json);
+    const configPath = effective.config.configPath;
+    ensureConfigFileOrExit(configPath, json);
+    const valueType = String(options.type ?? "auto");
+    if (!["auto", "string", "number", "boolean", "null", "json"].includes(valueType)) {
+      const msg = `Invalid --type: ${options.type}. Expected auto|string|number|boolean|null|json`;
+      if (json) {
+        printJsonError({
+          code: "CONFIG_VALUE_TYPE_INVALID",
+          message: msg,
+          recoverable: true
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    const doc = parseConfigDocumentForMutation(configPath);
+    const resolvedPath = resolveConfigPathAlias(path);
+    const segments = parseConfigPath(path);
+    const parsedValue = parseTypedValue(value, valueType);
+    doc.setIn(segments, parsedValue);
+    writeFileSync4(configPath, doc.toString({ lineWidth: 0 }), "utf-8");
+    if (json) {
+      printJsonSuccess({ path: resolvedPath, value: parsedValue, configPath });
+    } else {
+      console.log(`\u2705 Set ${resolvedPath} = ${value} in ${configPath}`);
+    }
+  });
+  config.command("unset").description("Remove config value by path").argument("<path>", "Config path").option("--json").action(async (path, options) => {
+    const effective = getEffectiveConfig();
+    const json = Boolean(options.json);
+    const configPath = effective.config.configPath;
+    ensureConfigFileOrExit(configPath, json);
+    const doc = parseConfigDocumentForMutation(configPath);
+    const resolvedPath = resolveConfigPathAlias(path);
+    const segments = parseConfigPath(path);
+    const removed = doc.deleteIn(segments);
+    if (!removed) {
+      const msg = `Config path not found: ${resolvedPath}`;
+      if (json) {
+        printJsonError({
+          code: "CONFIG_PATH_NOT_FOUND",
+          message: msg,
+          recoverable: true,
+          suggestion: "Use `fiber-pay config list` to inspect available paths."
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    writeFileSync4(configPath, doc.toString({ lineWidth: 0 }), "utf-8");
+    if (json) {
+      printJsonSuccess({ path: resolvedPath, removed: true, configPath });
+    } else {
+      console.log(`\u2705 Removed ${resolvedPath} from ${configPath}`);
+    }
+  });
+  config.command("list").description("List config key paths (optionally under a prefix)").option("--prefix <path>", "List only under this path").option("--json").action(async (options) => {
+    const effective = getEffectiveConfig();
+    const json = Boolean(options.json);
+    const configPath = effective.config.configPath;
+    ensureConfigFileOrExit(configPath, json);
+    const doc = parseConfigDocumentForMutation(configPath);
+    const prefix = options.prefix ? resolveConfigPathAlias(String(options.prefix)) : void 0;
+    let rootValue = doc.toJSON();
+    let basePrefix = "";
+    if (prefix) {
+      const segments = parseConfigPath(prefix);
+      rootValue = doc.getIn(segments);
+      if (rootValue === void 0) {
+        const msg = `Config path not found: ${prefix}`;
+        if (json) {
+          printJsonError({
+            code: "CONFIG_PATH_NOT_FOUND",
+            message: msg,
+            recoverable: true,
+            suggestion: "Use `fiber-pay config list` without prefix first."
+          });
+        } else {
+          console.error(`Error: ${msg}`);
+        }
+        process.exit(1);
+      }
+      basePrefix = prefix;
+    }
+    const paths = collectConfigPaths(rootValue, basePrefix).sort((a, b) => a.localeCompare(b));
+    if (json) {
+      printJsonSuccess({ prefix: prefix ?? null, paths, count: paths.length });
+    } else {
+      for (const path of paths) {
+        console.log(path);
+      }
+    }
+  });
+  const profile = new Command3("profile").description(
+    "Manage profile.json settings (CLI-only overrides)"
+  );
+  const PROFILE_KEYS = ["binaryPath", "keyPassword", "runtimeProxyListen"];
+  profile.command("show").description("Show current profile.json values").option("--json").action(async (options) => {
+    const effective = getEffectiveConfig();
+    const profileData = loadProfileConfig(effective.config.dataDir);
+    if (options.json) {
+      printJsonSuccess({ dataDir: effective.config.dataDir, profile: profileData ?? {} });
+    } else {
+      if (!profileData || Object.keys(profileData).length === 0) {
+        console.log("No profile settings found.");
+        console.log(`  Location: ${effective.config.dataDir}/profile.json`);
+        return;
+      }
+      console.log("Profile Settings");
+      console.log(`  Location: ${effective.config.dataDir}/profile.json`);
+      for (const key of PROFILE_KEYS) {
+        if (profileData[key] !== void 0) {
+          console.log(`  ${key}: ${profileData[key]}`);
+        }
+      }
+    }
+  });
+  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(", ")}`;
+      if (options.json) {
+        printJsonError({
+          code: "PROFILE_INVALID_KEY",
+          message: msg,
+          recoverable: true,
+          suggestion: `Use one of: ${PROFILE_KEYS.join(", ")}`
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    const effective = getEffectiveConfig();
+    const existing = loadProfileConfig(effective.config.dataDir) ?? {};
+    existing[key] = value;
+    saveProfileConfig(effective.config.dataDir, existing);
+    if (options.json) {
+      printJsonSuccess({ key, value, dataDir: effective.config.dataDir });
+    } else {
+      console.log(`\u2705 Profile key "${key}" set to "${value}"`);
+    }
+  });
+  profile.command("unset").description("Remove a profile key").argument("<key>", `One of: ${PROFILE_KEYS.join(", ")}`).option("--json").action(async (key, options) => {
+    if (!PROFILE_KEYS.includes(key)) {
+      const msg = `Unknown profile key: ${key}. Valid keys: ${PROFILE_KEYS.join(", ")}`;
+      if (options.json) {
+        printJsonError({
+          code: "PROFILE_INVALID_KEY",
+          message: msg,
+          recoverable: true,
+          suggestion: `Use one of: ${PROFILE_KEYS.join(", ")}`
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    const effective = getEffectiveConfig();
+    const existing = loadProfileConfig(effective.config.dataDir) ?? {};
+    delete existing[key];
+    saveProfileConfig(effective.config.dataDir, existing);
+    if (options.json) {
+      printJsonSuccess({ key, removed: true, dataDir: effective.config.dataDir });
+    } else {
+      console.log(`\u2705 Profile key "${key}" removed`);
+    }
+  });
+  config.addCommand(profile);
+  return config;
+}
+
+// src/commands/graph.ts
+import { shannonsToCkb as shannonsToCkb2, toHex as toHex2 } from "@fiber-pay/sdk";
+import { Command as Command4 } from "commander";
+function printGraphNodeListHuman(nodes) {
+  if (nodes.length === 0) {
+    console.log("No nodes found in the graph.");
+    return;
+  }
+  console.log(`Graph Nodes: ${nodes.length}`);
+  console.log("");
+  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 alias = (node.node_name || "(unnamed)").slice(0, 20).padEnd(20, " ");
+    const version = (node.version || "?").slice(0, 10).padEnd(10, " ");
+    const minFunding = shannonsToCkb2(node.auto_accept_min_ckb_funding_amount).toString().padStart(12, " ");
+    const age = formatAge(parseHexTimestampMs(node.timestamp));
+    console.log(`${nodeId} ${alias} ${version} ${minFunding} ${age}`);
+  }
+}
+function printGraphChannelListHuman(channels) {
+  if (channels.length === 0) {
+    console.log("No channels found in the graph.");
+    return;
+  }
+  console.log(`Graph Channels: ${channels.length}`);
+  console.log("");
+  console.log(
+    "OUTPOINT               NODE1                  NODE2                  CAPACITY     AGE"
+  );
+  console.log(
+    "----------------------------------------------------------------------------------------------"
+  );
+  for (const ch of channels) {
+    const outpoint = ch.channel_outpoint ? truncateMiddle(`${ch.channel_outpoint.tx_hash}:${ch.channel_outpoint.index}`, 10, 8) : "n/a";
+    const n1 = truncateMiddle(ch.node1, 10, 8).padEnd(22, " ");
+    const n2 = truncateMiddle(ch.node2, 10, 8).padEnd(22, " ");
+    const capacity = `${shannonsToCkb2(ch.capacity)} CKB`.padStart(12, " ");
+    const age = formatAge(parseHexTimestampMs(ch.created_timestamp));
+    console.log(`${outpoint.padEnd(22, " ")} ${n1} ${n2} ${capacity} ${age}`);
+  }
+}
+function createGraphCommand(config) {
+  const graph = new Command4("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)));
+    const result = await rpc.graphNodes({
+      limit,
+      after: options.after
+    });
+    if (options.json) {
+      printJsonSuccess({ nodes: result.nodes, lastCursor: result.last_cursor });
+    } else {
+      printGraphNodeListHuman(result.nodes);
+      if (result.last_cursor && result.last_cursor !== "0x0") {
+        console.log(`
+Next cursor: ${result.last_cursor}`);
+      }
+    }
+  });
+  graph.command("channels").option("--limit <n>", "Maximum number of channels 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)));
+    const result = await rpc.graphChannels({
+      limit,
+      after: options.after
+    });
+    if (options.json) {
+      printJsonSuccess({ channels: result.channels, lastCursor: result.last_cursor });
+    } else {
+      printGraphChannelListHuman(result.channels);
+      if (result.last_cursor && result.last_cursor !== "0x0") {
+        console.log(`
+Next cursor: ${result.last_cursor}`);
+      }
+    }
+  });
+  return graph;
+}
+
+// src/commands/invoice.ts
+import { ckbToShannons as ckbToShannons2, randomBytes32, shannonsToCkb as shannonsToCkb3, toHex as toHex3 } from "@fiber-pay/sdk";
+import { Command as Command5 } from "commander";
+function createInvoiceCommand(config) {
+  const invoice = new Command5("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);
+    const amountCkb = options.amount ? parseFloat(options.amount) : amountArg ? parseFloat(amountArg) : 0;
+    if (!amountCkb) {
+      if (options.json) {
+        printJsonError({
+          code: "INVOICE_CREATE_INPUT_INVALID",
+          message: "Amount required. Usage: invoice create --amount <CKB>",
+          recoverable: true,
+          suggestion: "Provide a valid positive amount via `--amount <CKB>`."
+        });
+      } else {
+        console.error("Error: Amount required. Usage: invoice create --amount <CKB>");
+      }
+      process.exit(1);
+    }
+    const expirySeconds = (options.expiry ? parseInt(options.expiry, 10) : 60) * 60;
+    const currency = config.network === "mainnet" ? "Fibb" : "Fibt";
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeInvoiceJob(endpoint.url, {
+        params: {
+          action: "create",
+          newInvoiceParams: {
+            amount: ckbToShannons2(amountCkb),
+            currency,
+            description: options.description,
+            expiry: toHex3(expirySeconds),
+            payment_preimage: randomBytes32()
+          },
+          waitForTerminal: false
+        }
+      });
+      if (created) {
+        const job = await waitForRuntimeJobTerminal(endpoint.url, created.id, 60);
+        if (job.state !== "succeeded") {
+          throw new Error(job.error?.message ?? `Invoice create job ${job.state}`);
+        }
+        const result2 = job.result ?? {};
+        const payload2 = {
+          jobId: job.id,
+          invoice: result2.invoiceAddress,
+          paymentHash: result2.paymentHash,
+          amountCkb,
+          expiresAt: new Date(Date.now() + expirySeconds * 1e3).toISOString(),
+          status: (result2.status ?? "Open").toLowerCase()
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log("Invoice created");
+          console.log(`  Job:          ${payload2.jobId}`);
+          console.log(`  Payment Hash: ${payload2.paymentHash ?? "n/a"}`);
+          console.log(`  Amount:       ${payload2.amountCkb} CKB`);
+          console.log(`  Expires At:   ${payload2.expiresAt}`);
+          console.log(`  Invoice:      ${payload2.invoice ?? "n/a"}`);
+        }
+        return;
+      }
+    }
+    const result = await rpc.newInvoice({
+      amount: ckbToShannons2(amountCkb),
+      currency,
+      description: options.description,
+      expiry: toHex3(expirySeconds),
+      payment_preimage: randomBytes32()
+    });
+    const payload = {
+      invoice: result.invoice_address,
+      paymentHash: result.invoice.data.payment_hash,
+      amountCkb,
+      expiresAt: new Date(Date.now() + expirySeconds * 1e3).toISOString(),
+      status: "open"
+    };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log("Invoice created");
+      console.log(`  Payment Hash: ${payload.paymentHash}`);
+      console.log(`  Amount:       ${payload.amountCkb} CKB`);
+      console.log(`  Expires At:   ${payload.expiresAt}`);
+      console.log(`  Invoice:      ${payload.invoice}`);
+    }
+  });
+  invoice.command("get").argument("<paymentHash>").option("--json").action(async (paymentHash, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const result = await rpc.getInvoice({ payment_hash: paymentHash });
+    const metadata = extractInvoiceMetadata(result.invoice);
+    const createdAtMs = parseHexTimestampMs(result.invoice.data.timestamp);
+    const output = {
+      paymentHash,
+      status: result.status,
+      invoice: result.invoice_address,
+      amountCkb: result.invoice.amount ? shannonsToCkb3(result.invoice.amount) : void 0,
+      currency: result.invoice.currency,
+      description: metadata.description,
+      createdAt: createdAtMs ? new Date(createdAtMs).toISOString() : result.invoice.data.timestamp,
+      expiresAt: metadata.expiresAt,
+      age: metadata.age
+    };
+    if (options.json) {
+      printJsonSuccess(output);
+    } else {
+      printInvoiceDetailHuman(output);
+    }
+  });
+  invoice.command("parse").argument("<invoiceString>").option("--json").action(async (invoiceString, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const result = await rpc.parseInvoice({ invoice: invoiceString });
+    if (options.json) {
+      printJsonSuccess(result);
+    } else {
+      console.log("Invoice parsed");
+      console.log(JSON.stringify(result, null, 2));
+    }
+  });
+  invoice.command("cancel").argument("<paymentHash>").option("--json").action(async (paymentHash, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeInvoiceJob(endpoint.url, {
+        params: {
+          action: "cancel",
+          cancelInvoiceParams: { payment_hash: paymentHash }
+        },
+        options: {
+          idempotencyKey: `invoice:cancel:${paymentHash}`
+        }
+      });
+      if (created) {
+        const job = await waitForRuntimeJobTerminal(endpoint.url, created.id, 60);
+        if (job.state !== "succeeded") {
+          throw new Error(job.error?.message ?? `Invoice cancel job ${job.state}`);
+        }
+        const result2 = job.result ?? {};
+        const output2 = {
+          jobId: job.id,
+          paymentHash,
+          status: result2.status ?? "Cancelled",
+          invoice: result2.invoiceAddress
+        };
+        if (json) {
+          printJsonSuccess(output2);
+        } else {
+          console.log("Invoice cancelled");
+          console.log(`  Job:          ${output2.jobId}`);
+          console.log(`  Payment Hash: ${output2.paymentHash}`);
+          console.log(`  Status:       ${output2.status}`);
+          console.log(`  Invoice:      ${output2.invoice ?? "n/a"}`);
+        }
+        return;
+      }
+    }
+    const result = await rpc.cancelInvoice({ payment_hash: paymentHash });
+    const output = { paymentHash, status: result.status, invoice: result.invoice_address };
+    if (json) {
+      printJsonSuccess(output);
+    } else {
+      console.log("Invoice cancelled");
+      console.log(`  Payment Hash:  ${output.paymentHash}`);
+      console.log(`  Status:        ${output.status}`);
+      console.log(`  Invoice:       ${output.invoice}`);
+    }
+  });
+  invoice.command("settle").argument("<paymentHash>").requiredOption("--preimage <preimage>").option("--json").action(async (paymentHash, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimeInvoiceJob(endpoint.url, {
+        params: {
+          action: "settle",
+          settleInvoiceParams: {
+            payment_hash: paymentHash,
+            payment_preimage: options.preimage
+          }
+        },
+        options: {
+          idempotencyKey: `invoice:settle:${paymentHash}`
+        }
+      });
+      if (created) {
+        const job = await waitForRuntimeJobTerminal(endpoint.url, created.id, 60);
+        if (job.state !== "succeeded") {
+          throw new Error(job.error?.message ?? `Invoice settle job ${job.state}`);
+        }
+        const output = { jobId: job.id, paymentHash, message: "Invoice settled." };
+        if (json) {
+          printJsonSuccess(output);
+        } else {
+          console.log(output.message);
+          console.log(`  Job:          ${output.jobId}`);
+          console.log(`  Payment Hash: ${output.paymentHash}`);
+        }
+        return;
+      }
+    }
+    await rpc.settleInvoice({
+      payment_hash: paymentHash,
+      payment_preimage: options.preimage
+    });
+    if (json) {
+      printJsonSuccess({ paymentHash, message: "Invoice settled." });
+    } else {
+      console.log("Invoice settled");
+      console.log(`  Payment Hash:  ${paymentHash}`);
+    }
+  });
+  return invoice;
+}
+
+// src/commands/job.ts
+import { existsSync as existsSync6 } from "fs";
+import { Command as Command6 } from "commander";
+
+// src/lib/log-files.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+function resolvePersistedLogPaths(dataDir, meta) {
+  return {
+    runtimeAlerts: meta?.alertLogFilePath ?? join4(dataDir, "logs", "runtime.alerts.jsonl"),
+    fnnStdout: meta?.fnnStdoutLogPath ?? join4(dataDir, "logs", "fnn.stdout.log"),
+    fnnStderr: meta?.fnnStderrLogPath ?? join4(dataDir, "logs", "fnn.stderr.log")
+  };
+}
+function resolvePersistedLogTargets(paths, source) {
+  const all = [
+    {
+      source: "runtime",
+      title: "runtime.alerts",
+      path: paths.runtimeAlerts
+    },
+    {
+      source: "fnn-stdout",
+      title: "fnn.stdout",
+      path: paths.fnnStdout
+    },
+    {
+      source: "fnn-stderr",
+      title: "fnn.stderr",
+      path: paths.fnnStderr
+    }
+  ];
+  if (source === "all") {
+    return all;
+  }
+  return all.filter((target) => target.source === source);
+}
+function readLastLines(filePath, maxLines) {
+  if (!existsSync5(filePath)) {
+    return [];
+  }
+  const content = readFileSync5(filePath, "utf-8");
+  const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
+  return lines.slice(-maxLines);
+}
+
+// src/commands/job.ts
+function createJobCommand(config) {
+  const job = new Command6("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);
+    const query = new URLSearchParams();
+    if (options.state) query.set("state", String(options.state));
+    if (options.type) query.set("type", String(options.type));
+    if (options.limit) query.set("limit", String(options.limit));
+    if (options.offset) query.set("offset", String(options.offset));
+    const response = await fetch(
+      `${runtimeUrl}/jobs${query.toString() ? `?${query.toString()}` : ""}`
+    );
+    if (!response.ok) {
+      return handleHttpError(response, "JOB_LIST_FAILED", json);
+    }
+    const payload = await response.json();
+    if (json) {
+      printJsonSuccess(payload);
+      return;
+    }
+    if (!payload.jobs.length) {
+      console.log("No jobs found.");
+      return;
+    }
+    console.log(`Jobs (${payload.jobs.length})`);
+    for (const item of payload.jobs) {
+      console.log(`- ${item.id}`);
+      console.log(`  Type:   ${item.type}`);
+      console.log(`  State:  ${item.state}`);
+      if (item.idempotencyKey) console.log(`  Key:    ${item.idempotencyKey}`);
+      if (typeof item.retryCount === "number" && typeof item.maxRetries === "number") {
+        console.log(`  Retry:  ${item.retryCount}/${item.maxRetries}`);
+      }
+    }
+  });
+  job.command("get").argument("<jobId>").option("--json").action(async (jobId, options) => {
+    const json = Boolean(options.json);
+    const runtimeUrl = getRuntimeUrlOrExit(config, json);
+    const response = await fetch(`${runtimeUrl}/jobs/${jobId}`);
+    if (!response.ok) {
+      return handleHttpError(response, "JOB_GET_FAILED", json);
+    }
+    const payload = await response.json();
+    if (json) {
+      printJsonSuccess(payload);
+      return;
+    }
+    console.log("Job");
+    console.log(`  ID:         ${payload.id}`);
+    console.log(`  Type:       ${payload.type}`);
+    console.log(`  State:      ${payload.state}`);
+    if (payload.idempotencyKey) console.log(`  Key:        ${payload.idempotencyKey}`);
+    if (typeof payload.retryCount === "number" && typeof payload.maxRetries === "number") {
+      console.log(`  Retry:      ${payload.retryCount}/${payload.maxRetries}`);
+    }
+    if (payload.error?.message) {
+      console.log(`  Error:      ${payload.error.message}`);
+    }
+    if (payload.result) {
+      console.log("  Result:");
+      console.log(`    ${JSON.stringify(payload.result)}`);
+    }
+  });
+  job.command("trace").argument("<jobId>").option("--tail <n>", "Max lines to inspect per log file", "400").option("--json").action(async (jobId, options) => {
+    const json = Boolean(options.json);
+    const tailInput = Number.parseInt(String(options.tail ?? "400"), 10);
+    const tail = Number.isFinite(tailInput) && tailInput > 0 ? tailInput : 400;
+    const runtimeUrl = getRuntimeUrlOrExit(config, json);
+    const jobResponse = await fetch(`${runtimeUrl}/jobs/${jobId}`);
+    if (!jobResponse.ok) {
+      return handleHttpError(jobResponse, "JOB_TRACE_GET_FAILED", json);
+    }
+    const eventsResponse = await fetch(`${runtimeUrl}/jobs/${jobId}/events`);
+    if (!eventsResponse.ok) {
+      return handleHttpError(eventsResponse, "JOB_TRACE_EVENTS_FAILED", json);
+    }
+    const jobRecord = await jobResponse.json();
+    const eventsPayload = await eventsResponse.json();
+    const tokens = collectTraceTokens(jobRecord, eventsPayload.events);
+    const meta = readRuntimeMeta(config.dataDir);
+    const logPaths = resolvePersistedLogPaths(config.dataDir, meta);
+    const runtimeAlertMatches = collectRelatedLines(logPaths.runtimeAlerts, tokens, tail);
+    const fnnStdoutMatches = collectRelatedLines(logPaths.fnnStdout, tokens, tail);
+    const fnnStderrMatches = collectRelatedLines(logPaths.fnnStderr, tokens, tail);
+    const result = {
+      job: jobRecord,
+      events: eventsPayload.events,
+      trace: {
+        tokens,
+        logPaths,
+        matches: {
+          runtimeAlerts: runtimeAlertMatches,
+          fnnStdout: fnnStdoutMatches,
+          fnnStderr: fnnStderrMatches
+        }
+      }
+    };
+    if (json) {
+      printJsonSuccess(result);
+      return;
+    }
+    console.log("Job trace");
+    console.log(`  Job ID:      ${jobRecord.id}`);
+    console.log(`  Type:        ${jobRecord.type}`);
+    console.log(`  State:       ${jobRecord.state}`);
+    if (jobRecord.idempotencyKey) {
+      console.log(`  Idempotency: ${jobRecord.idempotencyKey}`);
+    }
+    if (jobRecord.error?.message) {
+      console.log(`  Error:       ${jobRecord.error.message}`);
+    }
+    console.log(`  Events:      ${eventsPayload.events.length}`);
+    if (tokens.length > 0) {
+      console.log("  Tokens:");
+      for (const token of tokens) {
+        console.log(`    - ${token}`);
+      }
+    }
+    printTraceSection("runtime.alerts", logPaths.runtimeAlerts, runtimeAlertMatches);
+    printTraceSection("fnn.stdout", logPaths.fnnStdout, fnnStdoutMatches);
+    printTraceSection("fnn.stderr", logPaths.fnnStderr, fnnStderrMatches);
+  });
+  job.command("events").argument("<jobId>").option("--with-data", "Include event data payload in human-readable output").option("--json").action(async (jobId, options) => {
+    const json = Boolean(options.json);
+    const runtimeUrl = getRuntimeUrlOrExit(config, json);
+    const response = await fetch(`${runtimeUrl}/jobs/${jobId}/events`);
+    if (!response.ok) {
+      return handleHttpError(response, "JOB_EVENTS_FAILED", json);
+    }
+    const payload = await response.json();
+    if (json) {
+      printJsonSuccess(payload);
+      return;
+    }
+    if (!payload.events.length) {
+      console.log("No events found for job.");
+      return;
+    }
+    console.log(`Job events (${payload.events.length})`);
+    for (const event of payload.events) {
+      const timestamp = new Date(event.createdAt).toISOString();
+      const transition = event.toState ? `${event.fromState ?? "(none)"} -> ${event.toState}` : event.fromState ?? "(none)";
+      console.log(`- ${timestamp} ${event.eventType} (${transition})`);
+      if (options.withData && event.data !== void 0) {
+        console.log(`  data: ${JSON.stringify(event.data)}`);
+      }
+    }
+  });
+  job.command("cancel").argument("<jobId>").option("--json").action(async (jobId, options) => {
+    const json = Boolean(options.json);
+    const runtimeUrl = getRuntimeUrlOrExit(config, json);
+    const response = await fetch(`${runtimeUrl}/jobs/${jobId}`, { method: "DELETE" });
+    if (!response.ok) {
+      return handleHttpError(response, "JOB_CANCEL_FAILED", json);
+    }
+    const payload = { jobId, cancelled: true };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log(`Job cancelled: ${jobId}`);
+    }
+  });
+  return job;
+}
+function getRuntimeUrlOrExit(config, json) {
+  const endpoint = resolveRpcEndpoint(config);
+  if (endpoint.target !== "runtime-proxy") {
+    const message = "Runtime proxy is not active for the current profile/RPC URL. Start runtime first (fiber-pay runtime start --daemon).";
+    if (json) {
+      printJsonError({
+        code: "RUNTIME_PROXY_REQUIRED",
+        message,
+        recoverable: true,
+        suggestion: "Start runtime and retry the job command."
+      });
+    } else {
+      console.error(`Error: ${message}`);
+    }
+    process.exit(1);
+  }
+  return endpoint.url;
+}
+async function handleHttpError(response, code, json) {
+  const body = await safeJson(response);
+  const message = extractErrorMessage(body) ?? `HTTP ${response.status}`;
+  if (json) {
+    printJsonError({
+      code,
+      message,
+      recoverable: response.status >= 500 || response.status === 404,
+      suggestion: "Check runtime status and job id, then retry.",
+      details: {
+        status: response.status,
+        body
+      }
+    });
+  } else {
+    console.error(`Error: ${message}`);
+  }
+  process.exit(1);
+}
+function extractErrorMessage(body) {
+  if (!body || typeof body !== "object") {
+    return void 0;
+  }
+  if ("error" in body) {
+    const error = body.error;
+    if (typeof error === "string") {
+      return error;
+    }
+    if (error && typeof error === "object" && "message" in error) {
+      const message = error.message;
+      if (typeof message === "string") {
+        return message;
+      }
+    }
+  }
+  if ("message" in body) {
+    const message = body.message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return void 0;
+}
+async function safeJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+function collectTraceTokens(job, events) {
+  const result = /* @__PURE__ */ new Set();
+  addTraceToken(result, job.id);
+  addTraceToken(result, job.idempotencyKey);
+  collectStructuredTokens(result, job.params);
+  collectStructuredTokens(result, job.result);
+  collectStructuredTokens(result, job.error);
+  for (const event of events) {
+    addTraceToken(result, event.id);
+    collectStructuredTokens(result, event.data);
+  }
+  return Array.from(result).slice(0, 20);
+}
+function addTraceToken(set, value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  if (!normalized || normalized.length < 6) {
+    return;
+  }
+  if (normalized.includes(" ")) {
+    return;
+  }
+  if (normalized.length <= 128) {
+    set.add(normalized);
+  }
+}
+function collectStructuredTokens(set, input, depth = 0) {
+  if (depth > 3 || input === null || input === void 0) {
+    return;
+  }
+  if (typeof input === "string") {
+    if (input.startsWith("0x") || input.includes("peer") || input.includes("channel")) {
+      addTraceToken(set, input);
+    }
+    return;
+  }
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      collectStructuredTokens(set, item, depth + 1);
+    }
+    return;
+  }
+  if (typeof input === "object") {
+    for (const value of Object.values(input)) {
+      collectStructuredTokens(set, value, depth + 1);
+    }
+  }
+}
+function collectRelatedLines(filePath, tokens, tail) {
+  if (!existsSync6(filePath)) {
+    return [];
+  }
+  const lines = readLastLines(filePath, tail);
+  if (tokens.length === 0) {
+    return lines.slice(-Math.min(30, lines.length));
+  }
+  const related = lines.filter((line) => tokens.some((token) => line.includes(token)));
+  if (related.length > 0) {
+    return related.slice(-Math.min(80, related.length));
+  }
+  return lines.slice(-Math.min(20, lines.length));
+}
+function printTraceSection(title, filePath, lines) {
+  console.log(`
+${title}: ${filePath}`);
+  if (!existsSync6(filePath)) {
+    console.log("  (file not found)");
+    return;
+  }
+  if (lines.length === 0) {
+    console.log("  (no related lines)");
+    return;
+  }
+  for (const line of lines.slice(-20)) {
+    console.log(`  ${line}`);
+  }
+}
+
+// src/commands/logs.ts
+import { existsSync as existsSync7 } from "fs";
+import { formatRuntimeAlert } from "@fiber-pay/runtime";
+import { Command as Command7 } from "commander";
+var ALLOWED_SOURCES = /* @__PURE__ */ new Set([
+  "all",
+  "runtime",
+  "fnn-stdout",
+  "fnn-stderr"
+]);
+function parseRuntimeAlertLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function formatRuntimeAlertHuman(line) {
+  const parsed = parseRuntimeAlertLine(line);
+  if (!parsed) {
+    return line;
+  }
+  return formatRuntimeAlert(parsed);
+}
+function coerceJsonLineForOutput(source, line) {
+  if (source !== "runtime") {
+    return 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("--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 sourceInput = String(options.source ?? "all").trim().toLowerCase();
+    if (json && follow) {
+      const message = "--follow is not supported with --json. Use human mode for streaming logs.";
+      printJsonError({
+        code: "LOG_FOLLOW_JSON_UNSUPPORTED",
+        message,
+        recoverable: true,
+        suggestion: "Remove --json or remove --follow and retry."
+      });
+      process.exit(1);
+    }
+    if (!ALLOWED_SOURCES.has(sourceInput)) {
+      const message = "Invalid --source value. Expected one of: all, runtime, fnn-stdout, fnn-stderr.";
+      if (json) {
+        printJsonError({
+          code: "LOG_SOURCE_INVALID",
+          message,
+          recoverable: true,
+          suggestion: "Retry with --source all|runtime|fnn-stdout|fnn-stderr.",
+          details: { source: sourceInput }
+        });
+      } else {
+        console.error(`Error: ${message}`);
+      }
+      process.exit(1);
+    }
+    const source = sourceInput;
+    const tailInput = Number.parseInt(String(options.tail ?? "80"), 10);
+    const tail = Number.isFinite(tailInput) && tailInput > 0 ? tailInput : 80;
+    const intervalInput = Number.parseInt(String(options.intervalMs ?? "1000"), 10);
+    const intervalMs = Number.isFinite(intervalInput) && intervalInput > 0 ? intervalInput : 1e3;
+    const meta = readRuntimeMeta(config.dataDir);
+    const paths = resolvePersistedLogPaths(config.dataDir, meta);
+    const targets = resolvePersistedLogTargets(paths, source);
+    if (source !== "all" && targets.length === 1 && !existsSync7(targets[0].path)) {
+      const message = `Log file not found for source ${source}: ${targets[0].path}`;
+      if (json) {
+        printJsonError({
+          code: "LOG_FILE_NOT_FOUND",
+          message,
+          recoverable: true,
+          suggestion: "Start node/runtime or generate activity, then retry logs command.",
+          details: { source, path: targets[0].path }
+        });
+      } else {
+        console.error(`Error: ${message}`);
+      }
+      process.exit(1);
+    }
+    const entries = [];
+    for (const target of targets) {
+      const exists = existsSync7(target.path);
+      let lines = [];
+      if (exists) {
+        try {
+          lines = readLastLines(target.path, tail);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : `Failed to read log file: ${target.path}`;
+          if (json) {
+            printJsonError({
+              code: "LOG_READ_FAILED",
+              message,
+              recoverable: true,
+              suggestion: "Check log file permissions and retry.",
+              details: { source: target.source, path: target.path }
+            });
+          } else {
+            console.error(`Error: ${message}`);
+          }
+          process.exit(1);
+        }
+      }
+      entries.push({
+        source: target.source,
+        title: target.title,
+        path: target.path,
+        exists,
+        lineCount: lines.length,
+        lines,
+        jsonLines: lines.map((line) => coerceJsonLineForOutput(target.source, line))
+      });
+    }
+    if (json) {
+      printJsonSuccess({
+        source,
+        tail,
+        entries: entries.map((entry) => ({
+          source: entry.source,
+          title: entry.title,
+          path: entry.path,
+          exists: entry.exists,
+          lineCount: entry.lineCount,
+          lines: entry.jsonLines
+        }))
+      });
+      return;
+    }
+    console.log(`Logs (source: ${source}, tail: ${tail})`);
+    for (const entry of entries) {
+      console.log(`
+${entry.title}: ${entry.path}`);
+      if (!entry.exists) {
+        console.log("  (file not found)");
+        continue;
+      }
+      if (entry.lines.length === 0) {
+        console.log("  (no lines)");
+        continue;
+      }
+      for (const line of entry.lines) {
+        const output = entry.source === "runtime" ? formatRuntimeAlertHuman(line) : line;
+        console.log(`  ${output}`);
+      }
+    }
+    if (!follow) {
+      return;
+    }
+    console.log(`
+Following logs (interval: ${intervalMs}ms). Press Ctrl+C to stop.`);
+    const states = new Map(
+      entries.map((entry) => [
+        entry.source,
+        {
+          title: entry.title,
+          path: entry.path,
+          seenLines: entry.exists ? entry.lines.length : 0
+        }
+      ])
+    );
+    await new Promise((resolve2) => {
+      let stopped = false;
+      const stop = () => {
+        if (stopped) return;
+        stopped = true;
+        clearInterval(timer);
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        console.log("\nStopped following logs.");
+        resolve2();
+      };
+      const timer = setInterval(() => {
+        for (const target of targets) {
+          const state = states.get(target.source);
+          if (!state) continue;
+          if (!existsSync7(state.path)) {
+            continue;
+          }
+          const allLines = readLastLines(state.path, Number.MAX_SAFE_INTEGER);
+          const total = allLines.length;
+          const fromIndex = total < state.seenLines ? 0 : state.seenLines;
+          const newLines = allLines.slice(fromIndex);
+          if (newLines.length === 0) {
+            continue;
+          }
+          for (const line of newLines) {
+            const output = target.source === "runtime" ? formatRuntimeAlertHuman(line) : line;
+            console.log(`[${state.title}] ${output}`);
+          }
+          state.seenLines = total;
+        }
+      }, intervalMs);
+      process.on("SIGINT", stop);
+      process.on("SIGTERM", stop);
+    });
+  });
+}
+
+// src/commands/node.ts
+import { nodeIdToPeerId as nodeIdToPeerId2, scriptToAddress as scriptToAddress2 } from "@fiber-pay/sdk";
+import { Command as Command8 } from "commander";
+
+// src/lib/node-runtime-daemon.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+function getCustomBinaryState(binaryPath) {
+  const exists = existsSync8(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-log-file",
+      params.alertLogFile,
+      "--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/node-start.ts
+import { spawn } from "child_process";
+import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+import {
+  ensureFiberBinary,
+  getDefaultBinaryPath,
+  ProcessManager
+} from "@fiber-pay/node";
+import { startRuntimeService } from "@fiber-pay/runtime";
+import { createKeyManager } from "@fiber-pay/sdk";
+
+// src/lib/bootnode.ts
+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 = readFileSync6(configFilePath, "utf-8");
+    const doc = parseYaml(content);
+    const addrs = doc?.fiber?.bootnode_addrs;
+    if (!Array.isArray(addrs)) return [];
+    return addrs.filter((a) => typeof a === "string" && a.startsWith("/ip"));
+  } catch {
+    return [];
+  }
+}
+async function autoConnectBootnodes(rpc, bootnodes) {
+  if (bootnodes.length === 0) return;
+  console.log(`\u{1F517} Connecting to ${bootnodes.length} bootnode(s)...`);
+  for (const addr of bootnodes) {
+    const shortId = addr.match(/\/p2p\/(.+)$/)?.[1]?.slice(0, 12) || addr.slice(-12);
+    try {
+      await rpc.connectPeer({ address: addr });
+      console.log(`   \u2705 Connected to ${shortId}...`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.toLowerCase().includes("already")) {
+        console.log(`   \u2705 Already connected to ${shortId}...`);
+      } else {
+        console.error(`   \u26A0\uFE0F  Failed to connect to ${shortId}...: ${msg}`);
+      }
+    }
+  }
+}
+
+// src/lib/node-start.ts
+async function runNodeStartCommand(config, options) {
+  const json = Boolean(options.json);
+  const daemon = Boolean(options.daemon);
+  const isNodeChild = process.env.FIBER_NODE_CHILD === "1";
+  const quietFnn = Boolean(options.quietFnn);
+  const eventStream = String(options.eventStream ?? "jsonl").toLowerCase();
+  const emitStage = (stage, status, data) => {
+    if (!json) return;
+    printJsonEvent("startup_stage", { stage, status, ...data });
+  };
+  const emitFnnLog = (stream, text) => {
+    if (quietFnn) {
+      return;
+    }
+    if (json) {
+      printJsonEvent("fnn_log", { stream, text });
+      return;
+    }
+    const target = stream === "stderr" ? process.stderr : process.stdout;
+    const payload = text.endsWith("\n") ? text : `${text}
+`;
+    target.write(`[fnn:${stream}] ${payload}`);
+  };
+  if (json && eventStream !== "jsonl") {
+    printJsonError({
+      code: "NODE_EVENT_STREAM_INVALID",
+      message: `Unsupported --event-stream format: ${options.eventStream}. Expected: jsonl`,
+      recoverable: true,
+      suggestion: "Use `--event-stream jsonl` when using --json.",
+      details: { provided: options.eventStream, expected: ["jsonl"] }
+    });
+    process.exit(1);
+  }
+  if (daemon && !isNodeChild) {
+    const cliEntrypoint = process.argv[1];
+    if (!cliEntrypoint) {
+      const message = "Unable to resolve CLI entrypoint path for --daemon mode";
+      if (json) {
+        printJsonError({
+          code: "NODE_DAEMON_START_FAILED",
+          message,
+          recoverable: true,
+          suggestion: "Retry without --daemon or check CLI invocation method."
+        });
+      } else {
+        console.error(`\u274C ${message}`);
+      }
+      process.exit(1);
+    }
+    const childArgs = process.argv.slice(2).filter((arg) => arg !== "--daemon");
+    const child = spawn(process.execPath, [cliEntrypoint, ...childArgs], {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        FIBER_NODE_CHILD: "1",
+        FIBER_NODE_RUNTIME_DAEMON: "1"
+      }
+    });
+    child.unref();
+    const childPid = child.pid;
+    if (!childPid) {
+      const message = "Failed to spawn node daemon process";
+      if (json) {
+        printJsonError({
+          code: "NODE_DAEMON_START_FAILED",
+          message,
+          recoverable: true,
+          suggestion: "Retry node start and inspect system process limits."
+        });
+      } else {
+        console.error(`\u274C ${message}`);
+      }
+      process.exit(1);
+    }
+    if (json) {
+      printJsonEvent("node_daemon_starting", {
+        pid: childPid,
+        runtimeDaemon: true
+      });
+    } else {
+      console.log(`Node daemon starting (PID: ${childPid})`);
+      console.log("Use `fiber-pay node status --json` to verify readiness.");
+    }
+    return;
+  }
+  emitStage("init", "ok", { rpcUrl: config.rpcUrl, dataDir: config.dataDir });
+  const existingPid = readPidFile(config.dataDir);
+  if (existingPid && isProcessRunning(existingPid)) {
+    if (json) {
+      printJsonError({
+        code: "NODE_ALREADY_RUNNING",
+        message: `Node is already running (PID: ${existingPid})`,
+        recoverable: true,
+        suggestion: "Skip start or run `fiber-pay node stop` before retrying.",
+        details: { pid: existingPid }
+      });
+    } else {
+      console.log(`\u274C Node is already running (PID: ${existingPid})`);
+    }
+    process.exit(1);
+  }
+  const runtimeDaemon = process.env.FIBER_NODE_RUNTIME_DAEMON === "1";
+  const runtimeProxyListen = String(
+    options.runtimeProxyListen ?? config.runtimeProxyListen ?? "127.0.0.1:8229"
+  );
+  const proxyListenSource = options.runtimeProxyListen ? "cli" : config.runtimeProxyListen ? "profile" : "default";
+  const runtimeStateFilePath = join5(config.dataDir, "runtime-state.json");
+  const logsDir = join5(config.dataDir, "logs");
+  const fnnStdoutLogPath = join5(logsDir, "fnn.stdout.log");
+  const fnnStderrLogPath = join5(logsDir, "fnn.stderr.log");
+  const runtimeAlertLogPath = join5(logsDir, "runtime.alerts.jsonl");
+  mkdirSync2(logsDir, { recursive: true });
+  const binaryPath = config.binaryPath || getDefaultBinaryPath();
+  await ensureFiberBinary();
+  const binaryVersion = getBinaryVersion(binaryPath);
+  const configFilePath = ensureNodeConfigFile(config.dataDir, config.network);
+  emitStage("binary_resolved", "ok", {
+    binaryPath,
+    binaryVersion,
+    configFilePath
+  });
+  if (!json) {
+    console.log(`\u{1F9E9} Binary: ${binaryPath}`);
+    console.log(`\u{1F9E9} Version: ${binaryVersion}`);
+  }
+  const nodeConfig = {
+    binaryPath,
+    dataDir: config.dataDir,
+    configFilePath,
+    chain: config.network,
+    keyPassword: config.keyPassword
+  };
+  try {
+    const keyManager = createKeyManager(config.dataDir, {
+      encryptionPassword: config.keyPassword,
+      autoGenerate: true
+    });
+    await keyManager.initialize();
+    emitStage("key_initialized", "ok", {});
+  } catch (error) {
+    const message = `Failed to initialize node keys: ${error instanceof Error ? error.message : String(error)}`;
+    emitStage("key_initialized", "error", { code: "NODE_KEY_INIT_FAILED", message });
+    if (json) {
+      printJsonError({
+        code: "NODE_KEY_INIT_FAILED",
+        message,
+        recoverable: true,
+        suggestion: "Verify key password and write permission for the data directory.",
+        details: { dataDir: config.dataDir }
+      });
+    } else {
+      console.error(`\u274C ${message}`);
+    }
+    process.exit(1);
+  }
+  const processManager = new ProcessManager(nodeConfig);
+  let earlyStop = null;
+  const formatStopDetails = (stop) => {
+    if (!stop) return "";
+    return ` (code: ${stop.code ?? "null"}, signal: ${stop.signal ?? "null"})`;
+  };
+  processManager.on("stopped", (code, signal) => {
+    earlyStop = { code, signal };
+    removePidFile(config.dataDir);
+  });
+  processManager.on("stdout", (text) => {
+    appendFileSync(fnnStdoutLogPath, text, "utf-8");
+    emitFnnLog("stdout", text);
+  });
+  processManager.on("stderr", (text) => {
+    appendFileSync(fnnStderrLogPath, text, "utf-8");
+    emitFnnLog("stderr", text);
+  });
+  await processManager.start();
+  const processManagerState = processManager;
+  const processId = processManagerState.process?.pid;
+  if (processId !== void 0) {
+    writePidFile(config.dataDir, processId);
+  }
+  emitStage("process_started", "ok", { pid: processId ?? null });
+  let runtime;
+  const rpc = createRpcClient(config);
+  let rpcReady = true;
+  try {
+    await rpc.waitForReady({ timeout: 3e4, interval: 500 });
+  } catch {
+    rpcReady = false;
+  }
+  if (earlyStop || processManager.getState() === "stopped") {
+    const details = formatStopDetails(earlyStop);
+    emitStage("process_started", "error", {
+      code: "NODE_STARTUP_EXITED",
+      details
+    });
+    if (json) {
+      printJsonError({
+        code: "NODE_STARTUP_EXITED",
+        message: `Fiber node exited during startup${details}`,
+        recoverable: true,
+        suggestion: "Inspect fnn logs and verify config ports are free before retrying.",
+        details: earlyStop ?? void 0
+      });
+    } else {
+      console.error(`\u274C Fiber node exited during startup${details}`);
+    }
+    removePidFile(config.dataDir);
+    if (runtimeDaemon) {
+      stopRuntimeDaemonFromNode({ dataDir: config.dataDir, rpcUrl: config.rpcUrl });
+    } else if (runtime) {
+      await runtime.stop().catch(() => void 0);
+    }
+    removeRuntimeFiles(config.dataDir);
+    process.exit(1);
+  }
+  try {
+    if (runtimeDaemon) {
+      const daemonStart = startRuntimeDaemonFromNode({
+        dataDir: config.dataDir,
+        rpcUrl: config.rpcUrl,
+        proxyListen: runtimeProxyListen,
+        stateFilePath: runtimeStateFilePath,
+        alertLogFile: runtimeAlertLogPath
+      });
+      if (!daemonStart.ok) {
+        throw new Error(daemonStart.message);
+      }
+    } else {
+      runtime = await startRuntimeService({
+        fiberRpcUrl: config.rpcUrl,
+        proxy: {
+          enabled: true,
+          listen: runtimeProxyListen
+        },
+        storage: {
+          stateFilePath: runtimeStateFilePath
+        },
+        alerts: [{ type: "stdout" }, { type: "file", path: runtimeAlertLogPath }],
+        jobs: {
+          enabled: true,
+          dbPath: join5(config.dataDir, "runtime-jobs.db")
+        }
+      });
+      const runtimeStatus = runtime.service.getStatus();
+      writeRuntimePid(config.dataDir, process.pid);
+      writeRuntimeMeta(config.dataDir, {
+        pid: process.pid,
+        startedAt: runtimeStatus.startedAt,
+        fiberRpcUrl: runtimeStatus.targetUrl,
+        proxyListen: runtimeStatus.proxyListen,
+        stateFilePath: runtimeStateFilePath,
+        alertLogFilePath: runtimeAlertLogPath,
+        fnnStdoutLogPath,
+        fnnStderrLogPath,
+        daemon: false
+      });
+    }
+    emitStage("runtime_started", "ok", {
+      proxyListen: runtimeProxyListen,
+      daemon: runtimeDaemon
+    });
+  } catch (error) {
+    const message = `Runtime failed to start: ${error instanceof Error ? error.message : String(error)}`;
+    emitStage("runtime_started", "error", {
+      code: "NODE_RUNTIME_START_FAILED",
+      message,
+      proxyListen: runtimeProxyListen
+    });
+    if (json) {
+      printJsonError({
+        code: "NODE_RUNTIME_START_FAILED",
+        message,
+        recoverable: true,
+        suggestion: "Retry with a free --runtime-proxy-listen port.",
+        details: {
+          runtimeProxyListen
+        }
+      });
+    } else {
+      console.error(`\u274C ${message}`);
+    }
+    removeRuntimeFiles(config.dataDir);
+    removePidFile(config.dataDir);
+    await processManager.stop().catch(() => void 0);
+    process.exit(1);
+  }
+  if (!rpcReady) {
+    emitStage("rpc_ready", "error", {
+      code: "NODE_RPC_NOT_READY",
+      timeoutSeconds: 30
+    });
+    if (json) {
+      printJsonError({
+        code: "NODE_RPC_NOT_READY",
+        message: "RPC did not become ready within 30s. Node startup failed.",
+        recoverable: true,
+        suggestion: "Retry after a delay and verify RPC port + config consistency.",
+        details: { timeoutSeconds: 30, rpcUrl: config.rpcUrl }
+      });
+    } else {
+      console.error("\u274C RPC did not become ready within 30s. Node startup failed.");
+    }
+    const stderrTail = processManager.getStderr(12).join("").trim();
+    const stdoutTail = processManager.getStdout(12).join("").trim();
+    if (!json && stderrTail.length > 0) {
+      console.error("--- fnn stderr (tail) ---");
+      console.error(stderrTail);
+    }
+    if (!json && stdoutTail.length > 0) {
+      console.error("--- fnn stdout (tail) ---");
+      console.error(stdoutTail);
+    }
+    removePidFile(config.dataDir);
+    if (runtimeDaemon) {
+      stopRuntimeDaemonFromNode({ dataDir: config.dataDir, rpcUrl: config.rpcUrl });
+    } else if (runtime) {
+      await runtime.stop().catch(() => void 0);
+      removeRuntimeFiles(config.dataDir);
+    }
+    await processManager.stop().catch(() => void 0);
+    process.exit(1);
+  }
+  emitStage("rpc_ready", "ok", { rpcUrl: config.rpcUrl });
+  const bootnodes = nodeConfig.configFilePath ? extractBootnodeAddrs(nodeConfig.configFilePath) : extractBootnodeAddrs(join5(config.dataDir, "config.yml"));
+  if (bootnodes.length > 0) {
+    await autoConnectBootnodes(rpc, bootnodes);
+  }
+  emitStage("bootnodes_connected", "ok", { count: bootnodes.length });
+  if (earlyStop || processManager.getState() === "stopped") {
+    const details = formatStopDetails(earlyStop);
+    emitStage("bootnodes_connected", "error", {
+      code: "NODE_STARTUP_EXITED",
+      details
+    });
+    if (json) {
+      printJsonError({
+        code: "NODE_STARTUP_EXITED",
+        message: `Fiber node exited during startup${details}`,
+        recoverable: true,
+        suggestion: "Inspect fnn logs and verify config ports are free before retrying.",
+        details: earlyStop ?? void 0
+      });
+    } else {
+      console.error(`\u274C Fiber node exited during startup${details}`);
+    }
+    removePidFile(config.dataDir);
+    process.exit(1);
+  }
+  if (json) {
+    emitStage("startup_complete", "ok", {
+      pid: processId ?? null,
+      rpcUrl: config.rpcUrl
+    });
+    printJsonEvent("node_started", {
+      rpcUrl: config.rpcUrl,
+      binaryPath,
+      binaryVersion,
+      pid: processId ?? null,
+      runtimeEnabled: true,
+      runtimeDaemon,
+      quietFnn,
+      proxyUrl: `http://${runtimeProxyListen}`,
+      proxyListenSource,
+      logs: {
+        fnnStdout: fnnStdoutLogPath,
+        fnnStderr: fnnStderrLogPath,
+        runtimeAlerts: runtimeAlertLogPath
+      }
+    });
+  } else {
+    console.log("\u2705 Fiber node started successfully!");
+    console.log(`   RPC endpoint: ${config.rpcUrl}`);
+    console.log(
+      `   Runtime proxy: http://${runtimeProxyListen} (browser-safe endpoint + monitoring)`
+    );
+    console.log(`   Runtime mode:  ${runtimeDaemon ? "daemon" : "embedded"}`);
+    console.log(`   Log files:     ${logsDir}`);
+    console.log("   Press Ctrl+C to stop.");
+  }
+  let shutdownRequested = false;
+  const shutdown = async () => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    if (!json) {
+      console.log("\n\u{1F6D1} Shutting down...");
+    }
+    if (runtimeDaemon) {
+      stopRuntimeDaemonFromNode({ dataDir: config.dataDir, rpcUrl: config.rpcUrl });
+    } else if (runtime) {
+      await runtime.stop();
+    }
+    removeRuntimeFiles(config.dataDir);
+    removePidFile(config.dataDir);
+    await processManager.stop();
+    if (json) {
+      printJsonEvent("node_stopped", { reason: "signal" });
+    } else {
+      console.log("\u2705 Node stopped.");
+    }
+  };
+  await new Promise((resolve2) => {
+    const keepAlive = setInterval(() => void 0, 6e4);
+    const cleanup = () => {
+      clearInterval(keepAlive);
+      process.off("SIGINT", onSigInt);
+      process.off("SIGTERM", onSigTerm);
+      processManager.off("stopped", onStopped);
+      resolve2();
+    };
+    const onStopped = () => {
+      cleanup();
+    };
+    const onSigInt = () => {
+      shutdown().finally(cleanup);
+    };
+    const onSigTerm = () => {
+      shutdown().finally(cleanup);
+    };
+    process.on("SIGINT", onSigInt);
+    process.on("SIGTERM", onSigTerm);
+    processManager.on("stopped", onStopped);
+  });
+  if (!shutdownRequested) {
+    if (json) {
+      printJsonError({
+        code: "NODE_STOPPED_UNEXPECTEDLY",
+        message: "Fiber node stopped unexpectedly.",
+        recoverable: true,
+        suggestion: "Check process logs and restart the node when configuration is healthy."
+      });
+    } else {
+      console.error("\u274C Fiber node stopped unexpectedly.");
+    }
+    removePidFile(config.dataDir);
+    if (runtimeDaemon) {
+      stopRuntimeDaemonFromNode({ dataDir: config.dataDir, rpcUrl: config.rpcUrl });
+    }
+    removeRuntimeFiles(config.dataDir);
+    process.exit(1);
+  }
+}
+
+// src/lib/node-status.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join6 } from "path";
+import { getFiberBinaryInfo as getFiberBinaryInfo2 } from "@fiber-pay/node";
+import {
+  buildMultiaddrFromNodeId,
+  buildMultiaddrFromRpcUrl,
+  ChannelState as ChannelState2,
+  nodeIdToPeerId,
+  scriptToAddress
+} from "@fiber-pay/sdk";
+
+// src/lib/node-recommendation.ts
+function summarizeChannelLiquidity(readyChannels) {
+  const canSend = readyChannels.some((channel) => BigInt(channel.local_balance) > 0n);
+  const canReceive = readyChannels.some((channel) => BigInt(channel.remote_balance) > 0n);
+  let totalLocal = 0n;
+  let totalRemote = 0n;
+  for (const channel of readyChannels) {
+    totalLocal += BigInt(channel.local_balance);
+    totalRemote += BigInt(channel.remote_balance);
+  }
+  return {
+    canSend,
+    canReceive,
+    localCkb: Number(totalLocal) / 1e8,
+    remoteCkb: Number(totalRemote) / 1e8
+  };
+}
+function buildStatusRecommendation(input) {
+  const reasons = [];
+  if (!input.binaryReady) reasons.push("Fiber binary is missing or not executable.");
+  if (!input.configExists) reasons.push("Config file is missing.");
+  if (!input.nodeRunning) reasons.push("Node process is not running.");
+  if (input.nodeRunning && !input.rpcResponsive) {
+    reasons.push("Node process is running but RPC is not reachable.");
+  }
+  if (input.rpcResponsive && input.channelsReady === 0) {
+    reasons.push("No ChannelReady channel found.");
+  }
+  if (input.channelsReady > 0 && !input.canSend && input.canReceive) {
+    reasons.push("Send liquidity is low on ChannelReady channels.");
+  }
+  if (input.channelsReady > 0 && input.canSend && !input.canReceive) {
+    reasons.push("Receive liquidity is low on ChannelReady channels.");
+  }
+  if (input.channelsReady > 0 && !input.canSend && !input.canReceive) {
+    reasons.push("ChannelReady channels exist but liquidity is zero.");
+  }
+  let recommendation = "READY";
+  if (!input.binaryReady) {
+    recommendation = "INSTALL_BINARY";
+  } else if (!input.configExists) {
+    recommendation = "INIT_CONFIG";
+  } else if (!input.nodeRunning) {
+    recommendation = "START_NODE";
+  } else if (!input.rpcResponsive) {
+    recommendation = "WAIT_RPC";
+  } else if (input.channelsReady === 0) {
+    recommendation = "OPEN_CHANNEL";
+  } else if (!input.canSend && !input.canReceive) {
+    recommendation = "NO_LIQUIDITY";
+  } else if (!input.canSend && input.canReceive) {
+    recommendation = "SEND_CAPACITY_LOW";
+  } else if (input.canSend && !input.canReceive) {
+    recommendation = "RECEIVE_CAPACITY_LOW";
+  }
+  return { recommendation, reasons };
+}
+function buildReadyRecommendation(input) {
+  if (!input.nodeRunning) {
+    return {
+      recommendation: "NODE_STOPPED",
+      reasons: ["Node process is not running."]
+    };
+  }
+  if (!input.rpcReachable) {
+    return {
+      recommendation: "RPC_UNREACHABLE",
+      reasons: ["Node process is running but RPC is not reachable."]
+    };
+  }
+  if (input.channelsReady === 0) {
+    return {
+      recommendation: "NEED_CHANNEL",
+      reasons: ["No ChannelReady channel found. Open and wait for channel readiness."]
+    };
+  }
+  if (input.canSend && input.canReceive) {
+    return {
+      recommendation: "READY",
+      reasons: ["Node is reachable and has send/receive liquidity."]
+    };
+  }
+  if (input.canSend) {
+    return {
+      recommendation: "RECEIVE_CAPACITY_LOW",
+      reasons: ["Receive liquidity is low on all ChannelReady channels."]
+    };
+  }
+  if (input.canReceive) {
+    return {
+      recommendation: "SEND_CAPACITY_LOW",
+      reasons: ["Send liquidity is low on all ChannelReady channels."]
+    };
+  }
+  return {
+    recommendation: "NO_LIQUIDITY",
+    reasons: ["ChannelReady channels exist but both local/remote liquidity are zero."]
+  };
+}
+function buildStalePidRecommendation() {
+  return {
+    recommendation: "NODE_STOPPED",
+    reasons: ["Stale PID file detected and cleaned."]
+  };
+}
+
+// src/lib/node-rpc.ts
+var CELLS_PAGE_SIZE = 100;
+async function callJsonRpc(url, method, params) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  }
+  const payload = await response.json();
+  if (payload.error) {
+    const code = payload.error.code ?? "unknown";
+    const message = payload.error.message ?? "JSON-RPC error";
+    throw new Error(`${message} (code: ${code})`);
+  }
+  if (payload.result === void 0) {
+    throw new Error("Missing JSON-RPC result");
+  }
+  return payload.result;
+}
+async function getLockBalanceShannons(ckbRpcUrl, lockScript) {
+  let cursor;
+  let total = 0n;
+  const limitHex = `0x${CELLS_PAGE_SIZE.toString(16)}`;
+  for (let i = 0; i < 2e3; i++) {
+    const params = [{ script: lockScript, script_type: "lock" }, "asc", limitHex];
+    if (cursor) {
+      params.push(cursor);
+    }
+    const page = await callJsonRpc(ckbRpcUrl, "get_cells", params);
+    const cells = page.objects ?? [];
+    for (const cell of cells) {
+      if (cell.output?.capacity) {
+        total += BigInt(cell.output.capacity);
+      }
+    }
+    const nextCursor = page.last_cursor;
+    if (!nextCursor || nextCursor === cursor || cells.length < CELLS_PAGE_SIZE) {
+      break;
+    }
+    cursor = nextCursor;
+  }
+  return total;
+}
+
+// src/lib/node-status.ts
+async function runNodeStatusCommand(config, options) {
+  const json = Boolean(options.json);
+  const pid = readPidFile(config.dataDir);
+  const resolvedRpc = resolveRpcEndpoint(config);
+  const managedBinaryPath = join6(config.dataDir, "bin", "fnn");
+  const binaryInfo = config.binaryPath ? getCustomBinaryState(config.binaryPath) : await getFiberBinaryInfo2(join6(config.dataDir, "bin"));
+  const configExists = existsSync10(config.configPath);
+  const nodeRunning = Boolean(pid && isProcessRunning(pid));
+  let rpcResponsive = false;
+  let nodeId = null;
+  let peerId = null;
+  let peerIdError = null;
+  let multiaddr = null;
+  let multiaddrError = null;
+  let multiaddrInferred = false;
+  let channelsTotal = 0;
+  let channelsReady = 0;
+  let canSend = false;
+  let canReceive = false;
+  let localCkb = 0;
+  let remoteCkb = 0;
+  let fundingAddress = null;
+  let fundingCkb = 0;
+  let fundingBalanceError = null;
+  if (nodeRunning) {
+    try {
+      const rpc = await createReadyRpcClient(config);
+      const nodeInfo = await rpc.nodeInfo();
+      const channels = await rpc.listChannels({ include_closed: false });
+      rpcResponsive = true;
+      nodeId = nodeInfo.node_id;
+      try {
+        peerId = await nodeIdToPeerId(nodeInfo.node_id);
+      } 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);
+        } catch (error) {
+          multiaddrError = error instanceof Error ? error.message : String(error);
+        }
+      } else if (peerId) {
+        try {
+          multiaddr = buildMultiaddrFromRpcUrl(config.rpcUrl, peerId);
+          multiaddrInferred = true;
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : String(error);
+          multiaddrError = `no advertised addresses; infer failed: ${reason}`;
+        }
+      }
+      channelsTotal = channels.channels.length;
+      const readyChannels = channels.channels.filter(
+        (channel) => channel.state?.state_name === ChannelState2.ChannelReady
+      );
+      channelsReady = readyChannels.length;
+      const liquidity = summarizeChannelLiquidity(readyChannels);
+      canSend = liquidity.canSend;
+      canReceive = liquidity.canReceive;
+      localCkb = liquidity.localCkb;
+      remoteCkb = liquidity.remoteCkb;
+      fundingAddress = scriptToAddress(nodeInfo.default_funding_lock_script, config.network);
+      if (config.ckbRpcUrl) {
+        try {
+          const fundingBalance = await getLockBalanceShannons(
+            config.ckbRpcUrl,
+            nodeInfo.default_funding_lock_script
+          );
+          fundingCkb = Number(fundingBalance) / 1e8;
+        } catch (error) {
+          fundingBalanceError = error instanceof Error ? error.message : "Failed to query CKB balance for funding address";
+        }
+      } else {
+        fundingBalanceError = "CKB RPC URL not configured (set ckb.rpc_url in config.yml or FIBER_CKB_RPC_URL)";
+      }
+    } catch {
+      rpcResponsive = false;
+    }
+  } else if (pid) {
+    removePidFile(config.dataDir);
+  }
+  const { recommendation, reasons } = buildStatusRecommendation({
+    binaryReady: binaryInfo.ready,
+    configExists,
+    nodeRunning,
+    rpcResponsive,
+    channelsReady,
+    canSend,
+    canReceive
+  });
+  const output = {
+    running: nodeRunning,
+    pid: pid ?? null,
+    rpcResponsive,
+    rpcUrl: config.rpcUrl,
+    rpcTarget: resolvedRpc.target,
+    resolvedRpcUrl: resolvedRpc.url,
+    nodeId,
+    peerId,
+    peerIdError,
+    multiaddr,
+    multiaddrError,
+    multiaddrInferred,
+    checks: {
+      binary: {
+        path: binaryInfo.path,
+        ready: binaryInfo.ready,
+        version: binaryInfo.version,
+        source: config.binaryPath ? "env-binary-path" : "managed-binary-dir",
+        managedPath: managedBinaryPath
+      },
+      config: {
+        path: config.configPath,
+        exists: configExists,
+        network: config.network,
+        rpcUrl: config.rpcUrl
+      },
+      node: {
+        running: nodeRunning,
+        pid: pid ?? null,
+        rpcReachable: rpcResponsive,
+        rpcTarget: resolvedRpc.target,
+        rpcClientUrl: resolvedRpc.url
+      },
+      channels: {
+        total: channelsTotal,
+        ready: channelsReady,
+        canSend,
+        canReceive
+      }
+    },
+    balance: {
+      totalCkb: localCkb + fundingCkb,
+      channelLocalCkb: localCkb,
+      availableToSend: localCkb,
+      availableToReceive: remoteCkb,
+      channelCount: channelsTotal,
+      activeChannelCount: channelsReady,
+      fundingAddress,
+      fundingAddressTotalCkb: fundingCkb,
+      fundingBalanceError
+    },
+    recommendation,
+    reasons
+  };
+  if (json) {
+    printJsonSuccess(output);
+    return;
+  }
+  if (output.running) {
+    console.log(`\u2705 Node is running (PID: ${output.pid})`);
+    if (output.rpcResponsive) {
+      console.log(`   Node ID: ${String(output.nodeId)}`);
+      if (output.peerId) {
+        console.log(`   Peer ID: ${String(output.peerId)}`);
+      } else if (output.peerIdError) {
+        console.log(`   Peer ID: unavailable (${String(output.peerIdError)})`);
+      }
+      console.log(`   RPC: ${String(output.rpcUrl)}`);
+      console.log(`   RPC Client: ${String(output.rpcTarget)} (${String(output.resolvedRpcUrl)})`);
+      if (output.multiaddr) {
+        const inferredSuffix = output.multiaddrInferred ? " (inferred from RPC + peerId; no advertised addresses)" : "";
+        console.log(`   Multiaddr: ${String(output.multiaddr)}${inferredSuffix}`);
+      } else if (output.multiaddrError) {
+        console.log(`   Multiaddr: unavailable (${String(output.multiaddrError)})`);
+      } else {
+        console.log("   Multiaddr: unavailable");
+      }
+    } else {
+      console.log("   \u26A0\uFE0F  RPC not responding");
+    }
+  } else if (output.pid) {
+    console.log(`\u274C Node is not running (stale PID file: ${output.pid})`);
+  } else {
+    console.log("\u274C Node is not running");
+  }
+  console.log("");
+  console.log("Diagnostics");
+  console.log(`  Binary:        ${output.checks.binary.ready ? "ready" : "missing"}`);
+  console.log(`  Config:        ${output.checks.config.exists ? "present" : "missing"}`);
+  console.log(`  RPC:           ${output.checks.node.rpcReachable ? "reachable" : "unreachable"}`);
+  console.log(
+    `  Channels:      ${output.checks.channels.ready}/${output.checks.channels.total} ready/total`
+  );
+  console.log(`  Can Send:      ${output.checks.channels.canSend ? "yes" : "no"}`);
+  console.log(`  Can Receive:   ${output.checks.channels.canReceive ? "yes" : "no"}`);
+  console.log(`  Recommendation:${output.recommendation}`);
+  if (output.reasons.length > 0) {
+    console.log("  Reasons:");
+    for (const reason of output.reasons) {
+      console.log(`    - ${reason}`);
+    }
+  }
+  console.log("");
+  console.log("Balance");
+  console.log(`  Total CKB:     ${output.balance.totalCkb.toFixed(8)}`);
+  console.log(`  Channel Local: ${output.balance.channelLocalCkb.toFixed(8)}`);
+  console.log(`  To Send:       ${output.balance.availableToSend.toFixed(8)}`);
+  console.log(`  To Receive:    ${output.balance.availableToReceive.toFixed(8)}`);
+  console.log(
+    `  Channels:      ${output.balance.activeChannelCount}/${output.balance.channelCount} active/total`
+  );
+  if (output.balance.fundingAddress) {
+    console.log(`  Funding Addr:  ${output.balance.fundingAddress}`);
+  }
+  console.log(`  Funding CKB:   ${output.balance.fundingAddressTotalCkb.toFixed(8)}`);
+  if (output.balance.fundingBalanceError) {
+    console.log(`  Funding Err:   ${output.balance.fundingBalanceError}`);
+  }
+}
+async function runNodeReadyCommand(config, options) {
+  const json = Boolean(options.json);
+  const pid = readPidFile(config.dataDir);
+  const output = {
+    nodeRunning: false,
+    rpcReachable: false,
+    channelsTotal: 0,
+    channelsReady: 0,
+    canSend: false,
+    canReceive: false,
+    recommendation: "NODE_STOPPED",
+    reasons: ["Node process is not running."],
+    pid: pid ?? null,
+    rpcUrl: config.rpcUrl
+  };
+  if (pid && isProcessRunning(pid)) {
+    output.nodeRunning = true;
+    output.reasons = [];
+    try {
+      const rpc = await createReadyRpcClient(config);
+      output.rpcReachable = true;
+      const channels = await rpc.listChannels({ include_closed: false });
+      output.channelsTotal = channels.channels.length;
+      const readyChannels = channels.channels.filter(
+        (channel) => channel.state?.state_name === ChannelState2.ChannelReady
+      );
+      output.channelsReady = readyChannels.length;
+      const liquidity = summarizeChannelLiquidity(readyChannels);
+      output.canSend = liquidity.canSend;
+      output.canReceive = liquidity.canReceive;
+      const readyRecommendation = buildReadyRecommendation({
+        nodeRunning: true,
+        rpcReachable: true,
+        channelsReady: readyChannels.length,
+        canSend: liquidity.canSend,
+        canReceive: liquidity.canReceive
+      });
+      output.recommendation = readyRecommendation.recommendation;
+      output.reasons = readyRecommendation.reasons;
+    } catch {
+      output.rpcReachable = false;
+      const readyRecommendation = buildReadyRecommendation({
+        nodeRunning: true,
+        rpcReachable: false,
+        channelsReady: 0,
+        canSend: false,
+        canReceive: false
+      });
+      output.recommendation = readyRecommendation.recommendation;
+      output.reasons = readyRecommendation.reasons;
+    }
+  } else if (pid) {
+    const staleRecommendation = buildStalePidRecommendation();
+    output.recommendation = staleRecommendation.recommendation;
+    output.reasons = staleRecommendation.reasons;
+    removePidFile(config.dataDir);
+  }
+  if (json) {
+    printJsonSuccess(output);
+  } else {
+    console.log("Node Readiness");
+    console.log(`  Node Running:   ${output.nodeRunning ? "yes" : "no"}`);
+    console.log(`  RPC Reachable:  ${output.rpcReachable ? "yes" : "no"}`);
+    console.log(`  Channels:       ${output.channelsReady}/${output.channelsTotal} ready/total`);
+    console.log(`  Can Send:       ${output.canSend ? "yes" : "no"}`);
+    console.log(`  Can Receive:    ${output.canReceive ? "yes" : "no"}`);
+    console.log(`  Recommendation: ${String(output.recommendation)}`);
+    const reasons = Array.isArray(output.reasons) ? output.reasons : [];
+    if (reasons.length > 0) {
+      console.log("  Reasons:");
+      for (const reason of reasons) {
+        console.log(`    - ${String(reason)}`);
+      }
+    }
+  }
+}
+
+// src/commands/node.ts
+function createNodeCommand(config) {
+  const node = new Command8("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);
+  });
+  node.command("stop").option("--json").action(async (options) => {
+    const json = Boolean(options.json);
+    const runtimeMeta = readRuntimeMeta(config.dataDir);
+    const runtimePid = readRuntimePid(config.dataDir);
+    if (runtimeMeta?.daemon && runtimePid && isProcessRunning(runtimePid)) {
+      stopRuntimeDaemonFromNode({ dataDir: config.dataDir, rpcUrl: config.rpcUrl });
+    }
+    removeRuntimeFiles(config.dataDir);
+    const pid = readPidFile(config.dataDir);
+    if (!pid) {
+      if (json) {
+        printJsonError({
+          code: "NODE_NOT_RUNNING",
+          message: "No PID file found. Node may not be running.",
+          recoverable: true,
+          suggestion: "Run `fiber-pay node start` first if you intend to stop a node."
+        });
+      } else {
+        console.log("\u274C No PID file found. Node may not be running.");
+      }
+      process.exit(1);
+    }
+    if (!isProcessRunning(pid)) {
+      if (json) {
+        printJsonError({
+          code: "NODE_NOT_RUNNING",
+          message: `Process ${pid} is not running. Cleaning up PID file.`,
+          recoverable: true,
+          suggestion: "Start the node again if needed; stale PID has been cleaned.",
+          details: { pid, stalePidFileCleaned: true }
+        });
+      } else {
+        console.log(`\u274C Process ${pid} is not running. Cleaning up PID file.`);
+      }
+      removePidFile(config.dataDir);
+      process.exit(1);
+    }
+    if (!json) {
+      console.log(`\u{1F6D1} Stopping node (PID: ${pid})...`);
+    }
+    process.kill(pid, "SIGTERM");
+    let attempts = 0;
+    while (isProcessRunning(pid) && attempts < 30) {
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      attempts++;
+    }
+    if (isProcessRunning(pid)) {
+      process.kill(pid, "SIGKILL");
+    }
+    removePidFile(config.dataDir);
+    if (json) {
+      printJsonSuccess({ pid, stopped: true });
+    } else {
+      console.log("\u2705 Node stopped.");
+    }
+  });
+  node.command("status").option("--json").action(async (options) => {
+    await runNodeStatusCommand(config, options);
+  });
+  node.command("ready").description("Agent-oriented readiness summary for automation").option("--json").action(async (options) => {
+    await runNodeReadyCommand(config, options);
+  });
+  node.command("info").option("--json").action(async (options) => {
+    const rpc = await createReadyRpcClient(config);
+    const nodeInfo = await rpc.nodeInfo();
+    const fundingAddress = scriptToAddress2(nodeInfo.default_funding_lock_script, config.network);
+    const peerId = await nodeIdToPeerId2(nodeInfo.node_id);
+    const output = {
+      nodeId: nodeInfo.node_id,
+      peerId,
+      addresses: nodeInfo.addresses,
+      chainHash: nodeInfo.chain_hash,
+      fundingAddress,
+      fundingLockScript: nodeInfo.default_funding_lock_script,
+      version: nodeInfo.version,
+      channelCount: parseInt(nodeInfo.channel_count, 16),
+      pendingChannelCount: parseInt(nodeInfo.pending_channel_count, 16),
+      peersCount: parseInt(nodeInfo.peers_count, 16)
+    };
+    if (options.json) {
+      printJsonSuccess(output);
+    } else {
+      printNodeInfoHuman(output);
+    }
+  });
+  return node;
+}
+
+// src/commands/payment.ts
+import { ckbToShannons as ckbToShannons3, shannonsToCkb as shannonsToCkb4 } from "@fiber-pay/sdk";
+import { Command as Command9 } from "commander";
+function createPaymentCommand(config) {
+  const payment = new Command9("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);
+    const invoice = options.invoice || invoiceArg;
+    const recipientNodeId = options.to;
+    const amountCkb = options.amount ? parseFloat(options.amount) : void 0;
+    const maxFeeCkb = options.maxFee ? parseFloat(options.maxFee) : void 0;
+    const shouldWait = Boolean(options.wait);
+    const timeoutSeconds = parseInt(String(options.timeout ?? "120"), 10);
+    if (!invoice && !recipientNodeId) {
+      if (json) {
+        printJsonError({
+          code: "PAYMENT_SEND_INPUT_INVALID",
+          message: "Either invoice or --to <nodeId> required",
+          recoverable: true,
+          suggestion: "Provide a valid invoice, or provide both `--to` and `--amount`."
+        });
+      } else {
+        console.error("Error: Either invoice or --to <nodeId> required");
+      }
+      process.exit(1);
+    }
+    if (recipientNodeId && !amountCkb) {
+      if (json) {
+        printJsonError({
+          code: "PAYMENT_SEND_INPUT_INVALID",
+          message: "--amount required when using --to",
+          recoverable: true,
+          suggestion: "Add `--amount <ckb>` when using keysend mode (`--to`)."
+        });
+      } else {
+        console.error("Error: --amount required when using --to");
+      }
+      process.exit(1);
+    }
+    const paymentParams = {
+      invoice,
+      target_pubkey: recipientNodeId,
+      amount: amountCkb ? ckbToShannons3(amountCkb) : void 0,
+      keysend: recipientNodeId ? true : void 0,
+      max_fee_amount: maxFeeCkb ? ckbToShannons3(maxFeeCkb) : void 0
+    };
+    const endpoint = resolveRpcEndpoint(config);
+    if (endpoint.target === "runtime-proxy") {
+      const created = await tryCreateRuntimePaymentJob(endpoint.url, {
+        params: {
+          invoice,
+          sendPaymentParams: paymentParams
+        },
+        options: {
+          idempotencyKey: invoice ? `payment:invoice:${invoice}` : void 0
+        }
+      });
+      if (created) {
+        const job = shouldWait ? await waitForRuntimeJobTerminal(endpoint.url, created.id, timeoutSeconds) : created;
+        const payload2 = {
+          paymentHash: getJobPaymentHash(job) ?? "unknown",
+          status: job.state === "succeeded" ? "success" : job.state === "failed" || job.state === "cancelled" ? "failed" : "pending",
+          feeCkb: getJobFeeCkb(job),
+          failureReason: getJobFailure(job),
+          jobId: job.id,
+          jobState: job.state
+        };
+        if (json) {
+          printJsonSuccess(payload2);
+        } else {
+          console.log("Payment job submitted");
+          console.log(`  Job:    ${payload2.jobId}`);
+          console.log(`  Hash:   ${payload2.paymentHash}`);
+          console.log(`  Status: ${payload2.status} (${payload2.jobState})`);
+          console.log(`  Fee:    ${payload2.feeCkb} CKB`);
+          if (payload2.failureReason) {
+            console.log(`  Error:  ${payload2.failureReason}`);
+          }
+        }
+        return;
+      }
+    }
+    const result = await rpc.sendPayment(paymentParams);
+    const payload = {
+      paymentHash: result.payment_hash,
+      status: result.status === "Success" ? "success" : result.status === "Failed" ? "failed" : "pending",
+      feeCkb: shannonsToCkb4(result.fee),
+      failureReason: result.failed_error
+    };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log("Payment sent");
+      console.log(`  Hash:   ${payload.paymentHash}`);
+      console.log(`  Status: ${payload.status}`);
+      console.log(`  Fee:    ${payload.feeCkb} CKB`);
+      if (payload.failureReason) {
+        console.log(`  Error:  ${payload.failureReason}`);
+      }
+    }
+  });
+  payment.command("get").argument("<paymentHash>").option("--json").action(async (paymentHash, options) => {
+    const rpc = await createReadyRpcClient(config);
+    const result = await rpc.getPayment({ payment_hash: paymentHash });
+    if (options.json) {
+      printJsonSuccess(formatPaymentResult(result));
+    } else {
+      printPaymentDetailHuman(result);
+    }
+  });
+  payment.command("watch").argument("<paymentHash>").option("--interval <seconds>", "Polling interval", "2").option("--timeout <seconds>", "Timeout", "120").option("--until <target>", "SUCCESS | FAILED | TERMINAL", "TERMINAL").option("--on-timeout <behavior>", "fail | success", "fail").option("--json").action(async (paymentHash, options) => {
+    const json = Boolean(options.json);
+    const intervalSeconds = parseInt(options.interval, 10);
+    const timeoutSeconds = parseInt(options.timeout, 10);
+    const until = String(options.until ?? "TERMINAL").trim().toUpperCase();
+    const onTimeout = String(options.onTimeout ?? "fail").trim().toLowerCase();
+    if (!["SUCCESS", "FAILED", "TERMINAL"].includes(until)) {
+      if (json) {
+        printJsonError({
+          code: "PAYMENT_WATCH_INPUT_INVALID",
+          message: `Invalid --until value: ${options.until}. Expected SUCCESS, FAILED, or TERMINAL`,
+          recoverable: true,
+          suggestion: "Use one of: SUCCESS, FAILED, TERMINAL.",
+          details: { provided: options.until, expected: ["SUCCESS", "FAILED", "TERMINAL"] }
+        });
+      } else {
+        console.error(
+          `Error: Invalid --until value: ${options.until}. Expected SUCCESS, FAILED, or TERMINAL`
+        );
+      }
+      process.exit(1);
+    }
+    if (!["fail", "success"].includes(onTimeout)) {
+      if (json) {
+        printJsonError({
+          code: "PAYMENT_WATCH_INPUT_INVALID",
+          message: `Invalid --on-timeout value: ${options.onTimeout}. Expected fail or success`,
+          recoverable: true,
+          suggestion: "Use `--on-timeout fail` or `--on-timeout success`.",
+          details: { provided: options.onTimeout, expected: ["fail", "success"] }
+        });
+      } else {
+        console.error(
+          `Error: Invalid --on-timeout value: ${options.onTimeout}. Expected fail or success`
+        );
+      }
+      process.exit(1);
+    }
+    const rpc = await createReadyRpcClient(config);
+    const startedAt = Date.now();
+    let lastStatus;
+    while (Date.now() - startedAt < timeoutSeconds * 1e3) {
+      const paymentResult = await rpc.getPayment({ payment_hash: paymentHash });
+      if (paymentResult.status !== lastStatus) {
+        if (json) {
+          printJsonEvent("status_transition", {
+            statusTransition: {
+              from: lastStatus ?? null,
+              to: paymentResult.status
+            },
+            payment: formatPaymentResult(paymentResult)
+          });
+        } else {
+          console.log(`Status: ${lastStatus ?? "(initial)"} -> ${paymentResult.status}`);
+          printPaymentDetailHuman(paymentResult);
+          console.log("");
+        }
+        lastStatus = paymentResult.status;
+      }
+      const isSuccess = paymentResult.status === "Success";
+      const isFailed = paymentResult.status === "Failed";
+      const terminalReached = until === "TERMINAL" ? isSuccess || isFailed : until === "SUCCESS" ? isSuccess : isFailed;
+      if (terminalReached) {
+        if (json) {
+          printJsonEvent("terminal", {
+            paymentHash,
+            terminalStatus: paymentResult.status,
+            until
+          });
+        }
+        return;
+      }
+      if ((isSuccess || isFailed) && until !== "TERMINAL") {
+        if (json) {
+          printJsonError({
+            code: "PAYMENT_WATCH_UNEXPECTED_TERMINAL",
+            message: `Payment reached ${paymentResult.status} before requested --until ${until}`,
+            recoverable: true,
+            suggestion: "Set `--until TERMINAL` or handle mismatched terminal state in caller.",
+            details: { terminalStatus: paymentResult.status, until }
+          });
+        } else {
+          console.error(
+            `Error: Payment reached ${paymentResult.status} before requested --until ${until}`
+          );
+        }
+        process.exit(1);
+      }
+      await sleep(intervalSeconds * 1e3);
+    }
+    if (onTimeout === "success") {
+      if (json) {
+        printJsonEvent("terminal", {
+          paymentHash,
+          terminalStatus: "Timeout",
+          until,
+          timeoutSeconds
+        });
+      } else {
+        console.log(
+          `Timeout reached (${timeoutSeconds}s) and treated as success by --on-timeout=success.`
+        );
+      }
+      return;
+    }
+    if (json) {
+      printJsonError({
+        code: "PAYMENT_WATCH_TIMEOUT",
+        message: `Payment ${paymentHash} did not reach terminal state within ${timeoutSeconds}s`,
+        recoverable: true,
+        suggestion: "Increase timeout, or continue polling using `payment get --json`.",
+        details: { paymentHash, timeoutSeconds }
+      });
+    } else {
+      console.error(
+        `Error: Payment ${paymentHash} did not reach terminal state within ${timeoutSeconds}s`
+      );
+    }
+    process.exit(1);
+  });
+  payment.command("route").description("Build a payment route through specified hops").requiredOption("--hops <pubkeys>", "Comma-separated list of node pubkeys forming the route").option("--amount <ckb>", "Amount in CKB to route").option("--json").action(async (options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    const pubkeys = options.hops.split(",").map((s) => s.trim());
+    if (pubkeys.length === 0 || pubkeys.some((pk) => !pk)) {
+      const msg = "--hops must be a non-empty comma-separated list of pubkeys";
+      if (json) {
+        printJsonError({
+          code: "PAYMENT_ROUTE_INPUT_INVALID",
+          message: msg,
+          recoverable: true,
+          suggestion: "Provide pubkeys: --hops 0xabc...,0xdef..."
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    const hopsInfo = pubkeys.map((pubkey) => ({ pubkey }));
+    const amount = options.amount ? ckbToShannons3(parseFloat(options.amount)) : void 0;
+    const result = await rpc.buildRouter({
+      hops_info: hopsInfo,
+      amount
+    });
+    if (json) {
+      printJsonSuccess({ routerHops: result.router_hops });
+    } else {
+      console.log(`Route built: ${result.router_hops.length} hop(s)`);
+      for (let i = 0; i < result.router_hops.length; i++) {
+        const hop = result.router_hops[i];
+        console.log(`  #${i + 1}`);
+        console.log(`    Target:     ${hop.target}`);
+        console.log(
+          `    Outpoint:   ${hop.channel_outpoint.tx_hash}:${hop.channel_outpoint.index}`
+        );
+        console.log(`    Amount:     ${shannonsToCkb4(hop.amount_received)} CKB`);
+        console.log(`    Expiry:     ${hop.incoming_tlc_expiry}`);
+      }
+    }
+  });
+  payment.command("send-route").description("Send a payment using a pre-built route from `payment route`").requiredOption(
+    "--router <json>",
+    "JSON array of router hops (output of `payment route --json`)"
+  ).option("--invoice <invoice>", "Invoice to pay").option("--payment-hash <hash>", "Payment hash (for keysend)").option("--keysend", "Keysend mode").option("--dry-run", "Simulate\u2014do not actually send").option("--json").action(async (options) => {
+    const rpc = await createReadyRpcClient(config);
+    const json = Boolean(options.json);
+    let router;
+    try {
+      router = JSON.parse(options.router);
+    } catch {
+      const msg = "--router must be a valid JSON array of router hops";
+      if (json) {
+        printJsonError({
+          code: "PAYMENT_SEND_ROUTE_INPUT_INVALID",
+          message: msg,
+          recoverable: true,
+          suggestion: "Pipe --json output of `payment route` into this flag."
+        });
+      } else {
+        console.error(`Error: ${msg}`);
+      }
+      process.exit(1);
+    }
+    const result = await rpc.sendPaymentWithRouter({
+      router,
+      invoice: options.invoice,
+      payment_hash: options.paymentHash,
+      keysend: options.keysend ? true : void 0,
+      dry_run: options.dryRun ? true : void 0
+    });
+    const payload = {
+      paymentHash: result.payment_hash,
+      status: result.status === "Success" ? "success" : result.status === "Failed" ? "failed" : "pending",
+      feeCkb: shannonsToCkb4(result.fee),
+      failureReason: result.failed_error,
+      dryRun: Boolean(options.dryRun)
+    };
+    if (json) {
+      printJsonSuccess(payload);
+    } else {
+      console.log(options.dryRun ? "Payment dry-run complete" : "Payment sent via route");
+      console.log(`  Hash:   ${payload.paymentHash}`);
+      console.log(`  Status: ${payload.status}`);
+      console.log(`  Fee:    ${payload.feeCkb} CKB`);
+      if (payload.failureReason) {
+        console.log(`  Error:  ${payload.failureReason}`);
+      }
+    }
+  });
+  return payment;
+}
+function getJobPaymentHash(job) {
+  const result = job.result;
+  return result?.paymentHash;
+}
+function getJobFeeCkb(job) {
+  const result = job.result;
+  return result?.fee ? shannonsToCkb4(result.fee) : 0;
+}
+function getJobFailure(job) {
+  const result = job.result;
+  return result?.failedError ?? job.error?.message;
+}
+
+// src/commands/peer.ts
+import { Command as Command10 } from "commander";
+function extractPeerIdFromMultiaddr(address) {
+  const match = address.match(/\/p2p\/([^/]+)$/);
+  return match?.[1];
+}
+async function waitForPeerConnected(rpc, peerId, 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;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
+  }
+  return false;
+}
+function createPeerCommand(config) {
+  const peer = new Command10("peer").description("Peer management");
+  peer.command("list").option("--json").action(async (options) => {
+    const rpc = await createReadyRpcClient(config);
+    const peers = await rpc.listPeers();
+    if (options.json) {
+      printJsonSuccess(peers);
+    } else {
+      printPeerListHuman(peers.peers);
+    }
+  });
+  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) {
+      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);
+    if (!connected) {
+      throw new Error(
+        `connect_peer accepted but peer not found in list within ${Math.floor(timeoutMs / 1e3)}s (${peerId})`
+      );
+    }
+    if (options.json) {
+      printJsonSuccess({ address, peerId, message: "Connected" });
+    } else {
+      console.log("\u2705 Connected to peer");
+      console.log(`  Address: ${address}`);
+      console.log(`  Peer ID: ${peerId}`);
+    }
+  });
+  peer.command("disconnect").argument("<peerId>").option("--json").action(async (peerId, options) => {
+    const rpc = await createReadyRpcClient(config);
+    await rpc.disconnectPeer({ peer_id: peerId });
+    if (options.json) {
+      printJsonSuccess({ peerId, message: "Disconnected" });
+    } else {
+      console.log("\u2705 Disconnected peer");
+      console.log(`  Peer ID: ${peerId}`);
+    }
+  });
+  return peer;
+}
+
+// src/commands/runtime.ts
+import { spawn as spawn2 } from "child_process";
+import { resolve } from "path";
+import {
+  alertPriorityOrder,
+  formatRuntimeAlert as formatRuntimeAlert2,
+  isAlertPriority,
+  isAlertType,
+  startRuntimeService as startRuntimeService2
+} from "@fiber-pay/runtime";
+import { Command as Command11 } from "commander";
+
+// src/lib/parse-options.ts
+function parseIntegerOption(value, name) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${name}: ${value}. Expected positive integer.`);
+  }
+  return parsed;
+}
+function parseBoolOption(value, name) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  throw new Error(`Invalid ${name}: ${value}. Expected true|false.`);
+}
+
+// src/commands/runtime.ts
+function formatRuntimeAlertLine(alert) {
+  return formatRuntimeAlert2(alert);
+}
+function parseAlertPriorityOption(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!isAlertPriority(normalized)) {
+    throw new Error(`Invalid log-min-priority: ${value}. Expected critical|high|medium|low.`);
+  }
+  return normalized;
+}
+function parseAlertTypesOption(value) {
+  if (!value) {
+    return void 0;
+  }
+  const tokens = value.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return void 0;
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    if (!isAlertType(token)) {
+      throw new Error(`Invalid log-type: ${token}. Use runtime alert type names, comma-separated.`);
+    }
+    result.add(token);
+  }
+  return result;
+}
+function shouldPrintAlert(alert, filter) {
+  if (filter.minPriority) {
+    const minimumRank = alertPriorityOrder[filter.minPriority];
+    if (alertPriorityOrder[alert.priority] < minimumRank) {
+      return false;
+    }
+  }
+  if (filter.types && filter.types.size > 0 && !filter.types.has(alert.type)) {
+    return false;
+  }
+  return true;
+}
+function createRuntimeCommand(config) {
+  const runtime = new Command11("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").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)"
+  ).option("--log-type <types>", "Comma-separated runtime alert types to print").option("--json").action(async (options) => {
+    const asJson = Boolean(options.json);
+    const daemon = Boolean(options.daemon);
+    const isRuntimeChild = process.env.FIBER_RUNTIME_CHILD === "1";
+    try {
+      const existingPid = readRuntimePid(config.dataDir);
+      if (existingPid && isProcessRunning(existingPid) && (!isRuntimeChild || existingPid !== process.pid)) {
+        const message = `Runtime already running (PID: ${existingPid})`;
+        if (asJson) {
+          printJsonError({
+            code: "RUNTIME_ALREADY_RUNNING",
+            message,
+            recoverable: true,
+            suggestion: "Run `fiber-pay runtime status` or `fiber-pay runtime stop` first."
+          });
+        } else {
+          console.error(`Error: ${message}`);
+        }
+        process.exit(1);
+      }
+      if (existingPid && !isProcessRunning(existingPid)) {
+        removeRuntimeFiles(config.dataDir);
+      }
+      if (daemon && !isRuntimeChild) {
+        const childArgv = process.argv.filter((arg) => arg !== "--daemon");
+        const child = spawn2(process.execPath, childArgv.slice(1), {
+          detached: true,
+          stdio: "ignore",
+          cwd: process.cwd(),
+          env: {
+            ...process.env,
+            FIBER_RUNTIME_CHILD: "1"
+          }
+        });
+        child.unref();
+        const childPid = child.pid;
+        if (!childPid) {
+          throw new Error("Failed to spawn runtime daemon process");
+        }
+        writeRuntimePid(config.dataDir, childPid);
+        if (asJson) {
+          printJsonSuccess({
+            daemon: true,
+            pid: childPid,
+            message: "Runtime daemon starting"
+          });
+        } else {
+          console.log(`Runtime daemon starting (PID: ${childPid})`);
+        }
+        return;
+      }
+      const runtimeConfig = {
+        fiberRpcUrl: String(options.fiberRpcUrl ?? config.rpcUrl),
+        channelPollIntervalMs: parseIntegerOption(options.channelPollMs, "channel-poll-ms"),
+        invoicePollIntervalMs: parseIntegerOption(options.invoicePollMs, "invoice-poll-ms"),
+        paymentPollIntervalMs: parseIntegerOption(options.paymentPollMs, "payment-poll-ms"),
+        peerPollIntervalMs: parseIntegerOption(options.peerPollMs, "peer-poll-ms"),
+        healthPollIntervalMs: parseIntegerOption(options.healthPollMs, "health-poll-ms"),
+        includeClosedChannels: parseBoolOption(options.includeClosed, "include-closed"),
+        completedItemTtlSeconds: parseIntegerOption(
+          options.completedTtlSeconds,
+          "completed-ttl-seconds"
+        ),
+        proxy: {
+          enabled: true,
+          listen: String(options.proxyListen ?? config.runtimeProxyListen ?? "127.0.0.1:8229")
+        },
+        storage: {
+          stateFilePath: options.stateFile ? resolve(String(options.stateFile)) : resolve(config.dataDir, "runtime-state.json"),
+          flushIntervalMs: parseIntegerOption(options.flushMs, "flush-ms")
+        },
+        jobs: {
+          enabled: true,
+          dbPath: resolve(config.dataDir, "runtime-jobs.db")
+        }
+      };
+      const alertLogFile = options.alertLogFile ? resolve(String(options.alertLogFile)) : resolve(config.dataDir, "logs", "runtime.alerts.jsonl");
+      const alerts = [{ type: "stdout" }];
+      alerts.push({ type: "file", path: alertLogFile });
+      if (options.webhook) {
+        alerts.push({ type: "webhook", url: String(options.webhook) });
+      }
+      if (options.websocket) {
+        alerts.push({ type: "websocket", listen: String(options.websocket) });
+      }
+      runtimeConfig.alerts = alerts;
+      const logFilter = {
+        minPriority: parseAlertPriorityOption(options.logMinPriority),
+        types: parseAlertTypesOption(options.logType)
+      };
+      if (asJson) {
+        printJsonEvent("runtime_starting", {
+          fiberRpcUrl: runtimeConfig.fiberRpcUrl,
+          proxyListen: runtimeConfig.proxy?.listen
+        });
+      } else {
+        console.log("Starting fiber runtime monitor...");
+      }
+      const runtime2 = await startRuntimeService2(runtimeConfig);
+      const status = runtime2.service.getStatus();
+      writeRuntimePid(config.dataDir, process.pid);
+      writeRuntimeMeta(config.dataDir, {
+        pid: process.pid,
+        startedAt: status.startedAt,
+        fiberRpcUrl: status.targetUrl,
+        proxyListen: status.proxyListen,
+        stateFilePath: runtimeConfig.storage?.stateFilePath,
+        alertLogFilePath: alertLogFile,
+        daemon: daemon || isRuntimeChild
+      });
+      runtime2.service.on("alert", (alert) => {
+        if (!shouldPrintAlert(alert, logFilter)) {
+          return;
+        }
+        if (asJson) {
+          printJsonEvent("runtime_alert", alert);
+          return;
+        }
+        console.log(formatRuntimeAlertLine(alert));
+      });
+      if (asJson) {
+        printJsonSuccess({
+          status: "running",
+          fiberRpcUrl: status.targetUrl,
+          proxyListen: status.proxyListen,
+          stateFilePath: runtimeConfig.storage?.stateFilePath,
+          alertLogFile
+        });
+        printJsonEvent("runtime_started", status);
+      } else {
+        console.log(`Fiber RPC:    ${status.targetUrl}`);
+        console.log(`Proxy listen: ${status.proxyListen}`);
+        console.log(`State file:   ${runtimeConfig.storage?.stateFilePath}`);
+        console.log(`Alert log:    ${alertLogFile}`);
+        console.log("Runtime monitor is running. Press Ctrl+C to stop.");
+      }
+      const signal = await runtime2.waitForShutdownSignal();
+      if (asJson) {
+        printJsonEvent("runtime_stopping", { signal });
+      } else {
+        console.log(`Stopping runtime monitor on ${signal}...`);
+      }
+      await runtime2.stop();
+      removeRuntimeFiles(config.dataDir);
+      if (asJson) {
+        printJsonEvent("runtime_stopped", { signal });
+      } else {
+        console.log("Runtime monitor stopped.");
+      }
+    } catch (error) {
+      removeRuntimeFiles(config.dataDir);
+      const message = error instanceof Error ? error.message : String(error);
+      if (asJson) {
+        printJsonError({
+          code: "RUNTIME_START_FAILED",
+          message,
+          recoverable: true,
+          suggestion: "Check RPC URL reachability and runtime option values, then retry."
+        });
+      } else {
+        console.error(`Error: ${message}`);
+      }
+      process.exit(1);
+    }
+  });
+  runtime.command("status").description("Show runtime process and health status").option("--json").action(async (options) => {
+    const asJson = Boolean(options.json);
+    const pid = readRuntimePid(config.dataDir);
+    const meta = readRuntimeMeta(config.dataDir);
+    if (!pid) {
+      if (asJson) {
+        printJsonError({
+          code: "RUNTIME_NOT_RUNNING",
+          message: "Runtime PID file not found.",
+          recoverable: true,
+          suggestion: "Start runtime with `fiber-pay runtime start --daemon`."
+        });
+      } else {
+        console.log("Runtime is not running.");
+      }
+      process.exit(1);
+    }
+    const running = isProcessRunning(pid);
+    if (!running) {
+      removeRuntimeFiles(config.dataDir);
+      if (asJson) {
+        printJsonError({
+          code: "RUNTIME_NOT_RUNNING",
+          message: `Runtime process ${pid} is not running. Stale runtime files cleaned.`,
+          recoverable: true,
+          suggestion: "Start runtime again with `fiber-pay runtime start`.",
+          details: { pid, staleFilesCleaned: true }
+        });
+      } else {
+        console.log(`Runtime process ${pid} is not running. Stale runtime files cleaned.`);
+      }
+      process.exit(1);
+    }
+    let rpcStatus;
+    if (meta?.proxyListen) {
+      try {
+        const response = await fetch(`http://${meta.proxyListen}/monitor/status`);
+        if (response.ok) {
+          rpcStatus = await response.json();
+        }
+      } catch {
+        rpcStatus = void 0;
+      }
+    }
+    const payload = {
+      running: true,
+      pid,
+      meta,
+      proxyStatus: rpcStatus
+    };
+    if (asJson) {
+      printJsonSuccess(payload);
+    } else {
+      console.log(`Runtime is running (PID: ${pid})`);
+      if (meta?.fiberRpcUrl) {
+        console.log(`Fiber RPC:    ${meta.fiberRpcUrl}`);
+      }
+      if (meta?.proxyListen) {
+        console.log(`Proxy listen: ${meta.proxyListen}`);
+      }
+    }
+  });
+  runtime.command("stop").description("Stop runtime process by PID").option("--json").action(async (options) => {
+    const asJson = Boolean(options.json);
+    const pid = readRuntimePid(config.dataDir);
+    if (!pid) {
+      if (asJson) {
+        printJsonError({
+          code: "RUNTIME_NOT_RUNNING",
+          message: "Runtime PID file not found.",
+          recoverable: true,
+          suggestion: "Start runtime first with `fiber-pay runtime start --daemon`."
+        });
+      } else {
+        console.log("Runtime is not running.");
+      }
+      process.exit(1);
+    }
+    if (!isProcessRunning(pid)) {
+      removeRuntimeFiles(config.dataDir);
+      if (asJson) {
+        printJsonError({
+          code: "RUNTIME_NOT_RUNNING",
+          message: `Runtime process ${pid} is not running. Stale runtime files cleaned.`,
+          recoverable: true,
+          suggestion: "Start runtime again if needed.",
+          details: { pid, staleFilesCleaned: true }
+        });
+      } else {
+        console.log(`Runtime process ${pid} is not running. Stale runtime files cleaned.`);
+      }
+      process.exit(1);
+    }
+    process.kill(pid, "SIGTERM");
+    let attempts = 0;
+    while (isProcessRunning(pid) && attempts < 50) {
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      attempts += 1;
+    }
+    if (isProcessRunning(pid)) {
+      process.kill(pid, "SIGKILL");
+    }
+    removeRuntimeFiles(config.dataDir);
+    if (asJson) {
+      printJsonSuccess({ stopped: true, pid });
+    } else {
+      console.log(`Runtime stopped (PID: ${pid})`);
+    }
+  });
+  return runtime;
+}
+
+// src/commands/version.ts
+import { Command as Command12 } from "commander";
+
+// src/lib/build-info.ts
+var CLI_VERSION = "0.1.0-rc.1";
+var CLI_COMMIT = "4e24396aef57755a32c20f2162b88153492d81ec";
+
+// src/commands/version.ts
+function createVersionCommand() {
+  return new Command12("version").description("Show CLI version and commit id").option("--json", "Output JSON").action((options) => {
+    const payload = {
+      version: CLI_VERSION,
+      commit: CLI_COMMIT
+    };
+    if (options.json) {
+      printJsonSuccess(payload);
+      return;
+    }
+    console.log(`Version: ${payload.version}`);
+    console.log(`Commit:  ${payload.commit}`);
+  });
+}
+
+// src/index.ts
+function shouldOutputJson() {
+  return process.argv.includes("--json");
+}
+function getFlagValue(argv, index) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("-")) {
+    return void 0;
+  }
+  return value;
+}
+var explicitFlags = /* @__PURE__ */ new Set();
+function applyGlobalOverrides(argv) {
+  let explicitDataDir = false;
+  let profileName;
+  explicitFlags.clear();
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    switch (arg) {
+      case "--profile": {
+        const value = getFlagValue(argv, index);
+        if (value) profileName = value;
+        break;
+      }
+      case "--data-dir": {
+        const value = getFlagValue(argv, index);
+        if (value) {
+          process.env.FIBER_DATA_DIR = value;
+          explicitDataDir = true;
+          explicitFlags.add("dataDir");
+        }
+        break;
+      }
+      case "--rpc-url": {
+        const value = getFlagValue(argv, index);
+        if (value) {
+          process.env.FIBER_RPC_URL = value;
+          explicitFlags.add("rpcUrl");
+        }
+        break;
+      }
+      case "--network": {
+        const value = getFlagValue(argv, index);
+        if (value) {
+          process.env.FIBER_NETWORK = value;
+          explicitFlags.add("network");
+        }
+        break;
+      }
+      case "--key-password": {
+        const value = getFlagValue(argv, index);
+        if (value) {
+          process.env.FIBER_KEY_PASSWORD = value;
+          explicitFlags.add("keyPassword");
+        }
+        break;
+      }
+      case "--binary-path": {
+        const value = getFlagValue(argv, index);
+        if (value) {
+          process.env.FIBER_BINARY_PATH = value;
+          explicitFlags.add("binaryPath");
+        }
+        break;
+      }
+      case "--runtime-proxy-listen":
+      case "--proxy-listen": {
+        const value = getFlagValue(argv, index);
+        if (value) {
+          process.env.FIBER_RUNTIME_PROXY_LISTEN = value;
+          explicitFlags.add("runtimeProxyListen");
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!explicitDataDir && profileName) {
+    const homeDir = process.env.HOME ?? process.cwd();
+    process.env.FIBER_DATA_DIR = join7(homeDir, ".fiber-pay", "profiles", profileName);
+  }
+}
+function printFatal(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const commanderCode = error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+  if (shouldOutputJson()) {
+    printJsonError({
+      code: commanderCode ?? "CLI_FATAL",
+      message,
+      recoverable: !commanderCode || commanderCode.startsWith("commander."),
+      suggestion: commanderCode?.startsWith("commander.") ? "Run the command with --help and fix invalid arguments." : "Inspect command arguments and environment, then retry."
+    });
+  } else {
+    if (commanderCode?.startsWith("commander.")) {
+      return;
+    }
+    console.error("Fatal error:", message);
+  }
+}
+async function main() {
+  applyGlobalOverrides(process.argv);
+  const config = getEffectiveConfig(explicitFlags).config;
+  const program = new Command13();
+  program.name("fiber-pay").description("AI Agent Payment SDK for CKB Lightning Network").version(`${CLI_VERSION} (${CLI_COMMIT})`, "-v, --version", "Show version and commit id").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("--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({
+    writeOut: (str) => process.stdout.write(str),
+    writeErr: (str) => {
+      if (!shouldOutputJson()) {
+        process.stderr.write(str);
+      }
+    }
+  });
+  program.addCommand(createNodeCommand(config));
+  program.addCommand(createChannelCommand(config));
+  program.addCommand(createInvoiceCommand(config));
+  program.addCommand(createPaymentCommand(config));
+  program.addCommand(createJobCommand(config));
+  program.addCommand(createLogsCommand(config));
+  program.addCommand(createPeerCommand(config));
+  program.addCommand(createGraphCommand(config));
+  program.addCommand(createBinaryCommand(config));
+  program.addCommand(createConfigCommand(config));
+  program.addCommand(createRuntimeCommand(config));
+  program.addCommand(createVersionCommand());
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  const commanderCode = error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+  const commanderExitCode = error && typeof error === "object" && "exitCode" in error ? Number(error.exitCode) : void 0;
+  printFatal(error);
+  if (commanderCode?.startsWith("commander.") && commanderExitCode === 0) {
+    process.exit(0);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map