jbai-cli 1.5.2 → 1.5.4

package/README.md

@@ -70,6 +70,29 @@ jbai-aider --model gemini/gemini-2.5-pro
 jbai-opencode
 ```
 
+### Handoff to Orca Lab (local)
+```bash
+# Continue a task in Orca Lab via local facade
+jbai handoff --task "continue this work in orca-lab"
+```
+
+### In-session handoff (interactive tools)
+While running `jbai-codex`, `jbai-claude`, `jbai-gemini`, or `jbai-opencode`:
+- Press `Ctrl+]` to trigger a handoff to Orca Lab.
+- The last prompt you typed is used as the task.
+
+Optional environment variables:
+- `ORCA_LAB_URL` (default: `http://localhost:3000`)
+- `FACADE_JWT_TOKEN` (local facade auth)
+- `GITHUB_TOKEN` / `GH_TOKEN` (private repos)
+- `JBAI_HANDOFF_TASK` (fallback task if no prompt captured)
+- `JBAI_HANDOFF_REPO` (override repo URL)
+- `JBAI_HANDOFF_REF` (override git ref)
+- `JBAI_HANDOFF_BRANCH` (override working branch)
+- `JBAI_HANDOFF_ENV` (STAGING | PREPROD | PRODUCTION)
+- `JBAI_HANDOFF_MODEL` (Claude model for Orca Lab agent)
+- `JBAI_HANDOFF_OPEN` (set to `false` to avoid opening a browser)
+
 ## Super Mode (Skip Confirmations)
 
 Add `--super` (or `--yolo` or `-s`) to any command to enable maximum permissions:
@@ -157,6 +180,7 @@ jbai-aider --model gemini/gemini-2.5-pro
 | `jbai token set` | Set/update token |
 | `jbai test` | Test API connections |
 | `jbai models` | List all models |
+| `jbai handoff` | Continue a task in Orca Lab |
 | `jbai install` | Install all AI tools |
 | `jbai install claude` | Install specific tool |
 | `jbai doctor` | Check tool installation status |

package/bin/jbai-claude.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
 const config = require('../lib/config');
 
 const token = config.getToken();
@@ -16,6 +16,8 @@ if (config.isTokenExpired(token)) {
 
 const endpoints = config.getEndpoints();
 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'];
@@ -46,21 +48,30 @@ const env = {
 // Remove any existing auth token that might conflict
 delete env.ANTHROPIC_AUTH_TOKEN;
 
-const child = spawn('claude', finalArgs, {
-  stdio: 'inherit',
-  env
+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(),
+  },
 });
 
-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);
-});
-
-child.on('exit', (code) => process.exit(code || 0));
+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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -22,6 +22,8 @@ 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'];
@@ -75,21 +77,30 @@ const childEnv = {
   [envVarName]: token
 };
 
-const child = spawn('codex', finalArgs, {
-  stdio: 'inherit',
-  env: childEnv
+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(),
+  },
 });
 
-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);
-});
-
-child.on('exit', (code) => process.exit(code || 0));
+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

@@ -6,7 +6,7 @@
  * Uses GEMINI_CLI_CUSTOM_HEADERS and GEMINI_BASE_URL for authentication
  */
 
-const { spawn } = require('child_process');
+const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
 const config = require('../lib/config');
 
 const token = config.getToken();
@@ -22,6 +22,8 @@ if (config.isTokenExpired(token)) {
 
 const endpoints = config.getEndpoints();
 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'];
@@ -47,20 +49,29 @@ const env = {
   GEMINI_CLI_CUSTOM_HEADERS: `Grazie-Authenticate-JWT: ${token}`
 };
 
-const child = spawn('gemini', finalArgs, {
-  stdio: 'inherit',
-  env
+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(),
+  },
 });
 
-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);
-});
-
-child.on('exit', (code) => process.exit(code || 0));
+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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -20,6 +20,8 @@ if (config.isTokenExpired(token)) {
 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'];
@@ -58,9 +60,9 @@ const envVarName = environment === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_
 const anthropicProviderName = environment === 'staging' ? 'jbai-anthropic-staging' : 'jbai-anthropic';
 
 // Add/update JetBrains OpenAI provider with custom header (using env var reference)
-// Use openai-compatible SDK which properly sends custom headers
+// Use OpenAI SDK to support max_completion_tokens for GPT-5.x
 opencodeConfig.provider[providerName] = {
-  npm: '@ai-sdk/openai-compatible',
+  npm: '@ai-sdk/openai',
   name: `JetBrains AI OpenAI (${environment})`,
   options: {
     baseURL: endpoints.openai,
@@ -73,14 +75,14 @@ opencodeConfig.provider[providerName] = {
 };
 
 // Add OpenAI models
-// O-series models (o1, o3, o4) don't support max_tokens, they use max_completion_tokens
-// For these models, we omit the output limit to prevent the SDK from sending max_tokens
+// 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 }  // O-series have larger context, no output limit
+      ? { context: 200000, output: 8192 }
       : { context: 128000, output: 8192 }
   };
 });
@@ -132,21 +134,30 @@ const childEnv = {
   [envVarName]: token
 };
 
-const child = spawn('opencode', finalArgs, {
-  stdio: 'inherit',
-  env: childEnv
-});
-
-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);
+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(),
+  },
 });
 
-child.on('exit', (code) => process.exit(code || 0));
+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.js

@@ -4,6 +4,7 @@ const { spawn, execSync } = require('child_process');
 const readline = require('readline');
 const https = require('https');
 const config = require('../lib/config');
+const { createHandoff } = require('../lib/handoff');
 
 const TOOLS = {
   claude: {
@@ -42,6 +43,7 @@ COMMANDS:
   jbai token set       Set token interactively
   jbai token refresh   Refresh expired token
   jbai test            Test API endpoints (incl. Codex /responses)
+  jbai handoff         Continue task in Orca Lab
   jbai env [staging|production]  Switch environment
   jbai models          List available models
   jbai install         Install all AI tools (claude, codex, gemini, opencode)
@@ -66,6 +68,7 @@ EXAMPLES:
   jbai-claude                       # Start Claude Code
   jbai-codex exec "explain code"    # Run Codex task
   jbai-gemini                       # Start Gemini CLI
+  jbai handoff --task "fix lint"    # Handoff task to Orca Lab
 
 TOKEN:
   Get token: ${config.getEndpoints().tokenUrl}
@@ -137,13 +140,22 @@ async function testEndpoints() {
 
   const endpoints = config.getEndpoints();
   console.log(`Testing JetBrains AI Platform (${config.getEnvironment()})\n`);
+  const defaultOpenAIModel = config.MODELS.openai.default;
+  const useCompletionTokens = defaultOpenAIModel.startsWith('gpt-5') ||
+    defaultOpenAIModel.startsWith('o1') ||
+    defaultOpenAIModel.startsWith('o3') ||
+    defaultOpenAIModel.startsWith('o4');
 
   // Test OpenAI
   process.stdout.write('1. OpenAI Proxy (Chat): ');
   try {
     const result = await httpPost(
       `${endpoints.openai}/chat/completions`,
-      { model: config.MODELS.openai.default, messages: [{ role: 'user', content: 'Say OK' }], max_tokens: 5 },
+      {
+        model: defaultOpenAIModel,
+        messages: [{ role: 'user', content: 'Say OK' }],
+        ...(useCompletionTokens ? { max_completion_tokens: 5 } : { max_tokens: 5 })
+      },
       { 'Grazie-Authenticate-JWT': token }
     );
     const ok = result.statusCode === 200 && Array.isArray(result.json?.choices);
@@ -408,6 +420,142 @@ async function installTools(toolKey) {
   console.log('Run: jbai doctor  to verify');
 }
 
+const HANDOFF_HELP = `
+jbai handoff - Continue a task in Orca Lab
+
+Usage:
+  jbai handoff --task "your task"
+  jbai handoff "your task"
+
+Options:
+  --task, -t            Task description (or pass as positional)
+  --repo, -r            Git repo URL (defaults to origin remote)
+  --ref                 Git ref (defaults to current branch)
+  --branch, -b          Working branch name for the agent
+  --model, -m           Claude model (default: ${config.MODELS.claude.default})
+  --grazie-env, -e      STAGING | PREPROD | PRODUCTION
+  --grazie-token        Override Grazie token (default: ~/.jbai/token)
+  --git-token, -g       GitHub token (default: GITHUB_TOKEN/GH_TOKEN)
+  --facade-token, -f    Facade JWT token (default: FACADE_JWT_TOKEN)
+  --orca-url, -o        Orca Lab URL (default: http://localhost:3000)
+  --no-open             Do not open the Orca Lab URL
+  --no-auto-start       Do not auto-start the agent task
+  --help                Show this help
+`;
+
+function parseArgs(argv) {
+  const opts = {};
+  const rest = [];
+  const shortMap = {
+    t: 'task',
+    r: 'repo',
+    b: 'branch',
+    m: 'model',
+    e: 'grazie-env',
+    g: 'git-token',
+    f: 'facade-token',
+    o: 'orca-url',
+    h: 'help'
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--') {
+      rest.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith('--')) {
+      if (arg === '--no-open') {
+        opts.open = false;
+        continue;
+      }
+      if (arg === '--no-auto-start') {
+        opts.autoStart = false;
+        continue;
+      }
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        opts[key] = next;
+        i++;
+      } else {
+        opts[key] = true;
+      }
+      continue;
+    }
+    if (arg.startsWith('-') && arg.length === 2) {
+      const short = arg.slice(1);
+      const key = shortMap[short];
+      if (!key) {
+        rest.push(arg);
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        opts[key] = next;
+        i++;
+      } else {
+        opts[key] = true;
+      }
+      continue;
+    }
+    rest.push(arg);
+  }
+
+  return { opts, rest };
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => data += chunk);
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(''));
+  });
+}
+
+async function handoffToOrca(rawArgs) {
+  const { opts, rest } = parseArgs(rawArgs);
+  if (opts.help) {
+    console.log(HANDOFF_HELP);
+    return;
+  }
+
+  let task = opts.task || rest.join(' ').trim();
+  if (!task && !process.stdin.isTTY) {
+    task = (await readStdin()).trim();
+  }
+  if (!task) {
+    console.log(HANDOFF_HELP);
+    process.exit(1);
+  }
+
+  try {
+    const result = await createHandoff({
+      task,
+      repoUrl: opts.repo,
+      ref: opts.ref,
+      branchName: opts.branch,
+      gitToken: opts['git-token'] || opts.gitToken,
+      facadeToken: opts['facade-token'] || opts.facadeToken,
+      orcaUrl: opts['orca-url'] || opts.orcaUrl,
+      grazieToken: opts['grazie-token'] || opts.grazieToken,
+      grazieEnvironment: opts['grazie-env'] || opts.grazieEnv,
+      grazieModel: opts.model,
+      autoStart: opts.autoStart !== false,
+      shouldOpen: opts.open !== false,
+      source: 'jbai-cli',
+    });
+    console.log('✅ Handoff created');
+    console.log(`Environment: ${result.environmentId}`);
+    console.log(`Open: ${result.environmentUrl}`);
+  } catch (error) {
+    console.error(`❌ ${error instanceof Error ? error.message : 'Handoff failed'}`);
+    process.exit(1);
+  }
+}
+
 // Main
 const [,, command, ...args] = process.argv;
 
@@ -422,6 +570,9 @@ switch (command) {
   case 'test':
     testEndpoints();
     break;
+  case 'handoff':
+    handoffToOrca(args);
+    break;
   case 'models':
     showModels();
     break;

package/bin/test-clients.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+/**
+ * E2E Client Testing Script
+ * Tests that each jbai client can successfully execute a task with each available model.
+ * Uses the actual APIs to verify end-to-end functionality.
+ */
+
+const https = require('https');
+const config = require('../lib/config');
+
+const token = config.getToken();
+if (!token) {
+  console.error('❌ No token found. Run: jbai token set');
+  process.exit(1);
+}
+
+const endpoints = config.getEndpoints();
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m'
+};
+
+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 + urlObj.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data),
+        ...headers
+      },
+      timeout: 60000
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(body);
+          resolve({ status: res.statusCode, data: parsed });
+        } catch {
+          resolve({ status: res.statusCode, data: body, raw: true });
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(e));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Timeout'));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+
+// Test Claude (Anthropic API)
+async function testClaude(model) {
+  try {
+    const result = await httpPost(
+      `${endpoints.anthropic}/messages`,
+      {
+        model: model,
+        messages: [{ role: 'user', content: 'Reply with exactly: JBAI_OK' }],
+        max_tokens: 20
+      },
+      {
+        'Grazie-Authenticate-JWT': token,
+        'anthropic-version': '2023-06-01'
+      }
+    );
+
+    if (result.status === 200 && result.data.content) {
+      const response = result.data.content[0]?.text || '';
+      if (response.includes('JBAI_OK')) {
+        return { success: true, message: 'OK', response };
+      }
+      return { success: true, message: 'OK (response varied)', response };
+    } else if (result.status === 429) {
+      return { success: true, message: 'Rate limited (model works)', error: 'Rate limit' };
+    } 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 };
+  }
+}
+
+// Test Codex (OpenAI Responses API - used by codex CLI)
+async function testCodex(model) {
+  try {
+    // Codex uses the OpenAI "responses" API format
+    // For testing, we use chat/completions which is what the proxy supports
+    const needsCompletionTokens = model.startsWith('gpt-5') || model.startsWith('o1') ||
+                                   model.startsWith('o3') || model.startsWith('o4');
+
+    const bodyParams = needsCompletionTokens
+      ? { max_completion_tokens: 100 }
+      : { max_tokens: 20 };
+
+    const result = await httpPost(
+      `${endpoints.openai}/chat/completions`,
+      {
+        model: model,
+        messages: [{ role: 'user', content: 'Reply with exactly: JBAI_OK' }],
+        ...bodyParams
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200 && result.data.choices) {
+      const response = result.data.choices[0]?.message?.content || '';
+      if (response.includes('JBAI_OK')) {
+        return { success: true, message: 'OK', response };
+      }
+      return { success: true, message: 'OK (response varied)', response };
+    } else if (result.status === 429) {
+      return { success: true, message: 'Rate limited (model works)', error: 'Rate limit' };
+    } 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 };
+  }
+}
+
+// Test OpenCode (OpenAI Chat Completions API)
+async function testOpenCode(model) {
+  // OpenCode uses the same OpenAI API as Codex
+  return testCodex(model);
+}
+
+// Test Gemini (Vertex AI API)
+async function testGemini(model) {
+  try {
+    const result = await httpPost(
+      `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/${model}:generateContent`,
+      {
+        contents: [{ role: 'user', parts: [{ text: 'Reply with exactly: JBAI_OK' }] }]
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200 && result.data.candidates) {
+      const response = result.data.candidates[0]?.content?.parts?.[0]?.text || '';
+      if (response.includes('JBAI_OK')) {
+        return { success: true, message: 'OK', response };
+      }
+      return { success: true, message: 'OK (response varied)', response };
+    } else if (result.status === 429) {
+      return { success: true, message: 'Rate limited (model works)', error: 'Rate limit' };
+    } 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 CLIENT TESTING${colors.reset}`);
+  console.log(`Environment: ${config.getEnvironment()}`);
+  console.log(`${'='.repeat(70)}\n`);
+
+  const results = {
+    claude: { working: [], failing: [] },
+    codex: { working: [], failing: [] },
+    opencode: { working: [], failing: [] },
+    gemini: { working: [], failing: [] }
+  };
+
+  // Test jbai-claude with all Claude models
+  console.log(`${colors.cyan}Testing jbai-claude with all Claude models...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.claude.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testClaude(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.claude.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.claude.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Test jbai-codex with all Codex models
+  console.log(`\n${colors.cyan}Testing jbai-codex with all Codex models...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.codex.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testCodex(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 jbai-opencode with all OpenAI models
+  console.log(`\n${colors.cyan}Testing jbai-opencode with all OpenAI models...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.openai.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testOpenCode(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.opencode.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.opencode.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Test jbai-gemini with all Gemini models
+  console.log(`\n${colors.cyan}Testing jbai-gemini with all Gemini models...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.gemini.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testGemini(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.gemini.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.gemini.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Summary
+  console.log(`\n${'='.repeat(70)}`);
+  console.log(`${colors.cyan}SUMMARY${colors.reset}`);
+  console.log(`${'='.repeat(70)}`);
+
+  const totalWorking = results.claude.working.length + results.codex.working.length +
+                       results.opencode.working.length + results.gemini.working.length;
+  const totalFailing = results.claude.failing.length + results.codex.failing.length +
+                       results.opencode.failing.length + results.gemini.failing.length;
+
+  console.log(`\n${colors.green}Working: ${totalWorking}${colors.reset}`);
+  console.log(`${colors.red}Failing: ${totalFailing}${colors.reset}`);
+
+  console.log(`\n${colors.cyan}By Client:${colors.reset}`);
+  console.log(`  jbai-claude:   ${colors.green}${results.claude.working.length}${colors.reset} working, ${colors.red}${results.claude.failing.length}${colors.reset} failing`);
+  console.log(`  jbai-codex:    ${colors.green}${results.codex.working.length}${colors.reset} working, ${colors.red}${results.codex.failing.length}${colors.reset} failing`);
+  console.log(`  jbai-opencode: ${colors.green}${results.opencode.working.length}${colors.reset} working, ${colors.red}${results.opencode.failing.length}${colors.reset} failing`);
+  console.log(`  jbai-gemini:   ${colors.green}${results.gemini.working.length}${colors.reset} working, ${colors.red}${results.gemini.failing.length}${colors.reset} failing`);
+
+  if (totalFailing > 0) {
+    console.log(`\n${colors.red}FAILING MODELS:${colors.reset}`);
+
+    if (results.claude.failing.length > 0) {
+      console.log(`\n  jbai-claude:`);
+      results.claude.failing.forEach(f => console.log(`    - ${f.model}: ${f.error}`));
+    }
+    if (results.codex.failing.length > 0) {
+      console.log(`\n  jbai-codex:`);
+      results.codex.failing.forEach(f => console.log(`    - ${f.model}: ${f.error}`));
+    }
+    if (results.opencode.failing.length > 0) {
+      console.log(`\n  jbai-opencode:`);
+      results.opencode.failing.forEach(f => console.log(`    - ${f.model}: ${f.error}`));
+    }
+    if (results.gemini.failing.length > 0) {
+      console.log(`\n  jbai-gemini:`);
+      results.gemini.failing.forEach(f => console.log(`    - ${f.model}: ${f.error}`));
+    }
+  } else {
+    console.log(`\n${colors.green}All clients work with all their available models!${colors.reset}`);
+  }
+
+  console.log(`\n${'='.repeat(70)}\n`);
+
+  // Exit with error code if any failures
+  if (totalFailing > 0) {
+    process.exit(1);
+  }
+
+  return results;
+}
+
+// Run tests
+runTests().catch(err => {
+  console.error('Test error:', err);
+  process.exit(1);
+});

package/lib/config.js

@@ -38,7 +38,6 @@ const MODELS = {
       'claude-haiku-4-5-20251001',
       // Claude 4.x series
       'claude-opus-4-1-20250805',
-      'claude-opus-4-20250514',
       'claude-sonnet-4-20250514',
       // Claude 3.x series
       'claude-3-7-sonnet-20250219',
@@ -75,15 +74,24 @@ const MODELS = {
       'gpt-3.5-turbo-0125'
     ]
   },
-  // Codex CLI uses the OpenAI "responses" API (wire_api = "responses")
+  // Codex CLI uses OpenAI models via the "responses" API (wire_api = "responses")
+  // Uses the same models as openai, just different API wire format
   codex: {
-    default: 'gpt-5.2-codex',
+    default: 'o3-2025-04-16',
     available: [
-      'gpt-5-codex',
-      'gpt-5.1-codex',
-      'gpt-5.1-codex-mini',
-      'gpt-5.1-codex-max',
-      'gpt-5.2-codex'
+      // 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
+      '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'
     ]
   },
   gemini: {

package/lib/handoff.js

@@ -0,0 +1,152 @@
+const { execSync } = require('child_process');
+const config = require('./config');
+
+function getGitOutput(command, cwd = process.cwd()) {
+  try {
+    return execSync(command, { stdio: ['ignore', 'pipe', 'ignore'], cwd }).toString().trim();
+  } catch {
+    return '';
+  }
+}
+
+function getGitRepoUrl(cwd = process.cwd()) {
+  return getGitOutput('git remote get-url origin', cwd);
+}
+
+function getGitRef(cwd = process.cwd()) {
+  const branch = getGitOutput('git rev-parse --abbrev-ref HEAD', cwd);
+  if (branch && branch !== 'HEAD') {
+    return branch;
+  }
+  return getGitOutput('git rev-parse HEAD', cwd);
+}
+
+function openUrl(url) {
+  const escaped = url.replace(/"/g, '\\"');
+  try {
+    if (process.platform === 'darwin') {
+      execSync(`open "${escaped}"`, { stdio: 'ignore' });
+      return true;
+    }
+    if (process.platform === 'win32') {
+      execSync(`start "" "${escaped}"`, { stdio: 'ignore' });
+      return true;
+    }
+    execSync(`xdg-open "${escaped}"`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeGrazieEnvironment(env) {
+  if (!env) {
+    return config.getEnvironment() === 'production' ? 'PRODUCTION' : 'STAGING';
+  }
+  return env.toString().toUpperCase();
+}
+
+function getDefaultModel() {
+  return config.MODELS.claude.default;
+}
+
+function parseBool(value, fallback) {
+  if (value === undefined || value === null) {
+    return fallback;
+  }
+  const normalized = value.toString().toLowerCase();
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
+  return fallback;
+}
+
+async function createHandoff({
+  task,
+  repoUrl,
+  ref,
+  branchName,
+  grazieToken,
+  grazieEnvironment,
+  grazieModel,
+  gitToken,
+  facadeToken,
+  orcaUrl,
+  source,
+  autoStart,
+  shouldOpen,
+  cwd,
+}) {
+  const finalTask = task && task.trim()
+    ? task.trim()
+    : 'Continue the current task from the CLI session.';
+
+  const finalRepoUrl = repoUrl && repoUrl.trim() ? repoUrl.trim() : getGitRepoUrl(cwd);
+  if (!finalRepoUrl) {
+    throw new Error('Could not determine git repo. Use --repo or set JBAI_HANDOFF_REPO.');
+  }
+
+  const finalGrazieToken = grazieToken || config.getToken();
+  if (!finalGrazieToken) {
+    throw new Error('No Grazie token found. Run: jbai token set');
+  }
+  if (config.isTokenExpired(finalGrazieToken)) {
+    throw new Error('Grazie token expired. Run: jbai token refresh');
+  }
+
+  const finalRef = ref || getGitRef(cwd);
+  const finalOrcaUrl = (orcaUrl || process.env.ORCA_LAB_URL || 'http://localhost:3000')
+    .replace(/\/$/, '');
+  const finalFacadeToken = facadeToken || process.env.FACADE_JWT_TOKEN || '';
+  const finalGitToken = gitToken || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || '';
+  const finalGrazieEnv = normalizeGrazieEnvironment(
+    grazieEnvironment || process.env.JBAI_HANDOFF_ENV
+  );
+  const finalModel = grazieModel || process.env.JBAI_HANDOFF_MODEL || getDefaultModel();
+  const finalAutoStart = parseBool(autoStart ?? process.env.JBAI_HANDOFF_AUTO_START, true);
+  const openBrowser = parseBool(shouldOpen ?? process.env.JBAI_HANDOFF_OPEN, true);
+
+  const payload = {
+    task: finalTask,
+    repoUrl: finalRepoUrl,
+    ref: finalRef || undefined,
+    branchName: branchName || process.env.JBAI_HANDOFF_BRANCH || undefined,
+    gitToken: finalGitToken || undefined,
+    grazieToken: finalGrazieToken,
+    grazieEnvironment: finalGrazieEnv,
+    grazieModel: finalModel,
+    source: source || 'jbai-cli',
+    autoStart: finalAutoStart,
+  };
+
+  const headers = {
+    'Content-Type': 'application/json',
+    ...(finalFacadeToken ? { Authorization: `Bearer ${finalFacadeToken}` } : {}),
+  };
+
+  const response = await fetch(`${finalOrcaUrl}/api/handoff`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => '');
+    const detail = errorText ? ` ${errorText}` : '';
+    throw new Error(`Orca Lab handoff failed (${response.status}).${detail}`);
+  }
+
+  const result = await response.json();
+
+  if (openBrowser && result.environmentUrl) {
+    openUrl(result.environmentUrl);
+  }
+
+  return result;
+}
+
+module.exports = {
+  createHandoff,
+  getGitRepoUrl,
+  getGitRef,
+  openUrl,
+};

package/lib/interactive-handoff.js

@@ -0,0 +1,200 @@
+const os = require('os');
+const { spawn } = require('child_process');
+const pty = require('node-pty');
+const { createHandoff } = require('./handoff');
+
+const DEFAULT_TRIGGER = '\x1d'; // Ctrl+]
+const DEFAULT_TRIGGER_LABEL = 'Ctrl+]';
+
+function stripHandoffFlag(args) {
+  const cleaned = [];
+  let disabled = false;
+  for (const arg of args) {
+    if (arg === '--no-handoff') {
+      disabled = true;
+      continue;
+    }
+    cleaned.push(arg);
+  }
+  return { args: cleaned, disabled };
+}
+
+function isPrintableChar(char) {
+  const code = char.charCodeAt(0);
+  return code >= 32 && code !== 127;
+}
+
+function shouldIgnoreLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  if (trimmed.startsWith('/')) return true;
+  return false;
+}
+
+function buildTrigger() {
+  const trigger = process.env.JBAI_HANDOFF_TRIGGER || DEFAULT_TRIGGER;
+  const label = process.env.JBAI_HANDOFF_TRIGGER_LABEL || DEFAULT_TRIGGER_LABEL;
+  return { trigger, label };
+}
+
+function runWithHandoff({
+  command,
+  args,
+  env,
+  toolName,
+  handoffDefaults = {},
+}) {
+  const { trigger, label } = buildTrigger();
+  const canUsePty = process.stdin.isTTY && process.stdout.isTTY;
+
+  if (!canUsePty || handoffDefaults.enabled === false) {
+    const child = spawn(command, args, { stdio: 'inherit', env });
+    return child;
+  }
+
+  process.stderr.write(`ℹ️  Handoff trigger: ${label}\n`);
+
+  const ptyProcess = pty.spawn(command, args, {
+    name: 'xterm-256color',
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+    cwd: process.cwd(),
+    env,
+  });
+
+  let lineBuffer = '';
+  let lastPrompt = '';
+  let inEscape = false;
+  let handoffInProgress = false;
+
+  const updateLineBuffer = (text) => {
+    for (const char of text) {
+      if (char === '\u001b') {
+        inEscape = true;
+        continue;
+      }
+      if (inEscape) {
+        if (/[a-zA-Z~]/.test(char)) {
+          inEscape = false;
+        }
+        continue;
+      }
+      if (char === '\r' || char === '\n') {
+        if (!shouldIgnoreLine(lineBuffer)) {
+          lastPrompt = lineBuffer.trim();
+        }
+        lineBuffer = '';
+        continue;
+      }
+      if (char === '\u007f' || char === '\b') {
+        if (lineBuffer.length > 0) {
+          lineBuffer = lineBuffer.slice(0, -1);
+        }
+        continue;
+      }
+      if (!isPrintableChar(char)) {
+        continue;
+      }
+      lineBuffer += char;
+      if (lineBuffer.length > 4000) {
+        lineBuffer = lineBuffer.slice(-4000);
+      }
+    }
+  };
+
+  const triggerHandoff = async () => {
+    if (handoffInProgress) return;
+    handoffInProgress = true;
+    try {
+      const fallbackTask = process.env.JBAI_HANDOFF_TASK;
+      const task = (lastPrompt && lastPrompt.trim()) || fallbackTask || '';
+      if (!task) {
+        process.stderr.write('⚠️  No recent prompt detected; set JBAI_HANDOFF_TASK.\n');
+        return;
+      }
+
+      process.stderr.write('🚀 Creating Orca Lab handoff...\n');
+      const result = await createHandoff({
+        task,
+        repoUrl: process.env.JBAI_HANDOFF_REPO || handoffDefaults.repoUrl,
+        ref: process.env.JBAI_HANDOFF_REF || handoffDefaults.ref,
+        branchName: process.env.JBAI_HANDOFF_BRANCH || handoffDefaults.branchName,
+        gitToken: process.env.GITHUB_TOKEN || process.env.GH_TOKEN || handoffDefaults.gitToken,
+        facadeToken: process.env.FACADE_JWT_TOKEN || handoffDefaults.facadeToken,
+        orcaUrl: process.env.ORCA_LAB_URL || handoffDefaults.orcaUrl,
+        grazieToken: handoffDefaults.grazieToken,
+        grazieEnvironment: handoffDefaults.grazieEnvironment,
+        grazieModel: handoffDefaults.grazieModel,
+        source: toolName || 'jbai-cli',
+        autoStart: true,
+        shouldOpen: true,
+        cwd: handoffDefaults.cwd,
+      });
+
+      process.stderr.write(`✅ Handoff ready: ${result.environmentUrl}\n`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Handoff failed';
+      process.stderr.write(`❌ ${message}\n`);
+    } finally {
+      handoffInProgress = false;
+    }
+  };
+
+  ptyProcess.onData((data) => process.stdout.write(data));
+
+  const onStdinData = (data) => {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const hasTrigger = buffer.includes(Buffer.from(trigger));
+
+    const sanitized = hasTrigger
+      ? Buffer.from(buffer.toString('utf8').split(trigger).join(''), 'utf8')
+      : buffer;
+
+    if (hasTrigger) {
+      triggerHandoff();
+    }
+
+    if (sanitized.length > 0) {
+      updateLineBuffer(sanitized.toString('utf8'));
+      ptyProcess.write(sanitized);
+    }
+  };
+
+  const onResize = () => {
+    try {
+      ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+    } catch {
+      // Ignore resize errors
+    }
+  };
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on('data', onStdinData);
+
+  if (process.stdout.isTTY) {
+    process.stdout.on('resize', onResize);
+  }
+
+  const cleanup = () => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.off('data', onStdinData);
+    if (process.stdout.isTTY) {
+      process.stdout.off('resize', onResize);
+    }
+  };
+
+  ptyProcess.onExit(({ exitCode }) => {
+    cleanup();
+    process.exit(exitCode || 0);
+  });
+
+  return ptyProcess;
+}
+
+module.exports = {
+  runWithHandoff,
+  stripHandoffFlag,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbai-cli",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Gemini CLI, OpenCode) with JetBrains AI Platform",
   "keywords": [
     "jetbrains",
@@ -18,18 +18,18 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JetBrains/jbai-cli"
+    "url": "git+https://github.com/JetBrains/jbai-cli.git"
   },
   "bugs": {
     "url": "https://github.com/JetBrains/jbai-cli/issues"
   },
   "homepage": "https://github.com/JetBrains/jbai-cli#readme",
   "bin": {
-    "jbai": "./bin/jbai.js",
-    "jbai-claude": "./bin/jbai-claude.js",
-    "jbai-codex": "./bin/jbai-codex.js",
-    "jbai-gemini": "./bin/jbai-gemini.js",
-    "jbai-opencode": "./bin/jbai-opencode.js"
+    "jbai": "bin/jbai.js",
+    "jbai-claude": "bin/jbai-claude.js",
+    "jbai-codex": "bin/jbai-codex.js",
+    "jbai-gemini": "bin/jbai-gemini.js",
+    "jbai-opencode": "bin/jbai-opencode.js"
   },
   "files": [
     "bin/",
@@ -39,7 +39,9 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "node-pty": "^1.1.0"
+  },
   "scripts": {
     "postinstall": "node lib/postinstall.js",
     "test": "node bin/jbai.js test"