@naisys/hub 3.0.0-beta.6

package/dist/handlers/hubMailService.js

@@ -0,0 +1,397 @@
+import { HubEvents, MailArchiveRequestSchema, MailListRequestSchema, MailMarkReadRequestSchema, MailPeekRequestSchema, MailSearchRequestSchema, MailSendRequestSchema, MailUnreadRequestSchema, } from "@naisys/hub-protocol";
+const MAIL_AUTOSTART_CHECK_INTERVAL_MS = 10_000;
+/** Handles mail events from NAISYS instances */
+export function createHubMailService(naisysServer, { hubDb }, logService, heartbeatService, sendMailService, agentService, costService, configService) {
+    /** Check for inactive users with unread mail and trigger auto-start for each */
+    async function checkPendingAutoStarts() {
+        try {
+            const config = configService.getConfig();
+            if (!config.success || !config.config?.autoStartAgentsOnMessage)
+                return;
+            const activeUserIds = heartbeatService.getActiveUserIds();
+            // Find distinct users with unread mail (exclude 'from' type - senders pre-mark as read)
+            const unreadRecipients = await hubDb.mail_recipients.findMany({
+                where: {
+                    read_at: null,
+                    type: { not: "from" },
+                    user: { enabled: true, archived: false },
+                },
+                select: {
+                    user_id: true,
+                },
+                distinct: ["user_id"],
+            });
+            const inactiveUserIds = unreadRecipients
+                .map((recipient) => recipient.user_id)
+                .filter((userId) => !activeUserIds.has(userId));
+            if (inactiveUserIds.length === 0)
+                return;
+            await costService.checkSpendLimits(inactiveUserIds);
+            for (const userId of inactiveUserIds) {
+                if (heartbeatService.getActiveUserIds().has(userId))
+                    continue;
+                if (costService.isUserSpendSuspended(userId))
+                    continue;
+                void agentService.tryStartAgent(userId);
+            }
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] Auto-start check failed: ${error}`);
+        }
+    }
+    // When a NAISYS host connects, check for pending unread mail and auto-start agents
+    naisysServer.registerEvent(HubEvents.CLIENT_CONNECTED, (_hostId, connection) => {
+        if (connection.getHostType() === "naisys") {
+            void checkPendingAutoStarts();
+        }
+    });
+    const pendingAutoStartInterval = setInterval(() => void checkPendingAutoStarts(), MAIL_AUTOSTART_CHECK_INTERVAL_MS);
+    // MAIL_SEND
+    naisysServer.registerEvent(HubEvents.MAIL_SEND, async (hostId, data, ack) => {
+        try {
+            const parsed = MailSendRequestSchema.parse(data);
+            await sendMailService.sendMail({
+                fromUserId: parsed.fromUserId,
+                recipientUserIds: parsed.toUserIds,
+                subject: parsed.subject,
+                body: parsed.body,
+                kind: parsed.kind,
+                hostId,
+                attachmentIds: parsed.attachmentIds,
+            });
+            ack({ success: true });
+            void checkPendingAutoStarts();
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_send error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    // MAIL_LIST
+    naisysServer.registerEvent(HubEvents.MAIL_LIST, async (hostId, data, ack) => {
+        try {
+            const parsed = MailListRequestSchema.parse(data);
+            // Build ownership condition based on filter
+            let ownershipCondition;
+            if (parsed.withUserIds?.length) {
+                // Messages between exactly this group of participants
+                const allUserIds = [...new Set([parsed.userId, ...parsed.withUserIds])];
+                const users = await hubDb.users.findMany({
+                    where: { id: { in: allUserIds } },
+                    select: { username: true },
+                });
+                const participants = users
+                    .map((u) => u.username)
+                    .sort()
+                    .join(",");
+                ownershipCondition = { participants };
+            }
+            else if (parsed.filter === "received") {
+                ownershipCondition = {
+                    recipients: { some: { user_id: parsed.userId } },
+                };
+            }
+            else if (parsed.filter === "sent") {
+                ownershipCondition = { from_user_id: parsed.userId };
+            }
+            else {
+                ownershipCondition = {
+                    OR: [
+                        { from_user_id: parsed.userId },
+                        { recipients: { some: { user_id: parsed.userId } } },
+                    ],
+                };
+            }
+            const messages = await hubDb.mail_messages.findMany({
+                where: {
+                    ...ownershipCondition,
+                    kind: parsed.kind,
+                    NOT: {
+                        recipients: {
+                            some: {
+                                user_id: parsed.userId,
+                                archived_at: { not: null },
+                            },
+                        },
+                    },
+                },
+                include: {
+                    from_user: { select: { username: true, title: true } },
+                    recipients: {
+                        include: { user: { select: { username: true } } },
+                    },
+                    mail_attachments: {
+                        include: {
+                            attachment: {
+                                select: { public_id: true, filename: true, file_size: true },
+                            },
+                        },
+                    },
+                },
+                orderBy: { created_at: "desc" },
+                skip: parsed.skip,
+                take: parsed.take ?? 20,
+            });
+            const messageData = messages.map((m) => {
+                const myRecipient = m.recipients.find((r) => r.user_id === parsed.userId && r.type !== "from");
+                const isUnread = m.from_user_id !== parsed.userId && !myRecipient?.read_at;
+                return {
+                    id: m.id,
+                    fromUsername: m.from_user.username,
+                    fromTitle: m.from_user.title,
+                    recipientUsernames: m.recipients
+                        .filter((r) => r.type !== "from")
+                        .map((r) => r.user.username),
+                    subject: m.subject,
+                    createdAt: m.created_at.toISOString(),
+                    isUnread,
+                    ...(parsed.kind === "chat" ? { body: m.body } : {}),
+                    attachments: m.mail_attachments.length
+                        ? m.mail_attachments.map((ma) => ({
+                            id: ma.attachment.public_id,
+                            filename: ma.attachment.filename,
+                            fileSize: ma.attachment.file_size,
+                        }))
+                        : undefined,
+                };
+            });
+            ack({ success: true, messages: messageData });
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_list error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    // MAIL_PEEK
+    naisysServer.registerEvent(HubEvents.MAIL_PEEK, async (hostId, data, ack) => {
+        try {
+            const parsed = MailPeekRequestSchema.parse(data);
+            const message = await hubDb.mail_messages.findUnique({
+                where: { id: parsed.messageId },
+                include: {
+                    from_user: { select: { username: true, title: true } },
+                    recipients: {
+                        include: { user: { select: { username: true } } },
+                    },
+                    mail_attachments: {
+                        include: {
+                            attachment: {
+                                select: { public_id: true, filename: true, file_size: true },
+                            },
+                        },
+                    },
+                },
+            });
+            if (!message) {
+                ack({
+                    success: false,
+                    error: `Message ${parsed.messageId} not found`,
+                });
+                return;
+            }
+            ack({
+                success: true,
+                message: {
+                    id: message.id,
+                    subject: message.subject,
+                    fromUsername: message.from_user.username,
+                    fromTitle: message.from_user.title,
+                    recipientUsernames: message.recipients
+                        .filter((r) => r.type !== "from")
+                        .map((r) => r.user.username),
+                    createdAt: message.created_at.toISOString(),
+                    body: message.body,
+                    attachments: message.mail_attachments.length
+                        ? message.mail_attachments.map((ma) => ({
+                            id: ma.attachment.public_id,
+                            filename: ma.attachment.filename,
+                            fileSize: ma.attachment.file_size,
+                        }))
+                        : undefined,
+                },
+            });
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_peek error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    // MAIL_MARK_READ
+    naisysServer.registerEvent(HubEvents.MAIL_MARK_READ, async (hostId, data, ack) => {
+        try {
+            const parsed = MailMarkReadRequestSchema.parse(data);
+            const result = await hubDb.mail_recipients.updateMany({
+                where: {
+                    message_id: { in: parsed.messageIds },
+                    user_id: parsed.userId,
+                    read_at: null,
+                },
+                data: { read_at: new Date() },
+            });
+            ack({ success: true });
+            // Push read receipts to supervisor connections
+            if (result.count > 0) {
+                const messages = await hubDb.mail_messages.findMany({
+                    where: { id: { in: parsed.messageIds } },
+                    select: { participants: true },
+                });
+                // participants is like the room id, we broadcast to all rooms the read message ids
+                // It's ok if the specific message id is not in the room, the client will ignore it
+                const participants = [
+                    ...new Set(messages.map((m) => m.participants)),
+                ];
+                const payload = {
+                    messageIds: parsed.messageIds,
+                    userId: parsed.userId,
+                    kind: parsed.kind,
+                    participants,
+                };
+                naisysServer.broadcastToSupervisors(HubEvents.MAIL_READ_PUSH, payload);
+            }
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_mark_read error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    // MAIL_ARCHIVE
+    naisysServer.registerEvent(HubEvents.MAIL_ARCHIVE, async (hostId, data, ack) => {
+        try {
+            const parsed = MailArchiveRequestSchema.parse(data);
+            const archivedIds = [];
+            for (const messageId of parsed.messageIds) {
+                const message = await hubDb.mail_messages.findUnique({
+                    where: { id: messageId },
+                });
+                if (!message) {
+                    ack({
+                        success: false,
+                        error: `Message ${messageId} not found`,
+                    });
+                    return;
+                }
+                await hubDb.mail_recipients.updateMany({
+                    where: { message_id: message.id, user_id: parsed.userId },
+                    data: { archived_at: new Date() },
+                });
+                archivedIds.push(messageId);
+            }
+            ack({ success: true, archivedIds });
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_archive error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    // MAIL_SEARCH
+    naisysServer.registerEvent(HubEvents.MAIL_SEARCH, async (hostId, data, ack) => {
+        try {
+            const parsed = MailSearchRequestSchema.parse(data);
+            const searchCondition = parsed.subjectOnly
+                ? { subject: { contains: parsed.terms } }
+                : {
+                    OR: [
+                        { subject: { contains: parsed.terms } },
+                        { body: { contains: parsed.terms } },
+                    ],
+                };
+            const archiveCondition = parsed.includeArchived
+                ? {}
+                : {
+                    NOT: {
+                        recipients: {
+                            some: {
+                                user_id: parsed.userId,
+                                archived_at: { not: null },
+                            },
+                        },
+                    },
+                };
+            const messages = await hubDb.mail_messages.findMany({
+                where: {
+                    OR: [
+                        { from_user_id: parsed.userId },
+                        { recipients: { some: { user_id: parsed.userId } } },
+                    ],
+                    ...searchCondition,
+                    ...archiveCondition,
+                },
+                include: {
+                    from_user: { select: { username: true } },
+                },
+                orderBy: { created_at: "desc" },
+                take: 50,
+            });
+            const messageData = messages.map((m) => ({
+                id: m.id,
+                subject: m.subject,
+                fromUsername: m.from_user.username,
+                createdAt: m.created_at.toISOString(),
+            }));
+            ack({ success: true, messages: messageData });
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_search error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    // MAIL_UNREAD
+    naisysServer.registerEvent(HubEvents.MAIL_UNREAD, async (hostId, data, ack) => {
+        try {
+            const parsed = MailUnreadRequestSchema.parse(data);
+            const messages = await hubDb.mail_messages.findMany({
+                where: {
+                    kind: parsed.kind,
+                    ...(parsed.afterId ? { id: { gt: parsed.afterId } } : {}),
+                    recipients: {
+                        some: { user_id: parsed.userId, read_at: null },
+                    },
+                },
+                include: {
+                    from_user: { select: { username: true, title: true } },
+                    recipients: {
+                        include: { user: { select: { username: true } } },
+                    },
+                    mail_attachments: {
+                        include: {
+                            attachment: {
+                                select: { public_id: true, filename: true, file_size: true },
+                            },
+                        },
+                    },
+                },
+                orderBy: { id: "asc" },
+            });
+            ack({
+                success: true,
+                messages: messages.map((m) => ({
+                    id: m.id,
+                    subject: m.subject,
+                    fromUsername: m.from_user.username,
+                    fromTitle: m.from_user.title,
+                    recipientUsernames: m.recipients
+                        .filter((r) => r.type !== "from")
+                        .map((r) => r.user.username),
+                    createdAt: m.created_at.toISOString(),
+                    body: m.body,
+                    attachments: m.mail_attachments.length
+                        ? m.mail_attachments.map((ma) => ({
+                            id: ma.attachment.public_id,
+                            filename: ma.attachment.filename,
+                            fileSize: ma.attachment.file_size,
+                        }))
+                        : undefined,
+                })),
+            });
+        }
+        catch (error) {
+            logService.error(`[Hub:Mail] mail_unread error from host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    function cleanup() {
+        clearInterval(pendingAutoStartInterval);
+    }
+    return { cleanup };
+}
+//# sourceMappingURL=hubMailService.js.map

package/dist/handlers/hubModelsService.js

@@ -0,0 +1,106 @@
+import { builtInImageModels, builtInLlmModels, dbFieldsToImageModel, dbFieldsToLlmModel, imageModelToDbFields, llmModelToDbFields, } from "@naisys/common";
+import { loadCustomModels } from "@naisys/common-node";
+import { HubEvents } from "@naisys/hub-protocol";
+/** Hub handler that seeds models on startup, pushes them on connect, and broadcasts on change */
+export async function createHubModelsService(naisysServer, { hubDb }, logService) {
+    // Seed models table from built-in + YAML custom models (one-time, skips if non-empty)
+    await seedModels(hubDb, logService);
+    async function buildModelsPayload() {
+        const rows = (await hubDb.models.findMany());
+        const llmModels = rows
+            .filter((r) => r.type === "llm")
+            .map((r) => dbFieldsToLlmModel(r));
+        const imageModels = rows
+            .filter((r) => r.type === "image")
+            .map((r) => dbFieldsToImageModel(r));
+        return { success: true, llmModels, imageModels };
+    }
+    async function broadcastModels() {
+        try {
+            const payload = await buildModelsPayload();
+            logService.log(`[Hub:Models] Broadcasting ${payload.llmModels?.length ?? 0} LLM + ${payload.imageModels?.length ?? 0} image models to all clients`);
+            naisysServer.broadcastToAll(HubEvents.MODELS_UPDATED, payload);
+        }
+        catch (error) {
+            logService.error(`[Hub:Models] Error broadcasting models: ${error}`);
+        }
+    }
+    // Push models to newly connected clients
+    naisysServer.registerEvent(HubEvents.CLIENT_CONNECTED, async (hostId, connection) => {
+        try {
+            const payload = await buildModelsPayload();
+            logService.log(`[Hub:Models] Pushing ${payload.llmModels?.length ?? 0} LLM + ${payload.imageModels?.length ?? 0} image models to instance ${hostId}`);
+            connection.sendMessage(HubEvents.MODELS_UPDATED, payload);
+        }
+        catch (error) {
+            logService.error(`[Hub:Models] Error querying models for instance ${hostId}: ${error}`);
+            connection.sendMessage(HubEvents.MODELS_UPDATED, {
+                success: false,
+                error: String(error),
+            });
+        }
+    });
+    // Broadcast models to all clients when supervisor saves/deletes a model
+    naisysServer.registerEvent(HubEvents.MODELS_CHANGED, async () => {
+        await broadcastModels();
+    });
+}
+/** Seeds models table from built-in models + any YAML custom models.
+ *  Built-in models are upserted on every startup unless the user has customized them.
+ *  YAML custom models are only imported on first run (empty table). */
+async function seedModels(hubDb, logService) {
+    const existingRows = (await hubDb.models.findMany());
+    const isFirstRun = existingRows.length === 0;
+    // Upsert built-in models that haven't been customized
+    const builtInFields = [
+        ...builtInLlmModels.map((m) => llmModelToDbFields(m, true, false)),
+        ...builtInImageModels.map((m) => imageModelToDbFields(m, true, false)),
+    ];
+    for (const fields of builtInFields) {
+        const existing = existingRows.find((r) => r.key === fields.key);
+        if (existing?.is_custom) {
+            // User has customized this built-in model, don't overwrite
+            continue;
+        }
+        if (existing) {
+            await hubDb.models.update({ where: { key: fields.key }, data: fields });
+        }
+        else {
+            await hubDb.models.create({ data: fields });
+        }
+    }
+    // Import YAML custom models only on first run (migration from file-based storage)
+    if (isFirstRun) {
+        const custom = loadCustomModels(process.env.NAISYS_FOLDER || "");
+        const customRows = [];
+        for (const m of custom.llmModels ?? []) {
+            const isBuiltin = builtInLlmModels.some((b) => b.key === m.key);
+            const fields = llmModelToDbFields(m, isBuiltin, true);
+            if (isBuiltin) {
+                // Override the built-in row we just inserted
+                await hubDb.models.update({ where: { key: m.key }, data: fields });
+            }
+            else {
+                customRows.push(fields);
+            }
+        }
+        for (const m of custom.imageModels ?? []) {
+            const isBuiltin = builtInImageModels.some((b) => b.key === m.key);
+            const fields = imageModelToDbFields(m, isBuiltin, true);
+            if (isBuiltin) {
+                await hubDb.models.update({ where: { key: m.key }, data: fields });
+            }
+            else {
+                customRows.push(fields);
+            }
+        }
+        if (customRows.length > 0) {
+            await hubDb.models.createMany({ data: customRows });
+        }
+        logService.log(`[Hub:Models] First run: imported ${(custom.llmModels?.length ?? 0) + (custom.imageModels?.length ?? 0)} custom models from YAML`);
+    }
+    else {
+        logService.log(`[Hub:Models] Models already seeded`);
+    }
+}
+//# sourceMappingURL=hubModelsService.js.map

package/dist/handlers/hubRunService.js

@@ -0,0 +1,96 @@
+import { HubEvents, SessionCreateRequestSchema, SessionIncrementRequestSchema, } from "@naisys/hub-protocol";
+/** Handles session_create and session_increment requests from NAISYS instances */
+export function createHubRunService(naisysServer, { hubDb }, logService) {
+    function pushSessionToSupervisors(session) {
+        naisysServer.broadcastToSupervisors(HubEvents.SESSION_PUSH, {
+            session: {
+                ...session,
+                latestLogId: 0,
+                totalLines: 0,
+                totalCost: 0,
+            },
+        });
+    }
+    naisysServer.registerEvent(HubEvents.SESSION_CREATE, async (hostId, data, ack) => {
+        try {
+            const parsed = SessionCreateRequestSchema.parse(data);
+            // Get the last run_id across all sessions
+            const lastRun = await hubDb.run_session.findFirst({
+                select: { run_id: true },
+                orderBy: { run_id: "desc" },
+            });
+            const newRunId = lastRun ? lastRun.run_id + 1 : 1;
+            const newSessionId = 1;
+            const now = new Date().toISOString();
+            await hubDb.run_session.create({
+                data: {
+                    user_id: parsed.userId,
+                    run_id: newRunId,
+                    session_id: newSessionId,
+                    host_id: hostId,
+                    model_name: parsed.modelName,
+                    created_at: now,
+                    last_active: now,
+                },
+            });
+            ack({
+                success: true,
+                runId: newRunId,
+                sessionId: newSessionId,
+            });
+            pushSessionToSupervisors({
+                userId: parsed.userId,
+                runId: newRunId,
+                sessionId: newSessionId,
+                modelName: parsed.modelName,
+                createdAt: now,
+                lastActive: now,
+            });
+        }
+        catch (error) {
+            logService.error(`[Hub:Runs] session_create error for host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+    naisysServer.registerEvent(HubEvents.SESSION_INCREMENT, async (hostId, data, ack) => {
+        try {
+            const parsed = SessionIncrementRequestSchema.parse(data);
+            // Get the max session_id for this user + run
+            const lastSession = await hubDb.run_session.findFirst({
+                select: { session_id: true },
+                where: {
+                    user_id: parsed.userId,
+                    run_id: parsed.runId,
+                },
+                orderBy: { session_id: "desc" },
+            });
+            const newSessionId = lastSession ? lastSession.session_id + 1 : 1;
+            const now = new Date().toISOString();
+            await hubDb.run_session.create({
+                data: {
+                    user_id: parsed.userId,
+                    run_id: parsed.runId,
+                    session_id: newSessionId,
+                    host_id: hostId,
+                    model_name: parsed.modelName,
+                    created_at: now,
+                    last_active: now,
+                },
+            });
+            ack({ success: true, sessionId: newSessionId });
+            pushSessionToSupervisors({
+                userId: parsed.userId,
+                runId: parsed.runId,
+                sessionId: newSessionId,
+                modelName: parsed.modelName,
+                createdAt: now,
+                lastActive: now,
+            });
+        }
+        catch (error) {
+            logService.error(`[Hub:Runs] session_increment error for host ${hostId}: ${error}`);
+            ack({ success: false, error: String(error) });
+        }
+    });
+}
+//# sourceMappingURL=hubRunService.js.map