codemaxxing 1.0.16 → 1.1.0

package/dist/ui/wizard.js

@@ -0,0 +1,214 @@
+import { detectHardware } from "../utils/hardware.js";
+import { getRecommendationsWithLlmfit } from "../utils/models.js";
+import { isOllamaInstalled, isOllamaRunning, startOllama, pullModel, getOllamaInstallCommand } from "../utils/ollama.js";
+import { openRouterOAuth } from "../utils/auth.js";
+export function handleWizardScreen(_inputChar, key, ctx) {
+    if (!ctx.wizardScreen)
+        return false;
+    if (ctx.wizardScreen === "connection") {
+        const items = ["local", "openrouter", "apikey", "existing"];
+        if (key.upArrow) {
+            ctx.setWizardIndex((prev) => (prev - 1 + items.length) % items.length);
+            return true;
+        }
+        if (key.downArrow) {
+            ctx.setWizardIndex((prev) => (prev + 1) % items.length);
+            return true;
+        }
+        if (key.escape) {
+            ctx.setWizardScreen(null);
+            return true;
+        }
+        if (key.return) {
+            const selected = items[ctx.wizardIndex];
+            if (selected === "local") {
+                const hw = detectHardware();
+                ctx.setWizardHardware(hw);
+                const { models: recs } = getRecommendationsWithLlmfit(hw);
+                ctx.setWizardModels(recs.filter(m => m.fit !== "skip"));
+                ctx.setWizardScreen("models");
+                ctx.setWizardIndex(() => 0);
+            }
+            else if (selected === "openrouter") {
+                ctx.setWizardScreen(null);
+                ctx.addMsg("info", "Starting OpenRouter OAuth — opening browser...");
+                ctx.setLoading(true);
+                ctx.setSpinnerMsg("Waiting for authorization...");
+                openRouterOAuth((msg) => ctx.addMsg("info", msg))
+                    .then(() => {
+                    ctx.addMsg("info", "✅ OpenRouter authenticated! Use /connect to connect.");
+                    ctx.setLoading(false);
+                })
+                    .catch((err) => { ctx.addMsg("error", `OAuth failed: ${err.message}`); ctx.setLoading(false); });
+            }
+            else if (selected === "apikey") {
+                ctx.setWizardScreen(null);
+                ctx.setLoginPicker(true);
+                ctx.setLoginPickerIndex(() => 0);
+            }
+            else if (selected === "existing") {
+                ctx.setWizardScreen(null);
+                ctx.addMsg("info", "Start your LLM server, then type /connect to retry.");
+            }
+            return true;
+        }
+        return true;
+    }
+    if (ctx.wizardScreen === "models") {
+        const models = ctx.wizardModels;
+        if (key.upArrow) {
+            ctx.setWizardIndex((prev) => (prev - 1 + models.length) % models.length);
+            return true;
+        }
+        if (key.downArrow) {
+            ctx.setWizardIndex((prev) => (prev + 1) % models.length);
+            return true;
+        }
+        if (key.escape) {
+            ctx.setWizardScreen("connection");
+            ctx.setWizardIndex(() => 0);
+            return true;
+        }
+        if (key.return) {
+            const selected = models[ctx.wizardIndex];
+            if (selected) {
+                ctx.setWizardSelectedModel(selected);
+                if (!isOllamaInstalled()) {
+                    ctx.setWizardScreen("install-ollama");
+                }
+                else {
+                    startPullFlow(ctx, selected);
+                }
+            }
+            return true;
+        }
+        return true;
+    }
+    if (ctx.wizardScreen === "install-ollama") {
+        if (key.escape) {
+            ctx.setWizardScreen("models");
+            ctx.setWizardIndex(() => 0);
+            return true;
+        }
+        if (key.return) {
+            if (!isOllamaInstalled()) {
+                ctx.setLoading(true);
+                ctx.setSpinnerMsg("Installing Ollama... this may take a minute");
+                const installCmd = getOllamaInstallCommand(ctx.wizardHardware?.os ?? "linux");
+                (async () => {
+                    try {
+                        const { exec } = ctx._require("child_process");
+                        await new Promise((resolve, reject) => {
+                            exec(installCmd, { timeout: 180000 }, (err, _stdout, stderr) => {
+                                if (err)
+                                    reject(new Error(stderr || err.message));
+                                else
+                                    resolve();
+                            });
+                        });
+                        ctx.addMsg("info", "✅ Ollama installed! Proceeding to model download...");
+                        ctx.setLoading(false);
+                        await new Promise(r => setTimeout(r, 2000));
+                        ctx.setWizardScreen("models");
+                    }
+                    catch (e) {
+                        ctx.addMsg("error", `Install failed: ${e.message}`);
+                        ctx.addMsg("info", `Try manually in a separate terminal: ${installCmd}`);
+                        ctx.setLoading(false);
+                        ctx.setWizardScreen("install-ollama");
+                    }
+                })();
+                return true;
+            }
+            // Ollama already installed — proceed to pull
+            {
+                const selected = ctx.wizardSelectedModel;
+                if (selected) {
+                    startPullFlow(ctx, selected);
+                }
+            }
+            return true;
+        }
+        return true;
+    }
+    if (ctx.wizardScreen === "pulling") {
+        if (ctx.wizardPullError && key.return) {
+            const selected = ctx.wizardSelectedModel;
+            if (selected) {
+                ctx.setWizardPullError(null);
+                ctx.setWizardPullProgress({ status: "retrying", percent: 0 });
+                (async () => {
+                    try {
+                        const running = await isOllamaRunning();
+                        if (!running) {
+                            startOllama();
+                            for (let i = 0; i < 15; i++) {
+                                await new Promise(r => setTimeout(r, 1000));
+                                if (await isOllamaRunning())
+                                    break;
+                            }
+                        }
+                        await pullModel(selected.ollamaId, (p) => ctx.setWizardPullProgress(p));
+                        ctx.setWizardPullProgress({ status: "success", percent: 100 });
+                        await new Promise(r => setTimeout(r, 500));
+                        ctx.setWizardScreen(null);
+                        ctx.setWizardPullProgress(null);
+                        ctx.setWizardSelectedModel(null);
+                        ctx.addMsg("info", `✅ ${selected.name} installed! Connecting...`);
+                        await ctx.connectToProvider(true);
+                    }
+                    catch (err) {
+                        ctx.setWizardPullError(err.message);
+                    }
+                })();
+            }
+            return true;
+        }
+        if (ctx.wizardPullError && key.escape) {
+            ctx.setWizardScreen("models");
+            ctx.setWizardIndex(() => 0);
+            ctx.setWizardPullError(null);
+            ctx.setWizardPullProgress(null);
+            return true;
+        }
+        return true; // Ignore keys while pulling
+    }
+    return true;
+}
+// ── Shared pull-model flow ──
+function startPullFlow(ctx, selected) {
+    ctx.setWizardScreen("pulling");
+    ctx.setWizardPullProgress({ status: "starting", percent: 0 });
+    ctx.setWizardPullError(null);
+    (async () => {
+        try {
+            const running = await isOllamaRunning();
+            if (!running) {
+                ctx.setWizardPullProgress({ status: "Starting Ollama server...", percent: 0 });
+                startOllama();
+                for (let i = 0; i < 15; i++) {
+                    await new Promise(r => setTimeout(r, 1000));
+                    if (await isOllamaRunning())
+                        break;
+                }
+                if (!(await isOllamaRunning())) {
+                    ctx.setWizardPullError("Could not start Ollama server. Run 'ollama serve' manually, then press Enter.");
+                    return;
+                }
+            }
+            await pullModel(selected.ollamaId, (p) => {
+                ctx.setWizardPullProgress(p);
+            });
+            ctx.setWizardPullProgress({ status: "success", percent: 100 });
+            await new Promise(r => setTimeout(r, 500));
+            ctx.setWizardScreen(null);
+            ctx.setWizardPullProgress(null);
+            ctx.setWizardSelectedModel(null);
+            ctx.addMsg("info", `✅ ${selected.name} installed! Connecting...`);
+            await ctx.connectToProvider(true);
+        }
+        catch (err) {
+            ctx.setWizardPullError(err.message);
+        }
+    })();
+}

package/dist/utils/anthropic-oauth.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Anthropic OAuth PKCE flow
+ *
+ * Lets users log in with their Claude Pro/Max subscription (no API key needed).
+ * Uses the same OAuth flow as Claude Code CLI.
+ */
+import { type AuthCredential } from "./auth.js";
+export declare function refreshAnthropicOAuthToken(refreshToken: string): Promise<{
+    access: string;
+    refresh: string;
+    expires: number;
+}>;
+export declare function loginAnthropicOAuth(onStatus?: (msg: string) => void): Promise<AuthCredential>;

package/dist/utils/anthropic-oauth.js

@@ -0,0 +1,171 @@
+/**
+ * Anthropic OAuth PKCE flow
+ *
+ * Lets users log in with their Claude Pro/Max subscription (no API key needed).
+ * Uses the same OAuth flow as Claude Code CLI.
+ */
+import { createServer } from "http";
+import { randomBytes, createHash } from "crypto";
+import { exec } from "child_process";
+import { saveCredential } from "./auth.js";
+// ── Constants ──
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CALLBACK_HOST = "127.0.0.1";
+const CALLBACK_PORT = 53692;
+const CALLBACK_PATH = "/callback";
+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+// ── PKCE helpers ──
+function base64url(buf) {
+    return buf
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=/g, "");
+}
+function generatePKCE() {
+    const verifier = base64url(randomBytes(32));
+    const challenge = base64url(createHash("sha256").update(verifier).digest());
+    return { verifier, challenge };
+}
+// ── Browser opener ──
+function openBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? `open "${url}"`
+        : process.platform === "win32"
+            ? `start "" "${url}"`
+            : `xdg-open "${url}"`;
+    exec(cmd);
+}
+// ── Token refresh ──
+export async function refreshAnthropicOAuthToken(refreshToken) {
+    const res = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            grant_type: "refresh_token",
+            client_id: CLIENT_ID,
+            refresh_token: refreshToken,
+            scope: SCOPES,
+        }),
+    });
+    if (!res.ok) {
+        const errText = await res.text();
+        throw new Error(`Token refresh failed (${res.status}): ${errText}`);
+    }
+    const data = (await res.json());
+    return {
+        access: data.access_token,
+        refresh: data.refresh_token ?? refreshToken,
+        expires: Date.now() + data.expires_in * 1000,
+    };
+}
+// ── Main OAuth login flow ──
+export async function loginAnthropicOAuth(onStatus) {
+    const { verifier, challenge } = generatePKCE();
+    return new Promise((resolve, reject) => {
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url ?? "/", "http://localhost");
+            if (url.pathname !== CALLBACK_PATH) {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const returnedState = url.searchParams.get("state");
+            if (!code) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end("<h1>Error: No authorization code received</h1><p>Please try again.</p>");
+                server.close();
+                reject(new Error("No authorization code received"));
+                return;
+            }
+            // state should match verifier
+            if (returnedState !== verifier) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end("<h1>Error: State mismatch</h1><p>Please try again.</p>");
+                server.close();
+                reject(new Error("OAuth state mismatch"));
+                return;
+            }
+            onStatus?.("Exchanging code for tokens...");
+            try {
+                const tokenRes = await fetch(TOKEN_URL, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        grant_type: "authorization_code",
+                        client_id: CLIENT_ID,
+                        code,
+                        state: verifier,
+                        redirect_uri: REDIRECT_URI,
+                        code_verifier: verifier,
+                    }),
+                });
+                if (!tokenRes.ok) {
+                    const errText = await tokenRes.text();
+                    throw new Error(`Token exchange failed (${tokenRes.status}): ${errText}`);
+                }
+                const tokenData = (await tokenRes.json());
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("<html><body style=\"font-family:monospace;background:#1a1a2e;color:#0ff;display:flex;justify-content:center;align-items:center;height:100vh;margin:0\"><div style=\"text-align:center\"><h1>Authenticated!</h1><p>You can close this tab and return to Codemaxxing.</p></div></body></html>");
+                server.close();
+                const expiresAt = Date.now() + tokenData.expires_in * 1000;
+                const cred = {
+                    provider: "anthropic",
+                    method: "oauth",
+                    apiKey: tokenData.access_token,
+                    baseUrl: "https://api.anthropic.com",
+                    label: "Anthropic (Claude Pro/Max)",
+                    refreshToken: tokenData.refresh_token,
+                    oauthExpires: expiresAt,
+                    createdAt: new Date().toISOString(),
+                };
+                saveCredential(cred);
+                resolve(cred);
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "text/html" });
+                res.end(`<h1>Error</h1><p>${err.message}</p>`);
+                server.close();
+                reject(err);
+            }
+        });
+        server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+            const params = new URLSearchParams({
+                code: "true",
+                client_id: CLIENT_ID,
+                response_type: "code",
+                redirect_uri: REDIRECT_URI,
+                scope: SCOPES,
+                code_challenge: challenge,
+                code_challenge_method: "S256",
+                state: verifier,
+            });
+            const authUrl = `${AUTHORIZE_URL}?${params.toString()}`;
+            onStatus?.("Opening browser for Claude login...");
+            try {
+                openBrowser(authUrl);
+            }
+            catch {
+                onStatus?.(`Could not open browser. Please visit:\n${authUrl}`);
+            }
+            onStatus?.("Waiting for authorization...");
+            // Timeout after 120 seconds
+            setTimeout(() => {
+                server.close();
+                reject(new Error("OAuth timed out after 120 seconds"));
+            }, 120 * 1000);
+        });
+        server.on("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                reject(new Error(`Port ${CALLBACK_PORT} is already in use. Close other auth flows and try again.`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}

package/dist/utils/auth.d.ts

@@ -18,6 +18,8 @@ export interface AuthCredential {
     baseUrl: string;
     label?: string;
     expiresAt?: string;
+    refreshToken?: string;
+    oauthExpires?: number;
     createdAt: string;
 }
 export interface ProviderDef {

package/dist/utils/auth.js

@@ -17,6 +17,7 @@ import { join } from "path";
 import { createServer } from "http";
 import { randomBytes, createHash } from "crypto";
 import { execSync, exec } from "child_process";
+import { detectOpenAICodexOAuth } from "./openai-oauth.js";
 // ── Paths ──
 const CONFIG_DIR = join(homedir(), ".codemaxxing");
 const AUTH_FILE = join(CONFIG_DIR, "auth.json");
@@ -32,15 +33,15 @@ export const PROVIDERS = [
     {
         id: "anthropic",
         name: "Anthropic (Claude)",
-        methods: ["setup-token", "api-key"],
-        baseUrl: "https://api.anthropic.com/v1",
+        methods: ["oauth", "api-key"],
+        baseUrl: "https://api.anthropic.com",
         consoleUrl: "https://console.anthropic.com/settings/keys",
         description: "Claude Opus, Sonnet, Haiku — use your subscription or API key",
     },
     {
         id: "openai",
         name: "OpenAI (ChatGPT)",
-        methods: ["cached-token", "api-key"],
+        methods: ["oauth", "api-key"],
         baseUrl: "https://api.openai.com/v1",
         consoleUrl: "https://platform.openai.com/api-keys",
         description: "GPT-4o, GPT-5, o1 — use your ChatGPT subscription or API key",
@@ -291,6 +292,16 @@ export async function anthropicSetupToken(onStatus) {
 }
 // ── OpenAI / Codex CLI Cached Token ──
 export function detectCodexToken() {
+    // Check OpenClaw auth-profiles first (for Codex OAuth tokens)
+    try {
+        const oauthCreds = detectOpenAICodexOAuth();
+        if (oauthCreds?.access) {
+            return oauthCreds.access;
+        }
+    }
+    catch {
+        // detection failed, fall through
+    }
     // Codex CLI stores OAuth tokens — check common locations
     const locations = [
         join(homedir(), ".codex", "auth.json"),
@@ -314,6 +325,28 @@ export function detectCodexToken() {
             }
         }
     }
+    // Codex CLI v0.18+ stores tokens in macOS Keychain
+    if (process.platform === "darwin") {
+        const keychainQueries = [
+            ["security", "find-generic-password", "-s", "codex", "-w"],
+            ["security", "find-generic-password", "-a", "openai", "-s", "codex", "-w"],
+            ["security", "find-generic-password", "-s", "openai-codex", "-w"],
+            ["security", "find-generic-password", "-l", "codex", "-w"],
+        ];
+        for (const args of keychainQueries) {
+            try {
+                const token = execSync(args.join(" "), { stdio: "pipe", timeout: 3000 }).toString().trim();
+                if (token)
+                    return token;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    // Final fallback: environment variable
+    if (process.env.OPENAI_API_KEY)
+        return process.env.OPENAI_API_KEY;
     return null;
 }
 export function importCodexToken(onStatus) {
@@ -467,6 +500,12 @@ export function detectAvailableAuth() {
             description: "Claude Code CLI detected — can link your Anthropic subscription",
         });
     }
+    // OpenAI: always offer OAuth login, and note if cached tokens exist
+    available.push({
+        provider: "openai",
+        method: "oauth",
+        description: "Log in with your ChatGPT subscription (browser OAuth)",
+    });
     if (detectCodexToken()) {
         available.push({
             provider: "openai",

package/dist/utils/ollama.js

@@ -25,6 +25,11 @@ export function isOllamaInstalled() {
         if (getWindowsOllamaPaths().some(p => existsSync(p)))
             return true;
     }
+    // Check known install paths on macOS
+    if (process.platform === "darwin") {
+        if (existsSync("/usr/local/bin/ollama") || existsSync("/opt/homebrew/bin/ollama"))
+            return true;
+    }
     // Check if the server is responding (if server is running, Ollama is definitely installed)
     try {
         execSync("curl -s http://localhost:11434/api/tags", {
@@ -64,7 +69,7 @@ export async function isOllamaRunning() {
 /** Get the install command for the user's OS */
 export function getOllamaInstallCommand(os) {
     switch (os) {
-        case "macos": return "brew install ollama";
+        case "macos": return "curl -fsSL https://ollama.com/install.sh | sh";
         case "linux": return "curl -fsSL https://ollama.com/install.sh | sh";
         case "windows": return "winget install Ollama.Ollama";
     }

package/dist/utils/openai-oauth.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OpenAI Codex OAuth PKCE flow
+ *
+ * Lets users log in with their ChatGPT Plus/Pro subscription (no API key needed).
+ * Uses the same OAuth flow as OpenAI's Codex CLI.
+ */
+import { type AuthCredential } from "./auth.js";
+export declare function detectOpenAICodexOAuth(): {
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId: string;
+} | null;
+export declare function refreshOpenAICodexToken(refreshToken: string): Promise<{
+    access: string;
+    refresh: string;
+    expires: number;
+}>;
+export declare function loginOpenAICodexOAuth(onStatus?: (msg: string) => void): Promise<AuthCredential>;