codemax-setup 1.0.0

package/README.md

@@ -0,0 +1,32 @@
+# codemax-setup
+
+One-command setup for [CodeMax](https://codemax.pro) — configures Claude Code, MCP tools, and environment automatically.
+
+## Usage
+
+```bash
+npx codemax-setup
+```
+
+Or with your API key directly:
+
+```bash
+npx codemax-setup sk-cp-your-key-here
+```
+
+## What it does
+
+1. Validates your CodeMax API key
+2. Installs `codemax-mcp` (MCP tools: web_search & understand_image)
+3. Configures `~/.claude/settings.json` (Claude Code environment)
+4. Configures `~/.claude.json` (MCP server)
+5. Installs Claude Code CLI if missing
+
+## Requirements
+
+- [Node.js](https://nodejs.org) 18+
+
+## Links
+
+- Website: [codemax.pro](https://codemax.pro)
+- Docs: [codemax.pro/docs](https://codemax.pro/docs)

package/index.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const readline = require("readline");
+
+const API_ENDPOINT = "https://api.codemax.pro";
+const MCP_URL = "https://api.codemax.pro";
+
+// ── Colors ──
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    gray: "\x1b[90m",
+    white: "\x1b[97m",
+};
+
+const log = (msg) => console.log(msg);
+const ok = (msg) => log(`  ${c.green}✓ ${msg}${c.reset}`);
+const warn = (msg) => log(`  ${c.yellow}⚠ ${msg}${c.reset}`);
+const fail = (msg) => log(`  ${c.red}✗ ${msg}${c.reset}`);
+const info = (msg) => log(`  ${c.cyan}${msg}${c.reset}`);
+const gray = (msg) => log(`  ${c.gray}${msg}${c.reset}`);
+
+function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+function readJson(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            const raw = fs.readFileSync(filePath, "utf8").trim();
+            if (!raw) return {};
+            return JSON.parse(raw);
+        }
+    } catch {}
+    return {};
+}
+
+function writeJson(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+}
+
+function run(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf8", stdio: "pipe" }).trim();
+    } catch {
+        return null;
+    }
+}
+
+function which(cmd) {
+    try {
+        const r = execSync(process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`, {
+            encoding: "utf8",
+            stdio: "pipe",
+        }).trim();
+        return r ? true : false;
+    } catch {
+        return false;
+    }
+}
+
+async function validateKey(apiKey) {
+    const body = JSON.stringify({
+        model: "claude-opus-4-6-thinking",
+        max_tokens: 10,
+        messages: [{ role: "user", content: "Hi" }],
+    });
+
+    try {
+        const res = await fetch(`${API_ENDPOINT}/messages`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body,
+            signal: AbortSignal.timeout(30000),
+        });
+
+        if (res.ok) return { valid: true };
+        if (res.status === 429) return { valid: true, rateLimit: true };
+        if (res.status === 401 || res.status === 403) return { valid: false, reason: "Invalid API key" };
+        if (res.status === 402) return { valid: false, reason: "No remaining balance" };
+        return { valid: false, reason: `Server returned ${res.status}` };
+    } catch (e) {
+        return { valid: false, reason: e.message, network: true };
+    }
+}
+
+async function main() {
+    log("");
+    log(`  ${c.cyan}╔══════════════════════════════════════════╗${c.reset}`);
+    log(`  ${c.cyan}║        ${c.bold}CodeMax Setup${c.reset}${c.cyan}                     ║${c.reset}`);
+    log(`  ${c.cyan}╚══════════════════════════════════════════╝${c.reset}`);
+    log("");
+
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home) {
+        fail("Cannot determine home directory");
+        process.exit(1);
+    }
+
+    // ── Get API Key ──
+    let apiKey = process.argv[2] || "";
+    if (!apiKey) {
+        log(`  ${c.white}Enter your CodeMax API key${c.reset}`);
+        gray("Get it from your admin or codemax.pro");
+        log("");
+        apiKey = await ask(`  ${c.white}API Key: ${c.reset}`);
+        log("");
+    }
+
+    if (!apiKey || apiKey.length < 5) {
+        fail("No valid API key provided. Exiting.");
+        process.exit(1);
+    }
+
+    // ── [1/6] Validate API Key ──
+    info("[1/6] Validating API key...");
+    const result = await validateKey(apiKey);
+
+    if (result.valid) {
+        if (result.rateLimit) {
+            warn("API key valid but rate-limited. Continuing setup...");
+        } else {
+            ok("API key is valid!");
+            ok("Connected to CodeMax");
+        }
+    } else if (result.network) {
+        warn(`Could not reach server: ${result.reason}`);
+        const cont = await ask(`  ${c.yellow}Continue anyway? (y/n): ${c.reset}`);
+        if (cont.toLowerCase() !== "y") process.exit(1);
+    } else {
+        fail(result.reason);
+        gray("Make sure you're using a valid CodeMax API key (sk-cp-...)");
+        process.exit(1);
+    }
+    log("");
+
+    // ── [2/6] Check Node.js ──
+    info("[2/6] Checking Node.js...");
+    const nodeVer = run("node --version");
+    if (nodeVer) {
+        ok(`Node.js ${nodeVer} found`);
+    } else {
+        fail("Node.js not found. Install from https://nodejs.org");
+        process.exit(1);
+    }
+    log("");
+
+    // ── [3/6] Install codemax-mcp ──
+    info("[3/6] Installing codemax-mcp...");
+    const mcpResult = run("npm install -g codemax-mcp");
+    if (mcpResult !== null) {
+        ok("codemax-mcp installed");
+    } else {
+        warn("Could not install globally, will use npx");
+    }
+    log("");
+
+    // ── [4/6] Configure Claude Code settings ──
+    info("[4/6] Configuring Claude Code settings...");
+    const settingsPath = path.join(home, ".claude", "settings.json");
+    try {
+        const settings = readJson(settingsPath);
+        if (!settings.env) settings.env = {};
+
+        Object.assign(settings.env, {
+            ANTHROPIC_AUTH_TOKEN: apiKey,
+            ANTHROPIC_BASE_URL: API_ENDPOINT,
+            ANTHROPIC_MODEL: "claude-opus-4-6-thinking",
+            ANTHROPIC_REASONING_MODEL: "Opus 4.6",
+            ANTHROPIC_DEFAULT_SONNET_MODEL: "Sonnet 4.5",
+            ANTHROPIC_DEFAULT_OPUS_MODEL: "Opus 4.6",
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: "Haiku 4.5",
+            CLAUDE_CODE_SUBAGENT_MODEL: "claude-opus-4-6-thinking",
+            ENABLE_EXPERIMENTAL_MCP_CLI: "true",
+        });
+
+        settings.model = "opus[1m]";
+
+        writeJson(settingsPath, settings);
+        ok(settingsPath);
+    } catch (e) {
+        fail(`Failed: ${e.message}`);
+    }
+    log("");
+
+    // ── [5/6] Configure MCP server ──
+    info("[5/6] Configuring MCP server...");
+    const claudeJsonPath = path.join(home, ".claude.json");
+    try {
+        const claudeJson = readJson(claudeJsonPath);
+        if (!claudeJson.mcpServers) claudeJson.mcpServers = {};
+
+        claudeJson.mcpServers.CodeMax = {
+            command: "npx",
+            args: ["-y", "codemax-mcp"],
+            env: {
+                CodeMax_API_KEY: apiKey,
+                CodeMax_URL: MCP_URL,
+            },
+        };
+        claudeJson.hasCompletedOnboarding = true;
+
+        writeJson(claudeJsonPath, claudeJson);
+        ok(claudeJsonPath);
+    } catch (e) {
+        fail(`Failed: ${e.message}`);
+    }
+    log("");
+
+    // ── Clear stale env vars (Windows only) ──
+    if (process.platform === "win32") {
+        const staleVars = [
+            "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL",
+            "ANTHROPIC_MODEL", "ANTHROPIC_SMALL_FAST_MODEL",
+            "ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_OPUS_MODEL",
+            "ANTHROPIC_DEFAULT_HAIKU_MODEL", "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
+        ];
+        for (const v of staleVars) {
+            run(`setx ${v} ""`);
+        }
+    }
+
+    // ── [6/6] Install Claude Code CLI ──
+    info("[6/6] Checking Claude Code CLI...");
+    if (which("claude")) {
+        ok("Claude Code CLI already installed");
+    } else {
+        info("Installing Claude Code CLI...");
+        const cliResult = run("npm install -g @anthropic-ai/claude-code");
+        if (cliResult !== null) {
+            ok("Claude Code CLI installed!");
+        } else {
+            warn("Auto-install failed. Run: npm install -g @anthropic-ai/claude-code");
+        }
+    }
+
+    // ── Done ──
+    log("");
+    log(`  ${c.green}╔══════════════════════════════════════════╗${c.reset}`);
+    log(`  ${c.green}║       ${c.bold}✓ Setup complete!${c.reset}${c.green}                  ║${c.reset}`);
+    log(`  ${c.green}╚══════════════════════════════════════════╝${c.reset}`);
+    log("");
+    log(`  ${c.white}What was configured:${c.reset}`);
+    gray(`  • API key validated ✓`);
+    gray(`  • Claude Code settings (~/.claude/settings.json)`);
+    gray(`  • MCP server with web_search & understand_image (~/.claude.json)`);
+    gray(`  • Claude Code CLI`);
+    log("");
+    log(`  ${c.gray}╭───────────────────────────────────────╮${c.reset}`);
+    log(`  ${c.gray}│  Base URL:  api.codemax.pro           │${c.reset}`);
+    log(`  ${c.gray}│  Key:       ${apiKey.substring(0, 8)}...              │${c.reset}`);
+    log(`  ${c.gray}│  MCP:       CodeMax (web_search +     │${c.reset}`);
+    log(`  ${c.gray}│             understand_image)          │${c.reset}`);
+    log(`  ${c.gray}╰───────────────────────────────────────╯${c.reset}`);
+    log("");
+    gray("Restart Claude Code / VS Code to apply.");
+    gray("Re-run anytime to update your key.");
+    log("");
+
+    // Ask to launch
+    if (which("claude")) {
+        const launch = await ask(`  ${c.white}Launch Claude Code now? (y/n): ${c.reset}`);
+        if (launch.toLowerCase() === "y" || launch === "") {
+            log("");
+            info("🚀 Launching Claude Code...");
+            log(`  ${c.gray}════════════════════════════════════${c.reset}`);
+            log("");
+            try {
+                execSync("claude", { stdio: "inherit" });
+            } catch {}
+        } else {
+            log("");
+            log(`  ${c.white}To start later, open any terminal and type: claude${c.reset}`);
+            log("");
+        }
+    }
+}
+
+main().catch((e) => {
+    fail(`Unexpected error: ${e.message}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "codemax-setup",
+    "version": "1.0.0",
+    "description": "One-command setup for CodeMax — configures Claude Code, MCP tools, and environment",
+    "main": "index.js",
+    "bin": {
+        "codemax-setup": "index.js"
+    },
+    "keywords": [
+        "codemax",
+        "claude",
+        "claude-code",
+        "setup",
+        "anthropic",
+        "mcp",
+        "ai",
+        "coding-assistant"
+    ],
+    "author": "CodeMax",
+    "license": "MIT",
+    "engines": {
+        "node": ">=18"
+    },
+    "files": [
+        "index.js",
+        "README.md"
+    ]
+}