fastclaw-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1413 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/config-cmd.ts
+import chalk3 from "chalk";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/constants.ts
+var DEFAULT_URL = "https://claw.yesy.dev";
+var API_BASE = "/bot/api/v1";
+var MODEL_PRESETS = {
+  google: {
+    name: "google",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    models: [
+      {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        reasoning: true,
+        input: ["text", "image"],
+        context_window: 1048576,
+        max_tokens: 65536
+      },
+      {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        reasoning: true,
+        input: ["text", "image"],
+        context_window: 1048576,
+        max_tokens: 65536
+      }
+    ]
+  },
+  anthropic: {
+    name: "anthropic",
+    baseUrl: "https://api.anthropic.com",
+    auth: "api-key",
+    api: "anthropic-messages",
+    models: [
+      {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4",
+        reasoning: false,
+        input: ["text", "image"],
+        context_window: 2e5,
+        max_tokens: 8192
+      }
+    ]
+  },
+  openai: {
+    name: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    auth: "api-key",
+    api: "openai-completions",
+    models: [
+      {
+        id: "gpt-5.1",
+        name: "GPT-5.1",
+        reasoning: false,
+        input: ["text", "image"],
+        context_window: 1048576,
+        max_tokens: 32768
+      }
+    ]
+  },
+  minimax: {
+    name: "minimax",
+    baseUrl: "https://api.minimax.chat/v1",
+    auth: "api-key",
+    api: "openai-completions",
+    models: [
+      {
+        id: "MiniMax-Text-01",
+        name: "MiniMax Text 01",
+        reasoning: false,
+        input: ["text"],
+        context_window: 1e6,
+        max_tokens: 65536
+      }
+    ]
+  }
+};
+var PROVIDER_DEFAULTS = {
+  google: "google/gemini-2.5-flash",
+  anthropic: "anthropic/claude-sonnet-4-20250514",
+  openai: "openai/gpt-5.1",
+  minimax: "minimax/MiniMax-Text-01"
+};
+var CHANNEL_FIELDS = {
+  feishu: {
+    required: ["appId", "appSecret"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  },
+  telegram: {
+    required: ["botToken"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  },
+  slack: {
+    required: ["botToken", "appToken"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  },
+  discord: {
+    required: ["botToken"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  },
+  whatsapp: {
+    required: ["botToken"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  },
+  line: {
+    required: ["botToken", "channelSecret"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  },
+  teams: {
+    required: ["appId", "appPassword"],
+    optional: ["account", "dmPolicy", "groupPolicy"]
+  }
+};
+
+// src/config.ts
+var CONFIG_DIR = join(homedir(), ".fastclaw");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return {};
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function updateConfig(updates) {
+  const config = loadConfig();
+  Object.assign(config, updates);
+  saveConfig(config);
+  return config;
+}
+function resolveConfig(opts) {
+  const file = loadConfig();
+  return {
+    url: opts.url || process.env.FASTCLAW_URL || file.url || DEFAULT_URL,
+    adminToken: opts.adminToken || process.env.FASTCLAW_ADMIN_TOKEN || file.admin_token,
+    appToken: opts.appToken || process.env.FASTCLAW_APP_TOKEN || file.app_token,
+    userId: opts.userId || process.env.FASTCLAW_USER_ID || file.default_user_id || "default",
+    botId: opts.botId || process.env.FASTCLAW_BOT_ID || file.default_bot_id,
+    json: opts.json ?? false
+  };
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/utils/error.ts
+import chalk from "chalk";
+var ApiError = class extends Error {
+  constructor(statusCode, apiCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.apiCode = apiCode;
+    this.name = "ApiError";
+  }
+};
+function withErrorHandler(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      if (err instanceof ApiError) {
+        console.error(chalk.red(`Error [${err.statusCode}]: ${err.message}`));
+      } else if (err instanceof Error) {
+        if (err.name === "ExitPromptError") {
+          process.exit(0);
+        }
+        console.error(chalk.red(`Error: ${err.message}`));
+      } else {
+        console.error(chalk.red("Unknown error occurred"));
+      }
+      process.exit(1);
+    }
+  };
+}
+function requireOption(value, name) {
+  if (!value) {
+    console.error(chalk.red(`Missing required option: ${name}`));
+    console.error(chalk.dim(`Set via --${name}, env FASTCLAW_${name.toUpperCase().replace(/-/g, "_")}, or 'fastclaw config set ${name} <value>'`));
+    process.exit(1);
+  }
+  return value;
+}
+
+// src/output.ts
+import chalk2 from "chalk";
+import Table from "cli-table3";
+import ora from "ora";
+import boxen from "boxen";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(headers, rows) {
+  const table = new Table({
+    head: headers.map((h) => chalk2.cyan(h)),
+    style: { head: [], border: [] }
+  });
+  rows.forEach((r) => table.push(r));
+  console.log(table.toString());
+}
+function printKeyValue(pairs) {
+  const maxLen = Math.max(...Object.keys(pairs).map((k) => k.length));
+  for (const [key, value] of Object.entries(pairs)) {
+    if (value !== void 0) {
+      console.log(`  ${chalk2.dim(key.padEnd(maxLen))}  ${value}`);
+    }
+  }
+}
+function printSuccess(msg) {
+  console.log(chalk2.green("\u2713") + " " + msg);
+}
+function printBox(lines, title) {
+  const content = lines.join("\n");
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: { top: 1, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      title,
+      titleAlignment: "left"
+    })
+  );
+}
+function startSpinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+
+// src/commands/config-cmd.ts
+function registerConfigCommand(program2) {
+  const cmd = program2.command("config").description("Manage local configuration");
+  cmd.command("show").description("Show current configuration").action(
+    withErrorHandler(async () => {
+      const config = loadConfig();
+      const parent = program2.opts();
+      if (parent.json) {
+        printJson(config);
+      } else {
+        console.log(chalk3.dim(`Config file: ${getConfigPath()}
+`));
+        if (Object.keys(config).length === 0) {
+          console.log(chalk3.dim("  (empty \u2014 run 'fastclaw setup' to configure)"));
+        } else {
+          const display = {};
+          for (const [k, v] of Object.entries(config)) {
+            display[k] = k.includes("token") && v ? maskToken(v) : v;
+          }
+          printKeyValue(display);
+        }
+      }
+    })
+  );
+  cmd.command("get <key>").description("Get a config value").action(
+    withErrorHandler(async (key) => {
+      const config = loadConfig();
+      const value = config[key];
+      if (value === void 0) {
+        console.log(chalk3.dim("(not set)"));
+      } else {
+        console.log(String(value));
+      }
+    })
+  );
+  cmd.command("set <key> <value>").description("Set a config value").action(
+    withErrorHandler(async (key, value) => {
+      const config = loadConfig();
+      config[key] = value;
+      saveConfig(config);
+      console.log(chalk3.green("\u2713") + ` ${key} = ${key.includes("token") ? maskToken(value) : value}`);
+    })
+  );
+}
+function maskToken(token) {
+  if (token.length <= 8) return "\u2022\u2022\u2022\u2022";
+  return token.slice(0, 4) + "\u2022\u2022\u2022\u2022" + token.slice(-4);
+}
+
+// src/commands/admin/apps.ts
+import chalk4 from "chalk";
+
+// src/client.ts
+var FastClawClient = class {
+  baseUrl;
+  adminToken;
+  appToken;
+  constructor(opts) {
+    this.baseUrl = opts.url.replace(/\/+$/, "") + API_BASE;
+    this.adminToken = opts.adminToken;
+    this.appToken = opts.appToken;
+  }
+  // ── Helpers ──
+  async request(method, path, opts) {
+    const authType = opts?.auth ?? "app";
+    const token = authType === "admin" ? this.adminToken : this.appToken;
+    if (!token) {
+      throw new Error(`No ${authType} token configured. Set via --${authType}-token, env, or 'fastclaw config set'.`);
+    }
+    let url = this.baseUrl + path;
+    if (opts?.query) {
+      const params = new URLSearchParams();
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== void 0 && v !== "") params.set(k, v);
+      }
+      const qs = params.toString();
+      if (qs) url += "?" + qs;
+    }
+    const headers = {
+      Authorization: `Bearer ${token}`
+    };
+    let bodyStr;
+    if (opts?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      bodyStr = JSON.stringify(opts.body);
+    }
+    const res = await fetch(url, { method, headers, body: bodyStr });
+    if (!res.ok) {
+      let msg = res.statusText;
+      try {
+        const j = await res.json();
+        if (j.message) msg = j.message;
+      } catch {
+      }
+      throw new ApiError(res.status, res.status, msg);
+    }
+    const text = await res.text();
+    if (!text) return void 0;
+    const json = JSON.parse(text);
+    if (json && typeof json === "object" && "code" in json && json.code === 0 && "data" in json) {
+      return json.data;
+    }
+    return json;
+  }
+  // ── Admin: Apps ──
+  async createApp(req) {
+    return this.request("POST", "/admin/apps", { body: req, auth: "admin" });
+  }
+  async listApps() {
+    return this.request("GET", "/admin/apps", { auth: "admin" });
+  }
+  async getApp(id) {
+    return this.request("GET", `/admin/apps/${id}`, { auth: "admin" });
+  }
+  async updateApp(id, req) {
+    return this.request("PUT", `/admin/apps/${id}`, { body: req, auth: "admin" });
+  }
+  async deleteApp(id) {
+    return this.request("DELETE", `/admin/apps/${id}`, { auth: "admin" });
+  }
+  async rotateAppToken(id) {
+    return this.request("POST", `/admin/apps/${id}/reset-token`, { auth: "admin" });
+  }
+  // ── Admin: Bot Upgrade ──
+  async upgradeBot(id, req) {
+    return this.request("POST", `/admin/bots/${id}/upgrade`, { body: req ?? {}, auth: "admin" });
+  }
+  async upgradeAllBots(req) {
+    return this.request("POST", "/admin/bots/upgrade", { body: req ?? {}, auth: "admin" });
+  }
+  // ── Bots ──
+  async createBot(req) {
+    return this.request("POST", "/bots", { body: req });
+  }
+  async listBots(userId) {
+    return this.request("GET", "/bots", { query: { user_id: userId } });
+  }
+  async getBot(id) {
+    return this.request("GET", `/bots/${id}`);
+  }
+  async updateBot(id, req) {
+    return this.request("PUT", `/bots/${id}`, { body: req });
+  }
+  async deleteBot(id) {
+    return this.request("DELETE", `/bots/${id}`);
+  }
+  // ── Bot Lifecycle ──
+  async startBot(id) {
+    return this.request("POST", `/bots/${id}/start`);
+  }
+  async stopBot(id) {
+    return this.request("POST", `/bots/${id}/stop`);
+  }
+  async restartBot(id) {
+    return this.request("POST", `/bots/${id}/restart`);
+  }
+  async getBotStatus(id) {
+    return this.request("GET", `/bots/${id}/status`);
+  }
+  async getBotConnect(id) {
+    return this.request("GET", `/bots/${id}/connect`);
+  }
+  async resetBotToken(id) {
+    return this.request("POST", `/bots/${id}/reset-token`);
+  }
+  // ── Model Providers ──
+  async listProviders(botId) {
+    return this.request("GET", `/bots/${botId}/config/models`);
+  }
+  async addProvider(botId, provider) {
+    return this.request("POST", `/bots/${botId}/config/models`, { body: provider });
+  }
+  async getProvider(botId, name) {
+    return this.request("GET", `/bots/${botId}/config/models/${name}`);
+  }
+  async updateProvider(botId, name, provider) {
+    return this.request("PUT", `/bots/${botId}/config/models/${name}`, { body: provider });
+  }
+  async deleteProvider(botId, name) {
+    return this.request("DELETE", `/bots/${botId}/config/models/${name}`);
+  }
+  // ── Model Defaults ──
+  async getDefaults(botId) {
+    return this.request("GET", `/bots/${botId}/config/defaults`);
+  }
+  async setDefaults(botId, defaults) {
+    return this.request("PUT", `/bots/${botId}/config/defaults`, { body: defaults });
+  }
+  // ── Channels ──
+  async addChannel(botId, req) {
+    return this.request("POST", `/bots/${botId}/channels`, { body: req });
+  }
+  async listChannels(botId) {
+    return this.request("GET", `/bots/${botId}/channels`);
+  }
+  async removeChannel(botId, channel, account) {
+    const query = {};
+    if (account) query.account = account;
+    return this.request("DELETE", `/bots/${botId}/channels/${channel}`, { query });
+  }
+  // ── Channel Pairing ──
+  async listPairing(botId, channel) {
+    return this.request("GET", `/bots/${botId}/channels/${channel}/pairing`);
+  }
+  async approvePairing(botId, channel, req) {
+    return this.request("POST", `/bots/${botId}/channels/${channel}/pairing/approve`, { body: req });
+  }
+  async revokePairing(botId, channel, req) {
+    return this.request("POST", `/bots/${botId}/channels/${channel}/pairing/revoke`, { body: req });
+  }
+  async listPairedUsers(botId, channel) {
+    return this.request("GET", `/bots/${botId}/channels/${channel}/pairing/users`);
+  }
+  // ── Devices ──
+  async listDevices(botId, opts) {
+    const query = {};
+    if (opts?.status) query.status = opts.status;
+    if (opts?.client_mode) query.client_mode = opts.client_mode;
+    return this.request("GET", `/bots/${botId}/devices`, { query });
+  }
+  async approveDevice(botId, requestId) {
+    return this.request("POST", `/bots/${botId}/devices/${requestId}/approve`);
+  }
+  async revokeDevice(botId, deviceId, role) {
+    const query = {};
+    if (role) query.role = role;
+    return this.request("DELETE", `/bots/${botId}/devices/${deviceId}`, { query });
+  }
+  // ── Skills ──
+  async listSkills(botId) {
+    return this.request("GET", `/bots/${botId}/skills`);
+  }
+  async setSkill(botId, name, req) {
+    return this.request("PUT", `/bots/${botId}/skills/${name}`, { body: req });
+  }
+  async deleteSkill(botId, name) {
+    return this.request("DELETE", `/bots/${botId}/skills/${name}`);
+  }
+  // ── Utility: wait for bot ready ──
+  async waitForReady(botId, timeoutMs = 12e4, intervalMs = 3e3) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const status = await this.getBotStatus(botId);
+      if (status.ready) return status;
+      if (status.status === "error") throw new Error("Bot entered error state");
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error(`Bot not ready after ${timeoutMs / 1e3}s`);
+  }
+  // ── Health check ──
+  async health() {
+    try {
+      const url = this.baseUrl.replace(API_BASE, "") + "/health";
+      const res = await fetch(url);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/commands/admin/apps.ts
+function getClient(program2) {
+  const opts = program2.parent.parent.opts();
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.adminToken, "admin-token");
+  return { client: new FastClawClient({ url: cfg.url, adminToken: cfg.adminToken }), cfg };
+}
+function registerAppsCommand(admin) {
+  const apps = admin.command("apps").description("Manage apps");
+  apps.command("create").description("Create a new app").requiredOption("-n, --name <name>", "App name").option("--url <url>", "App website URL").option("--description <desc>", "App description").option("--owner-email <email>", "Owner email").option("--bot-domain-template <tpl>", "Bot domain template").action(
+    withErrorHandler(async (cmdOpts) => {
+      const { client, cfg } = getClient(apps);
+      const app = await client.createApp({
+        name: cmdOpts.name,
+        url: cmdOpts.url,
+        description: cmdOpts.description,
+        owner_email: cmdOpts.ownerEmail,
+        bot_domain_template: cmdOpts.botDomainTemplate
+      });
+      if (cfg.json) {
+        printJson(app);
+      } else {
+        printSuccess(`App created: ${app.id}`);
+        printKeyValue({
+          ID: app.id,
+          Name: app.name,
+          Token: app.api_token,
+          Status: app.status
+        });
+      }
+    })
+  );
+  apps.command("list").description("List all apps").action(
+    withErrorHandler(async () => {
+      const { client, cfg } = getClient(apps);
+      const list = await client.listApps();
+      if (cfg.json) {
+        printJson(list);
+      } else if (list.length === 0) {
+        console.log(chalk4.dim("No apps found."));
+      } else {
+        printTable(
+          ["ID", "Name", "Status", "Created"],
+          list.map((a) => [a.id, a.name, a.status, a.created_at])
+        );
+      }
+    })
+  );
+  apps.command("delete <id>").description("Delete an app").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient(apps);
+      const res = await client.deleteApp(id);
+      if (cfg.json) {
+        printJson(res);
+      } else {
+        printSuccess(`App ${id} deleted`);
+      }
+    })
+  );
+  apps.command("rotate-token <id>").description("Reset an app's API token").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient(apps);
+      const res = await client.rotateAppToken(id);
+      if (cfg.json) {
+        printJson(res);
+      } else {
+        printSuccess(`Token rotated for app ${id}`);
+        console.log(`  New token: ${res.api_token}`);
+      }
+    })
+  );
+}
+
+// src/commands/admin/index.ts
+function registerAdminCommand(program2) {
+  const admin = program2.command("admin").description("Admin operations");
+  registerAppsCommand(admin);
+}
+
+// src/commands/bot/crud.ts
+import chalk5 from "chalk";
+function getClient2(bot) {
+  const opts = { ...bot.parent.opts(), ...bot.opts() };
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function registerBotCrudCommands(bot) {
+  bot.command("create").description("Create a new bot").requiredOption("-n, --name <name>", "Bot name").option("--slug <slug>", "URL slug").option("--user-id <userId>", "User ID").option("--expires-at <date>", "Expiration date (ISO-8601)").action(
+    withErrorHandler(async (cmdOpts) => {
+      const { client, cfg } = getClient2(bot);
+      const userId = cmdOpts.userId || cfg.userId;
+      const result = await client.createBot({
+        user_id: userId,
+        name: cmdOpts.name,
+        slug: cmdOpts.slug,
+        expires_at: cmdOpts.expiresAt
+      });
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Bot created: ${result.id}`);
+        printKeyValue({
+          ID: result.id,
+          Name: result.name,
+          Slug: result.slug,
+          Status: result.status,
+          "Access Token": result.access_token,
+          "Access URL": result.access_url || ""
+        });
+      }
+    })
+  );
+  bot.command("list").description("List bots").option("--user-id <userId>", "User ID").action(
+    withErrorHandler(async (cmdOpts) => {
+      const { client, cfg } = getClient2(bot);
+      const userId = cmdOpts.userId || cfg.userId;
+      const list = await client.listBots(userId);
+      if (cfg.json) {
+        printJson(list);
+      } else if (list.length === 0) {
+        console.log(chalk5.dim("No bots found."));
+      } else {
+        printTable(
+          ["ID", "Name", "Slug", "Status", "Created"],
+          list.map((b) => [b.id, b.name, b.slug, b.status, b.created_at])
+        );
+      }
+    })
+  );
+  bot.command("get <id>").description("Get bot details").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient2(bot);
+      const b = await client.getBot(id);
+      if (cfg.json) {
+        printJson(b);
+      } else {
+        printKeyValue({
+          ID: b.id,
+          Name: b.name,
+          Slug: b.slug,
+          Status: b.status,
+          "User ID": b.user_id,
+          Endpoint: b.endpoint || "(none)",
+          "Access Token": b.access_token,
+          Image: b.image || "",
+          "Up to date": b.image_up_to_date !== void 0 ? String(b.image_up_to_date) : "",
+          "Expires at": b.expires_at || "(never)",
+          Created: b.created_at,
+          Updated: b.updated_at
+        });
+      }
+    })
+  );
+  bot.command("update <id>").description("Update a bot").option("-n, --name <name>", "New name").option("--slug <slug>", "New slug").option("--expires-at <date>", "New expiration date").action(
+    withErrorHandler(async (id, cmdOpts) => {
+      const { client, cfg } = getClient2(bot);
+      const result = await client.updateBot(id, {
+        name: cmdOpts.name,
+        slug: cmdOpts.slug,
+        expires_at: cmdOpts.expiresAt
+      });
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Bot ${id} updated`);
+      }
+    })
+  );
+  bot.command("delete <id>").description("Delete a bot").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient2(bot);
+      const res = await client.deleteBot(id);
+      if (cfg.json) {
+        printJson(res);
+      } else {
+        printSuccess(`Bot ${id} deleted`);
+      }
+    })
+  );
+}
+
+// src/commands/bot/lifecycle.ts
+import chalk6 from "chalk";
+function getClient3(bot) {
+  const opts = { ...bot.parent.opts(), ...bot.opts() };
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function buildBotUrls(baseUrl, slug, accessToken) {
+  const { hostname } = new URL(baseUrl);
+  const webchatUrl = `https://${slug}.${hostname}#token=${accessToken}`;
+  const wsUrl = `wss://${slug}.${hostname}`;
+  return { webchatUrl, wsUrl };
+}
+function registerBotLifecycleCommands(bot) {
+  bot.command("start <id>").description("Start a bot").option("--wait", "Wait until bot is ready", true).action(
+    withErrorHandler(async (id, cmdOpts) => {
+      const { client, cfg } = getClient3(bot);
+      await client.startBot(id);
+      if (cmdOpts.wait) {
+        const spinner = startSpinner("Waiting for bot to be ready...");
+        try {
+          const status = await client.waitForReady(id);
+          spinner.succeed("Bot is ready");
+          if (cfg.json) {
+            printJson(status);
+          }
+        } catch (err) {
+          spinner.fail("Bot failed to become ready");
+          throw err;
+        }
+      } else {
+        printSuccess(`Bot ${id} starting`);
+      }
+    })
+  );
+  bot.command("stop <id>").description("Stop a bot").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient3(bot);
+      const res = await client.stopBot(id);
+      if (cfg.json) {
+        printJson(res);
+      } else {
+        printSuccess(`Bot ${id} stopped`);
+      }
+    })
+  );
+  bot.command("restart <id>").description("Restart a bot").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient3(bot);
+      const res = await client.restartBot(id);
+      if (cfg.json) {
+        printJson(res);
+      } else {
+        printSuccess(`Bot ${id} restarting`);
+      }
+    })
+  );
+  bot.command("status <id>").description("Get bot status").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient3(bot);
+      const s = await client.getBotStatus(id);
+      const urls = s.status === "running" && s.ready ? await client.getBot(id).then((b) => buildBotUrls(cfg.url, b.slug, b.access_token)) : null;
+      if (cfg.json) {
+        if (urls) {
+          printJson({ ...s, webchat_url: urls.webchatUrl, ws_url: urls.wsUrl });
+        } else {
+          printJson(s);
+        }
+      } else {
+        const readyLabel = s.ready ? chalk6.green("ready") : chalk6.yellow("not ready");
+        const kv = {
+          ID: s.id,
+          Name: s.name,
+          Status: s.status,
+          Ready: readyLabel,
+          Endpoint: s.endpoint || "(none)"
+        };
+        if (urls) {
+          kv["Webchat"] = urls.webchatUrl;
+          kv["WebSocket"] = urls.wsUrl;
+        }
+        printKeyValue(kv);
+      }
+    })
+  );
+  bot.command("connect <id>").description("Get bot connection info").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient3(bot);
+      const [c, b] = await Promise.all([client.getBotConnect(id), client.getBot(id)]);
+      const urls = buildBotUrls(cfg.url, b.slug, b.access_token);
+      if (cfg.json) {
+        printJson({ ...c, webchat_url: urls.webchatUrl, ws_url: urls.wsUrl });
+      } else {
+        printBox(
+          [
+            `${chalk6.dim("Bot ID:")}    ${c.id}`,
+            `${chalk6.dim("Status:")}    ${c.status}`,
+            `${chalk6.dim("Ready:")}     ${c.ready ? chalk6.green("yes") : chalk6.yellow("no")}`,
+            `${chalk6.dim("Webchat:")}   ${urls.webchatUrl}`,
+            `${chalk6.dim("WebSocket:")} ${urls.wsUrl}`
+          ],
+          "Connection Info"
+        );
+      }
+    })
+  );
+  bot.command("reset-token <id>").description("Reset bot access token").action(
+    withErrorHandler(async (id) => {
+      const { client, cfg } = getClient3(bot);
+      const res = await client.resetBotToken(id);
+      if (cfg.json) {
+        printJson(res);
+      } else {
+        printSuccess("Access token reset");
+        printKeyValue({
+          "New Token": res.access_token,
+          "Access URL": res.access_url
+        });
+      }
+    })
+  );
+}
+
+// src/commands/bot/index.ts
+function registerBotCommand(program2) {
+  const bot = program2.command("bot").description("Manage bots").option("--user-id <userId>", "User ID for bot operations");
+  registerBotCrudCommands(bot);
+  registerBotLifecycleCommands(bot);
+}
+
+// src/commands/model/provider.ts
+import chalk7 from "chalk";
+
+// src/utils/prompt.ts
+import { input, select, password, confirm } from "@inquirer/prompts";
+async function promptText(message, defaultValue) {
+  return input({ message, default: defaultValue });
+}
+async function promptPassword(message) {
+  return password({ message, mask: "\u2022" });
+}
+async function promptSelect(message, choices) {
+  return select({ message, choices });
+}
+
+// src/commands/model/provider.ts
+function getClient4(model) {
+  const opts = model.parent.opts();
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function registerModelProviderCommands(model) {
+  model.command("add <bot-id>").description("Add a model provider (interactive or preset)").option("-p, --provider <name>", "Provider name or preset (google/anthropic/openai)").option("-k, --api-key <key>", "API key").action(
+    withErrorHandler(async (botId, cmdOpts) => {
+      const { client, cfg } = getClient4(model);
+      let providerName = cmdOpts.provider;
+      let apiKey = cmdOpts.apiKey;
+      if (!providerName) {
+        providerName = await promptSelect("Model Provider:", [
+          { name: "Google (Gemini)", value: "google" },
+          { name: "Anthropic (Claude)", value: "anthropic" },
+          { name: "OpenAI (GPT)", value: "openai" },
+          { name: "MiniMax", value: "minimax" },
+          { name: "Custom", value: "custom" }
+        ]);
+      }
+      let provider;
+      if (providerName === "custom") {
+        const name = await promptText("Provider name:");
+        const baseUrl = await promptText("Base URL:");
+        apiKey = apiKey || await promptPassword("API Key:");
+        const modelId = await promptText("Model ID:");
+        const modelName = await promptText("Model display name:", modelId);
+        provider = {
+          name,
+          baseUrl,
+          apiKey,
+          models: [{ id: modelId, name: modelName, input: ["text"] }]
+        };
+      } else if (MODEL_PRESETS[providerName]) {
+        const preset = MODEL_PRESETS[providerName];
+        apiKey = apiKey || await promptPassword(`${providerName} API Key:`);
+        provider = { ...preset, apiKey };
+      } else {
+        apiKey = apiKey || await promptPassword("API Key:");
+        provider = { name: providerName, apiKey, models: [] };
+      }
+      const result = await client.addProvider(botId, provider);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Provider '${provider.name}' added to bot ${botId}`);
+      }
+    })
+  );
+  model.command("list <bot-id>").description("List model providers").action(
+    withErrorHandler(async (botId) => {
+      const { client, cfg } = getClient4(model);
+      const providers = await client.listProviders(botId);
+      if (cfg.json) {
+        printJson(providers);
+      } else if (!providers || Object.keys(providers).length === 0) {
+        console.log(chalk7.dim("No model providers configured."));
+      } else {
+        const rows = [];
+        for (const [name, p] of Object.entries(providers)) {
+          const models = (p.models || []).map((m) => m.id).join(", ");
+          rows.push([name, p.baseUrl || "(default)", models]);
+        }
+        printTable(["Provider", "Base URL", "Models"], rows);
+      }
+    })
+  );
+  model.command("get <bot-id> <provider>").description("Get provider details").action(
+    withErrorHandler(async (botId, provider) => {
+      const { client, cfg } = getClient4(model);
+      const p = await client.getProvider(botId, provider);
+      if (cfg.json) {
+        printJson(p);
+      } else {
+        printKeyValue({
+          Name: p.name,
+          "Base URL": p.baseUrl || "(default)",
+          "API Key": p.apiKey ? "\u2022\u2022\u2022\u2022" + p.apiKey.slice(-4) : "(not set)",
+          Models: (p.models || []).map((m) => m.id).join(", ")
+        });
+      }
+    })
+  );
+  model.command("delete <bot-id> <provider>").description("Delete a model provider").action(
+    withErrorHandler(async (botId, provider) => {
+      const { client, cfg } = getClient4(model);
+      await client.deleteProvider(botId, provider);
+      if (cfg.json) {
+        printJson({ message: "deleted" });
+      } else {
+        printSuccess(`Provider '${provider}' deleted from bot ${botId}`);
+      }
+    })
+  );
+  const defaults = model.command("defaults").description("Manage default model settings");
+  defaults.command("get <bot-id>").description("Get default model settings").action(
+    withErrorHandler(async (botId) => {
+      const { client, cfg } = getClient4(model);
+      const d = await client.getDefaults(botId);
+      if (cfg.json) {
+        printJson(d);
+      } else {
+        printKeyValue({
+          "Primary Model": d.primary_model || "(not set)",
+          "Fallback Model": d.fallback_model || "(not set)"
+        });
+      }
+    })
+  );
+  defaults.command("set <bot-id>").description("Set default model").option("--primary <model>", "Primary model (provider/model_id)").option("--fallback <model>", "Fallback model").action(
+    withErrorHandler(async (botId, cmdOpts) => {
+      const { client, cfg } = getClient4(model);
+      const body = {};
+      if (cmdOpts.primary) body.primary_model = cmdOpts.primary;
+      if (cmdOpts.fallback) body.fallback_model = cmdOpts.fallback;
+      const d = await client.setDefaults(botId, body);
+      if (cfg.json) {
+        printJson(d);
+      } else {
+        printSuccess("Defaults updated");
+        printKeyValue({
+          "Primary Model": d.primary_model || "(not set)",
+          "Fallback Model": d.fallback_model || "(not set)"
+        });
+      }
+    })
+  );
+}
+
+// src/commands/model/index.ts
+function registerModelCommand(program2) {
+  const model = program2.command("model").description("Manage model providers");
+  registerModelProviderCommands(model);
+}
+
+// src/commands/channel/crud.ts
+import chalk8 from "chalk";
+function getClient5(parent) {
+  const opts = parent.parent.opts();
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function registerChannelCrudCommands(channel) {
+  channel.command("add <bot-id>").description("Add an IM channel").option("-c, --channel <type>", "Channel type (feishu/telegram/slack/discord)").option("--account <name>", "Account name", "default").option("--dm-policy <policy>", "DM policy (open/pairing/allowlist/disabled)").option("--group-policy <policy>", "Group policy (open/allowlist/disabled)").action(
+    withErrorHandler(async (botId, cmdOpts) => {
+      const { client, cfg } = getClient5(channel);
+      let channelType = cmdOpts.channel;
+      if (!channelType) {
+        channelType = await promptSelect("Channel type:", [
+          { name: "Feishu (\u98DE\u4E66)", value: "feishu" },
+          { name: "Telegram", value: "telegram" },
+          { name: "Slack", value: "slack" },
+          { name: "Discord", value: "discord" }
+        ]);
+      }
+      const req = {
+        channel: channelType,
+        account: cmdOpts.account,
+        dmPolicy: cmdOpts.dmPolicy,
+        groupPolicy: cmdOpts.groupPolicy
+      };
+      const fields = CHANNEL_FIELDS[channelType];
+      if (fields) {
+        for (const field of fields.required) {
+          const isSecret = field.toLowerCase().includes("secret") || field.toLowerCase().includes("token") || field.toLowerCase().includes("password");
+          const value = isSecret ? await promptPassword(`${field}:`) : await promptText(`${field}:`);
+          req[field] = value;
+        }
+      }
+      if (!req.dmPolicy) {
+        req.dmPolicy = await promptSelect("DM Policy:", [
+          { name: "Open (anyone can message)", value: "open" },
+          { name: "Pairing (require pairing code)", value: "pairing" },
+          { name: "Disabled", value: "disabled" }
+        ]);
+      }
+      const result = await client.addChannel(botId, req);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Channel '${channelType}' added to bot ${botId}`);
+      }
+    })
+  );
+  channel.command("list <bot-id>").description("List channels").action(
+    withErrorHandler(async (botId) => {
+      const { client, cfg } = getClient5(channel);
+      const channels = await client.listChannels(botId);
+      if (cfg.json) {
+        printJson(channels);
+      } else if (!channels || Object.keys(channels).length === 0) {
+        console.log(chalk8.dim("No channels configured."));
+      } else {
+        const rows = [];
+        for (const [type, accounts] of Object.entries(channels)) {
+          for (const [account, config] of Object.entries(accounts)) {
+            rows.push([type, account, config.dmPolicy || "", config.groupPolicy || ""]);
+          }
+        }
+        printTable(["Channel", "Account", "DM Policy", "Group Policy"], rows);
+      }
+    })
+  );
+  channel.command("remove <bot-id> <channel>").description("Remove a channel").option("--account <name>", "Specific account to remove").action(
+    withErrorHandler(async (botId, ch, cmdOpts) => {
+      const { client, cfg } = getClient5(channel);
+      const result = await client.removeChannel(botId, ch, cmdOpts.account);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Channel '${ch}' removed from bot ${botId}`);
+      }
+    })
+  );
+}
+
+// src/commands/channel/pairing.ts
+function getClient6(parent) {
+  const root = parent.parent.parent;
+  const opts = root.opts();
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function registerPairingCommands(channel) {
+  const pairing = channel.command("pairing").description("Manage channel pairing");
+  pairing.command("list <bot-id> <channel>").description("List pairing requests").action(
+    withErrorHandler(async (botId, ch) => {
+      const { client, cfg } = getClient6(pairing);
+      const list = await client.listPairing(botId, ch);
+      if (cfg.json) {
+        printJson(list);
+      } else {
+        console.log(JSON.stringify(list, null, 2));
+      }
+    })
+  );
+  pairing.command("approve <bot-id> <channel>").description("Approve a pairing request").requiredOption("--code <code>", "Pairing code").action(
+    withErrorHandler(async (botId, ch, cmdOpts) => {
+      const { client, cfg } = getClient6(pairing);
+      const result = await client.approvePairing(botId, ch, { code: cmdOpts.code });
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Pairing approved for channel '${ch}'`);
+      }
+    })
+  );
+  pairing.command("revoke <bot-id> <channel>").description("Revoke a user's pairing").requiredOption("--user-id <userId>", "User ID to revoke").action(
+    withErrorHandler(async (botId, ch, cmdOpts) => {
+      const { client, cfg } = getClient6(pairing);
+      const result = await client.revokePairing(botId, ch, { user_id: cmdOpts.userId });
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Pairing revoked for user '${cmdOpts.userId}' on channel '${ch}'`);
+      }
+    })
+  );
+  pairing.command("users <bot-id> <channel>").description("List paired users").action(
+    withErrorHandler(async (botId, ch) => {
+      const { client, cfg } = getClient6(pairing);
+      const result = await client.listPairedUsers(botId, ch);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printTable(["User ID"], (result.users || []).map((u) => [u]));
+      }
+    })
+  );
+}
+
+// src/commands/channel/index.ts
+function registerChannelCommand(program2) {
+  const channel = program2.command("channel").description("Manage IM channels");
+  registerChannelCrudCommands(channel);
+  registerPairingCommands(channel);
+}
+
+// src/commands/device/crud.ts
+import chalk9 from "chalk";
+function getClient7(device) {
+  const opts = device.parent.opts();
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function registerDeviceCrudCommands(device) {
+  device.command("list <bot-id>").description("List devices").option("--status <status>", "Filter by status (pending/paired)").option("--client-mode <mode>", "Filter by client mode (web/cli/desktop)").action(
+    withErrorHandler(async (botId, cmdOpts) => {
+      const { client, cfg } = getClient7(device);
+      const result = await client.listDevices(botId, {
+        status: cmdOpts.status,
+        client_mode: cmdOpts.clientMode
+      });
+      if (cfg.json) {
+        printJson(result);
+      } else if (!result.devices || result.devices.length === 0) {
+        console.log(chalk9.dim("No devices found."));
+      } else {
+        printTable(
+          ["Request ID", "Device ID", "Platform", "Mode", "Status", "Connected", "Age"],
+          result.devices.map((d) => [
+            d.request_id,
+            d.device_id,
+            d.platform,
+            d.client_mode,
+            d.status,
+            d.connected ? chalk9.green("yes") : "no",
+            d.age
+          ])
+        );
+      }
+    })
+  );
+  device.command("approve <bot-id> <request-id>").description("Approve a device pairing request").action(
+    withErrorHandler(async (botId, requestId) => {
+      const { client, cfg } = getClient7(device);
+      const result = await client.approveDevice(botId, requestId);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Device ${requestId} approved`);
+      }
+    })
+  );
+  device.command("revoke <bot-id> <device-id>").description("Revoke a paired device").option("--role <role>", "Role to revoke", "operator").action(
+    withErrorHandler(async (botId, deviceId, cmdOpts) => {
+      const { client, cfg } = getClient7(device);
+      const result = await client.revokeDevice(botId, deviceId, cmdOpts.role);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Device ${deviceId} revoked`);
+      }
+    })
+  );
+}
+
+// src/commands/device/index.ts
+function registerDeviceCommand(program2) {
+  const device = program2.command("device").description("Manage device pairing");
+  registerDeviceCrudCommands(device);
+}
+
+// src/commands/skill/crud.ts
+import { readFileSync as readFileSync2 } from "fs";
+import chalk10 from "chalk";
+function getClient8(skill) {
+  const opts = skill.parent.opts();
+  const cfg = resolveConfig(opts);
+  requireOption(cfg.appToken, "app-token");
+  return { client: new FastClawClient({ url: cfg.url, appToken: cfg.appToken }), cfg };
+}
+function registerSkillCrudCommands(skill) {
+  skill.command("list <bot-id>").description("List skills").action(
+    withErrorHandler(async (botId) => {
+      const { client, cfg } = getClient8(skill);
+      const list = await client.listSkills(botId);
+      if (cfg.json) {
+        printJson(list);
+      } else if (list.length === 0) {
+        console.log(chalk10.dim("No skills configured."));
+      } else {
+        printTable(["Name"], list.map((s) => [s.name]));
+      }
+    })
+  );
+  skill.command("set <bot-id> <name>").description("Create or update a skill").option("-c, --content <content>", "Skill content (markdown)").option("-f, --file <path>", "Read content from file").action(
+    withErrorHandler(async (botId, name, cmdOpts) => {
+      const { client, cfg } = getClient8(skill);
+      let content;
+      if (cmdOpts.file) {
+        content = readFileSync2(cmdOpts.file, "utf-8");
+      } else if (cmdOpts.content) {
+        content = cmdOpts.content;
+      } else {
+        throw new Error("Either --content or --file is required");
+      }
+      const result = await client.setSkill(botId, name, { content });
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Skill '${name}' set on bot ${botId}`);
+      }
+    })
+  );
+  skill.command("delete <bot-id> <name>").description("Delete a skill").action(
+    withErrorHandler(async (botId, name) => {
+      const { client, cfg } = getClient8(skill);
+      const result = await client.deleteSkill(botId, name);
+      if (cfg.json) {
+        printJson(result);
+      } else {
+        printSuccess(`Skill '${name}' deleted from bot ${botId}`);
+      }
+    })
+  );
+}
+
+// src/commands/skill/index.ts
+function registerSkillCommand(program2) {
+  const skill = program2.command("skill").description("Manage bot skills");
+  registerSkillCrudCommands(skill);
+}
+
+// src/commands/setup.ts
+import chalk11 from "chalk";
+
+// src/utils/validators.ts
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+
+// src/commands/setup.ts
+function registerSetupCommand(program2) {
+  program2.command("setup").description("Interactive setup wizard \u2014 create and start a bot in one step").action(
+    withErrorHandler(async () => {
+      console.log("");
+      console.log(chalk11.bold.cyan("  FastClaw CLI Setup"));
+      console.log(chalk11.dim("  \u2500".repeat(20)));
+      console.log("");
+      const existing = loadConfig();
+      const url = await promptText("FastClaw Server URL:", existing.url || "https://claw.yesy.dev");
+      const adminToken = await promptPassword("Admin Token:");
+      const adminClient = new FastClawClient({ url, adminToken });
+      const spinner1 = startSpinner("Connecting to server...");
+      const healthy = await adminClient.health();
+      if (!healthy) {
+        spinner1.fail("Cannot connect to server");
+        throw new Error(`Failed to connect to ${url}`);
+      }
+      spinner1.succeed("Connected to " + url);
+      updateConfig({ url, admin_token: adminToken });
+      let appToken;
+      const appAction = await promptSelect("App:", [
+        { name: "Create new app", value: "create" },
+        { name: "Use existing app token", value: "existing" }
+      ]);
+      if (appAction === "create") {
+        const appName = await promptText("App Name:", "default");
+        const app = await adminClient.createApp({ name: appName });
+        appToken = app.api_token;
+        printSuccess(`App created: ${app.id}`);
+        console.log(chalk11.dim(`  Token: ${appToken}`));
+      } else {
+        appToken = await promptPassword("App Token:");
+      }
+      updateConfig({ app_token: appToken });
+      const client = new FastClawClient({ url, appToken });
+      const botName = await promptText("Bot Name:");
+      const userId = await promptText("User ID:", existing.default_user_id || "default");
+      const defaultSlug = slugify(botName);
+      const slug = await promptText("Bot Slug:", defaultSlug);
+      const bot = await client.createBot({
+        user_id: userId,
+        name: botName,
+        slug
+      });
+      printSuccess(`Bot created: ${bot.id}`);
+      updateConfig({ default_user_id: userId, default_bot_id: bot.id });
+      const providerChoice = await promptSelect("Model Provider:", [
+        { name: "Google (Gemini)", value: "google" },
+        { name: "Anthropic (Claude)", value: "anthropic" },
+        { name: "OpenAI (GPT)", value: "openai" },
+        { name: "MiniMax", value: "minimax" },
+        { name: "Custom", value: "custom" },
+        { name: "Skip (configure later)", value: "skip" }
+      ]);
+      if (providerChoice !== "skip") {
+        let providerConfig;
+        if (providerChoice === "custom") {
+          const pName = await promptText("Provider name:");
+          const baseUrl = await promptText("Base URL:");
+          const apiKey = await promptPassword("API Key:");
+          const modelId = await promptText("Model ID:");
+          const modelName = await promptText("Model display name:", modelId);
+          providerConfig = {
+            name: pName,
+            baseUrl,
+            apiKey,
+            models: [{ id: modelId, name: modelName, input: ["text"] }]
+          };
+        } else {
+          const preset = MODEL_PRESETS[providerChoice];
+          const apiKey = await promptPassword(`${providerChoice} API Key:`);
+          providerConfig = { ...preset, apiKey };
+        }
+        await client.addProvider(bot.id, providerConfig);
+        printSuccess("Model provider configured");
+        const defaultModel = providerChoice !== "custom" ? PROVIDER_DEFAULTS[providerChoice] : `${providerConfig.name}/${providerConfig.models[0].id}`;
+        await client.setDefaults(bot.id, { primary_model: defaultModel });
+        printSuccess(`Default model: ${defaultModel}`);
+      }
+      const spinnerStart = startSpinner("Starting bot...");
+      await client.startBot(bot.id);
+      spinnerStart.text = "Waiting for bot to be ready...";
+      try {
+        await client.waitForReady(bot.id, 12e4, 3e3);
+        spinnerStart.succeed("Bot is ready");
+      } catch {
+        spinnerStart.warn("Bot started but not yet ready \u2014 it may need more time");
+      }
+      const addChannel = await promptSelect("Add a channel?", [
+        { name: "Skip", value: "skip" },
+        { name: "Feishu (\u98DE\u4E66)", value: "feishu" },
+        { name: "Telegram", value: "telegram" },
+        { name: "Slack", value: "slack" },
+        { name: "Discord", value: "discord" }
+      ]);
+      if (addChannel !== "skip") {
+        const channelReq = {
+          channel: addChannel,
+          account: "default"
+        };
+        const fields = CHANNEL_FIELDS[addChannel];
+        if (fields) {
+          for (const field of fields.required) {
+            const isSecret = field.toLowerCase().includes("secret") || field.toLowerCase().includes("token") || field.toLowerCase().includes("password");
+            channelReq[field] = isSecret ? await promptPassword(`${field}:`) : await promptText(`${field}:`);
+          }
+        }
+        const dmPolicy = await promptSelect("DM Policy:", [
+          { name: "Open (anyone can message)", value: "open" },
+          { name: "Pairing (require pairing code)", value: "pairing" },
+          { name: "Disabled", value: "disabled" }
+        ]);
+        channelReq.dmPolicy = dmPolicy;
+        try {
+          await client.addChannel(bot.id, channelReq);
+          printSuccess(`Channel '${addChannel}' added`);
+        } catch (err) {
+          console.log(chalk11.yellow(`  ! Channel add failed: ${err instanceof Error ? err.message : err}`));
+          console.log(chalk11.dim(`  You can add it later: fastclaw channel add ${bot.id}`));
+        }
+      }
+      let connectInfo;
+      try {
+        connectInfo = await client.getBotConnect(bot.id);
+      } catch {
+      }
+      const lines = [
+        `${chalk11.dim("Bot ID:")}      ${bot.id}`,
+        `${chalk11.dim("Bot Name:")}    ${bot.name}`,
+        `${chalk11.dim("Slug:")}        ${bot.slug}`,
+        `${chalk11.dim("Token:")}       ${bot.access_token}`
+      ];
+      if (connectInfo) {
+        lines.push(
+          `${chalk11.dim("Webchat:")}     ${connectInfo.webchat_url}`,
+          `${chalk11.dim("WebSocket:")}   ${connectInfo.ws_url}`
+        );
+        if (bot.access_url) {
+          lines.push(`${chalk11.dim("Quick URL:")}   ${bot.access_url}`);
+        }
+      }
+      printBox(lines, "Setup Complete");
+      console.log(chalk11.dim("\nUseful commands:"));
+      console.log(chalk11.dim(`  fastclaw bot status ${bot.id}`));
+      console.log(chalk11.dim(`  fastclaw bot connect ${bot.id}`));
+      console.log(chalk11.dim(`  fastclaw model list ${bot.id}`));
+      console.log(chalk11.dim(`  fastclaw channel add ${bot.id}`));
+      console.log("");
+    })
+  );
+}
+
+// src/index.ts
+var program = new Command().name("fastclaw").description("CLI for managing FastClaw bots").version("0.1.0").option("--url <url>", "FastClaw server URL").option("--admin-token <token>", "Admin API token").option("--app-token <token>", "App API token").option("--json", "Output as JSON");
+registerSetupCommand(program);
+registerConfigCommand(program);
+registerAdminCommand(program);
+registerBotCommand(program);
+registerModelCommand(program);
+registerChannelCommand(program);
+registerDeviceCommand(program);
+registerSkillCommand(program);
+program.parse();