limbo-ai 1.4.0 → 1.6.0

package/README.md

@@ -92,15 +92,18 @@ Managed automatically by `npx limbo-ai start`, stored in `~/.limbo/.env`.
 
 | Variable | Required | Default | Description |
 |----------|----------|---------|-------------|
-| `LLM_API_KEY` | **yes*** | — | API key for your chosen model provider (Anthropic or OpenAI) |
-| `ANTHROPIC_API_KEY` | **yes*** | — | Legacy alias for `LLM_API_KEY` — accepted for backwards compatibility |
-| `MODEL_PROVIDER` | no | `anthropic` | Model provider: `anthropic` or `openai` |
-| `MODEL_NAME` | no | `claude-sonnet-4-6` | Model name (e.g. `claude-sonnet-4-6`, `codex-mini-latest`, `gpt-4o`) |
+| `AUTH_MODE` | no | `api-key` | `api-key` or `subscription` |
+| `OPENAI_API_KEY` | no* | — | OpenAI API key for `MODEL_PROVIDER=openai` |
+| `ANTHROPIC_API_KEY` | no* | — | Anthropic API key for `MODEL_PROVIDER=anthropic` |
+| `LLM_API_KEY` | no | — | Legacy generic key path for older installs |
+| `MODEL_PROVIDER` | no | `anthropic` | Model provider: `anthropic`, `openai`, or `openai-codex` |
+| `MODEL_NAME` | no | `claude-opus-4-6` | Model name (e.g. `claude-opus-4-6`, `claude-sonnet-4-6`, `gpt-5.4`) |
 | `TELEGRAM_ENABLED` | no | `false` | Enable Telegram bot integration |
 | `TELEGRAM_BOT_TOKEN` | no | — | Telegram bot token (required if `TELEGRAM_ENABLED=true`) |
 | `TELEGRAM_AUTO_PAIR_FIRST_DM` | no | `true` | Auto-approves the first Telegram DM sender and persists access (MVP-friendly onboarding) |
+| `OPENCLAW_GATEWAY_TOKEN` | no | generated | Stable gateway token for OpenClaw-compatible clients |
 
-> \* Either `LLM_API_KEY` **or** `ANTHROPIC_API_KEY` is required. `LLM_API_KEY` takes precedence if both are set.
+> \* API keys are required only for `AUTH_MODE=api-key`. Subscription auth uses OpenClaw auth profiles instead.
 
 ---
 

package/cli.js

@@ -5,10 +5,11 @@
 'use strict';
 
 const { execSync, spawnSync } = require('child_process');
+const crypto = require('crypto');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const readline = require('readline');
-const os = require('os');
 
 // ─── Config ──────────────────────────────────────────────────────────────────
 
@@ -16,20 +17,63 @@ const LIMBO_DIR = path.join(os.homedir(), '.limbo');
 const ENV_FILE = path.join(LIMBO_DIR, '.env');
 const COMPOSE_FILE = path.join(LIMBO_DIR, 'docker-compose.yml');
 const GHCR_IMAGE = 'ghcr.io/tomasward1/limbo';
-const DEFAULT_TAG = '1.0.0';
+const DEFAULT_TAG = require('./package.json').version;
 const PORT = 18789;
 
+// OpenClaw compatibility snapshots from official docs:
+// - https://docs.openclaw.ai/providers/openai
+// - https://docs.openclaw.ai/providers/anthropic
+// - https://docs.openclaw.ai/start/wizard-cli-reference
+const MODEL_CATALOG = {
+  'openai:subscription': {
+    provider: 'openai-codex',
+    defaultModel: 'gpt-5.4',
+    menuModels: ['gpt-5.4'],
+    supportedModels: ['gpt-5.4', 'gpt-5.3-codex'],
+  },
+  'openai:api-key': {
+    provider: 'openai',
+    defaultModel: 'gpt-5.4',
+    menuModels: ['gpt-5.4', 'gpt-5.4-pro'],
+    supportedModels: ['gpt-5.4', 'gpt-5.4-pro', 'gpt-5.1-codex'],
+  },
+  'anthropic:subscription': {
+    provider: 'anthropic',
+    defaultModel: 'claude-opus-4-6',
+    menuModels: ['claude-opus-4-6', 'claude-sonnet-4-6'],
+    supportedModels: ['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-opus-4-1', 'claude-sonnet-4'],
+  },
+  'anthropic:api-key': {
+    provider: 'anthropic',
+    defaultModel: 'claude-opus-4-6',
+    menuModels: ['claude-opus-4-6', 'claude-sonnet-4-6'],
+    supportedModels: ['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-opus-4-1', 'claude-sonnet-4'],
+  },
+};
+
+const ASCII_ART = String.raw`
+ _     ___ __  __ ____   ___
+| |   |_ _|  \/  | __ ) / _ \
+| |    | || |\/| |  _ \| | | |
+| |___ | || |  | | |_) | |_| |
+|_____|___|_|  |_|____/ \___/
+`;
+
 // docker-compose.yml written to ~/.limbo on install
 const COMPOSE_CONTENT = `services:
   limbo:
-    image: ${GHCR_IMAGE}:\${LIMBO_IMAGE_TAG:-${DEFAULT_TAG}}
+    image: ${GHCR_IMAGE}:${DEFAULT_TAG}
     restart: unless-stopped
     ports:
       - "127.0.0.1:${PORT}:${PORT}"
     volumes:
       - limbo-data:/data
+      - limbo-openclaw-state:/home/limbo/.openclaw
     env_file:
       - .env
+    environment:
+      OPENCLAW_CONFIG_PATH: /home/limbo/.openclaw/openclaw.json
+      OPENCLAW_STATE_DIR: /home/limbo/.openclaw
     healthcheck:
       test:
         - CMD-SHELL
@@ -43,27 +87,197 @@ const COMPOSE_CONTENT = `services:
 
 volumes:
   limbo-data:
+  limbo-openclaw-state:
 `;
 
+const TEXT = {
+  en: {
+    languageName: 'English',
+    chooseLanguage: 'Choose your language',
+    menuHelp: 'Use arrow keys and press Enter.',
+    providerQuestion: 'AI Provider',
+    providerOpenAI: 'Codex (OpenAI)',
+    providerAnthropic: 'Claude (Anthropic)',
+    accessMethodQuestion: 'Access method',
+    accessSubscriptionOpenAI: 'ChatGPT / Codex subscription',
+    accessSubscriptionAnthropic: 'Claude Code subscription',
+    accessApiKey: 'API token',
+    modelQuestion: 'Model',
+    customModel: 'Add another supported model name',
+    customModelPrompt: '  Model name: ',
+    invalidModel: 'That model is not in the current OpenClaw docs allowlist for this provider/auth path.',
+    supportedModels: 'Supported models:',
+    openAiApiKeyPrompt: '  OpenAI API key (sk-...): ',
+    anthropicApiKeyPrompt: '  Anthropic API key (sk-ant-...): ',
+    requiredField: 'This field is required.',
+    invalidOpenAIKey: 'OpenAI API keys usually start with "sk-".',
+    invalidAnthropicKey: 'Anthropic API keys usually start with "sk-ant-".',
+    telegramQuestion: 'Want to speak to Limbo through Telegram?',
+    telegramTokenPrompt: '  Telegram bot token: ',
+    yes: 'Yes',
+    no: 'No',
+    configuration: 'Configuration',
+    reconfiguration: 'Reconfiguration',
+    foundExistingConfig: `Found existing config at ${ENV_FILE}`,
+    reconfigureHint: 'Starting with existing config. Use --reconfigure to change settings.',
+    envWritten: '.env written.',
+    pullingImage: 'Pulling image...',
+    imagePulled: 'Image pulled.',
+    pullFailed: 'Could not pull from GHCR. Trying local build fallback...',
+    buildingFallback: 'Building from local Dockerfile...',
+    buildOk: (tag) => `Built: ${GHCR_IMAGE}:${tag}`,
+    starting: 'Starting Limbo...',
+    verifying: 'Verifying health...',
+    waitingHealth: (i, max) => `Waiting for container to be healthy... (${i}/${max})`,
+    healthTimeout: 'Container did not report healthy within timeout.',
+    logsHint: 'Check logs with: limbo logs',
+    healthy: 'Container is healthy.',
+    subscriptionSetup: 'Provider authentication',
+    openaiSubscriptionIntro: 'Limbo will open OpenClaw auth inside the container so you can complete Codex login.',
+    anthropicSubscriptionIntro: 'Generate a Claude setup-token on any machine with `claude setup-token`, then paste it into the next step.',
+    authFlowStart: 'Starting provider auth flow...',
+    authFlowDone: 'Provider auth completed.',
+    authFlowFailed: 'Provider auth did not complete successfully.',
+    authStatusFailed: 'OpenClaw still reports missing or invalid auth for the selected provider.',
+    configFlowStart: 'Applying OpenClaw config...',
+    configFlowDone: 'OpenClaw config updated.',
+    configFlowFailed: 'Could not update the OpenClaw config for Limbo.',
+    success: 'Limbo is running!',
+    gateway: 'Gateway',
+    gatewayToken: 'Gateway token',
+    data: 'Data',
+    logs: 'Logs',
+    stop: 'Stop',
+    update: 'Update',
+    telegramEnabledHint: 'Telegram is enabled. Message your bot to start talking to Limbo.',
+    nonTelegramHintTitle: 'No Telegram? You can still talk to Limbo through another agent.',
+    nonTelegramPromptIntro: 'Suggested prompt:',
+    nonTelegramPrompt: (token) => `Connect to my Limbo gateway at ws://127.0.0.1:${PORT} using token ${token}. Use Limbo as my memory layer: save notes, recall context, and update maps of content when I ask.`,
+    dockerMissing: 'Docker is not installed or `docker compose` is unavailable.\nInstall Docker Desktop: https://docs.docker.com/get-docker/',
+    installMissing: 'Limbo is not installed. Run: npx limbo start',
+    helpTitle: 'limbo - personal AI memory agent',
+    usage: 'Usage',
+    commands: 'Commands',
+    flags: 'Flags',
+    dataDirectory: 'Data directory',
+    helpStart: 'Install and start Limbo (default if no command given)',
+    helpStop: 'Stop the running container',
+    helpLogs: 'Tail container logs',
+    helpUpdate: 'Pull latest image and restart',
+    helpStatus: 'Show container status',
+    helpHelp: 'Show this help',
+    helpReconfigure: 'Reconfigure auth and onboarding settings (use with start)',
+    unknownCommand: (cmd) => `Unknown command: ${cmd}`,
+  },
+  es: {
+    languageName: 'Espanol',
+    chooseLanguage: 'Elige tu idioma',
+    menuHelp: 'Usa las flechas y Enter.',
+    providerQuestion: 'AI Provider',
+    providerOpenAI: 'Codex (OpenAI)',
+    providerAnthropic: 'Claude (Anthropic)',
+    accessMethodQuestion: 'Metodo de acceso',
+    accessSubscriptionOpenAI: 'Suscripcion ChatGPT / Codex',
+    accessSubscriptionAnthropic: 'Suscripcion Claude Code',
+    accessApiKey: 'API token',
+    modelQuestion: 'Modelo',
+    customModel: 'Agregar otro nombre de modelo soportado',
+    customModelPrompt: '  Nombre del modelo: ',
+    invalidModel: 'Ese modelo no esta en la allowlist actual de OpenClaw para este provider y metodo.',
+    supportedModels: 'Modelos soportados:',
+    openAiApiKeyPrompt: '  OpenAI API key (sk-...): ',
+    anthropicApiKeyPrompt: '  Anthropic API key (sk-ant-...): ',
+    requiredField: 'Este campo es obligatorio.',
+    invalidOpenAIKey: 'Las API keys de OpenAI normalmente empiezan con "sk-".',
+    invalidAnthropicKey: 'Las API keys de Anthropic normalmente empiezan con "sk-ant-".',
+    telegramQuestion: 'Quieres hablar con Limbo por Telegram?',
+    telegramTokenPrompt: '  Telegram bot token: ',
+    yes: 'Si',
+    no: 'No',
+    configuration: 'Configuracion',
+    reconfiguration: 'Reconfiguracion',
+    foundExistingConfig: `Se encontro una configuracion existente en ${ENV_FILE}`,
+    reconfigureHint: 'Se va a usar la configuracion actual. Usa --reconfigure para cambiarla.',
+    envWritten: '.env escrito.',
+    pullingImage: 'Bajando imagen...',
+    imagePulled: 'Imagen descargada.',
+    pullFailed: 'No se pudo bajar la imagen desde GHCR. Probando build local...',
+    buildingFallback: 'Construyendo desde el Dockerfile local...',
+    buildOk: (tag) => `Imagen construida: ${GHCR_IMAGE}:${tag}`,
+    starting: 'Arrancando Limbo...',
+    verifying: 'Verificando health...',
+    waitingHealth: (i, max) => `Esperando a que el container quede healthy... (${i}/${max})`,
+    healthTimeout: 'El container no reporto healthy dentro del timeout.',
+    logsHint: 'Mira los logs con: limbo logs',
+    healthy: 'El container esta healthy.',
+    subscriptionSetup: 'Autenticacion del provider',
+    openaiSubscriptionIntro: 'Limbo va a abrir la autenticacion de OpenClaw dentro del container para que completes el login de Codex.',
+    anthropicSubscriptionIntro: 'Genera un Claude setup-token en cualquier maquina con `claude setup-token` y pegalo en el siguiente paso.',
+    authFlowStart: 'Iniciando autenticacion del provider...',
+    authFlowDone: 'Autenticacion del provider completada.',
+    authFlowFailed: 'La autenticacion del provider no termino correctamente.',
+    authStatusFailed: 'OpenClaw sigue reportando auth faltante o invalida para el provider elegido.',
+    configFlowStart: 'Aplicando configuracion de OpenClaw...',
+    configFlowDone: 'Configuracion de OpenClaw actualizada.',
+    configFlowFailed: 'No se pudo actualizar la configuracion de OpenClaw para Limbo.',
+    success: 'Limbo esta corriendo!',
+    gateway: 'Gateway',
+    gatewayToken: 'Token del gateway',
+    data: 'Data',
+    logs: 'Logs',
+    stop: 'Stop',
+    update: 'Update',
+    telegramEnabledHint: 'Telegram esta habilitado. Escribile a tu bot para empezar a hablar con Limbo.',
+    nonTelegramHintTitle: 'Sin Telegram? Igual puedes hablar con Limbo desde otro agente.',
+    nonTelegramPromptIntro: 'Prompt sugerido:',
+    nonTelegramPrompt: (token) => `Conectate a mi gateway de Limbo en ws://127.0.0.1:${PORT} usando el token ${token}. Usa Limbo como mi capa de memoria: guarda notas, recupera contexto y actualiza maps of content cuando yo lo pida.`,
+    dockerMissing: 'Docker no esta instalado o `docker compose` no esta disponible.\nInstala Docker Desktop: https://docs.docker.com/get-docker/',
+    installMissing: 'Limbo no esta instalado. Corre: npx limbo start',
+    helpTitle: 'limbo - agente personal de memoria con AI',
+    usage: 'Uso',
+    commands: 'Comandos',
+    flags: 'Flags',
+    dataDirectory: 'Directorio de data',
+    helpStart: 'Instala y arranca Limbo (default si no pasas comando)',
+    helpStop: 'Frena el container',
+    helpLogs: 'Sigue los logs del container',
+    helpUpdate: 'Baja la ultima imagen y reinicia',
+    helpStatus: 'Muestra el estado del container',
+    helpHelp: 'Muestra esta ayuda',
+    helpReconfigure: 'Reconfigura auth y onboarding (usar con start)',
+    unknownCommand: (cmd) => `Comando desconocido: ${cmd}`,
+  },
+};
+
 // ─── Colors ──────────────────────────────────────────────────────────────────
 
 const c = {
   reset: '\x1b[0m',
-  bold:  '\x1b[1m',
-  cyan:  '\x1b[36m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
   green: '\x1b[32m',
   yellow: '\x1b[33m',
-  red:   '\x1b[31m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
 };
 
-const log   = (msg) => console.log(`${c.cyan}[limbo]${c.reset} ${msg}`);
-const ok    = (msg) => console.log(`${c.green}[limbo]${c.reset} ${msg}`);
-const warn  = (msg) => console.log(`${c.yellow}[limbo]${c.reset} ${msg}`);
-const die   = (msg) => { console.error(`${c.red}[limbo] ERROR:${c.reset} ${msg}`); process.exit(1); };
+const log = (msg) => console.log(`${c.cyan}[limbo]${c.reset} ${msg}`);
+const ok = (msg) => console.log(`${c.green}[limbo]${c.reset} ${msg}`);
+const warn = (msg) => console.log(`${c.yellow}[limbo]${c.reset} ${msg}`);
+const die = (msg) => { console.error(`${c.red}[limbo] ERROR:${c.reset} ${msg}`); process.exit(1); };
 const header = (msg) => console.log(`\n${c.bold}${msg}${c.reset}`);
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
+function t(lang, key, ...args) {
+  const value = TEXT[lang][key];
+  return typeof value === 'function' ? value(...args) : value;
+}
+
+function sleep(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
 function hasDocker() {
   const result = spawnSync('docker', ['compose', 'version'], { stdio: 'pipe' });
   return result.status === 0;
@@ -77,161 +291,506 @@ function runQuiet(cmd) {
   return execSync(cmd, { stdio: 'pipe', cwd: LIMBO_DIR }).toString().trim();
 }
 
+function runDockerCompose(args, opts = {}) {
+  const result = spawnSync('docker', ['compose', ...args], {
+    cwd: LIMBO_DIR,
+    stdio: opts.stdio || 'inherit',
+    input: opts.input,
+    encoding: opts.encoding || 'utf8',
+  });
+
+  if (result.error) throw result.error;
+  return result;
+}
+
 function prompt(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
 
-async function collectConfig() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+function createPromptInterface() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
 
-  console.log('Limbo supports Anthropic (Claude) and OpenAI as model providers.');
-  console.log('Telegram integration is optional — press Enter to skip.\n');
+async function promptValidated(rl, question, validate, errorMessage) {
+  while (true) {
+    const value = (await prompt(rl, question)).trim();
+    const validation = validate(value);
+    if (validation.ok) return validation.value;
+    warn(validation.message || errorMessage);
+  }
+}
 
-  const provider = (await prompt(rl, '  Model provider (anthropic/openai) [anthropic]: ')).trim() || 'anthropic';
-  const isOpenAI = provider === 'openai';
-  const defaultModel = isOpenAI ? 'codex-mini-latest' : 'claude-sonnet-4-6';
-  const keyLabel = isOpenAI ? 'OpenAI API key (sk-...)' : 'Anthropic API key (sk-ant-...)';
+function renderMenu(question, options, selectedIndex, lang) {
+  const lines = [`${c.bold}${question}${c.reset}`, `${c.dim}${t(lang, 'menuHelp')}${c.reset}`, ''];
+  options.forEach((option, index) => {
+    const prefix = index === selectedIndex ? `${c.green}>${c.reset}` : ' ';
+    lines.push(`${prefix} ${option.label}`);
+    if (option.description) lines.push(`   ${c.dim}${option.description}${c.reset}`);
+  });
+  return lines.join('\n');
+}
 
-  let llmKey = '';
-  while (!llmKey) {
-    llmKey = (await prompt(rl, `  ${keyLabel}: `)).trim();
-    if (!llmKey) warn('This field is required.');
+async function selectMenu(question, options, lang) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== 'function') {
+    const rl = createPromptInterface();
+    while (true) {
+      console.log(`\n${question}`);
+      options.forEach((option, index) => console.log(`  ${index + 1}. ${option.label}`));
+      const raw = (await prompt(rl, '  > ')).trim();
+      const selected = Number(raw);
+      if (Number.isInteger(selected) && selected >= 1 && selected <= options.length) {
+        rl.close();
+        return options[selected - 1];
+      }
+      warn('Pick one of the listed options.');
+    }
   }
 
-  const modelName = (await prompt(rl, `  Model name [${defaultModel}]: `)).trim() || defaultModel;
-  const tgRaw = (await prompt(rl, '  Enable Telegram bot? (true/false) [false]: ')).trim() || 'false';
-  const telegramEnabled = tgRaw === 'true' ? 'true' : 'false';
-  let telegramToken = '';
-  if (telegramEnabled === 'true') {
-    while (!telegramToken) {
-      telegramToken = (await prompt(rl, '  Telegram bot token: ')).trim();
-      if (!telegramToken) warn('This field is required when Telegram is enabled.');
+  return new Promise((resolve) => {
+    let selectedIndex = 0;
+    let lastRenderLineCount = 0;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    readline.emitKeypressEvents(process.stdin, rl);
+    const previousRawMode = process.stdin.isRaw;
+    process.stdin.setRawMode(true);
+
+    function cleanup() {
+      process.stdin.off('keypress', onKeypress);
+      process.stdin.setRawMode(Boolean(previousRawMode));
+      rl.close();
+      process.stdout.write('\n');
     }
-  }
 
-  const tag = (await prompt(rl, `  Image tag [${DEFAULT_TAG}]: `)).trim() || DEFAULT_TAG;
+    function draw() {
+      const output = renderMenu(question, options, selectedIndex, lang);
+      if (lastRenderLineCount > 0) {
+        readline.moveCursor(process.stdout, 0, -lastRenderLineCount);
+      }
+      for (let i = 0; i < lastRenderLineCount; i++) {
+        readline.clearLine(process.stdout, 0);
+        if (i < lastRenderLineCount - 1) readline.moveCursor(process.stdout, 0, 1);
+      }
+      if (lastRenderLineCount > 0) {
+        readline.moveCursor(process.stdout, 0, -Math.max(lastRenderLineCount - 1, 0));
+      }
+      readline.cursorTo(process.stdout, 0);
+      process.stdout.write(output);
+      lastRenderLineCount = output.split('\n').length;
+    }
 
-  rl.close();
-  return { provider: isOpenAI ? 'openai' : 'anthropic', llmKey, modelName, telegramEnabled, telegramToken, tag };
-}
-
-function writeEnv({ provider, llmKey, modelName, telegramEnabled, telegramToken, tag }) {
-  const content = [
-    `LLM_API_KEY=${llmKey}`,
-    `MODEL_PROVIDER=${provider}`,
-    `MODEL_NAME=${modelName}`,
-    `TELEGRAM_ENABLED=${telegramEnabled}`,
-    `TELEGRAM_BOT_TOKEN=${telegramToken}`,
-    `LIMBO_IMAGE_TAG=${tag}`,
-  ].join('\n') + '\n';
+    function onKeypress(_, key = {}) {
+      if (key.name === 'up' || key.name === 'k') {
+        selectedIndex = selectedIndex === 0 ? options.length - 1 : selectedIndex - 1;
+        draw();
+        return;
+      }
+
+      if (key.name === 'down' || key.name === 'j') {
+        selectedIndex = selectedIndex === options.length - 1 ? 0 : selectedIndex + 1;
+        draw();
+        return;
+      }
+
+      if (key.name === 'return') {
+        const value = options[selectedIndex];
+        cleanup();
+        resolve(value);
+        return;
+      }
+
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        process.exit(130);
+      }
+    }
+
+    process.stdin.on('keypress', onKeypress);
+    draw();
+  });
+}
+
+function parseEnvFile() {
+  if (!fs.existsSync(ENV_FILE)) return {};
+  return fs.readFileSync(ENV_FILE, 'utf8')
+    .split('\n')
+    .filter((line) => line && !line.startsWith('#') && line.includes('='))
+    .reduce((acc, line) => {
+      const idx = line.indexOf('=');
+      acc[line.slice(0, idx)] = line.slice(idx + 1);
+      return acc;
+    }, {});
+}
+
+function generateGatewayToken() {
+  return crypto.randomBytes(24).toString('base64url');
+}
+
+function normalizeConfig(cfg, existingEnv = {}) {
+  const gatewayToken = cfg.gatewayToken || existingEnv.OPENCLAW_GATEWAY_TOKEN || generateGatewayToken();
+  const base = {
+    CLI_LANGUAGE: cfg.language || existingEnv.CLI_LANGUAGE || 'en',
+    AUTH_MODE: cfg.authMode || existingEnv.AUTH_MODE || 'api-key',
+    MODEL_PROVIDER: cfg.provider || existingEnv.MODEL_PROVIDER || 'anthropic',
+    MODEL_NAME: cfg.modelName || existingEnv.MODEL_NAME || 'claude-opus-4-6',
+    OPENAI_API_KEY: cfg.provider === 'openai' && cfg.apiKey ? cfg.apiKey : (cfg.keepExisting ? existingEnv.OPENAI_API_KEY || '' : ''),
+    ANTHROPIC_API_KEY: cfg.provider === 'anthropic' && cfg.apiKey ? cfg.apiKey : (cfg.keepExisting ? existingEnv.ANTHROPIC_API_KEY || '' : ''),
+    LLM_API_KEY: cfg.apiKey || (cfg.keepExisting ? existingEnv.LLM_API_KEY || '' : ''),
+    TELEGRAM_ENABLED: cfg.telegramEnabled || existingEnv.TELEGRAM_ENABLED || 'false',
+    TELEGRAM_BOT_TOKEN: cfg.telegramToken || (cfg.keepExisting ? existingEnv.TELEGRAM_BOT_TOKEN || '' : ''),
+    TELEGRAM_AUTO_PAIR_FIRST_DM: existingEnv.TELEGRAM_AUTO_PAIR_FIRST_DM || 'true',
+    OPENCLAW_GATEWAY_TOKEN: gatewayToken,
+  };
+
+  return base;
+}
+
+function writeEnv(cfg, existingEnv = {}) {
+  const content = Object.entries(normalizeConfig(cfg, existingEnv))
+    .map(([key, value]) => `${key}=${value}`)
+    .join('\n') + '\n';
   fs.writeFileSync(ENV_FILE, content, { mode: 0o600 });
 }
 
-function waitForHealthy(maxAttempts = 12) {
+function waitForHealthy(lang, maxAttempts = 12) {
   for (let i = 1; i <= maxAttempts; i++) {
     try {
       const raw = runQuiet('docker compose ps --format json');
       if (raw.includes('"healthy"')) return true;
     } catch {}
-    log(`Waiting for container to be healthy... (${i}/${maxAttempts})`);
-    // simple sync sleep
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5000);
+    log(t(lang, 'waitingHealth', i, maxAttempts));
+    sleep(5000);
   }
   return false;
 }
 
-// ─── Commands ────────────────────────────────────────────────────────────────
+function getModelCatalog(providerFamily, authMode) {
+  return MODEL_CATALOG[`${providerFamily}:${authMode}`];
+}
 
-async function cmdStart() {
-  header('=== Limbo ===');
+async function chooseModel(lang, providerFamily, authMode) {
+  const catalog = getModelCatalog(providerFamily, authMode);
+  const options = catalog.menuModels.map((model) => ({ label: model, value: model }));
+  options.push({ label: t(lang, 'customModel'), value: '__custom__' });
+
+  const selection = await selectMenu(t(lang, 'modelQuestion'), options, lang);
+  if (selection.value !== '__custom__') return selection.value;
 
-  if (!hasDocker()) {
-    die('Docker is not installed or `docker compose` is unavailable.\nInstall Docker Desktop: https://docs.docker.com/get-docker/');
+  const rl = createPromptInterface();
+  while (true) {
+    const modelName = (await prompt(rl, t(lang, 'customModelPrompt'))).trim();
+    if (!modelName) {
+      warn(t(lang, 'requiredField'));
+      continue;
+    }
+    if (catalog.supportedModels.includes(modelName)) {
+      rl.close();
+      return modelName;
+    }
+    warn(t(lang, 'invalidModel'));
+    console.log(`  ${t(lang, 'supportedModels')} ${catalog.supportedModels.join(', ')}`);
+  }
+}
+
+async function collectConfig(existingEnv = {}) {
+  console.log(`${c.cyan}${ASCII_ART}${c.reset}`);
+
+  const language = (await selectMenu(t('en', 'chooseLanguage'), [
+    { label: TEXT.en.languageName, value: 'en' },
+    { label: TEXT.es.languageName, value: 'es' },
+  ], 'en')).value;
+
+  const providerFamily = (await selectMenu(t(language, 'providerQuestion'), [
+    { label: t(language, 'providerOpenAI'), value: 'openai' },
+    { label: t(language, 'providerAnthropic'), value: 'anthropic' },
+  ], language)).value;
+
+  const accessMethod = (await selectMenu(t(language, 'accessMethodQuestion'), [
+    {
+      label: providerFamily === 'openai'
+        ? t(language, 'accessSubscriptionOpenAI')
+        : t(language, 'accessSubscriptionAnthropic'),
+      value: 'subscription',
+    },
+    { label: t(language, 'accessApiKey'), value: 'api-key' },
+  ], language)).value;
+
+  const modelName = await chooseModel(language, providerFamily, accessMethod);
+  const provider = getModelCatalog(providerFamily, accessMethod).provider;
+
+  const rl = createPromptInterface();
+  let apiKey = '';
+
+  if (accessMethod === 'api-key') {
+    if (providerFamily === 'openai') {
+      apiKey = await promptValidated(
+        rl,
+        t(language, 'openAiApiKeyPrompt'),
+        (value) => {
+          if (!value) return { ok: false, message: t(language, 'requiredField') };
+          if (!value.startsWith('sk-')) return { ok: false, message: t(language, 'invalidOpenAIKey') };
+          return { ok: true, value };
+        },
+      );
+    } else {
+      apiKey = await promptValidated(
+        rl,
+        t(language, 'anthropicApiKeyPrompt'),
+        (value) => {
+          if (!value) return { ok: false, message: t(language, 'requiredField') };
+          if (!value.startsWith('sk-ant-')) return { ok: false, message: t(language, 'invalidAnthropicKey') };
+          return { ok: true, value };
+        },
+      );
+    }
   }
 
+  const telegramChoice = await selectMenu(t(language, 'telegramQuestion'), [
+    { label: t(language, 'yes'), value: 'true' },
+    { label: t(language, 'no'), value: 'false' },
+  ], language);
+
+  let telegramToken = '';
+  if (telegramChoice.value === 'true') {
+    telegramToken = await promptValidated(
+      rl,
+      t(language, 'telegramTokenPrompt'),
+      (value) => value ? { ok: true, value } : { ok: false, message: t(language, 'requiredField') },
+    );
+  }
+
+  rl.close();
+
+  return {
+    language,
+    authMode: accessMethod,
+    provider,
+    providerFamily,
+    modelName,
+    apiKey,
+    telegramEnabled: telegramChoice.value,
+    telegramToken,
+    gatewayToken: existingEnv.OPENCLAW_GATEWAY_TOKEN || generateGatewayToken(),
+  };
+}
+
+function ensureComposeFile() {
   fs.mkdirSync(LIMBO_DIR, { recursive: true });
   fs.writeFileSync(COMPOSE_FILE, COMPOSE_CONTENT);
+}
+
+function ensureGatewayToken(existingEnv) {
+  if (existingEnv.OPENCLAW_GATEWAY_TOKEN) return existingEnv.OPENCLAW_GATEWAY_TOKEN;
+  writeEnv({ keepExisting: true }, existingEnv);
+  return parseEnvFile().OPENCLAW_GATEWAY_TOKEN;
+}
+
+function pullOrBuildImage(lang) {
+  header(t(lang, 'pullingImage'));
+  try {
+    run('docker compose pull -q');
+    ok(t(lang, 'imagePulled'));
+  } catch {
+    warn(t(lang, 'pullFailed'));
+    const repoDockerfile = path.join(__dirname, 'Dockerfile');
+    if (!fs.existsSync(repoDockerfile)) {
+      die('Could not pull image and no local Dockerfile found. Check your network or GHCR access.');
+    }
+    log(t(lang, 'buildingFallback'));
+    execSync(`docker build -t ${GHCR_IMAGE}:${DEFAULT_TAG} .`, { stdio: 'inherit', cwd: __dirname });
+    ok(t(lang, 'buildOk', DEFAULT_TAG));
+  }
+}
+
+function runOpenClaw(args, opts = {}) {
+  return runDockerCompose(['run', '--rm', '--entrypoint', 'openclaw', 'limbo', ...args], opts);
+}
+
+function applyOpenClawConfig(cfg) {
+  header(t(cfg.language, 'configFlowStart'));
+
+  const setCommands = [
+    ['config', 'set', 'gateway.mode', 'local'],
+    ['config', 'set', 'gateway.port', String(PORT), '--strict-json'],
+    ['config', 'set', 'gateway.bind', 'loopback'],
+    ['config', 'set', 'gateway.auth.mode', 'token'],
+    ['config', 'set', 'agents.defaults.workspace', '/data/workspace'],
+    ['config', 'set', 'agents.defaults.model.primary', `${cfg.provider}/${cfg.modelName}`],
+  ];
+
+  if (cfg.telegramEnabled === 'true') {
+    setCommands.push(
+      ['config', 'set', 'channels.telegram.enabled', 'true', '--strict-json'],
+      ['config', 'set', 'channels.telegram.botToken', cfg.telegramToken],
+    );
+  }
+
+  for (const command of setCommands) {
+    const result = runOpenClaw(command, { stdio: 'pipe' });
+    if (result.status !== 0) {
+      process.stdout.write(result.stdout || '');
+      process.stderr.write(result.stderr || '');
+      die(t(cfg.language, 'configFlowFailed'));
+    }
+  }
+
+  if (cfg.telegramEnabled !== 'true') {
+    runOpenClaw(['config', 'unset', 'channels.telegram'], { stdio: 'pipe' });
+  }
 
+  const validateResult = runOpenClaw(['config', 'validate'], { stdio: 'pipe' });
+  if (validateResult.status !== 0) {
+    process.stdout.write(validateResult.stdout || '');
+    process.stderr.write(validateResult.stderr || '');
+    die(t(cfg.language, 'configFlowFailed'));
+  }
+
+  ok(t(cfg.language, 'configFlowDone'));
+}
+
+function runSubscriptionAuthFlow(cfg) {
+  header(t(cfg.language, 'subscriptionSetup'));
+  if (cfg.providerFamily === 'openai') {
+    log(t(cfg.language, 'openaiSubscriptionIntro'));
+  } else {
+    log(t(cfg.language, 'anthropicSubscriptionIntro'));
+  }
+  log(t(cfg.language, 'authFlowStart'));
+
+  const authArgs = cfg.providerFamily === 'openai'
+    ? ['models', 'auth', 'login', '--provider', 'openai-codex']
+    : ['models', 'auth', 'paste-token', '--provider', 'anthropic'];
+
+  const authResult = runOpenClaw(authArgs);
+  if (authResult.status !== 0) die(t(cfg.language, 'authFlowFailed'));
+
+  const statusResult = runOpenClaw(
+    ['models', 'status', '--check', '--probe-provider', cfg.provider],
+    { stdio: 'pipe' },
+  );
+
+  if (statusResult.status !== 0) {
+    process.stdout.write(statusResult.stdout || '');
+    process.stderr.write(statusResult.stderr || '');
+    die(t(cfg.language, 'authStatusFailed'));
+  }
+
+  ok(t(cfg.language, 'authFlowDone'));
+}
+
+function printSuccess(cfg, gatewayToken) {
+  console.log(`
+${c.green}${c.bold}╔════════════════════════════════════════════╗${c.reset}
+${c.green}${c.bold}║       ${t(cfg.language, 'success').padEnd(34, ' ')}║${c.reset}
+${c.green}${c.bold}╚════════════════════════════════════════════╝${c.reset}
+
+  ${c.bold}${t(cfg.language, 'gateway')}:${c.reset}        ws://127.0.0.1:${PORT}
+  ${c.bold}${t(cfg.language, 'gatewayToken')}:${c.reset}  ${gatewayToken}
+  ${c.bold}${t(cfg.language, 'data')}:${c.reset}           ${LIMBO_DIR}
+  ${c.bold}${t(cfg.language, 'logs')}:${c.reset}           limbo logs
+  ${c.bold}${t(cfg.language, 'stop')}:${c.reset}           limbo stop
+  ${c.bold}${t(cfg.language, 'update')}:${c.reset}         limbo update
+`);
+
+  if (cfg.telegramEnabled === 'true') {
+    console.log(`  ${t(cfg.language, 'telegramEnabledHint')}`);
+    return;
+  }
+
+  console.log(`  ${t(cfg.language, 'nonTelegramHintTitle')}`);
+  console.log(`  ${t(cfg.language, 'nonTelegramPromptIntro')}`);
+  console.log(`  "${t(cfg.language, 'nonTelegramPrompt', gatewayToken)}"`);
+}
+
+// ─── Commands ────────────────────────────────────────────────────────────────
+
+async function cmdStart() {
+  if (!hasDocker()) die(t('en', 'dockerMissing'));
+
+  ensureComposeFile();
+
+  const existingEnv = parseEnvFile();
   const alreadyHasEnv = fs.existsSync(ENV_FILE);
   let cfg;
+  let lang = existingEnv.CLI_LANGUAGE || 'en';
 
   if (alreadyHasEnv) {
-    log(`Found existing config at ${ENV_FILE}`);
+    log(existingEnv.MODEL_PROVIDER ? t(lang, 'foundExistingConfig') : `Found existing config at ${ENV_FILE}`);
     const reconfig = process.argv.includes('--reconfigure');
     if (!reconfig) {
-      log('Starting with existing config. Use --reconfigure to change settings.');
-      cfg = null; // skip writing
+      lang = existingEnv.CLI_LANGUAGE || 'en';
+      log(t(lang, 'reconfigureHint'));
+      ensureGatewayToken(existingEnv);
+      cfg = {
+        language: lang,
+        provider: existingEnv.MODEL_PROVIDER || 'anthropic',
+        providerFamily: (existingEnv.MODEL_PROVIDER || 'anthropic').startsWith('openai') ? 'openai' : 'anthropic',
+        authMode: existingEnv.AUTH_MODE || 'api-key',
+        modelName: existingEnv.MODEL_NAME || 'claude-opus-4-6',
+        telegramEnabled: existingEnv.TELEGRAM_ENABLED || 'false',
+      };
     } else {
-      header('Reconfiguration');
-      cfg = await collectConfig();
+      header(t(lang, 'reconfiguration'));
+      cfg = await collectConfig(existingEnv);
+      writeEnv({ ...cfg, CLI_LANGUAGE: cfg.language }, existingEnv);
+      ok(t(cfg.language, 'envWritten'));
     }
   } else {
-    header('Configuration');
-    cfg = await collectConfig();
+    header(t('en', 'configuration'));
+    cfg = await collectConfig(existingEnv);
+    writeEnv({ ...cfg, CLI_LANGUAGE: cfg.language }, existingEnv);
+    ok(t(cfg.language, 'envWritten'));
   }
 
-  if (cfg) {
-    writeEnv(cfg);
-    ok('.env written.');
+  const mergedEnv = parseEnvFile();
+  if (!cfg.language) cfg.language = mergedEnv.CLI_LANGUAGE || 'en';
+  if (!mergedEnv.CLI_LANGUAGE) {
+    writeEnv({ ...cfg, keepExisting: true, CLI_LANGUAGE: cfg.language }, mergedEnv);
   }
 
-  header('Pulling image...');
-  try {
-    run('docker compose pull -q');
-    ok('Image pulled.');
-  } catch {
-    warn('Could not pull from GHCR. Is the image public? Trying local build fallback...');
-    // Fallback: build from current directory if we're inside the repo
-    const repoDockerfile = path.join(__dirname, 'Dockerfile');
-    if (fs.existsSync(repoDockerfile)) {
-      log('Building from local Dockerfile...');
-      const tag = cfg?.tag || DEFAULT_TAG;
-      execSync(`docker build -t ${GHCR_IMAGE}:${tag} .`, { stdio: 'inherit', cwd: __dirname });
-      ok(`Built: ${GHCR_IMAGE}:${tag}`);
-    } else {
-      die('Could not pull image and no local Dockerfile found. Check your network or GHCR access.');
-    }
+  pullOrBuildImage(cfg.language);
+
+  if (cfg.authMode === 'subscription' && (process.argv.includes('--reconfigure') || !alreadyHasEnv)) {
+    runSubscriptionAuthFlow(cfg);
   }
 
-  header('Starting Limbo...');
+  applyOpenClawConfig({
+    ...cfg,
+    telegramToken: mergedEnv.TELEGRAM_BOT_TOKEN || cfg.telegramToken || '',
+    telegramEnabled: mergedEnv.TELEGRAM_ENABLED || cfg.telegramEnabled || 'false',
+  });
+
+  header(t(cfg.language, 'starting'));
   run('docker compose up -d --remove-orphans');
 
-  header('Verifying health...');
-  const healthy = waitForHealthy();
+  header(t(cfg.language, 'verifying'));
+  const healthy = waitForHealthy(cfg.language);
   if (!healthy) {
-    warn('Container did not report healthy within timeout.');
-    warn(`Check logs with: limbo logs`);
+    warn(t(cfg.language, 'healthTimeout'));
+    warn(t(cfg.language, 'logsHint'));
   } else {
-    ok('Container is healthy.');
+    ok(t(cfg.language, 'healthy'));
   }
 
-  console.log(`
-${c.green}${c.bold}╔════════════════════════════════════════════╗${c.reset}
-${c.green}${c.bold}║       Limbo is running!                    ║${c.reset}
-${c.green}${c.bold}╚════════════════════════════════════════════╝${c.reset}
-
-  ${c.bold}Gateway:${c.reset}  ws://127.0.0.1:${PORT}
-  ${c.bold}Data:${c.reset}     ${LIMBO_DIR}
-  ${c.bold}Logs:${c.reset}     limbo logs
-  ${c.bold}Stop:${c.reset}     limbo stop
-  ${c.bold}Update:${c.reset}   limbo update
-`);
+  printSuccess({
+    language: cfg.language,
+    telegramEnabled: mergedEnv.TELEGRAM_ENABLED || cfg.telegramEnabled || 'false',
+  }, parseEnvFile().OPENCLAW_GATEWAY_TOKEN);
 }
 
 function cmdStop() {
-  if (!fs.existsSync(COMPOSE_FILE)) die('Limbo is not installed. Run: npx limbo start');
+  if (!fs.existsSync(COMPOSE_FILE)) die(t('en', 'installMissing'));
   log('Stopping Limbo...');
   run('docker compose down');
   ok('Stopped.');
 }
 
 function cmdLogs() {
-  if (!fs.existsSync(COMPOSE_FILE)) die('Limbo is not installed. Run: npx limbo start');
+  if (!fs.existsSync(COMPOSE_FILE)) die(t('en', 'installMissing'));
   run('docker compose logs -f');
 }
 
 function cmdUpdate() {
-  if (!fs.existsSync(COMPOSE_FILE)) die('Limbo is not installed. Run: npx limbo start');
+  if (!fs.existsSync(COMPOSE_FILE)) die(t('en', 'installMissing'));
   log('Pulling latest image...');
   run('docker compose pull -q');
   log('Restarting...');
@@ -249,7 +808,7 @@ function cmdStatus() {
 
 function cmdHelp() {
   console.log(`
-${c.bold}limbo${c.reset} — personal AI memory agent
+${c.bold}limbo${c.reset} - personal AI memory agent
 
 ${c.bold}Usage:${c.reset}
   npx limbo [command]
@@ -263,7 +822,7 @@ ${c.bold}Commands:${c.reset}
   help          Show this help
 
 ${c.bold}Flags:${c.reset}
-  --reconfigure  Reconfigure API keys and settings (use with start)
+  --reconfigure  Reconfigure auth and onboarding settings (use with start)
 
 ${c.bold}Data directory:${c.reset} ${LIMBO_DIR}
 `);
@@ -277,15 +836,15 @@ const [,, cmd = 'start'] = process.argv;
   switch (cmd) {
     case 'start':
     case 'install': await cmdStart(); break;
-    case 'stop':    cmdStop();  break;
-    case 'logs':    cmdLogs();  break;
+    case 'stop':    cmdStop(); break;
+    case 'logs':    cmdLogs(); break;
     case 'update':  cmdUpdate(); break;
     case 'status':  cmdStatus(); break;
     case 'help':
     case '--help':
     case '-h':      cmdHelp(); break;
     default:
-      warn(`Unknown command: ${cmd}`);
+      warn(t('en', 'unknownCommand', cmd));
       cmdHelp();
       process.exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limbo-ai",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Your personal AI memory agent — install and manage Limbo via npx",
   "type": "commonjs",
   "bin": {