@naisys/supervisor 3.0.0-beta.10

package/dist/routes/hosts.js

@@ -0,0 +1,296 @@
+import { AgentActionResultSchema, AgentNameParamSchema, AssignAgentToHostRequestSchema, CreateHostRequestSchema, ErrorResponseSchema, HostDetailResponseSchema, HostListResponseSchema, HostNameParamsSchema, UpdateHostRequestSchema, } from "@naisys/supervisor-shared";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { badRequest, conflict, notFound } from "../error-helpers.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { permGate, resolveActions } from "../route-helpers.js";
+import { emitHostsListChanged, isHostConnected, } from "../services/agentHostStatusService.js";
+import { assignAgentToHost, createHost, deleteHost, getHostDetail, getHosts, unassignAgentFromHost, updateHost, } from "../services/hostService.js";
+import { sendHostsChanged, sendUserListChanged, } from "../services/hubConnectionService.js";
+function hostActions(hostname, user, isOnline) {
+    const href = `${API_PREFIX}/hosts/${hostname}`;
+    return resolveActions([
+        {
+            rel: "update",
+            method: "PUT",
+            title: "Update Host",
+            permission: "manage_hosts",
+        },
+        {
+            rel: "assign-agent",
+            path: "/agents",
+            method: "POST",
+            title: "Assign Agent",
+            permission: "manage_hosts",
+        },
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Delete Host",
+            permission: "manage_hosts",
+            disabledWhen: (ctx) => ctx.isOnline ? "Host must be offline before deletion" : null,
+        },
+    ], href, { user, isOnline });
+}
+function hostActionTemplates(hostname, hasManageHostsPermission) {
+    if (!hasManageHostsPermission)
+        return [];
+    return [
+        {
+            rel: "unassignAgent",
+            hrefTemplate: `${API_PREFIX}/hosts/${hostname}/agents/{agentName}`,
+            method: "DELETE",
+            title: "Unassign Agent",
+        },
+    ];
+}
+export default function hostsRoutes(fastify, _options) {
+    // GET / — List hosts
+    fastify.get("/", {
+        schema: {
+            description: "List hosts with status",
+            tags: ["Hosts"],
+            response: {
+                200: HostListResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, _reply) => {
+        const hosts = await getHosts();
+        const user = request.supervisorUser;
+        const hasManageHostsPermission = hasPermission(user, "manage_hosts");
+        const items = hosts.map((host) => {
+            const online = isHostConnected(host.id);
+            return {
+                ...host,
+                online,
+                _actions: hostActions(host.name, user, online),
+            };
+        });
+        return {
+            items,
+            _links: [selfLink("/hosts")],
+            _linkTemplates: [
+                { rel: "item", hrefTemplate: `${API_PREFIX}/hosts/{name}` },
+            ],
+            _actions: [
+                {
+                    rel: "create",
+                    href: `${API_PREFIX}/hosts`,
+                    method: "POST",
+                    title: "Create Host",
+                    ...permGate(hasManageHostsPermission, "manage_hosts"),
+                },
+            ],
+        };
+    });
+    // POST / — Create host
+    fastify.post("/", {
+        preHandler: [requirePermission("manage_hosts")],
+        schema: {
+            description: "Create a new host",
+            tags: ["Hosts"],
+            body: CreateHostRequestSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        try {
+            const { name } = request.body;
+            const { id } = await createHost(name);
+            sendHostsChanged();
+            return {
+                success: true,
+                message: `Host '${name}' created successfully`,
+                id,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("already exists")) {
+                return conflict(reply, errorMessage);
+            }
+            if (errorMessage.includes("must contain only")) {
+                return badRequest(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // GET /:hostname — Host detail
+    fastify.get("/:hostname", {
+        schema: {
+            description: "Get host detail with assigned agents",
+            tags: ["Hosts"],
+            params: HostNameParamsSchema,
+            response: {
+                200: HostDetailResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        const { hostname } = request.params;
+        const host = await getHostDetail(hostname);
+        if (!host) {
+            return notFound(reply, `Host "${hostname}" not found`);
+        }
+        const user = request.supervisorUser;
+        const hasManageHostsPermission = hasPermission(user, "manage_hosts");
+        const online = isHostConnected(host.id);
+        return {
+            ...host,
+            online,
+            assignedAgents: host.assignedAgents,
+            _links: [selfLink(`/hosts/${hostname}`)],
+            _actions: hostActions(hostname, user, online),
+            _actionTemplates: hostActionTemplates(hostname, hasManageHostsPermission),
+        };
+    });
+    // PUT /:hostname — Update host
+    fastify.put("/:hostname", {
+        preHandler: [requirePermission("manage_hosts")],
+        schema: {
+            description: "Update host name and/or restricted flag",
+            tags: ["Hosts"],
+            params: HostNameParamsSchema,
+            body: UpdateHostRequestSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        try {
+            const { hostname } = request.params;
+            const body = request.body;
+            // Look up host to get id for online check
+            const host = await getHostDetail(hostname);
+            if (!host) {
+                return notFound(reply, `Host "${hostname}" not found`);
+            }
+            // Name change only allowed when offline
+            if (body.name !== undefined && isHostConnected(host.id)) {
+                return badRequest(reply, "Cannot rename an online host. Disconnect it first.");
+            }
+            await updateHost(hostname, body);
+            sendHostsChanged();
+            return { success: true, message: "Host updated" };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not found")) {
+                return notFound(reply, errorMessage);
+            }
+            if (errorMessage.includes("already exists")) {
+                return conflict(reply, errorMessage);
+            }
+            if (errorMessage.includes("must contain only")) {
+                return badRequest(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // DELETE /:hostname — Permanently delete a host
+    fastify.delete("/:hostname", {
+        preHandler: [requirePermission("manage_hosts")],
+        schema: {
+            description: "Permanently delete an offline host",
+            tags: ["Hosts"],
+            params: HostNameParamsSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        const { hostname } = request.params;
+        const hosts = await getHosts();
+        const host = hosts.find((h) => h.name === hostname);
+        if (!host) {
+            return notFound(reply, `Host "${hostname}" not found`);
+        }
+        if (isHostConnected(host.id)) {
+            return badRequest(reply, "Cannot delete an online host. Disconnect it first.");
+        }
+        await deleteHost(hostname);
+        sendHostsChanged();
+        return { success: true, message: "Host permanently deleted" };
+    });
+    // POST /:hostname/agents — Assign agent to host
+    fastify.post("/:hostname/agents", {
+        preHandler: [requirePermission("manage_hosts")],
+        schema: {
+            description: "Assign an agent to this host",
+            tags: ["Hosts"],
+            params: HostNameParamsSchema,
+            body: AssignAgentToHostRequestSchema,
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        try {
+            const { hostname } = request.params;
+            const { agentId } = request.body;
+            await assignAgentToHost(hostname, agentId);
+            sendUserListChanged();
+            emitHostsListChanged();
+            return { success: true, message: "Agent assigned to host" };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not found")) {
+                return notFound(reply, errorMessage);
+            }
+            if (errorMessage.includes("already assigned")) {
+                return conflict(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+    // DELETE /:hostname/agents/:agentName — Unassign agent from host
+    fastify.delete("/:hostname/agents/:agentName", {
+        preHandler: [requirePermission("manage_hosts")],
+        schema: {
+            description: "Unassign an agent from this host",
+            tags: ["Hosts"],
+            params: HostNameParamsSchema.merge(AgentNameParamSchema),
+            response: {
+                200: AgentActionResultSchema,
+                400: ErrorResponseSchema,
+                404: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, async (request, reply) => {
+        try {
+            const { hostname, agentName } = request.params;
+            await unassignAgentFromHost(hostname, agentName);
+            sendUserListChanged();
+            emitHostsListChanged();
+            return { success: true, message: "Agent unassigned from host" };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (errorMessage.includes("not assigned")) {
+                return badRequest(reply, errorMessage);
+            }
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=hosts.js.map

package/dist/routes/models.js

@@ -0,0 +1,152 @@
+import { dbFieldsToImageModel, dbFieldsToLlmModel, ImageModelSchema, LlmModelSchema, } from "@naisys/common";
+import { DeleteModelParamsSchema, DeleteModelResponseSchema, ErrorResponseSchema, ModelsResponseSchema, SaveImageModelRequestSchema, SaveLlmModelRequestSchema, SaveModelResponseSchema, } from "@naisys/supervisor-shared";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { badRequest } from "../error-helpers.js";
+import { API_PREFIX } from "../hateoas.js";
+import { sendModelsChanged } from "../services/hubConnectionService.js";
+import { deleteImageModel, deleteLlmModel, getAllModelsFromDb, saveImageModel, saveLlmModel, } from "../services/modelService.js";
+function modelActions(hasManagePermission) {
+    const actions = [];
+    if (hasManagePermission) {
+        actions.push({
+            rel: "save-llm",
+            href: `${API_PREFIX}/models/llm`,
+            method: "PUT",
+            title: "Save LLM Model",
+            schema: `${API_PREFIX}/schemas/SaveLlmModel`,
+        }, {
+            rel: "save-image",
+            href: `${API_PREFIX}/models/image`,
+            method: "PUT",
+            title: "Save Image Model",
+            schema: `${API_PREFIX}/schemas/SaveImageModel`,
+        }, {
+            rel: "delete",
+            href: `${API_PREFIX}/models/:type/:key`,
+            method: "DELETE",
+            title: "Delete Model",
+        });
+    }
+    return actions;
+}
+export default function modelsRoutes(fastify, _options) {
+    // GET /models — list all models with isCustom flag
+    fastify.get("/models", {
+        schema: {
+            description: "Get available LLM and image model options",
+            tags: ["Models"],
+            response: {
+                200: ModelsResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, _reply) => {
+        const allModels = await getAllModelsFromDb();
+        const llmRows = allModels.filter((r) => r.type === "llm");
+        const imageRows = allModels.filter((r) => r.type === "image");
+        const hasManagePermission = hasPermission(request.supervisorUser, "manage_models");
+        const actions = modelActions(hasManagePermission);
+        return {
+            llmModels: llmRows.map((r) => ({ value: r.key, label: r.label })),
+            imageModels: imageRows.map((r) => ({
+                value: r.key,
+                label: r.label,
+            })),
+            llmModelDetails: llmRows.map((r) => ({
+                ...dbFieldsToLlmModel(r),
+                isCustom: r.is_custom,
+            })),
+            imageModelDetails: imageRows.map((r) => ({
+                ...dbFieldsToImageModel(r),
+                isCustom: r.is_custom,
+            })),
+            _actions: actions.length > 0 ? actions : undefined,
+        };
+    });
+    // PUT /models/llm — upsert custom LLM model
+    fastify.put("/models/llm", {
+        preHandler: [requirePermission("manage_models")],
+        schema: {
+            description: "Create or update a custom LLM model",
+            tags: ["Models"],
+            body: SaveLlmModelRequestSchema,
+            response: {
+                200: SaveModelResponseSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            // Validate with the full common schema (includes superRefine)
+            const parsed = LlmModelSchema.parse(request.body.model);
+            const result = await saveLlmModel(parsed);
+            sendModelsChanged();
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to save LLM model";
+            return badRequest(reply, message);
+        }
+    });
+    // PUT /models/image — upsert custom image model
+    fastify.put("/models/image", {
+        preHandler: [requirePermission("manage_models")],
+        schema: {
+            description: "Create or update a custom image model",
+            tags: ["Models"],
+            body: SaveImageModelRequestSchema,
+            response: {
+                200: SaveModelResponseSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const parsed = ImageModelSchema.parse(request.body.model);
+            const result = await saveImageModel(parsed);
+            sendModelsChanged();
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to save image model";
+            return badRequest(reply, message);
+        }
+    });
+    // DELETE /models/:type/:key — delete a custom model
+    fastify.delete("/models/:type/:key", {
+        preHandler: [requirePermission("manage_models")],
+        schema: {
+            description: "Delete a custom model (reverts to built-in if one exists)",
+            tags: ["Models"],
+            params: DeleteModelParamsSchema,
+            response: {
+                200: DeleteModelResponseSchema,
+                400: ErrorResponseSchema,
+                500: ErrorResponseSchema,
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { type, key } = request.params;
+            let result;
+            if (type === "llm") {
+                result = await deleteLlmModel(key);
+            }
+            else if (type === "image") {
+                result = await deleteImageModel(key);
+            }
+            else {
+                return badRequest(reply, "Invalid model type");
+            }
+            sendModelsChanged();
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to delete model";
+            return reply.code(500).send({ success: false, message });
+        }
+    });
+}
+//# sourceMappingURL=models.js.map

package/dist/routes/root.js

@@ -0,0 +1,56 @@
+import { PermissionEnum } from "@naisys/supervisor-shared";
+const API_PREFIX = "/supervisor/api";
+export default function rootRoutes(fastify, _options) {
+    fastify.get("/", {
+        schema: {
+            description: "API discovery root",
+            tags: ["Discovery"],
+        },
+    }, (request) => {
+        const links = [
+            { rel: "self", href: `${API_PREFIX}/` },
+            {
+                rel: "auth-me",
+                href: `${API_PREFIX}/auth/me`,
+                title: "Current User",
+            },
+            { rel: "schemas", href: `${API_PREFIX}/schemas/`, title: "Schemas" },
+            { rel: "agents", href: `${API_PREFIX}/agents`, title: "Agents" },
+            { rel: "hosts", href: `${API_PREFIX}/hosts`, title: "Hosts" },
+            { rel: "models", href: `${API_PREFIX}/models`, title: "Models" },
+            {
+                rel: "variables",
+                href: `${API_PREFIX}/variables`,
+                title: "Variables",
+            },
+            {
+                rel: "permissions",
+                href: `${API_PREFIX}/permissions`,
+                title: "Available Permissions",
+            },
+        ];
+        // Only show user management links if user has supervisor_admin permission
+        if (request.supervisorUser?.permissions.includes("supervisor_admin")) {
+            links.push({
+                rel: "users",
+                href: `${API_PREFIX}/users`,
+                title: "User Management",
+            });
+            links.push({
+                rel: "admin",
+                href: `${API_PREFIX}/admin`,
+                title: "Admin",
+            });
+        }
+        return { _links: links };
+    });
+    fastify.get("/permissions", {
+        schema: {
+            description: "List all available permissions",
+            tags: ["Discovery"],
+        },
+    }, () => {
+        return { permissions: PermissionEnum.options };
+    });
+}
+//# sourceMappingURL=root.js.map

package/dist/routes/schemas.js

@@ -0,0 +1,31 @@
+import { z } from "zod/v4";
+import { schemaRegistry } from "../schema-registry.js";
+export default function schemaRoutes(fastify) {
+    // List all available schema names
+    fastify.get("/", {
+        schema: {
+            description: "List all available schema names",
+            tags: ["Discovery"],
+        },
+        handler: () => {
+            return { schemas: Object.keys(schemaRegistry) };
+        },
+    });
+    // Get a single schema by name
+    fastify.get("/:schemaName", {
+        schema: {
+            description: "Get a JSON Schema by name",
+            tags: ["Discovery"],
+        },
+        handler: (request, reply) => {
+            const { schemaName } = request.params;
+            const zodSchema = schemaRegistry[schemaName];
+            if (!zodSchema) {
+                reply.code(404);
+                return { error: "Schema not found", schemaName };
+            }
+            return z.toJSONSchema(zodSchema);
+        },
+    });
+}
+//# sourceMappingURL=schemas.js.map

package/dist/routes/status.js

@@ -0,0 +1,20 @@
+import { ErrorResponseSchema, StatusResponseSchema, } from "@naisys/supervisor-shared";
+import { isHubConnected } from "../services/hubConnectionService.js";
+export default function statusRoutes(fastify, _options) {
+    fastify.get("/status", {
+        schema: {
+            description: "Get server status including hub connection",
+            tags: ["Status"],
+            response: {
+                200: StatusResponseSchema,
+                401: ErrorResponseSchema,
+            },
+            security: [{ cookieAuth: [] }],
+        },
+    }, () => {
+        return {
+            hubConnected: isHubConnected(),
+        };
+    });
+}
+//# sourceMappingURL=status.js.map