@naisys/supervisor 3.0.0-beta.6

package/dist/services/attachmentProxyService.js

@@ -0,0 +1,130 @@
+import { createHash } from "crypto";
+import https from "https";
+import { hubDb } from "../database/hubDb.js";
+import { getLogger } from "../logger.js";
+import { getHubPinnedAgent, getHubUrl } from "./hubConnectionService.js";
+/**
+ * Upload a file buffer to the hub's attachment endpoint.
+ * Returns the attachment ID from the hub.
+ */
+export async function uploadToHub(fileBuffer, filename, uploadAsUserId, purpose = "mail") {
+    const hubUrl = getHubUrl();
+    if (!hubUrl) {
+        throw new Error("Hub URL not configured");
+    }
+    // Look up user's API key from the hub DB
+    const user = await hubDb.users.findUnique({
+        where: { id: uploadAsUserId },
+        select: { api_key: true },
+    });
+    if (!user?.api_key) {
+        throw new Error(`User ${uploadAsUserId} has no API key`);
+    }
+    // Compute SHA-256 of file buffer
+    const fileHash = createHash("sha256").update(fileBuffer).digest("hex");
+    const url = new URL("/attachments", hubUrl);
+    url.searchParams.set("filename", filename);
+    url.searchParams.set("filesize", String(fileBuffer.length));
+    url.searchParams.set("filehash", fileHash);
+    url.searchParams.set("purpose", purpose);
+    const response = await new Promise((resolve, reject) => {
+        const req = https.request(url, {
+            method: "POST",
+            agent: getHubPinnedAgent() ?? undefined,
+            headers: {
+                "Content-Length": fileBuffer.length,
+                Authorization: `Bearer ${user.api_key}`,
+            },
+        }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => (body += chunk));
+            res.on("end", () => {
+                try {
+                    const parsed = JSON.parse(body);
+                    if (res.statusCode !== 200) {
+                        reject(new Error(parsed.error ||
+                            `Hub upload failed with status ${res.statusCode}`));
+                    }
+                    else {
+                        resolve(parsed);
+                    }
+                }
+                catch {
+                    reject(new Error(`Invalid response from hub: ${body}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.end(fileBuffer);
+    });
+    getLogger().info(`Uploaded attachment ${response.id} (${filename}) for user ${uploadAsUserId}`);
+    return response.id;
+}
+/**
+ * Proxy a download request from the client through to the hub's attachment endpoint.
+ * Streams the file directly from hub to client.
+ */
+export async function proxyDownloadFromHub(publicId, reply) {
+    const hubUrl = getHubUrl();
+    if (!hubUrl) {
+        throw new Error("Hub URL not configured");
+    }
+    // Look up the attachment to get the uploader's user ID
+    const attachment = await hubDb.attachments.findUnique({
+        where: { public_id: publicId },
+        select: { uploaded_by: true },
+    });
+    if (!attachment) {
+        reply.code(404).send({ error: "Attachment not found" });
+        return;
+    }
+    // Look up the uploader's API key
+    const user = await hubDb.users.findUnique({
+        where: { id: attachment.uploaded_by },
+        select: { api_key: true },
+    });
+    if (!user?.api_key) {
+        reply.code(500).send({ error: "Cannot authenticate download to hub" });
+        return;
+    }
+    const url = new URL(`/attachments/${publicId}`, hubUrl);
+    return new Promise((resolve, reject) => {
+        const req = https.request(url, {
+            method: "GET",
+            agent: getHubPinnedAgent() ?? undefined,
+            headers: {
+                Authorization: `Bearer ${user.api_key}`,
+            },
+        }, (res) => {
+            if (res.statusCode !== 200) {
+                let body = "";
+                res.on("data", (chunk) => (body += chunk));
+                res.on("end", () => {
+                    reply.code(res.statusCode || 500).send({
+                        error: `Hub download failed: ${body}`,
+                    });
+                    resolve();
+                });
+                return;
+            }
+            // Forward headers from hub
+            if (res.headers["content-disposition"]) {
+                reply.header("content-disposition", res.headers["content-disposition"]);
+            }
+            if (res.headers["content-type"]) {
+                reply.header("content-type", res.headers["content-type"]);
+            }
+            if (res.headers["content-length"]) {
+                reply.header("content-length", res.headers["content-length"]);
+            }
+            reply.send(res);
+            resolve();
+        });
+        req.on("error", (err) => {
+            getLogger().error(err, "Error proxying attachment download");
+            reject(err);
+        });
+        req.end();
+    });
+}
+//# sourceMappingURL=attachmentProxyService.js.map

package/dist/services/browserSocketService.js

@@ -0,0 +1,78 @@
+import { Server as SocketIOServer } from "socket.io";
+import { extractBearerToken } from "@naisys/common-node";
+import { resolveUserFromApiKey, resolveUserFromToken, } from "../auth-middleware.js";
+import { isHubConnected } from "./hubConnectionService.js";
+let io = null;
+export function initBrowserSocket(httpServer, isProd) {
+    io = new SocketIOServer(httpServer, {
+        path: "/api/supervisor/ws",
+        cors: isProd
+            ? undefined
+            : { origin: ["http://localhost:3002"], credentials: true },
+    });
+    // Auth middleware: validate session cookie or API key on handshake
+    io.use(async (socket, next) => {
+        // Try cookie auth
+        const cookieHeader = socket.handshake.headers.cookie;
+        if (cookieHeader) {
+            const token = parseCookie(cookieHeader, "naisys_session");
+            if (token) {
+                const user = await resolveUserFromToken(token);
+                if (user) {
+                    socket.data.user = user;
+                    return next();
+                }
+            }
+        }
+        // Try API key auth
+        const apiKey = extractBearerToken(socket.handshake.headers.authorization);
+        if (apiKey) {
+            const user = await resolveUserFromApiKey(apiKey);
+            if (user) {
+                socket.data.user = user;
+                return next();
+            }
+        }
+        next(new Error("Authentication required"));
+    });
+    io.on("connection", (socket) => {
+        socket.on("subscribe", (data) => {
+            if (typeof data?.room === "string" && isRoomAllowed(data.room)) {
+                void socket.join(data.room);
+                // Send initial hub status when the client subscribes to the room
+                // (not on connect, because the client listener isn't ready yet)
+                if (data.room === "hub-status") {
+                    socket.emit("hub-status", { hubConnected: isHubConnected() });
+                }
+            }
+        });
+        socket.on("unsubscribe", (data) => {
+            if (typeof data?.room === "string") {
+                void socket.leave(data.room);
+            }
+        });
+    });
+}
+export function getIO() {
+    if (!io)
+        throw new Error("Socket.IO not initialized");
+    return io;
+}
+function parseCookie(header, name) {
+    const match = header.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`));
+    return match ? decodeURIComponent(match[1]) : undefined;
+}
+const ALLOWED_ROOM_PREFIXES = [
+    "agent-status",
+    "host-status",
+    "hub-status",
+    "runs:",
+    "logs:",
+    "mail:",
+    "chat-conversations:",
+    "chat-messages:",
+];
+function isRoomAllowed(room) {
+    return ALLOWED_ROOM_PREFIXES.some((prefix) => room === prefix || room.startsWith(prefix));
+}
+//# sourceMappingURL=browserSocketService.js.map

package/dist/services/chatService.js

@@ -0,0 +1,201 @@
+import { hubDb } from "../database/hubDb.js";
+import { getLogger } from "../logger.js";
+import { sendMailViaHub } from "./hubConnectionService.js";
+/**
+ * Get chat conversations for a user, grouped by participants
+ */
+export async function getConversations(userId, page = 1, count = 50) {
+    // Look up the current user's username for filtering
+    const currentUser = await hubDb.users.findUnique({
+        where: { id: userId },
+        select: { username: true },
+    });
+    const currentUsername = currentUser?.username;
+    // Get distinct conversations where this user is a participant
+    const messages = await hubDb.mail_messages.findMany({
+        where: {
+            kind: "chat",
+            participants: { not: "" },
+            OR: [
+                { from_user_id: userId },
+                { recipients: { some: { user_id: userId } } },
+            ],
+        },
+        orderBy: { created_at: "desc" },
+        select: {
+            participants: true,
+            body: true,
+            created_at: true,
+            from_user: { select: { username: true, title: true } },
+            recipients: {
+                where: { user_id: userId },
+                select: { archived_at: true },
+            },
+        },
+    });
+    // Look up titles for all participant usernames
+    const allUsernames = new Set();
+    for (const msg of messages) {
+        for (const name of msg.participants.split(",")) {
+            allUsernames.add(name);
+        }
+    }
+    const users = await hubDb.users.findMany({
+        where: { username: { in: [...allUsernames] } },
+        select: { username: true, title: true },
+    });
+    const titleMap = new Map(users.map((u) => [u.username, u.title]));
+    // Group by participants and take the latest message for each
+    const conversationMap = new Map();
+    for (const msg of messages) {
+        const key = msg.participants;
+        const existing = conversationMap.get(key);
+        if (!existing) {
+            conversationMap.set(key, {
+                lastMessage: msg.body,
+                lastMessageAt: msg.created_at,
+                lastMessageFrom: msg.from_user.username,
+                recipientRecords: [...msg.recipients],
+            });
+        }
+        else {
+            existing.recipientRecords.push(...msg.recipients);
+        }
+    }
+    // participants field already contains usernames, just split
+    const conversations = [];
+    for (const [participants, conv] of conversationMap) {
+        const names = participants.split(",");
+        // Exclude the current user from participant names
+        const participantNames = currentUsername
+            ? names.filter((n) => n !== currentUsername)
+            : names;
+        // Conversation is archived if there are recipient records and all are archived
+        const isArchived = conv.recipientRecords.length > 0 &&
+            conv.recipientRecords.every((r) => r.archived_at !== null);
+        conversations.push({
+            participants,
+            participantNames,
+            participantTitles: participantNames.map((n) => titleMap.get(n) ?? ""),
+            lastMessage: conv.lastMessage,
+            lastMessageAt: conv.lastMessageAt.toISOString(),
+            lastMessageFrom: conv.lastMessageFrom,
+            isArchived,
+        });
+    }
+    // Sort by latest message time (newest first)
+    conversations.sort((a, b) => new Date(b.lastMessageAt).getTime() - new Date(a.lastMessageAt).getTime());
+    const total = conversations.length;
+    const start = (page - 1) * count;
+    const paginated = conversations.slice(start, start + count);
+    return { conversations: paginated, total };
+}
+/**
+ * Get chat messages for a specific conversation
+ */
+export async function getMessages(participants, updatedSince, page = 1, count = 50) {
+    const whereClause = {
+        kind: "chat",
+        participants,
+    };
+    if (updatedSince) {
+        whereClause.created_at = { gte: updatedSince };
+    }
+    // Only get total on initial fetch
+    const total = updatedSince
+        ? undefined
+        : await hubDb.mail_messages.count({ where: whereClause });
+    const dbMessages = await hubDb.mail_messages.findMany({
+        where: whereClause,
+        orderBy: { id: "desc" },
+        skip: (page - 1) * count,
+        take: count,
+        select: {
+            id: true,
+            from_user_id: true,
+            body: true,
+            created_at: true,
+            from_user: { select: { username: true, title: true } },
+            recipients: {
+                select: { user_id: true, read_at: true, type: true },
+            },
+            mail_attachments: {
+                include: {
+                    attachment: {
+                        select: { public_id: true, filename: true, file_size: true },
+                    },
+                },
+            },
+        },
+    });
+    const messages = dbMessages.map((msg) => {
+        const readByIds = msg.recipients
+            .filter((r) => r.read_at !== null && r.type !== "from")
+            .map((r) => r.user_id);
+        return {
+            id: msg.id,
+            fromUserId: msg.from_user_id,
+            fromUsername: msg.from_user.username,
+            fromTitle: msg.from_user.title,
+            body: msg.body,
+            createdAt: msg.created_at.toISOString(),
+            attachments: msg.mail_attachments.length > 0
+                ? msg.mail_attachments.map((ma) => ({
+                    id: ma.attachment.public_id,
+                    filename: ma.attachment.filename,
+                    fileSize: ma.attachment.file_size,
+                }))
+                : undefined,
+            readBy: readByIds.length > 0 ? readByIds : undefined,
+        };
+    });
+    return {
+        messages,
+        total,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Archive all chat messages where the user is a recipient
+ */
+export async function archiveAllChatMessages(userId) {
+    const result = await hubDb.mail_recipients.updateMany({
+        where: {
+            user_id: userId,
+            archived_at: null,
+            message: {
+                kind: "chat",
+            },
+        },
+        data: {
+            archived_at: new Date(),
+        },
+    });
+    return result.count;
+}
+/**
+ * Send a chat message via the hub
+ */
+export async function sendChatMessage(fromId, toIds, message, attachmentIds) {
+    try {
+        const cleanMessage = message.replace(/\\n/g, "\n");
+        const response = await sendMailViaHub(fromId, toIds, "", cleanMessage, "chat", attachmentIds);
+        if (response.success) {
+            return { success: true, message: "Chat message sent" };
+        }
+        else {
+            return {
+                success: false,
+                message: response.error || "Failed to send chat message",
+            };
+        }
+    }
+    catch (error) {
+        getLogger().error(error, "Error sending chat message");
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : "Failed to send chat message",
+        };
+    }
+}
+//# sourceMappingURL=chatService.js.map

package/dist/services/configExportService.js

@@ -0,0 +1,61 @@
+import { dbFieldsToImageModel, dbFieldsToLlmModel, } from "@naisys/common";
+import yaml from "js-yaml";
+function toKebabCase(str) {
+    return str
+        .trim()
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .replace(/[^a-z0-9-]/gi, "")
+        .toLowerCase();
+}
+function agentFileName(user) {
+    return toKebabCase(user.title || user.username);
+}
+export function buildExportFiles(users, variables, modelRows) {
+    const files = [];
+    // --- Agents ---
+    const activeUsers = users.filter((u) => u.username !== "admin" && !u.archived);
+    const userById = new Map(activeUsers.map((u) => [u.id, u]));
+    // Walk up ancestor chain to build full directory path
+    function agentDirPath(user) {
+        const segments = [];
+        let current = user.lead_user_id
+            ? userById.get(user.lead_user_id)
+            : undefined;
+        while (current) {
+            segments.unshift(agentFileName(current));
+            current = current.lead_user_id
+                ? userById.get(current.lead_user_id)
+                : undefined;
+        }
+        return ["agents", ...segments].join("/");
+    }
+    for (const user of activeUsers) {
+        const filePath = `${agentDirPath(user)}/${agentFileName(user)}.yaml`;
+        const configObj = JSON.parse(user.config);
+        const configYaml = yaml.dump(configObj, { lineWidth: -1 });
+        files.push({ path: filePath, content: configYaml });
+    }
+    // --- Variables ---
+    if (variables.length > 0) {
+        const envContent = variables.map((v) => `${v.key}=${v.value}`).join("\n");
+        files.push({ path: ".env", content: envContent + "\n" });
+    }
+    // --- Custom models ---
+    const customModels = modelRows.filter((r) => r.is_custom);
+    if (customModels.length > 0) {
+        const llmRows = customModels.filter((r) => r.type === "llm");
+        const imageRows = customModels.filter((r) => r.type === "image");
+        const output = {};
+        if (llmRows.length > 0) {
+            output.llmModels = llmRows.map(dbFieldsToLlmModel);
+        }
+        if (imageRows.length > 0) {
+            output.imageModels = imageRows.map(dbFieldsToImageModel);
+        }
+        const yamlStr = yaml.dump(output, { lineWidth: -1 });
+        files.push({ path: "custom-models.yaml", content: yamlStr });
+    }
+    return files;
+}
+//# sourceMappingURL=configExportService.js.map

package/dist/services/costsService.js

@@ -0,0 +1,127 @@
+import { hubDb } from "../database/hubDb.js";
+export async function getSpendLimitSettings() {
+    const vars = await hubDb.variables.findMany({
+        where: { key: { in: ["SPEND_LIMIT_DOLLARS", "SPEND_LIMIT_HOURS"] } },
+    });
+    const dollarsVar = vars.find((v) => v.key === "SPEND_LIMIT_DOLLARS");
+    const hoursVar = vars.find((v) => v.key === "SPEND_LIMIT_HOURS");
+    return {
+        spendLimitDollars: dollarsVar ? parseFloat(dollarsVar.value) || null : null,
+        spendLimitHours: hoursVar ? parseFloat(hoursVar.value) || null : null,
+    };
+}
+/** Find the lead user and all subordinates recursively */
+export async function findUserIdsForLead(leadUsername) {
+    const leadUser = await hubDb.users.findUnique({
+        where: { username: leadUsername },
+        select: { id: true },
+    });
+    if (!leadUser)
+        return [];
+    const allUsers = await hubDb.users.findMany({
+        select: { id: true, lead_user_id: true },
+    });
+    const result = [leadUser.id];
+    function collect(parentId) {
+        for (const user of allUsers) {
+            if (user.lead_user_id === parentId) {
+                result.push(user.id);
+                collect(user.id);
+            }
+        }
+    }
+    collect(leadUser.id);
+    return result;
+}
+export async function getCostHistogram(start, end, bucketHours, userIds) {
+    const where = {
+        created_at: { gte: start, lte: end },
+    };
+    if (userIds) {
+        where.user_id = { in: userIds };
+    }
+    const costs = await hubDb.costs.findMany({
+        where,
+        select: {
+            cost: true,
+            created_at: true,
+            user_id: true,
+        },
+        orderBy: { created_at: "asc" },
+    });
+    // Collect unique user IDs and resolve usernames
+    const costUserIds = new Set(costs.map((c) => c.user_id));
+    const users = costUserIds.size > 0
+        ? await hubDb.users.findMany({
+            where: { id: { in: Array.from(costUserIds) } },
+            select: { id: true, username: true },
+        })
+        : [];
+    const userMap = new Map(users.map((u) => [u.id, u.username]));
+    // Build buckets
+    const bucketMs = bucketHours * 60 * 60 * 1000;
+    const startMs = start.getTime();
+    const endMs = end.getTime();
+    const buckets = [];
+    for (let bucketStart = startMs; bucketStart < endMs; bucketStart += bucketMs) {
+        const bucketEnd = Math.min(bucketStart + bucketMs, endMs);
+        buckets.push({
+            start: new Date(bucketStart).toISOString(),
+            end: new Date(bucketEnd).toISOString(),
+            cost: 0,
+            byAgent: {},
+        });
+    }
+    // Fill buckets with costs
+    for (const cost of costs) {
+        const costMs = cost.created_at.getTime();
+        const bucketIndex = Math.floor((costMs - startMs) / bucketMs);
+        if (bucketIndex >= 0 && bucketIndex < buckets.length) {
+            const amount = cost.cost ?? 0;
+            buckets[bucketIndex].cost += amount;
+            const username = userMap.get(cost.user_id) ?? `user-${cost.user_id}`;
+            buckets[bucketIndex].byAgent[username] =
+                (buckets[bucketIndex].byAgent[username] ?? 0) + amount;
+        }
+    }
+    return buckets;
+}
+export async function getCostsByAgent(start, end, userIds) {
+    const where = {
+        created_at: { gte: start, lte: end },
+    };
+    if (userIds) {
+        where.user_id = { in: userIds };
+    }
+    const costs = await hubDb.costs.findMany({
+        where,
+        select: {
+            cost: true,
+            user_id: true,
+        },
+    });
+    // Aggregate by user_id
+    const byUserId = new Map();
+    for (const c of costs) {
+        byUserId.set(c.user_id, (byUserId.get(c.user_id) ?? 0) + (c.cost ?? 0));
+    }
+    if (byUserId.size === 0)
+        return [];
+    // Look up usernames
+    const users = await hubDb.users.findMany({
+        where: { id: { in: Array.from(byUserId.keys()) } },
+        select: { id: true, username: true, title: true },
+    });
+    const userMap = new Map(users.map((u) => [u.id, { username: u.username, title: u.title }]));
+    return Array.from(byUserId.entries())
+        .map(([userId, cost]) => {
+        const user = userMap.get(userId);
+        return {
+            username: user?.username ?? `user-${userId}`,
+            title: user?.title ?? "",
+            cost: Math.round(cost * 100) / 100,
+        };
+    })
+        .sort((a, b) => b.cost - a.cost);
+}
+//# sourceMappingURL=costsService.js.map