archbyte 0.3.5 → 0.4.0

package/dist/cli/auth.js

@@ -4,6 +4,7 @@ import * as http from "http";
 import { spawn } from "child_process";
 import chalk from "chalk";
 import { CONFIG_DIR, CREDENTIALS_PATH, API_BASE, CLI_CALLBACK_PORT, OAUTH_TIMEOUT_MS, } from "./constants.js";
+import { confirm, select, textInput } from "./ui.js";
 export async function handleLogin(provider) {
     console.log();
     console.log(chalk.bold.cyan("ArchByte Login"));
@@ -32,10 +33,39 @@ export async function handleLogin(provider) {
             // Offline — use cached tier
         }
         console.log(chalk.green(`Already logged in as ${chalk.bold(existing.email)} (${existing.tier} tier)`));
-        console.log(chalk.gray("Run `archbyte logout` to sign out."));
+        console.log();
+        const addAnother = await confirm("Add a different account?");
+        if (!addAnother) {
+            console.log(chalk.gray("Run `archbyte logout` to sign out."));
+            return;
+        }
+        console.log();
+    }
+    // Pick provider: use explicit flag, or show interactive picker
+    let selectedProvider = provider ?? "github";
+    if (!provider) {
+        const providers = ["GitHub", "Google", "Email & Password"];
+        const idx = await select("Sign in with:", providers);
+        selectedProvider = ["github", "google", "email"][idx];
+        console.log();
+    }
+    // Email/password flow — direct API call, no browser
+    if (selectedProvider === "email") {
+        try {
+            const credentials = await emailPasswordFlow();
+            saveCredentials(credentials);
+            cacheVerifiedTier(credentials.tier === "premium" ? "premium" : "free", credentials.email);
+            console.log();
+            console.log(chalk.green(`Logged in as ${chalk.bold(credentials.email)} (${credentials.tier} tier)`));
+            console.log(chalk.gray(`Credentials saved to ${CREDENTIALS_PATH}`));
+        }
+        catch (err) {
+            console.error(chalk.red(`Login failed: ${err instanceof Error ? err.message : "Unknown error"}`));
+            process.exit(1);
+        }
         return;
     }
-    const selectedProvider = provider ?? "github";
+    // OAuth flow (GitHub / Google)
     console.log(chalk.gray(`Opening browser for ${selectedProvider} sign-in...`));
     console.log();
     try {
@@ -92,26 +122,57 @@ export async function handleLoginWithToken(token) {
     }
 }
 // === Logout ===
-export async function handleLogout() {
+export async function handleLogout(options) {
     console.log();
-    const creds = loadCredentials();
-    if (!creds) {
+    const store = loadStore();
+    if (!store) {
         console.log(chalk.gray("Not logged in."));
         return;
     }
-    try {
-        fs.unlinkSync(CREDENTIALS_PATH);
+    const emails = Object.keys(store.accounts);
+    // Logout all accounts
+    if (options?.all) {
+        try {
+            fs.unlinkSync(CREDENTIALS_PATH);
+        }
+        catch { /* Ignore */ }
+        try {
+            fs.unlinkSync(TIER_CACHE_PATH);
+        }
+        catch { /* Ignore */ }
+        resetOfflineActions();
+        console.log(chalk.green(`Logged out of ${emails.length} account${emails.length === 1 ? "" : "s"}.`));
+        return;
     }
-    catch {
-        // Ignore
+    // Determine which account to remove
+    const targetEmail = options?.email ?? store.active;
+    if (!store.accounts[targetEmail]) {
+        console.log(chalk.yellow(`No account found for ${targetEmail}.`));
+        return;
     }
-    // Clean up tier cache and offline action tracker
-    try {
-        fs.unlinkSync(TIER_CACHE_PATH);
+    delete store.accounts[targetEmail];
+    const remaining = Object.keys(store.accounts);
+    if (remaining.length === 0) {
+        // Last account — delete the file entirely
+        try {
+            fs.unlinkSync(CREDENTIALS_PATH);
+        }
+        catch { /* Ignore */ }
+        try {
+            fs.unlinkSync(TIER_CACHE_PATH);
+        }
+        catch { /* Ignore */ }
+        resetOfflineActions();
+    }
+    else {
+        // Auto-switch if we removed the active account
+        if (store.active === targetEmail) {
+            store.active = remaining[0];
+            console.log(chalk.gray(`Switched active account to ${store.active}`));
+        }
+        saveStore(store);
     }
-    catch { /* Ignore */ }
-    resetOfflineActions();
-    console.log(chalk.green(`Logged out (was ${creds.email}).`));
+    console.log(chalk.green(`Logged out (was ${targetEmail}).`));
 }
 // === Status ===
 export async function handleStatus() {
@@ -145,32 +206,105 @@ export async function handleStatus() {
     }
     console.log();
 }
+// === Accounts ===
+export async function handleAccounts() {
+    console.log();
+    console.log(chalk.bold.cyan("ArchByte Accounts"));
+    console.log();
+    const store = loadStore();
+    if (!store || Object.keys(store.accounts).length === 0) {
+        console.log(chalk.yellow("No accounts. Run `archbyte login` to sign in."));
+        return;
+    }
+    for (const [email, creds] of Object.entries(store.accounts)) {
+        const isActive = email === store.active;
+        const marker = isActive ? chalk.green("*") : " ";
+        const tier = creds.tier === "premium" ? chalk.green("Pro") : "Basic";
+        const expired = isExpired(creds) ? chalk.red(" (expired)") : "";
+        console.log(`  ${marker} ${chalk.bold(email)}  ${tier}${expired}`);
+    }
+    console.log();
+    console.log(chalk.gray("* = active account"));
+    console.log(chalk.gray("Switch: archbyte accounts switch [email]"));
+    console.log();
+}
+export async function handleAccountSwitch(email) {
+    console.log();
+    const store = loadStore();
+    if (!store || Object.keys(store.accounts).length === 0) {
+        console.log(chalk.yellow("No accounts. Run `archbyte login` to sign in."));
+        return;
+    }
+    const emails = Object.keys(store.accounts);
+    if (emails.length === 1) {
+        console.log(chalk.gray(`Only one account: ${emails[0]}`));
+        return;
+    }
+    let target = email;
+    if (!target) {
+        // Interactive selection
+        const idx = await select("Switch to account:", emails.map((e) => {
+            const active = e === store.active ? chalk.green(" (active)") : "";
+            const tier = store.accounts[e].tier === "premium" ? " Pro" : "";
+            return `${e}${tier}${active}`;
+        }));
+        target = emails[idx];
+    }
+    if (!store.accounts[target]) {
+        console.log(chalk.red(`Account not found: ${target}`));
+        console.log(chalk.gray(`Available: ${emails.join(", ")}`));
+        return;
+    }
+    if (store.active === target) {
+        console.log(chalk.gray(`Already active: ${target}`));
+        return;
+    }
+    store.active = target;
+    saveStore(store);
+    console.log(chalk.green(`Switched to ${chalk.bold(target)}`));
+}
 // === Credential Helpers (exported for license gate) ===
-export function loadCredentials() {
+function isMultiAccountStore(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        data.version === 2 &&
+        typeof data.active === "string" &&
+        typeof data.accounts === "object" &&
+        data.accounts !== null);
+}
+function loadStore() {
     try {
-        if (fs.existsSync(CREDENTIALS_PATH)) {
-            const data = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
-            // Validate structure — reject malformed credentials
-            if (typeof data?.token !== "string" ||
-                typeof data?.email !== "string" ||
-                typeof data?.tier !== "string" ||
-                typeof data?.expiresAt !== "string") {
-                return null;
-            }
-            return data;
+        if (!fs.existsSync(CREDENTIALS_PATH))
+            return null;
+        const raw = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+        // Already multi-account format
+        if (isMultiAccountStore(raw))
+            return raw;
+        // Auto-migrate old single-account format
+        if (typeof raw?.token === "string" &&
+            typeof raw?.email === "string" &&
+            typeof raw?.tier === "string" &&
+            typeof raw?.expiresAt === "string") {
+            const creds = raw;
+            const store = {
+                version: 2,
+                active: creds.email,
+                accounts: { [creds.email]: creds },
+            };
+            saveStore(store);
+            return store;
         }
+        return null;
     }
     catch {
-        // Ignore — corrupt file treated as no credentials
+        return null;
     }
-    return null;
 }
-function saveCredentials(creds) {
+function saveStore(store) {
     if (!fs.existsSync(CONFIG_DIR)) {
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
     }
-    fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
-    // Restrict permissions (owner-only read/write)
+    fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(store, null, 2), "utf-8");
     try {
         fs.chmodSync(CREDENTIALS_PATH, 0o600);
     }
@@ -178,6 +312,30 @@ function saveCredentials(creds) {
         // Windows doesn't support chmod
     }
 }
+export function loadCredentials() {
+    const store = loadStore();
+    if (!store)
+        return null;
+    const creds = store.accounts[store.active];
+    if (!creds ||
+        typeof creds.token !== "string" ||
+        typeof creds.email !== "string" ||
+        typeof creds.tier !== "string" ||
+        typeof creds.expiresAt !== "string") {
+        return null;
+    }
+    return creds;
+}
+function saveCredentials(creds) {
+    const store = loadStore() ?? {
+        version: 2,
+        active: creds.email,
+        accounts: {},
+    };
+    store.accounts[creds.email] = creds;
+    store.active = creds.email;
+    saveStore(store);
+}
 /**
  * Check if credentials are expired. Treats invalid/unparseable dates
  * as expired (fail-closed) to prevent corrupted files from bypassing
@@ -333,6 +491,58 @@ export function resetOfflineActions() {
         // Non-critical
     }
 }
+// === Email/Password Flow ===
+async function emailPasswordFlow() {
+    const email = await textInput("Email");
+    if (!email)
+        throw new Error("Email is required.");
+    const password = await textInput("Password", { mask: true });
+    if (!password)
+        throw new Error("Password is required.");
+    const res = await fetch(`${API_BASE}/api/v1/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+    });
+    if (res.status === 401) {
+        console.log();
+        console.log(chalk.yellow("No account found with those credentials."));
+        const shouldSignUp = await confirm("Create a new account?");
+        if (!shouldSignUp)
+            throw new Error("Login cancelled.");
+        return emailSignupFlow(email, password);
+    }
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "Unknown error" }));
+        throw new Error(body.error ?? `Login failed (${res.status})`);
+    }
+    return parseTokenResponse(await res.json());
+}
+async function emailSignupFlow(email, password) {
+    const name = await textInput("Name (optional)");
+    const res = await fetch(`${API_BASE}/api/v1/auth/signup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password, name: name || undefined }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "Unknown error" }));
+        throw new Error(body.error ?? `Signup failed (${res.status})`);
+    }
+    return parseTokenResponse(await res.json());
+}
+function parseTokenResponse(data) {
+    const { token, user } = data;
+    const payload = parseJWTPayload(token);
+    return {
+        token,
+        email: user.email,
+        tier: user.tier,
+        expiresAt: payload?.exp
+            ? new Date(payload.exp * 1000).toISOString()
+            : new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+    };
+}
 // === OAuth Flow ===
 function startOAuthFlow(provider = "github") {
     return new Promise((resolve, reject) => {

package/dist/cli/config.js

@@ -1,8 +1,9 @@
 import * as fs from "fs";
+import { execSync } from "child_process";
 import chalk from "chalk";
 import { CONFIG_DIR, CONFIG_PATH } from "./constants.js";
 import { maskKey } from "./utils.js";
-const VALID_PROVIDERS = ["anthropic", "openai", "google"];
+const VALID_PROVIDERS = ["anthropic", "openai", "google", "claude-sdk"];
 export async function handleConfig(options) {
     const [action, key, value] = options.args;
     if (!action || action === "show") {
@@ -74,7 +75,8 @@ function showConfig() {
         console.log(chalk.gray("  archbyte init"));
         return;
     }
-    console.log(`  ${chalk.bold("provider")}: ${config.provider ?? chalk.gray("not set")}`);
+    const providerDisplay = config.provider === "claude-sdk" ? "Claude Code (SDK)" : config.provider;
+    console.log(`  ${chalk.bold("provider")}: ${providerDisplay ?? chalk.gray("not set")}`);
     // Show profiles
     if (configured.length > 0) {
         console.log();
@@ -108,8 +110,10 @@ function setConfig(key, value) {
                 process.exit(1);
             }
             config.provider = value;
-            // Check if this provider has a stored profile
-            if (profiles[value]?.apiKey) {
+            if (value === "claude-sdk") {
+                console.log(chalk.green("Switched to Claude Code (SDK) — no API key needed."));
+            }
+            else if (profiles[value]?.apiKey) {
                 console.log(chalk.green(`Switched to ${value} (credentials on file)`));
             }
             else {
@@ -203,8 +207,20 @@ export function resolveConfig() {
     const profile = provider ? profiles[provider] : undefined;
     const apiKey = process.env.ARCHBYTE_API_KEY ?? profile?.apiKey ?? config.apiKey;
     const model = process.env.ARCHBYTE_MODEL ?? profile?.model ?? config.model;
-    // Auto-detect from known env vars if nothing explicit
+    // claude-sdk provider doesn't need an API key
+    if (provider === "claude-sdk") {
+        return {
+            provider,
+            model: model,
+        };
+    }
+    // Auto-detect if nothing explicitly configured
     if (!provider && !apiKey) {
+        // Claude Code on PATH → zero-config, preferred
+        if (isClaudeCodeOnPath()) {
+            return { provider: "claude-sdk" };
+        }
+        // Fall back to API key env vars
         if (process.env.ANTHROPIC_API_KEY) {
             return { provider: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY };
         }
@@ -227,3 +243,13 @@ export function resolveConfig() {
         model: model,
     };
 }
+function isClaudeCodeOnPath() {
+    try {
+        const cmd = process.platform === "win32" ? "where claude" : "which claude";
+        execSync(cmd, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/export.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { fileURLToPath } from "url";
 import { resolveArchitecturePath, loadArchitectureFile } from "./shared.js";
 /**
  * Export architecture diagram to Mermaid, Markdown, or JSON format.
@@ -7,11 +8,24 @@ export async function handleExport(options) {
     const diagramPath = resolveArchitecturePath(options);
     const arch = loadArchitectureFile(diagramPath);
     const format = options.format || "mermaid";
-    const SUPPORTED_FORMATS = ["mermaid", "markdown", "json", "plantuml", "dot"];
+    const SUPPORTED_FORMATS = ["mermaid", "markdown", "json", "plantuml", "dot", "html"];
     if (!SUPPORTED_FORMATS.includes(format)) {
-        console.error(chalk.red(`Unknown format: "${format}". Supported: ${SUPPORTED_FORMATS.join(", ")}`));
+        const formatList = SUPPORTED_FORMATS.map(f => f === "html" ? `html ${chalk.yellow("[Pro]")}` : f).join(", ");
+        console.error(chalk.red(`Unknown format: "${format}". Supported: ${formatList}`));
         process.exit(1);
     }
+    // HTML export requires Pro tier (skip in dev/local builds)
+    if (format === "html" && !process.env.ARCHBYTE_DEV) {
+        const { loadCredentials } = await import("./auth.js");
+        const creds = loadCredentials();
+        if (!creds || creds.tier !== "premium") {
+            console.error();
+            console.error(chalk.red("HTML export requires a Pro subscription."));
+            console.error(chalk.gray("Upgrade at https://heartbyte.io/archbyte"));
+            console.error();
+            process.exit(1);
+        }
+    }
     let output;
     switch (format) {
         case "mermaid":
@@ -26,6 +40,9 @@ export async function handleExport(options) {
         case "dot":
             output = exportDot(arch);
             break;
+        case "html":
+            output = await exportHtml(arch);
+            break;
         default:
             output = exportMarkdown(arch);
             break;
@@ -306,6 +323,51 @@ function exportDot(arch) {
     lines.push("}");
     return lines.join("\n");
 }
+/**
+ * Export architecture as a self-contained interactive HTML file.
+ * Reads the pre-built UI assets from ui/dist/ and inlines them
+ * with the architecture data injected as window.__ARCHBYTE_DATA__.
+ */
+async function exportHtml(arch) {
+    const fs = await import("fs");
+    const pathMod = await import("path");
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = pathMod.dirname(__filename);
+    const uiDist = pathMod.resolve(__dirname, "../../ui/dist");
+    if (!fs.existsSync(uiDist)) {
+        console.error(chalk.red("UI build not found at " + uiDist));
+        console.error(chalk.gray("Run: npm run build:ui"));
+        process.exit(1);
+    }
+    // Read CSS and JS assets
+    const assetsDir = pathMod.join(uiDist, "assets");
+    const assetFiles = fs.readdirSync(assetsDir);
+    let cssContent = "";
+    for (const f of assetFiles.filter((f) => f.endsWith(".css"))) {
+        cssContent += fs.readFileSync(pathMod.join(assetsDir, f), "utf-8") + "\n";
+    }
+    let jsContent = "";
+    for (const f of assetFiles.filter((f) => f.endsWith(".js"))) {
+        jsContent += fs.readFileSync(pathMod.join(assetsDir, f), "utf-8") + "\n";
+    }
+    const projectName = process.cwd().split("/").pop() || "Architecture";
+    // Build HTML from scratch (avoids fragile regex on Vite template)
+    return `<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${projectName} - ArchByte Architecture</title>
+  <style>${cssContent}</style>
+</head>
+<body>
+  <script>try{if(localStorage.getItem('archbyte-theme')==='light')document.documentElement.setAttribute('data-theme','light')}catch(e){}</script>
+  <div id="root"></div>
+  <script>window.__ARCHBYTE_DATA__ = ${JSON.stringify(arch)};</script>
+  <script type="module">${jsContent}</script>
+</body>
+</html>`;
+}
 /**
  * Sanitize an ID for use in PlantUML diagrams.
  */

package/dist/cli/setup.js

@@ -15,6 +15,12 @@ const PROVIDERS = [
     { name: "google", label: "Google", hint: "Gemini 2.5 Pro / Flash" },
 ];
 const PROVIDER_MODELS = {
+    "claude-sdk": [
+        { id: "", label: "Default (recommended)", hint: "Sonnet for all agents" },
+        { id: "opus", label: "Claude Opus 4.6", hint: "Most capable" },
+        { id: "sonnet", label: "Claude Sonnet 4.5", hint: "Fast, great quality" },
+        { id: "haiku", label: "Claude Haiku 4.5", hint: "Fastest, cheapest" },
+    ],
     anthropic: [
         { id: "", label: "Default (recommended)", hint: "Opus for all agents" },
         { id: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable" },
@@ -209,12 +215,6 @@ export async function handleSetup() {
     const hasClaude = isInPath("claude");
     const codexDir = path.join(CONFIG_DIR, "../.codex");
     const hasCodex = fs.existsSync(codexDir);
-    if (hasClaude || hasCodex) {
-        const tools = [hasClaude && "Claude Code", hasCodex && "Codex CLI"].filter(Boolean).join(" and ");
-        console.log(chalk.cyan(`  Detected ${tools} on this machine.`));
-        console.log(chalk.white(`  After setup, run `) + chalk.bold.cyan(`archbyte mcp install`) + chalk.white(` to use ArchByte from your AI tool.`));
-        console.log();
-    }
     const config = loadConfig();
     const profiles = getProfiles(config);
     // Migrate legacy flat config → profiles
@@ -247,6 +247,79 @@ export async function handleSetup() {
         }
         console.log();
     }
+    // Detect AI coding tools and offer zero-config options
+    if (hasClaude || hasCodex) {
+        const tools = [hasClaude && "Claude Code", hasCodex && "Codex CLI"].filter(Boolean).join(" and ");
+        console.log(chalk.cyan(`  Detected ${tools} on this machine.\n`));
+        // Build options based on what's detected
+        const toolOptions = [];
+        if (hasClaude) {
+            toolOptions.push({
+                label: `Claude Code (SDK) ${chalk.gray("zero config — uses your Claude Code subscription")}`,
+                value: "claude-sdk",
+            });
+        }
+        if (hasCodex) {
+            toolOptions.push({
+                label: `Codex CLI ${chalk.gray("zero config — uses your Codex subscription")}`,
+                value: "codex",
+            });
+        }
+        toolOptions.push({
+            label: `Bring your own API key ${chalk.gray("Anthropic, OpenAI, or Google")}`,
+            value: "byok",
+        });
+        const toolIdx = await select("How do you want to run ArchByte?", toolOptions.map((o) => o.label));
+        const choice = toolOptions[toolIdx].value;
+        if (choice === "claude-sdk") {
+            config.provider = "claude-sdk";
+            // Model selection
+            const models = PROVIDER_MODELS["claude-sdk"];
+            const modelIdx = await select("\n  Choose a model:", models.map((m) => `${m.label} ${chalk.gray(m.hint)}`));
+            const chosenModel = models[modelIdx];
+            if (chosenModel.id) {
+                config.model = chosenModel.id;
+                console.log(chalk.green(`  ✓ Model: ${chosenModel.label}`));
+            }
+            else {
+                delete config.model;
+                console.log(chalk.green(`  ✓ Model: Sonnet (default)`));
+            }
+            config.profiles = profiles;
+            delete config.apiKey;
+            saveConfig(config);
+            const dim = chalk.gray;
+            const sep = dim("  ───");
+            console.log();
+            console.log(chalk.bold.green("  ✓ Setup complete — using Claude Code (SDK)"));
+            console.log();
+            console.log(sep);
+            console.log();
+            console.log(dim("  No API key needed. ArchByte uses your Claude Code subscription."));
+            console.log(dim("  All model calls go through Claude Code on this machine."));
+            console.log();
+            console.log(sep);
+            console.log();
+            console.log("  " + chalk.bold("Next steps"));
+            console.log();
+            console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
+            if (hasCodex) {
+                console.log("  " + chalk.cyan("archbyte mcp install") + "    Use from Codex CLI");
+            }
+            console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
+            console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");
+            console.log();
+            return;
+        }
+        if (choice === "codex") {
+            // TODO: Add Codex SDK provider when available
+            console.log(chalk.yellow("\n  Codex SDK provider coming soon. Setting up with API key for now."));
+            console.log(chalk.gray("  In the meantime, use archbyte mcp install to run ArchByte from Codex.\n"));
+        }
+        // User chose BYOK — continue to normal provider selection below
+        if (choice === "byok")
+            console.log();
+    }
     // Step 1: Choose provider
     const idx = await select("Choose your model provider:", PROVIDERS.map((p) => {
         const active = config.provider === p.name ? chalk.green(" (active)") : "";

package/dist/cli/ui.d.ts

@@ -30,4 +30,13 @@ export declare function progressBar(totalSteps: number): ProgressBar;
  * (arrow keys, etc.) to prevent accidental confirmation.
  */
 export declare function confirm(prompt: string): Promise<boolean>;
+/**
+ * Text input prompt. Returns the entered string.
+ * Non-TTY fallback: returns empty string.
+ *
+ * @param mask - If true, replaces each character with * (for passwords).
+ */
+export declare function textInput(prompt: string, opts?: {
+    mask?: boolean;
+}): Promise<string>;
 export {};