archbyte 0.3.5 → 0.4.1

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/patrol.d.ts

@@ -4,13 +4,15 @@ interface PatrolOptions {
     interval?: string;
     onViolation?: string;
     daemon?: boolean;
+    once?: boolean;
+    watch?: boolean;
     history?: boolean;
-    rescan?: boolean;
 }
 /**
  * Run the architecture patrol daemon.
- * Inspired by Gastown's patrol loop pattern — cyclic monitoring
- * that detects drift and reports violations.
+ * Each cycle: snapshot → analyze (incremental) → generate → validate → diff
+ *
+ * --once: run a single cycle then exit (used by UI "Run Now")
  */
 export declare function handlePatrol(options: PatrolOptions): Promise<void>;
 export {};