traderclaw-cli 1.0.116 → 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`);
   }
@@ -2039,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
@@ -2489,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.
@@ -2600,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();
@@ -2615,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) {
@@ -2806,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;
 }
@@ -3598,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);
   }
 
@@ -4196,6 +4353,10 @@ async function cmdInstall(args) {
         return;
       }
 
+      for (const id of [...oauthSessions.keys()]) {
+        killOauthSession(id);
+      }
+
       running = true;
       runtime.status = "running";
       runtime.logs = [];
@@ -4628,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
@@ -4638,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.116",
+  "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.116"
+    "solana-traderclaw": "^1.0.117"
   },
   "keywords": [
     "traderclaw",