@naisys/supervisor 3.0.0-beta.6

package/dist/services/agentConfigService.js

@@ -0,0 +1,182 @@
+import { AgentConfigFileSchema, assertUrlSafeKey, buildDefaultAgentConfig, } from "@naisys/common";
+import { randomBytes } from "crypto";
+import { hubDb } from "../database/hubDb.js";
+import { sendUserListChanged } from "./hubConnectionService.js";
+/**
+ * Update the modified date on the user_notifications table
+ */
+async function updateUserNotificationModifiedDate(userId) {
+    await hubDb.user_notifications.upsert({
+        where: { user_id: userId },
+        create: {
+            user_id: userId,
+            updated_at: new Date(),
+        },
+        update: {
+            updated_at: new Date(),
+        },
+    });
+}
+/**
+ * Create a new agent with database entry.
+ */
+export async function createAgentConfig(name, title) {
+    assertUrlSafeKey(name, "Agent name");
+    // Check db if username already exists
+    const existingAgent = await hubDb.users.findFirst({
+        where: {
+            username: name,
+        },
+    });
+    if (existingAgent) {
+        throw new Error(`Agent '${name}' already exists in the database`);
+    }
+    // Create default config and convert to JSON
+    const defaultConfig = buildDefaultAgentConfig(name);
+    if (title) {
+        defaultConfig.title = title;
+    }
+    const jsonContent = JSON.stringify(canonicalConfigOrder(defaultConfig));
+    // Add agent to the database, let DB autoincrement
+    const user = await hubDb.users.create({
+        data: {
+            uuid: crypto.randomUUID(),
+            username: defaultConfig.username,
+            title: defaultConfig.title,
+            config: jsonContent,
+            api_key: randomBytes(32).toString("hex"),
+            enabled: true,
+        },
+    });
+    // Update user notification modified date
+    await updateUserNotificationModifiedDate(user.id);
+    // Notify hub to broadcast updated user list to all NAISYS clients
+    sendUserListChanged();
+    return { id: user.id, config: defaultConfig };
+}
+/**
+ * Get parsed agent configuration by user ID. Reads from DB config column.
+ */
+export async function getAgentConfigById(id) {
+    const user = await hubDb.users.findUnique({
+        where: { id },
+        select: { config: true },
+    });
+    if (!user) {
+        throw new Error(`User with ID ${id} not found`);
+    }
+    const parsed = JSON.parse(user.config);
+    return AgentConfigFileSchema.parse(parsed);
+}
+/**
+ * Build config object in canonical field order for consistent JSON output.
+ */
+function canonicalConfigOrder(config) {
+    const ordered = {};
+    // Identity
+    ordered.username = config.username;
+    ordered.title = config.title;
+    // Prompt
+    ordered.agentPrompt = config.agentPrompt;
+    // Models
+    ordered.shellModel = config.shellModel;
+    if (config.imageModel !== undefined)
+        ordered.imageModel = config.imageModel;
+    // Limits
+    ordered.tokenMax = config.tokenMax;
+    if (config.spendLimitDollars !== undefined)
+        ordered.spendLimitDollars = config.spendLimitDollars;
+    if (config.spendLimitHours !== undefined)
+        ordered.spendLimitHours = config.spendLimitHours;
+    // Features
+    if (config.mailEnabled !== undefined)
+        ordered.mailEnabled = config.mailEnabled;
+    if (config.chatEnabled !== undefined)
+        ordered.chatEnabled = config.chatEnabled;
+    if (config.webEnabled !== undefined)
+        ordered.webEnabled = config.webEnabled;
+    if (config.completeSessionEnabled !== undefined)
+        ordered.completeSessionEnabled = config.completeSessionEnabled;
+    if (config.wakeOnMessage !== undefined)
+        ordered.wakeOnMessage = config.wakeOnMessage;
+    if (config.workspacesEnabled !== undefined)
+        ordered.workspacesEnabled = config.workspacesEnabled;
+    if (config.multipleCommandsEnabled !== undefined)
+        ordered.multipleCommandsEnabled = config.multipleCommandsEnabled;
+    if (config.controlDesktop !== undefined)
+        ordered.controlDesktop = config.controlDesktop;
+    // Advanced
+    if (config.commandProtection !== undefined)
+        ordered.commandProtection = config.commandProtection;
+    if (config.debugPauseSeconds !== undefined)
+        ordered.debugPauseSeconds = config.debugPauseSeconds;
+    if (config.initialCommands !== undefined)
+        ordered.initialCommands = config.initialCommands;
+    return ordered;
+}
+/**
+ * Update agent configuration by user ID. Always updates DB.
+ * Snapshots the previous config as a revision before overwriting.
+ */
+export async function updateAgentConfigById(id, config, setUsername, changedById) {
+    // Snapshot the current config before overwriting
+    const currentUser = await hubDb.users.findUnique({
+        where: { id },
+        select: { config: true },
+    });
+    if (setUsername) {
+        // Normal edit: push config.username to the DB column
+    }
+    else {
+        // Import: preserve the DB username, override it in the config
+        const user = await hubDb.users.findUnique({ where: { id } });
+        if (user) {
+            config = { ...config, username: user.username };
+        }
+    }
+    const ordered = canonicalConfigOrder(config);
+    const jsonStr = JSON.stringify(ordered);
+    // Save revision of the old config (if it exists and differs)
+    if (currentUser?.config && currentUser.config !== jsonStr) {
+        await hubDb.config_revisions.create({
+            data: {
+                user_id: id,
+                config: currentUser.config,
+                changed_by_id: changedById ?? id,
+            },
+        });
+    }
+    await hubDb.users.update({
+        where: { id },
+        data: {
+            config: jsonStr,
+            ...(setUsername && { username: config.username }),
+            title: config.title,
+        },
+    });
+    // Update user notification modified date
+    await updateUserNotificationModifiedDate(id);
+    // Notify hub to broadcast updated user list to all NAISYS clients
+    sendUserListChanged();
+    return config;
+}
+/**
+ * Get config revision history for an agent.
+ */
+export async function getConfigRevisions(userId, limit = 50) {
+    const revisions = await hubDb.config_revisions.findMany({
+        where: { user_id: userId },
+        orderBy: { created_at: "desc" },
+        take: limit,
+        include: {
+            changed_by: { select: { username: true } },
+        },
+    });
+    return revisions.map((r) => ({
+        id: r.id,
+        config: r.config,
+        changedByUsername: r.changed_by.username,
+        createdAt: r.created_at,
+    }));
+}
+//# sourceMappingURL=agentConfigService.js.map

package/dist/services/agentHostStatusService.js

@@ -0,0 +1,178 @@
+import { determineAgentStatus } from "@naisys/common";
+import { getIO } from "./browserSocketService.js";
+const activeAgentIds = new Set();
+const disabledAgentIds = new Set();
+const costSuspendedAgentIds = new Set();
+const connectedHostIds = new Set();
+const agentNotifications = new Map();
+const hostOnlineStatus = new Map();
+const hostRestrictedStatus = new Map();
+const hostTypeStatus = new Map();
+const agentHostAssignments = new Map();
+function broadcast(room, event) {
+    try {
+        getIO().to(room).emit(room, event);
+    }
+    catch {
+        // Socket.IO not yet initialized during startup — safe to ignore
+    }
+}
+function broadcastAgentStatus(event) {
+    broadcast("agent-status", event);
+}
+function broadcastHostStatus(event) {
+    broadcast("host-status", event);
+}
+// --- Mutation functions (called by hubConnectionService event handlers) ---
+export function updateAgentsStatus(hostActiveAgents, notifications) {
+    activeAgentIds.clear();
+    connectedHostIds.clear();
+    for (const [hostId, userIds] of Object.entries(hostActiveAgents)) {
+        connectedHostIds.add(Number(hostId));
+        for (const id of userIds) {
+            activeAgentIds.add(id);
+        }
+    }
+    if (notifications) {
+        for (const [key, value] of Object.entries(notifications)) {
+            agentNotifications.set(Number(key), value);
+        }
+    }
+    broadcastAgentStatus(getAgentSnapshot());
+}
+export function updateHostsStatus(hosts) {
+    // Detect if the set of host IDs changed
+    const newHostIds = new Set(hosts.map((h) => h.hostId));
+    const prevHostIds = new Set(hostOnlineStatus.keys());
+    const hostSetChanged = newHostIds.size !== prevHostIds.size ||
+        [...newHostIds].some((id) => !prevHostIds.has(id));
+    hostOnlineStatus.clear();
+    hostRestrictedStatus.clear();
+    hostTypeStatus.clear();
+    connectedHostIds.clear();
+    for (const host of hosts) {
+        hostOnlineStatus.set(host.hostId, host.online);
+        hostRestrictedStatus.set(host.hostId, host.restricted);
+        hostTypeStatus.set(host.hostId, host.hostType);
+        if (host.online) {
+            connectedHostIds.add(host.hostId);
+        }
+    }
+    // Host topology changes can affect agent statuses (available/offline)
+    broadcastAgentStatus(getAgentSnapshot());
+    const hostEvent = getHostSnapshot();
+    if (hostSetChanged) {
+        hostEvent.hostsListChanged = true;
+    }
+    broadcastHostStatus(hostEvent);
+}
+export function markAgentStarted(userId) {
+    activeAgentIds.add(userId);
+    broadcastAgentStatus(getAgentSnapshot());
+}
+export function markAgentStopped(userId) {
+    activeAgentIds.delete(userId);
+    broadcastAgentStatus(getAgentSnapshot());
+}
+export function emitAgentsListChanged() {
+    broadcastAgentStatus({
+        ...getAgentSnapshot(),
+        agentsListChanged: true,
+    });
+}
+export function emitHostsListChanged() {
+    broadcastHostStatus({
+        ...getHostSnapshot(),
+        hostsListChanged: true,
+    });
+}
+export function emitHubConnectionStatus(connected) {
+    const event = { hubConnected: connected };
+    broadcast("hub-status", event);
+}
+// --- Agent host assignment cache ---
+export function updateAgentHostAssignments(assignments) {
+    for (const { agentId, hostIds } of assignments) {
+        agentHostAssignments.set(agentId, hostIds);
+    }
+}
+// --- Enabled status cache ---
+export function updateAgentEnabledStatus(agents) {
+    for (const { agentId, enabled } of agents) {
+        if (!enabled) {
+            disabledAgentIds.add(agentId);
+        }
+        else {
+            disabledAgentIds.delete(agentId);
+        }
+    }
+}
+// --- Cost suspension cache ---
+export function updateCostSuspendedAgents(agents) {
+    for (const { agentId, isSuspended } of agents) {
+        if (isSuspended) {
+            costSuspendedAgentIds.add(agentId);
+        }
+        else {
+            costSuspendedAgentIds.delete(agentId);
+        }
+    }
+}
+// --- Query functions ---
+export function isAgentActive(userId) {
+    return activeAgentIds.has(userId);
+}
+function hasNonRestrictedOnlineHost() {
+    for (const [hostId, online] of hostOnlineStatus) {
+        if (online &&
+            !hostRestrictedStatus.get(hostId) &&
+            hostTypeStatus.get(hostId) === "naisys")
+            return true;
+    }
+    return false;
+}
+export function getAgentStatus(agentId) {
+    return determineAgentStatus({
+        isActive: activeAgentIds.has(agentId),
+        isEnabled: !disabledAgentIds.has(agentId),
+        isSuspended: costSuspendedAgentIds.has(agentId),
+        assignedHostIds: agentHostAssignments.get(agentId),
+        isHostOnline: (hid) => connectedHostIds.has(hid),
+        hasNonRestrictedOnlineHost: hasNonRestrictedOnlineHost(),
+    });
+}
+export function isHostConnected(hostId) {
+    return connectedHostIds.has(hostId);
+}
+/** Build a snapshot of all agent statuses from current state */
+function getAgentSnapshot() {
+    const agents = {};
+    // Include all agents we know about from notifications
+    for (const [userId, notif] of agentNotifications) {
+        agents[String(userId)] = {
+            status: getAgentStatus(userId),
+            latestLogId: notif.latestLogId,
+            latestMailId: notif.latestMailId,
+        };
+    }
+    // Include active agents that may not have notifications yet
+    for (const userId of activeAgentIds) {
+        if (!agents[String(userId)]) {
+            agents[String(userId)] = {
+                status: "active",
+                latestLogId: 0,
+                latestMailId: 0,
+            };
+        }
+    }
+    return { agents };
+}
+/** Build a snapshot of all host online statuses from current state */
+function getHostSnapshot() {
+    const hosts = {};
+    for (const [hostId, online] of hostOnlineStatus) {
+        hosts[String(hostId)] = { online };
+    }
+    return { hosts };
+}
+//# sourceMappingURL=agentHostStatusService.js.map

package/dist/services/agentService.js

@@ -0,0 +1,291 @@
+import { AgentConfigFileSchema, calculatePeriodBoundaries, } from "@naisys/common";
+import { hubDb } from "../database/hubDb.js";
+import { updateAgentEnabledStatus, updateAgentHostAssignments, updateCostSuspendedAgents, } from "./agentHostStatusService.js";
+export async function getAgents(updatedSince) {
+    const users = await hubDb.users.findMany({
+        select: {
+            id: true,
+            uuid: true,
+            username: true,
+            title: true,
+            enabled: true,
+            archived: true,
+            config: true,
+            lead_user: { select: { username: true } },
+            user_hosts: { select: { host_id: true } },
+            user_notifications: {
+                select: {
+                    latest_log_id: true,
+                    latest_mail_id: true,
+                    last_active: true,
+                    cost_suspended_reason: true,
+                    budget_left: true,
+                    updated_at: true,
+                    host: { select: { name: true } },
+                },
+            },
+        },
+        where: updatedSince
+            ? {
+                user_notifications: {
+                    updated_at: { gte: new Date(updatedSince) },
+                },
+            }
+            : undefined,
+    });
+    const agents = users.map((user) => ({
+        id: user.id,
+        uuid: user.uuid,
+        name: user.username,
+        title: user.title,
+        host: user.user_notifications?.host?.name ?? "",
+        lastActive: user.user_notifications?.last_active?.toISOString(),
+        leadUsername: user.lead_user?.username || undefined,
+        latestLogId: user.user_notifications?.latest_log_id ?? 0,
+        latestMailId: user.user_notifications?.latest_mail_id ?? 0,
+        enabled: user.enabled,
+        archived: user.archived,
+        budgetLeft: user.user_notifications?.budget_left != null
+            ? Number(user.user_notifications.budget_left)
+            : undefined,
+        config: parseConfig(user.config),
+    }));
+    updateAgentHostAssignments(users.map((user) => ({
+        agentId: user.id,
+        hostIds: user.user_hosts.map((uh) => uh.host_id),
+    })));
+    updateCostSuspendedAgents(users.map((user) => ({
+        agentId: user.id,
+        isSuspended: !!user.user_notifications?.cost_suspended_reason,
+    })));
+    updateAgentEnabledStatus(users.map((user) => ({
+        agentId: user.id,
+        enabled: user.enabled,
+    })));
+    return agents;
+}
+function parseConfig(config) {
+    if (!config)
+        return null;
+    try {
+        return AgentConfigFileSchema.parse(JSON.parse(config));
+    }
+    catch {
+        return null;
+    }
+}
+// In-memory bidirectional lookup, refreshed by refreshUserLookup()
+const idToUsername = new Map();
+const usernameToId = new Map();
+export function resolveAgentId(username) {
+    return usernameToId.get(username);
+}
+export function resolveUsername(userId) {
+    return idToUsername.get(userId);
+}
+export async function refreshUserLookup() {
+    const users = await hubDb.users.findMany({
+        select: { id: true, username: true },
+    });
+    idToUsername.clear();
+    usernameToId.clear();
+    for (const user of users) {
+        idToUsername.set(user.id, user.username);
+        usernameToId.set(user.username, user.id);
+    }
+}
+export async function getHubAgentById(id) {
+    return hubDb.users.findUnique({
+        where: { id },
+        select: { id: true, uuid: true, username: true },
+    });
+}
+export async function getHubAgentByUuid(uuid) {
+    return hubDb.users.findFirst({
+        where: { uuid },
+        select: { id: true, username: true },
+    });
+}
+export async function getAgent(id) {
+    const user = await hubDb.users.findUnique({
+        where: { id },
+        select: {
+            id: true,
+            username: true,
+            title: true,
+            enabled: true,
+            archived: true,
+            config: true,
+            lead_user: { select: { username: true } },
+            user_hosts: {
+                select: {
+                    host_id: true,
+                    host: { select: { id: true, name: true } },
+                },
+            },
+            user_notifications: {
+                select: {
+                    latest_log_id: true,
+                    latest_mail_id: true,
+                    last_active: true,
+                    cost_suspended_reason: true,
+                    spend_limit_reset_at: true,
+                    updated_at: true,
+                    host: { select: { name: true } },
+                },
+            },
+        },
+    });
+    if (!user) {
+        return null;
+    }
+    updateAgentHostAssignments([
+        {
+            agentId: user.id,
+            hostIds: user.user_hosts.map((uh) => uh.host_id),
+        },
+    ]);
+    const config = parseConfig(user.config);
+    const currentSpend = await getAgentCurrentSpend(user.id, config.spendLimitDollars, config.spendLimitHours, user.user_notifications?.spend_limit_reset_at ?? null);
+    return {
+        id: user.id,
+        name: user.username,
+        title: user.title,
+        host: user.user_notifications?.host?.name ?? "",
+        lastActive: user.user_notifications?.last_active?.toISOString(),
+        leadUsername: user.lead_user?.username || undefined,
+        latestLogId: user.user_notifications?.latest_log_id ?? 0,
+        latestMailId: user.user_notifications?.latest_mail_id ?? 0,
+        enabled: user.enabled,
+        archived: user.archived,
+        costSuspendedReason: user.user_notifications?.cost_suspended_reason ?? undefined,
+        currentSpend,
+        spendLimitResetAt: user.user_notifications?.spend_limit_reset_at?.toISOString() ?? undefined,
+        config,
+        assignedHosts: user.user_hosts.map((uh) => ({
+            id: uh.host.id,
+            name: uh.host.name,
+        })),
+        _links: [],
+    };
+}
+export async function enableAgent(id) {
+    await hubDb.users.update({
+        where: { id },
+        data: { enabled: true },
+    });
+}
+export async function disableAgent(id) {
+    await hubDb.users.update({
+        where: { id },
+        data: { enabled: false },
+    });
+}
+export async function archiveAgent(id) {
+    await hubDb.users.update({
+        where: { id },
+        data: { archived: true },
+    });
+}
+export async function unarchiveAgent(id) {
+    await hubDb.users.update({
+        where: { id },
+        data: { archived: false },
+    });
+}
+export async function updateLeadAgent(id, leadUsername) {
+    const agent = await hubDb.users.findUnique({
+        where: { id },
+        select: { id: true },
+    });
+    if (!agent) {
+        throw new Error(`Agent with ID ${id} not found`);
+    }
+    let leadUserId = null;
+    if (leadUsername) {
+        const leadAgent = await hubDb.users.findUnique({
+            where: { username: leadUsername },
+            select: { id: true },
+        });
+        if (!leadAgent) {
+            throw new Error(`Lead agent '${leadUsername}' not found`);
+        }
+        leadUserId = leadAgent.id;
+    }
+    await hubDb.users.update({
+        where: { id },
+        data: { lead_user_id: leadUserId },
+    });
+}
+async function getAgentCurrentSpend(userId, spendLimitDollars, spendLimitHours, spendLimitResetAt) {
+    if (spendLimitDollars === undefined)
+        return undefined;
+    const where = { user_id: userId };
+    let effectiveStart;
+    if (spendLimitHours !== undefined) {
+        const { periodStart } = calculatePeriodBoundaries(spendLimitHours);
+        effectiveStart = periodStart;
+    }
+    if (spendLimitResetAt &&
+        (!effectiveStart || spendLimitResetAt > effectiveStart)) {
+        effectiveStart = spendLimitResetAt;
+    }
+    if (effectiveStart) {
+        where.created_at = { gte: effectiveStart };
+    }
+    const result = await hubDb.costs.aggregate({
+        where,
+        _sum: { cost: true },
+    });
+    return Math.round((result._sum.cost ?? 0) * 100) / 100;
+}
+export async function resetAgentSpend(id) {
+    await hubDb.user_notifications.updateMany({
+        where: { user_id: id },
+        data: {
+            spend_limit_reset_at: new Date(),
+            cost_suspended_reason: null,
+        },
+    });
+}
+export async function deleteAgent(id) {
+    const user = await hubDb.users.findUnique({
+        where: { id },
+        select: { id: true },
+    });
+    if (!user) {
+        throw new Error(`Agent with ID ${id} not found`);
+    }
+    await hubDb.$transaction(async (hubTx) => {
+        await hubTx.context_log.deleteMany({ where: { user_id: id } });
+        await hubTx.costs.deleteMany({ where: { user_id: id } });
+        await hubTx.run_session.deleteMany({ where: { user_id: id } });
+        // Get sent message IDs so we can delete their attachments and recipients
+        const sentMessages = await hubTx.mail_messages.findMany({
+            where: { from_user_id: id },
+            select: { id: true },
+        });
+        const sentMessageIds = sentMessages.map((m) => m.id);
+        if (sentMessageIds.length > 0) {
+            await hubTx.mail_attachments.deleteMany({
+                where: { message_id: { in: sentMessageIds } },
+            });
+            await hubTx.mail_recipients.deleteMany({
+                where: { message_id: { in: sentMessageIds } },
+            });
+            await hubTx.mail_messages.deleteMany({
+                where: { id: { in: sentMessageIds } },
+            });
+        }
+        // Delete remaining recipient entries (for messages received by this agent)
+        await hubTx.mail_recipients.deleteMany({ where: { user_id: id } });
+        await hubTx.user_notifications.deleteMany({ where: { user_id: id } });
+        await hubTx.user_hosts.deleteMany({ where: { user_id: id } });
+        await hubTx.users.updateMany({
+            where: { lead_user_id: id },
+            data: { lead_user_id: null },
+        });
+        await hubTx.users.delete({ where: { id } });
+    });
+}
+//# sourceMappingURL=agentService.js.map