@paroicms/site-generator-plugin/backend/dist/commands/execute-command.js

ParoiCMS Site Generator Plugin

import { messageOf } from "@paroicms/public-anywhere-lib";
import { fetchWorkSession, loadStep } from "../db/db-read.queries.js";
import { insertIssueEvent, updateSession } from "../db/db-write.queries.js";
import { invokeMessageGuard } from "../generator/llm-queries/invoke-message-guard.js";
import { startInitialAnalysis } from "../generator/llm-queries/invoke-new-site-analysis.js";
import { startUpdateSiteSchema } from "../generator/llm-queries/invoke-update-site-schema.js";
import { generateSite } from "../generator/site-generator/site-generator.js";
import { newSessionCommand, renewSessionCommand, verifySessionToken } from "./generator-session.js";
export async function executeCommand(commandCtx, input) {
    if (input.command === "newSession") {
        return {
            success: true,
            result: await newSessionCommand(commandCtx, input),
        };
    }
    if (input.command === "renewSession") {
        return {
            success: true,
            result: await renewSessionCommand(commandCtx, input),
        };
    }
    const { sessionId } = await verifySessionToken(commandCtx, input.sessionToken);
    const ctx = {
        ...commandCtx,
        sessionId,
    };
    try {
        if (input.command === "setLanguage") {
            await updateSession(ctx, { language: input.language });
            return {
                success: true,
                result: { updated: true },
            };
        }
        if (input.command === "loadWorkSession") {
            return {
                success: true,
                result: await fetchWorkSession(ctx),
            };
        }
        if (input.command === "loadStep") {
            return {
                success: true,
                result: await loadStep(ctx, input.stepNumber),
            };
        }
        if (input.command === "createSiteSchema") {
            const guardResult = await invokeMessageGuard(ctx, input);
            if ("success" in guardResult)
                return guardResult;
            return {
                success: true,
                result: await startInitialAnalysis(ctx, input),
                detectedLanguage: guardResult.detectedLanguage,
            };
        }
        if (input.command === "updateSiteSchema") {
            const guardResult = await invokeMessageGuard(ctx, input, { skipOutOfScopeCheck: true });
            if ("success" in guardResult)
                return guardResult;
            return {
                success: true,
                result: await startUpdateSiteSchema(ctx, input),
            };
        }
        if (input.command === "generateSite") {
            return {
                success: true,
                result: await generateSite(ctx, input),
            };
        }
        ctx.logger.error(`Invalid command: ${input.command}`);
        return {
            success: false,
            userMessage: "Invalid command",
        };
    }
    catch (error) {
        try {
            await insertIssueEvent(ctx, { eventType: "unexpectedError", issueMessage: messageOf(error) });
        }
        catch {
            ctx.logger.error("Failed to insert issue event", error);
        }
        throw error;
    }
}