@naisys/supervisor 3.0.0-beta.10

package/dist/routes/agentLifecycle.js

@@ -0,0 +1,350 @@
+import { AgentActionResultSchema, AgentStartRequestSchema, AgentStartResultSchema, AgentStopRequestSchema, AgentStopResultSchema, AgentToggleRequestSchema, AgentUsernameParamsSchema, ErrorResponseSchema, SetLeadAgentRequestSchema, } from "@naisys/supervisor-shared";
+import { requirePermission } from "../auth-middleware.js";
+import { hubDb } from "../database/hubDb.js";
+import { badRequest, notFound } from "../error-helpers.js";
+import { isAgentActive } from "../services/agentHostStatusService.js";
+import { archiveAgent, deleteAgent, disableAgent, enableAgent, getAgent, resetAgentSpend, resolveAgentId, unarchiveAgent, updateLeadAgent, } from "../services/agentService.js";
+import { isHubConnected, sendAgentStart, sendAgentStop, sendUserListChanged, } from "../services/hubConnectionService.js";
+async function findSubordinates(parentUserId, filter) {
+    const allUsers = await hubDb.users.findMany({
+        select: { id: true, lead_user_id: true },
+    });
+    const result = [];
+    function collect(parentId) {
+        for (const user of allUsers) {
+            if (user.lead_user_id === parentId) {
+                if (!filter || filter(user.id)) {
+                    result.push(user.id);
+                }
+                collect(user.id);
+            }
+        }
+    }
+    collect(parentUserId);
+    return result;
+}
+export default function agentLifecycleRoutes(fastify, _options) {
+    // POST /:username/start — Start agent via hub
+    fastify.post("/:username/start", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Start an agent via the hub",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: AgentStartRequestSchema,
+            response: {
+                200: AgentStartResultSchema,
+                503: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { task } = request.body;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        if (!isHubConnected()) {
+            return reply.status(503).send({
+                success: false,
+                message: "Hub is not connected",
+            });
+        }
+        const naisysUser = (await hubDb.users.findFirst({
+            where: { uuid: request.supervisorUser.uuid },
+            select: { id: true },
+        })) ??
+            (await hubDb.users.findFirst({
+                where: { username: "admin" },
+                select: { id: true },
+            }));
+        if (!naisysUser) {
+            return reply.status(500).send({
+                success: false,
+                message: "No matching user found in NAISYS database",
+            });
+        }
+        const response = await sendAgentStart(id, task, naisysUser.id);
+        if (response.success) {
+            return {
+                success: true,
+                message: "Agent started",
+                hostname: response.hostname,
+            };
+        }
+        else {
+            return reply.status(500).send({
+                success: false,
+                message: response.error || "Failed to start agent",
+            });
+        }
+    });
+    // POST /:username/stop — Stop agent via hub
+    fastify.post("/:username/stop", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Stop an agent via the hub",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: AgentStopRequestSchema,
+            response: {
+                200: AgentStopResultSchema,
+                503: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { recursive } = request.body;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        if (!isHubConnected()) {
+            return reply.status(503).send({
+                success: false,
+                message: "Hub is not connected",
+            });
+        }
+        // Fire-and-forget stops for subordinates when recursive
+        if (recursive) {
+            const subordinates = await findSubordinates(id, isAgentActive);
+            void Promise.all(subordinates.map((subId) => sendAgentStop(subId, "Stopped from supervisor (recursive)").catch((err) => request.log.error(err, `Failed to stop subordinate agent ${subId}`))));
+        }
+        const response = await sendAgentStop(id, "Stopped from supervisor");
+        if (response.success) {
+            return {
+                success: true,
+                message: recursive
+                    ? "Agent and subordinates stopped"
+                    : "Agent stopped",
+            };
+        }
+        else {
+            return reply.status(500).send({
+                success: false,
+                message: response.error || "Failed to stop agent",
+            });
+        }
+    });
+    // POST /:username/enable — Enable agent
+    fastify.post("/:username/enable", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Enable an agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: AgentToggleRequestSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { recursive } = request.body;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        const subordinateIds = recursive ? await findSubordinates(id) : [];
+        await enableAgent(id);
+        await Promise.all(subordinateIds.map((subId) => enableAgent(subId)));
+        sendUserListChanged();
+        const count = subordinateIds.length + 1;
+        return {
+            success: true,
+            message: recursive && count > 1
+                ? `Enabled ${count} agent(s)`
+                : "Agent enabled",
+        };
+    });
+    // POST /:username/disable — Disable agent
+    fastify.post("/:username/disable", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Disable an agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: AgentToggleRequestSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { recursive } = request.body;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        const subordinateIds = recursive ? await findSubordinates(id) : [];
+        const allIds = [id, ...subordinateIds];
+        // Disable all in DB first, then try to stop any active ones
+        await Promise.all(allIds.map((agentId) => disableAgent(agentId)));
+        sendUserListChanged();
+        if (isHubConnected()) {
+            const activeIds = allIds.filter((agentId) => isAgentActive(agentId));
+            if (activeIds.length > 0) {
+                void Promise.all(activeIds.map((agentId) => sendAgentStop(agentId, "Agent disabled").catch((err) => request.log.error(err, `Failed to stop disabled agent ${agentId}`))));
+            }
+        }
+        const count = allIds.length;
+        return {
+            success: true,
+            message: recursive && count > 1
+                ? `Disabled ${count} agent(s); stop requested for active ones`
+                : isAgentActive(id)
+                    ? "Agent disabled; stop requested"
+                    : "Agent disabled",
+        };
+    });
+    // POST /:username/archive — Archive agent
+    fastify.post("/:username/archive", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Archive an agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        if (isAgentActive(id)) {
+            return badRequest(reply, "Cannot archive an active agent. Stop it first.");
+        }
+        await archiveAgent(id);
+        sendUserListChanged();
+        return { success: true, message: "Agent archived" };
+    });
+    // POST /:username/unarchive — Unarchive agent
+    fastify.post("/:username/unarchive", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Unarchive an agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        await unarchiveAgent(id);
+        sendUserListChanged();
+        return { success: true, message: "Agent unarchived" };
+    });
+    // PUT /:username/lead — Set or clear lead agent
+    fastify.put("/:username/lead", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Set or clear the lead agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: SetLeadAgentRequestSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { leadAgentUsername } = request.body;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        await updateLeadAgent(id, leadAgentUsername);
+        sendUserListChanged();
+        return {
+            success: true,
+            message: leadAgentUsername
+                ? "Lead agent updated"
+                : "Lead agent cleared",
+        };
+    });
+    // POST /:username/reset-spend — Reset agent spend counter
+    fastify.post("/:username/reset-spend", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Reset an agent's spend counter",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        await resetAgentSpend(id);
+        return { success: true, message: "Spend counter reset" };
+    });
+    // DELETE /:username — Permanently delete agent
+    fastify.delete("/:username", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Permanently delete an archived agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, "Agent not found");
+        }
+        if (isAgentActive(id)) {
+            return badRequest(reply, "Cannot delete an active agent. Stop it first.");
+        }
+        const agent = await getAgent(id);
+        if (!agent) {
+            return notFound(reply, "Agent not found");
+        }
+        if (!agent.archived) {
+            return badRequest(reply, "Agent must be archived before it can be deleted.");
+        }
+        await deleteAgent(id);
+        sendUserListChanged();
+        return { success: true, message: "Agent permanently deleted" };
+    });
+}
+//# sourceMappingURL=agentLifecycle.js.map

package/dist/routes/agentMail.js

@@ -0,0 +1,171 @@
+import { AgentUsernameParamsSchema, ArchiveMailResponseSchema, ErrorResponseSchema, MailDataRequestSchema, MailDataResponseSchema, SendMailRequestSchema, SendMailResponseSchema, } from "@naisys/supervisor-shared";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { badRequest, notFound } from "../error-helpers.js";
+import { API_PREFIX } from "../hateoas.js";
+import { resolveAgentId } from "../services/agentService.js";
+import { archiveAllMailMessages, getMailDataByUserId, sendMessage, } from "../services/mailService.js";
+export default function agentMailRoutes(fastify, _options) {
+    // GET /:username/mail — Mail for agent
+    fastify.get("/:username/mail", {
+        schema: {
+            description: "Get mail data for a specific agent",
+            tags: ["Mail"],
+            params: AgentUsernameParamsSchema,
+            querystring: MailDataRequestSchema,
+            response: {
+                200: MailDataResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { updatedSince, page, count } = request.query;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, `Agent '${username}' not found`);
+        }
+        const data = await getMailDataByUserId(id, updatedSince, page, count, "mail");
+        const canSend = hasPermission(request.supervisorUser, "agent_communication");
+        return {
+            success: true,
+            message: "Mail data retrieved successfully",
+            data,
+            _links: data
+                ? [
+                    {
+                        rel: "next",
+                        href: `${API_PREFIX}/agents/${username}/mail?updatedSince=${encodeURIComponent(data.timestamp)}`,
+                        title: "Poll for newer mail",
+                    },
+                ]
+                : undefined,
+            _actions: canSend
+                ? [
+                    {
+                        rel: "send",
+                        href: `${API_PREFIX}/agents/${username}/mail`,
+                        method: "POST",
+                        title: "Send Mail",
+                        schema: `${API_PREFIX}/schemas/SendMail`,
+                        body: { fromId: 0, toIds: [0], subject: "", message: "" },
+                        alternateEncoding: {
+                            contentType: "multipart/form-data",
+                            description: "Send as multipart to include file attachments",
+                            fileFields: ["attachments"],
+                        },
+                    },
+                    {
+                        rel: "archive",
+                        href: `${API_PREFIX}/agents/${username}/mail/archive`,
+                        method: "POST",
+                        title: "Archive All Mail Messages",
+                    },
+                ]
+                : undefined,
+        };
+    });
+    // POST /:username/mail/archive — Archive all mail messages
+    fastify.post("/:username/mail/archive", {
+        preHandler: [requirePermission("agent_communication")],
+        schema: {
+            description: "Archive all mail messages for an agent",
+            tags: ["Mail"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: ArchiveMailResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, `Agent '${username}' not found`);
+        }
+        const archivedCount = await archiveAllMailMessages(id);
+        return { success: true, archivedCount };
+    });
+    // POST /:username/mail — Send mail as agent
+    fastify.post("/:username/mail", {
+        preHandler: [requirePermission("agent_communication")],
+        schema: {
+            description: "Send email as agent with optional attachments. Supports JSON and multipart/form-data",
+            tags: ["Mail"],
+            params: AgentUsernameParamsSchema,
+            // No body schema — multipart requests are parsed manually via request.parts()
+            response: {
+                200: SendMailResponseSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const contentType = request.headers["content-type"];
+        let fromId = 0, toIds = [], subject = "", message = "";
+        let attachments = [];
+        if (contentType?.includes("multipart/form-data")) {
+            const parts = request.parts();
+            for await (const part of parts) {
+                if (part.type === "field") {
+                    const field = part;
+                    switch (field.fieldname) {
+                        case "fromId":
+                            fromId = Number(field.value);
+                            break;
+                        case "toIds":
+                            try {
+                                toIds = JSON.parse(field.value);
+                            }
+                            catch {
+                                return badRequest(reply, "toIds must be valid JSON array");
+                            }
+                            break;
+                        case "subject":
+                            subject = field.value;
+                            break;
+                        case "message":
+                            message = field.value;
+                            break;
+                    }
+                }
+                else if (part.type === "file") {
+                    const file = part;
+                    if (file.fieldname === "attachments") {
+                        const buffer = await file.toBuffer();
+                        attachments.push({
+                            filename: file.filename || "unnamed_file",
+                            data: buffer,
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            const body = request.body;
+            fromId = body.fromId;
+            toIds = body.toIds;
+            subject = body.subject;
+            message = body.message;
+        }
+        const parsed = SendMailRequestSchema.safeParse({
+            fromId,
+            toIds,
+            subject,
+            message,
+        });
+        if (!parsed.success) {
+            return badRequest(reply, parsed.error.message);
+        }
+        ({ fromId, toIds, subject, message } = parsed.data);
+        const result = await sendMessage({ fromId, toIds, subject, message }, attachments.length > 0 ? attachments : undefined);
+        if (result.success) {
+            return reply.code(200).send(result);
+        }
+        else {
+            return reply.code(500).send(result);
+        }
+    });
+}
+//# sourceMappingURL=agentMail.js.map

package/dist/routes/agentRuns.js

@@ -0,0 +1,90 @@
+import { AgentUsernameParamsSchema, ContextLogParamsSchema, ContextLogRequestSchema, ContextLogResponseSchema, RunsDataRequestSchema, RunsDataResponseSchema, } from "@naisys/supervisor-shared";
+import { hasPermission } from "../auth-middleware.js";
+import { notFound } from "../error-helpers.js";
+import { API_PREFIX } from "../hateoas.js";
+import { resolveAgentId } from "../services/agentService.js";
+import { getContextLog, getRunsData, obfuscateLogs, } from "../services/runsService.js";
+export default function agentRunsRoutes(fastify, _options) {
+    // GET /:username/runs — Runs for agent
+    fastify.get("/:username/runs", {
+        schema: {
+            description: "Get run sessions for a specific agent",
+            tags: ["Runs"],
+            params: AgentUsernameParamsSchema,
+            querystring: RunsDataRequestSchema,
+            response: {
+                200: RunsDataResponseSchema,
+                500: RunsDataResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { updatedSince, page, count } = request.query;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, `Agent '${username}' not found`);
+        }
+        const data = await getRunsData(id, updatedSince, page, count);
+        return {
+            success: true,
+            message: "Runs data retrieved successfully",
+            data: data ?? undefined,
+            _linkTemplates: [
+                {
+                    rel: "logs",
+                    hrefTemplate: `${API_PREFIX}/agents/${username}/runs/{runId}/sessions/{sessionId}/logs`,
+                },
+            ],
+            _links: data
+                ? [
+                    {
+                        rel: "next",
+                        href: `${API_PREFIX}/agents/${username}/runs?updatedSince=${encodeURIComponent(data.timestamp)}`,
+                        title: "Poll for updated runs",
+                    },
+                ]
+                : undefined,
+        };
+    });
+    // GET /:username/runs/:runId/sessions/:sessionId/logs — Context log
+    fastify.get("/:username/runs/:runId/sessions/:sessionId/logs", {
+        schema: {
+            description: "Get context log for a specific run session",
+            tags: ["Runs"],
+            params: ContextLogParamsSchema,
+            querystring: ContextLogRequestSchema,
+            response: {
+                200: ContextLogResponseSchema,
+                500: ContextLogResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        const { username, runId, sessionId } = request.params;
+        const { logsAfter, logsBefore } = request.query;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, `Agent '${username}' not found`);
+        }
+        let data = await getContextLog(id, runId, sessionId, logsAfter, logsBefore);
+        // Obfuscate log text for users without view_run_logs permission
+        if (!hasPermission(request.supervisorUser, "view_run_logs")) {
+            data = obfuscateLogs(data);
+        }
+        const maxLogId = data?.logs.length
+            ? Math.max(...data.logs.map((l) => l.id))
+            : (logsAfter ?? 0);
+        return {
+            success: true,
+            message: "Context log retrieved successfully",
+            data,
+            _links: [
+                {
+                    rel: "next",
+                    href: `${API_PREFIX}/agents/${username}/runs/${runId}/sessions/${sessionId}/logs?logsAfter=${maxLogId}`,
+                    title: "Poll for newer logs",
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=agentRuns.js.map