codemaxxing 0.1.3 → 0.1.5

package/dist/auth-cli.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * codemaxxing auth CLI
+ *
+ * Commands:
+ *   codemaxxing login              — Interactive auth setup
+ *   codemaxxing auth list          — List saved credentials
+ *   codemaxxing auth remove <name> — Remove a credential
+ *   codemaxxing auth openrouter    — Start OpenRouter OAuth
+ *   codemaxxing auth anthropic     — Get Anthropic via Claude Code
+ *   codemaxxing auth openai        — Import Codex CLI credentials
+ *   codemaxxing auth qwen          — Import Qwen CLI credentials
+ *   codemaxxing auth copilot       — GitHub Copilot device flow
+ *   codemaxxing auth api-key <name> <key> — Save API key directly
+ */
+export declare function main(): Promise<void>;

package/dist/auth-cli.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+/**
+ * codemaxxing auth CLI
+ *
+ * Commands:
+ *   codemaxxing login              — Interactive auth setup
+ *   codemaxxing auth list          — List saved credentials
+ *   codemaxxing auth remove <name> — Remove a credential
+ *   codemaxxing auth openrouter    — Start OpenRouter OAuth
+ *   codemaxxing auth anthropic     — Get Anthropic via Claude Code
+ *   codemaxxing auth openai        — Import Codex CLI credentials
+ *   codemaxxing auth qwen          — Import Qwen CLI credentials
+ *   codemaxxing auth copilot       — GitHub Copilot device flow
+ *   codemaxxing auth api-key <name> <key> — Save API key directly
+ */
+import { PROVIDERS, getCredentials, removeCredential, openRouterOAuth, anthropicSetupToken, importCodexToken, importQwenToken, copilotDeviceFlow, saveApiKey, detectAvailableAuth, } from "./utils/auth.js";
+export async function main() {
+    const command = process.argv[2] ?? "login";
+    switch (command) {
+        case "login": {
+            console.log("\n💪 Codemaxxing Authentication\n");
+            console.log("Available providers:\n");
+            PROVIDERS.forEach((p, i) => {
+                const methods = p.methods.filter((m) => m !== "none").join(", ");
+                console.log(`  ${i + 1}. ${p.name}`);
+                console.log(`     ${p.description}`);
+                console.log(`     Methods: ${methods}\n`);
+            });
+            console.log("Detected on this machine:");
+            const detected = detectAvailableAuth();
+            if (detected.length === 0) {
+                console.log("  — No existing CLI credentials found\n");
+            }
+            else {
+                detected.forEach((d) => {
+                    console.log(`  ⚡ ${d.provider} — ${d.description}`);
+                });
+                console.log("");
+            }
+            const readline = await import("readline");
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+            const choice = await ask("Select a provider (1-" + PROVIDERS.length + ") or name: ");
+            const providerId = PROVIDERS[parseInt(choice) - 1]?.id ?? choice.toLowerCase();
+            const provider = PROVIDERS.find((p) => p.id === providerId);
+            if (!provider) {
+                console.log(`Unknown provider: ${providerId}`);
+                process.exit(1);
+            }
+            console.log(`\nSetting up ${provider.name}...\n`);
+            try {
+                if (providerId === "openrouter") {
+                    const cred = await openRouterOAuth((msg) => console.log(`  ${msg}`));
+                    console.log(`\n✅ OpenRouter authenticated! (${cred.label})`);
+                }
+                else if (providerId === "anthropic") {
+                    if (provider.methods.includes("setup-token")) {
+                        const cred = await anthropicSetupToken((msg) => console.log(`  ${msg}`));
+                        console.log(`\n✅ Anthropic authenticated! (${cred.label})`);
+                    }
+                    else {
+                        const apiKey = await ask("Enter your Anthropic API key: ");
+                        const cred = saveApiKey(providerId, apiKey);
+                        console.log(`\n✅ Saved API key for ${provider.name}`);
+                    }
+                }
+                else if (providerId === "openai") {
+                    const imported = importCodexToken((msg) => console.log(`  ${msg}`));
+                    if (imported) {
+                        console.log(`\n✅ Imported Codex credentials! (${imported.label})`);
+                    }
+                    else {
+                        const apiKey = await ask("Enter your OpenAI API key: ");
+                        const cred = saveApiKey(providerId, apiKey);
+                        console.log(`\n✅ Saved API key for ${provider.name}`);
+                    }
+                }
+                else if (providerId === "qwen") {
+                    const imported = importQwenToken((msg) => console.log(`  ${msg}`));
+                    if (imported) {
+                        console.log(`\n✅ Imported Qwen credentials! (${imported.label})`);
+                    }
+                    else {
+                        const apiKey = await ask("Enter your Qwen/DashScope API key: ");
+                        const cred = saveApiKey(providerId, apiKey);
+                        console.log(`\n✅ Saved API key for ${provider.name}`);
+                    }
+                }
+                else if (providerId === "copilot") {
+                    const cred = await copilotDeviceFlow((msg) => console.log(`  ${msg}`));
+                    console.log(`\n✅ GitHub Copilot authenticated!`);
+                }
+                else if (providerId === "custom") {
+                    const baseUrl = await ask("Enter the base URL: ");
+                    const apiKey = await ask("Enter your API key: ");
+                    const cred = saveApiKey(providerId, apiKey, baseUrl, "Custom provider");
+                    console.log(`\n✅ Saved custom provider`);
+                }
+                else {
+                    const apiKey = await ask(`Enter your ${provider.name} API key (${provider.consoleUrl}): `);
+                    const cred = saveApiKey(providerId, apiKey);
+                    console.log(`\n✅ Saved API key for ${provider.name}`);
+                }
+                console.log("\nRun 'codemaxxing' to start coding!");
+            }
+            catch (err) {
+                console.error(`\n❌ Error: ${err.message}`);
+                process.exit(1);
+            }
+            finally {
+                rl.close();
+            }
+            break;
+        }
+        case "list":
+        case "ls": {
+            const creds = getCredentials();
+            console.log("\n💪 Saved Credentials\n");
+            if (creds.length === 0) {
+                console.log("  No credentials saved.\n");
+                console.log("  Run 'codemaxxing login' to set up authentication.\n");
+                break;
+            }
+            creds.forEach((c) => {
+                console.log(`  ${c.provider}`);
+                console.log(`    Method: ${c.method}`);
+                console.log(`    Label: ${c.label ?? "—"}`);
+                const maskedKey = c.apiKey.length > 12
+                    ? c.apiKey.slice(0, 4) + "•".repeat(8) + c.apiKey.slice(-4)
+                    : "••••••••";
+                console.log(`    Key: ${maskedKey}`);
+                console.log(`    Base: ${c.baseUrl}`);
+                console.log("");
+            });
+            break;
+        }
+        case "remove":
+        case "rm":
+        case "delete": {
+            const target = process.argv[3];
+            if (!target) {
+                console.log("Usage: codemaxxing auth remove <provider-name>");
+                console.log("\nSaved providers:");
+                getCredentials().forEach((c) => console.log(`  ${c.provider}`));
+                process.exit(1);
+            }
+            const removed = removeCredential(target);
+            if (removed) {
+                console.log(`✅ Removed ${target}`);
+            }
+            else {
+                console.log(`❌ No credential found for: ${target}`);
+                console.log("\nSaved providers:");
+                getCredentials().forEach((c) => console.log(`  ${c.provider}`));
+                process.exit(1);
+            }
+            break;
+        }
+        case "openrouter": {
+            console.log("Starting OpenRouter OAuth flow...\n");
+            try {
+                const cred = await openRouterOAuth((msg) => console.log(`  ${msg}`));
+                console.log(`\n✅ OpenRouter authenticated!`);
+            }
+            catch (err) {
+                console.error(`\n❌ ${err.message}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case "anthropic": {
+            console.log("Starting Anthropic setup-token flow...\n");
+            try {
+                const cred = await anthropicSetupToken((msg) => console.log(`  ${msg}`));
+                console.log(`\n✅ Anthropic authenticated!`);
+            }
+            catch (err) {
+                console.error(`\n❌ ${err.message}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case "openai": {
+            console.log("Checking for Codex CLI credentials...\n");
+            const imported = importCodexToken((msg) => console.log(`  ${msg}`));
+            if (imported) {
+                console.log(`\n✅ Imported Codex credentials!`);
+            }
+            else {
+                console.log("\n❌ No Codex CLI credentials found.");
+                console.log("Make sure Codex CLI is installed and you've logged in.");
+            }
+            break;
+        }
+        case "qwen": {
+            console.log("Checking for Qwen CLI credentials...\n");
+            const imported = importQwenToken((msg) => console.log(`  ${msg}`));
+            if (imported) {
+                console.log(`\n✅ Imported Qwen credentials!`);
+            }
+            else {
+                console.log("\n❌ No Qwen CLI credentials found.");
+                console.log("Make sure Qwen CLI is installed and you've logged in.");
+            }
+            break;
+        }
+        case "copilot": {
+            console.log("Starting GitHub Copilot device flow...\n");
+            try {
+                const cred = await copilotDeviceFlow((msg) => console.log(`  ${msg}`));
+                console.log(`\n✅ GitHub Copilot authenticated!`);
+            }
+            catch (err) {
+                console.error(`\n❌ ${err.message}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case "api-key": {
+            const providerId = process.argv[3];
+            const apiKey = process.argv[4];
+            if (!providerId || !apiKey) {
+                console.log("Usage: codemaxxing auth api-key <provider-id> <api-key>");
+                process.exit(1);
+            }
+            const cred = saveApiKey(providerId, apiKey);
+            console.log(`\n✅ Saved API key for ${cred.provider}`);
+            break;
+        }
+        case "help":
+        case "--help":
+        case "-h": {
+            console.log(`
+💪 Codemaxxing Auth
+
+Commands:
+  codemaxxing login              Interactive authentication setup
+  codemaxxing auth list          List saved credentials
+  codemaxxing auth remove <name> Remove a credential
+  codemaxxing auth openrouter    Start OpenRouter OAuth flow
+  codemaxxing auth anthropic     Get Anthropic via Claude Code CLI
+  codemaxxing auth openai        Import Codex CLI credentials
+  codemaxxing auth qwen          Import Qwen CLI credentials
+  codemaxxing auth copilot       GitHub Copilot device flow
+  codemaxxing auth api-key <id> <key>  Save API key directly
+  codemaxxing auth help          Show this help
+
+Examples:
+  codemaxxing login              # Interactive provider picker
+  codemaxxing auth openrouter    # One browser login, access to 200+ models
+  codemaxxing auth anthropic     # Use your Claude subscription via Claude Code
+  codemaxxing auth list          # See what's saved
+`);
+            break;
+        }
+        default:
+            console.log(`Unknown command: ${command}`);
+            console.log("Run 'codemaxxing auth help' for available commands.");
+            process.exit(1);
+    }
+}
+// Run main if this is the main module
+if (typeof require !== "undefined" && require.main === module) {
+    main().catch((err) => {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Codemaxxing CLI entry point
+ * Routes subcommands (login, auth) to auth-cli, everything else to the TUI
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * Codemaxxing CLI entry point
+ * Routes subcommands (login, auth) to auth-cli, everything else to the TUI
+ */
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const subcmd = process.argv[2];
+if (subcmd === "login" || subcmd === "auth") {
+    // Route to auth CLI
+    const authScript = join(__dirname, "auth-cli.js");
+    const args = subcmd === "login"
+        ? [authScript, "login", ...process.argv.slice(3)]
+        : [authScript, ...process.argv.slice(3)];
+    const child = spawn(process.execPath, args, {
+        stdio: "inherit",
+        cwd: process.cwd(),
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+}
+else {
+    // Route to TUI
+    const tuiScript = join(__dirname, "index.js");
+    const child = spawn(process.execPath, [tuiScript, ...process.argv.slice(2)], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+}

package/dist/config.d.ts

@@ -39,3 +39,12 @@ export declare function detectLocalProvider(): Promise<ProviderConfig | null>;
  * List available models from a provider endpoint
  */
 export declare function listModels(baseUrl: string, apiKey: string): Promise<string[]>;
+/**
+ * Resolve provider configuration from auth store or config file
+ * Priority: CLI args > auth store > config file > auto-detect
+ */
+export declare function resolveProvider(providerId: string, cliArgs: CLIArgs): {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+} | null;

package/dist/config.js

@@ -1,6 +1,7 @@
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { getCredential } from "./utils/auth.js";
 const CONFIG_DIR = join(homedir(), ".codemaxxing");
 const CONFIG_FILE = join(CONFIG_DIR, "settings.json");
 const DEFAULT_CONFIG = {
@@ -172,3 +173,29 @@ export async function listModels(baseUrl, apiKey) {
     catch { /* ignore */ }
     return [];
 }
+/**
+ * Resolve provider configuration from auth store or config file
+ * Priority: CLI args > auth store > config file > auto-detect
+ */
+export function resolveProvider(providerId, cliArgs) {
+    // Check auth store first
+    const authCred = getCredential(providerId);
+    if (authCred) {
+        return {
+            baseUrl: authCred.baseUrl,
+            apiKey: authCred.apiKey,
+            model: cliArgs.model || "auto",
+        };
+    }
+    // Fall back to config file
+    const config = loadConfig();
+    const provider = config.providers?.[providerId];
+    if (provider) {
+        return {
+            baseUrl: provider.baseUrl,
+            apiKey: cliArgs.apiKey || provider.apiKey,
+            model: cliArgs.model || provider.model,
+        };
+    }
+    return null;
+}

package/dist/index.js

@@ -10,7 +10,8 @@ import { listSessions, getSession, loadMessages } from "./utils/sessions.js";
 import { execSync } from "child_process";
 import { isGitRepo, getBranch, getStatus, getDiff, undoLastCommit } from "./utils/git.js";
 import { getTheme, listThemes, THEMES, DEFAULT_THEME } from "./themes.js";
-const VERSION = "0.1.0";
+import { PROVIDERS, openRouterOAuth, anthropicSetupToken, importCodexToken, importQwenToken, copilotDeviceFlow } from "./utils/auth.js";
+const VERSION = "0.1.5";
 // ── Helpers ──
 function formatTimeAgo(date) {
     const secs = Math.floor((Date.now() - date.getTime()) / 1000);
@@ -28,6 +29,8 @@ function formatTimeAgo(date) {
 // ── Slash Commands ──
 const SLASH_COMMANDS = [
     { cmd: "/help", desc: "show commands" },
+    { cmd: "/login", desc: "set up authentication" },
+    { cmd: "/login", desc: "set up authentication" },
     { cmd: "/map", desc: "show repository map" },
     { cmd: "/reset", desc: "clear conversation" },
     { cmd: "/context", desc: "show message count" },
@@ -104,6 +107,8 @@ function App() {
     const [sessionPickerIndex, setSessionPickerIndex] = useState(0);
     const [themePicker, setThemePicker] = useState(false);
     const [themePickerIndex, setThemePickerIndex] = useState(0);
+    const [loginPicker, setLoginPicker] = useState(false);
+    const [loginPickerIndex, setLoginPickerIndex] = useState(0);
     const [approval, setApproval] = useState(null);
     // Listen for paste events from stdin interceptor
     useEffect(() => {
@@ -275,10 +280,16 @@ function App() {
             exit();
             return;
         }
+        if (trimmed === "/login" || trimmed === "/auth") {
+            setLoginPicker(true);
+            setLoginPickerIndex(0);
+            return;
+        }
         if (trimmed === "/help") {
             addMsg("info", [
                 "Commands:",
                 "  /help      — show this",
+                "  /login     — authentication setup (run codemaxxing login in terminal)",
                 "  /model     — switch model mid-session",
                 "  /models    — list available models",
                 "  /map       — show repository map",
@@ -487,6 +498,92 @@ function App() {
                 return;
             }
         }
+        // Login picker navigation
+        if (loginPicker) {
+            const loginProviders = PROVIDERS.filter((p) => p.id !== "local");
+            if (key.upArrow) {
+                setLoginPickerIndex((prev) => (prev - 1 + loginProviders.length) % loginProviders.length);
+                return;
+            }
+            if (key.downArrow) {
+                setLoginPickerIndex((prev) => (prev + 1) % loginProviders.length);
+                return;
+            }
+            if (key.return) {
+                const selected = loginProviders[loginPickerIndex];
+                setLoginPicker(false);
+                if (selected.id === "openrouter") {
+                    addMsg("info", "Starting OpenRouter OAuth — opening browser...");
+                    setLoading(true);
+                    setSpinnerMsg("Waiting for authorization...");
+                    openRouterOAuth((msg) => addMsg("info", msg))
+                        .then((cred) => {
+                        addMsg("info", `✅ OpenRouter authenticated! You now have access to 200+ models.`);
+                        addMsg("info", `Switch with: /model anthropic/claude-sonnet-4`);
+                        setLoading(false);
+                    })
+                        .catch((err) => {
+                        addMsg("error", `OAuth failed: ${err.message}`);
+                        setLoading(false);
+                    });
+                }
+                else if (selected.id === "anthropic") {
+                    addMsg("info", "Starting Anthropic setup-token flow...");
+                    setLoading(true);
+                    setSpinnerMsg("Waiting for Claude Code auth...");
+                    anthropicSetupToken((msg) => addMsg("info", msg))
+                        .then((cred) => {
+                        addMsg("info", `✅ Anthropic authenticated! (${cred.label})`);
+                        setLoading(false);
+                    })
+                        .catch((err) => {
+                        addMsg("error", `Anthropic auth failed: ${err.message}`);
+                        setLoading(false);
+                    });
+                }
+                else if (selected.id === "openai") {
+                    const imported = importCodexToken((msg) => addMsg("info", msg));
+                    if (imported) {
+                        addMsg("info", `✅ Imported Codex credentials! (${imported.label})`);
+                    }
+                    else {
+                        addMsg("info", "No Codex CLI found. Run: codemaxxing auth api-key openai <your-key>");
+                    }
+                }
+                else if (selected.id === "qwen") {
+                    const imported = importQwenToken((msg) => addMsg("info", msg));
+                    if (imported) {
+                        addMsg("info", `✅ Imported Qwen credentials! (${imported.label})`);
+                    }
+                    else {
+                        addMsg("info", "No Qwen CLI found. Run: codemaxxing auth api-key qwen <your-key>");
+                    }
+                }
+                else if (selected.id === "copilot") {
+                    addMsg("info", "Starting GitHub Copilot device flow...");
+                    setLoading(true);
+                    setSpinnerMsg("Waiting for GitHub authorization...");
+                    copilotDeviceFlow((msg) => addMsg("info", msg))
+                        .then(() => {
+                        addMsg("info", `✅ GitHub Copilot authenticated!`);
+                        setLoading(false);
+                    })
+                        .catch((err) => {
+                        addMsg("error", `Copilot auth failed: ${err.message}`);
+                        setLoading(false);
+                    });
+                }
+                else {
+                    addMsg("info", `Run: codemaxxing auth api-key ${selected.id} <your-key>\n  Get key at: ${selected.consoleUrl ?? selected.baseUrl}`);
+                }
+                return;
+            }
+            if (key.escape) {
+                setLoginPicker(false);
+                return;
+            }
+            return;
+        }
         // Theme picker navigation
         if (themePicker) {
             const themeKeys = listThemes();

package/dist/utils/auth.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Auth management for Codemaxxing
+ *
+ * Supports:
+ * - OpenRouter OAuth PKCE (browser login, no API key needed)
+ * - Anthropic setup-token (via Claude Code CLI)
+ * - OpenAI/ChatGPT (via Codex CLI cached token)
+ * - Qwen (via Qwen CLI cached credentials)
+ * - GitHub Copilot (device flow)
+ * - Manual API key entry (any provider)
+ *
+ * Credentials stored in ~/.codemaxxing/auth.json with 0o600 permissions.
+ */
+export interface AuthCredential {
+    provider: string;
+    method: "api-key" | "oauth" | "setup-token" | "cached-token";
+    apiKey: string;
+    baseUrl: string;
+    label?: string;
+    expiresAt?: string;
+    createdAt: string;
+}
+export interface ProviderDef {
+    id: string;
+    name: string;
+    methods: string[];
+    baseUrl: string;
+    consoleUrl?: string;
+    description: string;
+}
+export declare const PROVIDERS: ProviderDef[];
+export declare function getCredentials(): AuthCredential[];
+export declare function getCredential(providerId: string): AuthCredential | undefined;
+export declare function saveCredential(cred: AuthCredential): void;
+export declare function removeCredential(providerId: string): boolean;
+export declare function openRouterOAuth(onStatus?: (msg: string) => void): Promise<AuthCredential>;
+export declare function detectClaudeCLI(): boolean;
+export declare function anthropicSetupToken(onStatus?: (msg: string) => void): Promise<AuthCredential>;
+export declare function detectCodexToken(): string | null;
+export declare function importCodexToken(onStatus?: (msg: string) => void): AuthCredential | null;
+export declare function detectQwenToken(): string | null;
+export declare function importQwenToken(onStatus?: (msg: string) => void): AuthCredential | null;
+export declare function copilotDeviceFlow(onStatus?: (msg: string) => void): Promise<AuthCredential>;
+export declare function saveApiKey(providerId: string, apiKey: string, baseUrl?: string, label?: string): AuthCredential;
+/**
+ * Check which provider CLIs / cached tokens are available on this machine
+ */
+export declare function detectAvailableAuth(): Array<{
+    provider: string;
+    method: string;
+    description: string;
+}>;
+/**
+ * Resolve provider config: check auth store first, then fall back to config
+ */
+export declare function resolveProviderAuth(providerId: string): {
+    apiKey: string;
+    baseUrl: string;
+} | null;