@clanker-chain/clanker-cli 2026.9.8 → 2026.9.12-1

package/lib/setup.mjs

@@ -3,7 +3,14 @@
  */
 
 import { stdin as input } from "node:process";
-import { existsSync } from "node:fs";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
 import { getAddress } from "viem";
 import * as clack from "@clack/prompts";
 import {
@@ -33,8 +40,12 @@ import {
   exportFoundryKey,
   resolveFoundryAddress,
 } from "./foundry.mjs";
+import {
+  consumerFundHints,
+  generateOperatorKeyFile,
+} from "./operator-key.mjs";
+import { wireOpenClawMqtt } from "./openclaw-wire.mjs";
 import { c, nextHint } from "./ui.mjs";
-import { join } from "node:path";
 
 /**
  * @param {string[]} argv
@@ -52,6 +63,8 @@ export function parseSetupFlags(argv) {
   let skipChainCheck = false;
   let foundryAccount = null;
   let exportKey = false;
+  let generateKey = false;
+  let botKey = null;
 
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
@@ -62,7 +75,9 @@ export function parseSetupFlags(argv) {
     else if (a === "--key-env" && argv[i + 1]) keyEnv = argv[++i];
     else if (a === "--from-block" && argv[i + 1]) fromBlock = BigInt(argv[++i]);
     else if (a === "--foundry-account" && argv[i + 1]) foundryAccount = argv[++i];
+    else if (a === "--bot-key" && argv[i + 1]) botKey = argv[++i];
     else if (a === "--export-key") exportKey = true;
+    else if (a === "--generate-key") generateKey = true;
     else if (a === "--force") force = true;
     else if (a === "--yes" || a === "-y") yes = true;
     else if (a === "--skip-key") skipKey = true;
@@ -82,6 +97,8 @@ export function parseSetupFlags(argv) {
     skipChainCheck,
     foundryAccount,
     exportKey,
+    generateKey,
+    botKey,
   };
 }
 
@@ -155,6 +172,39 @@ export function buildKeyPointer({ keyFile, keyEnv, skipKey, env = process.env })
   return null;
 }
 
+/**
+ * Copy a downloaded bot key into ~/.openclaw/keys and wire channels.mqtt.
+ * @param {string} botKeyPath
+ * @param {{
+ *   operatorLabel: string,
+ *   network: { rpc: string, registry: string|null, brokerUrl?: string, mqttAuthServiceUrl?: string },
+ *   openclawHome?: string,
+ * }} opts
+ */
+export function attachBotKeyFile(botKeyPath, opts) {
+  if (!existsSync(botKeyPath)) {
+    throw new Error(`Bot key file not found: ${botKeyPath}`);
+  }
+  const botId = basename(botKeyPath).replace(/\.key$/i, "");
+  if (!botId || botId.includes("/") || botId.includes("..")) {
+    throw new Error(`Invalid bot key basename: ${botKeyPath}`);
+  }
+  const openclawHome = opts.openclawHome ?? join(homedir(), ".openclaw");
+  const destDir = join(openclawHome, "keys");
+  mkdirSync(destDir, { recursive: true });
+  const dest = join(destDir, `${botId}.key`);
+  copyFileSync(botKeyPath, dest);
+  chmodSync(dest, 0o600);
+  const wired = wireOpenClawMqtt({
+    botId,
+    operatorId: opts.operatorLabel,
+    network: opts.network,
+    keyPath: dest,
+    openclawHome,
+  });
+  return { botId, keyPath: dest, openclawPath: wired.path };
+}
+
 /**
  * Apply setup choices to disk.
  */
@@ -203,7 +253,7 @@ export async function runSetupNonInteractive(argv, opts = {}) {
   if (!flags.preset || !PRESETS[flags.preset]) {
     throw new Error(
       "Non-interactive setup requires --preset sepolia|local (stdin is not a TTY). " +
-        "Also pass --operator <label> and --address 0x…",
+        "Also pass --operator <label> and --generate-key (or --address / --key-file)",
     );
   }
   if (!flags.operator) {
@@ -218,6 +268,23 @@ export async function runSetupNonInteractive(argv, opts = {}) {
     inheritStdio: false,
   };
 
+  if (flags.generateKey) {
+    if (flags.skipKey) {
+      throw new Error("Cannot combine --generate-key with --skip-key");
+    }
+    const dest = keyFile || defaultOperatorKeyPath(home);
+    const created = generateOperatorKeyFile(dest, {
+      force: flags.force,
+    });
+    keyFile = created.path;
+    if (address && getAddress(address) !== getAddress(created.address)) {
+      throw new Error(
+        `Generated key address ${created.address} does not match --address ${getAddress(address)}`,
+      );
+    }
+    address = created.address;
+  }
+
   if (flags.foundryAccount) {
     if (!address) {
       address = resolveFoundryAddress(flags.foundryAccount, castOpts);
@@ -238,7 +305,7 @@ export async function runSetupNonInteractive(argv, opts = {}) {
   if (!address && env.OPERATOR_PRIVATE_KEY) address = addressFromEnv(env);
   if (!address) {
     throw new Error(
-      "Non-interactive setup requires --address 0x…, --key-file, OPERATOR_PRIVATE_KEY, or --foundry-account",
+      "Non-interactive setup requires --generate-key, --address 0x…, --key-file, OPERATOR_PRIVATE_KEY, or --foundry-account",
     );
   }
 
@@ -275,7 +342,7 @@ export async function runSetupNonInteractive(argv, opts = {}) {
     }
   }
 
-  return applySetup(
+  const result = applySetup(
     {
       preset: flags.preset,
       force: flags.force || flags.yes,
@@ -287,6 +354,34 @@ export async function runSetupNonInteractive(argv, opts = {}) {
     },
     { home, env },
   );
+  return finishSetupResult(result, flags, { ...opts, quiet: true });
+}
+
+/**
+ * @param {object} result
+ * @param {{ botKey?: string|null, operator?: string|null }} flags
+ * @param {{ openclawHome?: string, quiet?: boolean }} [opts]
+ */
+async function finishSetupResult(result, flags, opts = {}) {
+  if (flags.botKey) {
+    const attached = attachBotKeyFile(flags.botKey, {
+      operatorLabel: result.operator?.label ?? flags.operator,
+      network: {
+        rpc: result.config.chainRpcUrl,
+        registry: result.config.registryAddress,
+        brokerUrl: result.config.brokerUrl,
+        mqttAuthServiceUrl: result.config.mqttAuthServiceUrl,
+      },
+      openclawHome: opts.openclawHome,
+    });
+    result.botKey = attached;
+    if (!opts.quiet) {
+      clack.log.success(
+        `Bot key → ${attached.keyPath}; wired ${attached.openclawPath}`,
+      );
+    }
+  }
+  return result;
 }
 
 /**
@@ -305,9 +400,13 @@ export async function runSetupInteractive(argv, opts = {}) {
   });
 
   clack.intro(c.bold("clanker setup"));
-  clack.log.step("Creates ~/.clanker/config.json (network) and operator.json (identity).");
+  clack.log.step(
+    "Sets up your operator identity (org account) and network for OpenClaw bots.",
+  );
   clack.log.message(
-    c.dim("whoami works from owner without a key; mint/revoke need a key pointer later."),
+    c.dim(
+      "Attach an existing owner address (/join or any 0x), or create ~/.clanker/op.key. Mint needs test ETH later.",
+    ),
   );
   clack.log.message(c.dim(`Profile: ${home}`));
   console.log("");
@@ -366,6 +465,28 @@ export async function runSetupInteractive(argv, opts = {}) {
 
   let address = flags.address ?? null;
   let foundryAccountUsed = null;
+  let generatedKeyFile = null;
+  if (!address && flags.generateKey) {
+    const dest = flags.keyFile || defaultOperatorKeyPath(home);
+    let forceGen = flags.force;
+    if (existsSync(dest) && !forceGen) {
+      forceGen = cancelIf(
+        await clack.confirm({
+          message: `Overwrite existing ${dest}?`,
+          initialValue: false,
+        }),
+      );
+      if (!forceGen) {
+        clack.cancel("Aborted.");
+        process.exit(0);
+      }
+    }
+    const created = generateOperatorKeyFile(dest, { force: true });
+    generatedKeyFile = created.path;
+    address = created.address;
+    clack.log.success(`Created operator key at ${created.path}`);
+    clack.log.info(`Your operator address: ${created.address}`);
+  }
   if (!address && flags.keyFile) {
     address = addressFromKeyFile(flags.keyFile);
     clack.log.info(`Address from --key-file: ${address}`);
@@ -388,23 +509,87 @@ export async function runSetupInteractive(argv, opts = {}) {
     );
     if (useOp) address = hints.operator.owner;
   }
-  if (!address && hints.foundryAccounts.length) {
+  if (!address) {
     const options = [
-      ...hints.foundryAccounts.map((n) => ({
-        value: n,
-        label: n,
-        hint: "resolve via cast wallet address",
-      })),
-      { value: "__paste__", label: "Paste an address…", hint: "0x…" },
+      {
+        value: "__paste__",
+        label: "I already have an owner address",
+        hint: "/join or any 0x — usually read-only",
+      },
+      {
+        value: "__generate__",
+        label: "Create a new operator key for me",
+        hint: "writes ~/.clanker/op.key",
+      },
+      {
+        value: "__keyfile__",
+        label: "Use an existing key file…",
+        hint: "path to a 0x private key file",
+      },
     ];
+    if (hints.foundryAccounts.length) {
+      for (const n of hints.foundryAccounts) {
+        options.push({
+          value: n,
+          label: `Foundry: ${n}`,
+          hint: "advanced — cast wallet",
+        });
+      }
+    } else {
+      options.push({
+        value: "__foundry_missing__",
+        label: "Foundry account…",
+        hint: "advanced — install Foundry first",
+      });
+    }
+
     const pick = cancelIf(
       await clack.select({
-        message: "Operator owner source",
+        message: "How do you want to set your operator identity?",
         options,
-        initialValue: hints.foundryAccounts[0],
+        initialValue: "__paste__",
       }),
     );
-    if (pick === "__paste__") {
+
+    let attachReadOnly = false;
+    if (pick === "__generate__") {
+      const dest = defaultOperatorKeyPath(home);
+      let forceGen = flags.force;
+      if (existsSync(dest) && !forceGen) {
+        forceGen = cancelIf(
+          await clack.confirm({
+            message: `Overwrite existing ${dest}?`,
+            initialValue: false,
+          }),
+        );
+        if (!forceGen) {
+          clack.cancel("Aborted.");
+          process.exit(0);
+        }
+      }
+      const created = generateOperatorKeyFile(dest, { force: true });
+      generatedKeyFile = created.path;
+      address = created.address;
+      clack.log.success(`Created operator key at ${created.path}`);
+      clack.log.info(`Your operator address: ${created.address}`);
+    } else if (pick === "__keyfile__") {
+      const path = cancelIf(
+        await clack.text({
+          message: "Path to operator key file",
+          placeholder: join(home, "op.key"),
+          validate: (v) =>
+            v && String(v).trim() && existsSync(String(v).trim())
+              ? undefined
+              : "File not found",
+        }),
+      );
+      generatedKeyFile = String(path).trim();
+      address = addressFromKeyFile(generatedKeyFile);
+      clack.log.info(`Address from key file: ${address}`);
+    } else if (pick === "__foundry_missing__") {
+      clack.log.warn(
+        "Foundry (cast) is not available. Install https://book.getfoundry.sh/ or choose Create a new operator key.",
+      );
       address = cancelIf(
         await clack.text({
           message: "Operator owner address",
@@ -413,6 +598,17 @@ export async function runSetupInteractive(argv, opts = {}) {
             /^0x[0-9a-fA-F]{40}$/.test(v || "") ? undefined : "Need 0x + 40 hex",
         }),
       );
+      attachReadOnly = true;
+    } else if (pick === "__paste__") {
+      address = cancelIf(
+        await clack.text({
+          message: "Owner address (from /join or any EOA)",
+          placeholder: "0x…",
+          validate: (v) =>
+            /^0x[0-9a-fA-F]{40}$/.test(v || "") ? undefined : "Need 0x + 40 hex",
+        }),
+      );
+      attachReadOnly = true;
     } else {
       foundryAccountUsed = pick;
       try {
@@ -435,16 +631,9 @@ export async function runSetupInteractive(argv, opts = {}) {
         );
       }
     }
-  }
-  if (!address) {
-    address = cancelIf(
-      await clack.text({
-        message: "Operator owner address",
-        placeholder: "0x…",
-        validate: (v) =>
-          /^0x[0-9a-fA-F]{40}$/.test(v || "") ? undefined : "Need 0x + 40 hex",
-      }),
-    );
+    if (attachReadOnly) {
+      flags.skipKey = true;
+    }
   }
   address = getAddress(address);
 
@@ -483,7 +672,7 @@ export async function runSetupInteractive(argv, opts = {}) {
     throw err;
   }
 
-  let keyFile = flags.keyFile;
+  let keyFile = flags.keyFile || generatedKeyFile;
   let keyEnv = flags.keyEnv;
   let skipKey = flags.skipKey;
   if (!skipKey && !keyFile && !keyEnv) {
@@ -575,11 +764,23 @@ export async function runSetupInteractive(argv, opts = {}) {
     { home, env },
   );
 
+  await finishSetupResult(result, { ...flags, operator: label }, opts);
+
   clack.outro(c.green(`Wrote ${result.configPath}\nWrote ${result.operatorPath}`));
   if (!key) {
     nextHint([
+      "clanker fund",
       "clanker whoami",
-      "clanker setup --key-file ~/.clanker/op.key --force   # when you need mint",
+      "mint/pair/rotate need a signing key or stay on /join",
+    ]);
+  } else if (preset === "sepolia" && generatedKeyFile) {
+    nextHint(consumerFundHints({ address, label }));
+  } else if (preset === "sepolia") {
+    nextHint([
+      "clanker fund",
+      "clanker doctor",
+      "clanker whoami",
+      `clanker bot mint <label>`,
     ]);
   } else {
     nextHint(["clanker whoami", `clanker bot mint <label>`]);
@@ -593,23 +794,20 @@ export async function runSetupInteractive(argv, opts = {}) {
 export async function runSetup(argv, opts = {}) {
   const flags = parseSetupFlags(argv);
   const isTTY = opts.isTTY ?? Boolean(input.isTTY);
+  const hasIdentitySource = Boolean(
+    flags.address ||
+      flags.keyFile ||
+      flags.generateKey ||
+      flags.foundryAccount ||
+      opts.env?.OPERATOR_PRIVATE_KEY ||
+      process.env.OPERATOR_PRIVATE_KEY,
+  );
 
-  if (
-    !isTTY ||
-    (flags.yes && flags.preset && flags.operator && (flags.address || flags.keyFile))
-  ) {
+  if (!isTTY || (flags.yes && flags.preset && flags.operator && hasIdentitySource)) {
     if (!isTTY && !(flags.preset && flags.operator)) {
       return runSetupNonInteractive(argv, opts);
     }
-    if (
-      flags.yes &&
-      flags.preset &&
-      flags.operator &&
-      (flags.address ||
-        flags.keyFile ||
-        opts.env?.OPERATOR_PRIVATE_KEY ||
-        process.env.OPERATOR_PRIVATE_KEY)
-    ) {
+    if (flags.yes && flags.preset && flags.operator && hasIdentitySource) {
       return runSetupNonInteractive(argv, opts);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clanker-chain/clanker-cli",
-  "version": "2026.9.8",
+  "version": "2026.9.12-1",
   "description": "CLI for wiring clanker-chain identity and MQTT into OpenClaw and other agentic stacks.",
   "type": "module",
   "bin": {
@@ -25,6 +25,9 @@
   "dependencies": {
     "@clack/prompts": "^1.8.0",
     "picocolors": "^1.1.1",
-    "viem": "^2.21.0"
+    "viem": "^2.56.3"
+  },
+  "overrides": {
+    "ws": "^8.21.0"
   }
 }