limbo-ai 1.10.0 → 1.12.0

package/cli.js

@@ -50,6 +50,12 @@ const MODEL_CATALOG = {
     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'],
   },
+  'openrouter:api-key': {
+    provider: 'openrouter',
+    defaultModel: 'auto',
+    menuModels: [],
+    supportedModels: [],
+  },
 };
 
 const ASCII_ART = String.raw`
@@ -211,6 +217,7 @@ const TEXT = {
     providerQuestion: 'AI Provider',
     providerOpenAI: 'Codex (OpenAI)',
     providerAnthropic: 'Claude (Anthropic)',
+    providerOpenRouter: 'OpenRouter (100+ models)',
     accessMethodQuestion: 'Access method',
     accessSubscriptionOpenAI: 'ChatGPT / Codex subscription',
     accessSubscriptionAnthropic: 'Claude Code subscription',
@@ -225,6 +232,11 @@ const TEXT = {
     requiredField: 'This field is required.',
     invalidOpenAIKey: 'OpenAI API keys usually start with "sk-".',
     invalidAnthropicKey: 'Anthropic API keys usually start with "sk-ant-".',
+    openRouterApiKeyPrompt: '  OpenRouter API key (sk-or-...): ',
+    openRouterKeyWarn: 'OpenRouter API keys usually start with "sk-or-". Proceeding anyway.',
+    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',
     telegramQuestion: 'Want to speak to Limbo through Telegram?',
     telegramBotFatherSteps: [
       'To create a Telegram bot:',
@@ -260,6 +272,9 @@ const TEXT = {
     subscriptionSetup: 'Provider authentication',
     openaiSubscriptionIntro: 'Limbo will authenticate with your OpenAI account. A URL will open in your browser — log in and authorize access.',
     anthropicSubscriptionIntro: 'Generate a Claude setup-token on any machine with `claude setup-token`, then paste it into the next step.',
+    claudeTokenPrompt: '  Setup token: ',
+    claudeTokenInvalid: 'Invalid token. It should start with "sk-ant-".',
+    claudeTokenWritten: 'Auth profile written.',
     authFlowStart: 'Starting authentication...',
     authFlowDone: 'Authentication complete.',
     authFlowFailed: 'Authentication did not complete successfully.',
@@ -309,6 +324,7 @@ const TEXT = {
     providerQuestion: 'AI Provider',
     providerOpenAI: 'Codex (OpenAI)',
     providerAnthropic: 'Claude (Anthropic)',
+    providerOpenRouter: 'OpenRouter (100+ modelos)',
     accessMethodQuestion: 'Metodo de acceso',
     accessSubscriptionOpenAI: 'Suscripcion ChatGPT / Codex',
     accessSubscriptionAnthropic: 'Suscripcion Claude Code',
@@ -323,6 +339,11 @@ const TEXT = {
     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-".',
+    openRouterApiKeyPrompt: '  OpenRouter API key (sk-or-...): ',
+    openRouterKeyWarn: 'Las API keys de OpenRouter normalmente empiezan con "sk-or-". Continuando igual.',
+    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',
     telegramQuestion: 'Quieres hablar con Limbo por Telegram?',
     telegramBotFatherSteps: [
       'Para crear un bot de Telegram:',
@@ -358,6 +379,9 @@ const TEXT = {
     subscriptionSetup: 'Autenticacion del provider',
     openaiSubscriptionIntro: 'Limbo va a autenticarse con tu cuenta de OpenAI. Se va a abrir una URL en tu navegador — inicia sesion y autoriza el acceso.',
     anthropicSubscriptionIntro: 'Genera un Claude setup-token en cualquier maquina con `claude setup-token` y pegalo en el siguiente paso.',
+    claudeTokenPrompt: '  Setup token: ',
+    claudeTokenInvalid: 'Token invalido. Deberia empezar con "sk-ant-".',
+    claudeTokenWritten: 'Perfil de auth guardado.',
     authFlowStart: 'Iniciando autenticacion...',
     authFlowDone: 'Autenticacion completada.',
     authFlowFailed: 'La autenticacion no termino correctamente.',
@@ -584,7 +608,7 @@ function writeSecrets(cfg, existingEnv = {}) {
 }
 
 const SECRET_KEYS = new Set([
-  'LLM_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY',
+  'LLM_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'OPENROUTER_API_KEY',
   'TELEGRAM_BOT_TOKEN', 'OPENCLAW_GATEWAY_TOKEN',
 ]);
 
@@ -609,12 +633,29 @@ function waitForHealthy(lang, maxAttempts = 12) {
   return false;
 }
 
+function deriveProviderFamily(provider) {
+  if (!provider) return 'anthropic';
+  if (provider.startsWith('openai')) return 'openai';
+  if (provider === 'openrouter') return 'openrouter';
+  return 'anthropic';
+}
+
 function getModelCatalog(providerFamily, authMode) {
   return MODEL_CATALOG[`${providerFamily}:${authMode}`];
 }
 
 async function chooseModel(lang, providerFamily, authMode) {
   const catalog = getModelCatalog(providerFamily, authMode);
+
+  if (!catalog.menuModels.length) {
+    console.log(`  ${c.dim}${t(lang, 'openRouterModelHint')}${c.reset}`);
+    const modelName = await promptValidated(
+      t(lang, 'openRouterModelPrompt'),
+      (value) => ({ ok: true, value: value || catalog.defaultModel }),
+    );
+    return modelName;
+  }
+
   const options = catalog.menuModels.map((model) => ({ label: model, value: model }));
   options.push({ label: t(lang, 'customModel'), value: '__custom__' });
 
@@ -648,17 +689,23 @@ async function collectConfig(existingEnv = {}) {
   const providerFamily = (await selectMenu(t(language, 'providerQuestion'), [
     { label: t(language, 'providerOpenAI'), value: 'openai' },
     { label: t(language, 'providerAnthropic'), value: 'anthropic' },
+    { label: t(language, 'providerOpenRouter'), value: 'openrouter' },
   ], 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;
+  let accessMethod;
+  if (providerFamily === 'openrouter') {
+    accessMethod = 'api-key';
+  } else {
+    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;
@@ -674,6 +721,16 @@ async function collectConfig(existingEnv = {}) {
           return { ok: true, value };
         },
       );
+    } else if (providerFamily === 'openrouter') {
+      console.log(`  ${c.dim}${t(language, 'openRouterKeyHint')}${c.reset}`);
+      apiKey = await promptValidated(
+        t(language, 'openRouterApiKeyPrompt'),
+        (value) => {
+          if (!value) return { ok: false, message: t(language, 'requiredField') };
+          if (!value.startsWith('sk-or-')) warn(t(language, 'openRouterKeyWarn'));
+          return { ok: true, value };
+        },
+      );
     } else {
       apiKey = await promptValidated(
         t(language, 'anthropicApiKeyPrompt'),
@@ -933,10 +990,24 @@ function decodeJwtPayload(token) {
   return JSON.parse(Buffer.from(parts[1], 'base64url').toString());
 }
 
-function writeAuthProfilesToDocker(profile) {
-  // Write auth-profiles.json into the OpenClaw Docker volume via a temp container
+function writeAuthProfilesToDocker(store) {
+  const json = JSON.stringify(store, null, 2);
+  const destDir = '/home/limbo/.openclaw/agents/main/agent';
+  const destFile = `${destDir}/auth-profiles.json`;
+  spawnSync('docker', [
+    'compose', 'run', '--rm', '--no-deps', '--entrypoint', 'sh', 'limbo',
+    '-c', `mkdir -p "${destDir}" && cat > "${destFile}"`,
+  ], {
+    cwd: LIMBO_DIR,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    input: json,
+    encoding: 'utf8',
+  });
+}
+
+function buildCodexAuthProfile(profile) {
   const profileId = profile.email ? `openai-codex:${profile.email}` : 'openai-codex:default';
-  const store = {
+  return {
     version: 1,
     profiles: {
       [profileId]: {
@@ -952,19 +1023,46 @@ function writeAuthProfilesToDocker(profile) {
     lastGood: {},
     usageStats: {},
   };
-  const json = JSON.stringify(store, null, 2);
-  const destDir = '/home/limbo/.openclaw/agents/main/agent';
-  const destFile = `${destDir}/auth-profiles.json`;
-  // Use a one-shot container to write into the named volume
-  spawnSync('docker', [
-    'compose', 'run', '--rm', '--no-deps', '--entrypoint', 'sh', 'limbo',
-    '-c', `mkdir -p "${destDir}" && cat > "${destFile}"`,
-  ], {
-    cwd: LIMBO_DIR,
-    stdio: ['pipe', 'pipe', 'pipe'],
-    input: json,
-    encoding: 'utf8',
-  });
+}
+
+function buildAnthropicAuthProfile(token) {
+  return {
+    version: 1,
+    profiles: {
+      'anthropic:token': {
+        type: 'token',
+        provider: 'anthropic',
+        token,
+      },
+    },
+    order: { anthropic: ['anthropic:token'] },
+    lastGood: {},
+    usageStats: {},
+  };
+}
+
+function parseClaudeSetupToken(raw) {
+  const trimmed = raw.trim();
+  if (/^sk-ant-[a-zA-Z0-9_-]+$/.test(trimmed)) return trimmed;
+  return null;
+}
+
+async function runClaudeSetupTokenAuth(language) {
+  const tokenRaw = await promptValidated(
+    t(language, 'claudeTokenPrompt'),
+    (value) => {
+      if (!value) return { ok: false, message: t(language, 'requiredField') };
+      const parsed = parseClaudeSetupToken(value);
+      if (!parsed) return { ok: false, message: t(language, 'claudeTokenInvalid') };
+      return { ok: true, value };
+    },
+  );
+
+  const token = parseClaudeSetupToken(tokenRaw);
+  const store = buildAnthropicAuthProfile(token);
+  writeAuthProfilesToDocker(store);
+  ok(t(language, 'claudeTokenWritten'));
+  return 0;
 }
 
 async function runCodexOAuth(language) {
@@ -1004,13 +1102,14 @@ async function runCodexOAuth(language) {
   const accountId = authClaim.chatgpt_account_id || '';
   const email = jwt.email || '';
 
-  writeAuthProfilesToDocker({
+  const store = buildCodexAuthProfile({
     access: tokens.access_token,
     refresh: tokens.refresh_token,
     expires: Date.now() + (tokens.expires_in * 1000),
     accountId,
     email,
   });
+  writeAuthProfilesToDocker(store);
 
   return 0;
 }
@@ -1033,18 +1132,10 @@ async function runSubscriptionAuthFlow(cfg) {
   } else {
     log(t(cfg.language, 'anthropicSubscriptionIntro'));
     log(t(cfg.language, 'authFlowStart'));
-    // Anthropic paste-token is interactive (user pastes a token); keep stdio inherited
-    const authResult = runOpenClaw(['models', 'auth', 'paste-token', '--provider', 'anthropic']);
-    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'));
+    try {
+      await runClaudeSetupTokenAuth(cfg.language);
+    } catch (err) {
+      die(`${t(cfg.language, 'authFlowFailed')}: ${err.message}`);
     }
     ok(t(cfg.language, 'authFlowDone'));
   }
@@ -1098,7 +1189,7 @@ async function cmdStart() {
       cfg = {
         language: lang,
         provider: existingEnv.MODEL_PROVIDER || 'anthropic',
-        providerFamily: (existingEnv.MODEL_PROVIDER || 'anthropic').startsWith('openai') ? 'openai' : 'anthropic',
+        providerFamily: deriveProviderFamily(existingEnv.MODEL_PROVIDER),
         authMode: existingEnv.AUTH_MODE || 'api-key',
         modelName: existingEnv.MODEL_NAME || 'claude-opus-4-6',
         telegramEnabled: existingEnv.TELEGRAM_ENABLED || 'false',

package/package.json

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