leedab 0.1.0

package/dist/dashboard/routes.js

@@ -0,0 +1,410 @@
+import { execFile, spawn } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { resolveOpenClawBin, openclawEnv } from "../openclaw.js";
+import { addEntry, removeEntry, listEntries } from "../vault.js";
+import { readAuditLog } from "../audit.js";
+import { getAnalytics } from "../analytics.js";
+import { loadTeam, addMember, removeMember, updateRole } from "../team.js";
+const execFileAsync = promisify(execFile);
+async function restartGatewayQuietly(stateDir) {
+    try {
+        const bin = resolveOpenClawBin();
+        const env = openclawEnv(stateDir);
+        await execFileAsync(bin, ["gateway", "health"], { env, timeout: 3000 });
+        await execFileAsync(bin, ["gateway", "restart"], { env, timeout: 10000 });
+    }
+    catch {
+        // Gateway not running, no restart needed
+    }
+}
+export function createRoutes(config) {
+    const bin = resolveOpenClawBin();
+    const stateDir = resolve(".leedab");
+    return {
+        /**
+         * POST /api/chat — send a message to the agent, get a response
+         */
+        "POST /api/chat": async (req, res) => {
+            const body = await readBody(req);
+            const { message, session } = JSON.parse(body);
+            if (!message) {
+                json(res, { error: "message is required" }, 400);
+                return;
+            }
+            try {
+                const args = [
+                    "agent",
+                    "--message", message,
+                    "--session-id", session ?? "console",
+                    "--json",
+                ];
+                const { stdout, stderr } = await execFileAsync(bin, args, {
+                    env: openclawEnv(stateDir),
+                    timeout: 120000,
+                });
+                try {
+                    const result = JSON.parse(stdout);
+                    // Extract text from various response shapes
+                    const reply = result.result?.payloads?.[0]?.text ??
+                        result.reply ??
+                        result.text ??
+                        result.content ??
+                        stdout.trim();
+                    json(res, { reply, session: session ?? "console" });
+                }
+                catch {
+                    json(res, {
+                        reply: stdout.trim() || stderr.trim() || "No response",
+                        session: session ?? "console",
+                    });
+                }
+            }
+            catch (err) {
+                json(res, { error: err.message }, 500);
+            }
+        },
+        /**
+         * GET /api/chat/history — get conversation history
+         */
+        "GET /api/chat/history": async (_req, res, url) => {
+            const session = url.searchParams.get("session") ?? "console";
+            try {
+                const { stdout } = await execFileAsync(bin, ["sessions", "history", "--session-id", session, "--json"], { env: openclawEnv(stateDir) });
+                json(res, JSON.parse(stdout));
+            }
+            catch {
+                json(res, []);
+            }
+        },
+        /**
+         * GET /api/status — channel health status
+         */
+        "GET /api/status": async (_req, res) => {
+            let secrets = {};
+            try {
+                const raw = await readFile(resolve(stateDir, "secrets.json"), "utf-8");
+                secrets = JSON.parse(raw);
+            }
+            catch { }
+            const status = {
+                whatsapp: {
+                    connected: !!secrets.whatsapp?.connected || !!secrets.whatsapp?.accessToken,
+                    label: "WhatsApp",
+                },
+                telegram: {
+                    connected: !!secrets.telegram?.token,
+                    label: "Telegram",
+                },
+                teams: {
+                    connected: !!secrets.teams?.appSecret,
+                    label: "Microsoft Teams",
+                },
+            };
+            json(res, status);
+        },
+        /**
+         * POST /api/whatsapp/connect — register channel and start QR pairing
+         */
+        "POST /api/whatsapp/connect": async (_req, res) => {
+            try {
+                // Register channel if not already added
+                await execFileAsync(bin, ["channels", "add", "--channel", "whatsapp"], {
+                    env: openclawEnv(stateDir),
+                }).catch(() => { });
+                // Spawn login and capture output (including QR)
+                const login = spawn(bin, ["channels", "login", "--channel", "whatsapp"], {
+                    env: {
+                        ...openclawEnv(stateDir),
+                        NO_COLOR: "1",
+                    },
+                });
+                let output = "";
+                const qrReady = new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        resolve(output);
+                    }, 10000);
+                    const onData = (chunk) => {
+                        output += chunk.toString();
+                        if (output.includes("▄▄██")) {
+                            clearTimeout(timeout);
+                            resolve(output);
+                        }
+                    };
+                    login.stdout?.on("data", onData);
+                    login.stderr?.on("data", onData);
+                    login.on("error", reject);
+                });
+                const qrOutput = await qrReady;
+                // Mark connected when login completes
+                login.on("close", async (code) => {
+                    if (code === 0) {
+                        await mkdir(stateDir, { recursive: true });
+                        let secrets = {};
+                        try {
+                            const raw = await readFile(resolve(stateDir, "secrets.json"), "utf-8");
+                            secrets = JSON.parse(raw);
+                        }
+                        catch { }
+                        secrets.whatsapp = { connected: true };
+                        await writeFile(resolve(stateDir, "secrets.json"), JSON.stringify(secrets, null, 2) + "\n");
+                    }
+                });
+                json(res, { status: "pairing", qr: qrOutput });
+            }
+            catch (err) {
+                json(res, { error: err.message }, 500);
+            }
+        },
+        /**
+         * GET /api/sessions — list all conversation sessions
+         */
+        "GET /api/sessions": async (_req, res) => {
+            try {
+                const { stdout } = await execFileAsync(bin, ["sessions", "--json"], { env: openclawEnv(stateDir), timeout: 10000 });
+                const parsed = JSON.parse(stdout);
+                const sessions = parsed.sessions ?? (Array.isArray(parsed) ? parsed : []);
+                json(res, sessions);
+            }
+            catch {
+                json(res, []);
+            }
+        },
+        /**
+         * GET /api/audit — recent audit log entries
+         */
+        "GET /api/audit": async (_req, res, url) => {
+            const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+            const channel = url.searchParams.get("channel") ?? undefined;
+            const sinceParam = url.searchParams.get("since");
+            const since = sinceParam ? new Date(sinceParam) : undefined;
+            const entries = await readAuditLog({ limit, channel, since });
+            json(res, entries);
+        },
+        /**
+         * GET /api/analytics — usage analytics summary
+         */
+        "GET /api/analytics": async (_req, res, url) => {
+            const days = parseInt(url.searchParams.get("days") ?? "30", 10);
+            const summary = await getAnalytics(days);
+            json(res, summary);
+        },
+        /**
+         * GET /api/vault — list stored credentials (no passwords)
+         */
+        "GET /api/vault": async (_req, res) => {
+            const entries = await listEntries();
+            json(res, entries);
+        },
+        /**
+         * POST /api/vault — add a credential to the vault
+         */
+        "POST /api/vault": async (req, res) => {
+            const body = await readBody(req);
+            const { service, url, username, password, notes } = JSON.parse(body);
+            if (!service || typeof service !== "string") {
+                json(res, { error: "service name is required" }, 400);
+                return;
+            }
+            await addEntry(service.trim(), {
+                url: url || undefined,
+                username: username || undefined,
+                password: password || undefined,
+                notes: notes || undefined,
+            });
+            json(res, { ok: true, service: service.trim() });
+        },
+        /**
+         * POST /api/telegram/connect — validate token and save
+         */
+        "POST /api/telegram/connect": async (req, res) => {
+            const body = await readBody(req);
+            const { token } = JSON.parse(body);
+            if (!token || typeof token !== "string") {
+                json(res, { error: "token is required" }, 400);
+                return;
+            }
+            // Validate token via Telegram API
+            try {
+                const tgRes = await fetch(`https://api.telegram.org/bot${token.trim()}/getMe`);
+                const data = await tgRes.json();
+                if (!data.ok) {
+                    json(res, { error: "Invalid bot token" }, 400);
+                    return;
+                }
+                // Save to secrets
+                await mkdir(stateDir, { recursive: true });
+                let secrets = {};
+                try {
+                    const raw = await readFile(resolve(stateDir, "secrets.json"), "utf-8");
+                    secrets = JSON.parse(raw);
+                }
+                catch { }
+                secrets.telegram = { token: token.trim() };
+                await writeFile(resolve(stateDir, "secrets.json"), JSON.stringify(secrets, null, 2) + "\n");
+                json(res, { connected: true, username: data.result.username });
+            }
+            catch {
+                json(res, { error: "Could not reach Telegram API" }, 500);
+            }
+        },
+        /**
+         * GET /api/allowlist — get allowlist for a channel
+         * Expects ?channel=<name> query param
+         */
+        "GET /api/allowlist": async (_req, res, url) => {
+            const channel = url.searchParams.get("channel");
+            if (!channel) {
+                json(res, { error: "channel query param is required" }, 400);
+                return;
+            }
+            try {
+                const raw = await readFile(resolve(stateDir, "openclaw.json"), "utf-8");
+                const config = JSON.parse(raw);
+                const allowFrom = config.channels?.[channel]?.allowFrom ?? [];
+                const dmPolicy = config.channels?.[channel]?.dmPolicy ?? "pairing";
+                json(res, { channel, dmPolicy, allowFrom });
+            }
+            catch {
+                json(res, { channel, dmPolicy: "pairing", allowFrom: [] });
+            }
+        },
+        /**
+         * POST /api/allowlist — add a user to a channel's allowlist
+         */
+        "POST /api/allowlist": async (req, res) => {
+            const body = await readBody(req);
+            const { channel, userId } = JSON.parse(body);
+            if (!channel || !userId) {
+                json(res, { error: "channel and userId are required" }, 400);
+                return;
+            }
+            try {
+                const configPath = resolve(stateDir, "openclaw.json");
+                const config = JSON.parse(await readFile(configPath, "utf-8"));
+                if (!config.channels?.[channel]) {
+                    json(res, { error: `Channel "${channel}" not configured` }, 400);
+                    return;
+                }
+                if (!config.channels[channel].allowFrom) {
+                    config.channels[channel].allowFrom = [];
+                }
+                if (!config.channels[channel].allowFrom.includes(userId)) {
+                    config.channels[channel].allowFrom.push(userId);
+                }
+                config.channels[channel].dmPolicy = "allowlist";
+                await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+                await restartGatewayQuietly(stateDir);
+                json(res, { ok: true });
+            }
+            catch (err) {
+                json(res, { error: err.message }, 500);
+            }
+        },
+        /**
+         * DELETE /api/allowlist — remove a user from a channel's allowlist
+         * Expects ?channel=<name>&userId=<id> query params
+         */
+        "DELETE /api/allowlist": async (_req, res, url) => {
+            const channel = url.searchParams.get("channel");
+            const userId = url.searchParams.get("userId");
+            if (!channel || !userId) {
+                json(res, { error: "channel and userId query params are required" }, 400);
+                return;
+            }
+            try {
+                const configPath = resolve(stateDir, "openclaw.json");
+                const config = JSON.parse(await readFile(configPath, "utf-8"));
+                const list = config.channels?.[channel]?.allowFrom;
+                if (!list) {
+                    json(res, { ok: false, error: "No allowlist for this channel" }, 400);
+                    return;
+                }
+                config.channels[channel].allowFrom = list.filter((id) => id !== userId);
+                await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+                await restartGatewayQuietly(stateDir);
+                json(res, { ok: true });
+            }
+            catch (err) {
+                json(res, { error: err.message }, 500);
+            }
+        },
+        /**
+         * DELETE /api/vault — remove a credential from the vault
+         * Expects ?service=<name> query param
+         */
+        "DELETE /api/vault": async (_req, res, url) => {
+            const service = url.searchParams.get("service");
+            if (!service) {
+                json(res, { error: "service query param is required" }, 400);
+                return;
+            }
+            const removed = await removeEntry(service);
+            json(res, { ok: removed, service });
+        },
+        /**
+         * GET /api/team — list team members
+         */
+        "GET /api/team": async (_req, res) => {
+            const team = await loadTeam();
+            json(res, team);
+        },
+        /**
+         * POST /api/team — add a team member
+         */
+        "POST /api/team": async (req, res) => {
+            const body = await readBody(req);
+            const { name, email, role, channels } = JSON.parse(body);
+            if (!name || typeof name !== "string") {
+                json(res, { error: "name is required" }, 400);
+                return;
+            }
+            const member = await addMember({
+                name: name.trim(),
+                email: email || undefined,
+                role: role || "operator",
+                channels: channels || [],
+            });
+            json(res, member, 201);
+        },
+        /**
+         * DELETE /api/team — remove a team member
+         * Expects ?id=<uuid> query param
+         */
+        "DELETE /api/team": async (_req, res, url) => {
+            const id = url.searchParams.get("id");
+            if (!id) {
+                json(res, { error: "id query param is required" }, 400);
+                return;
+            }
+            const removed = await removeMember(id);
+            json(res, { ok: removed });
+        },
+        /**
+         * PUT /api/team/role — update a member's role
+         */
+        "PUT /api/team/role": async (req, res) => {
+            const body = await readBody(req);
+            const { id, role } = JSON.parse(body);
+            if (!id || !role) {
+                json(res, { error: "id and role are required" }, 400);
+                return;
+            }
+            const updated = await updateRole(id, role);
+            json(res, { ok: updated });
+        },
+    };
+}
+function json(res, data, status = 200) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        req.on("data", (chunk) => (body += chunk));
+        req.on("end", () => resolve(body));
+        req.on("error", reject);
+    });
+}

package/dist/dashboard/server.d.ts

@@ -0,0 +1,2 @@
+import type { LeedABConfig } from "../config/schema.js";
+export declare function startDashboard(config: LeedABConfig, port?: number): Promise<void>;

package/dist/dashboard/server.js

@@ -0,0 +1,80 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { resolve, extname } from "node:path";
+import { createRoutes } from "./routes.js";
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+};
+export async function startDashboard(config, port = 3000) {
+    const routes = createRoutes(config);
+    const staticDir = resolve(import.meta.dirname, "static");
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        const method = req.method ?? "GET";
+        // API routes
+        if (url.pathname.startsWith("/api/")) {
+            const handler = routes[`${method} ${url.pathname}`];
+            if (handler) {
+                try {
+                    await handler(req, res, url);
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+                return;
+            }
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "not found" }));
+            return;
+        }
+        // Static files — try .html extension for clean URLs (/console -> /console.html)
+        let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
+        if (!extname(filePath))
+            filePath += ".html";
+        try {
+            const fullPath = resolve(staticDir, filePath.slice(1));
+            const content = await readFile(fullPath);
+            const ext = extname(fullPath);
+            res.writeHead(200, { "Content-Type": MIME_TYPES[ext] ?? "text/plain" });
+            res.end(content);
+        }
+        catch {
+            // SPA fallback
+            try {
+                const index = await readFile(resolve(staticDir, "index.html"));
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(index);
+            }
+            catch {
+                res.writeHead(404);
+                res.end("Not found");
+            }
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.on("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                // Try next port
+                const nextPort = port + 1;
+                console.log(`  Port ${port} in use, trying ${nextPort}...`);
+                server.listen(nextPort, "127.0.0.1");
+                server.once("listening", () => {
+                    console.log(`  Dashboard: http://localhost:${nextPort}`);
+                    resolve();
+                });
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(port, "127.0.0.1", () => {
+            resolve();
+        });
+    });
+}