jbai-cli 1.9.2 → 2.1.0

package/bin/jbai.js

@@ -3,8 +3,13 @@
 const { spawn, execSync } = require('child_process');
 const readline = require('readline');
 const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 const config = require('../lib/config');
 const { createHandoff } = require('../lib/handoff');
+const { getGroupsForTool, showModelsForTool } = require('../lib/model-list');
+const completions = require('../lib/completions');
 
 const TOOLS = {
   claude: {
@@ -53,14 +58,18 @@ jbai-cli v${VERSION} - JetBrains AI Platform CLI Tools
 COMMANDS:
   jbai token           Show token status
   jbai token set       Set token interactively
-  jbai token refresh   Auto-refresh token via API (no UI needed)
+  jbai token refresh          Auto-refresh token via API
+  jbai token refresh <token>  Set new token (saves to ~/.jbai/token + ~/.zshrc)
   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 models [tool]   List Grazie models (all|claude|codex|gemini|opencode|goose|continue)
   jbai install         Install all AI tools (claude, codex, gemini, opencode, goose, continue)
   jbai install claude  Install specific tool
   jbai doctor          Check which tools are installed
+  jbai completions     Print zsh completions to stdout
+  jbai completions --install   Add completions to ~/.zshrc
+  jbai completions --bash      Print bash completions
   jbai help            Show this help
 
 PROXY (for Codex Desktop, Cursor, etc.):
@@ -74,18 +83,35 @@ TOOL WRAPPERS:
   jbai-codex    Launch Codex CLI with JetBrains AI
   jbai-gemini   Launch Gemini CLI with JetBrains AI
   jbai-opencode Launch OpenCode with JetBrains AI
+  jbai-council  Launch Claude + Codex + OpenCode in tmux council mode
+
+MODEL SHORTCUTS (super mode by default):
+  jbai-claude-opus              Claude Code + Opus 4.6
+  jbai-claude-sonnet            Claude Code + Sonnet 4.6
+  jbai-codex-5.3                Codex + GPT-5.3
+  jbai-codex-5.2                Codex + GPT-5.2
+  jbai-codex-rockhopper         Codex + Rockhopper Alpha (OpenAI EAP)
+  jbai-gemini-supernova         Gemini + Supernova (Google EAP)
+  jbai-gemini-3.1               Gemini + 3.1 Pro Preview
+  jbai-opencode-rockhopper      OpenCode + Rockhopper Alpha
+  jbai-opencode-grok            OpenCode + Grok 4 (xAI)
+  jbai-opencode-deepseek        OpenCode + DeepSeek R1
 
 SUPER MODE:
   Add --super (or --yolo or -s) to skip confirmations:
   jbai-claude --super               # Skip permission prompts
   jbai-codex --super                # Full auto mode
   jbai-gemini --super               # Auto-confirm changes
+  (All model shortcuts above run in super mode by default)
 
 EXAMPLES:
   jbai token set                    # Set your token
   jbai-claude                       # Start Claude Code
   jbai-codex exec "explain code"    # Run Codex task
-  jbai-gemini                       # Start Gemini CLI
+  jbai-codex-rockhopper             # Codex with Rockhopper (super mode)
+  jbai-gemini-supernova             # Gemini with Supernova (super mode)
+  jbai-council                      # Launch all 3 agents in tmux
+  jbai-council --super              # All agents in super mode
   jbai handoff --task "fix lint"    # Handoff task to Orca Lab
 
 TOKEN:
@@ -157,7 +183,47 @@ async function setToken() {
   });
 }
 
-async function refreshTokenCommand() {
+function updateZshrcToken(newToken) {
+  const zshrc = path.join(os.homedir(), '.zshrc');
+  if (!fs.existsSync(zshrc)) return false;
+
+  const content = fs.readFileSync(zshrc, 'utf-8');
+  const pattern = /^(export JBAI_PROXY_KEY=").*(")/m;
+  if (!pattern.test(content)) return false;
+
+  const updated = content.replace(pattern, `$1${newToken}$2`);
+  fs.writeFileSync(zshrc, updated);
+  return true;
+}
+
+function saveTokenEverywhere(newToken) {
+  config.setToken(newToken);
+  console.log('  ✅ Saved to ~/.jbai/token');
+
+  if (updateZshrcToken(newToken)) {
+    console.log('  ✅ Updated JBAI_PROXY_KEY in ~/.zshrc');
+  }
+}
+
+async function refreshTokenCommand(providedToken) {
+  // If a token was passed as argument, save it directly (skip API refresh)
+  if (providedToken && providedToken.includes('.')) {
+    const expiry = config.getTokenExpiry(providedToken);
+    if (!expiry) {
+      console.log('❌ Invalid token format (could not parse JWT)');
+      return;
+    }
+    if (config.isTokenExpired(providedToken)) {
+      console.log('❌ Provided token is already expired');
+      return;
+    }
+    console.log('🔄 Saving provided token...');
+    saveTokenEverywhere(providedToken);
+    console.log('✅ Token updated!');
+    showTokenStatus();
+    return;
+  }
+
   const token = config.getToken();
   if (!token) {
     console.log('❌ No token found. Run: jbai token set');
@@ -179,12 +245,13 @@ async function refreshTokenCommand() {
   try {
     console.log('🔄 Refreshing token via API...');
     const newToken = await config.refreshTokenApi(token);
-    config.setToken(newToken);
+    saveTokenEverywhere(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}`);
+    console.log(`❌ API refresh failed: ${e.message}`);
+    console.log(`   Paste token manually: jbai token refresh <token>`);
+    console.log(`   Get a new token: ${config.getEndpoints().tokenUrl}`);
   }
 }
 
@@ -303,41 +370,21 @@ function httpPost(url, body, headers) {
   });
 }
 
-function showModels() {
-  console.log('Available Models via JetBrains AI Platform (Grazie):\n');
-
-  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 Chat) - jbai-opencode:');
-  config.MODELS.openai.available.forEach((m) => {
-    const def = m === config.MODELS.openai.default ? ' (default)' : '';
-    console.log(`  - ${m}${def}`);
-  });
-
-  console.log('\nCodex (OpenAI Responses) - jbai-codex:');
-  config.MODELS.codex.available.forEach((m) => {
-    const def = m === config.MODELS.codex.default ? ' (default)' : '';
-    console.log(`  - ${m}${def}`);
-  });
+function showModels(filter) {
+  const tool = filter || 'all';
+  const heading = tool === 'all'
+    ? 'Available Models via JetBrains AI Platform (Grazie):'
+    : `Available Models via JetBrains AI Platform (Grazie) for ${tool}:`;
 
-  console.log('\nGemini (Google) - jbai-gemini:');
-  config.MODELS.gemini.available.forEach((m) => {
-    const def = m === config.MODELS.gemini.default ? ' (default)' : '';
-    console.log(`  - ${m}${def}`);
-  });
+  showModelsForTool(tool, heading);
 
-  // Count total
-  const total = config.MODELS.claude.available.length +
-    config.MODELS.openai.available.length +
-    config.MODELS.codex.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.');
+  const groups = getGroupsForTool(tool);
+  const total = groups.reduce((sum, group) => sum + group.models.length, 0);
+  console.log(`Total: ${total} models`);
+  if (tool === 'all') {
+    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) {
@@ -621,7 +668,7 @@ switch (command) {
     if (args[0] === 'set') {
       setToken();
     } else if (args[0] === 'refresh') {
-      refreshTokenCommand();
+      refreshTokenCommand(args[1]);
     } else {
       showTokenStatus();
     }
@@ -633,7 +680,14 @@ switch (command) {
     handoffToOrca(args);
     break;
   case 'models':
-    showModels();
+    if (args[0]) {
+      const allowed = new Set(['all', 'claude', 'codex', 'gemini', 'opencode', 'goose', 'continue']);
+      if (!allowed.has(args[0])) {
+        console.log('Usage: jbai models [all|claude|codex|gemini|opencode|goose|continue]');
+        break;
+      }
+    }
+    showModels(args[0]);
     break;
   case 'env':
     setEnvironment(args[0]);
@@ -652,6 +706,9 @@ switch (command) {
     proxyMod.main();
     break;
   }
+  case 'completions':
+    completions.run(args);
+    break;
   case 'help':
   case '--help':
   case '-h':

package/bin/test-cli-tictactoe.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+/**
+ * E2E CLI Task Testing Script
+ * Runs each jbai CLI across all configured models and verifies
+ * tic-tac-toe sources are created in a temp directory.
+ */
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const config = require('../lib/config');
+
+const PROMPT = [
+  'Create a minimal tic tac toe web app in the current directory.',
+  'Write index.html, styles.css, and app.js.',
+  'Use vanilla JS only. Keep the implementation small.',
+  'After writing files, reply with exactly: JBAI_DONE.'
+].join(' ');
+
+const BASE_DIR = path.join(os.tmpdir(), `jbai-cli-e2e-${Date.now()}`);
+const DEFAULT_TIMEOUT_MS = 3 * 60 * 1000;
+const FAST_TIMEOUT_MS = 60 * 1000;
+const BIN_DIR = __dirname;
+
+const REQUIRED_FILES = ['index.html', 'styles.css', 'app.js'];
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function hasRequiredFiles(dir) {
+  return REQUIRED_FILES.every((file) => {
+    const full = path.join(dir, file);
+    return fs.existsSync(full) && fs.statSync(full).size > 0;
+  });
+}
+
+function runCommand({ cmd, args, cwd, timeoutMs }) {
+  const result = spawnSync(cmd, args, {
+    cwd,
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+    timeout: timeoutMs || DEFAULT_TIMEOUT_MS,
+  });
+  return result;
+}
+
+function formatResult(ok, reason) {
+  return ok ? { ok: true } : { ok: false, reason: reason || 'unknown' };
+}
+
+function detectToolLimitation(output) {
+  const text = (output || '').toLowerCase();
+  if (text.includes('tool') && text.includes('not found in registry')) return true;
+  if (text.includes('no direct file writing tools')) return true;
+  if (text.includes('cannot proceed') && text.includes('files')) return true;
+  if (text.includes('apps/create_app') && text.includes('do not have direct')) return true;
+  return false;
+}
+
+function runTest(test) {
+  const dir = path.join(BASE_DIR, test.tool, test.modelId.replace(/[^a-zA-Z0-9._-]/g, '_'));
+  ensureDir(dir);
+
+  const result = runCommand({ cmd: test.cmd, args: test.args, cwd: dir, timeoutMs: test.timeoutMs });
+  const combinedOutput = `${result.stdout || ''}\n${result.stderr || ''}`;
+  const ok = result.status === 0 && hasRequiredFiles(dir);
+  const logPath = path.join(dir, 'run.log');
+  try {
+    fs.writeFileSync(logPath, combinedOutput);
+  } catch {
+    // ignore log write errors
+  }
+
+  return {
+    ok,
+    status: result.status,
+    signal: result.signal,
+    timedOut: result.error && result.error.code === 'ETIMEDOUT',
+    output: combinedOutput,
+    dir,
+  };
+}
+
+function buildTests() {
+  const tests = [];
+
+  // Claude Code
+  for (const model of config.MODELS.claude.available) {
+    tests.push({
+      tool: 'jbai-claude',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-claude.js'), '--super', '--model', model, '-p', PROMPT],
+    });
+  }
+
+  // Codex CLI
+  for (const model of config.MODELS.codex.available) {
+    tests.push({
+      tool: 'jbai-codex',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-codex.js'), '--super', '--model', model, 'exec', '--skip-git-repo-check', PROMPT],
+    });
+  }
+
+  // OpenCode (OpenAI models)
+  const environment = config.getEnvironment();
+  const openaiProvider = environment === 'staging' ? 'jbai-staging' : 'jbai';
+  const anthropicProvider = environment === 'staging' ? 'jbai-anthropic-staging' : 'jbai-anthropic';
+
+  for (const model of config.MODELS.openai.available) {
+    tests.push({
+      tool: 'jbai-opencode',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-opencode.js'), '--super', 'run', '--model', `${openaiProvider}/${model}`, PROMPT],
+    });
+  }
+  for (const model of config.MODELS.claude.available) {
+    tests.push({
+      tool: 'jbai-opencode',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-opencode.js'), '--super', 'run', '--model', `${anthropicProvider}/${model}`, PROMPT],
+    });
+  }
+
+  // Gemini CLI
+  for (const model of config.MODELS.gemini.available) {
+    tests.push({
+      tool: 'jbai-gemini',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-gemini.js'), '--super', '--model', model, '-p', PROMPT],
+      timeoutMs: FAST_TIMEOUT_MS,
+    });
+  }
+
+  // Goose (OpenAI + Claude)
+  for (const model of config.MODELS.openai.available) {
+    tests.push({
+      tool: 'jbai-goose',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-goose.js'), '--super', 'run', '--provider', 'openai', '--model', model, '--with-builtin', 'code_execution', '-t', PROMPT],
+      timeoutMs: FAST_TIMEOUT_MS,
+    });
+  }
+  for (const model of config.MODELS.claude.available) {
+    tests.push({
+      tool: 'jbai-goose',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-goose.js'), '--super', 'run', '--provider', 'anthropic', '--model', model, '--with-builtin', 'code_execution', '-t', PROMPT],
+      timeoutMs: FAST_TIMEOUT_MS,
+    });
+  }
+
+  // Continue CLI
+  for (const model of config.MODELS.claude.available) {
+    tests.push({
+      tool: 'jbai-continue',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-continue.js'), '--super', '--model', model, '-p', PROMPT],
+    });
+  }
+  for (const model of config.MODELS.openai.available) {
+    tests.push({
+      tool: 'jbai-continue',
+      modelId: model,
+      cmd: process.execPath,
+      args: [path.join(BIN_DIR, 'jbai-continue.js'), '--super', '--model', model, '-p', PROMPT],
+    });
+  }
+
+  return tests;
+}
+
+function main() {
+  ensureDir(BASE_DIR);
+
+  const tests = buildTests();
+  const results = [];
+  const skippedTools = new Map();
+
+  console.log(`Running ${tests.length} CLI task tests...`);
+  console.log(`Artifacts: ${BASE_DIR}`);
+  console.log('');
+
+  for (const test of tests) {
+    if (skippedTools.has(test.tool)) {
+      results.push({
+        tool: test.tool,
+        model: test.modelId,
+        ok: false,
+        skipped: true,
+        reason: skippedTools.get(test.tool),
+      });
+      continue;
+    }
+
+    const label = `${test.tool} :: ${test.modelId}`;
+    process.stdout.write(`${label} ... `);
+
+    const result = runTest(test);
+    const output = result.output || '';
+
+    if (result.ok) {
+      console.log('OK');
+      results.push({ tool: test.tool, model: test.modelId, ok: true, dir: result.dir });
+      continue;
+    }
+
+    let reason = 'unknown';
+    if (result.timedOut) {
+      reason = 'timeout';
+    } else if (result.status !== 0) {
+      reason = `exit ${result.status}`;
+    } else if (!hasRequiredFiles(result.dir)) {
+      reason = 'files missing';
+    }
+
+    console.log(`FAIL (${reason})`);
+    results.push({ tool: test.tool, model: test.modelId, ok: false, reason, output, dir: result.dir });
+
+    if (detectToolLimitation(output)) {
+      skippedTools.set(test.tool, 'missing file-write tooling');
+    } else if (test.tool === 'jbai-goose' && reason === 'files missing') {
+      skippedTools.set(test.tool, 'missing file-write tooling');
+    } else if (test.tool === 'jbai-goose' && reason === 'timeout') {
+      skippedTools.set(test.tool, 'likely missing file-write tooling (timeout)');
+    }
+  }
+
+  const summary = results.reduce((acc, r) => {
+    acc.total += 1;
+    if (r.ok) acc.passed += 1;
+    else if (r.skipped) acc.skipped += 1;
+    else acc.failed += 1;
+    return acc;
+  }, { total: 0, passed: 0, failed: 0, skipped: 0 });
+
+  console.log('\nSummary');
+  console.log(`Total: ${summary.total}`);
+  console.log(`Passed: ${summary.passed}`);
+  console.log(`Failed: ${summary.failed}`);
+  console.log(`Skipped: ${summary.skipped}`);
+
+  const failures = results.filter(r => !r.ok && !r.skipped);
+  if (failures.length > 0) {
+    console.log('\nFailures:');
+    for (const fail of failures) {
+      console.log(`- ${fail.tool} :: ${fail.model} (${fail.reason})`);
+    }
+  }
+
+  const skipped = results.filter(r => r.skipped);
+  if (skipped.length > 0) {
+    const byTool = skipped.reduce((acc, r) => {
+      if (!acc[r.tool]) acc[r.tool] = r.reason || 'skipped';
+      return acc;
+    }, {});
+    console.log('\nSkipped tools:');
+    for (const [tool, reason] of Object.entries(byTool)) {
+      console.log(`- ${tool}: ${reason}`);
+    }
+  }
+
+  if (summary.failed > 0) {
+    process.exit(1);
+  }
+}
+
+main();

package/bin/test-clients.js

@@ -98,11 +98,9 @@ async function testClaude(model) {
   }
 }
 
-// Test Codex (OpenAI Responses API - used by codex CLI)
-async function testCodex(model) {
+// Test OpenAI Chat (used by OpenCode)
+async function testOpenAIChat(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');
 
@@ -136,10 +134,44 @@ async function testCodex(model) {
   }
 }
 
+// Test Codex (OpenAI Responses API - used by codex CLI)
+async function testCodex(model) {
+  try {
+    const result = await httpPost(
+      `${endpoints.openai}/responses`,
+      {
+        model: model,
+        input: 'Reply with exactly: JBAI_OK',
+        max_output_tokens: 64
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200) {
+      const outputs = Array.isArray(result.data?.output) ? result.data.output : [];
+      const text = outputs
+        .flatMap(item => Array.isArray(item?.content) ? item.content : [])
+        .map(part => part?.text)
+        .filter(Boolean)
+        .join('\n');
+
+      if (text.includes('JBAI_OK')) {
+        return { success: true, message: 'OK', response: text };
+      }
+      return { success: true, message: 'OK (response varied)', response: text };
+    } 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);
+  return testOpenAIChat(model);
 }
 
 // Test Gemini (Vertex AI API)

package/bin/test-model-lists.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+/**
+ * E2E Model List Testing Script
+ * Verifies each jbai client exposes only Grazie models in its model list output.
+ */
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const { getGroupsForTool } = require('../lib/model-list');
+
+const tools = [
+  { key: 'claude', script: 'jbai-claude.js' },
+  { key: 'codex', script: 'jbai-codex.js' },
+  { key: 'gemini', script: 'jbai-gemini.js' },
+  { key: 'opencode', script: 'jbai-opencode.js' },
+  { key: 'goose', script: 'jbai-goose.js' },
+  { key: 'continue', script: 'jbai-continue.js' },
+];
+
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+};
+
+function parseModels(output) {
+  return output
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.startsWith('- '))
+    .map(line => line.slice(2).replace(/\s+\(default\)$/, ''))
+    .filter(Boolean);
+}
+
+function expectedModels(toolKey) {
+  const groups = getGroupsForTool(toolKey);
+  return groups.flatMap(group => group.models);
+}
+
+function runTool(script) {
+  const scriptPath = path.join(__dirname, script);
+  return execFileSync(process.execPath, [scriptPath, '--models'], { encoding: 'utf-8' });
+}
+
+function diffModels(expected, actual) {
+  const expectedSet = new Set(expected);
+  const actualSet = new Set(actual);
+  const missing = expected.filter(m => !actualSet.has(m));
+  const extra = actual.filter(m => !expectedSet.has(m));
+  return { missing, extra };
+}
+
+async function run() {
+  console.log(`\n${'='.repeat(70)}`);
+  console.log(`${colors.cyan}JBAI-CLI MODEL LIST E2E${colors.reset}`);
+  console.log(`${'='.repeat(70)}\n`);
+
+  let failures = 0;
+
+  for (const tool of tools) {
+    const expected = expectedModels(tool.key);
+    process.stdout.write(`Testing jbai-${tool.key} models... `);
+    try {
+      const output = runTool(tool.script);
+      const actual = parseModels(output);
+      const { missing, extra } = diffModels(expected, actual);
+      if (missing.length === 0 && extra.length === 0) {
+        console.log(`${colors.green}✓ OK${colors.reset}`);
+      } else {
+        failures += 1;
+        console.log(`${colors.red}✗ Mismatch${colors.reset}`);
+        if (missing.length > 0) {
+          console.log(`  ${colors.dim}Missing:${colors.reset} ${missing.join(', ')}`);
+        }
+        if (extra.length > 0) {
+          console.log(`  ${colors.dim}Extra:${colors.reset} ${extra.join(', ')}`);
+        }
+      }
+    } catch (err) {
+      failures += 1;
+      console.log(`${colors.red}✗ Error${colors.reset}`);
+      const msg = err && err.message ? err.message : String(err);
+      console.log(`  ${colors.dim}${msg}${colors.reset}`);
+    }
+  }
+
+  console.log(`\n${'='.repeat(70)}\n`);
+
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});