@fiber-pay/cli 0.1.1 → 0.2.1

package/README.md

@@ -23,5 +23,5 @@ See [docs/l402-agent-guide.md](../../docs/l402-agent-guide.md) for L402 and agen
 ## Compatibility
 
 - Node.js `>=20`
-- Fiber target: `v0.7.1`
+- Fiber target: `v0.8.0`
 

package/dist/cli.js

@@ -147,8 +147,8 @@ function formatChannel(channel) {
   return {
     channelId: channel.channel_id,
     channelIdShort: truncateMiddle(channel.channel_id, 10, 8),
-    peerId: channel.peer_id,
-    peerIdShort: truncateMiddle(channel.peer_id, 10, 8),
+    peerId: channel.pubkey,
+    peerIdShort: truncateMiddle(channel.pubkey, 10, 8),
     state: channel.state.state_name,
     stateLabel: stateLabel(channel.state.state_name),
     stateFlags: channel.state.state_flags,
@@ -185,10 +185,10 @@ function extractInvoiceMetadata(invoice) {
   let description;
   let expirySeconds;
   for (const attr of invoice.data.attrs) {
-    if ("Description" in attr) description = attr.Description;
-    if ("ExpiryTime" in attr) {
+    if ("description" in attr) description = attr.description;
+    if ("expiry_time" in attr) {
       try {
-        expirySeconds = Number(BigInt(attr.ExpiryTime));
+        expirySeconds = Number(BigInt(attr.expiry_time));
       } catch {
       }
     }
@@ -235,7 +235,7 @@ function printChannelDetailHuman(channel) {
   const capacity = local + remote;
   console.log("Channel");
   console.log(`  ID:            ${channel.channel_id}`);
-  console.log(`  Peer:          ${channel.peer_id}`);
+  console.log(`  Peer:          ${channel.pubkey}`);
   console.log(
     `  State:         ${stateLabel(channel.state.state_name)} (${channel.state.state_name})`
   );
@@ -308,7 +308,7 @@ function printChannelListHuman(channels) {
   );
   for (const channel of channels) {
     const id = truncateMiddle(channel.channel_id, 10, 8).padEnd(22, " ");
-    const peer = truncateMiddle(channel.peer_id, 10, 8).padEnd(22, " ");
+    const peer = truncateMiddle(channel.pubkey, 10, 8).padEnd(22, " ");
     const state = channel.state.state_name.padEnd(24, " ");
     const local = `${shannonsToCkb(channel.local_balance)}`.padStart(8, " ");
     const remote = `${shannonsToCkb(channel.remote_balance)}`.padStart(8, " ");
@@ -323,12 +323,11 @@ function printPeerListHuman(peers) {
   }
   console.log(`Peers: ${peers.length}`);
   console.log("");
-  console.log("PEER ID                 PUBKEY                  ADDRESS");
-  console.log("--------------------------------------------------------------------------");
+  console.log("PUBKEY                  ADDRESS");
+  console.log("----------------------------------------------------------");
   for (const peer of peers) {
-    const peerId = truncateMiddle(peer.peer_id, 10, 8).padEnd(22, " ");
     const pubkey = truncateMiddle(peer.pubkey, 10, 8).padEnd(22, " ");
-    console.log(`${peerId} ${pubkey} ${peer.address}`);
+    console.log(`${pubkey} ${peer.address}`);
   }
 }
 
@@ -676,7 +675,7 @@ async function runAgentCallCommand(config, url, options) {
 // src/lib/agent-serve.ts
 import { execFileSync, spawn } from "child_process";
 import { createServer } from "http";
-import { createL402Middleware, FiberRpcClient as FiberRpcClient2 } from "@fiber-pay/sdk";
+import { createL402Middleware, FiberRpcClient as FiberRpcClient2 } from "@fiber-pay/sdk/node";
 import express from "express";
 function getClientIp(req) {
   const forwarded = req.headers["x-forwarded-for"];
@@ -1232,7 +1231,7 @@ function createBinaryCommand(config) {
 
 // src/commands/channel.ts
 import { randomUUID } from "crypto";
-import { ckbToShannons as ckbToShannons2 } from "@fiber-pay/sdk";
+import { ckbToShannons as ckbToShannons2, nodeIdToPeerId } from "@fiber-pay/sdk";
 import { Command as Command3 } from "commander";
 
 // src/lib/async.ts
@@ -1333,7 +1332,7 @@ async function executeRebalance(config, params) {
     }
     process.exit(1);
   }
-  const selfPubkey = (await rpc.nodeInfo()).node_id;
+  const selfPubkey = (await rpc.nodeInfo()).pubkey;
   const amount = ckbToShannons(amountCkb);
   const isManual = manualHops.length > 0;
   let routeHopCount;
@@ -1468,7 +1467,7 @@ function registerChannelRebalanceCommand(parent, config) {
         }
         process.exit(1);
       }
-      if (fromChannel.peer_id === toChannel.peer_id) {
+      if (fromChannel.pubkey === toChannel.pubkey) {
         const message = "Source and target channels point to the same peer; choose two different channel peers.";
         if (json) {
           printJsonError({
@@ -1479,7 +1478,7 @@ function registerChannelRebalanceCommand(parent, config) {
             details: {
               fromChannel: fromChannelId,
               toChannel: toChannelId,
-              peerId: fromChannel.peer_id
+              peerId: fromChannel.pubkey
             }
           });
         } else {
@@ -1487,24 +1486,21 @@ function registerChannelRebalanceCommand(parent, config) {
         }
         process.exit(1);
       }
-      const peers = (await rpc.listPeers()).peers;
-      const pubkeyByPeerId = new Map(peers.map((peer) => [peer.peer_id, peer.pubkey]));
-      const fromPubkey = pubkeyByPeerId.get(fromChannel.peer_id);
-      const toPubkey = pubkeyByPeerId.get(toChannel.peer_id);
+      const fromPubkey = fromChannel.pubkey;
+      const toPubkey = toChannel.pubkey;
       if (!fromPubkey || !toPubkey) {
-        const message = "Unable to resolve selected channel peer_id to pubkey for guided rebalance route.";
+        const message = "Unable to resolve selected channel pubkey for guided rebalance route.";
         if (json) {
           printJsonError({
             code: "CHANNEL_REBALANCE_INPUT_INVALID",
             message,
             recoverable: true,
-            suggestion: "Ensure both peers are connected (`peer list --json`) and retry guided mode, or use `payment rebalance --hops`.",
+            suggestion: "Ensure channel details are up to date and retry guided mode, or use `payment rebalance --hops`.",
             details: {
               fromChannel: fromChannelId,
               toChannel: toChannelId,
-              fromPeerId: fromChannel.peer_id,
-              toPeerId: toChannel.peer_id,
-              resolvedPeers: peers.length
+              fromPeerId: fromChannel.pubkey,
+              toPeerId: toChannel.pubkey
             }
           });
         } else {
@@ -1526,13 +1522,42 @@ function registerChannelRebalanceCommand(parent, config) {
 }
 
 // src/commands/channel.ts
+function extractPeerIdFromMultiaddr(address) {
+  const match = address.match(/\/p2p\/([^/]+)$/);
+  return match?.[1];
+}
+async function resolvePeerPubkeyFromMultiaddr(rpc, address, timeoutMs) {
+  const expectedPeerId = extractPeerIdFromMultiaddr(address);
+  if (!expectedPeerId) {
+    throw new Error("Invalid peer multiaddr: missing /p2p/<peerId> suffix");
+  }
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const peers = await rpc.listPeers();
+    for (const peer of peers.peers) {
+      if (extractPeerIdFromMultiaddr(peer.address) === expectedPeerId) {
+        return peer.pubkey;
+      }
+      try {
+        if (await nodeIdToPeerId(peer.pubkey) === expectedPeerId) {
+          return peer.pubkey;
+        }
+      } catch {
+      }
+    }
+    await sleep(500);
+  }
+  throw new Error(
+    `connect_peer accepted but peer pubkey not resolved within ${Math.floor(timeoutMs / 1e3)}s (${expectedPeerId})`
+  );
+}
 function createChannelCommand(config) {
   const channel = new Command3("channel").description("Channel lifecycle and status commands");
-  channel.command("list").option("--state <state>").option("--peer <peerId>").option("--include-closed").option("--json").action(async (options) => {
+  channel.command("list").option("--state <state>").option("--peer <pubkey>").option("--include-closed").option("--json").action(async (options) => {
     const rpc = await createReadyRpcClient(config);
     const stateFilter = parseChannelState(options.state);
     const response = await rpc.listChannels(
-      options.peer ? { peer_id: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
+      options.peer ? { pubkey: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
     );
     const channels = stateFilter ? response.channels.filter((item) => item.state.state_name === stateFilter) : response.channels;
     if (options.json) {
@@ -1565,7 +1590,7 @@ function createChannelCommand(config) {
       printChannelDetailHuman(found);
     }
   });
-  channel.command("watch").option("--interval <seconds>", "Refresh interval", "5").option("--timeout <seconds>").option("--on-timeout <behavior>", "fail | success", "fail").option("--channel <channelId>").option("--peer <peerId>").option("--state <state>").option("--until <state>").option("--include-closed").option("--no-clear").option("--json").action(async (options) => {
+  channel.command("watch").option("--interval <seconds>", "Refresh interval", "5").option("--timeout <seconds>").option("--on-timeout <behavior>", "fail | success", "fail").option("--channel <channelId>").option("--peer <pubkey>").option("--state <state>").option("--until <state>").option("--include-closed").option("--no-clear").option("--json").action(async (options) => {
     const intervalSeconds = parseInt(options.interval, 10);
     const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : void 0;
     const onTimeout = String(options.onTimeout ?? "fail").trim().toLowerCase();
@@ -1594,7 +1619,7 @@ function createChannelCommand(config) {
     const previousStates = /* @__PURE__ */ new Map();
     while (true) {
       const response = await rpc.listChannels(
-        options.peer ? { peer_id: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
+        options.peer ? { pubkey: options.peer, include_closed: Boolean(options.includeClosed) } : { include_closed: Boolean(options.includeClosed) }
       );
       let channels = response.channels;
       if (options.channel) {
@@ -1676,7 +1701,7 @@ function createChannelCommand(config) {
       await sleep(intervalSeconds * 1e3);
     }
   });
-  channel.command("open").requiredOption("--peer <peerIdOrMultiaddr>").requiredOption("--funding <ckb>").option("--private").option(
+  channel.command("open").requiredOption("--peer <pubkeyOrMultiaddr>").requiredOption("--funding <ckb>").option("--private").option(
     "--idempotency-key <key>",
     "Reuse this key only when retrying the exact same open intent"
   ).option("--json").action(async (options) => {
@@ -1684,21 +1709,23 @@ function createChannelCommand(config) {
     const json = Boolean(options.json);
     const peerInput = options.peer;
     const fundingCkb = parseFloat(options.funding);
-    let peerId = peerInput;
+    let peerPubkey = peerInput;
     if (peerInput.includes("/")) {
       await rpc.connectPeer({ address: peerInput });
-      const peerIdMatch = peerInput.match(/\/p2p\/([^/]+)/);
-      if (peerIdMatch) peerId = peerIdMatch[1];
+      peerPubkey = await resolvePeerPubkeyFromMultiaddr(rpc, peerInput, 8e3);
+    }
+    if (!peerPubkey.startsWith("0x")) {
+      throw new Error(`Invalid peer pubkey: ${peerPubkey}`);
     }
-    const idempotencyKey = typeof options.idempotencyKey === "string" && options.idempotencyKey.trim().length > 0 ? options.idempotencyKey.trim() : `open:${peerId}:${randomUUID()}`;
+    const idempotencyKey = typeof options.idempotencyKey === "string" && options.idempotencyKey.trim().length > 0 ? options.idempotencyKey.trim() : `open:${peerPubkey}:${randomUUID()}`;
     const endpoint = resolveRpcEndpoint(config);
     if (endpoint.target === "runtime-proxy") {
       const created = await tryCreateRuntimeChannelJob(endpoint.url, {
         params: {
           action: "open",
-          peerId,
+          peerId: peerPubkey,
           openChannelParams: {
-            peer_id: peerId,
+            pubkey: peerPubkey,
             funding_amount: ckbToShannons2(fundingCkb),
             public: !options.private
           },
@@ -1713,7 +1740,7 @@ function createChannelCommand(config) {
         const payload2 = {
           jobId: created.id,
           jobState: created.state,
-          peer: peerId,
+          peer: peerPubkey,
           fundingCkb,
           idempotencyKey
         };
@@ -1731,11 +1758,15 @@ function createChannelCommand(config) {
       }
     }
     const result = await rpc.openChannel({
-      peer_id: peerId,
+      pubkey: peerPubkey,
       funding_amount: ckbToShannons2(fundingCkb),
       public: !options.private
     });
-    const payload = { temporaryChannelId: result.temporary_channel_id, peer: peerId, fundingCkb };
+    const payload = {
+      temporaryChannelId: result.temporary_channel_id,
+      peer: peerPubkey,
+      fundingCkb
+    };
     if (json) {
       printJsonSuccess(payload);
     } else {
@@ -2790,7 +2821,7 @@ function printGraphNodeListHuman(nodes) {
   console.log("NODE ID                ALIAS                VERSION    MIN FUNDING    AGE");
   console.log("---------------------------------------------------------------------------------");
   for (const node of nodes) {
-    const nodeId = truncateMiddle(node.node_id, 10, 8).padEnd(22, " ");
+    const nodeId = truncateMiddle(node.pubkey, 10, 8).padEnd(22, " ");
     const alias = (node.node_name || "(unnamed)").slice(0, 20).padEnd(20, " ");
     const version = (node.version || "?").slice(0, 10).padEnd(10, " ");
     const minFunding = shannonsToCkb3(node.auto_accept_min_ckb_funding_amount).toString().padStart(12, " ");
@@ -3768,7 +3799,7 @@ import { Command as Command8 } from "commander";
 
 // src/lib/l402-proxy.ts
 import { createServer as createServer2 } from "http";
-import { createL402Middleware as createL402Middleware2, FiberRpcClient as FiberRpcClient3 } from "@fiber-pay/sdk";
+import { createL402Middleware as createL402Middleware2, FiberRpcClient as FiberRpcClient3 } from "@fiber-pay/sdk/node";
 import express2 from "express";
 import { createProxyMiddleware } from "http-proxy-middleware";
 async function runL402ProxyCommand(config, options) {
@@ -4220,7 +4251,7 @@ async function runNodeInfoCommand(config, options) {
   console.log("\u2705 Node info retrieved");
   console.log(`  Version: ${nodeInfo.version}`);
   console.log(`  Commit: ${nodeInfo.commit_hash}`);
-  console.log(`  Node ID: ${nodeInfo.node_id}`);
+  console.log(`  Node Pubkey: ${nodeInfo.pubkey}`);
   if (nodeInfo.features.length > 0) {
     console.log("  Features:");
     for (const feature of nodeInfo.features) {
@@ -4272,11 +4303,7 @@ async function runNodeNetworkCommand(config, options) {
   ]);
   const graphNodesMap = /* @__PURE__ */ new Map();
   for (const node of graphNodes.nodes) {
-    graphNodesMap.set(node.node_id, node);
-  }
-  const peerIdToNodeIdMap = /* @__PURE__ */ new Map();
-  for (const peer of localPeers.peers) {
-    peerIdToNodeIdMap.set(peer.peer_id, peer.pubkey);
+    graphNodesMap.set(node.pubkey, node);
   }
   const graphChannelsMap = /* @__PURE__ */ new Map();
   for (const channel of graphChannels.channels) {
@@ -4290,8 +4317,7 @@ async function runNodeNetworkCommand(config, options) {
     nodeInfo: graphNodesMap.get(peer.pubkey)
   }));
   const enrichedChannels = localChannels.channels.map((channel) => {
-    const nodeId = peerIdToNodeIdMap.get(channel.peer_id) || channel.peer_id;
-    const peerNodeInfo = graphNodesMap.get(nodeId);
+    const peerNodeInfo = graphNodesMap.get(channel.pubkey);
     let graphChannelInfo;
     if (channel.channel_outpoint) {
       const outpointKey = `${channel.channel_outpoint.tx_hash}:${channel.channel_outpoint.index}`;
@@ -4310,7 +4336,7 @@ async function runNodeNetworkCommand(config, options) {
   }, 0n);
   const totalChannelCapacity = formatShannonsAsCkb(totalChannelCapacityShannons, 1);
   const networkData = {
-    localNodeId: nodeInfo.node_id,
+    localNodeId: nodeInfo.pubkey,
     peers: enrichedPeers,
     channels: enrichedChannels,
     graphNodes: graphNodes.nodes,
@@ -4337,16 +4363,16 @@ function printNodeNetworkHuman(data) {
   console.log("");
   if (data.peers.length > 0) {
     console.log("Peers:");
-    console.log("  PEER_ID                ALIAS                ADDRESS                    VERSION");
+    console.log("  PUBKEY                 ALIAS                ADDRESS                    VERSION");
     console.log(
       "  --------------------------------------------------------------------------------"
     );
     for (const peer of data.peers) {
-      const peerId = truncateMiddle(peer.peer_id, 10, 8).padEnd(22, " ");
+      const pubkey = truncateMiddle(peer.pubkey, 10, 8).padEnd(22, " ");
       const alias = sanitizeForTerminal(peer.nodeInfo?.node_name || "(unnamed)").slice(0, 20).padEnd(20, " ");
       const address = truncateMiddle(sanitizeForTerminal(peer.address), 15, 8).padEnd(25, " ");
       const version = sanitizeForTerminal(peer.nodeInfo?.version || "?").slice(0, 8).padEnd(8, " ");
-      console.log(`  ${peerId} ${alias} ${address} ${version}`);
+      console.log(`  ${pubkey} ${alias} ${address} ${version}`);
     }
     console.log("");
   }
@@ -5102,7 +5128,7 @@ import {
   buildMultiaddrFromNodeId,
   buildMultiaddrFromRpcUrl,
   ChannelState as ChannelState2,
-  nodeIdToPeerId,
+  nodeIdToPeerId as nodeIdToPeerId2,
   scriptToAddress
 } from "@fiber-pay/sdk";
 
@@ -5296,21 +5322,21 @@ async function runNodeStatusCommand(config, options) {
       const nodeInfo = await rpc.nodeInfo();
       const channels = await rpc.listChannels({ include_closed: false });
       rpcResponsive = true;
-      nodeId = nodeInfo.node_id;
+      nodeId = nodeInfo.pubkey;
       nodeName = nodeInfo.node_name;
       addresses = nodeInfo.addresses;
       chainHash = nodeInfo.chain_hash;
       version = nodeInfo.version;
       peersCount = parseInt(nodeInfo.peers_count, 16);
       try {
-        peerId = await nodeIdToPeerId(nodeInfo.node_id);
+        peerId = await nodeIdToPeerId2(nodeInfo.pubkey);
       } catch (error) {
         peerIdError = error instanceof Error ? error.message : String(error);
       }
       const baseAddress = nodeInfo.addresses[0];
       if (baseAddress) {
         try {
-          multiaddr = await buildMultiaddrFromNodeId(baseAddress, nodeInfo.node_id);
+          multiaddr = await buildMultiaddrFromNodeId(baseAddress, nodeInfo.pubkey);
         } catch (error) {
           multiaddrError = error instanceof Error ? error.message : String(error);
         }
@@ -5848,7 +5874,12 @@ async function runMigrationAndReport(opts) {
     }
     process.exit(0);
   }
-  if (!migrationCheck.needed) {
+  const precheckUnsupported = migrationCheck.precheckUnsupported;
+  if (precheckUnsupported && forceMigrateAttempt && !json) {
+    console.log("\u26A0\uFE0F  Migration pre-check is unavailable for this fnn-migrate version.");
+    console.log("   --force-migrate is set, so migration will be attempted directly.");
+  }
+  if (!migrationCheck.needed && !(precheckUnsupported && forceMigrateAttempt)) {
     if (!json) console.log("   Store is compatible, no migration needed.");
     return normalizeMigrationCheck(migrationCheck);
   }
@@ -6292,21 +6323,37 @@ function getJobFailure(job) {
 }
 
 // src/commands/peer.ts
+import { nodeIdToPeerId as nodeIdToPeerId3 } from "@fiber-pay/sdk";
 import { Command as Command12 } from "commander";
-function extractPeerIdFromMultiaddr(address) {
+function extractPeerIdFromMultiaddr2(address) {
   const match = address.match(/\/p2p\/([^/]+)$/);
   return match?.[1];
 }
-async function waitForPeerConnected(rpc, peerId, timeoutMs) {
+async function findPeerByPeerId(rpc, expectedPeerId) {
+  const peers = await rpc.listPeers();
+  for (const peer of peers.peers) {
+    if (extractPeerIdFromMultiaddr2(peer.address) === expectedPeerId) {
+      return peer;
+    }
+    try {
+      if (await nodeIdToPeerId3(peer.pubkey) === expectedPeerId) {
+        return peer;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function waitForPeerConnected(rpc, expectedPeerId, timeoutMs) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const peers = await rpc.listPeers();
-    if (peers.peers.some((peer) => peer.peer_id === peerId)) {
-      return true;
+    const match = await findPeerByPeerId(rpc, expectedPeerId);
+    if (match) {
+      return { pubkey: match.pubkey, address: match.address };
     }
     await new Promise((resolve2) => setTimeout(resolve2, 500));
   }
-  return false;
+  return void 0;
 }
 function createPeerCommand(config) {
   const peer = new Command12("peer").description("Peer management");
@@ -6321,34 +6368,40 @@ function createPeerCommand(config) {
   });
   peer.command("connect").argument("<multiaddr>").option("--timeout <sec>", "Wait timeout for peer to appear in peer list", "8").option("--json").action(async (address, options) => {
     const rpc = await createReadyRpcClient(config);
-    const peerId = extractPeerIdFromMultiaddr(address);
-    if (!peerId) {
+    const expectedPeerId = extractPeerIdFromMultiaddr2(address);
+    if (!expectedPeerId) {
       throw new Error("Invalid multiaddr: missing /p2p/<peerId> suffix");
     }
     await rpc.connectPeer({ address });
     const timeoutMs = Math.max(1, Number.parseInt(String(options.timeout), 10) || 8) * 1e3;
-    const connected = await waitForPeerConnected(rpc, peerId, timeoutMs);
+    const connected = await waitForPeerConnected(rpc, expectedPeerId, timeoutMs);
     if (!connected) {
       throw new Error(
-        `connect_peer accepted but peer not found in list within ${Math.floor(timeoutMs / 1e3)}s (${peerId})`
+        `connect_peer accepted but peer not found in list within ${Math.floor(timeoutMs / 1e3)}s (${expectedPeerId})`
       );
     }
     if (options.json) {
-      printJsonSuccess({ address, peerId, message: "Connected" });
+      printJsonSuccess({
+        address,
+        peerId: expectedPeerId,
+        pubkey: connected.pubkey,
+        message: "Connected"
+      });
     } else {
       console.log("\u2705 Connected to peer");
       console.log(`  Address: ${address}`);
-      console.log(`  Peer ID: ${peerId}`);
+      console.log(`  Peer ID: ${expectedPeerId}`);
+      console.log(`  Peer Pubkey: ${connected.pubkey}`);
     }
   });
-  peer.command("disconnect").argument("<peerId>").option("--json").action(async (peerId, options) => {
+  peer.command("disconnect").argument("<pubkey>").option("--json").action(async (pubkey, options) => {
     const rpc = await createReadyRpcClient(config);
-    await rpc.disconnectPeer({ peer_id: peerId });
+    await rpc.disconnectPeer({ pubkey });
     if (options.json) {
-      printJsonSuccess({ peerId, message: "Disconnected" });
+      printJsonSuccess({ pubkey, message: "Disconnected" });
     } else {
       console.log("\u2705 Disconnected peer");
-      console.log(`  Peer ID: ${peerId}`);
+      console.log(`  Peer Pubkey: ${pubkey}`);
     }
   });
   return peer;
@@ -6847,8 +6900,8 @@ function createRuntimeCommand(config) {
 import { Command as Command14 } from "commander";
 
 // src/lib/build-info.ts
-var CLI_VERSION = "0.1.1";
-var CLI_COMMIT = "4b099d434842d019d12ba4df4031314860de25be";
+var CLI_VERSION = "0.2.1";
+var CLI_COMMIT = "7326728d24bfb81f431401c681e5dfadee5d27a6";
 
 // src/commands/version.ts
 function createVersionCommand() {