jbai-cli 1.0.0

package/README.md

@@ -0,0 +1,211 @@
+# jbai-cli
+
+**Use AI coding tools with your JetBrains AI subscription** — no separate API keys needed.
+
+One token, all tools: Claude Code, Codex, Aider, Gemini, OpenCode.
+
+## Install
+
+```bash
+npm install -g jbai-cli
+```
+
+## Setup (2 minutes)
+
+### Step 1: Get your token
+
+1. Go to [platform.jetbrains.ai](https://platform.jetbrains.ai/) (or [staging](https://platform.stgn.jetbrains.ai/))
+2. Click your **Profile** icon (top right)
+3. Click **"Copy Developer Token"**
+
+### Step 2: Save your token
+
+```bash
+jbai token set
+# Paste your token when prompted
+```
+
+### Step 3: Verify it works
+
+```bash
+jbai test
+```
+
+Expected output:
+```
+Testing JetBrains AI Platform (staging)
+
+1. OpenAI Proxy (GPT): ✅ Working
+2. Anthropic Proxy (Claude): ✅ Working
+3. Google Proxy (Gemini): ✅ Working
+```
+
+## Usage
+
+### Claude Code
+```bash
+jbai-claude
+```
+
+### Codex CLI
+```bash
+# Interactive mode
+jbai-codex
+
+# One-shot task
+jbai-codex exec "explain this codebase"
+```
+
+### Aider
+```bash
+jbai-aider
+```
+
+### Gemini
+```bash
+# Interactive chat
+jbai-gemini
+
+# One-shot question
+jbai-gemini "What is Kubernetes?"
+```
+
+### OpenCode
+```bash
+jbai-opencode
+```
+
+## Using Different Models
+
+Each tool has a sensible default, but you can specify any available model:
+
+```bash
+# Claude with Opus
+jbai-claude --model claude-opus-4-1-20250805
+
+# Codex with GPT-5
+jbai-codex --model gpt-5-2025-08-07
+
+# Gemini with Pro
+jbai-gemini --model gemini-2.5-pro "Your question"
+```
+
+### Available Models
+
+**Claude (Anthropic)**
+| Model | Notes |
+|-------|-------|
+| `claude-sonnet-4-5-20250929` | Default, recommended |
+| `claude-opus-4-1-20250805` | Most capable |
+| `claude-sonnet-4-20250514` | |
+| `claude-3-7-sonnet-20250219` | |
+| `claude-3-5-haiku-20241022` | Fast |
+
+**GPT (OpenAI)**
+| Model | Notes |
+|-------|-------|
+| `gpt-4o-2024-11-20` | Default |
+| `gpt-5-2025-08-07` | Latest |
+| `gpt-5.1-2025-11-13` | |
+| `gpt-5-mini-2025-08-07` | Fast |
+| `o3-2025-04-16` | Reasoning |
+| `o3-mini-2025-01-31` | |
+
+**Gemini (Google)**
+| Model | Notes |
+|-------|-------|
+| `gemini-2.5-flash` | Default, fast |
+| `gemini-2.5-pro` | More capable |
+| `gemini-3-pro-preview` | Preview |
+| `gemini-3-flash-preview` | Preview |
+
+## Commands Reference
+
+| Command | Description |
+|---------|-------------|
+| `jbai help` | Show help |
+| `jbai token` | Show token status |
+| `jbai token set` | Set/update token |
+| `jbai test` | Test API connections |
+| `jbai models` | List all models |
+| `jbai env staging` | Use staging environment |
+| `jbai env production` | Use production environment |
+
+## Prerequisites
+
+Install the underlying tools you want to use:
+
+| Tool | Install Command |
+|------|-----------------|
+| Claude Code | `npm i -g @anthropic-ai/claude-code` |
+| Codex | `npm i -g @openai/codex` |
+| Aider | `pip install aider-chat` |
+| OpenCode | `go install github.com/opencode-ai/opencode@latest` |
+| Gemini | Built-in, no install needed |
+
+## Token Management
+
+```bash
+# Check token status (shows expiry date)
+jbai token
+
+# Update expired token
+jbai token set
+```
+
+Tokens are stored securely at `~/.jbai/token`
+
+## Switching Environments
+
+```bash
+# Staging (default) - for testing
+jbai env staging
+
+# Production - for real work
+jbai env production
+```
+
+> **Note**: Staging and production use different tokens. Get the right one from the corresponding platform URL.
+
+## How It Works
+
+jbai-cli uses JetBrains AI Platform's **Guarded Proxy**, which provides API-compatible endpoints:
+
+- OpenAI API → `api.jetbrains.ai/user/v5/llm/openai/v1`
+- Anthropic API → `api.jetbrains.ai/user/v5/llm/anthropic/v1`
+- Google Vertex → `api.jetbrains.ai/user/v5/llm/google/v1/vertex`
+
+Your JetBrains AI token authenticates all requests via the `Grazie-Authenticate-JWT` header.
+
+## Troubleshooting
+
+### "Token expired"
+```bash
+jbai token set
+# Get fresh token from platform.jetbrains.ai
+```
+
+### "Claude Code not found"
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+### "Connection failed"
+```bash
+# Test which endpoints work
+jbai test
+
+# Check your environment
+jbai token
+```
+
+### Wrong environment
+```bash
+# Staging token won't work with production
+jbai env staging   # if using staging token
+jbai env production  # if using production token
+```
+
+## License
+
+MIT

package/bin/jbai-aider.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+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 args = process.argv.slice(2);
+
+// Build aider arguments
+const hasModel = args.includes('--model');
+const aiderArgs = [
+  '--openai-api-base', endpoints.openai,
+  '--openai-api-key', 'placeholder',
+  '--extra-headers', JSON.stringify({ 'Grazie-Authenticate-JWT': token })
+];
+
+if (!hasModel) {
+  aiderArgs.push('--model', config.MODELS.openai.default);
+}
+aiderArgs.push(...args);
+
+const child = spawn('aider', aiderArgs, {
+  stdio: 'inherit',
+  env: process.env
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('❌ Aider not found. Install: pip install aider-chat');
+  } else {
+    console.error(`Error: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code) => process.exit(code || 0));

package/bin/jbai-claude.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+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 args = process.argv.slice(2);
+
+// Check if model specified
+const hasModel = args.includes('--model') || args.includes('-m');
+const finalArgs = hasModel ? args : ['--model', config.MODELS.claude.default, ...args];
+
+// Set environment for Claude Code
+const env = {
+  ...process.env,
+  ANTHROPIC_BASE_URL: endpoints.anthropic,
+  ANTHROPIC_API_KEY: token,
+  ANTHROPIC_AUTH_TOKEN: token
+};
+
+const child = spawn('claude', finalArgs, {
+  stdio: 'inherit',
+  env
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('❌ Claude Code not found. Install: npm install -g @anthropic-ai/claude-code');
+  } else {
+    console.error(`Error: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code) => process.exit(code || 0));

package/bin/jbai-codex.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+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 env = config.getEnvironment();
+const providerName = env === 'staging' ? 'jbai-staging' : 'jbai';
+const envVarName = env === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_API_TOKEN';
+
+// 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 (${env})
+[model_providers.${providerName}]
+name = "JetBrains AI (${env})"
+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 args = process.argv.slice(2);
+const hasModel = args.includes('--model');
+const finalArgs = ['-c', `model_provider=${providerName}`];
+
+if (!hasModel) {
+  finalArgs.push('--model', config.MODELS.openai.default);
+}
+finalArgs.push(...args);
+
+const childEnv = {
+  ...process.env,
+  [envVarName]: token
+};
+
+const child = spawn('codex', finalArgs, {
+  stdio: 'inherit',
+  env: childEnv
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('❌ Codex not found. Install: npm install -g @openai/codex');
+  } else {
+    console.error(`Error: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code) => process.exit(code || 0));

package/bin/jbai-gemini.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const readline = require('readline');
+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 args = process.argv.slice(2);
+
+// Get model from args or use default
+let model = config.MODELS.gemini.default;
+const modelIdx = args.indexOf('--model');
+if (modelIdx !== -1 && args[modelIdx + 1]) {
+  model = args[modelIdx + 1];
+}
+
+// If prompt provided as argument, run one-shot
+const prompt = args.filter((a, i) =>
+  a !== '--model' && (modelIdx === -1 || i !== modelIdx + 1)
+).join(' ');
+
+if (prompt) {
+  runPrompt(prompt, model);
+} else {
+  runInteractive(model);
+}
+
+async function runPrompt(prompt, model) {
+  const url = `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/${model}:generateContent`;
+
+  try {
+    const result = await httpPost(url, {
+      contents: [{ role: 'user', parts: [{ text: prompt }] }]
+    }, { 'Grazie-Authenticate-JWT': token });
+
+    if (result.candidates && result.candidates[0]) {
+      console.log(result.candidates[0].content.parts[0].text);
+    } else if (result.error) {
+      console.error(`Error: ${result.error.message}`);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+  }
+}
+
+async function runInteractive(model) {
+  console.log(`Gemini Interactive (${model})`);
+  console.log('Type your message, press Enter to send. Ctrl+C to exit.\n');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const history = [];
+
+  const askQuestion = () => {
+    rl.question('You: ', async (input) => {
+      if (!input.trim()) {
+        askQuestion();
+        return;
+      }
+
+      history.push({ role: 'user', parts: [{ text: input }] });
+
+      const url = `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/${model}:generateContent`;
+
+      try {
+        const result = await httpPost(url, { contents: history }, { 'Grazie-Authenticate-JWT': token });
+
+        if (result.candidates && result.candidates[0]) {
+          const response = result.candidates[0].content.parts[0].text;
+          history.push({ role: 'model', parts: [{ text: response }] });
+          console.log(`\nGemini: ${response}\n`);
+        } else if (result.error) {
+          console.error(`Error: ${result.error.message}\n`);
+        }
+      } catch (e) {
+        console.error(`Error: ${e.message}\n`);
+      }
+
+      askQuestion();
+    });
+  };
+
+  rl.on('close', () => {
+    console.log('\nGoodbye!');
+    process.exit(0);
+  });
+
+  askQuestion();
+}
+
+function httpPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const data = JSON.stringify(body);
+
+    const req = https.request({
+      hostname: urlObj.hostname,
+      port: 443,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data),
+        ...headers
+      }
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          reject(new Error('Invalid response'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}

package/bin/jbai-opencode.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+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 args = process.argv.slice(2);
+
+// Check if model specified
+const hasModel = args.includes('--model') || args.includes('-m');
+const finalArgs = hasModel ? args : ['--model', config.MODELS.claude.default, ...args];
+
+// Set environment for OpenCode
+const env = {
+  ...process.env,
+  ANTHROPIC_BASE_URL: endpoints.anthropic,
+  ANTHROPIC_API_KEY: token,
+  OPENAI_API_BASE: endpoints.openai,
+  OPENAI_API_KEY: token
+};
+
+const child = spawn('opencode', finalArgs, {
+  stdio: 'inherit',
+  env
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('❌ OpenCode not found. Install: go install github.com/opencode-ai/opencode@latest');
+  } else {
+    console.error(`Error: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code) => process.exit(code || 0));

package/bin/jbai.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const readline = require('readline');
+const https = require('https');
+const config = require('../lib/config');
+
+const VERSION = require('../package.json').version;
+
+const HELP = `
+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 test            Test all API endpoints
+  jbai env [staging|production]  Switch environment
+  jbai models          List available models
+  jbai help            Show this help
+
+TOOL WRAPPERS:
+  jbai-claude   Launch Claude Code with JetBrains AI
+  jbai-codex    Launch Codex CLI with JetBrains AI
+  jbai-aider    Launch Aider with JetBrains AI
+  jbai-gemini   Launch Gemini with JetBrains AI
+  jbai-opencode Launch OpenCode with JetBrains AI
+
+EXAMPLES:
+  jbai token set                    # Set your token
+  jbai-claude                       # Start Claude Code
+  jbai-codex exec "explain code"    # Run Codex task
+  jbai-aider                        # Start Aider
+
+TOKEN:
+  Get token: ${config.getEndpoints().tokenUrl}
+  Stored at: ${config.TOKEN_FILE}
+`;
+
+async function showTokenStatus() {
+  const token = config.getToken();
+
+  if (!token) {
+    console.log('❌ No token found');
+    console.log(`   Run: jbai token set`);
+    console.log(`   Get token: ${config.getEndpoints().tokenUrl}`);
+    return;
+  }
+
+  console.log(`Token file: ${config.TOKEN_FILE}`);
+  console.log(`Token length: ${token.length} chars`);
+  console.log(`Environment: ${config.getEnvironment()}`);
+
+  const expiry = config.getTokenExpiry(token);
+  if (expiry) {
+    const now = new Date();
+    const daysLeft = Math.floor((expiry - now) / (1000 * 60 * 60 * 24));
+
+    if (config.isTokenExpired(token)) {
+      console.log(`⚠️  Token EXPIRED: ${expiry.toLocaleString()}`);
+      console.log(`   Run: jbai token refresh`);
+    } else {
+      console.log(`✅ Expires: ${expiry.toLocaleString()} (${daysLeft} days left)`);
+    }
+  }
+}
+
+async function setToken() {
+  const endpoints = config.getEndpoints();
+  console.log(`Get token from: ${endpoints.tokenUrl}`);
+  console.log(`Click Profile → 'Copy Developer Token'\n`);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Paste your token: ', (token) => {
+      rl.close();
+
+      if (!token || !token.includes('.')) {
+        console.log('❌ Invalid token format');
+        resolve(false);
+        return;
+      }
+
+      config.setToken(token);
+      console.log('\n✅ Token saved!');
+      showTokenStatus();
+      resolve(true);
+    });
+  });
+}
+
+async function testEndpoints() {
+  const token = config.getToken();
+  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`);
+
+  // Test OpenAI
+  process.stdout.write('1. OpenAI Proxy (GPT): ');
+  try {
+    const result = await httpPost(
+      `${endpoints.openai}/chat/completions`,
+      { model: 'gpt-4o-2024-11-20', messages: [{ role: 'user', content: 'Say OK' }], max_tokens: 5 },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+    console.log(result.choices ? '✅ Working' : '❌ Failed');
+  } catch (e) {
+    console.log(`❌ ${e.message}`);
+  }
+
+  // Test Anthropic
+  process.stdout.write('2. Anthropic Proxy (Claude): ');
+  try {
+    const result = await httpPost(
+      `${endpoints.anthropic}/messages`,
+      { model: 'claude-sonnet-4-5-20250929', messages: [{ role: 'user', content: 'Say OK' }], max_tokens: 10 },
+      { 'Grazie-Authenticate-JWT': token, 'anthropic-version': '2023-06-01' }
+    );
+    console.log(result.content ? '✅ Working' : '❌ Failed');
+  } catch (e) {
+    console.log(`❌ ${e.message}`);
+  }
+
+  // Test Google
+  process.stdout.write('3. Google Proxy (Gemini): ');
+  try {
+    const result = await httpPost(
+      `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/gemini-2.5-flash:generateContent`,
+      { contents: [{ role: 'user', parts: [{ text: 'Say OK' }] }] },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+    console.log(result.candidates ? '✅ Working' : '❌ Failed');
+  } catch (e) {
+    console.log(`❌ ${e.message}`);
+  }
+}
+
+function httpPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const data = JSON.stringify(body);
+
+    const req = https.request({
+      hostname: urlObj.hostname,
+      port: 443,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data),
+        ...headers
+      }
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          reject(new Error('Invalid response'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+function showModels() {
+  console.log('Available Models:\n');
+
+  console.log('Claude (Anthropic):');
+  config.MODELS.claude.available.forEach((m, i) => {
+    const def = m === config.MODELS.claude.default ? ' (default)' : '';
+    console.log(`  - ${m}${def}`);
+  });
+
+  console.log('\nGPT (OpenAI):');
+  config.MODELS.openai.available.forEach((m, i) => {
+    const def = m === config.MODELS.openai.default ? ' (default)' : '';
+    console.log(`  - ${m}${def}`);
+  });
+
+  console.log('\nGemini (Google):');
+  config.MODELS.gemini.available.forEach((m, i) => {
+    const def = m === config.MODELS.gemini.default ? ' (default)' : '';
+    console.log(`  - ${m}${def}`);
+  });
+}
+
+function setEnvironment(env) {
+  if (!['staging', 'production'].includes(env)) {
+    console.log('Usage: jbai env [staging|production]');
+    console.log(`Current: ${config.getEnvironment()}`);
+    return;
+  }
+
+  const cfg = config.getConfig();
+  cfg.environment = env;
+  config.setConfig(cfg);
+  console.log(`✅ Switched to ${env}`);
+  console.log(`   Token URL: ${config.ENDPOINTS[env].tokenUrl}`);
+}
+
+// Main
+const [,, command, ...args] = process.argv;
+
+switch (command) {
+  case 'token':
+    if (args[0] === 'set' || args[0] === 'refresh') {
+      setToken();
+    } else {
+      showTokenStatus();
+    }
+    break;
+  case 'test':
+    testEndpoints();
+    break;
+  case 'models':
+    showModels();
+    break;
+  case 'env':
+    setEnvironment(args[0]);
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    console.log(HELP);
+    break;
+  case 'version':
+  case '--version':
+  case '-v':
+    console.log(`jbai-cli v${VERSION}`);
+    break;
+  default:
+    console.log(`Unknown command: ${command}`);
+    console.log('Run: jbai help');
+}

package/lib/config.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.jbai');
+const TOKEN_FILE = path.join(CONFIG_DIR, 'token');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const ENDPOINTS = {
+  staging: {
+    base: 'https://api.stgn.jetbrains.ai',
+    openai: 'https://api.stgn.jetbrains.ai/user/v5/llm/openai/v1',
+    anthropic: 'https://api.stgn.jetbrains.ai/user/v5/llm/anthropic/v1',
+    google: 'https://api.stgn.jetbrains.ai/user/v5/llm/google/v1/vertex',
+    tokenUrl: 'https://platform.stgn.jetbrains.ai/'
+  },
+  production: {
+    base: 'https://api.jetbrains.ai',
+    openai: 'https://api.jetbrains.ai/user/v5/llm/openai/v1',
+    anthropic: 'https://api.jetbrains.ai/user/v5/llm/anthropic/v1',
+    google: 'https://api.jetbrains.ai/user/v5/llm/google/v1/vertex',
+    tokenUrl: 'https://platform.jetbrains.ai/'
+  }
+};
+
+const MODELS = {
+  claude: {
+    default: 'claude-sonnet-4-5-20250929',
+    available: [
+      'claude-sonnet-4-5-20250929',
+      'claude-opus-4-1-20250805',
+      'claude-sonnet-4-20250514',
+      'claude-3-7-sonnet-20250219',
+      'claude-3-5-haiku-20241022'
+    ]
+  },
+  openai: {
+    default: 'gpt-4o-2024-11-20',
+    available: [
+      'gpt-4o-2024-11-20',
+      'gpt-5-2025-08-07',
+      'gpt-5.1-2025-11-13',
+      'gpt-5-mini-2025-08-07',
+      'o3-2025-04-16',
+      'o3-mini-2025-01-31'
+    ]
+  },
+  gemini: {
+    default: 'gemini-2.5-flash',
+    available: [
+      'gemini-2.5-flash',
+      'gemini-2.5-pro',
+      'gemini-3-pro-preview',
+      'gemini-3-flash-preview'
+    ]
+  }
+};
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+function getToken() {
+  if (!fs.existsSync(TOKEN_FILE)) {
+    return null;
+  }
+  return fs.readFileSync(TOKEN_FILE, 'utf-8').trim();
+}
+
+function setToken(token) {
+  ensureConfigDir();
+  fs.writeFileSync(TOKEN_FILE, token.trim(), { mode: 0o600 });
+}
+
+function getConfig() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return { environment: 'staging' };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return { environment: 'staging' };
+  }
+}
+
+function setConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function getEnvironment() {
+  const config = getConfig();
+  return config.environment || 'staging';
+}
+
+function getEndpoints() {
+  return ENDPOINTS[getEnvironment()];
+}
+
+function parseJWT(token) {
+  try {
+    const payload = token.split('.')[1];
+    const decoded = Buffer.from(payload, 'base64url').toString('utf-8');
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+
+function getTokenExpiry(token) {
+  const payload = parseJWT(token);
+  if (!payload || !payload.exp) return null;
+  return new Date(payload.exp * 1000);
+}
+
+function isTokenExpired(token) {
+  const expiry = getTokenExpiry(token);
+  if (!expiry) return true;
+  return expiry < new Date();
+}
+
+module.exports = {
+  CONFIG_DIR,
+  TOKEN_FILE,
+  CONFIG_FILE,
+  ENDPOINTS,
+  MODELS,
+  ensureConfigDir,
+  getToken,
+  setToken,
+  getConfig,
+  setConfig,
+  getEnvironment,
+  getEndpoints,
+  parseJWT,
+  getTokenExpiry,
+  isTokenExpired
+};

package/lib/postinstall.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const config = require('./config');
+
+console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                    jbai-cli installed!                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+Next steps:
+
+1. Get your token from: ${config.ENDPOINTS.staging.tokenUrl}
+   (Click Profile → 'Copy Developer Token')
+
+2. Set your token:
+   $ jbai token set
+
+3. Start using AI tools:
+   $ jbai-claude     # Claude Code
+   $ jbai-codex      # OpenAI Codex
+   $ jbai-aider      # Aider
+   $ jbai-gemini     # Gemini
+
+Run 'jbai help' for more options.
+`);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "jbai-cli",
+  "version": "1.0.0",
+  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Aider, Gemini) with JetBrains AI Platform",
+  "keywords": [
+    "jetbrains",
+    "ai",
+    "claude",
+    "codex",
+    "aider",
+    "gemini",
+    "cli",
+    "openai",
+    "anthropic"
+  ],
+  "author": "Andrii Shchupliak",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ashchupliak/jbai-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/ashchupliak/jbai-cli/issues"
+  },
+  "homepage": "https://github.com/ashchupliak/jbai-cli#readme",
+  "bin": {
+    "jbai": "./bin/jbai.js",
+    "jbai-claude": "./bin/jbai-claude.js",
+    "jbai-codex": "./bin/jbai-codex.js",
+    "jbai-aider": "./bin/jbai-aider.js",
+    "jbai-gemini": "./bin/jbai-gemini.js",
+    "jbai-opencode": "./bin/jbai-opencode.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "postinstall": "node lib/postinstall.js",
+    "test": "node bin/jbai.js test"
+  }
+}