@dashwire/server 0.1.0 → 0.3.0

package/dist/db/schema.js

@@ -0,0 +1,46 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const projects = sqliteTable("projects", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    apiKeyHash: text("api_key_hash").notNull(),
+    structureJson: text("structure_json").notNull(),
+    status: text("status", { enum: ["online", "offline"] }).notNull().default("offline"),
+    createdAt: text("created_at").notNull(),
+    lastSeenAt: text("last_seen_at"),
+});
+export const projectTokens = sqliteTable("project_tokens", {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    token: text("token").notNull().unique(),
+    active: integer("active", { mode: "boolean" }).notNull().default(true),
+    createdAt: text("created_at").notNull(),
+});
+export const capabilityState = sqliteTable("capability_state", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    projectId: text("project_id").notNull(),
+    capabilityPath: text("capability_path").notNull(),
+    valueJson: text("value_json").notNull(),
+    updatedAt: text("updated_at").notNull(),
+});
+export const overviewConfig = sqliteTable("overview_config", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    projectId: text("project_id").notNull(),
+    capabilityPath: text("capability_path").notNull(),
+    staleSince: text("stale_since"),
+});
+export const logs = sqliteTable("logs", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    projectId: text("project_id").notNull(),
+    level: text("level").notNull(),
+    message: text("message").notNull(),
+    source: text("source"),
+    metadataJson: text("metadata_json"),
+    timestamp: text("timestamp").notNull(),
+});
+export const users = sqliteTable("users", {
+    id: text("id").primaryKey(),
+    username: text("username").notNull().unique(),
+    passwordHash: text("password_hash").notNull(),
+    role: text("role").notNull().default("admin"),
+    createdAt: text("created_at").notNull(),
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function startDashwire(userConfig?: any): void;

package/dist/index.js

@@ -0,0 +1,114 @@
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import { Server as SocketServer } from "socket.io";
+import Database from "better-sqlite3";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PORT = Number(process.env.PORT ?? 4000);
+const dbPath = process.env.DASHWIRE_DB_PATH ?? "./dashwire.db";
+const app = Fastify({ logger: true });
+const sqlite = new Database(dbPath);
+sqlite.pragma("journal_mode = WAL");
+// Database Schema Initialisatie
+sqlite.exec(`
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    api_key_hash TEXT NOT NULL,
+    structure_version INTEGER NOT NULL DEFAULT 1,
+    structure_json TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'offline',
+    last_seen_at TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS capability_state (
+    project_id TEXT NOT NULL,
+    capability_path TEXT NOT NULL,
+    value_json TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (project_id, capability_path)
+  );
+`);
+app.addHook("onRequest", async (req, reply) => {
+    reply.header("Access-Control-Allow-Origin", "*");
+    reply.header("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
+    reply.header("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key, x-admin-token");
+    if (req.method === "OPTIONS")
+        return reply.code(200).send();
+});
+app.get("/health", async () => ({ ok: true }));
+app.get("/api/projects", async () => {
+    return sqlite.prepare("SELECT id, name, status, last_seen_at as lastSeenAt, structure_version as structureVersion FROM projects").all();
+});
+app.get("/api/projects/:id", async (req, reply) => {
+    const project = sqlite.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+    if (!project)
+        return reply.status(404).send({ error: "not found" });
+    const states = sqlite.prepare("SELECT capability_path, value_json FROM capability_state WHERE project_id = ?").all(req.params.id);
+    const stateMap = {};
+    for (const row of states)
+        stateMap[row.capability_path] = JSON.parse(row.value_json);
+    return {
+        id: project.id,
+        name: project.name,
+        status: project.status,
+        structure: JSON.parse(project.structure_json),
+        state: stateMap,
+    };
+});
+// Serveer de ingebouwde Dashboard UI
+app.register(fastifyStatic, {
+    root: join(__dirname, "../public"),
+    prefix: "/",
+});
+// SPA catch-all fallback voor Next.js client-side routing
+app.setNotFoundHandler((req, reply) => {
+    if (req.url?.startsWith("/api") || req.url?.startsWith("/sdk")) {
+        return reply.code(404).send({ error: "Not found" });
+    }
+    return reply.sendFile("index.html");
+});
+const io = new SocketServer(app.server, { cors: { origin: "*" } });
+const sdkNsp = io.of("/sdk");
+sdkNsp.on("connection", (socket) => {
+    const { projectId } = socket.handshake.auth || {};
+    if (!projectId)
+        return socket.disconnect();
+    socket.join(`project:${projectId}`);
+    sqlite.prepare("UPDATE projects SET status = 'online', last_seen_at = ? WHERE id = ?").run(new Date().toISOString(), projectId);
+    io.of("/dashboard").to(`project:${projectId}`).emit("project:online", { projectId });
+    socket.on("state:sync", ({ state }) => {
+        const stmt = sqlite.prepare(`INSERT INTO capability_state (project_id, capability_path, value_json, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT(project_id, capability_path) DO UPDATE SET value_json = excluded.value_json, updated_at = excluded.updated_at`);
+        const now = new Date().toISOString();
+        for (const [path, val] of Object.entries(state || {})) {
+            stmt.run(projectId, path, JSON.stringify(val), now);
+            io.of("/dashboard").to(`project:${projectId}`).emit("state:update", { projectId, path, value: val });
+        }
+    });
+    socket.on("state:update", ({ path, value }) => {
+        const now = new Date().toISOString();
+        sqlite.prepare(`INSERT INTO capability_state (project_id, capability_path, value_json, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT(project_id, capability_path) DO UPDATE SET value_json = excluded.value_json, updated_at = excluded.updated_at`).run(projectId, path, JSON.stringify(value), now);
+        io.of("/dashboard").to(`project:${projectId}`).emit("state:update", { projectId, path, value });
+    });
+    socket.on("disconnect", () => {
+        sqlite.prepare("UPDATE projects SET status = 'offline', last_seen_at = ? WHERE id = ?").run(new Date().toISOString(), projectId);
+        io.of("/dashboard").to(`project:${projectId}`).emit("project:offline", { projectId });
+    });
+});
+const dashNsp = io.of("/dashboard");
+dashNsp.on("connection", (socket) => {
+    socket.on("subscribe:project", ({ projectId }) => socket.join(`project:${projectId}`));
+    socket.on("unsubscribe:project", ({ projectId }) => socket.leave(`project:${projectId}`));
+    socket.on("capability:command", ({ projectId, path, value }) => {
+        io.of("/sdk").to(`project:${projectId}`).emit("capability:command", { path, value });
+    });
+    socket.on("action:execute", ({ projectId, path }) => {
+        io.of("/sdk").to(`project:${projectId}`).emit("action:execute", { path });
+    });
+});
+export function startDashwire(userConfig) {
+    app.listen({ port: PORT, host: "0.0.0.0" }).then(() => {
+        console.log(`⚡ Dashwire server & dashboard running on http://0.0.0.0:${PORT}`);
+    });
+}

package/dist/logs.service.d.ts

@@ -0,0 +1 @@
+export declare function insertLog(projectId: string, level: string, message: string, source?: string, metadata?: Record<string, unknown>): number;

package/dist/logs.service.js

@@ -0,0 +1,14 @@
+import { db } from "./db/client.js";
+import { logs } from "./db/schema.js";
+export function insertLog(projectId, level, message, source, metadata) {
+    const timestamp = new Date().toISOString();
+    const res = db.insert(logs).values({
+        projectId,
+        level,
+        message,
+        source: source ?? null,
+        metadataJson: metadata ? JSON.stringify(metadata) : null,
+        timestamp,
+    }).run();
+    return Number(res.lastInsertRowid);
+}

package/dist/overview.service.d.ts

@@ -0,0 +1,12 @@
+export interface OverviewEntryInput {
+    projectId: string;
+    capabilityPath: string;
+    order: number;
+}
+export declare function setOverviewConfig(entries: OverviewEntryInput[]): void;
+export declare function getOverviewConfig(projectId?: string): {
+    id: number;
+    projectId: string;
+    capabilityPath: string;
+    staleSince: string | null;
+}[];

package/dist/overview.service.js

@@ -0,0 +1,20 @@
+import { db } from "./db/client.js";
+import { overviewConfig } from "./db/schema.js";
+import { eq } from "drizzle-orm";
+export function setOverviewConfig(entries) {
+    db.delete(overviewConfig).run();
+    for (const entry of entries) {
+        db.insert(overviewConfig)
+            .values({
+            projectId: entry.projectId,
+            capabilityPath: entry.capabilityPath
+        })
+            .run();
+    }
+}
+export function getOverviewConfig(projectId) {
+    if (projectId) {
+        return db.select().from(overviewConfig).where(eq(overviewConfig.projectId, projectId)).all();
+    }
+    return db.select().from(overviewConfig).all();
+}

package/dist/projects.service.d.ts

@@ -0,0 +1,40 @@
+import type { DashboardStructure, Capability } from "@dashwire/core";
+export interface RegisterResult {
+    token: string;
+    staleOverviewPaths: string[];
+}
+export declare function registerProject(projectId: string, projectName: string, structure: DashboardStructure, authToken?: string): RegisterResult;
+export declare function verifyProjectToken(token: string): {
+    universal: boolean;
+} | null;
+export declare function listAllTokens(): {
+    id: string;
+    createdAt: string;
+    projectId: string;
+    token: string;
+    active: boolean;
+}[];
+export declare function createTokenForProject(label?: string): string;
+export declare function setTokenActiveStatus(tokenId: string, active: boolean): void;
+export declare function deleteToken(tokenId: string): void;
+export declare function setProjectStatus(projectId: string, status: "online" | "offline"): void;
+export declare function getProject(projectId: string): {
+    token: string;
+    structure: DashboardStructure;
+    state: Record<string, unknown>;
+    id: string;
+    name: string;
+    status: "online" | "offline";
+    createdAt: string;
+    lastSeenAt: string | null;
+} | null;
+export declare function listProjects(): {
+    id: string;
+    name: string;
+    status: "online" | "offline";
+    lastSeenAt: string | null;
+    token: string;
+}[];
+export declare function upsertCapabilityState(projectId: string, path: string, value: unknown, overwrite?: boolean): void;
+export declare function bulkSyncState(projectId: string, state: Record<string, unknown>): void;
+export declare function findCapability(structure: DashboardStructure, path: string): Capability | undefined;

package/dist/projects.service.js

@@ -0,0 +1,180 @@
+import { randomBytes } from "node:crypto";
+import { eq, and } from "drizzle-orm";
+import jwt from "jsonwebtoken";
+import { db } from "./db/client.js";
+import { projects, projectTokens, capabilityState, overviewConfig } from "./db/schema.js";
+const JWT_SECRET = process.env.JWT_SECRET || "super-secret-dashwire-key";
+function allPaths(structure) {
+    const set = new Set();
+    for (const section of structure.sections) {
+        for (const cap of section.capabilities)
+            set.add(cap.path);
+    }
+    return set;
+}
+export function registerProject(projectId, projectName, structure, authToken) {
+    const existing = db.select().from(projects).where(eq(projects.id, projectId)).get();
+    const now = new Date().toISOString();
+    const structureJsonString = JSON.stringify(structure);
+    let activeToken = authToken;
+    if (authToken) {
+        // Valideer enkel of het token geldig en actief is in de database (geen strenge project-ID match vereist)
+        const verified = verifyProjectToken(authToken);
+        if (!verified) {
+            throw new Error("Unauthorized: Invalid or inactive token.");
+        }
+        activeToken = authToken;
+    }
+    else {
+        // Zoek het eerste actieve token in de database dat als universele sleutel kan dienen
+        const existingTokenRecord = db.select().from(projectTokens).where(eq(projectTokens.active, true)).get();
+        if (existingTokenRecord) {
+            activeToken = existingTokenRecord.token;
+        }
+        else {
+            throw new Error("Unauthorized: No active token found. Please generate a token first via the /security page.");
+        }
+    }
+    if (!existing) {
+        db.insert(projects)
+            .values({
+            id: projectId,
+            name: projectName,
+            apiKeyHash: "jwt-secured",
+            structureJson: structureJsonString,
+            status: "offline",
+            createdAt: now,
+        })
+            .run();
+    }
+    else {
+        db.update(projects)
+            .set({
+            name: projectName,
+            structureJson: structureJsonString,
+        })
+            .where(eq(projects.id, projectId))
+            .run();
+    }
+    const currentPaths = allPaths(structure);
+    const configEntries = db.select().from(overviewConfig).where(eq(overviewConfig.projectId, projectId)).all();
+    const staleOverviewPaths = [];
+    for (const entry of configEntries) {
+        if (!currentPaths.has(entry.capabilityPath)) {
+            staleOverviewPaths.push(entry.capabilityPath);
+            db.update(overviewConfig).set({ staleSince: now }).where(eq(overviewConfig.id, entry.id)).run();
+        }
+        else if (entry.staleSince) {
+            db.update(overviewConfig).set({ staleSince: null }).where(eq(overviewConfig.id, entry.id)).run();
+        }
+    }
+    return { token: activeToken, staleOverviewPaths };
+}
+export function verifyProjectToken(token) {
+    try {
+        jwt.verify(token, JWT_SECRET);
+        const record = db.select().from(projectTokens).where(and(eq(projectTokens.token, token), eq(projectTokens.active, true))).get();
+        if (!record)
+            return null;
+        return { universal: true };
+    }
+    catch {
+        return null;
+    }
+}
+export function listAllTokens() {
+    return db.select().from(projectTokens).all();
+}
+export function createTokenForProject(label) {
+    const tokenName = label || "Universele Sleutel";
+    const token = jwt.sign({ name: tokenName, scope: "dashwire-access" }, JWT_SECRET);
+    const id = randomBytes(8).toString("hex");
+    const now = new Date().toISOString();
+    db.insert(projectTokens).values({
+        id,
+        projectId: "universal", // Niet gekoppeld aan 1 specifiek project
+        token,
+        active: true,
+        createdAt: now,
+    }).run();
+    return token;
+}
+export function setTokenActiveStatus(tokenId, active) {
+    db.update(projectTokens).set({ active }).where(eq(projectTokens.id, tokenId)).run();
+}
+export function deleteToken(tokenId) {
+    db.delete(projectTokens).where(eq(projectTokens.id, tokenId)).run();
+}
+export function setProjectStatus(projectId, status) {
+    db.update(projects).set({ status, lastSeenAt: new Date().toISOString() }).where(eq(projects.id, projectId)).run();
+}
+export function getProject(projectId) {
+    const project = db.select().from(projects).where(eq(projects.id, projectId)).get();
+    if (!project)
+        return null;
+    const state = db.select().from(capabilityState).where(eq(capabilityState.projectId, projectId)).all();
+    const stateMap = {};
+    for (const row of state)
+        stateMap[row.capabilityPath] = JSON.parse(row.valueJson);
+    const tokenRecord = db.select().from(projectTokens).where(eq(projectTokens.active, true)).get();
+    const token = tokenRecord ? tokenRecord.token : jwt.sign({ scope: "dashwire-access" }, JWT_SECRET);
+    const { apiKeyHash, structureJson, ...safe } = project;
+    return {
+        ...safe,
+        token,
+        structure: JSON.parse(structureJson),
+        state: stateMap,
+    };
+}
+export function listProjects() {
+    return db.select().from(projects).all().map((p) => {
+        const tokenRecord = db.select().from(projectTokens).where(eq(projectTokens.active, true)).get();
+        const token = tokenRecord ? tokenRecord.token : "";
+        return {
+            id: p.id,
+            name: p.name,
+            status: p.status,
+            lastSeenAt: p.lastSeenAt,
+            token,
+        };
+    });
+}
+export function upsertCapabilityState(projectId, path, value, overwrite = true) {
+    const now = new Date().toISOString();
+    const existing = db.select()
+        .from(capabilityState)
+        .where(eq(capabilityState.projectId, projectId))
+        .all()
+        .find((r) => r.capabilityPath === path);
+    if (existing) {
+        if (overwrite) {
+            db.update(capabilityState)
+                .set({ valueJson: JSON.stringify(value), updatedAt: now })
+                .where(and(eq(capabilityState.projectId, projectId), eq(capabilityState.capabilityPath, path)))
+                .run();
+        }
+    }
+    else {
+        db.insert(capabilityState)
+            .values({
+            projectId,
+            capabilityPath: path,
+            valueJson: JSON.stringify(value),
+            updatedAt: now
+        })
+            .run();
+    }
+}
+export function bulkSyncState(projectId, state) {
+    for (const [path, value] of Object.entries(state)) {
+        upsertCapabilityState(projectId, path, value, false);
+    }
+}
+export function findCapability(structure, path) {
+    for (const section of structure.sections) {
+        const found = section.capabilities.find((c) => c.path === path);
+        if (found)
+            return found;
+    }
+    return undefined;
+}

package/dist/realtime/dashboardNamespace.d.ts

@@ -0,0 +1,2 @@
+import type { Server as SocketServer } from "socket.io";
+export declare function attachDashboardNamespace(io: SocketServer): void;

package/dist/realtime/dashboardNamespace.js

@@ -0,0 +1,26 @@
+export function attachDashboardNamespace(io) {
+    const dashNsp = io.of("/dashboard");
+    const sdkNsp = io.of("/sdk");
+    dashNsp.on("connection", (socket) => {
+        socket.on("subscribe:project", ({ projectId }) => {
+            if (!projectId)
+                return;
+            socket.join(projectId);
+        });
+        socket.on("unsubscribe:project", ({ projectId }) => {
+            if (!projectId)
+                return;
+            socket.leave(projectId);
+        });
+        socket.on("capability:command", ({ projectId, path, value }) => {
+            if (!projectId || !path)
+                return;
+            sdkNsp.to(projectId).emit("capability:command", { path, value });
+        });
+        socket.on("action:execute", ({ projectId, path }) => {
+            if (!projectId || !path)
+                return;
+            sdkNsp.to(projectId).emit("action:execute", { path });
+        });
+    });
+}

package/dist/realtime/sdkNamespace.d.ts

@@ -0,0 +1,2 @@
+import type { Server as SocketServer } from "socket.io";
+export declare function attachSdkNamespace(io: SocketServer): void;

package/dist/realtime/sdkNamespace.js

@@ -0,0 +1,69 @@
+import { verifyProjectToken, setProjectStatus, upsertCapabilityState, } from "../projects.service.js";
+export function attachSdkNamespace(io) {
+    const sdkNsp = io.of("/sdk");
+    sdkNsp.use((socket, next) => {
+        const token = socket.handshake.auth?.token;
+        if (!token)
+            return next(new Error("Token required"));
+        if (!verifyProjectToken(token))
+            return next(new Error("Invalid token"));
+        next();
+    });
+    sdkNsp.on("connection", (socket) => {
+        const projectId = socket.handshake.query.projectId ||
+            socket.handshake.auth?.projectId;
+        if (projectId) {
+            socket.data.projectId = projectId;
+            socket.join(projectId);
+            setProjectStatus(projectId, "online");
+            io.of("/dashboard").to(projectId).emit("project:online", {
+                projectId,
+            });
+        }
+        socket.on("state:sync", ({ state }) => {
+            const pid = socket.data.projectId || projectId;
+            if (!pid)
+                return;
+            setProjectStatus(pid, "online");
+            io.of("/dashboard").to(pid).emit("project:online", {
+                projectId: pid,
+            });
+            for (const [path, value] of Object.entries(state)) {
+                upsertCapabilityState(pid, path, value, false);
+            }
+        });
+        socket.on("state:update", ({ path, value }) => {
+            const pid = socket.data.projectId || projectId;
+            if (!pid)
+                return;
+            upsertCapabilityState(pid, path, value, true);
+            io.of("/dashboard").to(pid).emit("state:update", {
+                projectId: pid,
+                path,
+                value,
+            });
+        });
+        socket.on("log:new", ({ level, message, source, metadata, timestamp }) => {
+            const pid = socket.data.projectId || projectId;
+            if (!pid)
+                return;
+            io.of("/dashboard").to(pid).emit("log:new", {
+                projectId: pid,
+                level,
+                message,
+                source,
+                metadata,
+                timestamp,
+            });
+        });
+        socket.on("disconnect", () => {
+            const pid = socket.data.projectId || projectId;
+            if (!pid)
+                return;
+            setProjectStatus(pid, "offline");
+            io.of("/dashboard").to(pid).emit("project:offline", {
+                projectId: pid,
+            });
+        });
+    });
+}

package/dist/routes/auth.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export declare function authRoutes(app: FastifyInstance): void;

package/dist/routes/auth.js

@@ -0,0 +1,76 @@
+import { hasAnyAdmin, createAdminUser, authenticateUser, createUserRecord, verifyAuthToken, listUsers, deleteUser } from "../auth.service.js";
+export function authRoutes(app) {
+    app.get("/api/auth/status", async (_req, reply) => {
+        return reply.send({ hasAdmin: hasAnyAdmin() });
+    });
+    app.post("/api/auth/setup", async (req, reply) => {
+        const { username, password } = req.body || {};
+        if (!username || !password) {
+            return reply.code(400).send({ error: "Gebruikersnaam en wachtwoord zijn verplicht." });
+        }
+        try {
+            if (hasAnyAdmin()) {
+                return reply.code(400).send({ error: "Setup is al voltooid." });
+            }
+            const token = createAdminUser(username, password);
+            return reply.send({ token });
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err.message });
+        }
+    });
+    app.post("/api/auth/login", async (req, reply) => {
+        const { username, password } = req.body || {};
+        if (!username || !password) {
+            return reply.code(400).send({ error: "Vul alle velden in." });
+        }
+        try {
+            const token = authenticateUser(username, password);
+            return reply.send({ token });
+        }
+        catch (err) {
+            return reply.code(401).send({ error: err.message });
+        }
+    });
+    app.get("/api/users", async (req, reply) => {
+        const authHeader = req.headers.authorization;
+        const token = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : "";
+        const verified = verifyAuthToken(token);
+        if (!verified || verified.role !== "admin") {
+            return reply.code(403).send({ error: "Toegang geweigerd. Alleen voor admins." });
+        }
+        return reply.send(listUsers());
+    });
+    app.post("/api/users", async (req, reply) => {
+        const authHeader = req.headers.authorization;
+        const token = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : "";
+        const verified = verifyAuthToken(token);
+        if (!verified || verified.role !== "admin") {
+            return reply.code(403).send({ error: "Toegang geweigerd. Alleen voor admins." });
+        }
+        try {
+            const { username, password, role } = req.body;
+            const newUser = createUserRecord(username, password, role || "user");
+            return reply.send(newUser);
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err.message });
+        }
+    });
+    // --- AANPASSING IN: de DELETE /api/users/:userId route ---
+    app.delete("/api/users/:userId", async (req, reply) => {
+        const authHeader = req.headers.authorization;
+        const token = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : "";
+        const verified = verifyAuthToken(token);
+        if (!verified || verified.role !== "admin") {
+            return reply.code(403).send({ error: "Toegang geweigerd." });
+        }
+        try {
+            deleteUser(req.params.userId, verified.id);
+            return reply.send({ success: true });
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err.message });
+        }
+    });
+}

package/dist/routes/overview.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export declare function overviewRoutes(app: FastifyInstance): void;

package/dist/routes/overview.js

@@ -0,0 +1,21 @@
+import { getOverviewConfig, setOverviewConfig } from "../overview.service.js";
+function requireAdmin(req, reply) {
+    const token = req.headers["x-admin-token"];
+    const expected = process.env.DASHWIRE_ADMIN_TOKEN;
+    if (!expected || token !== expected) {
+        reply.status(401).send({ error: "unauthorized" });
+        return false;
+    }
+    return true;
+}
+export function overviewRoutes(app) {
+    app.get("/api/overview-config", async () => {
+        return getOverviewConfig();
+    });
+    app.put("/api/overview-config", async (req, reply) => {
+        if (!requireAdmin(req, reply))
+            return;
+        setOverviewConfig(req.body.entries);
+        return reply.send({ ok: true });
+    });
+}

package/dist/routes/projects.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type { Server as SocketServer } from "socket.io";
+export declare function projectRoutes(app: FastifyInstance, io: SocketServer): void;