@net-protocol/cli 0.1.24 → 0.1.26

package/README.md

@@ -472,6 +472,7 @@ netp profile set-x-username \
 - `--chain-id` (optional): Chain ID. Can also be set via `NET_CHAIN_ID` environment variable
 - `--rpc-url` (optional): Custom RPC URL. Can also be set via `NET_RPC_URL` environment variable
 - `--encode-only` (optional): Output transaction data as JSON instead of executing
+- `--address` (optional): Wallet address to preserve existing metadata for (used with --encode-only)
 
 **Example:**
 
@@ -485,9 +486,10 @@ netp profile set-x-username \
   --username "@myusername" \
   --chain-id 8453
 
-# Encode-only
+# Encode-only (--address preserves existing bio, display name, token address)
 netp profile set-x-username \
   --username "myusername" \
+  --address 0xYourWalletAddress \
   --chain-id 8453 \
   --encode-only
 ```
@@ -512,6 +514,7 @@ netp profile set-bio \
 - `--chain-id` (optional): Chain ID. Can also be set via `NET_CHAIN_ID` environment variable
 - `--rpc-url` (optional): Custom RPC URL. Can also be set via `NET_RPC_URL` environment variable
 - `--encode-only` (optional): Output transaction data as JSON instead of executing
+- `--address` (optional): Wallet address to preserve existing metadata for (used with --encode-only)
 
 **Example:**
 
@@ -521,9 +524,10 @@ netp profile set-bio \
   --bio "Building cool stuff on Net Protocol" \
   --chain-id 8453
 
-# Encode-only
+# Encode-only (--address preserves existing x_username, display name, token address)
 netp profile set-bio \
   --bio "Building cool stuff on Net Protocol" \
+  --address 0xYourWalletAddress \
   --chain-id 8453 \
   --encode-only
 ```
@@ -548,6 +552,7 @@ netp profile set-display-name \
 - `--chain-id` (optional): Chain ID. Can also be set via `NET_CHAIN_ID` environment variable
 - `--rpc-url` (optional): Custom RPC URL. Can also be set via `NET_RPC_URL` environment variable
 - `--encode-only` (optional): Output transaction data as JSON instead of executing
+- `--address` (optional): Wallet address to preserve existing metadata for (used with --encode-only)
 
 **Example:**
 
@@ -557,9 +562,10 @@ netp profile set-display-name \
   --name "Alice" \
   --chain-id 8453
 
-# Encode-only
+# Encode-only (--address preserves existing bio, x_username, token address)
 netp profile set-display-name \
   --name "Alice" \
+  --address 0xYourWalletAddress \
   --chain-id 8453 \
   --encode-only
 ```
@@ -584,6 +590,7 @@ netp profile set-token-address \
 - `--chain-id` (optional): Chain ID. Can also be set via `NET_CHAIN_ID` environment variable
 - `--rpc-url` (optional): Custom RPC URL. Can also be set via `NET_RPC_URL` environment variable
 - `--encode-only` (optional): Output transaction data as JSON instead of executing
+- `--address` (optional): Wallet address to preserve existing metadata for (used with --encode-only)
 
 **Example:**
 
@@ -593,9 +600,10 @@ netp profile set-token-address \
   --token-address 0x1234567890abcdef1234567890abcdef12345678 \
   --chain-id 8453
 
-# Encode-only (get transaction data without executing)
+# Encode-only (--address preserves existing bio, x_username, display name)
 netp profile set-token-address \
   --token-address 0x1234567890abcdef1234567890abcdef12345678 \
+  --address 0xYourWalletAddress \
   --chain-id 8453 \
   --encode-only
 ```
@@ -778,12 +786,20 @@ src/
 │   ├── profile/          # Profile command module
 │   │   ├── index.ts      # Profile command definition
 │   │   ├── get.ts        # Profile get logic
-│   │   ├── set-picture.ts    # Set profile picture
-│   │   ├── set-username.ts   # Set X username
+│   │   ├── set-picture.ts        # Set profile picture
+│   │   ├── set-username.ts       # Set X username
+│   │   ├── set-bio.ts            # Set profile bio
+│   │   ├── set-display-name.ts   # Set display name
 │   │   ├── set-token-address.ts  # Set token address
+│   │   ├── set-canvas.ts         # Set profile canvas
+│   │   ├── get-canvas.ts         # Get profile canvas
 │   │   └── types.ts      # Profile-specific types
+│   ├── feed/             # Feed command module
 │   ├── message/          # Message command module
-│   └── token/            # Token command module
+│   ├── token/            # Token command module
+│   ├── bazaar/           # NFT Bazaar command module
+│   ├── chains/           # Chains listing command
+│   └── info/             # Contract info command
 └── shared/               # Shared utilities across commands
     └── types.ts          # Common types (CommonOptions, etc.)
 ```

package/dist/cli/index.mjs

@@ -4,8 +4,8 @@ import 'dotenv/config';
 import { Command } from 'commander';
 import { createRequire } from 'module';
 import chalk4 from 'chalk';
-import * as fs4 from 'fs';
-import { readFileSync } from 'fs';
+import * as fs6 from 'fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { OPTIMAL_CHUNK_SIZE, StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, chunkDataForStorage, CHUNKED_STORAGE_CONTRACT, STORAGE_CONTRACT as STORAGE_CONTRACT$1 } from '@net-protocol/storage';
 import { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, publicActions, defineChain } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
@@ -13,11 +13,13 @@ import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, NetClie
 import { createRelayX402Client, createRelaySession, checkBackendWalletBalance, fundBackendWallet, batchTransactions, submitTransactionsViaRelay, waitForConfirmations, retryFailedTransactions as retryFailedTransactions$1 } from '@net-protocol/relay';
 import { FeedRegistryClient, FeedClient, AgentRegistryClient } from '@net-protocol/feeds';
 import { isNetrSupportedChain, NetrClient } from '@net-protocol/netr';
-import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, PROFILE_CANVAS_STORAGE_KEY, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getProfileMetadataStorageArgs, isValidBio, isValidDisplayName, isValidTokenAddress } from '@net-protocol/profiles';
+import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, PROFILE_CANVAS_STORAGE_KEY, PROFILE_CSS_STORAGE_KEY, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getProfileMetadataStorageArgs, isValidBio, isValidDisplayName, isValidTokenAddress, DEMO_THEMES, MAX_CSS_SIZE, isValidCSS, getProfileCSSStorageArgs, buildCSSPrompt } from '@net-protocol/profiles';
 import { base } from 'viem/chains';
 import * as path from 'path';
+import { join } from 'path';
 import { BazaarClient } from '@net-protocol/bazaar';
 import * as os from 'os';
+import { homedir } from 'os';
 import * as readline from 'readline';
 
 var DEFAULT_CHAIN_ID = 8453;
@@ -1255,7 +1257,7 @@ async function encodeStorageUpload(options) {
   } else {
     operatorAddress = "0x0000000000000000000000000000000000000000";
   }
-  const fileContent = fs4.readFileSync(options.filePath, "utf-8");
+  const fileContent = fs6.readFileSync(options.filePath, "utf-8");
   const fileSize = Buffer.byteLength(fileContent, "utf-8");
   const client = new StorageClient({
     chainId: readOnlyOptions.chainId
@@ -1558,8 +1560,8 @@ function registerStorageCommand(program2) {
       console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       console.log(chalk4.blue(`\u{1F517} Using relay API: ${options.apiUrl}`));
       const result = await uploadFileWithRelay(uploadRelayOptions);
-      const { privateKeyToAccount: privateKeyToAccount25 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount25(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount26 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount26(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -2394,7 +2396,22 @@ async function executeProfileGet(options) {
         throw error;
       }
     }
-    const hasProfile = profilePicture || xUsername || bio || tokenAddress || canvasSize;
+    let cssSize;
+    try {
+      const cssResult = await client.readStorageData({
+        key: PROFILE_CSS_STORAGE_KEY,
+        operator: options.address
+      });
+      if (cssResult.data) {
+        cssSize = cssResult.data.length;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage !== "StoredDataNotFound") {
+        throw error;
+      }
+    }
+    const hasProfile = profilePicture || xUsername || bio || tokenAddress || canvasSize || cssSize;
     if (options.json) {
       const output = {
         address: options.address,
@@ -2404,6 +2421,7 @@ async function executeProfileGet(options) {
         bio: bio || null,
         tokenAddress: tokenAddress || null,
         canvas: canvasSize ? { size: canvasSize, isDataUri: canvasIsDataUri } : null,
+        css: cssSize ? { size: cssSize } : null,
         hasProfile
       };
       console.log(JSON.stringify(output, null, 2));
@@ -2427,6 +2445,9 @@ async function executeProfileGet(options) {
     console.log(
       `  ${chalk4.cyan("Canvas:")} ${canvasSize ? `${canvasSize} bytes${canvasIsDataUri ? " (data URI)" : ""}` : chalk4.gray("(not set)")}`
     );
+    console.log(
+      `  ${chalk4.cyan("Custom CSS:")} ${cssSize ? `${cssSize} bytes` : chalk4.gray("(not set)")}`
+    );
     if (!hasProfile) {
       console.log(chalk4.yellow("\n  No profile data found for this address."));
     }
@@ -2989,10 +3010,10 @@ async function executeProfileSetCanvas(options) {
   let canvasContent;
   if (options.file) {
     const filePath = path.resolve(options.file);
-    if (!fs4.existsSync(filePath)) {
+    if (!fs6.existsSync(filePath)) {
       exitWithError(`File not found: ${filePath}`);
     }
-    const buffer = fs4.readFileSync(filePath);
+    const buffer = fs6.readFileSync(filePath);
     if (buffer.length > MAX_CANVAS_SIZE) {
       exitWithError(
         `File too large: ${buffer.length} bytes exceeds maximum of ${MAX_CANVAS_SIZE} bytes (60KB).`
@@ -3167,12 +3188,12 @@ async function executeProfileGetCanvas(options) {
         if (!path.extname(outputPath)) {
           finalPath = outputPath + getExtensionFromMimeType(mimeType);
         }
-        fs4.writeFileSync(finalPath, buffer);
+        fs6.writeFileSync(finalPath, buffer);
         console.log(
           chalk4.green(`Canvas written to: ${finalPath} (${buffer.length} bytes)`)
         );
       } else {
-        fs4.writeFileSync(outputPath, canvasContent, "utf-8");
+        fs6.writeFileSync(outputPath, canvasContent, "utf-8");
         console.log(
           chalk4.green(
             `Canvas written to: ${outputPath} (${canvasContent.length} bytes)`
@@ -3188,6 +3209,197 @@ async function executeProfileGetCanvas(options) {
     );
   }
 }
+async function executeProfileSetCSS(options) {
+  const sourceCount = [options.file, options.content, options.theme].filter(
+    Boolean
+  ).length;
+  if (sourceCount === 0) {
+    exitWithError(
+      "Must provide one of --file, --content, or --theme to set CSS."
+    );
+  }
+  if (sourceCount > 1) {
+    exitWithError("Cannot provide more than one of --file, --content, --theme.");
+  }
+  let cssContent;
+  if (options.theme) {
+    const theme = DEMO_THEMES[options.theme];
+    if (!theme) {
+      const available = Object.entries(DEMO_THEMES).map(([key, val]) => `  ${key} \u2014 ${val.name}`).join("\n");
+      exitWithError(
+        `Unknown theme: "${options.theme}"
+
+Available themes:
+${available}`
+      );
+    }
+    cssContent = theme.css;
+    console.log(chalk4.gray(`   Using theme: ${theme.name}`));
+  } else if (options.file) {
+    const filePath = path.resolve(options.file);
+    if (!fs6.existsSync(filePath)) {
+      exitWithError(`File not found: ${filePath}`);
+    }
+    const buffer = fs6.readFileSync(filePath);
+    if (buffer.length > MAX_CSS_SIZE) {
+      exitWithError(
+        `File too large: ${buffer.length} bytes exceeds maximum of ${MAX_CSS_SIZE} bytes (10KB).`
+      );
+    }
+    cssContent = buffer.toString("utf-8");
+  } else {
+    cssContent = options.content;
+    const contentSize = Buffer.byteLength(cssContent, "utf-8");
+    if (contentSize > MAX_CSS_SIZE) {
+      exitWithError(
+        `Content too large: ${contentSize} bytes exceeds maximum of ${MAX_CSS_SIZE} bytes (10KB).`
+      );
+    }
+  }
+  if (!isValidCSS(cssContent)) {
+    exitWithError(
+      "Invalid CSS: content is empty, too large, or contains disallowed patterns (script injection)."
+    );
+  }
+  const storageArgs = getProfileCSSStorageArgs(cssContent);
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const encoded = encodeTransaction(
+      {
+        to: STORAGE_CONTRACT.address,
+        abi: STORAGE_CONTRACT.abi,
+        functionName: "put",
+        args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+      },
+      readOnlyOptions.chainId
+    );
+    console.log(JSON.stringify(encoded, null, 2));
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  try {
+    const account = privateKeyToAccount(commonOptions.privateKey);
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const client = createWalletClient({
+      account,
+      chain: base,
+      transport: http(rpcUrls[0])
+    }).extend(publicActions);
+    console.log(chalk4.blue(`Setting profile CSS...`));
+    console.log(
+      chalk4.gray(
+        `   Content size: ${Buffer.byteLength(cssContent, "utf-8")} bytes`
+      )
+    );
+    console.log(chalk4.gray(`   Address: ${account.address}`));
+    const hash = await client.writeContract({
+      address: STORAGE_CONTRACT.address,
+      abi: STORAGE_CONTRACT.abi,
+      functionName: "put",
+      args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+    });
+    console.log(chalk4.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk4.green(
+          `
+CSS updated successfully!
+  Transaction: ${hash}
+  Content size: ${Buffer.byteLength(cssContent, "utf-8")} bytes`
+        )
+      );
+    } else {
+      exitWithError(`Transaction failed: ${hash}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to set CSS: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeProfileGetCSS(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = new StorageClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  try {
+    let cssContent;
+    try {
+      const result = await client.readStorageData({
+        key: PROFILE_CSS_STORAGE_KEY,
+        operator: options.address
+      });
+      if (result.data) {
+        cssContent = result.data;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage !== "StoredDataNotFound") {
+        throw error;
+      }
+    }
+    if (options.json) {
+      const output = {
+        address: options.address,
+        chainId: readOnlyOptions.chainId,
+        css: cssContent || null,
+        hasCSS: !!cssContent,
+        contentLength: cssContent ? cssContent.length : 0
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (!cssContent) {
+      exitWithError(`No custom CSS found for address: ${options.address}`);
+    }
+    if (options.output) {
+      const outputPath = path.resolve(options.output);
+      fs6.writeFileSync(outputPath, cssContent, "utf-8");
+      console.log(
+        chalk4.green(
+          `CSS written to: ${outputPath} (${cssContent.length} bytes)`
+        )
+      );
+      return;
+    }
+    console.log(cssContent);
+  } catch (error) {
+    exitWithError(
+      `Failed to read CSS: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeProfileCSSPrompt(options) {
+  if (options.listThemes) {
+    console.log("Available demo themes:\n");
+    for (const [key, theme] of Object.entries(DEMO_THEMES)) {
+      console.log(`  ${key} \u2014 ${theme.name}`);
+    }
+    console.log(
+      "\nUse with: net profile set-css --theme <name>"
+    );
+    return;
+  }
+  console.log(buildCSSPrompt());
+}
 
 // src/commands/profile/index.ts
 function registerProfileCommand(program2) {
@@ -3378,6 +3590,51 @@ function registerProfileCommand(program2) {
       json: options.json
     });
   });
+  const setCSSCommand = new Command("set-css").description("Set your profile custom CSS theme").option("--file <path>", "Path to CSS file").option("--content <css>", "CSS content (inline)").option("--theme <name>", "Use a built-in demo theme (e.g. hotPink, midnightGrunge, ocean)").option(
+    "--private-key <key>",
+    "Private key (0x-prefixed hex, 66 characters). Can also be set via NET_PRIVATE_KEY env var"
+  ).option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
+  ).action(async (options) => {
+    await executeProfileSetCSS({
+      file: options.file,
+      content: options.content,
+      theme: options.theme,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const getCSSCommand = new Command("get-css").description("Get profile custom CSS for an address").requiredOption("--address <address>", "Wallet address to get CSS for").option("--output <path>", "Write CSS content to file instead of stdout").option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option("--json", "Output in JSON format").action(async (options) => {
+    await executeProfileGetCSS({
+      address: options.address,
+      output: options.output,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const cssPromptCommand = new Command("css-prompt").description("Print the AI prompt for generating profile CSS themes").option("--list-themes", "List available demo themes instead of the prompt").action(async (options) => {
+    await executeProfileCSSPrompt({
+      listThemes: options.listThemes
+    });
+  });
   profileCommand.addCommand(getCommand);
   profileCommand.addCommand(setPictureCommand);
   profileCommand.addCommand(setUsernameCommand);
@@ -3386,6 +3643,9 @@ function registerProfileCommand(program2) {
   profileCommand.addCommand(setTokenAddressCommand);
   profileCommand.addCommand(setCanvasCommand);
   profileCommand.addCommand(getCanvasCommand);
+  profileCommand.addCommand(setCSSCommand);
+  profileCommand.addCommand(getCSSCommand);
+  profileCommand.addCommand(cssPromptCommand);
 }
 
 // src/commands/bazaar/format.ts
@@ -5472,14 +5732,14 @@ var MAX_HISTORY_ENTRIES = 100;
 var STATE_DIR = path.join(os.homedir(), ".botchan");
 var STATE_FILE = path.join(STATE_DIR, "state.json");
 function ensureStateDir() {
-  if (!fs4.existsSync(STATE_DIR)) {
-    fs4.mkdirSync(STATE_DIR, { recursive: true });
+  if (!fs6.existsSync(STATE_DIR)) {
+    fs6.mkdirSync(STATE_DIR, { recursive: true });
   }
 }
 function loadState() {
   try {
-    if (fs4.existsSync(STATE_FILE)) {
-      const data = fs4.readFileSync(STATE_FILE, "utf-8");
+    if (fs6.existsSync(STATE_FILE)) {
+      const data = fs6.readFileSync(STATE_FILE, "utf-8");
       return JSON.parse(data);
     }
   } catch {
@@ -5489,8 +5749,8 @@ function loadState() {
 function saveState(state) {
   ensureStateDir();
   const tempFile = `${STATE_FILE}.tmp`;
-  fs4.writeFileSync(tempFile, JSON.stringify(state, null, 2));
-  fs4.renameSync(tempFile, STATE_FILE);
+  fs6.writeFileSync(tempFile, JSON.stringify(state, null, 2));
+  fs6.renameSync(tempFile, STATE_FILE);
 }
 function getLastSeenTimestamp(feedName) {
   const state = loadState();
@@ -5531,8 +5791,8 @@ function getFullState() {
   return loadState();
 }
 function resetState() {
-  if (fs4.existsSync(STATE_FILE)) {
-    fs4.unlinkSync(STATE_FILE);
+  if (fs6.existsSync(STATE_FILE)) {
+    fs6.unlinkSync(STATE_FILE);
   }
 }
 function getStateFilePath() {
@@ -6334,10 +6594,10 @@ async function confirm(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve5(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -6654,6 +6914,86 @@ function registerFeedCommand(program2) {
   registerFeedHistoryCommand(feedCommand);
   registerAgentRegisterCommand(feedCommand);
 }
+var CACHE_DIR = join(homedir(), ".netp");
+var CACHE_FILE = join(CACHE_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 5e3;
+function isNewerVersion(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] || 0) > (c[i] || 0)) return true;
+    if ((l[i] || 0) < (c[i] || 0)) return false;
+  }
+  return false;
+}
+function readCache() {
+  try {
+    if (existsSync(CACHE_FILE)) {
+      return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCache(cache) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync(CACHE_FILE, JSON.stringify(cache));
+  } catch {
+  }
+}
+async function fetchLatestVersion(pkg) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(pkg).replace("%40", "@")}/latest`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timeout);
+    if (res.ok) {
+      const data = await res.json();
+      return data.version;
+    }
+  } catch {
+  }
+  return null;
+}
+async function getUpdateInfo(currentVersion) {
+  const cache = readCache();
+  if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+    if (cache.latestVersion && isNewerVersion(cache.latestVersion, currentVersion)) {
+      return { latest: cache.latestVersion };
+    }
+    return null;
+  }
+  const latest = await fetchLatestVersion("@net-protocol/cli");
+  writeCache({
+    lastCheck: Date.now(),
+    latestVersion: latest
+  });
+  if (latest && isNewerVersion(latest, currentVersion)) {
+    return { latest };
+  }
+  return null;
+}
+function printUpdateBanner(current, latest) {
+  console.error("");
+  console.error(
+    chalk4.yellow(
+      `  Update available: ${chalk4.gray(current)} \u2192 ${chalk4.green(latest)}`
+    )
+  );
+  console.error(
+    chalk4.yellow(
+      `  Run ${chalk4.cyan("npm install -g @net-protocol/cli@latest")} to update`
+    )
+  );
+  console.error("");
+}
 
 // src/cli/index.ts
 var proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY;
@@ -6673,6 +7013,33 @@ registerTokenCommand(program);
 registerProfileCommand(program);
 registerBazaarCommand(program);
 registerFeedCommand(program);
-program.parse();
+program.command("update").description("Update netp to the latest version").action(async () => {
+  const { execSync } = await import('child_process');
+  console.log("Updating @net-protocol/cli...");
+  try {
+    execSync("npm install -g @net-protocol/cli@latest", {
+      stdio: "inherit"
+    });
+    console.log(chalk4.green("\n\u2713 netp updated successfully"));
+  } catch {
+    console.error(
+      chalk4.red(
+        "Failed to update. Try manually: npm install -g @net-protocol/cli@latest"
+      )
+    );
+  }
+});
+var updatePromise = getUpdateInfo(version).catch(() => null);
+await program.parseAsync();
+try {
+  const updateInfo = await Promise.race([
+    updatePromise,
+    new Promise((resolve5) => setTimeout(() => resolve5(null), 1500))
+  ]);
+  if (updateInfo) {
+    printUpdateBanner(version, updateInfo.latest);
+  }
+} catch {
+}
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map