@paroicms/site-generator-plugin 0.9.0 → 0.10.0

package/gen-backend/dist/generator/lib/llm-utils.js

@@ -0,0 +1,8 @@
+export class LlmError extends Error {
+    report;
+    constructor(message, report) {
+        super(message);
+        this.report = report;
+        this.name = "LlmError";
+    }
+}

package/gen-backend/dist/generator/lib/prompt-template.js

@@ -0,0 +1,10 @@
+export function buildPromptTemplate(template) {
+    return (variables) => {
+        let result = template;
+        for (const [key, value] of Object.entries(variables)) {
+            const placeholder = `{{${key}}}`;
+            result = result.replace(new RegExp(placeholder, "g"), value ?? "");
+        }
+        return result;
+    };
+}

package/gen-backend/dist/generator/lib/session-utils.js

@@ -0,0 +1,31 @@
+import { messageOf } from "@paroi/data-formatters-lib";
+import { insertIssueEvent, updateStep } from "../../db/db-write.queries.js";
+export function safeCallStep(ctx, stepHandle, cb) {
+    void safeCallStepExec(ctx, stepHandle, cb);
+}
+async function safeCallStepExec(ctx, stepHandle, cb) {
+    const { logger, sessionId } = ctx;
+    const { stepNumber } = stepHandle;
+    try {
+        await cb();
+    }
+    catch (error) {
+        logger.error(`[${sessionId}]`, error);
+        try {
+            await updateStep(ctx, stepHandle, {
+                status: "failed",
+                currentActivity: null,
+                explanation: null, // TODO: implement error explanation (localized)
+            });
+            await insertIssueEvent(ctx, {
+                eventType: "stepError",
+                issueMessage: messageOf(error),
+                llmTaskName: undefined, // TODO: implement StepError exception with task name
+                stepNumber,
+            });
+        }
+        catch (error) {
+            logger.error(`[${sessionId}] Error after error`, error);
+        }
+    }
+}

package/gen-backend/dist/generator/llm-queries/invoke-message-guard.js

@@ -1,5 +1,6 @@
 import { boolVal, listValOrUndef, strVal, strValOrUndef, } from "@paroi/data-formatters-lib";
-import { updateSession } from "../../db/db.queries.js";
+import { insertIssueEvent } from "../../db/db-write.queries.js";
+import { invokeClaude } from "../lib/calling-llm-anthropic.js";
 import { createPromptTemplate } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
@@ -8,19 +9,25 @@ const guardPrompt = await createPromptTemplate({
 });
 const invalidCauses = new Set(["rude", "malicious", "outOfScope", "technicalLimits", "noSense"]);
 export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = false } = {}) {
-    const debugName = "guard";
+    const llmTaskName = "guard";
     const llmInput = {
         message: input.prompt,
     };
-    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+    const debug = await debugLlmOutput(ctx, llmTaskName, ctx.anthropicModelName, undefined, {
         message: llmInput.message,
     });
-    let llmMessageContent = debug.storedContent;
-    if (!llmMessageContent) {
-        const llmMessage = await guardPrompt.pipe(ctx.goodModel).invoke(llmInput);
-        llmMessageContent = await debug.getMessageContent(llmMessage);
+    let llmOutput = debug.stored;
+    if (!llmOutput) {
+        const { messageContent, report } = await invokeClaude(ctx, {
+            llmTaskName,
+            prompt: guardPrompt(llmInput),
+            maxTokens: 200,
+            temperature: 0.2,
+            systemInstruction: "beFast",
+        });
+        llmOutput = await debug.getMessageContent(messageContent, report);
     }
-    const rawReport = parseLlmResponseAsProperties(llmMessageContent, [
+    const rawReport = parseLlmResponseAsProperties(llmOutput.output, [
         {
             tagName: "guard_yaml",
             key: "guard",
@@ -36,7 +43,11 @@ export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = fal
     }
     if (report.valid)
         return;
-    await updateSession(ctx, { guardCountInc: 1 });
+    await insertIssueEvent(ctx, {
+        eventType: "blockedByGuard",
+        llmTaskName: "guard",
+        issueMessage: report.explanation,
+    });
     return {
         success: false,
         language: report.language,

package/gen-backend/dist/generator/llm-queries/invoke-new-site-analysis.js

@@ -1,72 +1,90 @@
-import { updateSession } from "../../db/db.queries.js";
+import { loadStep } from "../../db/db-read.queries.js";
+import { insertStep, saveCompletedSchemaStep, updateStep, } from "../../db/db-write.queries.js";
 import { reorderObjectKeys } from "../helpers/js-utils.js";
+import { invokeClaude } from "../lib/calling-llm-anthropic.js";
 import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseMarkdownBulletedList } from "../lib/markdown-bulleted-list-parser.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
+import { safeCallStep } from "../lib/session-utils.js";
 import { createL10n } from "../site-schema-generator/create-l10n.js";
 import { createSiteSchemaFromAnalysis } from "../site-schema-generator/create-site-schema.js";
 import { invokeUpdateSiteSchema } from "./invoke-update-site-schema.js";
 export const analyzePrompt = await createPromptTemplate({
-    fileName: "new-site-1-analysis.md",
+    fileName: "initial-1-analysis.md",
     withSiteSchemaTsDefs: true,
 });
 const fieldsPrompt = await createPromptTemplate({
-    fileName: "new-site-2-fields.md",
+    fileName: "initial-2-fields.md",
     withSiteSchemaTsDefs: true,
 });
-export async function invokeNewSiteAnalysis(ctx, input) {
-    const { analysis, explanation, unusedInformation } = await invokeAnalysisStep1(ctx, input);
+export async function startInitialAnalysis(ctx, input) {
+    const stepHandle = await insertStep(ctx, {
+        kind: "initialSchema",
+        status: "pending",
+        currentActivity: "initial1",
+    });
+    safeCallStep(ctx, stepHandle, () => invokeInitialAnalysis(ctx, stepHandle, input));
+    return await loadStep(ctx, stepHandle.stepNumber);
+}
+export async function invokeInitialAnalysis(ctx, stepHandle, input) {
+    const { analysis, unusedInformation, explanation, llmReport: llmReport1, } = await invokeAnalysisStep1(ctx, input, stepHandle);
     const siteSchema = createSiteSchemaFromAnalysis(analysis);
-    const { unusedInformation: unusedInformation2 } = await invokeAnalysisStep2(ctx, { prompt: createUnusedInformationPrompt(unusedInformation, analysis) ?? "" }, siteSchema);
+    await updateStep(ctx, stepHandle, {
+        currentActivity: "initial2",
+        explanation: explanation ?? null,
+    });
+    const { unusedInformation: unusedInformation2, llmReport: llmReport2 } = await invokeAnalysisStep2(ctx, { prompt: createUnusedInformationPrompt(unusedInformation, analysis) ?? "" }, siteSchema, stepHandle);
     reorderSiteSchemaNodeTypes(siteSchema);
     const l10n = createL10n(analysis, siteSchema);
     const siteTitle = {
         [analysis.siteProperties.language]: analysis.siteProperties.title,
     };
+    const completedValues = {
+        status: "completed",
+        siteSchema,
+        l10n,
+        localizedValues: { siteTitle },
+        inputTokenCount: llmReport1.inputTokenCount + llmReport2.inputTokenCount,
+        outputTokenCount: (llmReport1.outputTokenCount ?? 0) + (llmReport2.outputTokenCount ?? 0),
+        promptTitle: undefined, // TODO: implement prompt title
+    };
     if (!unusedInformation2) {
-        await updateSession(ctx, { status: "analyzed", promptCountInc: 1 });
-        return {
-            siteTitle,
-            siteSchema,
-            l10n,
-            changed: true,
-            explanation,
-        };
+        await saveCompletedSchemaStep(ctx, stepHandle, completedValues);
+        return;
     }
     ctx.logger.debug("Unused information:", unusedInformation2);
-    const updated = await invokeUpdateSiteSchema(ctx, {
+    await invokeUpdateSiteSchema(ctx, stepHandle, {
         prompt: unusedInformation2,
-        generatedSchema: {
-            siteTitle,
-            siteSchema,
-            l10n,
-        },
-    }, { asRemainingPrompt: true });
-    await updateSession(ctx, { status: "analyzed", promptCountInc: 1 });
-    return {
-        siteTitle,
-        siteSchema: updated.siteSchema,
-        l10n: updated.l10n,
-        changed: true,
-        explanation: updated.changed ? `${explanation}\n\n${updated.explanation}` : explanation,
-    };
+        fromStepSchema: completedValues,
+    }, {
+        asRemainingOf: completedValues,
+    });
 }
-async function invokeAnalysisStep1(ctx, input) {
-    const debugName = "analysis";
+async function invokeAnalysisStep1(ctx, input, stepHandle) {
+    const llmTaskName = "analysis-1";
     const llmInput = {
         message: input.prompt,
         siteSchemaTsDefs: getSiteSchemaTsDefs(),
     };
-    const debug = await debugLlmOutput(ctx, debugName, ctx.bestModelName, {
+    const debug = await debugLlmOutput(ctx, llmTaskName, ctx.anthropicModelName, stepHandle, {
         message: llmInput.message,
     });
-    let llmMessageContent = debug.storedContent;
-    if (!llmMessageContent) {
-        const llmMessage = await analyzePrompt.pipe(ctx.bestModel).invoke(llmInput);
-        llmMessageContent = await debug.getMessageContent(llmMessage);
+    let llmOutput = debug.stored;
+    if (!llmOutput) {
+        // Create formatted messages using the template
+        const prompt = analyzePrompt(llmInput);
+        // Call the model
+        const { messageContent, report } = await invokeClaude(ctx, {
+            llmTaskName,
+            prompt,
+            maxTokens: 4_000,
+            temperature: 0.1,
+            systemInstruction: "beSmart",
+        });
+        llmOutput = await debug.getMessageContent(messageContent, report);
     }
-    const rawAnalysis = parseLlmResponseAsProperties(llmMessageContent, [
+    const rawAnalysis = parseLlmResponseAsProperties(llmOutput.output, [
         {
             tagName: "website_properties_yaml",
             key: "siteProperties",
@@ -102,30 +120,38 @@ async function invokeAnalysisStep1(ctx, input) {
     };
     return {
         analysis,
-        explanation: rawAnalysis.explanation,
         unusedInformation: rawAnalysis.unusedInformation,
+        explanation: rawAnalysis.explanation,
+        llmReport: llmOutput.llmReport,
     };
 }
 async function invokeAnalysisStep2(ctx, input, 
 /** Will be mutated. */
-siteSchema) {
-    const debugName = "assign-fields";
+siteSchema, stepHandle) {
+    const llmTaskName = "analysis-2";
     const llmInput = {
         siteSchemaTsDefs: getSiteSchemaTsDefs(),
         predefinedFields: JSON.stringify(getPredefinedFields(), undefined, 2),
         siteSchemaJson: JSON.stringify(siteSchema, undefined, 2),
         message: input.prompt,
     };
-    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+    const debug = await debugLlmOutput(ctx, llmTaskName, ctx.anthropicModelName, stepHandle, {
         message: llmInput.message,
         siteSchemaJson: llmInput.siteSchemaJson,
     });
-    let llmMessageContent = debug.storedContent;
-    if (!llmMessageContent) {
-        const llmMessage = await fieldsPrompt.pipe(ctx.goodModel).invoke(llmInput);
-        llmMessageContent = await debug.getMessageContent(llmMessage);
+    let llmOutput = debug.stored;
+    if (!llmOutput) {
+        const prompt = fieldsPrompt(llmInput);
+        const { messageContent, report } = await invokeClaude(ctx, {
+            llmTaskName,
+            prompt,
+            maxTokens: 700,
+            temperature: 0.1,
+            systemInstruction: "beFast",
+        });
+        llmOutput = await debug.getMessageContent(messageContent, report);
     }
-    const { assignedFields, unusedInformation } = parseLlmResponseAsProperties(llmMessageContent, [
+    const { assignedFields, unusedInformation } = parseLlmResponseAsProperties(llmOutput.output, [
         {
             tagName: "yaml_result",
             key: "assignedFields",
@@ -141,7 +167,7 @@ siteSchema) {
     if (siteSchema.nodeTypes) {
         assignFieldsToNodeTypes(ctx, assignedFields, siteSchema.nodeTypes);
     }
-    return { unusedInformation };
+    return { unusedInformation, llmReport: llmOutput.llmReport };
 }
 function assignFieldsToNodeTypes(ctx, assignedFields, nodeTypes) {
     const remainingTypeNames = new Set(Object.keys(assignedFields));

package/gen-backend/dist/generator/llm-queries/invoke-update-site-schema.js

@@ -1,56 +1,92 @@
-import { updateSession } from "../../db/db.queries.js";
+import { loadStep, readStepSchema } from "../../db/db-read.queries.js";
+import { insertStep, saveCompletedSchemaStep, updateStep, } from "../../db/db-write.queries.js";
+import { invokeClaude } from "../lib/calling-llm-anthropic.js";
 import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
+import { safeCallStep } from "../lib/session-utils.js";
 const prompt1Tpl = await createPromptTemplate({
     fileName: "update-site-schema-1-write-details.md",
 });
 const prompt2Tpl = await createPromptTemplate({
     fileName: "update-site-schema-2-execute.md",
 });
-export async function invokeUpdateSiteSchema(ctx, input, { asRemainingPrompt = false } = {}) {
-    const task = await invokeUpdateSiteSchemaStep1(ctx, input);
-    if (!task.taskDetailsMd) {
-        // no changes
-        return {
-            ...input.generatedSchema,
-            changed: false,
-            explanation: task.explanation,
-        };
-    }
-    const genSchema = await invokeUpdateSiteSchemaStep2(ctx, {
-        taskDetailsMd: task.taskDetailsMd,
-        generatedSchema: input.generatedSchema,
+export async function startUpdateSiteSchema(ctx, input) {
+    const fromStepSchema = await readStepSchema(ctx, input.fromStepNumber);
+    const stepHandle = await insertStep(ctx, {
+        kind: "updateSchema",
+        status: "pending",
+        currentActivity: "updating1",
     });
-    if (!asRemainingPrompt) {
-        await updateSession(ctx, { status: "updated", promptCountInc: 1 });
+    safeCallStep(ctx, stepHandle, () => invokeUpdateSiteSchema(ctx, stepHandle, { prompt: input.prompt, fromStepSchema }));
+    return await loadStep(ctx, stepHandle.stepNumber);
+}
+export async function invokeUpdateSiteSchema(ctx, stepHandle, input, { asRemainingOf } = {}) {
+    const { properties, llmReport: llmReport1 } = await invokeUpdateSiteSchemaStep1(ctx, input, stepHandle);
+    if (!properties.taskDetailsMd) {
+        await updateStep(ctx, stepHandle, {
+            status: "noEffect",
+            currentActivity: null,
+            explanation: properties.explanation,
+        });
+        return;
     }
-    return {
-        ...genSchema,
-        changed: true,
-        explanation: task.explanation,
+    await updateStep(ctx, stepHandle, {
+        currentActivity: "updating2",
+        explanation: properties.explanation,
+    });
+    const { stepSchema, llmReport: llmReport2 } = await invokeUpdateSiteSchemaStep2(ctx, {
+        taskDetailsMd: properties.taskDetailsMd,
+        fromStepSchema: input.fromStepSchema,
+    }, stepHandle);
+    const completedValues = {
+        ...stepSchema,
+        status: "completed",
+        inputTokenCount: llmReport1.inputTokenCount + llmReport2.inputTokenCount,
+        outputTokenCount: (llmReport1.outputTokenCount ?? 0) + (llmReport2.outputTokenCount ?? 0),
+        promptTitle: undefined, // TODO: implement prompt title
     };
+    if (asRemainingOf) {
+        completedValues.inputTokenCount += asRemainingOf.inputTokenCount;
+        completedValues.outputTokenCount += asRemainingOf.outputTokenCount;
+        completedValues.promptTitle = undefined;
+        if (asRemainingOf.explanation) {
+            completedValues.explanation = properties.explanation
+                ? `${asRemainingOf.explanation}\n\n${properties.explanation}`
+                : asRemainingOf.explanation;
+        }
+    }
+    await saveCompletedSchemaStep(ctx, stepHandle, completedValues);
 }
-async function invokeUpdateSiteSchemaStep1(ctx, input) {
-    const debugName = "update-step1";
+async function invokeUpdateSiteSchemaStep1(ctx, input, stepHandle) {
+    const llmTaskName = "update-step1";
     const llmInput = {
         siteSchemaTsDefs: getSiteSchemaTsDefs(),
         predefinedFields: JSON.stringify(getPredefinedFields(), undefined, 2),
-        siteSchemaJson: JSON.stringify(input.generatedSchema.siteSchema, undefined, 2),
-        l10nJson: JSON.stringify(input.generatedSchema.l10n, undefined, 2),
+        siteSchemaJson: JSON.stringify(input.fromStepSchema.siteSchema, undefined, 2),
+        l10nJson: JSON.stringify(input.fromStepSchema.l10n, undefined, 2),
         updateMessage: input.prompt,
     };
-    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+    const debug = await debugLlmOutput(ctx, llmTaskName, ctx.anthropicModelName, stepHandle, {
         updateMessage: llmInput.updateMessage,
         siteSchemaJson: llmInput.siteSchemaJson,
         l10nJson: llmInput.l10nJson,
     });
-    let llmMessageContent = debug.storedContent;
-    if (!llmMessageContent) {
-        const llmMessage = await prompt1Tpl.pipe(ctx.goodModel).invoke(llmInput);
-        llmMessageContent = await debug.getMessageContent(llmMessage);
+    let llmOutput = debug.stored;
+    if (!llmOutput) {
+        // Create formatted messages using the template
+        const message = prompt1Tpl(llmInput);
+        // Call the model
+        const { messageContent, report } = await invokeClaude(ctx, {
+            llmTaskName,
+            prompt: message,
+            maxTokens: 1_500,
+            temperature: 0.1,
+            systemInstruction: "beSmart",
+        });
+        llmOutput = await debug.getMessageContent(messageContent, report);
     }
-    return parseLlmResponseAsProperties(llmMessageContent, [
+    const properties = parseLlmResponseAsProperties(llmOutput.output, [
         {
             tagName: "task_details_md",
             key: "taskDetailsMd",
@@ -63,27 +99,40 @@ async function invokeUpdateSiteSchemaStep1(ctx, input) {
             format: "markdown",
         },
     ]);
+    return {
+        properties,
+        llmReport: llmOutput.llmReport,
+    };
 }
-async function invokeUpdateSiteSchemaStep2(ctx, input) {
-    const debugName = "update-step2";
+async function invokeUpdateSiteSchemaStep2(ctx, input, stepHandle) {
+    const llmTaskName = "update-step2";
     const llmInput = {
         siteSchemaTsDefs: getSiteSchemaTsDefs(),
         predefinedFields: JSON.stringify(getPredefinedFields(), undefined, 2),
-        siteSchemaJson: JSON.stringify(input.generatedSchema.siteSchema, undefined, 2),
-        l10nJson: JSON.stringify(input.generatedSchema.l10n, undefined, 2),
+        siteSchemaJson: JSON.stringify(input.fromStepSchema.siteSchema, undefined, 2),
+        l10nJson: JSON.stringify(input.fromStepSchema.l10n, undefined, 2),
         taskDetailsMd: input.taskDetailsMd,
     };
-    const debug = await debugLlmOutput(ctx, debugName, ctx.bestModelName, {
+    const debug = await debugLlmOutput(ctx, llmTaskName, ctx.anthropicModelName, stepHandle, {
         taskDetailsMd: llmInput.taskDetailsMd,
         siteSchemaJson: llmInput.siteSchemaJson,
         l10nJson: llmInput.l10nJson,
     });
-    let llmMessageContent = debug.storedContent;
-    if (!llmMessageContent) {
-        const llmMessage = await prompt2Tpl.pipe(ctx.bestModel).invoke(llmInput);
-        llmMessageContent = await debug.getMessageContent(llmMessage);
+    let llmOutput = debug.stored;
+    if (!llmOutput) {
+        // Create formatted messages using the template
+        const message = prompt2Tpl(llmInput);
+        // Call the model
+        const { messageContent, report } = await invokeClaude(ctx, {
+            llmTaskName,
+            prompt: message,
+            maxTokens: 7_000,
+            temperature: 0.1,
+            systemInstruction: "beSmart",
+        });
+        llmOutput = await debug.getMessageContent(messageContent, report);
     }
-    const parsed = parseLlmResponseAsProperties(llmMessageContent, [
+    const parsed = parseLlmResponseAsProperties(llmOutput.output, [
         {
             tagName: "updated_site_schema_json",
             key: "siteSchema",
@@ -98,7 +147,7 @@ async function invokeUpdateSiteSchemaStep2(ctx, input) {
         },
     ]);
     const result = {
-        ...input.generatedSchema,
+        ...input.fromStepSchema,
     };
     if (parsed.siteSchema) {
         result.siteSchema = fixSiteSchema(parsed.siteSchema);
@@ -106,16 +155,30 @@ async function invokeUpdateSiteSchemaStep2(ctx, input) {
     if (parsed.l10n) {
         result.l10n = parsed.l10n;
     }
-    return result;
+    return {
+        stepSchema: result,
+        llmReport: llmOutput.llmReport,
+    };
 }
 function fixSiteSchema(siteSchema) {
     for (const nodeType of siteSchema.nodeTypes ?? []) {
-        for (const field of nodeType.fields ?? []) {
+        if (!nodeType.fields)
+            continue;
+        // Add Quill plugin to fields with renderAs "html"
+        for (const field of nodeType.fields) {
             if (typeof field !== "string" && field.renderAs === "html") {
                 field.dataType = "json";
                 field.plugin = "@paroicms/quill-editor-plugin";
             }
         }
+        // Move labeling fields to the beginning of the fields array
+        const labelingFields = nodeType.fields.filter((f) => typeof f !== "string" && f.storedAs === "labeling");
+        if (labelingFields.length > 0) {
+            nodeType.fields = [
+                ...labelingFields,
+                ...nodeType.fields.filter((f) => typeof f === "string" || f.storedAs !== "labeling"),
+            ];
+        }
     }
     return siteSchema;
 }

package/gen-backend/dist/generator/site-generator/site-generator.js

@@ -1,13 +1,22 @@
 import { generateSlug } from "@paroicms/public-anywhere-lib";
+import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { updateSession } from "../../db/db.queries.js";
+import { loadStep, readStepSchema } from "../../db/db-read.queries.js";
+import { insertStep, saveGeneratedSiteStep, } from "../../db/db-write.queries.js";
 import { fillSiteWithFakeContent } from "../fake-content-generator.ts/create-database-with-fake-content.js";
+import { safeCallStep } from "../lib/session-utils.js";
 import { createTheme } from "./theme-creator.js";
 export async function generateSite(ctx, input) {
     const { service, logger, sitesDir, packConf: { packName }, } = ctx;
-    const { generatedSchema: { l10n, siteSchema, siteTitle }, withFakeContent, } = input;
-    const siteId = ctx.sessionId;
+    const { fromStepNumber, withSampleData } = input;
+    const stepHandle = await insertStep(ctx, {
+        kind: "generateSite",
+        status: "pending",
+        currentActivity: "generatingSite",
+    });
+    const { l10n, siteSchema, localizedValues } = await readStepSchema(ctx, fromStepNumber);
+    const siteId = randomUUID();
     logger.info(`Generating site: ${siteId}…`);
     const siteDir = join(sitesDir, siteId);
     await mkdir(siteDir);
@@ -16,7 +25,9 @@ export async function generateSite(ctx, input) {
         await writeFile(join(siteDir, `site-schema.l10n.${language}.json`), JSON.stringify(l10nData, null, 2), "utf-8");
     }
     await writeFile(join(siteDir, "package.json"), JSON.stringify(getPackageJsonContent({
-        siteTitle: siteTitle.en ?? Object.values(siteTitle)[0] ?? "new-website",
+        siteTitle: localizedValues.siteTitle.en ??
+            Object.values(localizedValues.siteTitle)[0] ??
+            "new-website",
     }), null, 2), "utf-8");
     await createTheme(ctx, siteDir, siteSchema);
     const regSite = await service.connector.registerNewSite({
@@ -25,12 +36,6 @@ export async function generateSite(ctx, input) {
         domain: siteId,
         version: "0.0.0",
     });
-    if (withFakeContent) {
-        const report = await fillSiteWithFakeContent(ctx, { regSite, siteTitle });
-        await updateSession(ctx, {
-            contentCountInc: report.getContentCount(),
-        });
-    }
     const account = {
         kind: "local",
         email: `${siteId}@yopmail.com`,
@@ -39,16 +44,19 @@ export async function generateSite(ctx, input) {
     };
     await ctx.service.connector.createAccount(regSite.fqdn, account, { asContactEmail: true });
     const { siteUrl } = regSite;
-    await updateSession(ctx, {
-        status: "generated",
-        nodeTypeCount: siteSchema.nodeTypes?.length ?? 0,
-    });
-    return {
+    const values = {
+        status: withSampleData ? "pending" : "completed",
         siteId,
-        url: siteUrl,
-        boUrl: `${siteUrl}/adm`,
-        account,
+        siteUrl,
+        localizedValues,
+        loginEmail: account.email,
+        loginPassword: account.password,
     };
+    await saveGeneratedSiteStep(ctx, stepHandle, values);
+    if (withSampleData) {
+        safeCallStep(ctx, stepHandle, () => fillSiteWithFakeContent(ctx, stepHandle, { regSite, localizedValues }));
+    }
+    return await loadStep(ctx, stepHandle.stepNumber);
 }
 function getPackageJsonContent(options) {
     return {

package/gen-backend/dist/lib/create-raw-context.js

@@ -0,0 +1,31 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { Mistral } from "@mistralai/mistralai";
+import { getJwtSecretSync } from "@paroicms/internal-server-lib";
+import { join } from "node:path";
+export function createRawContext(service, options) {
+    const { cn, logNextQuery, pluginConf, debugDir } = options;
+    const packConf = service.connector.getSitePackConf(pluginConf.packName);
+    const { sitesDir, packName } = packConf;
+    if (!sitesDir || packConf.serveOn !== "subDomain") {
+        throw new Error(`Site-generator plugin can generate sites only for sub-domain pack with "sitesDir", but pack "${packName}" doesn't have it`);
+    }
+    return {
+        cn,
+        logNextQuery,
+        jwtSecret: getJwtSecretSync(join(service.registeredSite.dataDir, "site-generator-secret.txt")),
+        pluginConf,
+        debugDir,
+        sitesDir,
+        packConf,
+        service,
+        logger: service.logger,
+        anthropic: new Anthropic({
+            apiKey: pluginConf.anthropicApiKey,
+        }),
+        mistral: new Mistral({
+            apiKey: pluginConf.mistralApiKey,
+        }),
+        mistralModelName: "ministral-8b-2410",
+        anthropicModelName: "claude-3-7-sonnet-20250219",
+    };
+}

package/gen-backend/dist/lib/site-remover.js

@@ -13,7 +13,7 @@ export function startSiteRemover(ctx) {
         catch (error) {
             ctx.logger.error("[site-remover]", error);
         }
-    }, 1000 * 60 * 60).unref(); // Check every hour
+    }, 1000 * 60 * 60).unref();
     return {
         stop() {
             clearInterval(runningId);