limbo-ai 1.22.0 → 1.23.0

package/README.md

@@ -58,10 +58,39 @@ npx limbo-ai@latest update       # Pull latest image and restart
 npx limbo-ai@latest status       # Show container status
 npx limbo-ai@latest logs         # Tail container logs
 npx limbo-ai@latest start --reconfigure   # Change API keys or settings
+npx limbo-ai@latest config               # Configure optional features (voice, web-search)
 ```
 
 ---
 
+## Optional Features
+
+Limbo supports optional features that can be enabled during the setup wizard (step 7) or anytime via the CLI.
+
+### Voice Messages
+
+Transcribe Telegram voice notes using [Groq](https://groq.com) Whisper. Requires a Groq API key (`gsk_...`).
+
+```sh
+npx limbo-ai@latest config voice --enable --api-key gsk_xxx
+npx limbo-ai@latest config voice --status
+npx limbo-ai@latest config voice --disable
+```
+
+### Web Search
+
+Give Limbo real-time web search via the [Brave Search API](https://brave.com/search/api/). Requires a Brave API key (`BSA...`).
+
+```sh
+npx limbo-ai@latest config web-search --enable --api-key BSAxxx
+npx limbo-ai@latest config web-search --status
+npx limbo-ai@latest config web-search --disable
+```
+
+Both features store API keys as Docker secrets and toggle config sections in the container on restart.
+
+---
+
 ## Updating
 
 ```sh
@@ -124,6 +153,8 @@ Managed automatically by `npx limbo-ai start`, stored in `~/.limbo/.env`.
 | `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`) |
+| `VOICE_ENABLED` | no | `false` | Enable voice transcription (requires Groq API key as Docker secret) |
+| `WEB_SEARCH_ENABLED` | no | `false` | Enable web search (requires Brave API key as Docker secret) |
 
 > \* API keys are required only for `AUTH_MODE=api-key`. Subscription auth uses ZeroClaw auth profiles instead.
 

package/cli.js

@@ -318,6 +318,18 @@ const TEXT = {
     openRouterKeyHint: 'Get your key at: https://openrouter.ai/keys',
     openRouterModelPrompt: '  Model name (blank = auto-routing): ',
     openRouterModelHint: 'Examples: anthropic/claude-sonnet-4-6, openai/gpt-4o, google/gemini-2.5-pro',
+    optionalFeatures: 'Optional features',
+    voiceQuestion: 'Enable voice transcription? (Requires Groq API key)',
+    groqApiKeyPrompt: '  Groq API key (gsk_...): ',
+    groqApiKeyHint: 'Get your free key at: https://console.groq.com/keys',
+    invalidGroqKey: 'Groq API keys usually start with "gsk_". Proceeding anyway.',
+    webSearchQuestion: 'Enable web search? (Requires Brave Search API key)',
+    braveApiKeyPrompt: '  Brave API key (BSA...): ',
+    braveApiKeyHint: 'Get your key at: https://brave.com/search/api/',
+    invalidBraveKey: 'Brave API keys usually start with "BSA". Proceeding anyway.',
+    reviewHeader: 'Review your configuration',
+    reviewConfirm: 'Proceed with this configuration?',
+    reviewStartOver: 'Start over',
     telegramQuestion: 'Want to speak to Limbo through Telegram?',
     telegramBotFatherSteps: [
       'To create a Telegram bot:',
@@ -434,6 +446,18 @@ const TEXT = {
     openRouterKeyHint: 'Consegui tu key en: https://openrouter.ai/keys',
     openRouterModelPrompt: '  Nombre del modelo (vacio = auto-routing): ',
     openRouterModelHint: 'Ejemplos: anthropic/claude-sonnet-4-6, openai/gpt-4o, google/gemini-2.5-pro',
+    optionalFeatures: 'Funciones opcionales',
+    voiceQuestion: 'Habilitar transcripcion de voz? (Requiere API key de Groq)',
+    groqApiKeyPrompt: '  Groq API key (gsk_...): ',
+    groqApiKeyHint: 'Consegui tu key gratis en: https://console.groq.com/keys',
+    invalidGroqKey: 'Las API keys de Groq normalmente empiezan con "gsk_". Continuando igual.',
+    webSearchQuestion: 'Habilitar busqueda web? (Requiere API key de Brave Search)',
+    braveApiKeyPrompt: '  Brave API key (BSA...): ',
+    braveApiKeyHint: 'Consegui tu key en: https://brave.com/search/api/',
+    invalidBraveKey: 'Las API keys de Brave normalmente empiezan con "BSA". Continuando igual.',
+    reviewHeader: 'Revisa tu configuracion',
+    reviewConfirm: 'Continuar con esta configuracion?',
+    reviewStartOver: 'Empezar de nuevo',
     telegramQuestion: 'Quieres hablar con Limbo por Telegram?',
     telegramBotFatherSteps: [
       'Para crear un bot de Telegram:',
@@ -902,7 +926,6 @@ async function collectConfig(existingEnv = {}) {
   ], language);
 
   let telegramToken = '';
-  let telegramAutoPair = 'false';
   if (telegramChoice.value === 'true') {
     console.log('');
     TEXT[language].telegramBotFatherSteps.forEach((line) => console.log(`  ${c.dim}${line}${c.reset}`));
@@ -912,11 +935,73 @@ async function collectConfig(existingEnv = {}) {
       t(language, 'telegramTokenPrompt'),
       (value) => value ? { ok: true, value } : { ok: false, message: t(language, 'requiredField') },
     );
-    const autoPairChoice = await selectMenu(t(language, 'telegramAutoPairQuestion'), [
-      { label: t(language, 'no'), value: 'false' },
-      { label: t(language, 'yes'), value: 'true' },
-    ], language);
-    telegramAutoPair = autoPairChoice.value;
+  }
+
+  // ── Optional features ────────────────────────────────────────────────────
+  header(t(language, 'optionalFeatures'));
+
+  let voiceEnabled = 'false';
+  let groqApiKey = '';
+  const voiceChoice = await selectMenu(t(language, 'voiceQuestion'), [
+    { label: t(language, 'no'), value: 'false' },
+    { label: t(language, 'yes'), value: 'true' },
+  ], language);
+  if (voiceChoice.value === 'true') {
+    console.log(`  ${c.dim}${t(language, 'groqApiKeyHint')}${c.reset}`);
+    groqApiKey = await promptValidated(
+      t(language, 'groqApiKeyPrompt'),
+      (value) => {
+        if (!value) return { ok: false, message: t(language, 'requiredField') };
+        if (!value.startsWith('gsk_')) warn(t(language, 'invalidGroqKey'));
+        return { ok: true, value };
+      },
+    );
+    voiceEnabled = 'true';
+  }
+
+  let webSearchEnabled = 'false';
+  let braveApiKey = '';
+  const webSearchChoice = await selectMenu(t(language, 'webSearchQuestion'), [
+    { label: t(language, 'no'), value: 'false' },
+    { label: t(language, 'yes'), value: 'true' },
+  ], language);
+  if (webSearchChoice.value === 'true') {
+    console.log(`  ${c.dim}${t(language, 'braveApiKeyHint')}${c.reset}`);
+    braveApiKey = await promptValidated(
+      t(language, 'braveApiKeyPrompt'),
+      (value) => {
+        if (!value) return { ok: false, message: t(language, 'requiredField') };
+        if (!value.startsWith('BSA')) warn(t(language, 'invalidBraveKey'));
+        return { ok: true, value };
+      },
+    );
+    webSearchEnabled = 'true';
+  }
+
+  // ── Review step ──────────────────────────────────────────────────────────
+  const providerLabel = providerFamily === 'openai' ? 'OpenAI'
+    : providerFamily === 'anthropic' ? 'Anthropic' : 'OpenRouter';
+  const authLabel = accessMethod === 'subscription' ? 'Subscription' : 'API key';
+  const enabledLabel = language === 'es' ? 'habilitado' : 'enabled';
+  const disabledLabel = language === 'es' ? 'deshabilitado' : 'disabled';
+
+  header(t(language, 'reviewHeader'));
+  console.log(`
+  ${c.bold}Provider:${c.reset}      ${providerLabel}
+  ${c.bold}Model:${c.reset}         ${modelName}
+  ${c.bold}Auth:${c.reset}          ${authLabel}
+  ${c.bold}Telegram:${c.reset}      ${telegramChoice.value === 'true' ? `${c.green}${enabledLabel}${c.reset}` : `${c.dim}${disabledLabel}${c.reset}`}
+  ${c.bold}Voice:${c.reset}         ${voiceEnabled === 'true' ? `${c.green}${enabledLabel}${c.reset}` : `${c.dim}${disabledLabel}${c.reset}`}
+  ${c.bold}Web search:${c.reset}    ${webSearchEnabled === 'true' ? `${c.green}${enabledLabel}${c.reset}` : `${c.dim}${disabledLabel}${c.reset}`}
+`);
+
+  const confirmChoice = await selectMenu(t(language, 'reviewConfirm'), [
+    { label: t(language, 'yes'), value: 'confirm' },
+    { label: t(language, 'reviewStartOver'), value: 'restart' },
+  ], language);
+
+  if (confirmChoice.value === 'restart') {
+    return collectConfig(existingEnv);
   }
 
   return {
@@ -928,7 +1013,11 @@ async function collectConfig(existingEnv = {}) {
     apiKey,
     telegramEnabled: telegramChoice.value,
     telegramToken,
-    telegramAutoPair,
+    telegramAutoPair: 'true',
+    voiceEnabled,
+    groqApiKey,
+    webSearchEnabled,
+    braveApiKey,
     gatewayToken: existingEnv.GATEWAY_TOKEN || generateGatewayToken(),
   };
 }
@@ -1067,7 +1156,7 @@ function teardownSetupTunnel(tunnel) {
 function installGlobalAlias() {
   // Create a `limbo` shell wrapper so users don't have to type `npx limbo-ai` every time.
   // Tries /usr/local/bin first (macOS, Linux with sudo), falls back to ~/.local/bin (no sudo).
-  const wrapper = '#!/bin/sh\nexec npx limbo-ai "$@"\n';
+  const wrapper = '#!/bin/sh\nexec npx limbo-ai@latest "$@"\n';
   const candidates = [
     path.join(os.homedir(), '.local', 'bin', 'limbo'),
     '/usr/local/bin/limbo',
@@ -1075,10 +1164,10 @@ function installGlobalAlias() {
 
   for (const target of candidates) {
     try {
-      // Skip if already installed and current
+      // Skip if already installed and current (must include @latest)
       if (fs.existsSync(target)) {
         const existing = fs.readFileSync(target, 'utf8');
-        if (existing.includes('limbo-ai')) return;
+        if (existing.includes('limbo-ai@latest')) return;
       }
       const dir = path.dirname(target);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -1670,9 +1759,32 @@ function cmdLogs() {
   run('docker compose logs -f');
 }
 
+function selfUpdateCli() {
+  const pkg = require('./package.json');
+  try {
+    const latest = execSync('npm view limbo-ai version', { encoding: 'utf8', timeout: 10000 }).trim();
+    if (!latest || latest === pkg.version) return;
+    const cur = pkg.version.split('.').map(Number);
+    const lat = latest.split('.').map(Number);
+    const isNewer = lat[0] > cur[0] || (lat[0] === cur[0] && lat[1] > cur[1]) ||
+      (lat[0] === cur[0] && lat[1] === cur[1] && lat[2] > cur[2]);
+    if (!isNewer) return;
+
+    log(`Updating CLI: ${pkg.version} → ${latest}...`);
+    execSync('npm install -g limbo-ai@latest', { stdio: 'inherit', timeout: 60000 });
+    ok(`CLI updated to ${latest}.`);
+  } catch {
+    warn('Could not self-update CLI. Run: npm install -g limbo-ai@latest');
+  }
+}
+
 function cmdUpdate() {
   if (!fs.existsSync(COMPOSE_FILE)) die(t('en', 'installMissing'));
 
+  // Self-update the CLI if installed globally
+  const isGlobal = !process.argv[1].includes('npx') && !process.argv[1].includes('node_modules/.cache');
+  if (isGlobal) selfUpdateCli();
+
   // Patch image tag to :latest in existing compose files (handles upgrades from pinned tags)
   let compose = fs.readFileSync(COMPOSE_FILE, 'utf8');
   const patched = compose.replace(

package/config.toml.template

@@ -3,7 +3,7 @@
 # conditionally — see entrypoint.sh for details.
 
 default_provider = "${MODEL_PROVIDER}"
-default_model = "${MODEL_PROVIDER}/${MODEL_NAME}"
+default_model = "${ZEROCLAW_MODEL}"
 
 [gateway]
 host = "127.0.0.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limbo-ai",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "Your personal AI memory agent — install and manage Limbo via npx",
   "type": "commonjs",
   "bin": {
@@ -14,7 +14,7 @@
   },
   "scripts": {
     "start": "node cli.js start",
-    "test": "node --test test/cli-filter.test.js test/cli-auth.test.js test/zeroclaw-migration.test.js test/setup-server.test.js"
+    "test": "node --test test/cli-filter.test.js test/cli-auth.test.js test/zeroclaw-migration.test.js test/setup-server.test.js test/cli-wizard-parity.test.js"
   },
   "keywords": [
     "limbo",

package/test/cli-wizard-parity.test.js

@@ -0,0 +1,224 @@
+// test/cli-wizard-parity.test.js — Ensures CLI and setup wizard stay in sync.
+// If this test fails, someone added a feature to one path without the other.
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const cli = require('../cli.js');
+const wizard = require('../setup-server/server.js');
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+// Extract the env var keys that normalizeConfig produces (CLI path).
+function cliEnvKeys() {
+  const cfg = cli.normalizeConfig({
+    language: 'en',
+    authMode: 'api-key',
+    provider: 'anthropic',
+    modelName: 'claude-opus-4-6',
+    apiKey: 'sk-ant-test',
+    telegramEnabled: 'false',
+    telegramToken: '',
+    telegramAutoPair: 'true',
+    voiceEnabled: 'false',
+    webSearchEnabled: 'false',
+    gatewayToken: 'test-token',
+  });
+  return new Set(Object.keys(cfg));
+}
+
+// Extract the env var keys the wizard writes in handleConfigure.
+// We read the source and parse the envVars object keys.
+function wizardEnvKeys() {
+  const src = fs.readFileSync(
+    path.join(__dirname, '..', 'setup-server', 'server.js'),
+    'utf8',
+  );
+  // Match the envVars = { ... } block inside handleConfigure
+  const match = src.match(/const envVars\s*=\s*\{([^}]+)\}/);
+  assert.ok(match, 'could not find envVars block in setup-server/server.js');
+  const keys = [];
+  for (const line of match[1].split('\n')) {
+    const m = line.match(/^\s*([A-Z_]+)\s*:/);
+    if (m) keys.push(m[1]);
+  }
+  return new Set(keys);
+}
+
+// Extract secret file names written by each path.
+function cliSecretNames() {
+  const src = fs.readFileSync(path.join(__dirname, '..', 'cli.js'), 'utf8');
+  // writeSecrets function writes these secret files
+  const match = src.match(/function writeSecrets[\s\S]*?^}/m);
+  assert.ok(match, 'could not find writeSecrets in cli.js');
+  const names = [];
+  for (const m of match[0].matchAll(/writeSecretFile\(['"]([^'"]+)['"]/g)) {
+    names.push(m[1]);
+  }
+  return new Set(names);
+}
+
+function wizardSecretNames() {
+  const src = fs.readFileSync(
+    path.join(__dirname, '..', 'setup-server', 'server.js'),
+    'utf8',
+  );
+  // handleConfigure writes secrets via writeSecretFile
+  const match = src.match(/async function handleConfigure[\s\S]*?^}/m);
+  assert.ok(match, 'could not find handleConfigure in setup-server/server.js');
+  const names = [];
+  for (const m of match[0].matchAll(/writeSecretFile\(['"]([^'"]+)['"]/g)) {
+    names.push(m[1]);
+  }
+  // gateway_token is written via ensureGatewayToken, not directly
+  names.push('gateway_token');
+  return new Set(names);
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('CLI ↔ Wizard parity', () => {
+
+  // --- Env vars ---
+
+  it('wizard writes every env var that CLI normalizeConfig produces (minus secrets)', () => {
+    const cliKeys = cliEnvKeys();
+    const wizKeys = wizardEnvKeys();
+
+    // CLI normalizeConfig includes secret-adjacent keys (LLM_API_KEY, OPENAI_API_KEY, etc.)
+    // that the wizard writes to secret files instead of .env. Filter those out.
+    const secretAdjacentKeys = new Set([
+      'LLM_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY',
+      'TELEGRAM_BOT_TOKEN', 'GATEWAY_TOKEN',
+      // TELEGRAM_AUTO_PAIR_FIRST_DM is set by CLI but wizard handles auto-pair implicitly
+      'TELEGRAM_AUTO_PAIR_FIRST_DM',
+    ]);
+
+    const cliNonSecret = new Set([...cliKeys].filter(k => !secretAdjacentKeys.has(k)));
+
+    for (const key of cliNonSecret) {
+      assert.ok(
+        wizKeys.has(key),
+        `CLI writes env var "${key}" but wizard does not. Add it to handleConfigure's envVars.`,
+      );
+    }
+  });
+
+  it('CLI writes every env var that wizard produces', () => {
+    const cliKeys = cliEnvKeys();
+    const wizKeys = wizardEnvKeys();
+
+    for (const key of wizKeys) {
+      assert.ok(
+        cliKeys.has(key),
+        `Wizard writes env var "${key}" but CLI normalizeConfig does not. Add it to normalizeConfig.`,
+      );
+    }
+  });
+
+  // --- Secrets ---
+
+  it('both paths write the same secret files', () => {
+    const cliSec = cliSecretNames();
+    const wizSec = wizardSecretNames();
+
+    for (const name of cliSec) {
+      assert.ok(
+        wizSec.has(name),
+        `CLI writes secret "${name}" but wizard does not. Add writeSecretFile('${name}', ...) to handleConfigure.`,
+      );
+    }
+    for (const name of wizSec) {
+      assert.ok(
+        cliSec.has(name),
+        `Wizard writes secret "${name}" but CLI does not. Add writeSecretFile('${name}', ...) to writeSecrets.`,
+      );
+    }
+  });
+
+  // --- Providers ---
+
+  it('both paths support the same set of providers', () => {
+    const cliProviders = new Set(
+      Object.keys(cli.MODEL_CATALOG).map(k => k.split(':')[0]),
+    );
+    const wizProviders = new Set(Object.keys(wizard.MODEL_CATALOG));
+
+    for (const p of cliProviders) {
+      assert.ok(
+        wizProviders.has(p),
+        `CLI supports provider "${p}" but wizard MODEL_CATALOG does not.`,
+      );
+    }
+    for (const p of wizProviders) {
+      assert.ok(
+        cliProviders.has(p),
+        `Wizard supports provider "${p}" but CLI MODEL_CATALOG does not.`,
+      );
+    }
+  });
+
+  // --- Auth modes ---
+
+  it('CLI MODEL_CATALOG covers both api-key and subscription for non-openrouter providers', () => {
+    const cliKeys = Object.keys(cli.MODEL_CATALOG);
+    for (const provider of ['openai', 'anthropic']) {
+      assert.ok(
+        cliKeys.includes(`${provider}:api-key`),
+        `CLI missing "${provider}:api-key" catalog entry`,
+      );
+      assert.ok(
+        cliKeys.includes(`${provider}:subscription`),
+        `CLI missing "${provider}:subscription" catalog entry`,
+      );
+    }
+  });
+
+  // --- i18n ---
+
+  it('CLI TEXT has the same keys in English and Spanish', () => {
+    // We need to read the source to extract TEXT keys since TEXT is not exported
+    const src = fs.readFileSync(path.join(__dirname, '..', 'cli.js'), 'utf8');
+
+    function extractTextKeys(lang) {
+      // Find the start of the language block
+      const blockStart = src.indexOf(`  ${lang}: {`);
+      assert.ok(blockStart !== -1, `could not find TEXT.${lang} block`);
+      // Find matching closing brace by counting braces
+      let depth = 0;
+      let start = -1;
+      for (let i = blockStart; i < src.length; i++) {
+        if (src[i] === '{') {
+          if (start === -1) start = i;
+          depth++;
+        }
+        if (src[i] === '}') {
+          depth--;
+          if (depth === 0) {
+            const block = src.slice(start, i + 1);
+            // Extract top-level keys (simple property names before :)
+            const keys = [];
+            for (const m of block.matchAll(/^\s{4}(\w+)\s*:/gm)) {
+              keys.push(m[1]);
+            }
+            return new Set(keys);
+          }
+        }
+      }
+      assert.fail(`could not parse TEXT.${lang} block`);
+    }
+
+    const enKeys = extractTextKeys('en');
+    const esKeys = extractTextKeys('es');
+
+    for (const key of enKeys) {
+      assert.ok(esKeys.has(key), `TEXT.en has key "${key}" but TEXT.es does not.`);
+    }
+    for (const key of esKeys) {
+      assert.ok(enKeys.has(key), `TEXT.es has key "${key}" but TEXT.en does not.`);
+    }
+  });
+});

package/test/zeroclaw-migration.test.js

@@ -74,7 +74,7 @@ test('config.toml.template does NOT contain unsupported sections', () => {
 
 test('config.toml.template uses envsubst variables', () => {
   const toml = read('config.toml.template');
-  const vars = ['${MODEL_PROVIDER}', '${MODEL_NAME}', '${LIMBO_PORT}'];
+  const vars = ['${MODEL_PROVIDER}', '${ZEROCLAW_MODEL}', '${LIMBO_PORT}'];
   for (const v of vars) {
     assert.ok(toml.includes(v), `Missing envsubst variable: ${v}`);
   }
@@ -108,7 +108,8 @@ test('entrypoint.sh appends channels_config.telegram conditionally', () => {
 
 test('Dockerfile pulls ZeroClaw binary from official image', () => {
   const df = read('Dockerfile');
-  assert.ok(df.includes('FROM ghcr.io/zeroclaw-labs/zeroclaw:latest AS zeroclaw'));
+  assert.ok(df.match(/FROM ghcr\.io\/zeroclaw-labs\/zeroclaw:\S+ AS zeroclaw/),
+    'Dockerfile must pull ZeroClaw from ghcr.io/zeroclaw-labs/zeroclaw');
   assert.ok(df.includes('COPY --from=zeroclaw /usr/local/bin/zeroclaw /usr/local/bin/zeroclaw'));
 });