jbai-cli 1.3.1 → 1.5.0

package/bin/jbai-opencode.js

@@ -54,12 +54,14 @@ if (!opencodeConfig.provider) {
 // Environment variable name for the token
 const envVarName = environment === 'staging' ? 'GRAZIE_STAGING_TOKEN' : 'GRAZIE_API_TOKEN';
 
-// Add/update JetBrains provider with custom header (using env var reference)
+// 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-compatible SDK which properly sends custom headers
-// Point to OpenAI endpoint for compatibility
 opencodeConfig.provider[providerName] = {
   npm: '@ai-sdk/openai-compatible',
-  name: `JetBrains AI (${environment})`,
+  name: `JetBrains AI OpenAI (${environment})`,
   options: {
     baseURL: endpoints.openai,
     apiKey: `{env:${envVarName}}`,
@@ -70,15 +72,33 @@ opencodeConfig.provider[providerName] = {
   models: {}
 };
 
-// Add OpenAI models (since we use openai-compatible SDK)
-// Set context and output limits to avoid "max_tokens too large" errors
+// Add OpenAI models
 config.MODELS.openai.available.forEach(model => {
   opencodeConfig.provider[providerName].models[model] = {
     name: model,
-    limit: {
-      context: 128000,
-      output: 8192
+    limit: { 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: {}
+};
+
+// Add Claude models to Anthropic provider
+config.MODELS.claude.available.forEach(model => {
+  opencodeConfig.provider[anthropicProviderName].models[model] = {
+    name: model,
+    limit: { context: 200000, output: 8192 }
   };
 });
 

package/bin/jbai.js

@@ -18,12 +18,6 @@ const TOOLS = {
     install: 'npm install -g @openai/codex',
     check: 'codex --version'
   },
-  aider: {
-    name: 'Aider',
-    command: 'aider',
-    install: 'pipx install aider-chat',
-    check: 'aider --version'
-  },
   gemini: {
     name: 'Gemini CLI',
     command: 'gemini',
@@ -50,7 +44,7 @@ COMMANDS:
   jbai test            Test all API endpoints
   jbai env [staging|production]  Switch environment
   jbai models          List available models
-  jbai install         Install all AI tools (claude, codex, aider)
+  jbai install         Install all AI tools (claude, codex, gemini, opencode)
   jbai install claude  Install specific tool
   jbai doctor          Check which tools are installed
   jbai help            Show this help
@@ -58,7 +52,6 @@ COMMANDS:
 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 CLI with JetBrains AI
   jbai-opencode Launch OpenCode with JetBrains AI
 
@@ -66,13 +59,13 @@ SUPER MODE:
   Add --super (or --yolo or -s) to skip confirmations:
   jbai-claude --super               # Skip permission prompts
   jbai-codex --super                # Full auto mode
-  jbai-aider --super                # Auto-confirm changes
+  jbai-gemini --super               # Auto-confirm changes
 
 EXAMPLES:
   jbai token set                    # Set your token
   jbai-claude                       # Start Claude Code
   jbai-codex exec "explain code"    # Run Codex task
-  jbai-aider                        # Start Aider
+  jbai-gemini                       # Start Gemini CLI
 
 TOKEN:
   Get token: ${config.getEndpoints().tokenUrl}
@@ -219,25 +212,33 @@ function httpPost(url, body, headers) {
 }
 
 function showModels() {
-  console.log('Available Models:\n');
+  console.log('Available Models via JetBrains AI Platform (Grazie):\n');
 
-  console.log('Claude (Anthropic):');
-  config.MODELS.claude.available.forEach((m, i) => {
+  console.log('Claude (Anthropic) - jbai-claude:');
+  config.MODELS.claude.available.forEach((m) => {
     const def = m === config.MODELS.claude.default ? ' (default)' : '';
     console.log(`  - ${m}${def}`);
   });
 
-  console.log('\nGPT (OpenAI):');
-  config.MODELS.openai.available.forEach((m, i) => {
+  console.log('\nGPT (OpenAI) - jbai-codex, jbai-opencode:');
+  config.MODELS.openai.available.forEach((m) => {
     const def = m === config.MODELS.openai.default ? ' (default)' : '';
     console.log(`  - ${m}${def}`);
   });
 
-  console.log('\nGemini (Google):');
-  config.MODELS.gemini.available.forEach((m, i) => {
+  console.log('\nGemini (Google) - jbai-gemini:');
+  config.MODELS.gemini.available.forEach((m) => {
     const def = m === config.MODELS.gemini.default ? ' (default)' : '';
     console.log(`  - ${m}${def}`);
   });
+
+  // Count total
+  const total = config.MODELS.claude.available.length +
+    config.MODELS.openai.available.length +
+    config.MODELS.gemini.available.length;
+  console.log(`\nTotal: ${total} models`);
+  console.log('\nNote: Other providers (DeepSeek, Mistral, Qwen, XAI, Meta) are available');
+  console.log('via Grazie native API but not via OpenAI-compatible CLI tools.');
 }
 
 function setEnvironment(env) {

package/bin/test-models.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+/**
+ * E2E Model Compatibility Testing Script
+ * Tests all configured Grazie models against the API endpoints
+ * to identify which models are valid and which return 404 or errors.
+ */
+
+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: 30000
+    }, (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();
+  });
+}
+
+async function testOpenAIModel(model) {
+  try {
+    // GPT-5.x and O-series models require max_completion_tokens instead of max_tokens
+    const needsCompletionTokens = model.startsWith('gpt-5') || model.startsWith('o1') ||
+                                   model.startsWith('o3') || model.startsWith('o4');
+
+    const bodyParams = needsCompletionTokens
+      ? { max_completion_tokens: 500 }  // O-series needs more tokens for reasoning
+      : { max_tokens: 5 };
+
+    const result = await httpPost(
+      `${endpoints.openai}/chat/completions`,
+      {
+        model: model,
+        messages: [{ role: 'user', content: 'Say OK' }],
+        ...bodyParams
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200 && result.data.choices) {
+      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 testAnthropicModel(model) {
+  try {
+    const result = await httpPost(
+      `${endpoints.anthropic}/messages`,
+      {
+        model: model,
+        messages: [{ role: 'user', content: 'Say OK' }],
+        max_tokens: 10
+      },
+      {
+        'Grazie-Authenticate-JWT': token,
+        'anthropic-version': '2023-06-01'
+      }
+    );
+
+    if (result.status === 200 && result.data.content) {
+      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 testGeminiModel(model) {
+  try {
+    // Gemini API format via Vertex AI proxy
+    const result = await httpPost(
+      `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/${model}:generateContent`,
+      {
+        contents: [{ role: 'user', parts: [{ text: 'Say OK' }] }]
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200 && result.data.candidates) {
+      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}`);
+  console.log(`Environment: ${config.getEnvironment()}`);
+  console.log(`${'='.repeat(70)}\n`);
+
+  const results = {
+    openai: { working: [], failing: [] },
+    anthropic: { working: [], failing: [] },
+    gemini: { working: [], failing: [] }
+  };
+
+  // Test Claude models (Anthropic)
+  console.log(`${colors.cyan}Testing Claude models (jbai-claude)...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.claude.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testAnthropicModel(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.anthropic.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.anthropic.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Test OpenAI models (Codex, OpenCode)
+  console.log(`\n${colors.cyan}Testing OpenAI/GPT models (jbai-codex, jbai-opencode)...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.openai.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testOpenAIModel(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.openai.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.openai.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));
+  for (const model of config.MODELS.gemini.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testGeminiModel(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.anthropic.working.length + results.openai.working.length +
+                       results.gemini.working.length;
+  const totalFailing = results.anthropic.failing.length + results.openai.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(`  Gemini (Google):    ${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 TO REMOVE:${colors.reset}`);
+
+    if (results.anthropic.failing.length > 0) {
+      console.log(`\n  Claude models:`);
+      results.anthropic.failing.forEach(f => console.log(`    - ${f.model}`));
+    }
+    if (results.openai.failing.length > 0) {
+      console.log(`\n  OpenAI models:`);
+      results.openai.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}`));
+    }
+  } else {
+    console.log(`\n${colors.green}All models are working correctly!${colors.reset}`);
+  }
+
+  console.log(`\n${'='.repeat(70)}\n`);
+
+  // Return results for programmatic use
+  return results;
+}
+
+// Run tests
+runTests().catch(console.error);

package/lib/config.js

@@ -12,6 +12,7 @@ const ENDPOINTS = {
     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',
+    profiles: 'https://api.stgn.jetbrains.ai/user/v5/llm/profiles',
     tokenUrl: 'https://platform.stgn.jetbrains.ai/'
   },
   production: {
@@ -19,17 +20,27 @@ const ENDPOINTS = {
     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',
+    profiles: 'https://api.jetbrains.ai/user/v5/llm/profiles',
     tokenUrl: 'https://platform.jetbrains.ai/'
   }
 };
 
+// All models available from JetBrains AI Platform (Grazie)
+// Model names must match EXACTLY what the Grazie API accepts
+// Run 'node bin/test-models.js' to verify model availability
 const MODELS = {
   claude: {
     default: 'claude-sonnet-4-5-20250929',
     available: [
+      // Claude 4.5 series (latest)
+      'claude-opus-4-5-20251101',
       'claude-sonnet-4-5-20250929',
+      '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',
       'claude-3-5-haiku-20241022'
     ]
@@ -37,23 +48,54 @@ const MODELS = {
   openai: {
     default: 'gpt-4o-2024-11-20',
     available: [
-      'gpt-4o-2024-11-20',
-      'gpt-5-2025-08-07',
+      // GPT-5.x series (latest) - require date-versioned names
+      'gpt-5.2-2025-12-11',
+      'gpt-5.2',
       'gpt-5.1-2025-11-13',
+      'gpt-5-2025-08-07',
       'gpt-5-mini-2025-08-07',
+      'gpt-5-nano-2025-08-07',
+      // GPT-4.x series
+      'gpt-4.1-2025-04-14',
+      'gpt-4.1-mini-2025-04-14',
+      'gpt-4.1-nano-2025-04-14',
+      'gpt-4o-2024-11-20',
+      'gpt-4o-mini-2024-07-18',
+      'gpt-4-turbo-2024-04-09',
+      'gpt-4-0613',
+      'gpt-3.5-turbo-0125',
+      // O-series (reasoning) - use max_completion_tokens instead of max_tokens
+      'o4-mini-2025-04-16',
       'o3-2025-04-16',
-      'o3-mini-2025-01-31'
+      'o3-mini-2025-01-31',
+      'o1-2024-12-17'
     ]
   },
   gemini: {
     default: 'gemini-2.5-flash',
     available: [
-      'gemini-2.5-flash',
-      'gemini-2.5-pro',
+      // Gemini 3.x (preview)
       'gemini-3-pro-preview',
-      'gemini-3-flash-preview'
+      'gemini-3-flash-preview',
+      // Gemini 2.5
+      'gemini-2.5-pro',
+      'gemini-2.5-flash',
+      'gemini-2.5-flash-lite',
+      // Gemini 2.0
+      'gemini-2.0-flash-001',
+      'gemini-2.0-flash-lite-001'
     ]
   }
+  // NOTE: Other providers (DeepSeek, Mistral, Qwen, XAI, Meta) 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.
+};
+
+// All models for tools that support multiple providers (OpenCode, Codex)
+const ALL_MODELS = {
+  openai: MODELS.openai.available,
+  anthropic: MODELS.claude.available,
+  gemini: MODELS.gemini.available
 };
 
 function ensureConfigDir() {
@@ -133,11 +175,6 @@ const TOOLS = {
     command: 'codex',
     install: 'npm install -g @openai/codex'
   },
-  aider: {
-    name: 'Aider',
-    command: 'aider',
-    install: 'pipx install aider-chat'
-  },
   gemini: {
     name: 'Gemini CLI',
     command: 'gemini',
@@ -156,6 +193,7 @@ module.exports = {
   CONFIG_FILE,
   ENDPOINTS,
   MODELS,
+  ALL_MODELS,
   TOOLS,
   ensureConfigDir,
   getToken,

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "jbai-cli",
-  "version": "1.3.1",
-  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Aider, Gemini CLI, OpenCode) with JetBrains AI Platform",
+  "version": "1.5.0",
+  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Gemini CLI, OpenCode) with JetBrains AI Platform",
   "keywords": [
     "jetbrains",
     "ai",
     "claude",
     "codex",
-    "aider",
     "gemini",
     "opencode",
     "cli",
@@ -29,7 +28,6 @@
     "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"
   },
@@ -41,9 +39,7 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "yaml": "^2.7.1"
-  },
+  "dependencies": {},
   "scripts": {
     "postinstall": "node lib/postinstall.js",
     "test": "node bin/jbai.js test"

package/bin/jbai-aider.js

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-
-const { spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const yaml = require('yaml');
-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);
-
-// 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));
-
-// Create model settings file with extra headers for JetBrains authentication
-const configDir = path.join(os.homedir(), '.jbai');
-const modelSettingsFile = path.join(configDir, 'aider-model-settings.yml');
-
-// Ensure config directory exists
-if (!fs.existsSync(configDir)) {
-  fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-}
-
-// Create model settings with extra_headers for authentication
-// Use aider/extra_params for global settings that apply to all models
-const modelSettings = [
-  {
-    name: 'aider/extra_params',
-    extra_params: {
-      extra_headers: {
-        'Grazie-Authenticate-JWT': token
-      }
-    }
-  }
-];
-
-// Write model settings file
-fs.writeFileSync(modelSettingsFile, yaml.stringify(modelSettings), { mode: 0o600 });
-
-// Build aider arguments
-// Note: --no-stream is required because JetBrains proxy has stream_options issues
-const hasModel = args.includes('--model');
-const aiderArgs = [
-  '--openai-api-base', endpoints.openai,
-  '--openai-api-key', 'placeholder',
-  '--model-settings-file', modelSettingsFile,
-  '--no-stream'
-];
-
-if (!hasModel) {
-  aiderArgs.push('--model', config.MODELS.openai.default);
-}
-
-// Add super mode flags (auto-confirm all)
-if (superMode) {
-  aiderArgs.push('--yes');
-  console.log('🚀 Super mode: --yes (auto-confirm) enabled');
-}
-
-aiderArgs.push(...args);
-
-const child = spawn('aider', aiderArgs, {
-  stdio: 'inherit',
-  env: process.env
-});
-
-child.on('error', (err) => {
-  if (err.code === 'ENOENT') {
-    const tool = config.TOOLS.aider;
-    console.error(`❌ ${tool.name} not found.\n`);
-    console.error(`Install with: ${tool.install}`);
-    console.error(`Or run: jbai install aider`);
-  } else {
-    console.error(`Error: ${err.message}`);
-  }
-  process.exit(1);
-});
-
-child.on('exit', (code) => process.exit(code || 0));