@naisys/supervisor 3.0.0-beta.10

package/dist/routes/agentChat.js

@@ -0,0 +1,194 @@
+import { AgentUsernameParamsSchema, ArchiveChatResponseSchema, ChatConversationsRequestSchema, ChatConversationsResponseSchema, ChatMessagesRequestSchema, ChatMessagesResponseSchema, ErrorResponseSchema, SendChatRequestSchema, SendChatResponseSchema, } 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 { uploadToHub } from "../services/attachmentProxyService.js";
+import { archiveAllChatMessages, getConversations, getMessages, sendChatMessage, } from "../services/chatService.js";
+function sendChatAction(username) {
+    return {
+        rel: "send",
+        href: `${API_PREFIX}/agents/${username}/chat`,
+        method: "POST",
+        title: "Send Chat Message",
+        schema: `${API_PREFIX}/schemas/SendChat`,
+        body: { fromId: 0, toIds: [0], message: "" },
+        alternateEncoding: {
+            contentType: "multipart/form-data",
+            description: "Send as multipart to include file attachments",
+            fileFields: ["attachments"],
+        },
+    };
+}
+function archiveChatAction(username) {
+    return {
+        rel: "archive",
+        href: `${API_PREFIX}/agents/${username}/chat/archive`,
+        method: "POST",
+        title: "Archive All Chat Messages",
+    };
+}
+export default function agentChatRoutes(fastify, _options) {
+    // GET /:username/chat — List conversations for agent
+    fastify.get("/:username/chat", {
+        schema: {
+            description: "Get chat conversations for a specific agent",
+            tags: ["Chat"],
+            params: AgentUsernameParamsSchema,
+            querystring: ChatConversationsRequestSchema,
+            response: {
+                200: ChatConversationsResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        const { username } = request.params;
+        const { page, count } = request.query;
+        const id = resolveAgentId(username);
+        if (!id) {
+            return notFound(reply, `Agent '${username}' not found`);
+        }
+        const { conversations, total } = await getConversations(id, page, count);
+        const canSend = hasPermission(request.supervisorUser, "agent_communication");
+        return {
+            success: true,
+            conversations,
+            total,
+            _actions: canSend
+                ? [sendChatAction(username), archiveChatAction(username)]
+                : undefined,
+        };
+    });
+    // GET /:username/chat/:participants — Messages in a conversation
+    fastify.get("/:username/chat/:participants", {
+        schema: {
+            description: "Get chat messages for a specific conversation",
+            tags: ["Chat"],
+            querystring: ChatMessagesRequestSchema,
+            response: {
+                200: ChatMessagesResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, _reply) => {
+        const { username, participants } = request.params;
+        const { updatedSince, page, count } = request.query;
+        const data = await getMessages(participants, updatedSince, page, count);
+        const canSend = hasPermission(request.supervisorUser, "agent_communication");
+        return {
+            success: true,
+            messages: data.messages,
+            total: data.total,
+            timestamp: data.timestamp,
+            _actions: canSend ? [sendChatAction(username)] : undefined,
+        };
+    });
+    // POST /:username/chat/archive — Archive all chat messages
+    fastify.post("/:username/chat/archive", {
+        preHandler: [requirePermission("agent_communication")],
+        schema: {
+            description: "Archive all chat messages for an agent",
+            tags: ["Chat"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: ArchiveChatResponseSchema,
+                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 archiveAllChatMessages(id);
+        return { success: true, archivedCount };
+    });
+    // POST /:username/chat — Send chat message
+    fastify.post("/:username/chat", {
+        preHandler: [requirePermission("agent_communication")],
+        schema: {
+            description: "Send a chat message as an agent with optional attachments. Supports JSON and multipart/form-data",
+            tags: ["Chat"],
+            params: AgentUsernameParamsSchema,
+            // No body schema — multipart requests are parsed manually via request.parts()
+            response: {
+                200: SendChatResponseSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const contentType = request.headers["content-type"];
+        let fromId = 0, toIds = [], message = "";
+        let attachmentBuffers = [];
+        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 "message":
+                            message = field.value;
+                            break;
+                    }
+                }
+                else if (part.type === "file") {
+                    const file = part;
+                    if (file.fieldname === "attachments") {
+                        const buffer = await file.toBuffer();
+                        attachmentBuffers.push({
+                            filename: file.filename || "unnamed_file",
+                            data: buffer,
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            const body = request.body;
+            fromId = body.fromId;
+            toIds = body.toIds;
+            message = body.message;
+        }
+        const parsed = SendChatRequestSchema.safeParse({
+            fromId,
+            toIds,
+            message,
+        });
+        if (!parsed.success) {
+            return badRequest(reply, parsed.error.message);
+        }
+        ({ fromId, toIds, message } = parsed.data);
+        // Upload attachments to hub and collect IDs
+        let attachmentIds;
+        if (attachmentBuffers.length > 0) {
+            attachmentIds = [];
+            for (const att of attachmentBuffers) {
+                const id = await uploadToHub(att.data, att.filename, fromId, "mail");
+                attachmentIds.push(id);
+            }
+        }
+        const result = await sendChatMessage(fromId, toIds, message, attachmentIds);
+        if (result.success) {
+            return reply.code(200).send(result);
+        }
+        else {
+            return reply.code(500).send(result);
+        }
+    });
+}
+//# sourceMappingURL=agentChat.js.map

package/dist/routes/agentConfig.js

@@ -0,0 +1,265 @@
+import { AgentConfigFileSchema } from "@naisys/common";
+import { AgentUsernameParamsSchema, ConfigRevisionListResponseSchema, ErrorResponseSchema, ExportAgentConfigResponseSchema, GetAgentConfigResponseSchema, ImportAgentConfigRequestSchema, ImportAgentConfigResponseSchema, UpdateAgentConfigRequestSchema, UpdateAgentConfigResponseSchema, } from "@naisys/supervisor-shared";
+import yaml from "js-yaml";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { badRequest, notFound } from "../error-helpers.js";
+import { API_PREFIX } from "../hateoas.js";
+import { getAgentConfigById, getConfigRevisions, updateAgentConfigById, } from "../services/agentConfigService.js";
+import { resolveAgentId } from "../services/agentService.js";
+import { getAllModelsFromDb } from "../services/modelService.js";
+/** Validate model keys in config against known models. Returns error message or null. */
+async function validateModelKeys(config) {
+    const isTemplateVar = (v) => /^\$\{.+\}$/.test(v);
+    const allModels = await getAllModelsFromDb();
+    const keysOfType = (type) => new Set(allModels
+        .filter((r) => r.type === type)
+        .map((r) => r.key));
+    const validLlmKeys = keysOfType("llm");
+    const validImageKeys = keysOfType("image");
+    const invalidModels = [];
+    if (!isTemplateVar(config.shellModel) &&
+        !validLlmKeys.has(config.shellModel)) {
+        invalidModels.push(`shellModel: "${config.shellModel}"`);
+    }
+    if (config.imageModel &&
+        !isTemplateVar(config.imageModel) &&
+        !validImageKeys.has(config.imageModel)) {
+        invalidModels.push(`imageModel: "${config.imageModel}"`);
+    }
+    if (invalidModels.length > 0) {
+        return `Invalid model key(s): ${invalidModels.join(", ")}`;
+    }
+    return null;
+}
+export default function agentConfigRoutes(fastify, _options) {
+    // GET /:username/config — Get parsed agent config
+    fastify.get("/:username/config", {
+        schema: {
+            description: "Get parsed agent configuration",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: GetAgentConfigResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { username } = request.params;
+            const id = resolveAgentId(username);
+            if (!id) {
+                return notFound(reply, `Agent '${username}' not found`);
+            }
+            const config = await getAgentConfigById(id);
+            const canManage = hasPermission(request.supervisorUser, "manage_agents");
+            return {
+                config,
+                _actions: canManage
+                    ? [
+                        {
+                            rel: "update",
+                            href: `${API_PREFIX}/agents/${username}/config`,
+                            method: "PUT",
+                            title: "Update Config",
+                        },
+                        {
+                            rel: "import-config",
+                            href: `${API_PREFIX}/agents/${username}/config/import`,
+                            method: "POST",
+                            title: "Import Config",
+                        },
+                        {
+                            rel: "export-config",
+                            href: `${API_PREFIX}/agents/${username}/config/export`,
+                            method: "GET",
+                            title: "Export Config",
+                        },
+                    ]
+                    : undefined,
+            };
+        }
+        catch (error) {
+            request.log.error(error, "Error in GET /agents/:username/config route");
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not found")) {
+                return notFound(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // PUT /:username/config — Update agent config
+    fastify.put("/:username/config", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Update agent configuration",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: UpdateAgentConfigRequestSchema,
+            response: {
+                200: UpdateAgentConfigResponseSchema,
+                400: ErrorResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        try {
+            const { username } = request.params;
+            const { config } = request.body;
+            const id = resolveAgentId(username);
+            if (!id) {
+                return notFound(reply, `Agent '${username}' not found`);
+            }
+            // Validate model keys against known models
+            const modelError = await validateModelKeys(config);
+            if (modelError) {
+                return badRequest(reply, modelError);
+            }
+            const updatedConfig = await updateAgentConfigById(id, config, true, request.supervisorUser?.id);
+            return {
+                success: true,
+                message: "Agent configuration updated successfully",
+                config: updatedConfig,
+            };
+        }
+        catch (error) {
+            request.log.error(error, "Error in PUT /agents/:username/config route");
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not found")) {
+                return notFound(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // GET /:username/config/export — Export agent config as YAML
+    fastify.get("/:username/config/export", {
+        schema: {
+            description: "Export agent configuration as YAML",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: ExportAgentConfigResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { username } = request.params;
+            const id = resolveAgentId(username);
+            if (!id) {
+                return notFound(reply, `Agent '${username}' not found`);
+            }
+            const config = await getAgentConfigById(id);
+            const yamlString = yaml.dump(config, { lineWidth: -1 });
+            return { yaml: yamlString };
+        }
+        catch (error) {
+            request.log.error(error, "Error in GET /agents/:username/config/export route");
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not found")) {
+                return notFound(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // POST /:username/config/import — Import agent config from YAML
+    fastify.post("/:username/config/import", {
+        preHandler: [requirePermission("manage_agents")],
+        schema: {
+            description: "Import agent configuration from YAML",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            body: ImportAgentConfigRequestSchema,
+            response: {
+                200: ImportAgentConfigResponseSchema,
+                400: ErrorResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        try {
+            const { username } = request.params;
+            const { yaml: yamlString } = request.body;
+            const id = resolveAgentId(username);
+            if (!id) {
+                return notFound(reply, `Agent '${username}' not found`);
+            }
+            // Parse YAML
+            let parsed;
+            try {
+                parsed = yaml.load(yamlString);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "Invalid YAML syntax";
+                return badRequest(reply, `YAML parse error: ${message}`);
+            }
+            // Validate against schema
+            let config;
+            try {
+                config = AgentConfigFileSchema.parse(parsed);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "Invalid config structure";
+                return badRequest(reply, `Config validation error: ${message}`);
+            }
+            // Validate model keys
+            const modelError = await validateModelKeys(config);
+            if (modelError) {
+                return badRequest(reply, modelError);
+            }
+            const updatedConfig = await updateAgentConfigById(id, config, false, request.supervisorUser?.id);
+            return {
+                success: true,
+                message: "Agent configuration imported successfully",
+                config: updatedConfig,
+            };
+        }
+        catch (error) {
+            request.log.error(error, "Error in POST /agents/:username/config/import route");
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not found")) {
+                return notFound(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // GET /:username/config/revisions — List config revision history
+    fastify.get("/:username/config/revisions", {
+        schema: {
+            description: "List config revision history for an agent",
+            tags: ["Agents"],
+            params: AgentUsernameParamsSchema,
+            response: {
+                200: ConfigRevisionListResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { username } = request.params;
+            const id = resolveAgentId(username);
+            if (!id) {
+                return notFound(reply, `Agent '${username}' not found`);
+            }
+            const revisions = await getConfigRevisions(id);
+            return {
+                items: revisions.map((r) => ({
+                    ...r,
+                    config: yaml.dump(JSON.parse(r.config), { lineWidth: -1 }),
+                    createdAt: r.createdAt.toISOString(),
+                })),
+            };
+        }
+        catch (error) {
+            request.log.error(error, "Error in GET /agents/:username/config/revisions route");
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=agentConfig.js.map