starkbot-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1571 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/ui.ts
+import chalk from "chalk";
+import ora from "ora";
+function banner() {
+  console.log(brand.bold("\n  \u26A1 Starkbot CLI\n"));
+}
+function spinner(text) {
+  return ora({ text, color: "magenta" });
+}
+function printError(msg) {
+  console.error(`${error.bold("Error:")} ${msg}`);
+}
+function printSuccess(msg) {
+  console.log(`${success("\u2713")} ${msg}`);
+}
+function printWarning(msg) {
+  console.log(`${warn("!")} ${msg}`);
+}
+function printKeyValue(key, value) {
+  console.log(`  ${dim(key + ":")} ${value ?? dim("\u2014")}`);
+}
+var brand, success, error, warn, dim, info, bold, prefix;
+var init_ui = __esm({
+  "src/lib/ui.ts"() {
+    "use strict";
+    brand = chalk.hex("#7C3AED");
+    success = chalk.green;
+    error = chalk.red;
+    warn = chalk.yellow;
+    dim = chalk.dim;
+    info = chalk.cyan;
+    bold = chalk.bold;
+    prefix = {
+      you: chalk.green.bold("you>"),
+      agent: chalk.cyan.bold("agent>"),
+      system: chalk.blue.bold("system>"),
+      error: chalk.red.bold("error>")
+    };
+  }
+});
+
+// src/lib/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    CONFIG_DIR = join(homedir(), ".starkbot-cli");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+    DEFAULT_CONFIG = {
+      flash_base_url: "https://starkbot.cloud"
+    };
+  }
+});
+
+// src/lib/flash-client.ts
+var FlashClient;
+var init_flash_client = __esm({
+  "src/lib/flash-client.ts"() {
+    "use strict";
+    init_config();
+    FlashClient = class {
+      baseUrl;
+      jwt;
+      constructor(jwt) {
+        this.baseUrl = loadConfig().flash_base_url;
+        this.jwt = jwt;
+      }
+      headers() {
+        return {
+          Authorization: `Bearer ${this.jwt}`,
+          "Content-Type": "application/json"
+        };
+      }
+      async request(method, path, body) {
+        const url = `${this.baseUrl}/api${path}`;
+        const resp = await fetch(url, {
+          method,
+          headers: this.headers(),
+          body: body ? JSON.stringify(body) : void 0
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          let msg;
+          try {
+            const json = JSON.parse(text);
+            msg = json.error || text;
+          } catch {
+            msg = text || `HTTP ${resp.status}`;
+          }
+          throw new Error(msg);
+        }
+        return resp.json();
+      }
+      // ==================== Auth ====================
+      /** Get X OAuth authorization URL (for CLI flow) */
+      async getAuthUrl(cliRedirect) {
+        const url = `${this.baseUrl}/api/auth/x?cli_redirect=${encodeURIComponent(cliRedirect)}`;
+        const resp = await fetch(url);
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`Failed to get auth URL: ${text}`);
+        }
+        return resp.json();
+      }
+      // ==================== User Info ====================
+      async getMe() {
+        return this.request("GET", "/me");
+      }
+      // ==================== Tenant ====================
+      async getTenantStatus() {
+        return this.request("GET", "/tenant/status");
+      }
+      async provision() {
+        return this.request("POST", "/provision", {});
+      }
+      async getDeploymentStatus() {
+        return this.request(
+          "GET",
+          "/tenant/deployment-status"
+        );
+      }
+      // ==================== Gateway Token ====================
+      async getGatewayToken() {
+        return this.request("GET", "/tenant/gateway-token");
+      }
+      // ==================== Subscription ====================
+      async activateSubscription(txHash) {
+        return this.request("POST", "/subscription/activate", { tx_hash: txHash });
+      }
+      // ==================== Instances (Multi-Tenant) ====================
+      async listInstances() {
+        return this.request("GET", "/instances");
+      }
+      async createInstance(displayName) {
+        return this.request("POST", "/instances", {
+          display_name: displayName ?? null
+        });
+      }
+      async switchInstance(tenantId) {
+        return this.request("POST", "/instances/switch", {
+          tenant_id: tenantId
+        });
+      }
+      async deleteInstance() {
+        return this.request("POST", "/tenant/delete");
+      }
+      // ==================== Vouchers ====================
+      async redeemVoucher(code) {
+        return this.request("POST", "/voucher/redeem", { code });
+      }
+      async claimTrial() {
+        return this.request("POST", "/voucher/claim-trial");
+      }
+    };
+  }
+});
+
+// src/lib/auth.ts
+import { createServer } from "http";
+import { createInterface } from "readline";
+import { randomBytes } from "crypto";
+import { URL } from "url";
+import open from "open";
+async function runOAuthFlow() {
+  return new Promise((resolve, reject) => {
+    let server;
+    let timeout;
+    const csrfNonce = randomBytes(16).toString("hex");
+    server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost`);
+      if (url.pathname === "/callback") {
+        const returnedNonce = url.searchParams.get("nonce");
+        if (returnedNonce !== csrfNonce) {
+          res.writeHead(403, { "Content-Type": "text/html" });
+          res.end("<h1>Forbidden</h1><p>Invalid CSRF nonce.</p>");
+          return;
+        }
+        const jwt = url.searchParams.get("jwt");
+        const username = url.searchParams.get("username");
+        const tenantId = url.searchParams.get("tenant_id");
+        if (jwt && username) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+            <head><title>Starkbot CLI</title></head>
+            <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0f0f0f; color: #e0e0e0;">
+              <div style="text-align: center;">
+                <h1 style="color: #7C3AED;">&#9889; Logged in!</h1>
+                <p>You can close this tab and return to the terminal.</p>
+              </div>
+            </body>
+            </html>
+          `);
+          clearTimeout(timeout);
+          server.close();
+          resolve({
+            jwt,
+            username,
+            tenant_id: tenantId ?? void 0
+          });
+        } else {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<h1>Login failed</h1><p>Missing JWT or username in callback.</p>");
+          clearTimeout(timeout);
+          server.close();
+          reject(new Error("OAuth callback missing jwt or username"));
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(0, "127.0.0.1", async () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+      const port = addr.port;
+      const callbackUrl = `http://localhost:${port}/callback?nonce=${csrfNonce}`;
+      try {
+        const spin = spinner("Preparing login...");
+        spin.start();
+        const client = new FlashClient("");
+        const { url } = await client.getAuthUrl(callbackUrl);
+        spin.stop();
+        console.log(dim("  Your browser will open for X authorization.\n"));
+        await new Promise((res) => {
+          const rl = createInterface({ input: process.stdin, output: process.stdout });
+          rl.question("  Press Enter when you're ready to log in to X...", () => {
+            rl.close();
+            res();
+          });
+        });
+        const loginSpin = spinner("Opening browser for X login...");
+        loginSpin.start();
+        await open(url);
+        loginSpin.text = "Waiting for login in browser...";
+        timeout = setTimeout(() => {
+          loginSpin.fail("Login timed out (5 minutes)");
+          server.close();
+          reject(new Error("Login timed out"));
+        }, 5 * 60 * 1e3);
+      } catch (err) {
+        printError("Failed to start login");
+        server.close();
+        reject(err);
+      }
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Local server error: ${err.message}`));
+    });
+  });
+}
+var init_auth = __esm({
+  "src/lib/auth.ts"() {
+    "use strict";
+    init_flash_client();
+    init_ui();
+  }
+});
+
+// src/lib/credentials.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function ensureDir() {
+  if (!existsSync2(CONFIG_DIR2)) {
+    mkdirSync2(CONFIG_DIR2, { recursive: true, mode: 448 });
+  }
+}
+function loadCredentials() {
+  try {
+    if (!existsSync2(CREDS_FILE)) return null;
+    const raw = readFileSync2(CREDS_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  ensureDir();
+  writeFileSync2(CREDS_FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+}
+function updateCredentials(partial) {
+  const existing = loadCredentials();
+  if (!existing) throw new Error("No credentials stored. Run `starkbot login` first.");
+  saveCredentials({ ...existing, ...partial });
+}
+function clearCredentials() {
+  try {
+    if (existsSync2(CREDS_FILE)) unlinkSync(CREDS_FILE);
+  } catch {
+  }
+}
+function isJwtExpired(creds) {
+  if (!creds.jwt) return true;
+  try {
+    const parts = creds.jwt.split(".");
+    if (parts.length !== 3) return true;
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    const exp = payload.exp;
+    if (!exp) return true;
+    return Date.now() / 1e3 > exp - 300;
+  } catch {
+    return true;
+  }
+}
+function requireCredentials() {
+  const creds = loadCredentials();
+  if (!creds) {
+    throw new Error("Not logged in. Run `starkbot login` first.");
+  }
+  if (isJwtExpired(creds)) {
+    throw new Error("Session expired. Run `starkbot login` to re-authenticate.");
+  }
+  return creds;
+}
+var CONFIG_DIR2, CREDS_FILE;
+var init_credentials = __esm({
+  "src/lib/credentials.ts"() {
+    "use strict";
+    CONFIG_DIR2 = join2(homedir2(), ".starkbot-cli");
+    CREDS_FILE = join2(CONFIG_DIR2, "credentials.json");
+  }
+});
+
+// src/commands/login.ts
+var login_exports = {};
+__export(login_exports, {
+  loginCommand: () => loginCommand
+});
+async function loginCommand() {
+  const existing = loadCredentials();
+  if (existing && !isJwtExpired(existing)) {
+    printWarning(`Already logged in as @${existing.username}. Use \`starkbot logout\` first to switch accounts.`);
+    return;
+  }
+  const result = await runOAuthFlow();
+  const spin = spinner("Fetching account info...");
+  spin.start();
+  try {
+    const client = new FlashClient(result.jwt);
+    const me = await client.getMe();
+    saveCredentials({
+      jwt: result.jwt,
+      username: me.user.username,
+      tenant_id: me.tenant.id,
+      instance_domain: me.tenant.domain ?? void 0,
+      jwt_expires_at: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString()
+    });
+    spin.stop();
+    printSuccess(`Logged in as @${me.user.username}`);
+    if (me.tenant.status === "pending") {
+      console.log("\n  Your bot is not yet provisioned. Run `starkbot subscribe` then `starkbot provision`.");
+    } else if (me.tenant.status === "active" && me.tenant.domain) {
+      console.log(`
+  Your bot is running at ${me.tenant.domain}`);
+    }
+  } catch {
+    spin.stop();
+    saveCredentials({
+      jwt: result.jwt,
+      username: result.username,
+      tenant_id: result.tenant_id ?? ""
+    });
+    printSuccess(`Logged in as @${result.username}`);
+  }
+}
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    init_auth();
+    init_credentials();
+    init_flash_client();
+    init_ui();
+  }
+});
+
+// src/commands/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  logoutCommand: () => logoutCommand
+});
+async function logoutCommand() {
+  const creds = loadCredentials();
+  clearCredentials();
+  if (creds) {
+    printSuccess(`Logged out from @${creds.username}`);
+  } else {
+    console.log(dim("No credentials stored."));
+  }
+}
+var init_logout = __esm({
+  "src/commands/logout.ts"() {
+    "use strict";
+    init_credentials();
+    init_ui();
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  statusCommand: () => statusCommand
+});
+async function statusCommand() {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  const spin = spinner("Fetching account status...");
+  spin.start();
+  const me = await client.getMe();
+  spin.stop();
+  console.log(bold("\n  Account"));
+  printKeyValue("Username", `@${me.user.username}`);
+  printKeyValue("Display name", me.user.display_name);
+  printKeyValue("Wallet", me.user.wallet_address);
+  console.log(bold("\n  Subscription"));
+  if (me.subscription) {
+    const statusColor2 = me.subscription.status === "active" ? success : warn;
+    printKeyValue("Status", statusColor2(me.subscription.status));
+    printKeyValue("Expires", me.subscription.expires_at);
+    printKeyValue("Days remaining", String(me.subscription.days_remaining));
+    if (me.subscription.is_expiring_soon) {
+      console.log(warn("    \u26A0 Subscription expiring soon!"));
+    }
+  } else {
+    printKeyValue("Status", dim("none"));
+    console.log(dim("    Run `starkbot subscribe` to get started."));
+  }
+  console.log(bold("\n  Active Instance"));
+  printKeyValue("ID", me.tenant.id);
+  const tenantStatus = me.tenant.status;
+  const statusColor = tenantStatus === "active" ? success : tenantStatus === "pending" ? dim : warn;
+  printKeyValue("Status", statusColor(tenantStatus));
+  printKeyValue("Domain", me.tenant.domain);
+  printKeyValue("Auto-update", me.tenant.auto_update_enabled ? "enabled" : "disabled");
+  if (me.tenant.updating) {
+    console.log(warn("    \u26A0 Instance is updating..."));
+  }
+  if (me.tenants && me.tenants.length > 1) {
+    console.log(bold(`
+  All Instances (${me.tenants.length})`));
+    for (const t of me.tenants) {
+      const active = t.id === me.tenant.id;
+      const tColor = t.status === "active" ? success : t.status === "pending" ? dim : warn;
+      const label = t.display_name ?? t.id;
+      console.log(`    ${active ? success("*") : " "} ${label} ${dim("\u2014")} ${tColor(t.status)}${t.domain ? dim(` (${t.domain})`) : ""}`);
+    }
+    console.log(dim("\n    Use `starkbot instances select` to change active instance."));
+  }
+  if (me.premium && me.premium.status !== "none") {
+    console.log(bold("\n  Premium"));
+    printKeyValue("Status", me.premium.status);
+    printKeyValue("Domain type", me.premium.domain_type);
+    if (me.premium.custom_subdomain) {
+      printKeyValue("Subdomain", me.premium.custom_subdomain);
+    }
+    if (me.premium.custom_domain) {
+      printKeyValue("Custom domain", me.premium.custom_domain);
+    }
+  }
+  console.log();
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_credentials();
+    init_flash_client();
+    init_ui();
+  }
+});
+
+// src/commands/subscribe.ts
+var subscribe_exports = {};
+__export(subscribe_exports, {
+  subscribeCommand: () => subscribeCommand
+});
+import inquirer from "inquirer";
+async function subscribeCommand() {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  const spin = spinner("Checking subscription...");
+  spin.start();
+  const me = await client.getMe();
+  spin.stop();
+  if (me.subscription && me.subscription.status === "active") {
+    printSuccess(`You already have an active subscription (${me.subscription.days_remaining} days remaining).`);
+    return;
+  }
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "How would you like to subscribe?",
+      choices: [
+        { name: "Claim free trial (7 days)", value: "trial" },
+        { name: "Redeem a voucher code", value: "voucher" },
+        { name: "Pay with crypto", value: "pay" }
+      ]
+    }
+  ]);
+  if (action === "trial") {
+    const spin2 = spinner("Claiming free trial...");
+    spin2.start();
+    try {
+      const result = await client.claimTrial();
+      spin2.stop();
+      if (result.success) {
+        printSuccess("Free trial activated! You can now run `starkbot provision`.");
+      } else {
+        printWarning(result.message ?? "Could not claim trial \u2014 you may have already used it.");
+      }
+    } catch (err) {
+      spin2.stop();
+      printError(err.message);
+    }
+  } else if (action === "voucher") {
+    const { code } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "code",
+        message: "Enter voucher code:",
+        validate: (v) => v.trim().length > 0 || "Code cannot be empty"
+      }
+    ]);
+    const spin2 = spinner("Redeeming voucher...");
+    spin2.start();
+    try {
+      const result = await client.redeemVoucher(code.trim());
+      spin2.stop();
+      if (result.success) {
+        printSuccess("Voucher redeemed! You can now run `starkbot provision`.");
+      } else {
+        printWarning(result.message ?? "Invalid or already redeemed voucher.");
+      }
+    } catch (err) {
+      spin2.stop();
+      printError(err.message);
+    }
+  } else {
+    console.log(`
+  Visit ${dim("https://starkbot.cloud")} to pay with crypto.`);
+    console.log(`  After payment, run ${dim("`starkbot status`")} to verify.
+`);
+  }
+}
+var init_subscribe = __esm({
+  "src/commands/subscribe.ts"() {
+    "use strict";
+    init_credentials();
+    init_flash_client();
+    init_ui();
+  }
+});
+
+// src/commands/provision.ts
+var provision_exports = {};
+__export(provision_exports, {
+  provisionCommand: () => provisionCommand
+});
+async function provisionCommand() {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  const spin = spinner("Checking instance status...");
+  spin.start();
+  try {
+    const me = await client.getMe();
+    if (me.tenant.status === "active" && me.tenant.domain) {
+      spin.stop();
+      printSuccess(`Instance already running at ${me.tenant.domain}`);
+      console.log(dim(`  Run \`starkbot connect\` to set up the gateway connection.`));
+      return;
+    }
+    if (!me.subscription || me.subscription.status !== "active") {
+      spin.stop();
+      printWarning("No active subscription. Run `starkbot subscribe` first.");
+      return;
+    }
+    spin.text = "Provisioning your Starkbot instance...";
+    const result = await client.provision();
+    if (result.success) {
+      spin.text = `Deployed to ${result.domain} \u2014 waiting for instance to start...`;
+      let attempts = 0;
+      const maxAttempts = 60;
+      while (attempts < maxAttempts) {
+        await new Promise((r) => setTimeout(r, 2e3));
+        attempts++;
+        try {
+          const status = await client.getDeploymentStatus();
+          if (status.ready) {
+            break;
+          }
+          if (status.needs_reprovision) {
+            spin.fail(`Deployment failed: ${status.status}`);
+            return;
+          }
+          const statusLower = status.status.toLowerCase();
+          if (statusLower === "failed" || statusLower === "crashed") {
+            spin.fail(`Deployment failed: ${status.status}`);
+            return;
+          }
+          spin.text = `Waiting for instance... (${status.status})`;
+        } catch {
+        }
+      }
+      spin.stop();
+      updateCredentials({ instance_domain: result.domain });
+      printSuccess(`Instance provisioned at ${result.domain}`);
+      console.log(dim(`  Run \`starkbot connect\` to set up the gateway connection.`));
+    } else {
+      spin.fail("Provisioning failed");
+    }
+  } catch (err) {
+    spin.fail("Provisioning failed");
+    printError(err.message);
+  }
+}
+var init_provision = __esm({
+  "src/commands/provision.ts"() {
+    "use strict";
+    init_credentials();
+    init_flash_client();
+    init_ui();
+  }
+});
+
+// src/lib/gateway-client.ts
+var GatewayClient;
+var init_gateway_client = __esm({
+  "src/lib/gateway-client.ts"() {
+    "use strict";
+    GatewayClient = class {
+      baseUrl;
+      token;
+      sessionId;
+      constructor(baseUrl, token, sessionId) {
+        this.baseUrl = baseUrl.replace(/\/+$/, "");
+        this.token = token;
+        this.sessionId = sessionId;
+      }
+      headers() {
+        return {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        };
+      }
+      chatBody(message) {
+        return {
+          message,
+          ...this.sessionId ? { session_id: this.sessionId } : {}
+        };
+      }
+      /** Send a message and get the full response */
+      async chat(message) {
+        const url = `${this.baseUrl}/api/gateway/chat`;
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify(this.chatBody(message))
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`HTTP ${resp.status}: ${text}`);
+        }
+        return resp.json();
+      }
+      /** Send a message and stream SSE events */
+      async chatStream(message, onEvent) {
+        const url = `${this.baseUrl}/api/gateway/chat/stream`;
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify(this.chatBody(message))
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`HTTP ${resp.status}: ${text}`);
+        }
+        if (!resp.body) throw new Error("No response body");
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let pos;
+          while ((pos = buffer.indexOf("\n\n")) !== -1) {
+            const frame = buffer.slice(0, pos);
+            buffer = buffer.slice(pos + 2);
+            for (const line of frame.split("\n")) {
+              if (line.startsWith("data: ")) {
+                try {
+                  const event = JSON.parse(line.slice(6));
+                  const isDone = event.type === "done";
+                  onEvent(event);
+                  if (isDone) return;
+                } catch {
+                }
+              }
+            }
+          }
+        }
+      }
+      /** Create a new session */
+      async newSession() {
+        const url = `${this.baseUrl}/api/gateway/sessions/new`;
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: this.headers()
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`HTTP ${resp.status}: ${text}`);
+        }
+        return resp.json();
+      }
+      /** List sessions */
+      async listSessions() {
+        const url = `${this.baseUrl}/api/gateway/sessions`;
+        const resp = await fetch(url, {
+          method: "GET",
+          headers: this.headers()
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`HTTP ${resp.status}: ${text}`);
+        }
+        return resp.json();
+      }
+      /** Get message history for a session */
+      async getHistory(sessionId) {
+        const url = `${this.baseUrl}/api/gateway/sessions/${sessionId}/messages`;
+        const resp = await fetch(url, {
+          method: "GET",
+          headers: this.headers()
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`HTTP ${resp.status}: ${text}`);
+        }
+        return resp.json();
+      }
+      /** Simple health check */
+      async ping() {
+        try {
+          const resp = await fetch(`${this.baseUrl}/api/health`, {
+            headers: this.headers()
+          });
+          return resp.ok;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/commands/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  connectCommand: () => connectCommand
+});
+import inquirer2 from "inquirer";
+async function connectCommand(opts = {}) {
+  const creds = requireCredentials();
+  if (opts.token) {
+    const domain = opts.domain ?? creds.instance_domain;
+    if (!domain) {
+      printError("Instance domain required. Use --domain <your-instance.starkbot.cloud> or run `starkbot status` first.");
+      return;
+    }
+    updateCredentials({
+      gateway_token: opts.token,
+      instance_domain: domain
+    });
+    const spin2 = spinner("Testing connection...");
+    spin2.start();
+    try {
+      const gw = new GatewayClient(`https://${domain}`, opts.token);
+      const ok = await gw.ping();
+      spin2.stop();
+      if (ok) {
+        printSuccess(`Connected to ${domain}`);
+        console.log(dim(`  Run \`starkbot chat\` to start chatting.`));
+      } else {
+        printWarning(`Gateway token saved for ${domain}, but instance is not responding yet.`);
+        console.log(dim("  The instance may still be starting. Try again in a moment."));
+      }
+    } catch (err) {
+      spin2.fail("Connection failed");
+      printError(err.message);
+    }
+    return;
+  }
+  const client = new FlashClient(creds.jwt);
+  const spin = spinner("Fetching gateway credentials...");
+  spin.start();
+  try {
+    const { token, domain } = await client.getGatewayToken();
+    updateCredentials({
+      gateway_token: token,
+      instance_domain: domain
+    });
+    spin.text = "Testing connection...";
+    const gw = new GatewayClient(`https://${domain}`, token);
+    const ok = await gw.ping();
+    spin.stop();
+    if (ok) {
+      printSuccess(`Connected to ${domain}`);
+      console.log(dim(`  Run \`starkbot chat\` to start chatting.`));
+    } else {
+      printWarning(`Gateway token saved for ${domain}, but instance is not responding yet.`);
+      console.log(dim("  The instance may still be starting. Try again in a moment."));
+    }
+  } catch (err) {
+    spin.fail("Connection failed");
+    if (err.message?.includes("No CLI gateway token found")) {
+      printWarning("This instance was provisioned before CLI support \u2014 no gateway token on file.");
+      console.log(dim("  You can grab your token and domain from the instance dashboard.\n"));
+      const answers = await inquirer2.prompt([
+        {
+          type: "input",
+          name: "token",
+          message: "Gateway token:",
+          validate: (v) => v.trim().length > 0 || "Token is required"
+        },
+        {
+          type: "input",
+          name: "domain",
+          message: "Instance domain (e.g. my-bot.starkbot.cloud):",
+          default: creds.instance_domain || void 0,
+          validate: (v) => v.trim().length > 0 || "Domain is required"
+        }
+      ]);
+      return connectCommand({ token: answers.token.trim(), domain: answers.domain.trim() });
+    } else {
+      printError(err.message);
+    }
+  }
+}
+var init_connect = __esm({
+  "src/commands/connect.ts"() {
+    "use strict";
+    init_credentials();
+    init_flash_client();
+    init_gateway_client();
+    init_ui();
+  }
+});
+
+// src/commands/chat.ts
+var chat_exports = {};
+__export(chat_exports, {
+  chatOneShotCommand: () => chatOneShotCommand,
+  chatReplCommand: () => chatReplCommand
+});
+import { createInterface as createInterface2 } from "readline";
+function requireGateway() {
+  const creds = requireCredentials();
+  if (!creds.gateway_token || !creds.instance_domain) {
+    throw new Error(
+      "Gateway not configured. Run `starkbot connect` first."
+    );
+  }
+  return new GatewayClient(
+    `https://${creds.instance_domain}`,
+    creds.gateway_token
+  );
+}
+function printSseEvent(event) {
+  switch (event.type) {
+    case "tool_call": {
+      const name = event.tool_name ?? "unknown";
+      process.stdout.write(dim(`[${name}...] `));
+      break;
+    }
+    case "tool_result":
+      break;
+    case "text":
+      if (event.content) {
+        process.stdout.write(event.content);
+      }
+      break;
+    case "done":
+      break;
+  }
+}
+async function chatOneShotCommand(message) {
+  const gw = requireGateway();
+  process.stdout.write(`${prefix.agent} `);
+  try {
+    await gw.chatStream(message, printSseEvent);
+    console.log();
+  } catch (err) {
+    console.log();
+    printError(err.message);
+    process.exit(1);
+  }
+}
+async function chatReplCommand() {
+  const gw = requireGateway();
+  console.log(
+    dim(
+      "Starkbot CLI \u2014 type a message, /new to reset, /sessions to list, /quit to exit"
+    )
+  );
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  const prompt = () => {
+    rl.question(`${prefix.you} `, async (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        prompt();
+        return;
+      }
+      switch (trimmed) {
+        case "/quit":
+        case "/exit":
+        case "/q":
+          rl.close();
+          console.log(dim("Goodbye!"));
+          return;
+        case "/new": {
+          try {
+            const resp = await gw.newSession();
+            console.log(
+              `${prefix.system} New session created (id: ${resp.session_id})`
+            );
+          } catch (err) {
+            console.log(`${prefix.error} ${err.message}`);
+          }
+          prompt();
+          return;
+        }
+        case "/sessions": {
+          try {
+            const resp = await gw.listSessions();
+            if (resp.sessions.length === 0) {
+              console.log(`${prefix.system} No sessions found`);
+            } else {
+              console.log(`${prefix.system} Sessions:`);
+              for (const s of resp.sessions) {
+                console.log(
+                  `  ${info(s.session_key)} | ${s.message_count} msgs | last active: ${dim(s.last_activity_at)}`
+                );
+              }
+            }
+          } catch (err) {
+            console.log(`${prefix.error} ${err.message}`);
+          }
+          prompt();
+          return;
+        }
+        case "/help":
+          console.log(`${prefix.system} Commands:`);
+          console.log(`  ${info("/new")}      \u2014 Start a new session`);
+          console.log(`  ${info("/sessions")} \u2014 List sessions`);
+          console.log(
+            `  ${info("/history <id>")} \u2014 Show message history`
+          );
+          console.log(`  ${info("/quit")}     \u2014 Exit`);
+          prompt();
+          return;
+        default:
+          if (trimmed.startsWith("/history")) {
+            const parts = trimmed.split(/\s+/);
+            if (parts.length < 2) {
+              console.log(
+                `${prefix.system} Usage: /history <session_id>`
+              );
+            } else {
+              const sid = parseInt(parts[1], 10);
+              if (isNaN(sid)) {
+                console.log(`${prefix.error} Invalid session ID: ${parts[1]}`);
+              } else {
+                try {
+                  const resp = await gw.getHistory(sid);
+                  for (const m of resp.messages) {
+                    const p = m.role === "user" ? prefix.you : m.role === "assistant" ? prefix.agent : dim(`${m.role}>`);
+                    console.log(`${p} ${m.content}`);
+                  }
+                } catch (err) {
+                  console.log(`${prefix.error} ${err.message}`);
+                }
+              }
+            }
+            prompt();
+            return;
+          }
+          process.stdout.write(`${prefix.agent} `);
+          try {
+            await gw.chatStream(trimmed, printSseEvent);
+            console.log();
+          } catch (err) {
+            console.log();
+            console.log(`${prefix.error} ${err.message}`);
+          }
+          prompt();
+      }
+    });
+  };
+  prompt();
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+var init_chat = __esm({
+  "src/commands/chat.ts"() {
+    "use strict";
+    init_credentials();
+    init_gateway_client();
+    init_ui();
+  }
+});
+
+// src/commands/instances.ts
+var instances_exports = {};
+__export(instances_exports, {
+  instancesDeleteCommand: () => instancesDeleteCommand,
+  instancesListCommand: () => instancesListCommand,
+  instancesNewCommand: () => instancesNewCommand,
+  instancesSelectCommand: () => instancesSelectCommand
+});
+import inquirer3 from "inquirer";
+async function instancesListCommand() {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  const spin = spinner("Fetching instances...");
+  spin.start();
+  try {
+    const instances2 = await client.listInstances();
+    spin.stop();
+    if (instances2.length === 0) {
+      printWarning("No instances found. Run `starkbot instances new` to create one.");
+      return;
+    }
+    console.log(bold(`
+  Your Instances (${instances2.length})
+`));
+    for (const inst of instances2) {
+      const active = inst.id === creds.tenant_id;
+      const marker = active ? success(" * ") : "   ";
+      const statusColor = inst.status === "active" ? success : inst.status === "pending" ? dim : warn;
+      const name = inst.display_name ?? inst.id;
+      console.log(`${marker}${bold(name)}${active ? dim(" (active)") : ""}`);
+      printKeyValue("    ID", inst.id);
+      printKeyValue("    Status", statusColor(inst.status));
+      printKeyValue("    Domain", inst.domain);
+      printKeyValue("    Wallet", inst.wallet_address);
+      if (inst.subscription) {
+        printKeyValue("    Subscription", inst.subscription.status);
+      }
+      console.log();
+    }
+  } catch (err) {
+    spin.fail("Failed to fetch instances");
+    printError(err.message);
+  }
+}
+async function instancesNewCommand(opts) {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  const spin = spinner("Creating new instance...");
+  spin.start();
+  try {
+    const result = await client.createInstance(opts.name);
+    spin.stop();
+    printSuccess(`Created instance ${bold(result.tenant.id)}`);
+    if (result.tenant.domain) {
+      printKeyValue("Domain", result.tenant.domain);
+    }
+    printKeyValue("Status", result.tenant.status);
+    if (result.jwt) {
+      saveCredentials({
+        ...creds,
+        jwt: result.jwt,
+        tenant_id: result.tenant.id,
+        // Clear gateway credentials since this is a new instance
+        gateway_token: void 0,
+        instance_domain: void 0
+      });
+      console.log(dim("\n  Switched to new instance. Run `starkbot provision` to deploy it."));
+    }
+  } catch (err) {
+    spin.fail("Failed to create instance");
+    printError(err.message);
+  }
+}
+async function instancesSelectCommand(tenantId) {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  if (!tenantId) {
+    const spin2 = spinner("Fetching instances...");
+    spin2.start();
+    try {
+      const instances2 = await client.listInstances();
+      spin2.stop();
+      if (instances2.length <= 1) {
+        printWarning("You only have one instance. Nothing to switch to.");
+        return;
+      }
+      const choices = instances2.map((inst) => ({
+        name: `${inst.display_name ?? inst.id} ${dim(`(${inst.status}${inst.domain ? ` - ${inst.domain}` : ""})`)}${inst.id === creds.tenant_id ? success(" *active*") : ""}`,
+        value: inst.id
+      }));
+      const answer = await inquirer3.prompt([
+        {
+          type: "list",
+          name: "tenantId",
+          message: "Select instance:",
+          choices
+        }
+      ]);
+      tenantId = answer.tenantId;
+    } catch (err) {
+      spin2.fail("Failed to fetch instances");
+      printError(err.message);
+      return;
+    }
+  }
+  if (tenantId === creds.tenant_id) {
+    printWarning("Already on that instance.");
+    return;
+  }
+  const spin = spinner("Switching instance...");
+  spin.start();
+  try {
+    const result = await client.switchInstance(tenantId);
+    spin.stop();
+    saveCredentials({
+      ...creds,
+      jwt: result.jwt,
+      tenant_id: result.tenant.id,
+      // Clear gateway credentials for the new active instance
+      gateway_token: void 0,
+      instance_domain: result.tenant.domain ?? void 0
+    });
+    const name = result.tenant.id;
+    printSuccess(`Switched to ${bold(name)}`);
+    printKeyValue("Status", result.tenant.status);
+    printKeyValue("Domain", result.tenant.domain);
+    if (result.tenant.status === "active" && result.tenant.domain) {
+      console.log(dim("\n  Run `starkbot connect` to set up the gateway connection."));
+    } else if (result.tenant.status === "pending") {
+      console.log(dim("\n  Run `starkbot provision` to deploy this instance."));
+    }
+  } catch (err) {
+    spin.fail("Failed to switch instance");
+    printError(err.message);
+  }
+}
+async function instancesDeleteCommand(tenantId) {
+  const creds = requireCredentials();
+  const client = new FlashClient(creds.jwt);
+  if (tenantId && tenantId !== creds.tenant_id) {
+    const spin = spinner("Switching to target instance...");
+    spin.start();
+    try {
+      const result = await client.switchInstance(tenantId);
+      spin.stop();
+      saveCredentials({
+        ...creds,
+        jwt: result.jwt,
+        tenant_id: result.tenant.id,
+        gateway_token: void 0,
+        instance_domain: void 0
+      });
+      const newCreds = requireCredentials();
+      const newClient = new FlashClient(newCreds.jwt);
+      await doDelete(newClient, tenantId, newCreds);
+    } catch (err) {
+      spin.fail("Failed to switch to target instance");
+      printError(err.message);
+    }
+    return;
+  }
+  await doDelete(client, creds.tenant_id, creds);
+}
+async function doDelete(client, tenantId, creds) {
+  const answer = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Delete instance ${bold(tenantId)}? This cannot be undone.`,
+      default: false
+    }
+  ]);
+  if (!answer.confirm) {
+    console.log(dim("Cancelled."));
+    return;
+  }
+  const spin = spinner("Deleting instance...");
+  spin.start();
+  try {
+    await client.deleteInstance();
+    spin.stop();
+    printSuccess(`Deleted instance ${tenantId}`);
+    const me = await new FlashClient(creds.jwt).getMe();
+    if (me.tenants && me.tenants.length > 0) {
+      const first = me.tenants[0];
+      const switchResult = await new FlashClient(creds.jwt).switchInstance(first.id);
+      saveCredentials({
+        ...creds,
+        jwt: switchResult.jwt,
+        tenant_id: switchResult.tenant.id,
+        gateway_token: void 0,
+        instance_domain: switchResult.tenant.domain ?? void 0
+      });
+      console.log(dim(`  Switched to instance ${first.id}`));
+    }
+  } catch (err) {
+    spin.fail("Failed to delete instance");
+    printError(err.message);
+  }
+}
+var init_instances = __esm({
+  "src/commands/instances.ts"() {
+    "use strict";
+    init_credentials();
+    init_flash_client();
+    init_ui();
+  }
+});
+
+// src/commands/sessions.ts
+var sessions_exports = {};
+__export(sessions_exports, {
+  sessionsCommand: () => sessionsCommand
+});
+async function sessionsCommand() {
+  const creds = requireCredentials();
+  if (!creds.gateway_token || !creds.instance_domain) {
+    throw new Error("Gateway not configured. Run `starkbot connect` first.");
+  }
+  const gw = new GatewayClient(
+    `https://${creds.instance_domain}`,
+    creds.gateway_token
+  );
+  const spin = spinner("Fetching sessions...");
+  spin.start();
+  try {
+    const resp = await gw.listSessions();
+    spin.stop();
+    if (resp.sessions.length === 0) {
+      console.log(dim("  No sessions found."));
+      return;
+    }
+    console.log(bold(`
+  Sessions (${resp.sessions.length}):
+`));
+    for (const s of resp.sessions) {
+      console.log(
+        `  ${info(String(s.id).padStart(4))}  ${s.session_key}  ${dim(`${s.message_count} msgs`)}  ${dim(s.last_activity_at)}`
+      );
+    }
+    console.log();
+  } catch (err) {
+    spin.fail("Failed to fetch sessions");
+    printError(err.message);
+  }
+}
+var init_sessions = __esm({
+  "src/commands/sessions.ts"() {
+    "use strict";
+    init_credentials();
+    init_gateway_client();
+    init_ui();
+  }
+});
+
+// src/commands/history.ts
+var history_exports = {};
+__export(history_exports, {
+  historyCommand: () => historyCommand
+});
+async function historyCommand(sessionId) {
+  const creds = requireCredentials();
+  if (!creds.gateway_token || !creds.instance_domain) {
+    throw new Error("Gateway not configured. Run `starkbot connect` first.");
+  }
+  const sid = parseInt(sessionId, 10);
+  if (isNaN(sid)) {
+    printError(`Invalid session ID: ${sessionId}`);
+    process.exit(1);
+  }
+  const gw = new GatewayClient(
+    `https://${creds.instance_domain}`,
+    creds.gateway_token
+  );
+  const spin = spinner("Fetching message history...");
+  spin.start();
+  try {
+    const resp = await gw.getHistory(sid);
+    spin.stop();
+    if (resp.messages.length === 0) {
+      console.log(dim("  No messages in this session."));
+      return;
+    }
+    console.log();
+    for (const m of resp.messages) {
+      const p = m.role === "user" ? prefix.you : m.role === "assistant" ? prefix.agent : dim(`${m.role}>`);
+      console.log(`${p} ${m.content}`);
+    }
+    console.log();
+  } catch (err) {
+    spin.fail("Failed to fetch history");
+    printError(err.message);
+  }
+}
+var init_history = __esm({
+  "src/commands/history.ts"() {
+    "use strict";
+    init_credentials();
+    init_gateway_client();
+    init_ui();
+  }
+});
+
+// src/commands/wizard.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  wizardCommand: () => wizardCommand
+});
+import inquirer4 from "inquirer";
+async function wizardCommand() {
+  banner();
+  const creds = loadCredentials();
+  if (!creds || isJwtExpired(creds)) {
+    console.log(bold("  Step 1: Login with X\n"));
+    await loginCommand();
+    console.log();
+  } else {
+    printSuccess(`Logged in as @${creds.username}`);
+  }
+  const currentCreds = requireCredentials();
+  const client = new FlashClient(currentCreds.jwt);
+  const spin = spinner("Checking account...");
+  spin.start();
+  let me;
+  try {
+    me = await client.getMe();
+    spin.stop();
+  } catch (err) {
+    spin.fail("Failed to check account status");
+    console.log(dim(`  Error: ${err.message}`));
+    return;
+  }
+  const hasInstances = me.tenants && me.tenants.length > 0;
+  if (!me.is_new_user && hasInstances) {
+    const instances2 = me.tenants;
+    const choices = instances2.map((inst) => {
+      const statusTag = inst.status === "active" ? "active" : inst.status;
+      const domain = inst.domain ? ` \u2014 ${inst.domain}` : "";
+      const name = inst.display_name || inst.id.slice(0, 8);
+      const isCurrent = inst.id === me.tenant.id;
+      const label = `${name}${domain} (${statusTag})${isCurrent ? " \u2190 current" : ""}`;
+      return { name: label, value: inst.id };
+    });
+    choices.push({ name: "Create new instance", value: "__new__" });
+    console.log(bold("\n  Select an instance\n"));
+    const { instanceChoice } = await inquirer4.prompt([
+      {
+        type: "list",
+        name: "instanceChoice",
+        message: "Which instance do you want to work with?",
+        choices,
+        default: me.tenant.id
+      }
+    ]);
+    if (instanceChoice === "__new__") {
+      const { displayName } = await inquirer4.prompt([
+        {
+          type: "input",
+          name: "displayName",
+          message: "Display name for the new instance (optional):"
+        }
+      ]);
+      const createSpin = spinner("Creating instance...");
+      createSpin.start();
+      try {
+        me = await client.createInstance(displayName || void 0);
+        updateCredentials({ tenant_id: me.tenant.id, gateway_token: void 0, instance_domain: void 0 });
+        createSpin.succeed("Instance created");
+      } catch (err) {
+        createSpin.fail("Failed to create instance");
+        console.log(dim(`  Error: ${err.message}`));
+        return;
+      }
+    } else if (instanceChoice !== me.tenant.id) {
+      const switchSpin = spinner("Switching instance...");
+      switchSpin.start();
+      try {
+        me = await client.switchInstance(instanceChoice);
+        updateCredentials({ tenant_id: me.tenant.id, gateway_token: void 0, instance_domain: void 0 });
+        switchSpin.succeed(`Switched to instance ${me.tenant.domain || instanceChoice}`);
+      } catch (err) {
+        switchSpin.fail("Failed to switch instance");
+        console.log(dim(`  Error: ${err.message}`));
+        return;
+      }
+    } else {
+      printSuccess(`Using current instance${me.tenant.domain ? ` (${me.tenant.domain})` : ""}`);
+    }
+    console.log();
+  }
+  if (!me.subscription || me.subscription.status !== "active") {
+    console.log(bold("\n  Subscribe\n"));
+    await subscribeCommand();
+    try {
+      me = await client.getMe();
+    } catch {
+      return;
+    }
+    if (!me.subscription || me.subscription.status !== "active") {
+      printWarning("Subscription required to continue. Run `starkbot subscribe` when ready.");
+      return;
+    }
+    console.log();
+  } else {
+    printSuccess(`Subscription active (${me.subscription.days_remaining} days remaining)`);
+  }
+  if (me.tenant.status !== "active" || !me.tenant.domain) {
+    console.log(bold("\n  Provision your bot\n"));
+    await provisionCommand();
+    console.log();
+  } else {
+    printSuccess(`Instance running at ${me.tenant.domain}`);
+  }
+  const updatedCreds = loadCredentials();
+  if (!updatedCreds?.gateway_token || !updatedCreds?.instance_domain) {
+    console.log(bold("\n  Connect to gateway\n"));
+    await connectCommand();
+    console.log();
+  } else {
+    printSuccess("Gateway connected");
+  }
+  const finalCreds = loadCredentials();
+  if (finalCreds?.gateway_token && finalCreds?.instance_domain) {
+    const { startChat } = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "startChat",
+        message: "Start chatting with your bot?",
+        default: true
+      }
+    ]);
+    if (startChat) {
+      console.log();
+      await chatReplCommand();
+    }
+  }
+}
+var init_wizard = __esm({
+  "src/commands/wizard.ts"() {
+    "use strict";
+    init_credentials();
+    init_flash_client();
+    init_ui();
+    init_login();
+    init_subscribe();
+    init_provision();
+    init_connect();
+    init_chat();
+  }
+});
+
+// src/index.ts
+init_ui();
+import { Command } from "commander";
+var program = new Command();
+program.name("starkbot").description("CLI for Starkbot \u2014 login, provision, and chat with your bot").version("0.1.0").addHelpCommand("help", "Show help for a command");
+program.command("login").description("Login with your X (Twitter) account").action(async () => {
+  const { loginCommand: loginCommand2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+  await loginCommand2();
+});
+program.command("logout").description("Clear stored credentials").action(async () => {
+  const { logoutCommand: logoutCommand2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
+  await logoutCommand2();
+});
+program.command("status").description("Show account, subscription, and instance status").action(async () => {
+  const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  await statusCommand2();
+});
+program.command("subscribe").description("Claim trial, redeem voucher, or subscribe").action(async () => {
+  const { subscribeCommand: subscribeCommand2 } = await Promise.resolve().then(() => (init_subscribe(), subscribe_exports));
+  await subscribeCommand2();
+});
+program.command("provision").description("Provision your Starkbot instance").action(async () => {
+  const { provisionCommand: provisionCommand2 } = await Promise.resolve().then(() => (init_provision(), provision_exports));
+  await provisionCommand2();
+});
+program.command("connect").description("Fetch gateway token and test connection").option("-t, --token <token>", "Manually provide a gateway token (for existing instances)").option("-d, --domain <domain>", "Instance domain (e.g. mybot-abc123.starkbot.cloud)").action(async (opts) => {
+  const { connectCommand: connectCommand2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
+  await connectCommand2(opts);
+});
+program.command("chat [message]").description("Chat with your bot (REPL or one-shot)").action(async (message) => {
+  const { chatOneShotCommand: chatOneShotCommand2, chatReplCommand: chatReplCommand2 } = await Promise.resolve().then(() => (init_chat(), chat_exports));
+  if (message) {
+    await chatOneShotCommand2(message);
+  } else {
+    await chatReplCommand2();
+  }
+});
+var instances = program.command("instances").description("Manage your Starkbot instances").addHelpCommand("help", "Show help for instance commands");
+instances.command("list").description("List all your instances").action(async () => {
+  const { instancesListCommand: instancesListCommand2 } = await Promise.resolve().then(() => (init_instances(), instances_exports));
+  await instancesListCommand2();
+});
+instances.command("new").description("Create a new instance").option("-n, --name <name>", "Display name for the instance").action(async (opts) => {
+  const { instancesNewCommand: instancesNewCommand2 } = await Promise.resolve().then(() => (init_instances(), instances_exports));
+  await instancesNewCommand2(opts);
+});
+instances.command("select [tenant-id]").description("Select the active instance").action(async (tenantId) => {
+  const { instancesSelectCommand: instancesSelectCommand2 } = await Promise.resolve().then(() => (init_instances(), instances_exports));
+  await instancesSelectCommand2(tenantId);
+});
+instances.command("delete [tenant-id]").description("Delete a deprovisioned instance").action(async (tenantId) => {
+  const { instancesDeleteCommand: instancesDeleteCommand2 } = await Promise.resolve().then(() => (init_instances(), instances_exports));
+  await instancesDeleteCommand2(tenantId);
+});
+instances.action(async () => {
+  const { instancesListCommand: instancesListCommand2 } = await Promise.resolve().then(() => (init_instances(), instances_exports));
+  await instancesListCommand2();
+});
+program.command("sessions").description("List chat sessions").action(async () => {
+  const { sessionsCommand: sessionsCommand2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+  await sessionsCommand2();
+});
+program.command("history <session-id>").description("Show message history for a session").action(async (sessionId) => {
+  const { historyCommand: historyCommand2 } = await Promise.resolve().then(() => (init_history(), history_exports));
+  await historyCommand2(sessionId);
+});
+program.action(async () => {
+  const { wizardCommand: wizardCommand2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
+  await wizardCommand2();
+});
+program.parseAsync(process.argv).catch((err) => {
+  printError(err.message);
+  process.exit(1);
+});