claude-scionos 2.2.0 → 3.0.1

package/CHANGELOG.md

@@ -5,6 +5,18 @@ 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

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
 
 ---
 
@@ -99,9 +99,13 @@ npx claude-scionos
 **Ce qui se passe :**
 
 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`
-3. Lance Claude Code avec le jeton stocké **uniquement en mémoire**
-4. Nettoie automatiquement les informations d'identification à la sortie
+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
 
@@ -148,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
 
 ---
 
@@ -99,9 +99,13 @@ npx claude-scionos
 **What happens:**
 
 1.  Checks if Claude Code CLI is installed (if not, offers **automatic installation**)
-2.  Prompts for your `ANTHROPIC_AUTH_TOKEN`
-3.  Launches Claude Code with token stored **in memory only**
-4.  Automatically cleans credentials on exit
+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
 
 #### Debugging
 
@@ -136,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,11 +1,11 @@
 #!/usr/bin/env node
 
 import chalk from 'chalk';
-import { password, confirm } from '@inquirer/prompts';
+import { password, confirm, select } from '@inquirer/prompts';
 import spawn from 'cross-spawn';
 import updateNotifier from 'update-notifier';
 import process from 'node:process';
-import { execSync } from 'node:child_process';
+import http from 'node:http';
 import { createRequire } from 'node:module';
 import { isClaudeCodeInstalled, detectOS, checkGitBashOnWindows, getInstallationInstructions } from './src/detectors/claude-only.js';
 
@@ -15,6 +15,177 @@ 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);
@@ -23,166 +194,173 @@ if (process.argv.includes('--version') || process.argv.includes('-v')) {
 
 const isDebug = process.argv.includes('--scionos-debug');
 
-// 1. Enhanced System Detection
-console.log(chalk.cyan('🔍 Checking system configuration...'));
+// 1. Show Banner
+showBanner();
 
-// Detect OS and environment
+// 2. System Check
+if (isDebug) console.log(chalk.cyan('🔍 Checking system configuration...'));
 const osInfo = detectOS();
-console.log(chalk.gray(`✓ OS: ${osInfo.type} (${osInfo.arch})`));
-console.log(chalk.gray(`✓ Shell: ${osInfo.shell}`));
-
-// Check Claude Code installation
 let claudeStatus = isClaudeCodeInstalled();
 
+// Check Claude Code installation
 if (!claudeStatus.installed) {
     console.error(chalk.redBright('\n❌ Claude Code CLI not found'));
-
-    // Show detailed detection info
-    console.error(chalk.yellow('\nDetection Details:'));
-    console.error(chalk.gray(claudeStatus.details));
-    console.log(''); // spacer
-
     const shouldInstall = await confirm({
-        message: 'Claude Code CLI is not installed. Do you want to install it via npm now?',
+        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 globally...'));
-            execSync('npm install -g @anthropic-ai/claude-code', { stdio: 'inherit' });
-            console.log(chalk.green('✓ Installation successful!'));
-            
-            // Re-detect to get the new path
+            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) {
-                 // Fallback if install succeeded but path isn't picked up immediately
-                 console.warn(chalk.yellow('⚠ Installation finished, but the executable was not found in the standard paths immediately.'));
-                 console.warn(chalk.yellow('You may need to restart your terminal.'));
+                 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.yellow('Please try installing manually using the instructions below.'));
-            
-            const instructions = getInstallationInstructions(osInfo, claudeStatus);
-            console.error(chalk.cyan(instructions));
+            console.error(chalk.cyan(getInstallationInstructions(osInfo)));
             process.exit(1);
         }
     } else {
-        // User declined install
-        const instructions = getInstallationInstructions(osInfo, claudeStatus);
-        console.error(chalk.cyan(instructions));
+        console.error(chalk.cyan(getInstallationInstructions(osInfo)));
         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)
+// Check Git Bash on Windows
 let gitBashPath = null;
 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'));
+        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.green('✓ Git Bash available'));
-        console.log(chalk.gray(gitBashStatus.message));
-        gitBashPath = gitBashStatus.path;
+        console.log(chalk.yellow(`⚠ Validation warning: ${validation.message || validation.status}`));
+        const ignore = await confirm({ message: "Continue anyway?", default: false });
+        if (ignore) break;
     }
 }
 
-// 3. Intro
-console.clear();
-console.log(chalk.cyan.bold("Claude Code (via ScioNos)"));
-console.log(chalk.gray(`Running on ${osInfo.type} with ${osInfo.shell}`));
-if (isDebug) console.log(chalk.yellow("🐞 Debug Mode Active"));
-
-// 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.";
+// 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'
         }
-        return true;
-    },
-    mask: '*'
+    ]
 });
 
-// 6. Environment configuration
+// 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: "https://routerlab.ch",
+    ANTHROPIC_BASE_URL: finalBaseUrl,
     ANTHROPIC_AUTH_TOKEN: token,
-    ANTHROPIC_API_KEY: "" // Force empty string
+    ANTHROPIC_API_KEY: "" // Force empty
 };
 
-// 7. Launch Claude Code
-// Filter out our internal flag before passing args to Claude
+// 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(`Platform: ${process.platform}`));
-    console.log(chalk.gray(`Claude Command: claude ${args.join(' ')}`));
-    console.log(chalk.gray(`Router URL: ${env.ANTHROPIC_BASE_URL}`));
-    console.log(chalk.gray(`Token Length: ${token.length} chars`));
-    if (gitBashPath) console.log(chalk.gray(`Git Bash: ${gitBashPath}`));
+    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
 });
 
-// Signal Handling
-// We intentionally ignore SIGINT in the parent process.
-// Because stdio is 'inherit', the child process (Claude) receives the Ctrl+C (SIGINT) directly from the TTY.
-process.on('SIGINT', () => {
-    if (isDebug) {
-        console.error(chalk.yellow('\n[Wrapper] Received SIGINT. Waiting for Claude to exit...'));
+// 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);
 });
 
-// Handle SIGTERM (e.g., Docker stop, kill)
-process.on('SIGTERM', () => {
-    if (isDebug) {
-        console.error(chalk.yellow('\n[Wrapper] Received SIGTERM. Forwarding to Claude...'));
-    }
-    if (child) {
-        child.kill('SIGTERM');
+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(0);
+    process.exit(1);
 });
 
-child.on('close', (code) => {
-    if (isDebug) {
-        console.error(chalk.yellow(`\n[Wrapper] Child process exited with code ${code}`));
-    }
-    process.exit(code);
+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
 });
 
-child.on('error', (err) => {
-    console.error(chalk.red(`Error launching Claude at ${claudeStatus.cliPath}: ${err.message}`));
-    process.exit(1);
+process.on('SIGTERM', () => {
+    if (child) child.kill('SIGTERM');
+    cleanup();
+    process.exit(0);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-scionos",
-    "version": "2.2.0",
+    "version": "3.0.1",
     "description": "Ephemeral and secure runner for Claude Code CLI in ScioNos environment",
     "type": "module",
     "main": "index.js",

package/src/detectors/claude-only.js

@@ -6,7 +6,15 @@ 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

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)