traderclaw-cli 1.0.115 → 1.0.117

package/bin/installer-step-engine.mjs

@@ -268,9 +268,17 @@ function commandExists(cmd) {
   }
 }
 
-function getCommandOutput(cmd) {
+function getCommandOutput(cmd, { timeoutMs = 0 } = {}) {
   try {
-    return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], shell: true, maxBuffer: 50 * 1024 * 1024, env: NO_COLOR_ENV }).trim();
+    const opts = {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true,
+      maxBuffer: 50 * 1024 * 1024,
+      env: NO_COLOR_ENV,
+    };
+    if (timeoutMs > 0) opts.timeout = timeoutMs;
+    return execSync(cmd, opts).trim();
   } catch {
     return null;
   }
@@ -511,12 +519,35 @@ export async function ensureOpenClawGlobalPackageDependencies() {
  * global from an older install causes `openclaw plugins install` to fail config validation with
  * "plugin requires OpenClaw >=… but this host is …".
  */
-async function installOpenClawPlatform() {
+/** Bound `openclaw --version` so a post-OAuth CLI that blocks on gateway/device init cannot hang the wizard. */
+const OPENCLAW_CLI_VERSION_TIMEOUT_MS = 25_000;
+
+async function installOpenClawPlatform(onEvent) {
   const hadOpenclaw = commandExists("openclaw");
-  const previousVersion = hadOpenclaw ? getCommandOutput("openclaw --version") : null;
-  await runCommandWithEvents("npm", ["install", "-g", "--ignore-scripts", "--registry", "https://registry.npmjs.org/", `openclaw@${OPENCLAW_VERSION}`]);
+  const previousVersion = hadOpenclaw ? getCommandOutput("openclaw --version", { timeoutMs: OPENCLAW_CLI_VERSION_TIMEOUT_MS }) : null;
+  if (hadOpenclaw && !previousVersion && typeof onEvent === "function") {
+    onEvent({
+      type: "stderr",
+      text: "openclaw --version did not return in time (or failed); continuing with npm install -g anyway.\n",
+      urls: [],
+    });
+  }
+  const npmCwd = getNpmGlobalInstallCwd();
+  await runCommandWithEvents("npm", ["install", "-g", "--ignore-scripts", "--registry", "https://registry.npmjs.org/", `openclaw@${OPENCLAW_VERSION}`], {
+    onEvent,
+    cwd: npmCwd,
+    shell: false,
+  });
   const available = commandExists("openclaw");
-  const version = available ? getCommandOutput("openclaw --version") : null;
+  let version = available ? getCommandOutput("openclaw --version", { timeoutMs: OPENCLAW_CLI_VERSION_TIMEOUT_MS }) : null;
+  if (available && !version && typeof onEvent === "function") {
+    onEvent({
+      type: "stderr",
+      text: "openclaw is on PATH but --version timed out; treating install as successful.\n",
+      urls: [],
+    });
+    version = "(version check timed out)";
+  }
   if (!available) {
     throw new Error(`npm install -g openclaw@${OPENCLAW_VERSION} finished but \`openclaw\` is not available on PATH`);
   }
@@ -1827,12 +1858,13 @@ function configureOpenClawLlmModelPrimaryOnly({ provider, model }, configPath =
 }
 
 /**
- * Spawns `openclaw models auth login --provider openai-codex` with a pseudo-TTY when possible.
+ * Spawns `openclaw models auth login --provider openai-codex --method oauth` with a pseudo-TTY when possible.
+ * `--method oauth` skips the interactive Browser vs Device pairing menu (OpenClaw 2026.4.29+); device flow is `device-code`.
  * The CLI often exits immediately when stdin/stdout are plain pipes (no TTY). On Unix, `script(1)`
  * allocates a PTY so the same flow works as in an interactive terminal.
  */
 export function spawnOpenClawCodexAuthLoginChild() {
-  const argv = ["models", "auth", "login", "--provider", "openai-codex"];
+  const argv = ["models", "auth", "login", "--provider", "openai-codex", "--method", "oauth"];
   if (process.platform === "win32") {
     return spawn("openclaw", argv, { stdio: ["pipe", "pipe", "pipe"], shell: false });
   }
@@ -1846,7 +1878,8 @@ export function spawnOpenClawCodexAuthLoginChild() {
     // --return propagates openclaw's exit code (util-linux 2.38+).
     // -f/--flush: force immediate forwarding of each PTY write to the pipe so the
     // wizard sees the URL as soon as OpenClaw prints it (default is block-buffered).
-    const cmdline = "stty cols 32767 rows 50 2>/dev/null; openclaw models auth login --provider openai-codex";
+    const cmdline =
+      "stty cols 32767 rows 50 2>/dev/null; openclaw models auth login --provider openai-codex --method oauth";
     return spawn("script", ["--return", "-f", "-q", "-c", cmdline, "/dev/null"], {
       stdio: ["pipe", "pipe", "pipe"],
       // COLUMNS/LINES: belt-and-suspenders env fallback for programs that read env
@@ -1859,7 +1892,7 @@ export function spawnOpenClawCodexAuthLoginChild() {
 }
 
 /**
- * Runs `openclaw models auth login --provider openai-codex` and feeds the pasted redirect URL or code on stdin
+ * Runs `openclaw models auth login --provider openai-codex --method oauth` and feeds the pasted redirect URL or code on stdin
  * when the CLI prompts (with a timed fallback for non-interactive / SSH).
  */
 function runOpenClawCodexOAuthLogin(paste, emitLog) {
@@ -2037,6 +2070,8 @@ export class InstallerStepEngine {
       skipInstallOpenClaw: options.skipInstallOpenClaw === true,
       skipInstallPlugin: options.skipInstallPlugin === true,
       skipTailscale: options.skipTailscale === true,
+      /** When true (e.g. EC2 bootstrap before Tailscale auth), gateway starts without `tailscale funnel`. */
+      skipFunnel: options.skipFunnel === true,
       skipGatewayBootstrap: options.skipGatewayBootstrap === true,
       skipGatewayConfig: options.skipGatewayConfig === true,
       // Wizard / CLI — must be preserved for seedXConfig
@@ -2333,7 +2368,7 @@ export class InstallerStepEngine {
         } catch (err) {
           const tail = `${err?.stderr || ""}\n${err?.stdout || ""}\n${err?.message || ""}`.trim();
           throw new Error(
-            `${tail}\n\nIf OAuth cannot complete from the wizard, run in a shell: openclaw models auth login --provider openai-codex — then re-run the wizard with "already logged in" checked.`,
+            `${tail}\n\nIf OAuth cannot complete from the wizard, run in a shell: openclaw models auth login --provider openai-codex --method oauth — then re-run the wizard with "already logged in" checked.`,
           );
         }
       }
@@ -2347,7 +2382,7 @@ export class InstallerStepEngine {
         throw new Error(
           "No OAuth credentials found at " + authFile + ". " +
           "The wizard OAuth flow did not save tokens (the callback may not have reached the OpenClaw CLI). " +
-          "Run 'openclaw models auth login --provider openai-codex' in a terminal, " +
+          "Run 'openclaw models auth login --provider openai-codex --method oauth' in a terminal, " +
           "then re-run the wizard with the 'already logged in' option.",
         );
       }
@@ -2487,7 +2522,11 @@ export class InstallerStepEngine {
       }
 
       if (!this.options.skipInstallOpenClaw) {
-        await this.runStep("install_openclaw", "Installing or upgrading OpenClaw platform", async () => installOpenClawPlatform());
+        await this.runStep("install_openclaw", "Installing or upgrading OpenClaw platform", async () =>
+          installOpenClawPlatform((evt) =>
+            this.emitLog("install_openclaw", evt.type === "stderr" ? "warn" : "info", evt.text, evt.urls || []),
+          ),
+        );
       }
 
       // Non-fatal: warn when the CLI has devices in pending-approval or repair state.
@@ -2598,6 +2637,14 @@ export class InstallerStepEngine {
             );
             await this.runWithPrivilegeGuidance("gateway_bootstrap", "openclaw", ["gateway", "install"]);
             await this.runWithPrivilegeGuidance("gateway_bootstrap", "openclaw", ["gateway", "restart"]);
+            if (this.options.skipFunnel) {
+              this.emitLog(
+                "gateway_bootstrap",
+                "info",
+                "Skipping Tailscale funnel (skipFunnel). After `tailscale up`, run: traderclaw install --headless --funnel-only",
+              );
+              return { funnelSkipped: true };
+            }
             return this.runFunnel();
           } catch (err) {
             const text = `${err?.message || ""}\n${err?.stderr || ""}\n${err?.stdout || ""}`.toLowerCase();
@@ -2613,6 +2660,9 @@ export class InstallerStepEngine {
             if (gatewayStartFailed || gatewayModeUnset) {
               const recovered = await this.tryAutoRecoverGatewayMode("gateway_bootstrap");
               if (recovered.success) {
+                if (this.options.skipFunnel) {
+                  return { funnelSkipped: true, recovered: true };
+                }
                 return this.runFunnel();
               }
               if (gatewayModeUnset) {
@@ -2804,6 +2854,28 @@ export class InstallerStepEngine {
   }
 }
 
+/**
+ * After Tailscale login (`tailscale up`), expose loopback gateway :18789 via funnel.
+ */
+export async function tailscaleFunnelOpenclaw18789(options = {}) {
+  const onEvt = typeof options.onEvent === "function" ? options.onEvent : () => {};
+  try {
+    await runCommandWithEvents(
+      "tailscale",
+      ["funnel", "--bg", "18789"],
+      { onEvent: (evt) => onEvt(evt) },
+    );
+  } catch (err) {
+    const details = `${err?.stderr || ""}\n${err?.stdout || ""}\n${err?.message || ""}`.toLowerCase();
+    if (details.includes("access denied") || details.includes("operator")) {
+      throw new Error(tailscalePermissionRemediation());
+    }
+    throw err;
+  }
+  const statusOut = getCommandOutput("tailscale funnel status") || "";
+  return { funnelUrl: firstUrl(statusOut) || null, rawStatus: statusOut };
+}
+
 export function assertWizardXCredentials(modeConfig, options = {}) {
   const t = (s) => (typeof s === "string" ? s.trim() : "");
   const o = options || {};

package/bin/openclaw-trader.mjs

@@ -2135,6 +2135,10 @@ function parseInstallWizardArgs(args) {
     if ((key === "--gateway-token" || key === "-t") && next) out.gatewayToken = args[++i];
     if (key === "--with-telegram") out.enableTelegram = true;
     if (key === "--telegram-token" && next) out.telegramToken = args[++i];
+    if (key === "--x-consumer-key" && next) out.xConsumerKey = args[++i];
+    if (key === "--x-consumer-secret" && next) out.xConsumerSecret = args[++i];
+    if (key === "--x-access-token-main" && next) out.xAccessTokenMain = args[++i];
+    if (key === "--x-access-token-main-secret" && next) out.xAccessTokenMainSecret = args[++i];
   }
   return out;
 }
@@ -3043,7 +3047,11 @@ function wizardHtml(defaults) {
             setOauthStep(oauthStepOpen, "error");
             setOauthStep(oauthStepComplete, "error");
             setOauthStep(oauthStepVerify, "error");
-            setOauthStatus((data && (data.message || data.error)) || "Could not start OAuth sign-in.", true);
+            let msg = (data && (data.message || data.error)) || "Could not start OAuth sign-in.";
+            if (data && typeof data.detail === "string" && data.detail.trim()) {
+              msg += " " + data.detail.trim().slice(0, 1500);
+            }
+            setOauthStatus(msg, true);
             if (oauthRetryBtn) oauthRetryBtn.classList.remove("hidden");
             updateStartButtonState();
             return;
@@ -3594,10 +3602,163 @@ function wizardHtml(defaults) {
 </html>`;
 }
 
+function traderclawHeadlessEnv(name) {
+  return String(process.env[name] || "").trim();
+}
+
+function parseInstallHeadlessMeta(args) {
+  const funnelOnly = args.includes("--funnel-only");
+  const skipTailscale =
+    args.includes("--skip-tailscale") || traderclawHeadlessEnv("TRADERCLAW_INSTALL_SKIP_TAILSCALE") === "1";
+  let skipFunnel = args.includes("--skip-funnel") || traderclawHeadlessEnv("TRADERCLAW_INSTALL_SKIP_FUNNEL") === "1";
+  if (skipTailscale) skipFunnel = true;
+  return { funnelOnly, skipTailscale, skipFunnel };
+}
+
+function filterHeadlessArgv(args) {
+  const strip = new Set(["--headless", "--funnel-only", "--skip-tailscale", "--skip-funnel"]);
+  return args.filter((a) => !strip.has(a));
+}
+
+async function cmdInstallHeadless(args) {
+  const meta = parseInstallHeadlessMeta(args);
+  const { tailscaleFunnelOpenclaw18789, createInstallerStepEngine, assertWizardXCredentials } = await import(
+    "./installer-step-engine.mjs",
+  );
+
+  if (meta.funnelOnly) {
+    print("\nTraderClaw install — Tailscale funnel (public HTTPS → gateway loopback :18789)\n");
+    try {
+      const r = await tailscaleFunnelOpenclaw18789({
+        onEvent: (evt) => {
+          const t = typeof evt?.text === "string" ? evt.text : "";
+          if (t.trim()) printInfo(t.trimEnd());
+        },
+      });
+      if (r.funnelUrl) printSuccess(`Public gateway URL (Tailscale funnel): ${r.funnelUrl}`);
+      else printWarn("Could not parse funnel URL — on the VPS run: tailscale funnel status");
+      print("");
+    } catch (err) {
+      printError(err?.message || String(err));
+      process.exit(1);
+    }
+    printInfo(
+      "Use this URL as gatewayBaseUrl when running: traderclaw setup --gateway-base-url <url> --gateway-token <token>",
+    );
+    return;
+  }
+
+  let w = parseInstallWizardArgs(filterHeadlessArgv(args));
+  w.llmProvider = w.llmProvider || traderclawHeadlessEnv("TRADERCLAW_HEADLESS_LLM_PROVIDER");
+  w.llmModel = w.llmModel || traderclawHeadlessEnv("TRADERCLAW_HEADLESS_LLM_MODEL");
+  w.llmCredential =
+    w.llmCredential
+    || traderclawHeadlessEnv("TRADERCLAW_HEADLESS_LLM_API_KEY")
+    || traderclawHeadlessEnv("TRADERCLAW_LLM_API_KEY");
+  w.telegramToken =
+    w.telegramToken
+    || traderclawHeadlessEnv("TRADERCLAW_HEADLESS_TELEGRAM_TOKEN")
+    || traderclawHeadlessEnv("OPENCLAW_TELEGRAM_BOT_TOKEN");
+  w.apiKey =
+    w.apiKey
+    || traderclawHeadlessEnv("TRADERCLAW_HEADLESS_ORCHESTRATOR_API_KEY")
+    || traderclawHeadlessEnv("TRADERCLAW_API_KEY");
+  if (!(w.orchestratorUrl || "").trim()) {
+    w.orchestratorUrl = traderclawHeadlessEnv("TRADERCLAW_ORCHESTRATOR_URL") || "https://api.traderclaw.ai";
+  }
+  w.xConsumerKey = w.xConsumerKey || traderclawHeadlessEnv("X_CONSUMER_KEY");
+  w.xConsumerSecret = w.xConsumerSecret || traderclawHeadlessEnv("X_CONSUMER_SECRET");
+  w.xAccessTokenMain = w.xAccessTokenMain || traderclawHeadlessEnv("X_ACCESS_TOKEN_MAIN");
+  w.xAccessTokenMainSecret =
+    w.xAccessTokenMainSecret || traderclawHeadlessEnv("X_ACCESS_TOKEN_MAIN_SECRET");
+
+  if (w.llmAuthMode === "oauth") {
+    printError("traderclaw install --headless does not support LLM OAuth — use traderclaw install --wizard");
+    process.exit(1);
+  }
+  if (!w.llmProvider || !w.llmModel || !w.llmCredential) {
+    printError(
+      "Headless install requires --llm-provider, --llm-model, --llm-api-key (env: TRADERCLAW_HEADLESS_LLM_* ).",
+    );
+    process.exit(1);
+  }
+  if (!w.telegramToken) {
+    printError("Headless install requires --telegram-token (env: TRADERCLAW_HEADLESS_TELEGRAM_TOKEN).");
+    process.exit(1);
+  }
+
+  const modeConfig = {
+    pluginPackage: "solana-traderclaw",
+    pluginId: "solana-trader",
+    cliName: "traderclaw",
+    gatewayConfig: "gateway-v1.json5",
+    agents: ["cto", "onchain-analyst", "alpha-signal-analyst", "risk-officer", "strategy-researcher"],
+  };
+
+  const xErr = assertWizardXCredentials(modeConfig, w);
+  if (xErr) {
+    printError(xErr);
+    process.exit(1);
+  }
+
+  print("\nTraderClaw install — headless (non-interactive)\n");
+  const engine = createInstallerStepEngine(
+    modeConfig,
+    {
+      lane: w.lane === "quick-local" ? "quick-local" : "event-driven",
+      llmAuthMode: "api_key",
+      llmProvider: w.llmProvider,
+      llmModel: w.llmModel,
+      llmCredential: w.llmCredential,
+      apiKey: w.apiKey || "",
+      orchestratorUrl: String(w.orchestratorUrl || "https://api.traderclaw.ai").replace(/\/+$/, ""),
+      gatewayBaseUrl: w.gatewayBaseUrl || "",
+      gatewayToken: w.gatewayToken || "",
+      enableTelegram: true,
+      telegramToken: w.telegramToken,
+      skipTailscale: meta.skipTailscale,
+      skipFunnel: meta.skipFunnel,
+      xConsumerKey: w.xConsumerKey,
+      xConsumerSecret: w.xConsumerSecret,
+      xAccessTokenMain: w.xAccessTokenMain,
+      xAccessTokenMainSecret: w.xAccessTokenMainSecret,
+    },
+    {
+      onLog: ({ text }) => {
+        if (text) print(String(text));
+      },
+      onStepEvent: ({ stepId, status, detail }) => {
+        print(`[install] ${stepId} ${status}${detail ? ` — ${detail}` : ""}`);
+      },
+    },
+  );
+
+  const state = await engine.runAll();
+  if (state.status !== "completed") {
+    printError("Headless install failed.");
+    process.exit(1);
+  }
+
+  printSuccess("\nHeadless install completed.");
+  if (state.setupHandoff?.command) {
+    printInfo(`CLI hand-off: ${state.setupHandoff.command}`);
+  }
+  if (meta.skipFunnel) {
+    printWarn(
+      "Funnel skipped — run `tailscale up` then `traderclaw install --headless --funnel-only`, then traderclaw setup with --gateway-base-url.",
+    );
+  }
+}
+
 async function cmdInstall(args) {
+  const headless = args.includes("--headless");
+  if (headless) {
+    await cmdInstallHeadless(args);
+    return;
+  }
   const wizard = args.includes("--wizard");
   if (!wizard) {
-    printError("Only wizard mode is currently supported. Use: traderclaw install --wizard");
+    printError('Use: traderclaw install --wizard  or  traderclaw install --headless (--help)');
     process.exit(1);
   }
 
@@ -3629,6 +3790,27 @@ async function cmdInstall(args) {
   // The \S+ (non-whitespace) tail captures the full query string; see trySendUrl()
   // for why we run this against a stripAnsi+CR-stripped copy of the output.
   const OPENAI_OAUTH_AUTHORIZE_RE = /https:\/\/auth\.openai\.com\/(?:oauth\/authorize|authorize)[^\s"]*/;
+  const OPENAI_OAUTH_AUTHORIZE_RE_LOOSE =
+    /https:\/\/(?:[a-z0-9-]+\.)*openai\.com\/[^\s"]*?(?:oauth\/authorize|\/authorize[^\s"]*)/i;
+
+  /** Best-effort: primary regex, then subdomain/openai authorize URLs, then token-like query heuristics. */
+  function tryExtractOpenAiCodexAuthorizeUrl(cleaned) {
+    let m = cleaned.match(OPENAI_OAUTH_AUTHORIZE_RE);
+    if (m?.[0]) return m[0];
+    m = cleaned.match(OPENAI_OAUTH_AUTHORIZE_RE_LOOSE);
+    if (m?.[0]) return m[0];
+    const candidates = cleaned.match(/https:\/\/[^\s"]+/g) || [];
+    for (const u of candidates) {
+      if (
+        /openai\.com/i.test(u)
+        && /authorize/i.test(u)
+        && /oauth|response_type|client_id|redirect_uri|scope=/i.test(u)
+      ) {
+        return u;
+      }
+    }
+    return null;
+  }
   const oauthSessionTtlMs = 15 * 60 * 1000;
 
   // Long-lived callback proxy on port 1455. Bound at wizard startup so
@@ -3856,6 +4038,10 @@ async function cmdInstall(args) {
       const urlTimeout = setTimeout(() => {
         if (responded) return;
         responded = true;
+        const detail = stripAnsi(combined).slice(-4000);
+        if (process.env.TRADERCLAW_WIZARD_OAUTH_DEBUG === "1") {
+          printWarn(`[TRADERCLAW_WIZARD_OAUTH_DEBUG] OpenClaw output tail before oauth_url_timeout:\n${detail}`);
+        }
         try {
           child.kill("SIGTERM");
         } catch {
@@ -3868,6 +4054,7 @@ async function cmdInstall(args) {
           error: "oauth_url_timeout",
           message:
             "OpenClaw did not provide a ChatGPT sign-in URL in time. Try again.",
+          detail,
         });
       }, 120_000);
 
@@ -3881,17 +4068,17 @@ async function cmdInstall(args) {
         const cleanedForUrl = stripAnsi(combined)
           .replace(/\r/g, "")
           .replace(/([A-Za-z0-9%&=+?#:/@._~!$'()*,;-])\n([A-Za-z0-9%&=+?#:/@._~!$'()*,;-])/g, "$1$2");
-        let m = cleanedForUrl.match(OPENAI_OAUTH_AUTHORIZE_RE);
+        let authUrl = tryExtractOpenAiCodexAuthorizeUrl(cleanedForUrl);
         // Layer 2: try the raw combined buffer in case stripAnsi dropped a character that
         // broke the URL detection (raw ANSI seqs don't include space so regex still works).
-        if (!m || !m[0]) {
+        if (!authUrl) {
           const rawCleaned = combined.replace(/\r/g, "")
             .replace(/([A-Za-z0-9%&=+?#:/@._~!$'()*,;-])\n([A-Za-z0-9%&=+?#:/@._~!$'()*,;-])/g, "$1$2");
-          m = rawCleaned.match(OPENAI_OAUTH_AUTHORIZE_RE);
+          authUrl = tryExtractOpenAiCodexAuthorizeUrl(rawCleaned);
         }
-        if (!m || !m[0]) return;
+        if (!authUrl) return;
         // Strip any trailing ANSI remnants (e.g. \x1b[0m appended by colour reset)
-        const authUrl = stripAnsi(m[0]).replace(/\r/g, "").trim();
+        authUrl = stripAnsi(authUrl).replace(/\r/g, "").trim();
         if (!authUrl.startsWith("https://")) return;
         clearTimeout(urlTimeout);
         responded = true;
@@ -3954,7 +4141,7 @@ async function cmdInstall(args) {
             pending.status = "failed";
             pending.message =
               "OpenClaw exited OK but no auth tokens were saved. " +
-              "Run 'openclaw models auth login --provider openai-codex' in a terminal, " +
+              "Run 'openclaw models auth login --provider openai-codex --method oauth' in a terminal, " +
               "then re-run the wizard with the already-logged-in option.";
           } else {
             pending.status = "failed";
@@ -4166,6 +4353,10 @@ async function cmdInstall(args) {
         return;
       }
 
+      for (const id of [...oauthSessions.keys()]) {
+        killOauthSession(id);
+      }
+
       running = true;
       runtime.status = "running";
       runtime.logs = [];
@@ -4598,6 +4789,16 @@ Install wizard (traderclaw install --wizard):
   --llm-oauth-paste    Paste redirect URL or code for Codex OAuth (non-skip)
   --llm-oauth-skip-login       Skip login when you already ran openclaw models auth login
 
+Headless VPS / CI (traderclaw install --headless):
+  Requires API-key LLM (no OAuth): --llm-provider, --llm-model, --llm-api-key, --telegram-token
+  Same flags as wizard for --api-key/-k, --url/-u, --gateway-base-url/-g, X/Twitter (optional, all-or-none):
+  --x-consumer-key ... --x-consumer-secret ... --x-access-token-main ... --x-access-token-main-secret ...
+  --skip-tailscale       Skip Tailscale install/up (implies --skip-funnel unless overridden)
+  --skip-funnel          Do not run tailscale funnel after gateway restart
+  --funnel-only          After manual tailscale up: publish gateway :18789 via funnel only
+  Env: TRADERCLAW_HEADLESS_LLM_PROVIDER/MODEL/API_KEY, TRADERCLAW_HEADLESS_TELEGRAM_TOKEN,
+       TRADERCLAW_HEADLESS_ORCHESTRATOR_API_KEY, TRADERCLAW_INSTALL_SKIP_TAILSCALE/FUNNEL, X_* etc.
+
 Examples:
   traderclaw signup
   traderclaw setup
@@ -4608,6 +4809,9 @@ Examples:
   traderclaw install --wizard
   traderclaw install --wizard --lane quick-local
   traderclaw install --wizard --llm-auth oauth --llm-provider openai-codex --llm-oauth-skip-login
+  traderclaw install --headless --skip-tailscale --llm-provider anthropic --llm-model anthropic/claude-sonnet-4-6 \\
+    --llm-api-key \"$ANTHROPIC_KEY\" --telegram-token \"$TG\" --skip-funnel
+  traderclaw install --headless --funnel-only
   traderclaw repair-openclaw
   traderclaw gateway ensure-persistent
   traderclaw setup --signup --user-id my_agent_001 --referral-code ABCD1234

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "traderclaw-cli",
-  "version": "1.0.115",
+  "version": "1.0.117",
   "description": "Global TraderClaw CLI (install --wizard, setup, precheck). Installs solana-traderclaw as a dependency for OpenClaw plugin files.",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "solana-traderclaw": "^1.0.115"
+    "solana-traderclaw": "^1.0.117"
   },
   "keywords": [
     "traderclaw",