archbyte 0.1.0

package/dist/server/src/index.js

@@ -0,0 +1,1311 @@
+#!/usr/bin/env node
+import { watch } from "chokidar";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createServer } from "http";
+import { execSync, spawn, spawnSync } from "child_process";
+// Get UI assets path
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const UI_DIST = path.resolve(__dirname, "../../../ui/dist");
+// Global state
+let config;
+let sseClients = new Set();
+let diagramWatcher = null;
+let currentArchitecture = null;
+// Process tracking for run-from-UI
+const runningWorkflows = new Map();
+let patrolProcess = null;
+let patrolRunning = false;
+let chatProcess = null;
+// Resolve archbyte CLI binary path
+function getArchbyteBin() {
+    try {
+        return execSync("which archbyte", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch {
+        // Fallback: resolve relative to this package
+        return path.resolve(__dirname, "../../../cli/dist/index.js");
+    }
+}
+// Broadcast ops event to SSE clients
+function broadcastOpsEvent(event) {
+    const data = JSON.stringify(event);
+    for (const client of sseClients) {
+        client.write(`data: ${data}\n\n`);
+    }
+}
+// Load architecture from JSON file
+async function loadArchitecture() {
+    try {
+        if (!existsSync(config.diagramPath)) {
+            return null;
+        }
+        const content = await readFile(config.diagramPath, "utf-8");
+        const data = JSON.parse(content);
+        return data;
+    }
+    catch (error) {
+        console.error("[archbyte] Failed to load architecture:", error);
+        return null;
+    }
+}
+// Get git info
+function getGitInfo() {
+    try {
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+            cwd: config.workspaceRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const commit = execSync("git rev-parse --short HEAD", {
+            cwd: config.workspaceRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        let repo = null;
+        let remoteUrl = null;
+        try {
+            remoteUrl = execSync("git remote get-url origin", {
+                cwd: config.workspaceRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            // Extract repo name from URL (handles both https and ssh)
+            const match = remoteUrl.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+            repo = match ? match[1] : null;
+        }
+        catch {
+            // No remote configured
+        }
+        return { branch, commit, repo, remoteUrl };
+    }
+    catch {
+        return null;
+    }
+}
+// Broadcast update to SSE clients
+function broadcastUpdate() {
+    if (!currentArchitecture)
+        return;
+    const data = JSON.stringify({ type: "update", architecture: currentArchitecture });
+    for (const client of sseClients) {
+        client.write(`data: ${data}\n\n`);
+    }
+}
+// HTTP Server
+let httpServer;
+function createHttpServer() {
+    httpServer = createServer(async (req, res) => {
+        // Security headers — restrict to localhost origins only
+        const reqOrigin = req.headers.origin || "";
+        const allowedOrigin = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(reqOrigin) ? reqOrigin : `http://localhost:${config.port}`;
+        res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.setHeader("X-Frame-Options", "SAMEORIGIN");
+        if (req.method === "OPTIONS") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const url = req.url || "/";
+        // SSE endpoint
+        if (url === "/events") {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            currentArchitecture = await loadArchitecture();
+            if (currentArchitecture) {
+                res.write(`data: ${JSON.stringify({ type: "init", architecture: currentArchitecture })}\n\n`);
+            }
+            sseClients.add(res);
+            req.on("close", () => sseClients.delete(res));
+            return;
+        }
+        // API: Get architecture
+        if (url === "/api/architecture" && req.method === "GET") {
+            currentArchitecture = await loadArchitecture();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(currentArchitecture || { nodes: [], edges: [] }));
+            return;
+        }
+        // API: Health
+        if (url === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok", project: config.name }));
+            return;
+        }
+        // API: License — returns user's tier and feature access
+        if (url === "/api/license" && req.method === "GET") {
+            const license = loadLicenseInfo();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(license));
+            return;
+        }
+        // API: Git info (supports both /api/git and /api/tools-git for compatibility)
+        if (url === "/api/git" || url === "/api/tools-git") {
+            const info = getGitInfo();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(info || {}));
+            return;
+        }
+        // API: Stats
+        if (url === "/api/stats" && req.method === "GET") {
+            const arch = currentArchitecture || (await loadArchitecture());
+            if (!arch) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No architecture loaded" }));
+                return;
+            }
+            const realNodes = arch.nodes;
+            const n = realNodes.length;
+            const possibleConnections = n > 1 ? (n * (n - 1)) / 2 : 1;
+            const layerCounts = {};
+            for (const node of realNodes) {
+                layerCounts[node.layer] = (layerCounts[node.layer] || 0) + 1;
+            }
+            const connectedIds = new Set();
+            for (const edge of arch.edges) {
+                connectedIds.add(edge.source);
+                connectedIds.add(edge.target);
+            }
+            const orphans = realNodes.filter((nd) => !connectedIds.has(nd.id)).length;
+            const connectionCounts = new Map();
+            for (const edge of arch.edges) {
+                connectionCounts.set(edge.source, (connectionCounts.get(edge.source) || 0) + 1);
+                connectionCounts.set(edge.target, (connectionCounts.get(edge.target) || 0) + 1);
+            }
+            const hubs = realNodes.filter((nd) => (connectionCounts.get(nd.id) || 0) > 6);
+            // Read scan metadata from analysis.json
+            let scanMeta = {};
+            try {
+                const analysisPath = path.join(config.workspaceRoot, ".archbyte/analysis.json");
+                if (existsSync(analysisPath)) {
+                    const raw = JSON.parse(readFileSync(analysisPath, "utf-8"));
+                    scanMeta = raw.metadata || {};
+                }
+            }
+            catch { /* ignore */ }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                components: realNodes.filter((x) => x.type === "component" || x.type === "service").length,
+                databases: realNodes.filter((x) => x.type === "database").length,
+                externalServices: realNodes.filter((x) => x.type === "external").length,
+                totalConnections: arch.edges.length,
+                orphans,
+                hubs: hubs.length,
+                flows: arch.flows?.length || 0,
+                layerCounts,
+                lastUpdated: arch.lastUpdated,
+                durationMs: scanMeta.durationMs ?? null,
+                filesScanned: scanMeta.filesScanned ?? null,
+                analyzedAt: scanMeta.analyzedAt ?? null,
+                mode: scanMeta.mode ?? null,
+                tokenUsage: scanMeta.tokenUsage ?? null,
+            }));
+            return;
+        }
+        // API: Validate
+        if (url === "/api/validate" && req.method === "GET") {
+            const arch = currentArchitecture || (await loadArchitecture());
+            if (!arch) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No architecture loaded" }));
+                return;
+            }
+            const realNodes = arch.nodes;
+            const nodeMap = new Map();
+            for (const nd of realNodes)
+                nodeMap.set(nd.id, nd);
+            const violations = [];
+            // no-layer-bypass
+            const layerOrder = { presentation: 0, application: 1, data: 2 };
+            for (const edge of arch.edges) {
+                const src = nodeMap.get(edge.source);
+                const tgt = nodeMap.get(edge.target);
+                if (!src || !tgt)
+                    continue;
+                const srcO = layerOrder[src.layer];
+                const tgtO = layerOrder[tgt.layer];
+                if (srcO !== undefined && tgtO !== undefined && tgtO - srcO > 1) {
+                    violations.push({
+                        rule: "no-layer-bypass",
+                        level: "error",
+                        message: `"${src.label}" (${src.layer}) -> "${tgt.label}" (${tgt.layer})`,
+                        nodeIds: [src.id, tgt.id],
+                    });
+                }
+            }
+            // max-connections
+            const connectionCounts2 = new Map();
+            for (const edge of arch.edges) {
+                connectionCounts2.set(edge.source, (connectionCounts2.get(edge.source) || 0) + 1);
+                connectionCounts2.set(edge.target, (connectionCounts2.get(edge.target) || 0) + 1);
+            }
+            for (const nd of realNodes) {
+                const count = connectionCounts2.get(nd.id) || 0;
+                if (count > 6) {
+                    violations.push({
+                        rule: "max-connections",
+                        level: "warn",
+                        message: `"${nd.label}" has ${count} connections (threshold: 6)`,
+                        nodeIds: [nd.id],
+                    });
+                }
+            }
+            // no-orphans
+            const connected = new Set();
+            for (const edge of arch.edges) {
+                connected.add(edge.source);
+                connected.add(edge.target);
+            }
+            for (const nd of realNodes) {
+                if (!connected.has(nd.id)) {
+                    violations.push({
+                        rule: "no-orphans",
+                        level: "warn",
+                        message: `"${nd.label}" has no connections`,
+                        nodeIds: [nd.id],
+                    });
+                }
+            }
+            // no-circular-deps (simple cycle detection)
+            const adjacency = new Map();
+            for (const nd of realNodes)
+                adjacency.set(nd.id, []);
+            for (const edge of arch.edges) {
+                adjacency.get(edge.source)?.push(edge.target);
+            }
+            const visited = new Set();
+            const inStack = new Set();
+            const cyclePath = [];
+            const cycles = [];
+            function dfs(nodeId) {
+                visited.add(nodeId);
+                inStack.add(nodeId);
+                cyclePath.push(nodeId);
+                for (const neighbor of adjacency.get(nodeId) || []) {
+                    if (!visited.has(neighbor)) {
+                        dfs(neighbor);
+                    }
+                    else if (inStack.has(neighbor)) {
+                        const start = cyclePath.indexOf(neighbor);
+                        if (start !== -1)
+                            cycles.push([...cyclePath.slice(start), neighbor]);
+                    }
+                }
+                cyclePath.pop();
+                inStack.delete(nodeId);
+            }
+            for (const nd of realNodes) {
+                if (!visited.has(nd.id))
+                    dfs(nd.id);
+            }
+            for (const cycle of cycles) {
+                violations.push({
+                    rule: "no-circular-deps",
+                    level: "error",
+                    message: `Cycle: ${cycle.map((id) => nodeMap.get(id)?.label || id).join(" -> ")}`,
+                    nodeIds: cycle.filter((id, i, arr) => arr.indexOf(id) === i),
+                });
+            }
+            const errors = violations.filter((v) => v.level === "error").length;
+            const warnings = violations.filter((v) => v.level === "warn").length;
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                passed: errors === 0,
+                errors,
+                warnings,
+                violations,
+            }));
+            return;
+        }
+        // API: Export architecture as text format
+        if (url.startsWith("/api/export") && req.method === "GET") {
+            const arch = currentArchitecture || (await loadArchitecture());
+            if (!arch) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No architecture loaded" }));
+                return;
+            }
+            const params = new URL(url, `http://localhost:${config.port}`).searchParams;
+            const format = params.get("format") || "mermaid";
+            const supported = ["mermaid", "markdown", "json", "plantuml", "dot"];
+            if (!supported.includes(format)) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: `Unknown format: ${format}. Supported: ${supported.join(", ")}` }));
+                return;
+            }
+            const realNodes = arch.nodes;
+            const nodeMap = new Map();
+            for (const nd of realNodes)
+                nodeMap.set(nd.id, nd);
+            let content;
+            let contentType = "text/plain";
+            let ext = "txt";
+            switch (format) {
+                case "mermaid": {
+                    const layerGroups = new Map();
+                    for (const node of realNodes) {
+                        const layer = node.layer || "other";
+                        if (!layerGroups.has(layer))
+                            layerGroups.set(layer, []);
+                        layerGroups.get(layer).push(node);
+                    }
+                    const lines = ["graph TD"];
+                    for (const layer of ["presentation", "application", "data", "external", "deployment"]) {
+                        const nodes = layerGroups.get(layer);
+                        if (!nodes || nodes.length === 0)
+                            continue;
+                        lines.push(`  subgraph ${layer.charAt(0).toUpperCase() + layer.slice(1)}`);
+                        for (const node of nodes) {
+                            const id = node.id.replace(/[^a-zA-Z0-9_-]/g, "_");
+                            const shape = node.type === "database" ? `[("${node.label}")]` : `["${node.label}"]`;
+                            lines.push(`    ${id}${shape}`);
+                        }
+                        lines.push("  end");
+                    }
+                    for (const edge of arch.edges) {
+                        const src = edge.source.replace(/[^a-zA-Z0-9_-]/g, "_");
+                        const tgt = edge.target.replace(/[^a-zA-Z0-9_-]/g, "_");
+                        lines.push(edge.label ? `  ${src} -->|${edge.label}| ${tgt}` : `  ${src} --> ${tgt}`);
+                    }
+                    content = lines.join("\n");
+                    ext = "mmd";
+                    break;
+                }
+                case "plantuml": {
+                    const layerGroups = new Map();
+                    for (const node of realNodes) {
+                        const layer = node.layer || "other";
+                        if (!layerGroups.has(layer))
+                            layerGroups.set(layer, []);
+                        layerGroups.get(layer).push(node);
+                    }
+                    const lines = ["@startuml Architecture", "!theme plain", "skinparam componentStyle rectangle", ""];
+                    for (const layer of ["presentation", "application", "data", "external", "deployment"]) {
+                        const nodes = layerGroups.get(layer);
+                        if (!nodes || nodes.length === 0)
+                            continue;
+                        lines.push(`package "${layer.charAt(0).toUpperCase() + layer.slice(1)}" {`);
+                        for (const node of nodes) {
+                            const type = node.type === "database" ? "database" : "component";
+                            const id = node.id.replace(/[^a-zA-Z0-9_]/g, "_");
+                            lines.push(`  ${type} "${node.label.split("\\n")[0]}" as ${id}`);
+                        }
+                        lines.push("}", "");
+                    }
+                    for (const edge of arch.edges) {
+                        const src = edge.source.replace(/[^a-zA-Z0-9_]/g, "_");
+                        const tgt = edge.target.replace(/[^a-zA-Z0-9_]/g, "_");
+                        lines.push(`${src} --> ${tgt}${edge.label ? ` : ${edge.label}` : ""}`);
+                    }
+                    lines.push("", "@enduml");
+                    content = lines.join("\n");
+                    ext = "puml";
+                    break;
+                }
+                case "dot": {
+                    const layerFills = {
+                        presentation: "#d0ebff", application: "#ffe8cc", data: "#b2f2bb",
+                        external: "#eebefa", deployment: "#ffe3e3",
+                    };
+                    const layerGroups = new Map();
+                    for (const node of realNodes) {
+                        const l = node.layer || "other";
+                        if (!layerGroups.has(l))
+                            layerGroups.set(l, []);
+                        layerGroups.get(l).push(node);
+                    }
+                    const lines = ["digraph Architecture {", "  rankdir=TB;", '  node [shape=box, style="rounded,filled", fontname="Helvetica"];', ""];
+                    for (const layer of ["presentation", "application", "data", "external", "deployment"]) {
+                        const nodes = layerGroups.get(layer);
+                        if (!nodes || nodes.length === 0)
+                            continue;
+                        lines.push(`  subgraph cluster_${layer} {`);
+                        lines.push(`    label="${layer.charAt(0).toUpperCase() + layer.slice(1)}";`);
+                        lines.push(`    style=filled; color="${layerFills[layer] || "#f0f0f0"}";`);
+                        for (const node of nodes) {
+                            const shape = node.type === "database" ? "cylinder" : "box";
+                            lines.push(`    "${node.id}" [label="${node.label.split("\\n")[0]}", shape=${shape}, fillcolor="${layerFills[layer] || "#ffffff"}"];`);
+                        }
+                        lines.push("  }");
+                    }
+                    lines.push("");
+                    for (const edge of arch.edges) {
+                        lines.push(`  "${edge.source}" -> "${edge.target}"${edge.label ? ` [label="${edge.label}"]` : ""};`);
+                    }
+                    lines.push("}");
+                    content = lines.join("\n");
+                    ext = "dot";
+                    break;
+                }
+                case "json": {
+                    const components = realNodes.map((node) => {
+                        const clean = { id: node.id, type: node.type, label: node.label, layer: node.layer };
+                        if (node.environments?.length)
+                            clean.environments = node.environments;
+                        return clean;
+                    });
+                    const connections = arch.edges.map((edge) => {
+                        const clean = { id: edge.id, source: edge.source, target: edge.target };
+                        if (edge.label)
+                            clean.label = edge.label;
+                        if (edge.environments?.length)
+                            clean.environments = edge.environments;
+                        return clean;
+                    });
+                    const result = { components, connections };
+                    if (arch.flows?.length)
+                        result.flows = arch.flows;
+                    if (arch.environments)
+                        result.environments = arch.environments;
+                    result.metadata = { lastUpdated: arch.lastUpdated, version: arch.version };
+                    content = JSON.stringify(result, null, 2);
+                    contentType = "application/json";
+                    ext = "json";
+                    break;
+                }
+                default: { // markdown
+                    const lines = [`# Architecture — ${config.name}`, "", `> Generated by ArchByte on ${new Date().toISOString().slice(0, 10)}`, ""];
+                    lines.push("## Summary", "");
+                    lines.push(`- **Components:** ${realNodes.filter((n) => n.type === "component" || n.type === "service").length}`);
+                    lines.push(`- **Databases:** ${realNodes.filter((n) => n.type === "database").length}`);
+                    lines.push(`- **External Services:** ${realNodes.filter((n) => n.type === "external").length}`);
+                    lines.push(`- **Connections:** ${arch.edges.length}`, "");
+                    lines.push("## Components", "", "| Name | Type | Layer |", "|------|------|-------|");
+                    for (const node of realNodes)
+                        lines.push(`| ${node.label} | ${node.type} | ${node.layer} |`);
+                    lines.push("", "## Connections", "");
+                    for (const edge of arch.edges) {
+                        const src = nodeMap.get(edge.source)?.label || edge.source;
+                        const tgt = nodeMap.get(edge.target)?.label || edge.target;
+                        lines.push(`- **${src}** → **${tgt}**${edge.label ? ` — ${edge.label}` : ""}`);
+                    }
+                    content = lines.join("\n");
+                    ext = "md";
+                    break;
+                }
+            }
+            res.writeHead(200, {
+                "Content-Type": contentType,
+                "Content-Disposition": `attachment; filename="architecture.${ext}"`,
+            });
+            res.end(content);
+            return;
+        }
+        // API: Patrol history
+        if (url === "/api/patrol/latest" && req.method === "GET") {
+            const latestPath = path.join(config.workspaceRoot, ".archbyte/patrols/latest.json");
+            if (!existsSync(latestPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+                return;
+            }
+            try {
+                const content = readFileSync(latestPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+            }
+            return;
+        }
+        if (url === "/api/patrol/history" && req.method === "GET") {
+            const historyPath = path.join(config.workspaceRoot, ".archbyte/patrols/history.jsonl");
+            if (!existsSync(historyPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify([]));
+                return;
+            }
+            try {
+                const content = readFileSync(historyPath, "utf-8");
+                const records = content.trim().split("\n").filter(Boolean).slice(-50).map((line) => JSON.parse(line));
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(records));
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify([]));
+            }
+            return;
+        }
+        // API: Workflow list and status
+        if (url === "/api/workflow/list" && req.method === "GET") {
+            const workflows = [];
+            // Built-in workflows
+            const builtins = [
+                { id: "full-analysis", name: "Full Analysis Pipeline", description: "Complete architecture pipeline", steps: ["generate", "validate", "stats", "export"] },
+                { id: "ci-check", name: "CI Architecture Check", description: "Lightweight CI pipeline", steps: ["validate"] },
+                { id: "drift-check", name: "Architecture Drift Check", description: "Check for architecture drift", steps: ["snapshot", "generate", "diff"] },
+            ];
+            for (const b of builtins) {
+                let status = null;
+                const stPath = path.join(config.workspaceRoot, `.archbyte/workflows/.state/${b.id}.json`);
+                if (existsSync(stPath)) {
+                    try {
+                        status = JSON.parse(readFileSync(stPath, "utf-8")).status;
+                    }
+                    catch { }
+                }
+                workflows.push({ ...b, builtin: true, status });
+            }
+            // Custom workflows
+            const workflowDir = path.join(config.workspaceRoot, ".archbyte/workflows");
+            if (existsSync(workflowDir)) {
+                const { readdirSync } = await import("fs");
+                const files = readdirSync(workflowDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+                for (const file of files) {
+                    try {
+                        const content = readFileSync(path.join(workflowDir, file), "utf-8");
+                        const idMatch = content.match(/^id:\s*(.+)$/m);
+                        const nameMatch = content.match(/^name:\s*"?([^"\n]+)"?$/m);
+                        const descMatch = content.match(/^description:\s*"?([^"\n]+)"?$/m);
+                        if (idMatch) {
+                            const id = idMatch[1].trim();
+                            if (builtins.some((b) => b.id === id))
+                                continue;
+                            let status = null;
+                            const stPath = path.join(config.workspaceRoot, `.archbyte/workflows/.state/${id}.json`);
+                            if (existsSync(stPath)) {
+                                try {
+                                    status = JSON.parse(readFileSync(stPath, "utf-8")).status;
+                                }
+                                catch { }
+                            }
+                            workflows.push({
+                                id,
+                                name: nameMatch?.[1]?.trim() || id,
+                                description: descMatch?.[1]?.trim() || "",
+                                steps: [],
+                                builtin: false,
+                                status,
+                            });
+                        }
+                    }
+                    catch { }
+                }
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(workflows));
+            return;
+        }
+        if (url.startsWith("/api/workflow/status/") && req.method === "GET") {
+            const id = url.split("/").pop();
+            // Validate ID to prevent path traversal (alphanumeric, hyphens, underscores only)
+            if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid workflow ID" }));
+                return;
+            }
+            const stPath = path.join(config.workspaceRoot, `.archbyte/workflows/.state/${id}.json`);
+            if (!existsSync(stPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+                return;
+            }
+            try {
+                const content = readFileSync(stPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+            }
+            return;
+        }
+        // API: Open file in VS Code
+        if (url === "/api/open-file" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { path: filePath } = JSON.parse(body);
+                    if (!filePath) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Path required" }));
+                        return;
+                    }
+                    const fullPath = path.resolve(config.workspaceRoot, filePath);
+                    // Validate path stays within workspace to prevent traversal
+                    if (!fullPath.startsWith(path.resolve(config.workspaceRoot))) {
+                        res.writeHead(403, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Path outside workspace" }));
+                        return;
+                    }
+                    if (existsSync(fullPath) && statSync(fullPath).isFile()) {
+                        // Open file in existing VS Code window (no shell — prevents injection)
+                        spawnSync("code", ["-r", "-g", fullPath], { stdio: "ignore" });
+                    }
+                    else if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
+                        spawnSync("code", ["-r", fullPath], { stdio: "ignore" });
+                    }
+                    else {
+                        spawnSync("code", ["-r", config.workspaceRoot], { stdio: "ignore" });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ success: true, path: fullPath }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
+        // API: Update positions from UI
+        if (url === "/api/update-positions" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { updates } = JSON.parse(body);
+                    const content = existsSync(config.diagramPath)
+                        ? await readFile(config.diagramPath, "utf-8")
+                        : '{"nodes":[],"edges":[],"flows":[],"lastUpdated":"","version":1}';
+                    const architecture = JSON.parse(content);
+                    for (const update of updates || []) {
+                        const node = architecture.nodes?.find((n) => n.id === update.id);
+                        if (node) {
+                            node.x = update.x;
+                            node.y = update.y;
+                            if (update.width)
+                                node.width = update.width;
+                            if (update.height)
+                                node.height = update.height;
+                        }
+                    }
+                    // Update timestamp
+                    architecture.lastUpdated = new Date().toISOString();
+                    const dir = path.dirname(config.diagramPath);
+                    if (!existsSync(dir)) {
+                        await mkdir(dir, { recursive: true });
+                    }
+                    await writeFile(config.diagramPath, JSON.stringify(architecture, null, 2));
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ success: true, updated: updates?.length || 0 }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
+        // API: Run generate
+        if (url === "/api/generate" && req.method === "POST") {
+            if (runningWorkflows.has("__generate__")) {
+                res.writeHead(409, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Generate already running" }));
+                return;
+            }
+            const bin = getArchbyteBin();
+            const child = spawn(process.execPath, [bin, "generate"], {
+                cwd: config.workspaceRoot,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: { ...process.env, FORCE_COLOR: "0" },
+            });
+            runningWorkflows.set("__generate__", child);
+            broadcastOpsEvent({ type: "generate:started" });
+            child.on("close", (code) => {
+                runningWorkflows.delete("__generate__");
+                broadcastOpsEvent({ type: "generate:finished", code });
+            });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+        // API: Generate status
+        if (url === "/api/generate/status" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ running: runningWorkflows.has("__generate__") }));
+            return;
+        }
+        // API: Run workflow
+        if (url.startsWith("/api/workflow/run/") && req.method === "POST") {
+            const id = url.split("/").pop();
+            // Validate ID to prevent injection into spawn args
+            if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid workflow ID" }));
+                return;
+            }
+            if (runningWorkflows.has(id)) {
+                res.writeHead(409, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Workflow already running", id }));
+                return;
+            }
+            const bin = getArchbyteBin();
+            const child = spawn(process.execPath, [bin, "workflow", "--run", id], {
+                cwd: config.workspaceRoot,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: { ...process.env, FORCE_COLOR: "0" },
+            });
+            runningWorkflows.set(id, child);
+            broadcastOpsEvent({ type: "workflow:started", id });
+            child.on("close", (code) => {
+                runningWorkflows.delete(id);
+                broadcastOpsEvent({ type: "workflow:finished", id, code });
+            });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true, id }));
+            return;
+        }
+        // API: Reset workflow state
+        if (url === "/api/workflow/reset" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { id } = JSON.parse(body || "{}");
+                    const stateDir = path.join(config.workspaceRoot, ".archbyte/workflows/.state");
+                    if (id) {
+                        // Validate ID to prevent path traversal
+                        if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+                            res.writeHead(400, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({ error: "Invalid workflow ID" }));
+                            return;
+                        }
+                        const stPath = path.join(stateDir, `${id}.json`);
+                        if (existsSync(stPath)) {
+                            const { unlinkSync } = await import("fs");
+                            unlinkSync(stPath);
+                        }
+                    }
+                    else {
+                        // Reset all
+                        if (existsSync(stateDir)) {
+                            const { readdirSync, unlinkSync } = await import("fs");
+                            for (const f of readdirSync(stateDir)) {
+                                if (f.endsWith(".json"))
+                                    unlinkSync(path.join(stateDir, f));
+                            }
+                        }
+                    }
+                    broadcastOpsEvent({ type: "workflow:reset", id: id || "all" });
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
+        // API: Start patrol
+        if (url === "/api/patrol/start" && req.method === "POST") {
+            if (patrolRunning) {
+                res.writeHead(409, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Patrol already running" }));
+                return;
+            }
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", () => {
+                const { interval } = JSON.parse(body || "{}");
+                const bin = getArchbyteBin();
+                const args = [bin, "patrol", "--watch"];
+                if (interval)
+                    args.push("--interval", String(interval));
+                patrolProcess = spawn(process.execPath, args, {
+                    cwd: config.workspaceRoot,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    env: { ...process.env, FORCE_COLOR: "0" },
+                });
+                patrolRunning = true;
+                broadcastOpsEvent({ type: "patrol:started" });
+                patrolProcess.on("close", () => {
+                    patrolProcess = null;
+                    patrolRunning = false;
+                    broadcastOpsEvent({ type: "patrol:stopped" });
+                });
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ ok: true }));
+            });
+            return;
+        }
+        // API: Stop patrol
+        if (url === "/api/patrol/stop" && req.method === "POST") {
+            if (patrolProcess) {
+                patrolProcess.kill("SIGTERM");
+                patrolProcess = null;
+                patrolRunning = false;
+                broadcastOpsEvent({ type: "patrol:stopped" });
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+        // API: Patrol running status
+        if (url === "/api/patrol/running" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ running: patrolRunning }));
+            return;
+        }
+        // API: Config — read project config (including provider settings)
+        if (url === "/api/config" && req.method === "GET") {
+            const configPath = path.join(config.workspaceRoot, ".archbyte/config.json");
+            if (!existsSync(configPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({}));
+                return;
+            }
+            try {
+                const content = readFileSync(configPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({}));
+            }
+            return;
+        }
+        // API: Config — save project config (provider, API key, etc.)
+        if (url === "/api/config" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const data = JSON.parse(body);
+                    const configDir = path.join(config.workspaceRoot, ".archbyte");
+                    if (!existsSync(configDir))
+                        await mkdir(configDir, { recursive: true });
+                    const configPath = path.join(configDir, "config.json");
+                    // Merge with existing config if present
+                    let existing = {};
+                    if (existsSync(configPath)) {
+                        try {
+                            existing = JSON.parse(readFileSync(configPath, "utf-8"));
+                        }
+                        catch { }
+                    }
+                    const merged = { ...existing, ...data };
+                    await writeFile(configPath, JSON.stringify(merged, null, 2));
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, config: merged }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
+        // API: Premium agent results
+        if (url === "/api/premium-agents/results" && req.method === "GET") {
+            const premiumPath = path.join(config.workspaceRoot, ".archbyte/premium-results.json");
+            if (!existsSync(premiumPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify([]));
+                return;
+            }
+            try {
+                const content = readFileSync(premiumPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify([]));
+            }
+            return;
+        }
+        // API: Project info from analysis.json
+        if (url === "/api/project" && req.method === "GET") {
+            const analysisPath = path.join(config.workspaceRoot, ".archbyte/analysis.json");
+            if (!existsSync(analysisPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+                return;
+            }
+            try {
+                const content = readFileSync(analysisPath, "utf-8");
+                const analysis = JSON.parse(content);
+                const project = analysis.project || {};
+                const gitInfo = getGitInfo();
+                const remoteUrl = gitInfo?.remoteUrl || null;
+                const repoUrl = remoteUrl
+                    ? remoteUrl.replace(/^git@([^:]+):/, "https://$1/").replace(/\.git$/, "")
+                    : null;
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    name: project.name || config.name,
+                    description: project.description || null,
+                    primaryLanguage: project.primaryLanguage || null,
+                    isMonorepo: project.isMonorepo || false,
+                    components: (analysis.components || []).length,
+                    databases: (analysis.databases || []).length,
+                    externalServices: (analysis.externalServices || []).length,
+                    connections: (analysis.connections || []).length,
+                    flows: (analysis.flows || []).length,
+                    repoUrl,
+                    workspacePath: config.workspaceRoot,
+                }));
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ name: config.name }));
+            }
+            return;
+        }
+        // API: Analysis status — last analyze result (success/error)
+        if (url === "/api/analysis-status" && req.method === "GET") {
+            const statusPath = path.join(config.workspaceRoot, ".archbyte/analysis-status.json");
+            if (!existsSync(statusPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+                return;
+            }
+            try {
+                const content = readFileSync(statusPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+            }
+            return;
+        }
+        // API: Telemetry — read agent timing data from analysis runs
+        if (url === "/api/telemetry" && req.method === "GET") {
+            const telPath = path.join(config.workspaceRoot, ".archbyte/telemetry.json");
+            if (!existsSync(telPath)) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+                return;
+            }
+            try {
+                const content = readFileSync(telPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(null));
+            }
+            return;
+        }
+        // API: Telemetry — record agent timing data
+        if (url === "/api/telemetry" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const data = JSON.parse(body);
+                    const telDir = path.join(config.workspaceRoot, ".archbyte");
+                    if (!existsSync(telDir))
+                        await mkdir(telDir, { recursive: true });
+                    await writeFile(path.join(telDir, "telemetry.json"), JSON.stringify(data, null, 2));
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
+        // API: Chat with architecture assistant
+        if (url === "/api/chat" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { message, history } = JSON.parse(body || "{}");
+                    if (!message) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Message required" }));
+                        return;
+                    }
+                    const arch = currentArchitecture || (await loadArchitecture());
+                    if (!arch) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "No architecture loaded. Run 'archbyte generate' first." }));
+                        return;
+                    }
+                    // Build compact architecture summary
+                    const nodeMap = new Map();
+                    for (const nd of arch.nodes)
+                        nodeMap.set(nd.id, nd);
+                    const layerGroups = new Map();
+                    for (const nd of arch.nodes) {
+                        if (!layerGroups.has(nd.layer))
+                            layerGroups.set(nd.layer, []);
+                        layerGroups.get(nd.layer).push(nd.label.split("\n")[0]);
+                    }
+                    let summary = "";
+                    for (const [layer, names] of layerGroups) {
+                        summary += `${layer}: ${names.join(", ")}\n`;
+                    }
+                    summary += "\nConnections:\n";
+                    for (const edge of arch.edges) {
+                        const src = nodeMap.get(edge.source)?.label.split("\n")[0] || edge.source;
+                        const tgt = nodeMap.get(edge.target)?.label.split("\n")[0] || edge.target;
+                        summary += `  ${src} -> ${tgt}${edge.label ? ` (${edge.label})` : ""}\n`;
+                    }
+                    if (arch.flows && arch.flows.length > 0) {
+                        summary += "\nFlows:\n";
+                        for (const flow of arch.flows) {
+                            summary += `  ${flow.name}: ${flow.description}\n`;
+                        }
+                    }
+                    if (arch.environments) {
+                        summary += "\nEnvironments: " + Object.keys(arch.environments).join(", ") + "\n";
+                    }
+                    // Build the prompt with conversation history
+                    const systemPrompt = `You are an architecture assistant for "${config.name}". Answer ONLY about this architecture. If asked unrelated questions, politely decline.\n\nARCHITECTURE:\n${summary}`;
+                    let fullPrompt = systemPrompt + "\n\n";
+                    if (history && Array.isArray(history)) {
+                        for (const msg of history) {
+                            if (msg.role === "user")
+                                fullPrompt += `User: ${msg.content}\n`;
+                            else if (msg.role === "assistant")
+                                fullPrompt += `Assistant: ${msg.content}\n`;
+                        }
+                    }
+                    fullPrompt += `User: ${message}\nAssistant:`;
+                    // Kill previous chat process if still running
+                    if (chatProcess) {
+                        try {
+                            chatProcess.kill("SIGTERM");
+                        }
+                        catch { }
+                        chatProcess = null;
+                    }
+                    // Check if claude CLI is available (no shell — prevents injection)
+                    let claudePath;
+                    try {
+                        const result = spawnSync("which", ["claude"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+                        claudePath = (result.stdout || "").trim();
+                        if (!claudePath || result.status !== 0)
+                            throw new Error("not found");
+                    }
+                    catch {
+                        res.writeHead(503, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code" }));
+                        return;
+                    }
+                    // Stream response as SSE
+                    res.writeHead(200, {
+                        "Content-Type": "text/event-stream",
+                        "Cache-Control": "no-cache",
+                        Connection: "keep-alive",
+                        "Access-Control-Allow-Origin": "*",
+                    });
+                    const child = spawn(claudePath, ["-p", "--model", "sonnet"], {
+                        cwd: config.workspaceRoot,
+                        stdio: ["pipe", "pipe", "pipe"],
+                        env: { ...process.env, FORCE_COLOR: "0" },
+                    });
+                    chatProcess = child;
+                    child.stdin.write(fullPrompt);
+                    child.stdin.end();
+                    child.stdout.on("data", (data) => {
+                        const text = data.toString();
+                        res.write(`data: ${JSON.stringify({ type: "text", text })}\n\n`);
+                    });
+                    child.stderr.on("data", (data) => {
+                        console.error("[archbyte-chat] stderr:", data.toString().trim());
+                    });
+                    child.on("close", (code) => {
+                        res.write(`data: ${JSON.stringify({ type: "done", code })}\n\n`);
+                        res.end();
+                        if (chatProcess === child)
+                            chatProcess = null;
+                    });
+                    child.on("error", (err) => {
+                        res.write(`data: ${JSON.stringify({ type: "error", message: String(err) })}\n\n`);
+                        res.end();
+                        if (chatProcess === child)
+                            chatProcess = null;
+                    });
+                    req.on("close", () => {
+                        if (chatProcess === child) {
+                            try {
+                                child.kill("SIGTERM");
+                            }
+                            catch { }
+                            chatProcess = null;
+                        }
+                    });
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(error) }));
+                }
+            });
+            return;
+        }
+        // Serve static UI files
+        const MIME_TYPES = {
+            ".html": "text/html",
+            ".js": "application/javascript",
+            ".css": "text/css",
+            ".json": "application/json",
+            ".png": "image/png",
+            ".svg": "image/svg+xml",
+        };
+        let filePath = url === "/" ? "/index.html" : url;
+        // Use path.resolve to normalize traversal sequences (e.g. /../)
+        const fullPath = path.resolve(UI_DIST, filePath.replace(/^\//, ""));
+        if (!fullPath.startsWith(UI_DIST)) {
+            res.writeHead(403);
+            res.end("Forbidden");
+            return;
+        }
+        try {
+            const content = readFileSync(fullPath);
+            const ext = path.extname(filePath);
+            res.writeHead(200, { "Content-Type": MIME_TYPES[ext] || "application/octet-stream" });
+            res.end(content);
+        }
+        catch {
+            try {
+                const indexContent = readFileSync(path.join(UI_DIST, "index.html"));
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(indexContent);
+            }
+            catch {
+                res.writeHead(404);
+                res.end("Not found");
+            }
+        }
+    });
+}
+// Start HTTP server
+async function startHttpServer() {
+    return new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(config.port, () => {
+            console.error(`[archbyte] Server running at http://localhost:${config.port}`);
+            resolve();
+        });
+    });
+}
+// Setup file watcher
+function setupWatcher() {
+    if (!existsSync(config.diagramPath))
+        return;
+    diagramWatcher = watch(config.diagramPath, { ignoreInitial: true });
+    diagramWatcher.on("change", async () => {
+        console.error("[archbyte] Diagram changed, reloading...");
+        currentArchitecture = await loadArchitecture();
+        broadcastUpdate();
+    });
+}
+// Graceful shutdown
+function setupShutdown() {
+    const shutdown = async () => {
+        console.error("[archbyte] Shutting down...");
+        // Kill tracked child processes
+        for (const [, proc] of runningWorkflows) {
+            try {
+                proc.kill("SIGTERM");
+            }
+            catch { }
+        }
+        runningWorkflows.clear();
+        if (patrolProcess) {
+            try {
+                patrolProcess.kill("SIGTERM");
+            }
+            catch { }
+            patrolProcess = null;
+            patrolRunning = false;
+        }
+        if (chatProcess) {
+            try {
+                chatProcess.kill("SIGTERM");
+            }
+            catch { }
+            chatProcess = null;
+        }
+        for (const client of sseClients) {
+            try {
+                client.end();
+            }
+            catch { }
+        }
+        sseClients.clear();
+        await diagramWatcher?.close();
+        httpServer?.close();
+        process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+}
+// License info helper — reads ~/.archbyte/credentials.json
+function loadLicenseInfo() {
+    const defaults = {
+        loggedIn: false,
+        email: null,
+        tier: "free",
+        features: {
+            analyze: true,
+            validate: false,
+            patrol: false,
+            workflows: false,
+            chat: false,
+            premiumAgents: false,
+        },
+    };
+    try {
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        const credPath = path.join(home, ".archbyte", "credentials.json");
+        if (!existsSync(credPath))
+            return defaults;
+        const creds = JSON.parse(readFileSync(credPath, "utf-8"));
+        if (!creds.token)
+            return defaults;
+        // Check expiry
+        if (creds.expiresAt && new Date(creds.expiresAt) < new Date()) {
+            return { ...defaults, loggedIn: true, email: creds.email ?? null };
+        }
+        const isPremium = creds.tier === "premium";
+        return {
+            loggedIn: true,
+            email: creds.email ?? null,
+            tier: isPremium ? "premium" : "free",
+            features: {
+                analyze: true,
+                validate: isPremium,
+                patrol: isPremium,
+                workflows: isPremium,
+                chat: isPremium,
+                premiumAgents: isPremium,
+            },
+        };
+    }
+    catch {
+        return defaults;
+    }
+}
+// Export start function
+export async function startServer(cfg) {
+    config = cfg;
+    setupShutdown();
+    createHttpServer();
+    try {
+        await startHttpServer();
+    }
+    catch (err) {
+        console.error("[archbyte] Failed to start HTTP server:", err);
+        process.exit(1);
+    }
+    setupWatcher();
+    console.error(`[archbyte] Serving ${config.name}`);
+    console.error(`[archbyte] Diagram: ${config.diagramPath}`);
+}