@alchemy/cli 0.1.0

package/dist/interactive-2ITFWH3B.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
+import {
+  getRPCNetworkIds,
+  getSetupMethod
+} from "./chunk-F7KTEZFZ.js";
+import {
+  bgRgb,
+  bold,
+  brand,
+  brandedHelp,
+  configDir,
+  dim,
+  green,
+  isJSONMode,
+  load,
+  noColor,
+  rgb,
+  setBrandedHelpSuppressed,
+  setReplMode
+} from "./chunk-QKXQW4OF.js";
+
+// src/commands/interactive.ts
+import * as readline from "readline";
+import { stdin, stdout, stderr } from "process";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+var COMMAND_NAMES = [
+  "apps",
+  "apps list",
+  "apps get",
+  "apps create",
+  "apps delete",
+  "apps update",
+  "apps networks",
+  "apps address-allowlist",
+  "apps origin-allowlist",
+  "apps ip-allowlist",
+  "bal",
+  "balance",
+  "block",
+  "chains",
+  "chains list",
+  "trace",
+  "debug",
+  "transfers",
+  "prices",
+  "prices symbol",
+  "prices address",
+  "prices historical",
+  "portfolio",
+  "portfolio tokens",
+  "portfolio token-balances",
+  "portfolio nfts",
+  "portfolio nft-contracts",
+  "portfolio transactions",
+  "simulate",
+  "simulate asset-changes",
+  "simulate execution",
+  "simulate asset-changes-bundle",
+  "simulate execution-bundle",
+  "webhooks",
+  "webhooks list",
+  "webhooks create",
+  "webhooks update",
+  "webhooks delete",
+  "webhooks addresses",
+  "webhooks nft-filters",
+  "bundler",
+  "bundler send-user-operation",
+  "bundler estimate-user-operation-gas",
+  "bundler get-user-operation-receipt",
+  "gas-manager",
+  "gas-manager request-gas-and-paymaster",
+  "gas-manager request-paymaster-token-quote",
+  "solana",
+  "solana rpc",
+  "solana das",
+  "config",
+  "config set",
+  "config set api-key",
+  "config set access-key",
+  "config set app",
+  "config set network",
+  "config set verbose",
+  "config set wallet-key-file",
+  "config set x402",
+  "config get",
+  "config list",
+  "help",
+  "network",
+  "network list",
+  "nfts",
+  "nfts metadata",
+  "nfts contract",
+  "rpc",
+  "setup",
+  "setup status",
+  "tokens",
+  "tokens metadata",
+  "tokens allowance",
+  "tx",
+  "version",
+  "wallet",
+  "wallet generate",
+  "wallet import",
+  "wallet address"
+];
+var NETWORK_NAMES = getRPCNetworkIds();
+var REPL_HISTORY_MAX = 100;
+function formatSetupMethodLabel() {
+  const method = getSetupMethod(load());
+  if (method === "api_key") return "API key";
+  if (method === "access_key_app") return "Access key + app";
+  if (method === "x402_wallet") return "x402 wallet";
+  return "Not configured";
+}
+function replHistoryPath() {
+  return join(configDir(), "repl-history");
+}
+function loadReplHistory() {
+  const historyFilePath = replHistoryPath();
+  if (!existsSync(historyFilePath)) return [];
+  try {
+    return readFileSync(historyFilePath, "utf-8").split("\n").map((line) => line.trim()).filter(Boolean).slice(-REPL_HISTORY_MAX);
+  } catch {
+    return [];
+  }
+}
+function saveReplHistory(lines) {
+  const historyFilePath = replHistoryPath();
+  const normalized = Array.from(
+    new Set(lines.map((line) => line.trim()).filter(Boolean))
+  ).slice(-REPL_HISTORY_MAX);
+  mkdirSync(dirname(historyFilePath), { recursive: true, mode: 493 });
+  writeFileSync(historyFilePath, normalized.join("\n") + "\n", { mode: 384 });
+}
+async function startREPL(program) {
+  if (!stdin.isTTY) return;
+  setReplMode(true);
+  setBrandedHelpSuppressed(true);
+  const applyExitOverride = (cmd) => {
+    cmd.exitOverride();
+    for (const subcommand of cmd.commands) {
+      applyExitOverride(subcommand);
+    }
+  };
+  applyExitOverride(program);
+  const addressHistory = [];
+  const rootCommands = Array.from(
+    new Set(
+      COMMAND_NAMES.map((name) => name.split(" ")[0]).concat([
+        "help",
+        "exit",
+        "quit"
+      ])
+    )
+  );
+  const getCompletions = (line) => {
+    const input = line.trimStart();
+    const hasTrailingSpace = /\s$/.test(input);
+    const tokens = input.length > 0 ? input.split(/\s+/) : [];
+    if (tokens.length === 0) {
+      return rootCommands;
+    }
+    if (tokens.length === 1 && !hasTrailingSpace) {
+      return rootCommands;
+    }
+    const first = tokens[0];
+    const phraseWithoutLeading = input;
+    const commandPhrases = first === "help" ? COMMAND_NAMES : COMMAND_NAMES.filter((name) => name.startsWith(first));
+    const phraseCandidates = commandPhrases.filter(
+      (name) => name.startsWith(phraseWithoutLeading)
+    );
+    const networkArgContext = /(?:^|\s)(?:-n|--network)\s+\S*$/.test(input);
+    const networkCandidates = networkArgContext ? NETWORK_NAMES : [];
+    const addressPrefix = tokens[tokens.length - 1] ?? "";
+    const addressCandidates = addressPrefix.startsWith("0x") && addressHistory.length > 0 ? addressHistory : [];
+    return Array.from(
+      /* @__PURE__ */ new Set([...phraseCandidates, ...networkCandidates, ...addressCandidates])
+    );
+  };
+  const longestCommonPrefix = (values) => {
+    if (values.length === 0) return "";
+    if (values.length === 1) return values[0];
+    let prefix = values[0];
+    for (let i = 1; i < values.length; i += 1) {
+      const value = values[i];
+      let j = 0;
+      while (j < prefix.length && j < value.length && prefix[j] === value[j]) {
+        j += 1;
+      }
+      prefix = prefix.slice(0, j);
+      if (!prefix) break;
+    }
+    return prefix;
+  };
+  const getCompletionMatches = (input) => Array.from(new Set(getCompletions(input))).filter((c) => c.startsWith(input) && c !== input).sort((a, b) => a.localeCompare(b));
+  const getInlineSuggestion = (line) => {
+    const input = line.trimStart();
+    if (!input) return "";
+    const candidates = getCompletionMatches(input);
+    if (candidates.length === 0) return "";
+    const uniqueSorted = Array.from(new Set(candidates)).sort(
+      (a, b) => a.length - b.length || a.localeCompare(b)
+    );
+    const best = uniqueSorted[0];
+    if (!best || best === input) return "";
+    return best.slice(input.length);
+  };
+  const printIntro = () => {
+    if (isJSONMode()) return;
+    process.stdout.write(brandedHelp({ force: true }));
+    console.log("");
+    console.log(`  ${brand("\u25C6")} ${bold("Welcome to Alchemy CLI")}`);
+    console.log(`  ${green("\u2713")} ${dim(`Configured auth: ${formatSetupMethodLabel()}`)}`);
+    console.log(`  ${dim("Run commands directly (no 'alchemy' prefix).")}`);
+    console.log("");
+    console.log(`  ${brand("\u25C6")} ${bold("Quick commands")}`);
+    console.log(`  ${dim("- rpc eth_chainId")}`);
+    console.log(`  ${dim("- config list")}`);
+    console.log(`  ${dim("- network list")}`);
+    console.log(`  ${dim("- help")}`);
+    console.log("");
+    console.log(`  ${dim("Press TAB for autocomplete. Type 'exit' or 'quit' to leave.")}`);
+    console.log("");
+    console.log("");
+  };
+  const PROMPT_STR = "\x1B[38;2;54;63;249m\u203A\x1B[39m ";
+  const submittedCommandBg = bgRgb(64, 64, 68);
+  const submittedCommandFg = rgb(232, 232, 236);
+  const OUTPUT_INDENT = "  ";
+  const styleSubmittedCommand = (command) => {
+    if (!stdout.isTTY || noColor) return command;
+    return submittedCommandBg(submittedCommandFg(` ${command} `));
+  };
+  const runWithIndentedOutput = async (fn) => {
+    if (isJSONMode() || !stdout.isTTY) {
+      await fn();
+      return;
+    }
+    const createIndentedWriter = (orig) => {
+      let atLineStart = true;
+      return function(chunk, ...rest) {
+        const str = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        if (!str) return true;
+        let out = "";
+        for (const ch of str) {
+          if (atLineStart && ch !== "\n" && ch !== "\r") {
+            out += OUTPUT_INDENT;
+            atLineStart = false;
+          }
+          out += ch;
+          if (ch === "\n" || ch === "\r") {
+            atLineStart = true;
+          }
+        }
+        return orig(out, ...rest);
+      };
+    };
+    const origStdoutWrite = stdout.write.bind(stdout);
+    const origStderrWrite = stderr.write.bind(stderr);
+    stdout.write = createIndentedWriter(origStdoutWrite);
+    stderr.write = createIndentedWriter(origStderrWrite);
+    try {
+      await fn();
+    } finally {
+      stdout.write = origStdoutWrite;
+      stderr.write = origStderrWrite;
+    }
+  };
+  const rl = readline.createInterface({
+    input: stdin,
+    output: stdout,
+    prompt: PROMPT_STR,
+    historySize: REPL_HISTORY_MAX,
+    removeHistoryDuplicates: true
+  });
+  const initialHistory = loadReplHistory();
+  const rlWithHistory = rl;
+  if (Array.isArray(rlWithHistory.history) && initialHistory.length > 0) {
+    rlWithHistory.history = [...initialHistory].reverse();
+  }
+  const renderInlineSuggestion = () => {
+    if (!stdout.isTTY) return;
+    const line = rl.line;
+    const cursor = typeof rl.cursor === "number" ? rl.cursor : line.length;
+    if (cursor !== line.length) return;
+    const suggestion = getInlineSuggestion(line);
+    readline.clearLine(stdout, 1);
+    if (!suggestion) return;
+    stdout.write(dim(suggestion));
+    readline.moveCursor(stdout, -suggestion.length, 0);
+  };
+  const acceptInlineCompletion = () => {
+    const line = rl.line;
+    const cursor = typeof rl.cursor === "number" ? rl.cursor : line.length;
+    if (cursor !== line.length) return;
+    const input = line.trimStart();
+    const candidates = getCompletionMatches(input);
+    if (candidates.length === 0) return;
+    const prefix = longestCommonPrefix(Array.from(new Set(candidates)));
+    if (prefix && prefix.length > input.length) {
+      rl.write(prefix.slice(input.length));
+      return;
+    }
+    const suggestion = getInlineSuggestion(line);
+    if (suggestion) {
+      rl.write(suggestion);
+    }
+  };
+  const rlWithTTYWrite = rl;
+  const originalTTYWrite = rlWithTTYWrite._ttyWrite?.bind(rl);
+  if (originalTTYWrite) {
+    rlWithTTYWrite._ttyWrite = (s, key) => {
+      if (key?.name === "return" && !rl.line.trim()) {
+        return;
+      }
+      if (key?.name === "tab") {
+        acceptInlineCompletion();
+        return;
+      }
+      originalTTYWrite(s, key);
+    };
+  }
+  const onKeypress = (_char, key) => {
+    if (key?.name === "tab") return;
+    setImmediate(() => {
+      renderInlineSuggestion();
+    });
+  };
+  stdin.on("keypress", onKeypress);
+  const prompt = () => {
+    stdin.resume();
+    stdin.ref?.();
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+      stdin.setRawMode(true);
+    }
+    rl.prompt();
+  };
+  const printPostOutputSpacing = () => {
+    if (!isJSONMode() && stdout.isTTY) {
+      console.log("");
+    }
+  };
+  const onLine = async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      prompt();
+      return;
+    }
+    if (trimmed === "exit" || trimmed === "quit") {
+      rl.close();
+      return;
+    }
+    if (!isJSONMode() && stdout.isTTY) {
+      readline.moveCursor(stdout, 0, -1);
+      readline.clearLine(stdout, 0);
+      stdout.write(styleSubmittedCommand(trimmed) + "\n");
+      console.log("");
+    }
+    const words = trimmed.split(/\s+/);
+    if (words[0] === "help") {
+      const target = words.slice(1);
+      try {
+        await runWithIndentedOutput(async () => {
+          await program.parseAsync(["node", "alchemy", ...target, "--help"]);
+        });
+      } catch {
+      }
+      printPostOutputSpacing();
+      prompt();
+      return;
+    }
+    for (const w of words) {
+      if (w.startsWith("0x") && w.length > 10 && !addressHistory.includes(w)) {
+        addressHistory.push(w);
+      }
+    }
+    try {
+      await runWithIndentedOutput(async () => {
+        await program.parseAsync(["node", "alchemy", ...words]);
+      });
+    } catch {
+    }
+    printPostOutputSpacing();
+    prompt();
+  };
+  return new Promise((resolve) => {
+    rl.on("line", (line) => void onLine(line));
+    rl.on("close", () => {
+      if (Array.isArray(rlWithHistory.history)) {
+        saveReplHistory([...rlWithHistory.history].reverse());
+      }
+      setReplMode(false);
+      setBrandedHelpSuppressed(false);
+      stdin.off("keypress", onKeypress);
+      resolve();
+    });
+    printIntro();
+    prompt();
+  });
+}
+export {
+  startREPL
+};

package/dist/onboarding-3J4EXZMG.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
+import {
+  AdminClient,
+  generateAndPersistWallet,
+  importAndPersistWallet,
+  selectOrCreateApp
+} from "./chunk-PH4BPYSY.js";
+import {
+  bold,
+  brand,
+  brandedHelp,
+  dim,
+  green,
+  load,
+  maskIf,
+  printKeyValueBox,
+  promptSelect,
+  promptText,
+  save
+} from "./chunk-QKXQW4OF.js";
+
+// src/commands/onboarding.ts
+function printNextSteps(method) {
+  const commandsByMethod = {
+    "api-key": ["alchemy config set api-key <key>"],
+    "access-key": [
+      "alchemy config set access-key <key>",
+      "alchemy config set app <app-id>"
+    ],
+    x402: [
+      "alchemy wallet generate",
+      "alchemy config set wallet-key-file <path>",
+      "alchemy config set x402 true"
+    ]
+  };
+  console.log("");
+  console.log(`  ${dim("Next steps:")}`);
+  for (const command of commandsByMethod[method]) {
+    console.log(`  ${dim(`- ${command}`)}`);
+  }
+}
+function printAPIKeyPostSetupGuidance() {
+  const cfg = load() ?? {};
+  const network = cfg.network ?? "eth-mainnet";
+  console.log("");
+  console.log(`  ${brand("\u25C6")} ${bold("Your configuration")}`);
+  printKeyValueBox([
+    ["api-key", cfg.api_key ? maskIf(cfg.api_key) : dim("(not set)")],
+    ["network", cfg.network ? network : `${network} ${dim("(default)")}`]
+  ]);
+  console.log("");
+  console.log(`  ${brand("\u25C6")} ${bold("Next steps")}`);
+  printKeyValueBox([
+    ["Verify setup", "rpc eth_chainId"],
+    ["Need a different chain?", "config set network <network>"],
+    ["List available chains", "network list"],
+    ["View set API key", "config get api-key"],
+    ["Need help?", "help"]
+  ]);
+}
+async function runAPIKeyOnboarding() {
+  const key = await promptText({
+    message: "Enter API Key",
+    cancelMessage: "Skipped API key setup.",
+    clearAfterSubmit: true
+  });
+  if (!key || !key.trim()) return;
+  const cfg = load();
+  save({ ...cfg, api_key: key.trim() });
+  console.log(`  ${green("\u2713")} Saved API key`);
+}
+async function runAccessKeyOnboarding() {
+  const key = await promptText({
+    message: "Alchemy access key",
+    placeholder: "Used for Admin API operations",
+    cancelMessage: "Skipped access key setup."
+  });
+  if (!key || !key.trim()) return;
+  const cfg = load();
+  save({ ...cfg, access_key: key.trim() });
+  console.log(`  ${green("\u2713")} Saved access key`);
+  await selectOrCreateApp(new AdminClient(key.trim()));
+}
+async function runX402Onboarding() {
+  const action = await promptSelect({
+    message: "x402 wallet setup",
+    options: [
+      { label: "Generate a new wallet", value: "generate" },
+      { label: "Import wallet from key file", value: "import" }
+    ],
+    initialValue: "generate",
+    cancelMessage: "Skipped x402 setup."
+  });
+  if (!action) return;
+  const wallet = action === "generate" ? generateAndPersistWallet() : await (async () => {
+    const path = await promptText({
+      message: "Wallet private key file path",
+      cancelMessage: "Skipped wallet import."
+    });
+    if (!path || !path.trim()) return null;
+    return importAndPersistWallet(path.trim());
+  })();
+  if (!wallet) return;
+  const cfg = load();
+  save({ ...cfg, x402: true });
+  console.log(`  ${green("\u2713")} x402 enabled with wallet ${wallet.address}`);
+}
+async function runOnboarding(_program) {
+  process.stdout.write(brandedHelp({ force: true }));
+  console.log("");
+  console.log(`  ${brand("\u25C6")} ${bold("Welcome to Alchemy CLI")}`);
+  console.log(`  ${dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
+  console.log(`  ${dim("  Let's get you set up with authentication.")}`);
+  console.log(`  ${dim("  Choose one auth path to continue.")}`);
+  console.log(`  ${dim("  Tip: select 'exit' to skip setup for now.")}`);
+  console.log("");
+  const method = await promptSelect({
+    message: "Choose an auth setup path",
+    options: [
+      {
+        label: "API key",
+        hint: "Query Alchemy RPC nodes",
+        value: "api-key"
+      },
+      {
+        label: "Access Key",
+        hint: "Admin API plus RPC nodes",
+        value: "access-key"
+      },
+      {
+        label: "x402",
+        hint: "Agentic API access and payment",
+        value: "x402"
+      },
+      {
+        label: "exit",
+        value: "exit"
+      }
+    ],
+    initialValue: "api-key",
+    cancelMessage: "Skipped onboarding."
+  });
+  if (!method) return false;
+  if (method === "exit") {
+    console.log(`  ${dim("Exited onboarding.")}`);
+    return false;
+  }
+  if (method === "api-key") {
+    await runAPIKeyOnboarding();
+    const complete2 = Boolean(load().api_key?.trim());
+    if (!complete2) {
+      printNextSteps("api-key");
+    } else {
+      printAPIKeyPostSetupGuidance();
+    }
+    return complete2;
+  }
+  if (method === "access-key") {
+    await runAccessKeyOnboarding();
+    const cfg2 = load();
+    const complete2 = Boolean(cfg2.access_key?.trim() && cfg2.app?.id && cfg2.app.apiKey);
+    if (!complete2) {
+      printNextSteps("access-key");
+    }
+    return complete2;
+  }
+  await runX402Onboarding();
+  const cfg = load();
+  const complete = cfg.x402 === true && Boolean(cfg.wallet_key_file?.trim());
+  if (!complete) {
+    printNextSteps("x402");
+  }
+  return complete;
+}
+export {
+  runOnboarding
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@alchemy/cli",
+  "version": "0.1.0",
+  "description": "Alchemy CLI — interact with blockchain data",
+  "type": "module",
+  "bin": {
+    "alchemy": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "pnpm build && vitest run --config vitest.e2e.config.ts",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "alchemy",
+    "blockchain",
+    "ethereum",
+    "cli"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alchemyplatform/alchemy-cli.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@alchemy/x402": "^0.4.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "packageManager": "pnpm@10.18.2+sha512.9fb969fa749b3ade6035e0f109f0b8a60b5d08a1a87fdf72e337da90dcc93336e2280ca4e44f2358a649b83c17959e9993e777c2080879f3801e6f0d999ad3dd"
+}