jbai-cli 1.7.0 → 1.8.0

package/bin/jbai-claude.js

@@ -2,76 +2,69 @@
 
 const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
 const config = require('../lib/config');
+const { ensureToken } = require('../lib/ensure-token');
 
-const token = config.getToken();
-if (!token) {
-  console.error('❌ No token found. Run: jbai token set');
-  process.exit(1);
-}
+(async () => {
+  const token = await ensureToken();
+  const endpoints = config.getEndpoints();
+  let args = process.argv.slice(2);
+  const handoffConfig = stripHandoffFlag(args);
+  args = handoffConfig.args;
 
-if (config.isTokenExpired(token)) {
-  console.error('⚠️  Token expired. Run: jbai token refresh');
-  process.exit(1);
-}
+  // Check for super mode (--super, --yolo, -s)
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  args = args.filter(a => !superFlags.includes(a));
 
-const endpoints = config.getEndpoints();
-let args = process.argv.slice(2);
-const handoffConfig = stripHandoffFlag(args);
-args = handoffConfig.args;
+  // Check if model specified
+  const hasModel = args.includes('--model') || args.includes('-m');
+  let finalArgs = hasModel ? args : ['--model', config.MODELS.claude.default, ...args];
 
-// Check for super mode (--super, --yolo, -s)
-const superFlags = ['--super', '--yolo', '-s'];
-const superMode = args.some(a => superFlags.includes(a));
-args = args.filter(a => !superFlags.includes(a));
+  // Add super mode flags
+  if (superMode) {
+    finalArgs = ['--dangerously-skip-permissions', ...finalArgs];
+    console.log('🚀 Super mode: --dangerously-skip-permissions enabled');
+  }
 
-// Check if model specified
-const hasModel = args.includes('--model') || args.includes('-m');
-let finalArgs = hasModel ? args : ['--model', config.MODELS.claude.default, ...args];
+  // Set environment for Claude Code
+  // Use ANTHROPIC_CUSTOM_HEADERS for the Grazie auth header
+  // Remove /v1 from endpoint - Claude Code adds it automatically
+  const baseUrl = endpoints.anthropic.replace(/\/v1$/, '');
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: baseUrl,
+    ANTHROPIC_API_KEY: 'placeholder',
+    ANTHROPIC_CUSTOM_HEADERS: `Grazie-Authenticate-JWT: ${token}`
+  };
 
-// Add super mode flags
-if (superMode) {
-  finalArgs = ['--dangerously-skip-permissions', ...finalArgs];
-  console.log('🚀 Super mode: --dangerously-skip-permissions enabled');
-}
+  // Remove any existing auth token that might conflict
+  delete env.ANTHROPIC_AUTH_TOKEN;
 
-// Set environment for Claude Code
-// Use ANTHROPIC_CUSTOM_HEADERS for the Grazie auth header
-// Remove /v1 from endpoint - Claude Code adds it automatically
-const baseUrl = endpoints.anthropic.replace(/\/v1$/, '');
-const env = {
-  ...process.env,
-  ANTHROPIC_BASE_URL: baseUrl,
-  ANTHROPIC_API_KEY: 'placeholder',
-  ANTHROPIC_CUSTOM_HEADERS: `Grazie-Authenticate-JWT: ${token}`
-};
-
-// Remove any existing auth token that might conflict
-delete env.ANTHROPIC_AUTH_TOKEN;
-
-const child = runWithHandoff({
-  command: 'claude',
-  args: finalArgs,
-  env,
-  toolName: 'jbai-claude',
-  handoffDefaults: {
-    enabled: !handoffConfig.disabled,
-    grazieToken: token,
-    grazieEnvironment: config.getEnvironment() === 'production' ? 'PRODUCTION' : 'STAGING',
-    grazieModel: config.MODELS.claude.default,
-    cwd: process.cwd(),
-  },
-});
-
-if (child && typeof child.on === 'function') {
-  child.on('error', (err) => {
-    if (err.code === 'ENOENT') {
-      const tool = config.TOOLS.claude;
-      console.error(`❌ ${tool.name} not found.\n`);
-      console.error(`Install with: ${tool.install}`);
-      console.error(`Or run: jbai install claude`);
-    } else {
-      console.error(`Error: ${err.message}`);
-    }
-    process.exit(1);
+  const child = runWithHandoff({
+    command: 'claude',
+    args: finalArgs,
+    env,
+    toolName: 'jbai-claude',
+    handoffDefaults: {
+      enabled: !handoffConfig.disabled,
+      grazieToken: token,
+      grazieEnvironment: config.getEnvironment() === 'production' ? 'PRODUCTION' : 'STAGING',
+      grazieModel: config.MODELS.claude.default,
+      cwd: process.cwd(),
+    },
   });
-}
+
+  if (child && typeof child.on === 'function') {
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const tool = config.TOOLS.claude;
+        console.error(`❌ ${tool.name} not found.\n`);
+        console.error(`Install with: ${tool.install}`);
+        console.error(`Or run: jbai install claude`);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    });
+  }
+})();

package/bin/jbai-codex.js

@@ -5,47 +5,39 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const config = require('../lib/config');
-
-const token = config.getToken();
-if (!token) {
-  console.error('❌ No token found. Run: jbai token set');
-  process.exit(1);
-}
-
-if (config.isTokenExpired(token)) {
-  console.error('⚠️  Token expired. Run: jbai token refresh');
-  process.exit(1);
-}
-
-const endpoints = config.getEndpoints();
-const environment = config.getEnvironment();
-const providerName = environment === 'staging' ? 'jbai-staging' : 'jbai';
-const envVarName = environment === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_API_TOKEN';
-let args = process.argv.slice(2);
-const handoffConfig = stripHandoffFlag(args);
-args = handoffConfig.args;
-
-// Check for super mode (--super, --yolo, -s)
-const superFlags = ['--super', '--yolo', '-s'];
-const superMode = args.some(a => superFlags.includes(a));
-args = args.filter(a => !superFlags.includes(a));
-
-// Ensure Codex config exists
-const codexDir = path.join(os.homedir(), '.codex');
-const codexConfig = path.join(codexDir, 'config.toml');
-
-if (!fs.existsSync(codexDir)) {
-  fs.mkdirSync(codexDir, { recursive: true });
-}
-
-// Check if our provider is configured
-let configContent = '';
-if (fs.existsSync(codexConfig)) {
-  configContent = fs.readFileSync(codexConfig, 'utf-8');
-}
-
-if (!configContent.includes(`[model_providers.${providerName}]`)) {
-  const providerConfig = `
+const { ensureToken } = require('../lib/ensure-token');
+
+(async () => {
+  const token = await ensureToken();
+  const endpoints = config.getEndpoints();
+  const environment = config.getEnvironment();
+  const providerName = environment === 'staging' ? 'jbai-staging' : 'jbai';
+  const envVarName = environment === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_API_TOKEN';
+  let args = process.argv.slice(2);
+  const handoffConfig = stripHandoffFlag(args);
+  args = handoffConfig.args;
+
+  // Check for super mode (--super, --yolo, -s)
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  args = args.filter(a => !superFlags.includes(a));
+
+  // Ensure Codex config exists
+  const codexDir = path.join(os.homedir(), '.codex');
+  const codexConfig = path.join(codexDir, 'config.toml');
+
+  if (!fs.existsSync(codexDir)) {
+    fs.mkdirSync(codexDir, { recursive: true });
+  }
+
+  // Check if our provider is configured
+  let configContent = '';
+  if (fs.existsSync(codexConfig)) {
+    configContent = fs.readFileSync(codexConfig, 'utf-8');
+  }
+
+  if (!configContent.includes(`[model_providers.${providerName}]`)) {
+    const providerConfig = `
 # JetBrains AI (${environment})
 [model_providers.${providerName}]
 name = "JetBrains AI (${environment})"
@@ -53,54 +45,68 @@ base_url = "${endpoints.openai}"
 env_http_headers = { "Grazie-Authenticate-JWT" = "${envVarName}" }
 wire_api = "responses"
 `;
-  fs.appendFileSync(codexConfig, providerConfig);
-  console.log(`✅ Added ${providerName} provider to Codex config`);
-}
-
-const hasModel = args.includes('--model');
-const finalArgs = ['-c', `model_provider=${providerName}`];
-
-if (!hasModel) {
-  finalArgs.push('--model', config.MODELS.codex?.default || config.MODELS.openai.default);
-}
-
-// Add super mode flags (full-auto)
-if (superMode) {
-  finalArgs.push('--full-auto');
-  console.log('🚀 Super mode: --full-auto enabled');
-}
-
-finalArgs.push(...args);
-
-const childEnv = {
-  ...process.env,
-  [envVarName]: token
-};
-
-const child = runWithHandoff({
-  command: 'codex',
-  args: finalArgs,
-  env: childEnv,
-  toolName: 'jbai-codex',
-  handoffDefaults: {
-    enabled: !handoffConfig.disabled,
-    grazieToken: token,
-    grazieEnvironment: environment === 'production' ? 'PRODUCTION' : 'STAGING',
-    grazieModel: config.MODELS.claude.default,
-    cwd: process.cwd(),
-  },
-});
-
-if (child && typeof child.on === 'function') {
-  child.on('error', (err) => {
-    if (err.code === 'ENOENT') {
-      const tool = config.TOOLS.codex;
-      console.error(`❌ ${tool.name} not found.\n`);
-      console.error(`Install with: ${tool.install}`);
-      console.error(`Or run: jbai install codex`);
-    } else {
-      console.error(`Error: ${err.message}`);
-    }
-    process.exit(1);
+    fs.appendFileSync(codexConfig, providerConfig);
+    console.log(`✅ Added ${providerName} provider to Codex config`);
+  }
+
+  // Point Codex model picker to our proxy (serves our model list instead of chatgpt.com)
+  const proxyModelUrl = 'http://localhost:18080/';
+  if (!configContent.includes('chatgpt_base_url')) {
+    fs.appendFileSync(codexConfig, `\nchatgpt_base_url = "${proxyModelUrl}"\n`);
+    console.log('✅ Set chatgpt_base_url to jbai-proxy for model picker');
+  } else if (!configContent.includes(proxyModelUrl)) {
+    // Update existing chatgpt_base_url
+    configContent = fs.readFileSync(codexConfig, 'utf-8');
+    const updated = configContent.replace(/^chatgpt_base_url\s*=\s*"[^"]*"/m, `chatgpt_base_url = "${proxyModelUrl}"`);
+    fs.writeFileSync(codexConfig, updated);
+    console.log('✅ Updated chatgpt_base_url to jbai-proxy');
+  }
+
+  const hasModel = args.includes('--model');
+  const finalArgs = ['-c', `model_provider=${providerName}`];
+
+  if (!hasModel) {
+    finalArgs.push('--model', config.MODELS.codex?.default || config.MODELS.openai.default);
+  }
+
+  // Add super mode flags (full-auto)
+  if (superMode) {
+    finalArgs.push('--full-auto');
+    console.log('🚀 Super mode: --full-auto enabled');
+  }
+
+  finalArgs.push(...args);
+
+  const childEnv = {
+    ...process.env,
+    [envVarName]: token
+  };
+
+  const child = runWithHandoff({
+    command: 'codex',
+    args: finalArgs,
+    env: childEnv,
+    toolName: 'jbai-codex',
+    handoffDefaults: {
+      enabled: !handoffConfig.disabled,
+      grazieToken: token,
+      grazieEnvironment: environment === 'production' ? 'PRODUCTION' : 'STAGING',
+      grazieModel: config.MODELS.claude.default,
+      cwd: process.cwd(),
+    },
   });
-}
+
+  if (child && typeof child.on === 'function') {
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const tool = config.TOOLS.codex;
+        console.error(`❌ ${tool.name} not found.\n`);
+        console.error(`Install with: ${tool.install}`);
+        console.error(`Or run: jbai install codex`);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    });
+  }
+})();

package/bin/jbai-gemini.js

@@ -8,70 +8,63 @@
 
 const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
 const config = require('../lib/config');
+const { ensureToken } = require('../lib/ensure-token');
 
-const token = config.getToken();
-if (!token) {
-  console.error('❌ No token found. Run: jbai token set');
-  process.exit(1);
-}
+(async () => {
+  const token = await ensureToken();
+  const endpoints = config.getEndpoints();
+  let args = process.argv.slice(2);
+  const handoffConfig = stripHandoffFlag(args);
+  args = handoffConfig.args;
 
-if (config.isTokenExpired(token)) {
-  console.error('⚠️  Token expired. Run: jbai token refresh');
-  process.exit(1);
-}
+  // Check for super mode (--super, --yolo, -s)
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  args = args.filter(a => !superFlags.includes(a));
 
-const endpoints = config.getEndpoints();
-let args = process.argv.slice(2);
-const handoffConfig = stripHandoffFlag(args);
-args = handoffConfig.args;
+  // Check if model specified
+  const hasModel = args.includes('--model') || args.includes('-m');
+  let finalArgs = hasModel ? args : ['--model', config.MODELS.gemini.default, ...args];
 
-// Check for super mode (--super, --yolo, -s)
-const superFlags = ['--super', '--yolo', '-s'];
-const superMode = args.some(a => superFlags.includes(a));
-args = args.filter(a => !superFlags.includes(a));
+  // Add super mode flags (auto-confirm) - Gemini uses --yolo
+  if (superMode) {
+    finalArgs = ['--yolo', ...finalArgs];
+    console.log('🚀 Super mode: --yolo (auto-confirm) enabled');
+  }
 
-// Check if model specified
-const hasModel = args.includes('--model') || args.includes('-m');
-let finalArgs = hasModel ? args : ['--model', config.MODELS.gemini.default, ...args];
+  // Set environment for Gemini CLI
+  // Uses GEMINI_CLI_CUSTOM_HEADERS for auth (supported since Nov 2025)
+  const env = {
+    ...process.env,
+    GEMINI_BASE_URL: endpoints.google,
+    GEMINI_API_KEY: 'placeholder',
+    GEMINI_CLI_CUSTOM_HEADERS: `Grazie-Authenticate-JWT: ${token}`
+  };
 
-// Add super mode flags (auto-confirm) - Gemini uses --yolo
-if (superMode) {
-  finalArgs = ['--yolo', ...finalArgs];
-  console.log('🚀 Super mode: --yolo (auto-confirm) enabled');
-}
-
-// Set environment for Gemini CLI
-// Uses GEMINI_CLI_CUSTOM_HEADERS for auth (supported since Nov 2025)
-const env = {
-  ...process.env,
-  GEMINI_BASE_URL: endpoints.google,
-  GEMINI_API_KEY: 'placeholder',
-  GEMINI_CLI_CUSTOM_HEADERS: `Grazie-Authenticate-JWT: ${token}`
-};
-
-const child = runWithHandoff({
-  command: 'gemini',
-  args: finalArgs,
-  env,
-  toolName: 'jbai-gemini',
-  handoffDefaults: {
-    enabled: !handoffConfig.disabled,
-    grazieToken: token,
-    grazieEnvironment: config.getEnvironment() === 'production' ? 'PRODUCTION' : 'STAGING',
-    grazieModel: config.MODELS.claude.default,
-    cwd: process.cwd(),
-  },
-});
-
-if (child && typeof child.on === 'function') {
-  child.on('error', (err) => {
-    if (err.code === 'ENOENT') {
-      console.error(`❌ Gemini CLI not found.\n`);
-      console.error(`Install with: npm install -g @google/gemini-cli`);
-      console.error(`Or run: jbai install gemini`);
-    } else {
-      console.error(`Error: ${err.message}`);
-    }
-    process.exit(1);
+  const child = runWithHandoff({
+    command: 'gemini',
+    args: finalArgs,
+    env,
+    toolName: 'jbai-gemini',
+    handoffDefaults: {
+      enabled: !handoffConfig.disabled,
+      grazieToken: token,
+      grazieEnvironment: config.getEnvironment() === 'production' ? 'PRODUCTION' : 'STAGING',
+      grazieModel: config.MODELS.claude.default,
+      cwd: process.cwd(),
+    },
   });
-}
+
+  if (child && typeof child.on === 'function') {
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        console.error(`❌ Gemini CLI not found.\n`);
+        console.error(`Install with: npm install -g @google/gemini-cli`);
+        console.error(`Or run: jbai install gemini`);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    });
+  }
+})();

package/bin/jbai-opencode.js

@@ -5,164 +5,155 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const config = require('../lib/config');
-
-const token = config.getToken();
-if (!token) {
-  console.error('❌ No token found. Run: jbai token set');
-  process.exit(1);
-}
-
-if (config.isTokenExpired(token)) {
-  console.error('⚠️  Token expired. Run: jbai token refresh');
-  process.exit(1);
-}
-
-const endpoints = config.getEndpoints();
-const environment = config.getEnvironment();
-let args = process.argv.slice(2);
-const handoffConfig = stripHandoffFlag(args);
-args = handoffConfig.args;
-
-// Check for super mode (--super, --yolo, -s)
-const superFlags = ['--super', '--yolo', '-s'];
-const superMode = args.some(a => superFlags.includes(a));
-args = args.filter(a => !superFlags.includes(a));
-
-// Setup OpenCode config with JetBrains provider
-const configDir = path.join(os.homedir(), '.config', 'opencode');
-const configFile = path.join(configDir, 'opencode.json');
-
-if (!fs.existsSync(configDir)) {
-  fs.mkdirSync(configDir, { recursive: true });
-}
-
-// Create or update OpenCode config with JetBrains provider
-const providerName = environment === 'staging' ? 'jbai-staging' : 'jbai';
-let opencodeConfig = {};
-
-if (fs.existsSync(configFile)) {
-  try {
-    opencodeConfig = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
-  } catch {
-    opencodeConfig = {};
+const { ensureToken } = require('../lib/ensure-token');
+
+(async () => {
+  const token = await ensureToken();
+  const endpoints = config.getEndpoints();
+  const environment = config.getEnvironment();
+  let args = process.argv.slice(2);
+  const handoffConfig = stripHandoffFlag(args);
+  args = handoffConfig.args;
+
+  // Check for super mode (--super, --yolo, -s)
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  args = args.filter(a => !superFlags.includes(a));
+
+  // Setup OpenCode config with JetBrains provider
+  const configDir = path.join(os.homedir(), '.config', 'opencode');
+  const configFile = path.join(configDir, 'opencode.json');
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
   }
-}
-
-// Ensure provider section exists
-if (!opencodeConfig.provider) {
-  opencodeConfig.provider = {};
-}
-
-// Environment variable name for the token
-const envVarName = environment === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_API_TOKEN';
-
-// Provider names for OpenAI and Anthropic
-const anthropicProviderName = environment === 'staging' ? 'jbai-anthropic-staging' : 'jbai-anthropic';
-
-// Add/update JetBrains OpenAI provider with custom header (using env var reference)
-// Use OpenAI SDK to support max_completion_tokens for GPT-5.x
-opencodeConfig.provider[providerName] = {
-  npm: '@ai-sdk/openai',
-  name: `JetBrains AI OpenAI (${environment})`,
-  options: {
-    baseURL: endpoints.openai,
-    apiKey: `{env:${envVarName}}`,
-    headers: {
-      'Grazie-Authenticate-JWT': `{env:${envVarName}}`
+
+  // Create or update OpenCode config with JetBrains provider
+  const providerName = environment === 'staging' ? 'jbai-staging' : 'jbai';
+  let opencodeConfig = {};
+
+  if (fs.existsSync(configFile)) {
+    try {
+      opencodeConfig = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+    } catch {
+      opencodeConfig = {};
     }
-  },
-  models: {}
-};
-
-// Add OpenAI models
-// OpenCode requires an output limit in the config.
-// For O-series models we keep a larger context window but still set output.
-config.MODELS.openai.available.forEach(model => {
-  const isOSeries = /^o[1-9]/.test(model);
-  opencodeConfig.provider[providerName].models[model] = {
-    name: model,
-    limit: isOSeries
-      ? { context: 200000, output: 8192 }
-      : { context: 128000, output: 8192 }
+  }
+
+  // Ensure provider section exists
+  if (!opencodeConfig.provider) {
+    opencodeConfig.provider = {};
+  }
+
+  // Environment variable name for the token
+  const envVarName = environment === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_API_TOKEN';
+
+  // Provider names for OpenAI and Anthropic
+  const anthropicProviderName = environment === 'staging' ? 'jbai-anthropic-staging' : 'jbai-anthropic';
+
+  // Add/update JetBrains OpenAI provider with custom header (using env var reference)
+  // Use OpenAI SDK to support max_completion_tokens for GPT-5.x
+  opencodeConfig.provider[providerName] = {
+    npm: '@ai-sdk/openai',
+    name: `JetBrains AI OpenAI (${environment})`,
+    options: {
+      baseURL: endpoints.openai,
+      apiKey: `{env:${envVarName}}`,
+      headers: {
+        'Grazie-Authenticate-JWT': `{env:${envVarName}}`
+      }
+    },
+    models: {}
   };
-});
-
-// Add JetBrains Anthropic provider for Claude models
-opencodeConfig.provider[anthropicProviderName] = {
-  npm: '@ai-sdk/anthropic',
-  name: `JetBrains AI Anthropic (${environment})`,
-  options: {
-    baseURL: endpoints.anthropic,
-    apiKey: `{env:${envVarName}}`,
-    headers: {
-      'Grazie-Authenticate-JWT': `{env:${envVarName}}`
-    }
-  },
-  models: {}
-};
-
-// Add Claude models to Anthropic provider
-config.MODELS.claude.available.forEach(model => {
-  opencodeConfig.provider[anthropicProviderName].models[model] = {
-    name: model,
-    limit: { context: 200000, output: 8192 }
+
+  // Add OpenAI models
+  // OpenCode requires an output limit in the config.
+  // For O-series models we keep a larger context window but still set output.
+  config.MODELS.openai.available.forEach(model => {
+    const isOSeries = /^o[1-9]/.test(model);
+    opencodeConfig.provider[providerName].models[model] = {
+      name: model,
+      limit: isOSeries
+        ? { context: 200000, output: 8192 }
+        : { context: 128000, output: 8192 }
+    };
+  });
+
+  // Add JetBrains Anthropic provider for Claude models
+  opencodeConfig.provider[anthropicProviderName] = {
+    npm: '@ai-sdk/anthropic',
+    name: `JetBrains AI Anthropic (${environment})`,
+    options: {
+      baseURL: endpoints.anthropic,
+      apiKey: `{env:${envVarName}}`,
+      headers: {
+        'Grazie-Authenticate-JWT': `{env:${envVarName}}`
+      }
+    },
+    models: {}
   };
-});
-
-// NOTE: Gemini models are NOT available via Grazie OpenAI-compatible proxy.
-// The /user/v5/llm/google/v1/vertex endpoint only works with native Google API
-// format (used by jbai-gemini), not OpenAI chat/completions format.
-// Use `jbai gemini` instead for Gemini models.
-
-// Write config
-fs.writeFileSync(configFile, JSON.stringify(opencodeConfig, null, 2));
-
-// Check if model specified
-const hasModel = args.includes('--model') || args.includes('-m');
-let finalArgs = [];
-
-if (!hasModel) {
-  // Use provider/model format for OpenCode
-  finalArgs.push('--model', `${providerName}/${config.MODELS.openai.default}`);
-}
-
-// Note: OpenCode run is already non-interactive, no super mode needed
-if (superMode) {
-  console.log('ℹ️  OpenCode run is already non-interactive (no super mode flag needed)');
-}
-
-finalArgs.push(...args);
-
-// Set the token in environment variable for OpenCode config to reference
-const childEnv = {
-  ...process.env,
-  [envVarName]: token
-};
-
-const child = runWithHandoff({
-  command: 'opencode',
-  args: finalArgs,
-  env: childEnv,
-  toolName: 'jbai-opencode',
-  handoffDefaults: {
-    enabled: !handoffConfig.disabled,
-    grazieToken: token,
-    grazieEnvironment: environment === 'production' ? 'PRODUCTION' : 'STAGING',
-    grazieModel: config.MODELS.claude.default,
-    cwd: process.cwd(),
-  },
-});
-
-if (child && typeof child.on === 'function') {
-  child.on('error', (err) => {
-    if (err.code === 'ENOENT') {
-      const tool = config.TOOLS.opencode;
-      console.error(`❌ ${tool.name} not found.\n`);
-      console.error(`Install with: ${tool.install}`);
-      console.error(`Or run: jbai install opencode`);
-    } else {
-      console.error(`Error: ${err.message}`);
-    }
-    process.exit(1);
+
+  // Add Claude models to Anthropic provider
+  config.MODELS.claude.available.forEach(model => {
+    opencodeConfig.provider[anthropicProviderName].models[model] = {
+      name: model,
+      limit: { context: 200000, output: 8192 }
+    };
   });
-}
+
+  // NOTE: Gemini models are NOT available via Grazie OpenAI-compatible proxy.
+  // The /user/v5/llm/google/v1/vertex endpoint only works with native Google API
+  // format (used by jbai-gemini), not OpenAI chat/completions format.
+  // Use `jbai gemini` instead for Gemini models.
+
+  // Enable max permissions (yolo mode) by default
+  opencodeConfig.yolo = true;
+
+  // Write config
+  fs.writeFileSync(configFile, JSON.stringify(opencodeConfig, null, 2));
+
+  // Check if model specified
+  const hasModel = args.includes('--model') || args.includes('-m');
+  let finalArgs = ['--yolo'];
+
+  if (!hasModel) {
+    // Use provider/model format for OpenCode
+    finalArgs.push('--model', `${providerName}/${config.MODELS.openai.default}`);
+  }
+
+  finalArgs.push(...args);
+
+  // Set the token in environment variable for OpenCode config to reference
+  const childEnv = {
+    ...process.env,
+    [envVarName]: token
+  };
+
+  const child = runWithHandoff({
+    command: 'opencode',
+    args: finalArgs,
+    env: childEnv,
+    toolName: 'jbai-opencode',
+    handoffDefaults: {
+      enabled: !handoffConfig.disabled,
+      grazieToken: token,
+      grazieEnvironment: environment === 'production' ? 'PRODUCTION' : 'STAGING',
+      grazieModel: config.MODELS.claude.default,
+      cwd: process.cwd(),
+    },
+  });
+
+  if (child && typeof child.on === 'function') {
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const tool = config.TOOLS.opencode;
+        console.error(`❌ ${tool.name} not found.\n`);
+        console.error(`Install with: ${tool.install}`);
+        console.error(`Or run: jbai install opencode`);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    });
+  }
+})();

package/bin/jbai-proxy.js

@@ -107,9 +107,17 @@ function resolveRoute(method, urlPath) {
 function buildModelsResponse() {
   const models = [];
   const now = Math.floor(Date.now() / 1000);
+  const seen = new Set();
 
   for (const m of config.MODELS.openai.available) {
     models.push({ id: m, object: 'model', created: now, owned_by: 'openai' });
+    seen.add(m);
+  }
+  // Include codex-only models (responses API only) that aren't already in the openai list
+  for (const m of config.MODELS.codex.available) {
+    if (!seen.has(m)) {
+      models.push({ id: m, object: 'model', created: now, owned_by: 'openai' });
+    }
   }
   for (const m of config.MODELS.claude.available) {
     models.push({ id: m, object: 'model', created: now, owned_by: 'anthropic' });
@@ -121,6 +129,34 @@ function buildModelsResponse() {
   return { object: 'list', data: models };
 }
 
+// Codex CLI model picker response (matches chatgpt.com/backend-api/codex/models format)
+function buildCodexModelsResponse() {
+  const descriptions = {
+    'gpt-5.3-codex-api-preview': 'Latest GPT-5.3 Codex model. Designed for long-running, detailed software engineering tasks.',
+    'gpt-5.2-codex': 'Latest frontier agentic coding model.',
+    'gpt-5.2-pro-2025-12-11': 'GPT-5.2 Pro for deep reasoning and complex tasks.',
+    'gpt-5.2-2025-12-11': 'Latest frontier model with improvements across knowledge, reasoning and coding.',
+    'gpt-5.2': 'Latest frontier model (alias).',
+    'gpt-5.1-codex-max': 'Codex-optimized flagship for deep and fast reasoning.',
+    'gpt-5.1-codex': 'Codex-optimized for software engineering tasks.',
+    'gpt-5.1-codex-mini': 'Optimized for codex. Cheaper, faster, but less capable.',
+    'gpt-5.1-2025-11-13': 'GPT-5.1 general-purpose model.',
+    'gpt-5-codex': 'GPT-5 Codex for agentic coding.',
+    'gpt-5-2025-08-07': 'GPT-5 general-purpose model.',
+    'o4-mini-2025-04-16': 'O4-mini reasoning model.',
+    'o3-2025-04-16': 'O3 reasoning model.',
+  };
+
+  const models = config.MODELS.codex.available.map((id, i) => ({
+    slug: id,
+    name: id,
+    description: descriptions[id] || id,
+    default_active: i === 0,
+  }));
+
+  return { models };
+}
+
 // ---------------------------------------------------------------------------
 // Proxy handler
 // ---------------------------------------------------------------------------
@@ -144,6 +180,17 @@ function proxy(req, res) {
   const route = resolveRoute(req.method, urlPath);
 
   if (!route) {
+    // Codex CLI model picker endpoint (overrides chatgpt.com/backend-api/codex/models)
+    if (urlPath === '/backend-api/codex/models') {
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+      });
+      res.end(JSON.stringify(buildCodexModelsResponse()));
+      log(`[codex] GET /backend-api/codex/models → 200 (${Date.now() - startTime}ms)`);
+      return;
+    }
+
     // Health / info endpoint
     if (urlPath === '/' || urlPath === '/health') {
       const token = getToken();

package/bin/jbai.js

@@ -41,7 +41,7 @@ jbai-cli v${VERSION} - JetBrains AI Platform CLI Tools
 COMMANDS:
   jbai token           Show token status
   jbai token set       Set token interactively
-  jbai token refresh   Refresh expired token
+  jbai token refresh   Auto-refresh token via API (no UI needed)
   jbai test            Test API endpoints (incl. Codex /responses)
   jbai handoff         Continue task in Orca Lab
   jbai env [staging|production]  Switch environment
@@ -98,13 +98,21 @@ async function showTokenStatus() {
   const expiry = config.getTokenExpiry(token);
   if (expiry) {
     const now = new Date();
-    const daysLeft = Math.floor((expiry - now) / (1000 * 60 * 60 * 24));
+    const hoursLeft = Math.round((expiry - now) / (1000 * 60 * 60));
 
     if (config.isTokenExpired(token)) {
+      const refreshable = config.isTokenRefreshable(token);
       console.log(`⚠️  Token EXPIRED: ${expiry.toLocaleString()}`);
-      console.log(`   Run: jbai token refresh`);
+      if (refreshable) {
+        console.log(`   Run: jbai token refresh  (auto-refresh via API)`);
+      } else {
+        console.log(`   Token expired >2 weeks ago. Get a new one: ${config.getEndpoints().tokenUrl}`);
+      }
+    } else if (config.isTokenExpiringSoon(token)) {
+      console.log(`⏳ Expiring soon: ${expiry.toLocaleString()} (${hoursLeft}h left)`);
+      console.log(`   Run: jbai token refresh  (auto-refresh via API)`);
     } else {
-      console.log(`✅ Expires: ${expiry.toLocaleString()} (${daysLeft} days left)`);
+      console.log(`✅ Expires: ${expiry.toLocaleString()} (${hoursLeft}h left)`);
     }
   }
 }
@@ -137,13 +145,44 @@ async function setToken() {
   });
 }
 
-async function testEndpoints() {
+async function refreshTokenCommand() {
   const token = config.getToken();
   if (!token) {
     console.log('❌ No token found. Run: jbai token set');
     return;
   }
 
+  if (!config.isTokenExpired(token) && !config.isTokenExpiringSoon(token)) {
+    const expiry = config.getTokenExpiry(token);
+    const hoursLeft = Math.round((expiry - Date.now()) / (1000 * 60 * 60));
+    console.log(`✅ Token is still valid (${hoursLeft}h left). Refreshing anyway...`);
+  }
+
+  if (config.isTokenExpired(token) && !config.isTokenRefreshable(token)) {
+    console.log('❌ Token expired more than 2 weeks ago. Cannot auto-refresh.');
+    console.log(`   Get a new token: ${config.getEndpoints().tokenUrl}`);
+    return;
+  }
+
+  try {
+    console.log('🔄 Refreshing token via API...');
+    const newToken = await config.refreshTokenApi(token);
+    config.setToken(newToken);
+    console.log('✅ Token refreshed successfully!');
+    showTokenStatus();
+  } catch (e) {
+    console.log(`❌ Refresh failed: ${e.message}`);
+    console.log(`   Get a new token manually: ${config.getEndpoints().tokenUrl}`);
+  }
+}
+
+async function testEndpoints() {
+  const token = await config.getValidToken();
+  if (!token) {
+    console.log('❌ No token found. Run: jbai token set');
+    return;
+  }
+
   const endpoints = config.getEndpoints();
   console.log(`Testing JetBrains AI Platform (${config.getEnvironment()})\n`);
   const defaultOpenAIModel = config.MODELS.openai.default;
@@ -567,8 +606,10 @@ const [,, command, ...args] = process.argv;
 
 switch (command) {
   case 'token':
-    if (args[0] === 'set' || args[0] === 'refresh') {
+    if (args[0] === 'set') {
       setToken();
+    } else if (args[0] === 'refresh') {
+      refreshTokenCommand();
     } else {
       showTokenStatus();
     }

package/bin/test-models.js

@@ -154,6 +154,33 @@ async function testGeminiModel(model) {
   }
 }
 
+async function testCodexModel(model) {
+  try {
+    // Codex models use the OpenAI Responses API (not chat/completions)
+    const result = await httpPost(
+      `${endpoints.openai}/responses`,
+      {
+        model: model,
+        input: 'Say OK',
+        max_output_tokens: 50
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200) {
+      return { success: true, message: 'OK' };
+    } else if (result.status === 404) {
+      return { success: false, message: `404 Not Found`, error: result.data.error?.message || 'Model not found' };
+    } else if (result.status === 400) {
+      return { success: false, message: `400 Bad Request`, error: result.data.error?.message || 'Invalid request' };
+    } else {
+      return { success: false, message: `Status ${result.status}`, error: result.data.error?.message || JSON.stringify(result.data).substring(0, 100) };
+    }
+  } catch (e) {
+    return { success: false, message: 'Error', error: e.message };
+  }
+}
+
 async function runTests() {
   console.log(`\n${'='.repeat(70)}`);
   console.log(`${colors.cyan}JBAI-CLI E2E MODEL COMPATIBILITY TESTING${colors.reset}`);
@@ -162,6 +189,7 @@ async function runTests() {
 
   const results = {
     openai: { working: [], failing: [] },
+    codex: { working: [], failing: [] },
     anthropic: { working: [], failing: [] },
     gemini: { working: [], failing: [] }
   };
@@ -198,6 +226,26 @@ async function runTests() {
     }
   }
 
+  // Test Codex-only models (responses API only, not in openai.available)
+  const openaiSet = new Set(config.MODELS.openai.available);
+  const codexOnlyModels = config.MODELS.codex.available.filter(m => !openaiSet.has(m));
+  if (codexOnlyModels.length > 0) {
+    console.log(`\n${colors.cyan}Testing Codex-only models (jbai-codex, responses API)...${colors.reset}`);
+    console.log('-'.repeat(50));
+    for (const model of codexOnlyModels) {
+      process.stdout.write(`  ${model.padEnd(35)} `);
+      const result = await testCodexModel(model);
+      if (result.success) {
+        console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+        results.codex.working.push(model);
+      } else {
+        console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+        console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+        results.codex.failing.push({ model, error: result.error });
+      }
+    }
+  }
+
   // Test Gemini models
   console.log(`\n${colors.cyan}Testing Gemini models (jbai-gemini)...${colors.reset}`);
   console.log('-'.repeat(50));
@@ -220,16 +268,17 @@ async function runTests() {
   console.log(`${'='.repeat(70)}`);
 
   const totalWorking = results.anthropic.working.length + results.openai.working.length +
-                       results.gemini.working.length;
+                       results.codex.working.length + results.gemini.working.length;
   const totalFailing = results.anthropic.failing.length + results.openai.failing.length +
-                       results.gemini.failing.length;
+                       results.codex.failing.length + results.gemini.failing.length;
 
   console.log(`\n${colors.green}Working Models: ${totalWorking}${colors.reset}`);
   console.log(`${colors.red}Failing Models: ${totalFailing}${colors.reset}`);
 
   console.log(`\n${colors.cyan}By Provider:${colors.reset}`);
   console.log(`  Claude (Anthropic): ${colors.green}${results.anthropic.working.length}${colors.reset} working, ${colors.red}${results.anthropic.failing.length}${colors.reset} failing`);
-  console.log(`  OpenAI/GPT:         ${colors.green}${results.openai.working.length}${colors.reset} working, ${colors.red}${results.openai.failing.length}${colors.reset} failing`);
+  console.log(`  OpenAI/GPT (Chat):  ${colors.green}${results.openai.working.length}${colors.reset} working, ${colors.red}${results.openai.failing.length}${colors.reset} failing`);
+  console.log(`  Codex (Responses):  ${colors.green}${results.codex.working.length}${colors.reset} working, ${colors.red}${results.codex.failing.length}${colors.reset} failing`);
   console.log(`  Gemini (Google):    ${colors.green}${results.gemini.working.length}${colors.reset} working, ${colors.red}${results.gemini.failing.length}${colors.reset} failing`);
 
   if (totalFailing > 0) {
@@ -243,6 +292,10 @@ async function runTests() {
       console.log(`\n  OpenAI models:`);
       results.openai.failing.forEach(f => console.log(`    - ${f.model}`));
     }
+    if (results.codex.failing.length > 0) {
+      console.log(`\n  Codex models:`);
+      results.codex.failing.forEach(f => console.log(`    - ${f.model}`));
+    }
     if (results.gemini.failing.length > 0) {
       console.log(`\n  Gemini models:`);
       results.gemini.failing.forEach(f => console.log(`    - ${f.model}`));

package/lib/config.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const https = require('https');
 
 const CONFIG_DIR = path.join(os.homedir(), '.jbai');
 const TOKEN_FILE = path.join(CONFIG_DIR, 'token');
@@ -32,7 +33,9 @@ const MODELS = {
   claude: {
     default: 'claude-sonnet-4-5-20250929',
     available: [
-      // Claude 4.5 series (latest)
+      // Claude 4.6 series (latest)
+      'claude-opus-4-6',
+      // Claude 4.5 series
       'claude-opus-4-5-20251101',
       'claude-sonnet-4-5-20250929',
       'claude-haiku-4-5-20251001',
@@ -75,12 +78,26 @@ const MODELS = {
     ]
   },
   // Codex CLI uses OpenAI models via the "responses" API (wire_api = "responses")
-  // Uses the same models as openai, just different API wire format
+  // Includes chat-capable models PLUS codex-only models (responses API only)
   codex: {
-    default: 'gpt-5.2-2025-12-11',
+    default: 'gpt-5.3-codex-api-preview',
     available: [
+      // Codex-specific models (responses API only, NOT available via chat/completions)
+      'gpt-5.3-codex-api-preview',
+      // GPT-5.x chat models (also work via responses API)
       'gpt-5.2-2025-12-11',
-      'gpt-5.2'
+      'gpt-5.2',
+      'gpt-5.1-2025-11-13',
+      'gpt-5-2025-08-07',
+      'gpt-5.2-codex',
+      'gpt-5.2-pro-2025-12-11',
+      'gpt-5.1-codex-max',
+      'gpt-5.1-codex',
+      'gpt-5.1-codex-mini',
+      'gpt-5-codex',
+      // O-series (also work via responses API)
+      'o4-mini-2025-04-16',
+      'o3-2025-04-16'
     ]
   },
   gemini: {
@@ -98,7 +115,7 @@ const MODELS = {
       'gemini-2.0-flash-lite-001'
     ]
   }
-  // NOTE: Other providers (DeepSeek, Mistral, Qwen, XAI, Meta) are available
+  // NOTE: Other providers (DeepSeek, Mistral, Qwen, XAI, Meta, Grok) are available
   // via Grazie native Chat API but NOT via the OpenAI-compatible proxy.
   // They are not supported by CLI tools that use OpenAI API format.
 };
@@ -176,6 +193,88 @@ function isTokenExpired(token) {
   return expiry < new Date();
 }
 
+function isTokenExpiringSoon(token, thresholdMs = 60 * 60 * 1000) {
+  const expiry = getTokenExpiry(token);
+  if (!expiry) return true;
+  return (expiry.getTime() - Date.now()) < thresholdMs;
+}
+
+// Max age for refresh: token expired less than 2 weeks ago
+function isTokenRefreshable(token) {
+  const expiry = getTokenExpiry(token);
+  if (!expiry) return false;
+  const twoWeeksMs = 14 * 24 * 60 * 60 * 1000;
+  return (Date.now() - expiry.getTime()) < twoWeeksMs;
+}
+
+function refreshTokenApi(token) {
+  return new Promise((resolve, reject) => {
+    const endpoints = ENDPOINTS[getEnvironment()];
+    const url = new URL(`${endpoints.base}/user/v5/auth/jwt/refresh/v3`);
+
+    const req = https.request({
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Grazie-Authenticate-JWT': token
+      }
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`Refresh failed (HTTP ${res.statusCode}): ${body}`));
+          return;
+        }
+        try {
+          const json = JSON.parse(body);
+          if (!json.token) {
+            reject(new Error('No token in refresh response'));
+            return;
+          }
+          resolve(json.token);
+        } catch (e) {
+          reject(new Error(`Failed to parse refresh response: ${body}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.write('');
+    req.end();
+  });
+}
+
+async function refreshToken() {
+  const token = getToken();
+  if (!token) {
+    throw new Error('No token found. Run: jbai token set');
+  }
+  if (!isTokenExpired(token) && !isTokenExpiringSoon(token)) {
+    return token; // still valid, no refresh needed
+  }
+  if (isTokenExpired(token) && !isTokenRefreshable(token)) {
+    throw new Error('Token expired more than 2 weeks ago. Get a new one from the UI.');
+  }
+  const newToken = await refreshTokenApi(token);
+  setToken(newToken);
+  return newToken;
+}
+
+async function getValidToken() {
+  const token = getToken();
+  if (!token) return null;
+  if (!isTokenExpiringSoon(token)) return token;
+  try {
+    return await refreshToken();
+  } catch {
+    return token; // return current token as fallback
+  }
+}
+
 const TOOLS = {
   claude: {
     name: 'Claude Code',
@@ -216,5 +315,10 @@ module.exports = {
   getEndpoints,
   parseJWT,
   getTokenExpiry,
-  isTokenExpired
+  isTokenExpired,
+  isTokenExpiringSoon,
+  isTokenRefreshable,
+  refreshTokenApi,
+  refreshToken,
+  getValidToken
 };

package/lib/ensure-token.js

@@ -0,0 +1,31 @@
+const config = require('./config');
+
+/**
+ * Get a valid token, auto-refreshing if expiring soon.
+ * Exits the process if no token or refresh fails on an expired token.
+ */
+async function ensureToken() {
+  let token = config.getToken();
+  if (!token) {
+    console.error('❌ No token found. Run: jbai token set');
+    process.exit(1);
+  }
+
+  if (config.isTokenExpiringSoon(token)) {
+    try {
+      console.error('🔄 Token expiring soon, auto-refreshing...');
+      token = await config.refreshToken();
+      console.error('✅ Token refreshed');
+    } catch (e) {
+      if (config.isTokenExpired(token)) {
+        console.error(`❌ Token expired and refresh failed: ${e.message}`);
+        process.exit(1);
+      }
+      // Token not expired yet, continue with current
+    }
+  }
+
+  return token;
+}
+
+module.exports = { ensureToken };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbai-cli",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Gemini CLI, OpenCode) with JetBrains AI Platform",
   "keywords": [
     "jetbrains",