teleton 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1055 @@
+import {
+  CasinoConfigSchema,
+  ConfigSchema,
+  DealsConfigSchema,
+  MarketConfigSchema,
+  configExists,
+  ensureWorkspace,
+  generateWallet,
+  getDefaultConfigPath,
+  getProviderMetadata,
+  getSupportedProviders,
+  isNewWorkspace,
+  main,
+  saveWallet,
+  validateApiKeyFormat
+} from "../chunk-WXVHT6CI.js";
+import "../chunk-XBGUNXF2.js";
+import "../chunk-WDUHRPGA.js";
+import "../chunk-UR2LQEKR.js";
+import {
+  TELETON_ROOT
+} from "../chunk-7NJ46ZIX.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/prompts.ts
+import * as clack from "@clack/prompts";
+var ClackPrompter = class {
+  /**
+   * Display intro banner
+   */
+  async intro(title) {
+    clack.intro(title);
+  }
+  /**
+   * Display outro message
+   */
+  async outro(message) {
+    clack.outro(message);
+  }
+  /**
+   * Display note/info
+   */
+  async note(message, title) {
+    clack.note(message, title);
+  }
+  /**
+   * Text input prompt
+   */
+  async text(options) {
+    const result = await clack.text({
+      message: options.message,
+      placeholder: options.placeholder,
+      initialValue: options.initialValue,
+      validate: options.validate
+    });
+    if (clack.isCancel(result)) {
+      throw new CancelledError();
+    }
+    return result;
+  }
+  /**
+   * Password input (hidden)
+   */
+  async password(options) {
+    const result = await clack.password({
+      message: options.message,
+      validate: options.validate
+    });
+    if (clack.isCancel(result)) {
+      throw new CancelledError();
+    }
+    return result;
+  }
+  /**
+   * Select prompt (single choice)
+   */
+  async select(options) {
+    const result = await clack.select({
+      message: options.message,
+      options: options.options.map((opt) => {
+        const mapped = {
+          value: opt.value,
+          label: opt.label
+        };
+        if (opt.hint) {
+          mapped.hint = opt.hint;
+        }
+        return mapped;
+      }),
+      initialValue: options.initialValue
+    });
+    if (clack.isCancel(result)) {
+      throw new CancelledError();
+    }
+    return result;
+  }
+  /**
+   * Confirm (yes/no)
+   */
+  async confirm(options) {
+    const result = await clack.confirm({
+      message: options.message,
+      initialValue: options.initialValue ?? false
+    });
+    if (clack.isCancel(result)) {
+      throw new CancelledError();
+    }
+    return result;
+  }
+  /**
+   * Multi-select prompt
+   */
+  async multiselect(options) {
+    const result = await clack.multiselect({
+      message: options.message,
+      options: options.options.map((opt) => {
+        const mapped = {
+          value: opt.value,
+          label: opt.label
+        };
+        if (opt.hint) {
+          mapped.hint = opt.hint;
+        }
+        return mapped;
+      }),
+      required: options.required
+    });
+    if (clack.isCancel(result)) {
+      throw new CancelledError();
+    }
+    return result;
+  }
+  /**
+   * Spinner for long operations
+   */
+  spinner() {
+    const s = clack.spinner();
+    return {
+      start: (message) => s.start(message),
+      stop: (message) => s.stop(message),
+      message: (message) => s.message(message)
+    };
+  }
+  /**
+   * Log message
+   */
+  log(message) {
+    clack.log.message(message);
+  }
+  /**
+   * Log warning
+   */
+  warn(message) {
+    clack.log.warn(message);
+  }
+  /**
+   * Log error
+   */
+  error(message) {
+    clack.log.error(message);
+  }
+  /**
+   * Log success
+   */
+  success(message) {
+    clack.log.success(message);
+  }
+};
+var CancelledError = class extends Error {
+  constructor() {
+    super("Operation cancelled by user");
+    this.name = "CancelledError";
+  }
+};
+function createPrompter() {
+  return new ClackPrompter();
+}
+
+// src/cli/commands/onboard.ts
+import { writeFileSync } from "fs";
+import { execSync } from "child_process";
+import YAML from "yaml";
+async function onboardCommand(options = {}) {
+  const prompter = createPrompter();
+  try {
+    if (options.nonInteractive) {
+      await runNonInteractiveOnboarding(options, prompter);
+    } else {
+      await runInteractiveOnboarding(options, prompter);
+    }
+  } catch (err) {
+    if (err instanceof CancelledError) {
+      prompter.outro("Onboarding cancelled");
+      process.exit(0);
+    }
+    throw err;
+  }
+}
+async function runInteractiveOnboarding(options, prompter) {
+  const blue2 = "\x1B[34m";
+  const reset2 = "\x1B[0m";
+  console.log(`
+${blue2}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+  \u2502                                                                                       \u2502
+  \u2502       ______________    ________________  _   __   ___   _____________   ________     \u2502
+  \u2502      /_  __/ ____/ /   / ____/_  __/ __ \\/ | / /  /   | / ____/ ____/ | / /_  __/     \u2502
+  \u2502       / / / __/ / /   / __/   / / / / / /  |/ /  / /| |/ / __/ __/ /  |/ / / /        \u2502
+  \u2502      / / / /___/ /___/ /___  / / / /_/ / /|  /  / ___ / /_/ / /___/ /|  / / /         \u2502
+  \u2502     /_/ /_____/_____/_____/ /_/  \\____/_/ |_/  /_/  |_\\____/_____/_/ |_/ /_/          \u2502
+  \u2502                                                                                       \u2502
+  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 SETUP \u2500\u2500\u2518${reset2}
+
+  Need help? Join @ResistanceForum on Telegram
+`);
+  prompter.note(
+    "Your Teleton agent will have FULL CONTROL over:\n\n\u2022 TELEGRAM: Read, send, and delete messages on your behalf\n\u2022 TON WALLET: A new wallet will be generated that the agent\n  can use to send transactions autonomously\n\nWe strongly recommend using a dedicated Telegram account.\nOnly fund the generated wallet with amounts you're comfortable\nletting the agent manage.",
+    "Security Warning"
+  );
+  const acceptRisk = await prompter.confirm({
+    message: "I understand the risks and want to continue",
+    initialValue: false
+  });
+  if (!acceptRisk) {
+    prompter.outro("Setup cancelled - you must accept the risks to continue");
+    process.exit(1);
+  }
+  const spinner2 = prompter.spinner();
+  spinner2.start("Creating workspace...");
+  const workspace = await ensureWorkspace({
+    workspaceDir: options.workspace,
+    ensureTemplates: true
+  });
+  const isNew = isNewWorkspace(workspace);
+  spinner2.stop(`\u2713 Workspace: ${workspace.root}`);
+  if (!isNew) {
+    prompter.warn("Existing configuration detected");
+    const shouldOverwrite = await prompter.confirm({
+      message: "Overwrite existing configuration?",
+      initialValue: false
+    });
+    if (!shouldOverwrite) {
+      prompter.outro("Setup cancelled - existing configuration preserved");
+      return;
+    }
+  }
+  const flow = await prompter.select({
+    message: "Installation mode",
+    options: [
+      { value: "quick", label: "QuickStart", hint: "Minimal configuration (recommended)" },
+      { value: "advanced", label: "Advanced", hint: "Detailed configuration" }
+    ],
+    initialValue: "quick"
+  });
+  const providers = getSupportedProviders();
+  const selectedProvider = await prompter.select({
+    message: "AI Provider",
+    options: providers.map((p) => ({
+      value: p.id,
+      label: p.displayName,
+      hint: p.toolLimit !== null ? `${p.defaultModel} (max ${p.toolLimit} tools)` : `${p.defaultModel}`
+    })),
+    initialValue: "anthropic"
+  });
+  const providerMeta = getProviderMetadata(selectedProvider);
+  if (providerMeta.toolLimit !== null) {
+    prompter.note(
+      `${providerMeta.displayName} supports max ${providerMeta.toolLimit} tools.
+Tonnet currently has ~121 tools. If more tools are added,
+some may be truncated.`,
+      "Tool Limit"
+    );
+  }
+  prompter.note(
+    "You need Telegram credentials from https://my.telegram.org/apps\nCreate an application and note the API ID and API Hash",
+    "Telegram"
+  );
+  const apiIdStr = options.apiId ? options.apiId.toString() : await prompter.text({
+    message: "API ID (from my.telegram.org)",
+    validate: (value) => {
+      if (!value || isNaN(parseInt(value))) return "Invalid API ID (must be a number)";
+    }
+  });
+  const apiId = parseInt(apiIdStr);
+  const apiHash = options.apiHash ? options.apiHash : await prompter.text({
+    message: "API Hash (from my.telegram.org)",
+    validate: (value) => {
+      if (!value || value.length < 10) return "Invalid API Hash";
+    }
+  });
+  const phone = options.phone ? options.phone : await prompter.text({
+    message: "Phone number (international format, e.g. +1234567890)",
+    placeholder: "+1234567890",
+    validate: (value) => {
+      if (!value || !value.startsWith("+")) return "Invalid format (must start with +)";
+    }
+  });
+  prompter.note(
+    "To get your Telegram User ID:\n1. Open @userinfobot on Telegram\n2. Send /start\n3. Note the ID displayed",
+    "User ID"
+  );
+  const userIdStr = options.userId ? options.userId.toString() : await prompter.text({
+    message: "Your Telegram User ID (for admin rights)",
+    validate: (value) => {
+      if (!value || isNaN(parseInt(value))) return "Invalid User ID";
+    }
+  });
+  const userId = parseInt(userIdStr);
+  prompter.note(
+    `${providerMeta.displayName} API key required.
+Get it at: ${providerMeta.consoleUrl}`,
+    "API Key"
+  );
+  const apiKey = options.apiKey ? options.apiKey : await prompter.password({
+    message: `${providerMeta.displayName} API Key (${providerMeta.keyHint})`,
+    validate: (value) => validateApiKeyFormat(selectedProvider, value)
+  });
+  let selectedModel = providerMeta.defaultModel;
+  if (flow === "advanced") {
+    const customModel = await prompter.text({
+      message: `Model ID (default: ${providerMeta.defaultModel})`,
+      placeholder: providerMeta.defaultModel,
+      initialValue: providerMeta.defaultModel
+    });
+    if (customModel && customModel.trim()) {
+      selectedModel = customModel.trim();
+    }
+  }
+  let dmPolicy = "open";
+  let groupPolicy = "open";
+  let requireMention = true;
+  if (flow === "advanced") {
+    dmPolicy = await prompter.select({
+      message: "DM policy (private messages)",
+      options: [
+        { value: "open", label: "Open", hint: "Reply to everyone" },
+        { value: "allowlist", label: "Allowlist", hint: "Only specific users" },
+        { value: "disabled", label: "Disabled", hint: "No DM replies" }
+      ],
+      initialValue: "open"
+    });
+    groupPolicy = await prompter.select({
+      message: "Group policy",
+      options: [
+        { value: "open", label: "Open", hint: "Reply in all groups" },
+        { value: "allowlist", label: "Allowlist", hint: "Only specific groups" },
+        { value: "disabled", label: "Disabled", hint: "No group replies" }
+      ],
+      initialValue: "open"
+    });
+    requireMention = await prompter.confirm({
+      message: "Require @mention in groups?",
+      initialValue: true
+    });
+  }
+  const config = {
+    meta: {
+      version: "1.0.0",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      onboard_command: "teleton setup"
+    },
+    agent: {
+      provider: selectedProvider,
+      api_key: apiKey,
+      model: selectedModel,
+      max_tokens: 4096,
+      temperature: 0.7,
+      system_prompt: null,
+      max_agentic_iterations: 5,
+      session_reset_policy: {
+        daily_reset_enabled: true,
+        daily_reset_hour: 4,
+        idle_expiry_enabled: true,
+        idle_expiry_minutes: 1440
+      }
+    },
+    telegram: {
+      api_id: apiId,
+      api_hash: apiHash,
+      phone,
+      session_name: "tonnet_session",
+      session_path: workspace.sessionPath,
+      dm_policy: dmPolicy,
+      allow_from: [],
+      group_policy: groupPolicy,
+      group_allow_from: [],
+      require_mention: requireMention,
+      max_message_length: 4096,
+      typing_simulation: true,
+      rate_limit_messages_per_second: 1,
+      rate_limit_groups_per_minute: 20,
+      admin_ids: [userId],
+      agent_channel: null,
+      debounce_ms: 1500,
+      bot_token: "YOUR_BOT_TOKEN_FROM_BOTFATHER",
+      bot_username: "your_deals_bot"
+    },
+    storage: {
+      sessions_file: `${workspace.root}/sessions.json`,
+      pairing_file: `${workspace.root}/pairing.json`,
+      memory_file: `${workspace.root}/memory.json`,
+      history_limit: 100
+    },
+    casino: CasinoConfigSchema.parse({}),
+    deals: DealsConfigSchema.parse({}),
+    market: MarketConfigSchema.parse({})
+  };
+  spinner2.start("Saving configuration...");
+  const configYaml = YAML.stringify(config);
+  writeFileSync(workspace.configPath, configYaml, "utf-8");
+  spinner2.stop("\u2713 Configuration saved");
+  spinner2.start("Generating TON wallet...");
+  const wallet = await generateWallet();
+  saveWallet(wallet);
+  spinner2.stop("\u2713 TON wallet generated");
+  spinner2.start("Installing browser for market data...");
+  try {
+    execSync("npx playwright install chromium", {
+      stdio: "pipe",
+      timeout: 12e4
+      // 2 minutes timeout
+    });
+    spinner2.stop("\u2713 Browser installed");
+  } catch (err) {
+    spinner2.stop(
+      "\u26A0 Browser install failed (can be done later with: npx playwright install chromium)"
+    );
+  }
+  prompter.note(
+    "BACKUP REQUIRED - WRITE DOWN THESE 24 WORDS:\n\n" + wallet.mnemonic.join(" ") + "\n\nThese words allow you to recover your wallet.\nWithout them, you will lose access to your TON.\nWrite them on paper and keep them safe.",
+    "Mnemonic Seed (24 words)"
+  );
+  prompter.note(
+    `Workspace: ${workspace.root}
+Config: ${workspace.configPath}
+Templates: SOUL.md, MEMORY.md, IDENTITY.md, USER.md
+Telegram: ${phone} (API ID: ${apiId})
+Admin: User ID ${userId}
+Provider: ${providerMeta.displayName}
+Model: ${selectedModel}
+TON Wallet: ${wallet.address}`,
+    "Setup complete"
+  );
+  prompter.note(
+    "Next steps:\n\n1. Start the agent:\n   $ teleton start\n\n2. On first launch, you will be asked for:\n   - Telegram verification code\n   - 2FA password (if enabled)\n\n3. Send a message to your Telegram account to test",
+    "Ready"
+  );
+  prompter.outro("Good luck!");
+}
+async function runNonInteractiveOnboarding(options, prompter) {
+  if (!options.apiId || !options.apiHash || !options.phone || !options.apiKey || !options.userId) {
+    prompter.error(
+      "Non-interactive mode requires: --api-id, --api-hash, --phone, --api-key, --user-id"
+    );
+    process.exit(1);
+  }
+  const workspace = await ensureWorkspace({
+    workspaceDir: options.workspace,
+    ensureTemplates: true
+  });
+  const selectedProvider = options.provider || "anthropic";
+  const providerMeta = getProviderMetadata(selectedProvider);
+  const config = {
+    meta: {
+      version: "1.0.0",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      onboard_command: "teleton setup"
+    },
+    agent: {
+      provider: selectedProvider,
+      api_key: options.apiKey,
+      model: providerMeta.defaultModel,
+      max_tokens: 4096,
+      temperature: 0.7,
+      system_prompt: null,
+      max_agentic_iterations: 5,
+      session_reset_policy: {
+        daily_reset_enabled: true,
+        daily_reset_hour: 4,
+        idle_expiry_enabled: true,
+        idle_expiry_minutes: 1440
+      }
+    },
+    telegram: {
+      api_id: options.apiId,
+      api_hash: options.apiHash,
+      phone: options.phone,
+      session_name: "tonnet_session",
+      session_path: workspace.sessionPath,
+      dm_policy: "open",
+      allow_from: [],
+      group_policy: "open",
+      group_allow_from: [],
+      require_mention: true,
+      max_message_length: 4096,
+      typing_simulation: true,
+      rate_limit_messages_per_second: 1,
+      rate_limit_groups_per_minute: 20,
+      admin_ids: [options.userId],
+      agent_channel: null,
+      debounce_ms: 1500,
+      bot_token: "YOUR_BOT_TOKEN_FROM_BOTFATHER",
+      bot_username: "your_deals_bot"
+    },
+    storage: {
+      sessions_file: `${workspace.root}/sessions.json`,
+      pairing_file: `${workspace.root}/pairing.json`,
+      memory_file: `${workspace.root}/memory.json`,
+      history_limit: 100
+    },
+    casino: CasinoConfigSchema.parse({}),
+    deals: DealsConfigSchema.parse({}),
+    market: MarketConfigSchema.parse({})
+  };
+  const configYaml = YAML.stringify(config);
+  writeFileSync(workspace.configPath, configYaml, "utf-8");
+  prompter.success(`\u2713 Configuration created: ${workspace.configPath}`);
+}
+
+// src/cli/commands/doctor.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse } from "yaml";
+var green = "\x1B[32m";
+var yellow = "\x1B[33m";
+var red = "\x1B[31m";
+var reset = "\x1B[0m";
+var blue = "\x1B[34m";
+function formatResult(result) {
+  const icon = result.status === "ok" ? `${green}\u2713${reset}` : result.status === "warn" ? `${yellow}\u26A0${reset}` : `${red}\u2717${reset}`;
+  return `${icon} ${result.name}: ${result.message}`;
+}
+async function checkConfig(workspaceDir) {
+  const configPath = join(workspaceDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return {
+      name: "Config file",
+      status: "error",
+      message: `Not found at ${configPath}`
+    };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const raw = parse(content);
+    const result = ConfigSchema.safeParse(raw);
+    if (!result.success) {
+      return {
+        name: "Config file",
+        status: "error",
+        message: `Invalid: ${result.error.issues[0]?.message || "Unknown error"}`
+      };
+    }
+    return {
+      name: "Config file",
+      status: "ok",
+      message: "Valid"
+    };
+  } catch (err) {
+    return {
+      name: "Config file",
+      status: "error",
+      message: `Parse error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function checkTelegramCredentials(workspaceDir) {
+  const configPath = join(workspaceDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return {
+      name: "Telegram credentials",
+      status: "error",
+      message: "Config not found"
+    };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = parse(content);
+    if (!config.telegram?.api_id || !config.telegram?.api_hash) {
+      return {
+        name: "Telegram credentials",
+        status: "error",
+        message: "Missing API ID or API Hash"
+      };
+    }
+    if (!config.telegram?.phone) {
+      return {
+        name: "Telegram credentials",
+        status: "error",
+        message: "Missing phone number"
+      };
+    }
+    return {
+      name: "Telegram credentials",
+      status: "ok",
+      message: `Phone: ${config.telegram.phone}`
+    };
+  } catch {
+    return {
+      name: "Telegram credentials",
+      status: "error",
+      message: "Could not read config"
+    };
+  }
+}
+async function checkApiKey(workspaceDir) {
+  const configPath = join(workspaceDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return {
+      name: "API key",
+      status: "error",
+      message: "Config not found"
+    };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = parse(content);
+    const provider = config.agent?.provider || "anthropic";
+    const apiKey = config.agent?.api_key;
+    let meta;
+    try {
+      meta = getProviderMetadata(provider);
+    } catch {
+      return {
+        name: "API key",
+        status: "error",
+        message: `Unknown provider: ${provider}`
+      };
+    }
+    if (!apiKey) {
+      return {
+        name: `${meta.displayName} API key`,
+        status: "error",
+        message: "Not configured"
+      };
+    }
+    const validationError = validateApiKeyFormat(provider, apiKey);
+    if (validationError) {
+      return {
+        name: `${meta.displayName} API key`,
+        status: "warn",
+        message: validationError
+      };
+    }
+    const maskLen = Math.min(10, apiKey.length - 4);
+    const masked = apiKey.substring(0, maskLen) + "..." + apiKey.substring(apiKey.length - 4);
+    return {
+      name: `${meta.displayName} API key`,
+      status: "ok",
+      message: masked
+    };
+  } catch {
+    return {
+      name: "API key",
+      status: "error",
+      message: "Could not read config"
+    };
+  }
+}
+async function checkWallet(workspaceDir) {
+  const walletPath = join(workspaceDir, "wallet.json");
+  if (!existsSync(walletPath)) {
+    return {
+      name: "TON wallet",
+      status: "warn",
+      message: "Not found (run teleton setup to generate)"
+    };
+  }
+  try {
+    const content = readFileSync(walletPath, "utf-8");
+    const wallet = JSON.parse(content);
+    if (!wallet.address) {
+      return {
+        name: "TON wallet",
+        status: "error",
+        message: "Invalid wallet file (no address)"
+      };
+    }
+    const shortAddr = wallet.address.substring(0, 8) + "..." + wallet.address.substring(wallet.address.length - 6);
+    return {
+      name: "TON wallet",
+      status: "ok",
+      message: shortAddr
+    };
+  } catch {
+    return {
+      name: "TON wallet",
+      status: "error",
+      message: "Could not read wallet file"
+    };
+  }
+}
+async function checkSoul(workspaceDir) {
+  const soulPath = join(workspaceDir, "SOUL.md");
+  if (!existsSync(soulPath)) {
+    return {
+      name: "SOUL.md",
+      status: "warn",
+      message: "Not found (agent will use defaults)"
+    };
+  }
+  try {
+    const stats = statSync(soulPath);
+    const sizeKb = (stats.size / 1024).toFixed(1);
+    return {
+      name: "SOUL.md",
+      status: "ok",
+      message: `${sizeKb} KB`
+    };
+  } catch {
+    return {
+      name: "SOUL.md",
+      status: "error",
+      message: "Could not read file"
+    };
+  }
+}
+async function checkDatabase(workspaceDir) {
+  const dbPath = join(workspaceDir, "memory.db");
+  if (!existsSync(dbPath)) {
+    return {
+      name: "Memory database",
+      status: "warn",
+      message: "Not found (will be created on first start)"
+    };
+  }
+  try {
+    const stats = statSync(dbPath);
+    const sizeMb = (stats.size / 1024 / 1024).toFixed(2);
+    return {
+      name: "Memory database",
+      status: "ok",
+      message: `${sizeMb} MB`
+    };
+  } catch {
+    return {
+      name: "Memory database",
+      status: "error",
+      message: "Could not read database"
+    };
+  }
+}
+async function checkTelegramSession(workspaceDir) {
+  const sessionPath = join(workspaceDir, "telegram_session.txt");
+  if (!existsSync(sessionPath)) {
+    return {
+      name: "Telegram session",
+      status: "warn",
+      message: "Not found (will prompt for login on first start)"
+    };
+  }
+  try {
+    const stats = statSync(sessionPath);
+    const age = Date.now() - stats.mtimeMs;
+    const daysAgo = Math.floor(age / (1e3 * 60 * 60 * 24));
+    if (daysAgo > 30) {
+      return {
+        name: "Telegram session",
+        status: "warn",
+        message: `Last updated ${daysAgo} days ago (may need re-auth)`
+      };
+    }
+    return {
+      name: "Telegram session",
+      status: "ok",
+      message: daysAgo === 0 ? "Active (today)" : `Active (${daysAgo} days ago)`
+    };
+  } catch {
+    return {
+      name: "Telegram session",
+      status: "error",
+      message: "Could not read session"
+    };
+  }
+}
+async function checkMarketData(workspaceDir) {
+  const dbPath = join(workspaceDir, "gifts.db");
+  if (!existsSync(dbPath)) {
+    return {
+      name: "Gift market data",
+      status: "warn",
+      message: "Not found (will fetch on first start)"
+    };
+  }
+  try {
+    const Database = (await import("better-sqlite3")).default;
+    const db = new Database(dbPath, { readonly: true });
+    const collections = db.prepare("SELECT COUNT(*) as count FROM gift_collections").get();
+    const models = db.prepare("SELECT COUNT(*) as count FROM gift_models").get();
+    const lastUpdate = db.prepare("SELECT MAX(updated_at) as last FROM gift_collections").get();
+    db.close();
+    if (!lastUpdate.last) {
+      return {
+        name: "Gift market data",
+        status: "warn",
+        message: "Database empty (no data yet)"
+      };
+    }
+    const lastUpdateTime = (/* @__PURE__ */ new Date(lastUpdate.last + "Z")).getTime();
+    const age = Date.now() - lastUpdateTime;
+    const hoursAgo = Math.floor(age / (1e3 * 60 * 60));
+    const daysAgo = Math.floor(hoursAgo / 24);
+    const dataInfo = `${collections.count} collections, ${models.count} models`;
+    if (daysAgo > 7) {
+      return {
+        name: "Gift market data",
+        status: "warn",
+        message: `Stale (${daysAgo} days old) - ${dataInfo}`
+      };
+    }
+    if (hoursAgo > 24) {
+      return {
+        name: "Gift market data",
+        status: "ok",
+        message: `${daysAgo} day${daysAgo > 1 ? "s" : ""} old - ${dataInfo}`
+      };
+    }
+    return {
+      name: "Gift market data",
+      status: "ok",
+      message: hoursAgo === 0 ? `Fresh (< 1h) - ${dataInfo}` : `${hoursAgo}h old - ${dataInfo}`
+    };
+  } catch (err) {
+    return {
+      name: "Gift market data",
+      status: "error",
+      message: `Database error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function checkModel(workspaceDir) {
+  const configPath = join(workspaceDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return {
+      name: "AI Model",
+      status: "error",
+      message: "Config not found"
+    };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = parse(content);
+    const provider = config.agent?.provider || "anthropic";
+    let model = config.agent?.model;
+    if (!model) {
+      try {
+        model = getProviderMetadata(provider).defaultModel;
+      } catch {
+        model = "unknown";
+      }
+    }
+    return {
+      name: "AI Model",
+      status: "ok",
+      message: `${provider}/${model}`
+    };
+  } catch {
+    return {
+      name: "AI Model",
+      status: "error",
+      message: "Could not read config"
+    };
+  }
+}
+async function checkAdmins(workspaceDir) {
+  const configPath = join(workspaceDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return {
+      name: "Admin users",
+      status: "error",
+      message: "Config not found"
+    };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = parse(content);
+    const admins = config.telegram?.admin_ids || [];
+    if (admins.length === 0) {
+      return {
+        name: "Admin users",
+        status: "warn",
+        message: "None configured (no admin commands available)"
+      };
+    }
+    return {
+      name: "Admin users",
+      status: "ok",
+      message: `${admins.length} user${admins.length > 1 ? "s" : ""}: ${admins.join(", ")}`
+    };
+  } catch {
+    return {
+      name: "Admin users",
+      status: "error",
+      message: "Could not read config"
+    };
+  }
+}
+async function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split(".")[0]);
+  if (major < 20) {
+    return {
+      name: "Node.js",
+      status: "error",
+      message: `${version} (requires >= 20.0.0)`
+    };
+  }
+  return {
+    name: "Node.js",
+    status: "ok",
+    message: version
+  };
+}
+async function checkPlaywrightBrowser() {
+  const homeDir = homedir();
+  const browserPaths = [
+    join(homeDir, ".cache", "ms-playwright", "chromium-*"),
+    join(homeDir, ".cache", "ms-playwright"),
+    join(homeDir, "Library", "Caches", "ms-playwright"),
+    join(homeDir, "AppData", "Local", "ms-playwright")
+  ];
+  for (const basePath of browserPaths) {
+    const checkPath = basePath.replace("/chromium-*", "");
+    if (existsSync(checkPath)) {
+      try {
+        const { readdirSync } = await import("fs");
+        const contents = readdirSync(checkPath);
+        const hasChromium = contents.some((f) => f.startsWith("chromium"));
+        if (hasChromium) {
+          return {
+            name: "Playwright browser",
+            status: "ok",
+            message: "Chromium installed"
+          };
+        }
+      } catch {
+        return {
+          name: "Playwright browser",
+          status: "ok",
+          message: "Cache found"
+        };
+      }
+    }
+  }
+  return {
+    name: "Playwright browser",
+    status: "warn",
+    message: "Not found (run: npx playwright install chromium)"
+  };
+}
+async function doctorCommand() {
+  const workspaceDir = TELETON_ROOT;
+  console.log(`
+${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+  \u2502  TELETON DOCTOR - System Health Check                       \u2502
+  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518${reset}
+`);
+  console.log(`  Workspace: ${workspaceDir}
+`);
+  const results = [];
+  console.log("  Running checks...\n");
+  results.push(await checkNodeVersion());
+  results.push(await checkPlaywrightBrowser());
+  results.push(await checkConfig(workspaceDir));
+  results.push(await checkTelegramCredentials(workspaceDir));
+  results.push(await checkApiKey(workspaceDir));
+  results.push(await checkTelegramSession(workspaceDir));
+  results.push(await checkWallet(workspaceDir));
+  results.push(await checkSoul(workspaceDir));
+  results.push(await checkDatabase(workspaceDir));
+  results.push(await checkMarketData(workspaceDir));
+  results.push(await checkModel(workspaceDir));
+  results.push(await checkAdmins(workspaceDir));
+  for (const result of results) {
+    console.log(`  ${formatResult(result)}`);
+  }
+  const errors = results.filter((r) => r.status === "error").length;
+  const warnings = results.filter((r) => r.status === "warn").length;
+  const ok = results.filter((r) => r.status === "ok").length;
+  console.log("");
+  if (errors > 0) {
+    console.log(
+      `${red}  \u2717 ${errors} error${errors > 1 ? "s" : ""} found - run 'teleton setup' to fix${reset}`
+    );
+  } else if (warnings > 0) {
+    console.log(
+      `${yellow}  \u26A0 ${warnings} warning${warnings > 1 ? "s" : ""} - agent may work with limited features${reset}`
+    );
+  } else {
+    console.log(`${green}  \u2713 All ${ok} checks passed - system ready${reset}`);
+  }
+  console.log("");
+}
+
+// src/cli/index.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function findPackageJson() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    const candidate = join2(dir, "package.json");
+    if (existsSync2(candidate)) {
+      return JSON.parse(readFileSync2(candidate, "utf-8"));
+    }
+    dir = dirname(dir);
+  }
+  return { version: "0.0.0" };
+}
+var packageJson = findPackageJson();
+var program = new Command();
+program.name("teleton").description("Teleton Agent - Personal AI Agent for Telegram").version(packageJson.version);
+program.command("setup").description("Interactive wizard to set up Teleton").option("--workspace <dir>", "Workspace directory (default: ~/.teleton)").option("--non-interactive", "Non-interactive mode (requires all options)").option("--api-id <id>", "Telegram API ID").option("--api-hash <hash>", "Telegram API Hash").option("--phone <number>", "Phone number (international format)").option("--api-key <key>", "Anthropic API key").option("--user-id <id>", "Your Telegram User ID (for admin)").action(async (options) => {
+  try {
+    await onboardCommand({
+      workspace: options.workspace,
+      nonInteractive: options.nonInteractive,
+      apiId: options.apiId ? parseInt(options.apiId) : void 0,
+      apiHash: options.apiHash,
+      phone: options.phone,
+      apiKey: options.apiKey,
+      userId: options.userId ? parseInt(options.userId) : void 0
+    });
+  } catch (error) {
+    console.error("Erreur:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("start").description("Start the Teleton agent").option("-c, --config <path>", "Config file path", getDefaultConfigPath()).action(async (options) => {
+  try {
+    if (!configExists(options.config)) {
+      console.error("\u274C Configuration non trouv\xE9e");
+      console.error(`   Fichier attendu: ${options.config}`);
+      console.error("\n\u{1F4A1} Lance d'abord: teleton setup");
+      process.exit(1);
+    }
+    await main(options.config);
+  } catch (error) {
+    console.error("Erreur:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("doctor").description("Run system health checks").action(async () => {
+  try {
+    await doctorCommand();
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.action(() => {
+  program.help();
+});
+program.parse(process.argv);