claude-scionos 2.0.1 → 3.0.1

package/CHANGELOG.md

@@ -5,6 +5,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.0.1] - 2026-01-11
+
+### Added
+- **Model Mapping & Proxy**: Integrated local proxy to transparently map Claude models to **GLM-4.7** or **MiniMax-M2.1**.
+- **Active Token Validation**: Now validates the `ANTHROPIC_AUTH_TOKEN` against the `routerlab.ch` API in real-time before launching.
+- **Interactive Menu**: Added a selection menu at startup to choose the model strategy (Default vs Mapped).
+- **Pro Branding**: New professional "ScioNos ✕ Claude Code" banner with corporate colors.
+
+### Improved
+- **Error Handling**: Better distinction between missing executable (`ENOENT`) and permission errors (`EACCES`).
+- **User Interface**: Clearer validation steps and visual feedback.
+
+## [2.2.0] - 2026-01-06
+
+### Added
+- **Auto-Installation**: Prompts users to automatically install Claude Code CLI (`npm install -g`) if missing.
+- **Native Path Detection**: Now detects Claude Code installations in native paths (`~/.local/bin`, Windows Apps, etc.) per official docs.
+- **SIGTERM Support**: Added handling for `SIGTERM` signals (Docker, CI/CD) to cleanly stop the child process.
+
+### Fixed
+- **Crash on Config-Only**: Fixed a critical bug where the wrapper would crash if a configuration file existed but the CLI executable was missing.
+- **Recursion Safety**: Now launches the detected absolute path of the executable instead of the generic command name, preventing potential loop issues.
+- **Error Logging**: Errors are now correctly sent to `stderr` instead of `stdout`.
+
+## [2.1.0] - 2026-01-06
+
+### Added
+- **Debug Mode**: New `--scionos-debug` flag for detailed diagnostic output
+- **Test Infrastructure**: Added Vitest test suite covering core detection logic
+- **Linting**: Fixed development environment and linting rules
+
+### Fixed
+- **Windows Path Handling**: Fixed an issue where `where claude` returned multiple paths on Windows
+- **Signal Handling**: Improved `SIGINT` (Ctrl+C) handling to prevent wrapper from killing Claude prematurely
+
 ## [2.0.0] - 2025-12-12
 
 ### ⚠️ BREAKING CHANGES

package/README.fr.md

@@ -41,11 +41,11 @@ L'objectif est d'offrir une couche d'exécution propre, isolée et professionnel
 ### 📌 Points clés
 
 - 🔒 **Isolation du jeton** — Le jeton d'authentification n'est jamais écrit sur le disque
+- 🔄 **Mapping de Modèles** — Redirection transparente vers **GLM-4.7** ou **MiniMax-M2.1** via proxy local
 - 💾 **Zéro persistance** — Aucun fichier temporaire ni configuration locale stockés
 - 🧩 **Compatibilité totale** — Fonctionne parfaitement avec la CLI officielle Claude Code
 - 🔐 **Stockage en mémoire uniquement** — Toutes les informations d'identification sont détruites à la fin du processus
 - 🚀 **Démarrage rapide** — Exécution en une seule commande via `npx`
-- 🧪 **Prêt pour CI/CD** — Adapté aux workflows automatisés et pipelines
 
 ---
 
@@ -54,14 +54,10 @@ L'objectif est d'offrir une couche d'exécution propre, isolée et professionnel
 Avant d'utiliser `claude-scionos`, assurez-vous d'avoir :
 
 - **Node.js** version 22 ou supérieure ([Télécharger](https://nodejs.org/))
-- La CLI **Claude Code** installée globalement :
-
-  ```bash
-  npm install -g @anthropic-ai/claude-code
-  ```
-
 - Un **ANTHROPIC_AUTH_TOKEN** valide depuis [https://routerlab.ch/keys](https://routerlab.ch/keys)
 
+*(Note : Si la CLI **Claude Code** n'est pas installée, l'outil vous proposera de l'installer automatiquement.)*
+
 ---
 
 ### 📥 Installation
@@ -102,10 +98,22 @@ npx claude-scionos
 
 **Ce qui se passe :**
 
-1. L'outil vérifie si la CLI Claude Code est installée
-2. Vous invite à saisir votre `ANTHROPIC_AUTH_TOKEN`
-3. Lance Claude Code avec le jeton stocké **uniquement en mémoire**
-4. Nettoie automatiquement les informations d'identification à la sortie
+1. L'outil vérifie si la CLI Claude Code est installée (si non, propose l'**installation automatique**)
+2. Vous invite à saisir votre `ANTHROPIC_AUTH_TOKEN` et le valide instantanément
+3. **Menu de Sélection** : Vous choisissez la stratégie de modèle :
+   - *Default* : Utilise les modèles Anthropic (Opus/Sonnet/Haiku)
+   - *Force GLM-4.7* : Mappe toutes les requêtes vers GLM-4.7
+   - *Force MiniMax-M2.1* : Mappe toutes les requêtes vers MiniMax-M2.1
+4. Lance Claude Code (avec un proxy local transparent si un mapping est choisi)
+5. Nettoie automatiquement les informations d'identification à la sortie
+
+#### Débogage
+
+Si vous rencontrez des problèmes, utilisez le flag de débogage pour voir les informations détaillées :
+
+```bash
+npx claude-scionos --scionos-debug
+```
 
 #### Exemple de session
 
@@ -144,7 +152,7 @@ Pour une liste complète des flags et commandes disponibles, consultez la [docum
 ### 🔍 Fonctionnement
 
 1. **Vérification** : Vérifie que la commande `claude` est disponible dans votre PATH
-2. **Saisie du jeton** : Demande de manière sécurisée votre jeton d'authentification (entrée masquée)
+2. **Validation du jeton** : Demande et valide votre jeton en temps réel via l'API (assurant qu'il est fonctionnel avant le lancement)
 3. **Configuration de l'environnement** : Crée des variables d'environnement isolées :
    - `ANTHROPIC_BASE_URL` → `https://routerlab.ch`
    - `ANTHROPIC_AUTH_TOKEN` → Votre jeton (mémoire uniquement)

package/README.md

@@ -41,11 +41,11 @@ The goal is to offer a clean, isolated, and professional execution layer fully c
 ### 📌 Key Features
 
 - 🔒 **Token Isolation** — Authentication token never written to disk
+- 🔄 **Model Mapping** — Transparently route requests to **GLM-4.7** or **MiniMax-M2.1** via local proxy
 - 💾 **Zero Persistence** — No temporary files or local configuration stored
 - 🧩 **Full Compatibility** — Works seamlessly with the official Claude Code CLI
 - 🔐 **Memory-Only Storage** — All credentials destroyed on process exit
 - 🚀 **Quick Start** — Single command execution via `npx`
-- 🧪 **CI/CD Ready** — Suitable for automated workflows and pipelines
 
 ---
 
@@ -54,14 +54,10 @@ The goal is to offer a clean, isolated, and professional execution layer fully c
 Before using `claude-scionos`, ensure you have:
 
 - **Node.js** version 22 or later ([Download](https://nodejs.org/))
-- **Claude Code** CLI installed globally:
-
-  ```bash
-  npm install -g @anthropic-ai/claude-code
-  ```
-
 - A valid **ANTHROPIC_AUTH_TOKEN** from [https://routerlab.ch/keys](https://routerlab.ch/keys)
 
+*(Note: If **Claude Code** is not installed, the tool will offer to install it for you automatically.)*
+
 ---
 
 ### 📥 Installation
@@ -94,7 +90,7 @@ claude-scionos
 
 #### Basic Usage
 
-Simply execute the command:
+Run the command:
 
 ```bash
 npx claude-scionos
@@ -102,24 +98,24 @@ npx claude-scionos
 
 **What happens:**
 
-1. The tool checks if Claude Code CLI is installed
-2. Prompts you to enter your `ANTHROPIC_AUTH_TOKEN`
-3. Launches Claude Code with the token stored **only in memory**
-4. Automatically cleans up credentials when you exit
+1.  Checks if Claude Code CLI is installed (if not, offers **automatic installation**)
+2.  Prompts for your `ANTHROPIC_AUTH_TOKEN` and validates it instantly
+3.  **Selection Menu**: Choose your model strategy:
+    - *Default*: Use standard Anthropic models (Opus/Sonnet/Haiku)
+    - *Force GLM-4.7*: Maps all requests to GLM-4.7
+    - *Force MiniMax-M2.1*: Maps all requests to MiniMax-M2.1
+4.  Launches Claude Code (starting a transparent local proxy if needed)
+5.  Automatically cleans credentials on exit
 
-#### Example Session
+#### Debugging
 
-```bash
-$ npx claude-scionos
-
-Claude Code (via ScioNos)
-To retrieve your token, visit: https://routerlab.ch/keys
-? Please enter your ANTHROPIC_AUTH_TOKEN: ********
+If you encounter issues, you can run with the debug flag to see detailed diagnostic information:
 
-# Claude Code starts...
+```bash
+npx claude-scionos --scionos-debug
 ```
 
-#### Command-Line Options
+#### Command Line Options
 
 ```bash
 # Display version
@@ -144,7 +140,7 @@ For a complete list of available flags and commands, see the [official Claude Co
 ### 🔍 How It Works
 
 1. **Verification**: Checks if `claude` command is available in your PATH
-2. **Token Input**: Securely prompts for your authentication token (masked input)
+2. **Token Validation**: Prompts for and validates your token in real-time via the API (ensuring it works before launch)
 3. **Environment Setup**: Creates isolated environment variables:
    - `ANTHROPIC_BASE_URL` → `https://routerlab.ch`
    - `ANTHROPIC_AUTH_TOKEN` → Your token (memory only)

package/index.js

@@ -1,117 +1,366 @@
 #!/usr/bin/env node
-
-import chalk from 'chalk';
-import { password } from '@inquirer/prompts';
-import spawn from 'cross-spawn';
-import updateNotifier from 'update-notifier';
-import process from 'node:process';
-import { createRequire } from 'node:module';
-import { isClaudeCodeInstalled, detectOS, checkGitBashOnWindows, getInstallationInstructions } from './src/detectors/claude-only.js';
-
-const require = createRequire(import.meta.url);
-const pkg = require('./package.json');
-
-// Initialize update notifier
-updateNotifier({ pkg }).notify();
-
-// 0. Handle --version / -v flag
-if (process.argv.includes('--version') || process.argv.includes('-v')) {
-    console.log(pkg.version);
-    process.exit(0);
-}
-
-// 1. Enhanced System Detection
-console.log(chalk.cyan('🔍 Checking system configuration...'));
-
-// Detect OS and environment
-const osInfo = detectOS();
-console.log(chalk.gray(`✓ OS: ${osInfo.type} (${osInfo.arch})`));
-console.log(chalk.gray(`✓ Shell: ${osInfo.shell}`));
-
-// Check Claude Code installation
-const claudeStatus = isClaudeCodeInstalled();
-
-if (!claudeStatus.installed) {
-    console.error(chalk.redBright('\n❌ Claude Code not found'));
-
-    // Show detailed detection info
-    console.log(chalk.yellow('\nDetection Details:'));
-    console.log(chalk.gray(claudeStatus.details));
-
-    // Show installation instructions
-    const instructions = getInstallationInstructions(osInfo, claudeStatus);
-    console.log(chalk.cyan(instructions));
-
-    process.exit(1);
-}
-
-// Show Claude Code status
-console.log(chalk.green('\n✓ Claude Code detected'));
-console.log(chalk.gray(claudeStatus.details));
-
-// 2. Check Git Bash on Windows (if needed)
-if (process.platform === 'win32') {
-    console.log(chalk.cyan('\n🔍 Checking Git Bash availability...'));
-    const gitBashStatus = checkGitBashOnWindows();
-
-    if (!gitBashStatus.available) {
-        console.log(chalk.red('\n❌ Git Bash is required on Windows'));
-        console.log(chalk.gray(gitBashStatus.message));
-
-        // Show Git Bash installation instructions
-        console.log(chalk.cyan('\n📥 Install Git for Windows:'));
-        console.log(chalk.white('   https://git-scm.com/downloads/win\n'));
-        console.log(chalk.cyan('⚙️  Or set the path manually:'));
-        console.log(chalk.white('   set CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe'));
-        console.log(chalk.white('   (PowerShell: $env:CLAUDE_CODE_GIT_BASH_PATH="C:\\Program Files\\Git\\bin\\bash.exe")\n'));
-        console.log(chalk.yellow('💡 After installation, restart your terminal and try again.\n'));
-        process.exit(1);
-    } else {
-        console.log(chalk.green('✓ Git Bash available'));
-        console.log(chalk.gray(gitBashStatus.message));
-    }
-}
-
-// 3. Intro
-console.clear();
-console.log(chalk.cyan.bold("Claude Code (via ScioNos)"));
-console.log(chalk.gray(`Running on ${osInfo.type} with ${osInfo.shell}`));
-
-// 4. Token info
-console.log(chalk.blueBright("To retrieve your token, visit: https://routerlab.ch/keys"));
-
-// 5. Token input
-const token = await password({
-    message: "Please enter your ANTHROPIC_AUTH_TOKEN:",
-    validate: (input) => {
-        if (!input || input.trim() === '') {
-            return "Token cannot be empty.";
-        }
-        return true;
-    },
-    mask: '*'
-});
-
-// 6. Environment configuration
-const env = {
-    ...process.env,
-    ANTHROPIC_BASE_URL: "https://routerlab.ch",
-    ANTHROPIC_AUTH_TOKEN: token,
-    ANTHROPIC_API_KEY: "" // Force empty string
-};
-
-// 7. Launch Claude Code
-const args = process.argv.slice(2);
-const child = spawn('claude', args, {
-    stdio: 'inherit',
-    env: env
-});
-
-child.on('close', (code) => {
-    process.exit(code);
-});
-
-child.on('error', (err) => {
-    console.error(chalk.red(`Error launching Claude: ${err.message}`));
-    process.exit(1);
-});
+
+import chalk from 'chalk';
+import { password, confirm, select } from '@inquirer/prompts';
+import spawn from 'cross-spawn';
+import updateNotifier from 'update-notifier';
+import process from 'node:process';
+import http from 'node:http';
+import { createRequire } from 'node:module';
+import { isClaudeCodeInstalled, detectOS, checkGitBashOnWindows, getInstallationInstructions } from './src/detectors/claude-only.js';
+
+const require = createRequire(import.meta.url);
+const pkg = require('./package.json');
+
+// Initialize update notifier
+updateNotifier({ pkg }).notify();
+
+// --- CONFIGURATION ---
+const BASE_URL = "https://routerlab.ch";
+
+// --- UTILS ---
+
+/**
+ * Displays the application banner
+ */
+function showBanner() {
+    console.clear();
+    const p = chalk.hex('#3b82f6'); // Primary (Scio)
+    const s = chalk.hex('#a855f7'); // Secondary (Nos)
+    const c = chalk.hex('#D97757'); // Claude Orange
+    const w = chalk.white;
+    const g = chalk.gray;
+    const border = g; // Gray border
+
+    console.log("");
+    console.log(border("   ┌──────────────────────────────────────────────────────────┐"));
+    console.log(border("   │                                                          │"));
+    console.log(border("   │                 ") + p.bold("Scio") + s.bold("Nos") + w.bold("  ✕  ") + c.bold("Claude Code") + border("                  │"));
+    console.log(border("   │                                                          │"));
+    console.log(border("   └──────────────────────────────────────────────────────────┘"));
+    console.log(g(`                                                   v${pkg.version}`));
+    console.log("");
+}
+
+/**
+ * Validates the API Token against RouterLab
+ */
+async function validateToken(apiKey) {
+    try {
+        const response = await fetch(`${BASE_URL}/v1/models`, {
+            method: 'GET',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01'
+            }
+        });
+
+        if (response.ok) {
+            return { valid: true };
+        } else if (response.status === 401 || response.status === 403) {
+            return { valid: false, reason: 'auth_failed' };
+        } else {
+            return { valid: false, reason: 'server_error', status: response.status, statusText: response.statusText };
+        }
+    } catch (error) {
+        return { valid: false, reason: 'network_error', message: error.message };
+    }
+}
+
+/**
+ * Starts a local proxy server to map models
+ * @param {string} targetModel - The model ID to map to (e.g., 'glm-4.7')
+ * @param {string} validToken - The validated Auth Token
+ * @returns {Promise<string>} - The local URL (e.g., http://127.0.0.1:45321)
+ */
+function startProxyServer(targetModel, validToken) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            // Handle CORS preflight if necessary (usually strict for CLI tools but good practice)
+            if (req.method === 'OPTIONS') {
+                res.writeHead(200, {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                    'Access-Control-Allow-Headers': '*'
+                });
+                res.end();
+                return;
+            }
+
+            // We only care about interception if it's a message generation request
+            // Claude Code uses /v1/messages
+            if (req.method === 'POST' && req.url.includes('/messages')) {
+                const chunks = [];
+                req.on('data', chunk => chunks.push(chunk));
+                req.on('end', async () => {
+                    try {
+                        const bodyBuffer = Buffer.concat(chunks);
+                        let bodyJson;
+                        try {
+                            bodyJson = JSON.parse(bodyBuffer.toString());
+                        } catch (e) {
+                            // If not JSON, forward as is
+                            bodyJson = null;
+                        }
+
+                        // THE MAGIC: Swap the model
+                        if (bodyJson && bodyJson.model) {
+                            // Map any Claude model to our target
+                            // Claude Code usually requests 'claude-3-opus-...' or 'claude-3-5-sonnet...'
+                            // We force the target.
+                            if (process.argv.includes('--scionos-debug')) {
+                                console.log(chalk.yellow(`[Proxy] Swapping model ${bodyJson.model} -> ${targetModel}`));
+                            }
+                            bodyJson.model = targetModel;
+                        }
+
+                        // Prepare upstream request
+                        const upstreamRes = await fetch(`${BASE_URL}${req.url}`, {
+                            method: 'POST',
+                            headers: {
+                                ...req.headers,
+                                'host': new URL(BASE_URL).host,
+                                'x-api-key': validToken // Ensure we use the validated token
+                            },
+                            body: bodyJson ? JSON.stringify(bodyJson) : bodyBuffer
+                        });
+
+                        // Pipe response back
+                        res.writeHead(upstreamRes.status, upstreamRes.headers);
+                        if (upstreamRes.body) {
+                            // @ts-ignore - Node fetch body is iterable
+                            for await (const chunk of upstreamRes.body) {
+                                res.write(chunk);
+                            }
+                        }
+                        res.end();
+
+                    } catch (error) {
+                        console.error(chalk.red(`[Proxy Error] ${error.message}`));
+                        res.writeHead(500);
+                        res.end(JSON.stringify({ error: { message: "Scionos Proxy Error" } }));
+                    }
+                });
+            } else {
+                // Passthrough for other endpoints (like /models potentially)
+                // In a simple CLI usage, direct passthrough might be enough, 
+                // but since we changed the BASE_URL, we must forward everything.
+                // For simplicity in this script, we assume most traffic is POST /messages.
+                // If Claude Code calls GET /models, we should forward it too.
+                
+                // Simple Redirect implementation for non-body requests
+                try {
+                     const upstreamRes = await fetch(`${BASE_URL}${req.url}`, {
+                        method: req.method,
+                        headers: {
+                            ...req.headers,
+                            'host': new URL(BASE_URL).host,
+                            'x-api-key': validToken
+                        }
+                    });
+                     res.writeHead(upstreamRes.status, upstreamRes.headers);
+                     if (upstreamRes.body) {
+                        // @ts-ignore
+                        for await (const chunk of upstreamRes.body) {
+                            res.write(chunk);
+                        }
+                     }
+                     res.end();
+                } catch (e) {
+                    res.writeHead(502);
+                    res.end();
+                }
+            }
+        });
+
+        // Listen on random port
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = address.port;
+            resolve({ server, url: `http://127.0.0.1:${port}` });
+        });
+
+        server.on('error', (err) => reject(err));
+    });
+}
+
+// --- MAIN EXECUTION ---
+
+// 0. Handle Flags
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+    console.log(pkg.version);
+    process.exit(0);
+}
+
+const isDebug = process.argv.includes('--scionos-debug');
+
+// 1. Show Banner
+showBanner();
+
+// 2. System Check
+if (isDebug) console.log(chalk.cyan('🔍 Checking system configuration...'));
+const osInfo = detectOS();
+let claudeStatus = isClaudeCodeInstalled();
+
+// Check Claude Code installation
+if (!claudeStatus.installed) {
+    console.error(chalk.redBright('\n❌ Claude Code CLI not found'));
+    const shouldInstall = await confirm({
+        message: 'Claude Code CLI is not installed. Install globally via npm?',
+        default: true
+    });
+
+    if (shouldInstall) {
+        try {
+            console.log(chalk.cyan('\n📦 Installing @anthropic-ai/claude-code...'));
+            spawn.sync('npm', ['install', '-g', '@anthropic-ai/claude-code'], { stdio: 'inherit' });
+            claudeStatus = isClaudeCodeInstalled();
+            if (!claudeStatus.installed) {
+                 console.warn(chalk.yellow('⚠ Installation finished, but executable not found immediately. Restart terminal recommended.'));
+                 process.exit(0);
+            }
+        } catch (e) {
+            console.error(chalk.red(`\n❌ Installation failed: ${e.message}`));
+            console.error(chalk.cyan(getInstallationInstructions(osInfo)));
+            process.exit(1);
+        }
+    } else {
+        console.error(chalk.cyan(getInstallationInstructions(osInfo)));
+        process.exit(1);
+    }
+}
+
+// Check Git Bash on Windows
+let gitBashPath = null;
+if (process.platform === 'win32') {
+    const gitBashStatus = checkGitBashOnWindows();
+    if (!gitBashStatus.available) {
+        console.log(chalk.red('\n❌ Git Bash is required on Windows'));
+        console.log(chalk.cyan('Please install Git for Windows: https://git-scm.com/downloads/win'));
+        process.exit(1);
+    }
+    gitBashPath = gitBashStatus.path;
+}
+
+// 3. Token Loop
+let token = "";
+while (true) {
+    console.log(chalk.blueBright("To retrieve your token, visit: https://routerlab.ch/keys"));
+    token = await password({
+        message: "Please enter your ANTHROPIC_AUTH_TOKEN:",
+        mask: '*'
+    });
+
+    console.log(chalk.gray("Validating token..."));
+    const validation = await validateToken(token);
+
+    if (validation.valid) {
+        console.log(chalk.green("✓ Token validated."));
+        break;
+    } else if (validation.reason === 'auth_failed') {
+        console.log(chalk.red("❌ Invalid token (401/403). Try again."));
+    } else {
+        console.log(chalk.yellow(`⚠ Validation warning: ${validation.message || validation.status}`));
+        const ignore = await confirm({ message: "Continue anyway?", default: false });
+        if (ignore) break;
+    }
+}
+
+// 4. Model Selection
+const modelChoice = await select({
+    message: 'Select Model Strategy:',
+    choices: [
+        {
+            name: 'Default (Use Claude Opus/Sonnet/Haiku natively)',
+            value: 'default',
+            description: 'Standard behavior. Claude decides which model to use.'
+        },
+        {
+            name: 'Force GLM-4.7 (Map all models to GLM-4.7)',
+            value: 'glm-4.7',
+            description: 'Intercepts traffic and routes everything to GLM-4.7'
+        },
+        {
+            name: 'Force MiniMax-M2.1 (Map all models to MiniMax)',
+            value: 'minimax-m2.1',
+            description: 'Intercepts traffic and routes everything to MiniMax-M2.1'
+        }
+    ]
+});
+
+// 5. Setup Environment & Proxy
+let finalBaseUrl = BASE_URL;
+let proxyServer = null;
+
+if (modelChoice !== 'default') {
+    console.log(chalk.magenta(`\n🔮 Starting Local Proxy to map models to ${chalk.bold(modelChoice)}...`));
+    try {
+        const proxyInfo = await startProxyServer(modelChoice, token);
+        proxyServer = proxyInfo.server;
+        finalBaseUrl = proxyInfo.url; // e.g. http://127.0.0.1:54321
+        if (isDebug) console.log(chalk.gray(`✓ Proxy listening on ${finalBaseUrl}`));
+    } catch (err) {
+        console.error(chalk.red(`Failed to start proxy: ${err.message}`));
+        process.exit(1);
+    }
+}
+
+const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: finalBaseUrl,
+    ANTHROPIC_AUTH_TOKEN: token,
+    ANTHROPIC_API_KEY: "" // Force empty
+};
+
+// 6. Launch Claude
+const args = process.argv.slice(2).filter(arg => arg !== '--scionos-debug');
+if (isDebug) {
+    console.log(chalk.yellow('\n--- DEBUG INFO ---'));
+    console.log(chalk.gray(`Endpoint: ${env.ANTHROPIC_BASE_URL}`));
+    console.log(chalk.gray(`Model Strategy: ${modelChoice}`));
+    console.log(chalk.yellow('------------------\n'));
+}
+
+console.log(chalk.green(`\n🚀 Launching Claude Code [${modelChoice}]...\n`));
+
+const child = spawn(claudeStatus.cliPath, args, {
+    stdio: 'inherit',
+    env: env
+});
+
+// 7. Cleanup Handlers
+const cleanup = () => {
+    if (proxyServer) {
+        if (isDebug) console.log(chalk.gray('\nStopping proxy server...'));
+        proxyServer.close();
+    }
+};
+
+child.on('exit', (code) => {
+    cleanup();
+    process.exit(code);
+});
+
+child.on('error', (err) => {
+    cleanup();
+    console.error(chalk.red(`\n❌ Error launching Claude CLI:`));
+    if (err.code === 'ENOENT') {
+        console.error(chalk.yellow(`   Executable not found. Try 'npm install -g @anthropic-ai/claude-code'`));
+    } else if (err.code === 'EACCES') {
+        console.error(chalk.yellow(`   Permission denied.`));
+    } else {
+        console.error(chalk.yellow(`   ${err.message}`));
+    }
+    process.exit(1);
+});
+
+process.on('SIGINT', () => {
+    // Child handles SIGINT usually, but we ensure cleanup if wrapper is killed
+    // We don't exit here immediately to let Claude handle the interrupt
+});
+
+process.on('SIGTERM', () => {
+    if (child) child.kill('SIGTERM');
+    cleanup();
+    process.exit(0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-scionos",
-    "version": "2.0.1",
+    "version": "3.0.1",
     "description": "Ephemeral and secure runner for Claude Code CLI in ScioNos environment",
     "type": "module",
     "main": "index.js",
@@ -8,7 +8,7 @@
         "claude-scionos": "index.js"
     },
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "test": "vitest run",
         "lint": "eslint .",
         "release:patch": "npm version patch -m \"Chore: Bump version to %s\"",
         "release:minor": "npm version minor -m \"Chore: Bump version to %s\"",
@@ -44,6 +44,7 @@
     "devDependencies": {
         "@eslint/js": "^9.39.2",
         "eslint": "^9.39.2",
-        "globals": "^17.0.0"
+        "globals": "^17.0.0",
+        "vitest": "^4.0.16"
     }
 }

package/src/detectors/claude-only.js

@@ -6,86 +6,83 @@ import os from 'os';
 
 /**
  * Detects if Claude Code is installed and returns detailed status
- * @returns {{installed: boolean, path: string|null, configPath: string|null, cliAvailable: boolean, details: string}}
+ * @returns {{
+ *   installed: boolean, 
+ *   path: string|null, 
+ *   configPath: string|null, 
+ *   cliAvailable: boolean, 
+ *   cliPath: string|null, 
+ *   details: string,
+ *   configFound: boolean
+ * }}
  */
 function isClaudeCodeInstalled() {
   // Check for Claude Code directory in user home
   const claudeDir = path.join(os.homedir(), '.claude');
   const details = [];
 
+  // 1. Check for Configuration
+  let configFound = false;
   if (fs.existsSync(claudeDir)) {
-    details.push(`✓ Found Claude directory: ${claudeDir}`);
-
-    // Check for settings.json to confirm it's actually Claude Code
     const settingsPath = path.join(claudeDir, 'settings.json');
     if (fs.existsSync(settingsPath)) {
-      details.push(`✓ Configuration file found: ${settingsPath}`);
-
-      // Try to read the config to see if it's configured
-      try {
-        const config = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-        const hasBaseUrl = config.env?.ANTHROPIC_BASE_URL;
-        const hasApiKey = config.env?.ANTHROPIC_API_KEY;
-
-        if (hasBaseUrl && hasApiKey) {
-          details.push(`✓ Claude Code is configured with custom API`);
-        } else if (hasBaseUrl || hasApiKey) {
-          details.push(`⚠ Claude Code is partially configured`);
-        } else {
-          details.push(`ℹ Claude Code installed but not configured`);
-        }
-      } catch (error) {
-        details.push(`⚠ Could not read configuration file: ${error.message}`);
-      }
-
-      return {
-        installed: true,
-        path: claudeDir,
-        configPath: settingsPath,
-        cliAvailable: false, // Will check next
-        details: details.join('\n  ')
-      };
-    } else {
-      details.push(`⚠ Directory exists but no settings.json found`);
+      configFound = true;
+      details.push(`✓ Configuration found at: ${settingsPath}`);
     }
   }
 
-  // Also check for the claude CLI command in PATH
-  try {
-    const command = process.platform === 'win32' ? 'where claude' : 'which claude';
-    const claudePath = execSync(command, { encoding: 'utf8' }).trim();
+  // 2. Check for Executable (CLI)
+  let cliPath = null;
 
-    if (claudePath) {
-      details.push(`✓ Claude CLI found in PATH: ${claudePath}`);
+  // 2a. Check Native Install Paths (per official docs)
+  const home = os.homedir();
+  const nativePaths = process.platform === 'win32' 
+    ? [path.join(home, '.local', 'bin', 'claude.exe'), path.join(home, 'AppData', 'Local', 'Microsoft', 'WindowsApps', 'claude.exe')]
+    : [path.join(home, '.local', 'bin', 'claude'), '/opt/homebrew/bin/claude', '/usr/local/bin/claude'];
+
+  for (const p of nativePaths) {
+    if (fs.existsSync(p)) {
+      cliPath = p;
+      details.push(`✓ Found native binary: ${p}`);
+      break;
+    }
+  }
 
-      // Try to get version to confirm it's working
-      try {
-        const version = execSync('claude --version', { encoding: 'utf8' }).trim();
-        details.push(`✓ Version: ${version}`);
-      } catch (error) {
-        details.push(`⚠ CLI found but version check failed: ${error.message}`);
+  // 2b. Check PATH if not found yet
+  if (!cliPath) {
+    try {
+      const command = process.platform === 'win32' ? 'where claude' : 'which claude';
+      const output = execSync(command, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      const foundPath = output.split(/\r?\n/)[0].trim();
+      if (foundPath && fs.existsSync(foundPath)) {
+        cliPath = foundPath;
+        details.push(`✓ Found in PATH: ${foundPath}`);
       }
+    } catch (e) {
+      // Ignore error if not found in PATH
+    }
+  }
 
-      return {
-        installed: true,
-        path: claudeDir && fs.existsSync(claudeDir) ? claudeDir : null,
-        configPath: claudeDir && fs.existsSync(path.join(claudeDir, 'settings.json'))
-          ? path.join(claudeDir, 'settings.json')
-          : null,
-        cliAvailable: true,
-        cliPath: claudePath,
-        details: details.join('\n  ')
-      };
+  // 3. Verify Version (if executable found)
+  if (cliPath) {
+    try {
+      // We use the full path to avoid recursion or alias issues
+      const version = execSync(`"${cliPath}" --version`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      details.push(`✓ Version: ${version}`);
+    } catch (error) {
+      details.push(`⚠ Executable found but version check failed: ${error.message}`);
     }
-  } catch (error) {
-    details.push(`✗ Claude CLI not found in PATH: ${error.message}`);
+  } else {
+    details.push(`✗ Executable 'claude' not found in PATH or standard locations.`);
   }
 
   return {
-    installed: false,
-    path: null,
-    configPath: null,
-    cliAvailable: false,
+    installed: !!cliPath, // STRICT: Only true if the binary is found
+    configFound: configFound,
+    path: claudeDir,
+    configPath: configFound ? path.join(claudeDir, 'settings.json') : null,
+    cliAvailable: !!cliPath,
+    cliPath: cliPath,
     details: details.join('\n  ')
   };
 }

package/tests/detectors.test.js

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import child_process from 'child_process';
+import { isClaudeCodeInstalled, detectOS, checkGitBashOnWindows } from '../src/detectors/claude-only.js';
+
+// Mock modules
+vi.mock('fs');
+vi.mock('os');
+vi.mock('child_process');
+
+describe('System Detectors', () => {
+  const originalPlatform = process.platform;
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+    process.env = originalEnv;
+  });
+
+  describe('detectOS', () => {
+    it('should detect Windows', () => {
+      vi.mocked(os.platform).mockReturnValue('win32');
+      vi.mocked(os.arch).mockReturnValue('x64');
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      process.env.WINDIR = 'C:\\Windows'; // Simulate CMD
+
+      const result = detectOS();
+      expect(result.type).toBe('Windows');
+      expect(result.shell).toBe('Command Prompt (CMD)');
+    });
+
+    it('should detect macOS', () => {
+      vi.mocked(os.platform).mockReturnValue('darwin');
+      vi.mocked(os.arch).mockReturnValue('arm64');
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+      process.env.SHELL = '/bin/zsh';
+
+      const result = detectOS();
+      expect(result.type).toBe('macOS');
+      expect(result.shell).toBe('Zsh');
+    });
+  });
+
+  describe('checkGitBashOnWindows', () => {
+    it('should return available if Git Bash exists in standard path on Windows', () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      vi.mocked(fs.existsSync).mockImplementation((p) => p === 'C:\\Program Files\\Git\\bin\\bash.exe');
+
+      const result = checkGitBashOnWindows();
+      expect(result.available).toBe(true);
+      expect(result.path).toBe('C:\\Program Files\\Git\\bin\\bash.exe');
+    });
+
+    it('should return not available if no Git Bash found on Windows', () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = checkGitBashOnWindows();
+      expect(result.available).toBe(false);
+    });
+
+    it('should not require Git Bash on non-Windows', () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+      
+      const result = checkGitBashOnWindows();
+      expect(result.available).toBe(true);
+      expect(result.message).toContain('Not required');
+    });
+  });
+
+  describe('isClaudeCodeInstalled', () => {
+    it('should detect Claude in PATH', () => {
+        // Mock homedir to avoid finding config file
+        vi.mocked(os.homedir).mockReturnValue('/home/user');
+        
+        // Mock execSync to return a path
+        vi.mocked(child_process.execSync).mockImplementation((cmd) => {
+            if (cmd.includes('which claude') || cmd.includes('where claude')) {
+                return '/usr/local/bin/claude';
+            }
+            if (cmd.includes('--version')) {
+                return '0.0.1';
+            }
+            return '';
+        });
+
+        // Mock existsSync: false for config, true for CLI path
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+             if (p === '/usr/local/bin/claude') return true;
+             return false;
+        });
+
+        const result = isClaudeCodeInstalled();
+        expect(result.installed).toBe(true);
+        expect(result.cliAvailable).toBe(true);
+        expect(result.cliPath).toBe('/usr/local/bin/claude');
+    });
+
+    it('should detect Claude from config file ONLY if CLI is also found', () => {
+        vi.mocked(os.homedir).mockReturnValue('/home/user');
+        // Simulate .claude directory and settings.json existence
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            if (p.endsWith('.claude')) return true;
+            if (p.endsWith('settings.json')) return true;
+            return false;
+        });
+        
+        // Mock reading config
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+            env: { ANTHROPIC_BASE_URL: 'https://api.anthropic.com' }
+        }));
+
+        // BUT execSync fails (CLI not found)
+        vi.mocked(child_process.execSync).mockImplementation(() => {
+            throw new Error('not found');
+        });
+
+        const result = isClaudeCodeInstalled();
+        // Updated logic: installed should be false if CLI is missing, even if config exists
+        expect(result.installed).toBe(false);
+        expect(result.configFound).toBe(true);
+        expect(result.cliAvailable).toBe(false);
+        expect(result.details).toContain('Executable \'claude\' not found');
+    });
+
+    it('should detect Claude in native path (Linux/Mac)', () => {
+        // Force Linux platform to ensure implementation looks for 'claude' not 'claude.exe'
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+
+        // We simulate logic but path.join will use OS separators.
+        // On Windows, path.join produces backslashes.
+        // The code under test uses path.join.
+        const mockHome = '/home/user';
+        const expectedPath = path.join(mockHome, '.local', 'bin', 'claude');
+        
+        vi.mocked(os.homedir).mockReturnValue(mockHome);
+        
+        // Simulate native path existence
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            return p === expectedPath;
+        });
+
+        const result = isClaudeCodeInstalled();
+        expect(result.installed).toBe(true);
+        expect(result.cliPath).toBe(expectedPath);
+    });
+
+    it('should return false if neither CLI nor config found', () => {
+        vi.mocked(os.homedir).mockReturnValue('/home/user');
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        vi.mocked(child_process.execSync).mockImplementation(() => {
+            throw new Error('not found');
+        });
+
+        const result = isClaudeCodeInstalled();
+        expect(result.installed).toBe(false);
+    });
+  });
+});

package/CLAUDE.md

@@ -1,90 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-claude-scionos is a lightweight Node.js CLI wrapper that provides ephemeral and secure execution of the official Claude Code CLI. It's designed for the ScioNos environment and focuses on in-memory credential management with zero disk persistence.
-
-## Architecture
-
-The project is a single-file Node.js application (`index.js`) that:
-
-1. **Validates prerequisites**: Checks if Claude Code CLI is installed and available in PATH
-2. **Windows-specific check**: Verifies Git Bash installation (required by Claude Code on Windows)
-3. **Secure token collection**: Uses `@inquirer/prompts` for masked password input
-4. **Environment isolation**: Creates isolated environment variables with:
-   - `ANTHROPIC_BASE_URL`: Set to `https://routerlab.ch` (hardcoded ScioNos endpoint)
-   - `ANTHROPIC_AUTH_TOKEN`: User-provided token (memory only)
-   - `ANTHROPIC_API_KEY`: Explicitly set to empty string
-5. **Process spawning**: Launches Claude Code CLI with inherited stdio and custom environment
-
-## Key Dependencies
-
-- `@inquirer/prompts`: For secure password input with masking
-- `cross-spawn`: Platform-agnostic process spawning
-- `chalk`: Terminal colors for user-friendly output
-- `update-notifier`: Automatic npm update notifications
-- `which`: Command availability checking
-
-## Development Commands
-
-```bash
-# Run locally during development
-node index.js
-
-# Lint code
-npm run lint
-
-# Version bumping (automated commit messages)
-npm run release:patch  # Bump patch version
-npm run release:minor  # Bump minor version
-npm run release:major  # Bump major version
-
-# Check for vulnerabilities
-npm audit
-```
-
-## Testing
-
-Currently no automated tests are configured. When implementing tests, focus on:
-- Version flag handling (`--version`, `-v`)
-- Claude Code CLI detection
-- Windows Git Bash detection logic
-- Token validation and environment setup
-
-## Release Process
-
-1. Update version in `package.json` if not using npm scripts
-2. Update `SESSION_SUMMARY.md` with changes
-3. Commit changes with descriptive message
-4. Publish to npm: `npm publish`
-5. Create GitHub release with changelog
-
-## Platform-Specific Behavior
-
-### Windows
-- Requires Git Bash for Claude Code CLI to function
-- Detects Git Bash in standard locations:
-  - `C:\Program Files\Git\bin\bash.exe` (64-bit)
-  - `C:\Program Files (x86)\Git\bin\bash.exe` (32-bit)
-  - Custom path via `CLAUDE_CODE_GIT_BASH_PATH` environment variable
-- Provides clear error messages with installation guidance
-
-### Unix (macOS/Linux)
-- No additional requirements beyond Claude Code CLI
-- Standard Unix process spawning behavior
-
-## Important Constants
-
-- `ANTHROPIC_BASE_URL`: `"https://routerlab.ch"` (ScioNos-specific endpoint)
-- Minimum Node.js version: 22
-- Package entry point: `index.js` with shebang for direct execution
-
-## Code Style Notes
-
-- ES6 modules throughout (`import`/`export`)
-- Async/await pattern for asynchronous operations
-- Colored terminal output using chalk
-- Clear user error messages with actionable guidance
-- Process exit codes: 0 (success), 1 (error)