@naisys/supervisor 3.0.0-beta.6

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

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