arsenal-agent 0.1.0

package/dist/profiles.js

@@ -0,0 +1,171 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, copyFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { spawnSync } from "node:child_process";
+const CONFIG_DIR = join(homedir(), ".arsenal-agent");
+const CONFIG_FILE = join(CONFIG_DIR, "profiles.json");
+const CREDS_DIR = join(CONFIG_DIR, "credentials"); // um .json por perfil
+const CLAUDE_CREDS = join(homedir(), ".claude", ".credentials.json");
+// ── Helpers de arquivo ───────────────────────────────────────────────────────
+function ensureDir() {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    mkdirSync(CREDS_DIR, { recursive: true, mode: 0o700 });
+}
+function loadConfig() {
+    ensureDir();
+    if (!existsSync(CONFIG_FILE))
+        return { current: "", profiles: {} };
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+}
+function saveConfig(config) {
+    ensureDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+    chmodSync(CONFIG_FILE, 0o600);
+}
+function credsPath(name) {
+    return join(CREDS_DIR, `${name}.json`);
+}
+function prompt(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+    });
+}
+// ── Adicionar perfil ─────────────────────────────────────────────────────────
+export async function addProfile(name) {
+    const config = loadConfig();
+    const profileName = name || await prompt("Nome do perfil (ex: pessoal, trabalho): ");
+    if (!profileName) {
+        console.error("Nome obrigatório.");
+        process.exit(1);
+    }
+    const label = await prompt(`Label (ex: DBC Tech, Pessoal) [Enter p/ pular]: `);
+    const email = await prompt("Email da conta: ");
+    const stored = {
+        label: label || profileName,
+        auth_method: "browser",
+        email,
+    };
+    await _captureOAuthToken(profileName, email);
+    config.profiles[profileName] = stored;
+    if (!config.current)
+        config.current = profileName;
+    saveConfig(config);
+    console.log(`\n✓ Perfil "${profileName}" salvo (chmod 600)`);
+    console.log(`  Use: aa --profile ${profileName}`);
+}
+async function _captureOAuthToken(profileName, email) {
+    const backup = `${CLAUDE_CREDS}.bak`;
+    const hadCreds = existsSync(CLAUDE_CREDS);
+    if (hadCreds)
+        copyFileSync(CLAUDE_CREDS, backup);
+    console.log(`\n──────────────────────────────────────────`);
+    console.log(` Autenticando: ${email}`);
+    console.log(` O navegador vai abrir — faça login com essa conta.`);
+    console.log(`──────────────────────────────────────────\n`);
+    try {
+        spawnSync("claude", ["auth", "logout"], { stdio: "inherit", env: process.env });
+        // Inicia login — no WSL pode não abrir o browser automaticamente
+        const login = spawnSync("claude", ["auth", "login", "--email", email], {
+            stdio: "inherit",
+            env: process.env,
+        });
+        // Mesmo que retorne erro (browser não abriu), verifica se o token foi gravado
+        if (!existsSync(CLAUDE_CREDS)) {
+            // Fallback: pede para o usuário abrir o link manualmente e confirmar
+            console.log("\n⚠  Browser não abriu automaticamente.");
+            console.log("   Copie a URL acima, abra no navegador, faça login e volte aqui.");
+            await prompt("\nPressione Enter após completar o login no navegador...");
+            if (!existsSync(CLAUDE_CREDS)) {
+                throw new Error("Login não completado — .credentials.json não encontrado.");
+            }
+        }
+        copyFileSync(CLAUDE_CREDS, credsPath(profileName));
+        chmodSync(credsPath(profileName), 0o600);
+        console.log(`\n✓ Token OAuth de "${profileName}" salvo`);
+    }
+    finally {
+        if (hadCreds) {
+            copyFileSync(backup, CLAUDE_CREDS);
+            console.log("✓ Conta anterior restaurada");
+        }
+    }
+}
+// ── Listar perfis ────────────────────────────────────────────────────────────
+export function listProfiles() {
+    const config = loadConfig();
+    const names = Object.keys(config.profiles);
+    if (names.length === 0) {
+        console.log("Nenhum perfil. Use: aa profile add");
+        return;
+    }
+    console.log("\nPerfis cadastrados:\n");
+    for (const name of names) {
+        const p = config.profiles[name];
+        const active = name === config.current ? " ← ativo" : "";
+        console.log(`  ${name}${active}  [${p.auth_method}]`);
+        console.log(`    label: ${p.label ?? name}`);
+        if (p.auth_method === "api_key" && p.anthropic_api_key) {
+            console.log(`    anthropic: ${p.anthropic_api_key.slice(0, 14)}...`);
+            if (p.openrouter_api_key)
+                console.log(`    openrouter: ${p.openrouter_api_key.slice(0, 14)}...`);
+        }
+        else {
+            const hasCreds = existsSync(credsPath(name));
+            console.log(`    email: ${p.email ?? "?"}`);
+            console.log(`    oauth token: ${hasCreds ? "✓ salvo" : "✗ não encontrado — rode: aa profile add " + name}`);
+        }
+        console.log();
+    }
+}
+// ── Trocar perfil padrão ─────────────────────────────────────────────────────
+export function useProfile(name) {
+    const config = loadConfig();
+    if (!config.profiles[name]) {
+        console.error(`Perfil "${name}" não encontrado. Perfis: ${Object.keys(config.profiles).join(", ")}`);
+        process.exit(1);
+    }
+    config.current = name;
+    saveConfig(config);
+    // Se for browser, faz o swap do .credentials.json
+    const p = config.profiles[name];
+    if (p.auth_method === "browser") {
+        _swapCredentials(name, p.label ?? name);
+    }
+    console.log(`✓ Perfil ativo: ${name} (${p.label ?? name})`);
+}
+function _swapCredentials(profileName, label) {
+    const src = credsPath(profileName);
+    if (!existsSync(src)) {
+        console.error(`Token OAuth não encontrado para "${profileName}". Rode: aa profile add ${profileName}`);
+        process.exit(1);
+    }
+    // Backup do atual
+    if (existsSync(CLAUDE_CREDS))
+        copyFileSync(CLAUDE_CREDS, `${CLAUDE_CREDS}.prev`);
+    copyFileSync(src, CLAUDE_CREDS);
+    chmodSync(CLAUDE_CREDS, 0o600);
+    console.log(`✓ Credenciais OAuth trocadas → ${label}`);
+}
+// ── Carregar e aplicar perfil ────────────────────────────────────────────────
+export function loadProfile(name) {
+    const config = loadConfig();
+    const profileName = name || config.current;
+    if (!profileName || !config.profiles[profileName])
+        return null;
+    return { name: profileName, ...config.profiles[profileName] };
+}
+export function applyProfile(profile) {
+    if (profile.auth_method === "browser") {
+        // Garante que as credenciais certas estão no lugar para o claude CLI
+        _swapCredentials(profile.name, profile.label ?? profile.name);
+    }
+    else {
+        if (profile.anthropic_api_key)
+            process.env.ANTHROPIC_API_KEY = profile.anthropic_api_key;
+        if (profile.openrouter_api_key)
+            process.env.OPENROUTER_API_KEY = profile.openrouter_api_key;
+    }
+}
+//# sourceMappingURL=profiles.js.map

package/dist/router.d.ts

@@ -0,0 +1,4 @@
+import type { ModelAlias, RouterDecision } from "./types.js";
+export declare const COST_PER_1K: Record<ModelAlias, number>;
+export declare function getModelId(alias: ModelAlias): string;
+export declare function classifyTask(task: string): RouterDecision;

package/dist/router.js

@@ -0,0 +1,42 @@
+const MODELS = {
+    "nemotron-120b": "openrouter/nvidia/nemotron-3-super-120b-a12b:free",
+    "nemotron-nano": "openrouter/nvidia/nemotron-nano-12b-v2-vl:free",
+    "sonnet": "anthropic/claude-sonnet-4-6",
+};
+// Custo por 1k tokens (output estimado ~300 tokens)
+export const COST_PER_1K = {
+    "nemotron-120b": 0.0,
+    "nemotron-nano": 0.0,
+    "sonnet": 0.003,
+};
+export function getModelId(alias) {
+    return MODELS[alias];
+}
+const COMPLEX_PATTERNS = [
+    /arquitetura|architecture/i,
+    /seguran[cç]a|security|vulnerabilidade/i,
+    /debug|investiga|diagnos/i,
+    /refatora|refactor/i,
+    /por que|why|como funciona|how does/i,
+    /analisa|analyze|avalia/i,
+    /projeta|design system/i,
+    /pipeline|infraestrutura|infrastructure/i,
+    /revis[aã]o|review/i,
+    /estrat[eé]gia|strategy/i,
+    /crie um sistema|cria um sistema|build a system/i,
+    /explique a arquitetura/i,
+    /implemente.*sistema|implement.*system/i,
+    /agent[e]? mcp|mcp server/i,
+];
+export function classifyTask(task) {
+    for (const pattern of COMPLEX_PATTERNS) {
+        if (pattern.test(task)) {
+            return { model: "sonnet", reason: `match: ${pattern.source.split("|")[0]}` };
+        }
+    }
+    if (task.length > 400) {
+        return { model: "sonnet", reason: "prompt longo (>400 chars)" };
+    }
+    return { model: "nemotron-120b", reason: "task simples → free" };
+}
+//# sourceMappingURL=router.js.map

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export type ModelAlias = "nemotron-120b" | "nemotron-nano" | "sonnet";
+export interface Message {
+    id: string;
+    role: "user" | "assistant";
+    content: string;
+    model: ModelAlias;
+    elapsed?: number;
+    timestamp: Date;
+}
+export interface RouterDecision {
+    model: ModelAlias;
+    reason: string;
+}
+export interface Stats {
+    tasksTotal: number;
+    tasksFree: number;
+    tasksPaid: number;
+    costPaid: number;
+    costSaved: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "arsenal-agent",
+  "version": "0.1.0",
+  "description": "Dual AI agent CLI — routes tasks between Claude Sonnet and Nemotron (free) automatically",
+  "license": "MIT",
+  "author": "DBC Tech",
+  "type": "module",
+  "bin": {
+    "arsenal-agent": "./dist/index.js",
+    "aa": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.tsx",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.51.0",
+    "@opencode-ai/sdk": "^1.3.13",
+    "ink": "^5.2.1",
+    "react": "^18.3.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.3",
+    "tsx": "^4.19.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": ["ai", "claude", "opencode", "nemotron", "cli", "agent", "dual-agent"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dbc-tech/arsenal-agent.git"
+  }
+}

package/run.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Dual Agent CLI launcher
+# Verifica deps e lança o TUI
+
+VENV="/home/dbeze/projetos/arsenal/venv"
+SCRIPT="$(dirname "$0")/app.py"
+
+# Verifica se claude CLI está disponível
+if ! command -v claude &>/dev/null; then
+  echo "AVISO: 'claude' CLI não encontrado — tasks complexas usarão Nemotron como fallback"
+fi
+
+# Verifica se opencode está disponível
+if ! command -v opencode &>/dev/null; then
+  echo "ERRO: 'opencode' não encontrado. Instale com: npm install -g opencode-ai"
+  exit 1
+fi
+
+exec "$VENV/bin/python3" "$SCRIPT"

package/src/agents.ts

@@ -0,0 +1,54 @@
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import Anthropic from "@anthropic-ai/sdk"
+import type { ModelAlias } from "./types.js"
+import { getModelId } from "./router.js"
+
+const execFileAsync = promisify(execFile)
+
+const anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+})
+
+export interface AgentResult {
+  content: string
+  elapsed: number
+  model: ModelAlias
+}
+
+export async function runClaude(task: string): Promise<AgentResult> {
+  const t0 = Date.now()
+
+  const message = await anthropic.messages.create({
+    model: "claude-sonnet-4-6-20251101",
+    max_tokens: 2048,
+    messages: [{ role: "user", content: task }],
+  })
+
+  const content = message.content
+    .filter((b) => b.type === "text")
+    .map((b) => (b as { type: "text"; text: string }).text)
+    .join("\n")
+
+  return { content, elapsed: (Date.now() - t0) / 1000, model: "sonnet" }
+}
+
+export async function runOpencode(task: string, alias: ModelAlias): Promise<AgentResult> {
+  const t0 = Date.now()
+  const modelId = getModelId(alias)
+
+  try {
+    const { stdout, stderr } = await execFileAsync(
+      "opencode",
+      ["run", task, "--model", modelId],
+      { timeout: 120_000, env: process.env }
+    )
+    const raw = stdout || stderr || "Sem resposta."
+    // Remove ANSI escape codes
+    const content = raw.replace(/\x1b\[[0-9;]*m/g, "").replace(/\[[\d]+m/g, "").trim()
+    return { content, elapsed: (Date.now() - t0) / 1000, model: alias }
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return { content: `Erro: ${msg}`, elapsed: (Date.now() - t0) / 1000, model: alias }
+  }
+}

package/src/app.tsx

@@ -0,0 +1,236 @@
+import React, { useState, useCallback } from "react"
+import { Box, Text, useInput, useApp } from "ink"
+import type { Message, Stats, RouterDecision } from "./types.js"
+import { classifyTask, COST_PER_1K } from "./router.js"
+import { runClaude, runOpencode } from "./agents.js"
+
+// ── Componentes ──────────────────────────────────────────────────────────────
+
+function MessageList({ messages, model }: { messages: Message[]; model: "sonnet" | "nemotron" }) {
+  const filtered = messages.filter((m) =>
+    model === "sonnet" ? m.model === "sonnet" : m.model !== "sonnet"
+  )
+
+  return (
+    <Box flexDirection="column" gap={0}>
+      {filtered.map((msg) => (
+        <Box key={msg.id} flexDirection="column" marginBottom={1}>
+          <Text color={msg.role === "user" ? "cyan" : "green"} bold>
+            {msg.role === "user" ? "Você" : model === "sonnet" ? "Claude" : "Nemotron"}
+            {msg.elapsed ? ` (${msg.elapsed.toFixed(1)}s)` : ""}
+          </Text>
+          <Text wrap="wrap">{msg.content}</Text>
+        </Box>
+      ))}
+    </Box>
+  )
+}
+
+function Panel({
+  title,
+  color,
+  messages,
+  model,
+  loading,
+  width,
+}: {
+  title: string
+  color: string
+  messages: Message[]
+  model: "sonnet" | "nemotron"
+  loading: boolean
+  width: number
+}) {
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor={color as "cyan" | "yellow"}
+      width={width}
+      height={30}
+      paddingX={1}
+    >
+      <Text bold color={color as "cyan" | "yellow"}>
+        {title}
+      </Text>
+      <Box flexDirection="column" flexGrow={1} overflow="hidden">
+        <MessageList messages={messages} model={model} />
+        {loading && (
+          <Text color="gray" dimColor>
+            aguardando...
+          </Text>
+        )}
+      </Box>
+    </Box>
+  )
+}
+
+function RouterLog({ entries }: { entries: string[] }) {
+  const last = entries.slice(-12)
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="gray"
+      width={26}
+      height={30}
+      paddingX={1}
+    >
+      <Text bold color="gray">
+        ROUTER
+      </Text>
+      {last.map((e, i) => (
+        <Text key={i} color="gray" dimColor wrap="wrap">
+          {e}
+        </Text>
+      ))}
+    </Box>
+  )
+}
+
+function StatsBar({ stats }: { stats: Stats }) {
+  const pct =
+    stats.costSaved + stats.costPaid > 0
+      ? Math.round((stats.costSaved / (stats.costSaved + stats.costPaid)) * 100)
+      : 0
+
+  return (
+    <Box borderStyle="single" borderColor="gray" paddingX={2} marginTop={0}>
+      <Text>
+        Tasks: <Text bold>{stats.tasksTotal}</Text>{"  "}
+        Free: <Text color="green" bold>{stats.tasksFree}</Text>{"  "}
+        Pago: <Text color="yellow" bold>{stats.tasksPaid}</Text>{"  "}
+        Economizado: <Text color="green" bold>{pct}%</Text> (~${stats.costSaved.toFixed(4)}){"  "}
+        Gasto: <Text color="yellow">${stats.costPaid.toFixed(4)}</Text>{"  "}
+        <Text dimColor>[ctrl+c sair • ctrl+l limpar]</Text>
+      </Text>
+    </Box>
+  )
+}
+
+// ── App principal ─────────────────────────────────────────────────────────────
+
+export function App() {
+  const { exit } = useApp()
+  const [messages, setMessages] = useState<Message[]>([])
+  const [routerLog, setRouterLog] = useState<string[]>(["iniciado", "claude: sonnet-4-6", "free: nemotron-120b"])
+  const [input, setInput] = useState("")
+  const [loadingLeft, setLoadingLeft] = useState(false)
+  const [loadingRight, setLoadingRight] = useState(false)
+  const [stats, setStats] = useState<Stats>({
+    tasksTotal: 0, tasksFree: 0, tasksPaid: 0, costPaid: 0, costSaved: 0,
+  })
+
+  const addRouter = useCallback((line: string) => {
+    setRouterLog((prev) => [...prev, line])
+  }, [])
+
+  const dispatch = useCallback(
+    async (task: string) => {
+      const decision: RouterDecision = classifyTask(task)
+      const ts = new Date().toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit", second: "2-digit" })
+      addRouter(`${ts} → ${task.slice(0, 22)}...`)
+      addRouter(`  ${decision.model} (${decision.reason})`)
+
+      const userMsg: Message = {
+        id: `u-${Date.now()}`,
+        role: "user",
+        content: task,
+        model: decision.model,
+        timestamp: new Date(),
+      }
+      setMessages((prev) => [...prev, userMsg])
+
+      if (decision.model === "sonnet") {
+        setLoadingLeft(true)
+        try {
+          const result = await runClaude(task)
+          const assistantMsg: Message = {
+            id: `a-${Date.now()}`,
+            role: "assistant",
+            content: result.content,
+            model: "sonnet",
+            elapsed: result.elapsed,
+            timestamp: new Date(),
+          }
+          setMessages((prev) => [...prev, assistantMsg])
+          const cost = (300 / 1000) * COST_PER_1K["sonnet"]
+          const saved = (300 / 1000) * COST_PER_1K["nemotron-120b"]
+          setStats((s) => ({ ...s, tasksTotal: s.tasksTotal + 1, tasksPaid: s.tasksPaid + 1, costPaid: s.costPaid + cost, costSaved: s.costSaved + saved }))
+        } finally {
+          setLoadingLeft(false)
+        }
+      } else {
+        setLoadingRight(true)
+        try {
+          const result = await runOpencode(task, decision.model)
+          const assistantMsg: Message = {
+            id: `a-${Date.now()}`,
+            role: "assistant",
+            content: result.content,
+            model: decision.model,
+            elapsed: result.elapsed,
+            timestamp: new Date(),
+          }
+          setMessages((prev) => [...prev, assistantMsg])
+          const saved = (300 / 1000) * COST_PER_1K["sonnet"]
+          setStats((s) => ({ ...s, tasksTotal: s.tasksTotal + 1, tasksFree: s.tasksFree + 1, costSaved: s.costSaved + saved }))
+        } finally {
+          setLoadingRight(false)
+        }
+      }
+    },
+    [addRouter]
+  )
+
+  useInput((char, key) => {
+    if (key.ctrl && char === "c") { exit(); return }
+    if (key.ctrl && char === "l") { setMessages([]); setRouterLog(["limpo"]); return }
+    if (key.return) {
+      const task = input.trim()
+      if (task) { setInput(""); dispatch(task) }
+      return
+    }
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1))
+      return
+    }
+    if (char && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + char)
+    }
+  })
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text bold color="blue"> arsenal-agent </Text>
+        <Text dimColor>Claude Sonnet + Nemotron free — roteamento automatico</Text>
+      </Box>
+      <Box flexDirection="row" gap={0}>
+        <Panel
+          title="Claude Sonnet 4.6  (tasks complexas)"
+          color="cyan"
+          messages={messages}
+          model="sonnet"
+          loading={loadingLeft}
+          width={50}
+        />
+        <RouterLog entries={routerLog} />
+        <Panel
+          title="Nemotron 120B  (free · tasks simples)"
+          color="yellow"
+          messages={messages}
+          model="nemotron"
+          loading={loadingRight}
+          width={50}
+        />
+      </Box>
+      <Box borderStyle="single" borderColor="gray" paddingX={1}>
+        <Text color="gray">{">"} </Text>
+        <Text>{input}</Text>
+        <Text color="gray">█</Text>
+      </Box>
+      <StatsBar stats={stats} />
+    </Box>
+  )
+}

package/src/index.tsx

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import React from "react"
+import { render } from "ink"
+import { Command } from "commander"
+import { App } from "./app.js"
+import { addProfile, listProfiles, useProfile, loadProfile, applyProfile } from "./profiles.js"
+
+const program = new Command()
+
+program
+  .name("arsenal-agent")
+  .description("Dual AI agent CLI — Claude Sonnet + Nemotron free, roteamento automatico")
+  .version("0.1.0")
+  .option("-p, --profile <name>", "perfil a usar (substitui env vars)")
+
+// ── Subcomando: profile ────────────────────────────────────────────────────
+const profileCmd = program
+  .command("profile")
+  .description("gerenciar perfis de API keys")
+
+profileCmd
+  .command("add [name]")
+  .description("adicionar ou atualizar um perfil")
+  .action(async (name?: string) => {
+    await addProfile(name)
+    process.exit(0)
+  })
+
+profileCmd
+  .command("list")
+  .alias("ls")
+  .description("listar perfis cadastrados")
+  .action(() => {
+    listProfiles()
+    process.exit(0)
+  })
+
+profileCmd
+  .command("use <name>")
+  .description("definir perfil ativo padrão")
+  .action((name: string) => {
+    useProfile(name)
+    process.exit(0)
+  })
+
+// ── Ação principal: lança TUI ──────────────────────────────────────────────
+program.action((opts: { profile?: string }) => {
+  // Aplica perfil se informado ou se há um perfil ativo salvo
+  const profile = loadProfile(opts.profile)
+  if (profile) {
+    applyProfile(profile)
+    process.stderr.write(`[arsenal-agent] perfil: ${profile.label ?? profile.name}\n`)
+  } else if (!process.env.ANTHROPIC_API_KEY) {
+    console.error("Nenhuma ANTHROPIC_API_KEY encontrada.")
+    console.error("Adicione um perfil: aa profile add")
+    console.error("Ou exporte a variável: export ANTHROPIC_API_KEY=sk-ant-...")
+    process.exit(1)
+  }
+
+  const { waitUntilExit } = render(<App />)
+  waitUntilExit().then(() => process.exit(0))
+})
+
+program.parse()