jbai-cli 1.6.0 → 1.8.0

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
@@ -51,6 +51,12 @@ COMMANDS:
   jbai doctor          Check which tools are installed
   jbai help            Show this help
 
+PROXY (for Codex Desktop, Cursor, etc.):
+  jbai proxy setup             One-liner setup: proxy + Codex + shell env
+  jbai proxy --daemon          Start proxy in background
+  jbai proxy stop              Stop background proxy
+  jbai proxy status            Check proxy status
+
 TOOL WRAPPERS:
   jbai-claude   Launch Claude Code with JetBrains AI
   jbai-codex    Launch Codex CLI with JetBrains AI
@@ -92,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)`);
     }
   }
 }
@@ -131,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;
@@ -561,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();
     }
@@ -586,6 +633,13 @@ switch (command) {
   case 'status':
     doctor();
     break;
+  case 'proxy': {
+    const proxyMod = require('./jbai-proxy');
+    // Re-set argv so jbai-proxy sees the right args
+    process.argv = [process.argv[0], process.argv[1], ...args];
+    proxyMod.main();
+    break;
+  }
   case 'help':
   case '--help':
   case '-h':

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,23 +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: 'o3-2025-04-16',
+    default: 'gpt-5.3-codex-api-preview',
     available: [
-      // O-series models (best for coding tasks)
-      'o3-2025-04-16',
-      'o3-mini-2025-01-31',
-      'o4-mini-2025-04-16',
-      // GPT-5.x series
+      // 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.1-2025-11-13',
       'gpt-5-2025-08-07',
-      // GPT-4.x series
-      'gpt-4.1-2025-04-14',
-      'gpt-4o-2024-11-20',
-      'gpt-4-turbo-2024-04-09'
+      '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: {
@@ -109,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.
 };
@@ -187,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',
@@ -227,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.6.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",
@@ -26,6 +26,7 @@
   "homepage": "https://github.com/JetBrains/jbai-cli#readme",
   "bin": {
     "jbai": "bin/jbai.js",
+    "jbai-proxy": "bin/jbai-proxy.js",
     "jbai-claude": "bin/jbai-claude.js",
     "jbai-codex": "bin/jbai-codex.js",
     "jbai-gemini": "bin/jbai-gemini.js",