@paroicms/site-generator-plugin 0.7.0 → 0.8.0

package/gen-backend/ddl/site-generator.ddl.sql

@@ -0,0 +1,22 @@
+PRAGMA journal_mode = TRUNCATE;
+PRAGMA foreign_keys = 1;
+
+create table PaMetadata (
+  dbSchema varchar(100) not null,
+  k varchar(100) not null,
+  val varchar(250) not null,
+  primary key (dbSchema, k)
+);
+
+insert into PaMetadata (dbSchema, k, val) values ('site-generator', 'dbSchemaVersion', '1');
+
+create table PaGenSession (
+  id char(36) not null primary key,
+  createdAt timestamp not null default current_timestamp,
+  status varchar(100) not null,
+  guardCount integer not null default 0,
+  promptCount integer not null default 0,
+  nodeTypeCount integer not null default 0,
+  contentCount integer not null default 0,
+  errorMessage varchar(500)
+);

package/gen-backend/dist/commands/execute-command.js

@@ -0,0 +1,60 @@
+import { messageOf } from "@paroi/data-formatters-lib";
+import { updateSession } from "../db/db.queries.js";
+import { invokeMessageGuard } from "../generator/llm-queries/invoke-message-guard.js";
+import { invokeNewSiteAnalysis } from "../generator/llm-queries/invoke-new-site-analysis.js";
+import { invokeUpdateSiteSchema } from "../generator/llm-queries/invoke-update-site-schema.js";
+import { generateSite } from "../generator/site-generator/site-generator.js";
+import { newSession, verifySessionToken } from "./generator-session.js";
+export async function executeCommand(commandCtx, input) {
+    if (input.command === "newSession") {
+        return {
+            success: true,
+            result: await newSession(commandCtx, input),
+        };
+    }
+    const { sessionId } = await verifySessionToken(commandCtx, input.sessionToken);
+    const ctx = {
+        ...commandCtx,
+        sessionId,
+    };
+    try {
+        if (input.command === "createSiteSchema") {
+            const errorResponse = await invokeMessageGuard(ctx, input);
+            if (errorResponse)
+                return errorResponse;
+            return {
+                success: true,
+                result: await invokeNewSiteAnalysis(ctx, input),
+            };
+        }
+        if (input.command === "updateSiteSchema") {
+            const errorResponse = await invokeMessageGuard(ctx, input, { skipOutOfScopeCheck: true });
+            if (errorResponse)
+                return errorResponse;
+            return {
+                success: true,
+                result: await invokeUpdateSiteSchema(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 updateSession(ctx, { status: "error", errorMessage: messageOf(error) });
+        }
+        catch {
+            ctx.logger.error("Failed to update session error message", error);
+        }
+        throw error;
+    }
+}

package/gen-backend/dist/{generator/session → commands}/generator-session.js

@@ -1,24 +1,25 @@
 import { ApiError } from "@paroicms/public-server-lib";
-import { nanoid } from "nanoid";
+import { randomUUID } from "node:crypto";
+import { insertSession, readSession } from "../db/db.queries.js";
 const { sign, verify } = (await import("jsonwebtoken")).default;
-const JWT_SECRET = "init"; // FIXME: Hardcoded JWT secret as specified
 export async function newSession(ctx, command) {
     const { service } = ctx;
     const { recaptchaToken } = command;
     const isValid = await service.validateRecaptchaResponse(recaptchaToken);
     if (!isValid)
         throw new ApiError("Invalid reCAPTCHA token", 400);
-    const sessionId = nanoid();
-    const token = sign({ sessionId }, JWT_SECRET, { expiresIn: "24h" });
+    const sessionId = randomUUID();
+    const token = sign({ sessionId }, ctx.jwtSecret, { expiresIn: "48h" });
+    await insertSession(ctx, { sessionId });
     return { token };
 }
 /**
  * Verifies a session token and returns the session ID if valid
  */
-export function verifySessionToken(token) {
+export async function verifySessionToken(ctx, token) {
     let payload;
     try {
-        payload = verify(token, JWT_SECRET);
+        payload = verify(token, ctx.jwtSecret);
     }
     catch (error) {
         if (error.name === "TokenExpiredError")
@@ -27,7 +28,14 @@ export function verifySessionToken(token) {
             throw new ApiError("Invalid session token", 401);
         throw error;
     }
-    if (!payload || !payload.sessionId)
+    if (!payload || !("sessionId" in payload) || typeof payload.sessionId !== "string") {
         throw new ApiError("Invalid session token", 401);
-    return payload.sessionId;
+    }
+    const sessionId = payload.sessionId;
+    const session = await readSession(ctx, sessionId);
+    if (!session)
+        throw new ApiError(`Missing session "${sessionId}"`, 500);
+    if (session.promptCount >= 20)
+        throw new ApiError("Session consumed", 401);
+    return { sessionId };
 }

package/gen-backend/dist/context.js

@@ -1,2 +1,8 @@
+import { strVal } from "@paroi/data-formatters-lib";
 import { resolveModuleDirectory } from "@paroicms/public-server-lib";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 export const projectDir = resolveModuleDirectory(import.meta.url, { parent: true });
+export const packageDir = dirname(projectDir);
+export const pluginVersion = strVal(JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8")).version);
+export const SLUG = "site-generator";

package/gen-backend/dist/db/db-init.js

@@ -0,0 +1,35 @@
+import { createOrOpenSqliteConnection, createSqlLogger, getMetadataDbSchemaVersion, } from "@paroicms/internal-server-lib";
+import { join } from "node:path";
+import { projectDir } from "../context.js";
+import { currentDbSchemaVersion, dbSchemaName, migrateSiteGeneratorDb } from "./ddl-migration.js";
+export async function createOrOpenSiteGeneratorConnection({ sqliteFile, canCreate, logger, }) {
+    const { logNextQuery, knexLogger } = createSqlLogger({ logger, dbSchemaName });
+    const { cn } = await createOrOpenSqliteConnection({
+        canCreate,
+        dbSchemaName,
+        sqliteFile,
+        ddlFile: join(projectDir, "ddl", "site-generator.ddl.sql"),
+        migrateDb,
+        knexLogger,
+        logger,
+    });
+    async function migrateDb(cn) {
+        const dbVersion = await getMetadataDbSchemaVersion(cn, { dbSchemaName });
+        if (dbVersion === currentDbSchemaVersion) {
+            return {
+                migrated: false,
+                schemaVersion: dbVersion,
+            };
+        }
+        await migrateSiteGeneratorDb(cn, {
+            fromVersion: dbVersion,
+            logger,
+        });
+        return {
+            migrated: true,
+            fromVersion: dbVersion,
+            schemaVersion: currentDbSchemaVersion,
+        };
+    }
+    return { cn, logNextQuery };
+}

package/gen-backend/dist/db/db.queries.js

@@ -0,0 +1,60 @@
+import { strVal } from "@paroi/data-formatters-lib";
+export async function readSession(ctx, sessionId) {
+    const { cn } = ctx;
+    const row = await cn("PaGenSession")
+        .select("id", "status", "guardCount", "promptCount", "nodeTypeCount", "contentCount", "errorMessage")
+        .where({ id: sessionId })
+        .first();
+    if (!row)
+        return;
+    return {
+        id: strVal(row.id),
+        createdAt: strVal(row.createdAt),
+        status: formatSessionStatus(row.status),
+        guardCount: Number(row.guardCount),
+        promptCount: Number(row.promptCount),
+        nodeTypeCount: Number(row.nodeTypeCount),
+        contentCount: Number(row.contentCount),
+        errorMessage: strVal(row.errorMessage),
+    };
+}
+export async function insertSession(ctx, { sessionId }) {
+    const { cn } = ctx;
+    await cn("PaGenSession").insert({
+        id: sessionId,
+        status: "started",
+    });
+}
+export async function updateSession(ctx, values) {
+    const { sessionId, cn } = ctx;
+    const { status, guardCountInc, promptCountInc, nodeTypeCount, contentCountInc, errorMessage } = values;
+    const affected = await cn("PaGenSession")
+        .where({
+        id: sessionId,
+    })
+        .update({
+        status,
+        guardCountInc: guardCountInc ? cn.raw(`guardCount + ${guardCountInc}`) : undefined,
+        promptCount: promptCountInc ? cn.raw(`promptCount + ${promptCountInc}`) : undefined,
+        nodeTypeCount,
+        contentCount: contentCountInc ? cn.raw(`contentCount + ${contentCountInc}`) : undefined,
+        errorMessage,
+    });
+    if (affected !== 1) {
+        throw new Error(`Session "${sessionId}" not found`);
+    }
+}
+function formatSessionStatus(val) {
+    const v = strVal(val);
+    if (v === "started")
+        return "started";
+    if (v === "analyzed")
+        return "analyzed";
+    if (v === "updated")
+        return "updated";
+    if (v === "generated")
+        return "generated";
+    if (v === "error")
+        return "error";
+    throw new Error(`Invalid session status: "${val}"`);
+}

package/gen-backend/dist/db/ddl-migration.js

@@ -0,0 +1,15 @@
+export const dbSchemaName = "site-generator";
+export const currentDbSchemaVersion = 1;
+export async function migrateSiteGeneratorDb(_cn, { fromVersion, logger }) {
+    const toVersion = currentDbSchemaVersion;
+    const currentVersion = fromVersion;
+    if (currentVersion === 1) {
+        // await cn.raw("...");
+        // await setMetadataDbSchemaVersion(cn, { dbSchemaName, value: 2 });
+        // currentVersion = 2;
+    }
+    if (currentVersion !== toVersion) {
+        throw new Error(`version of ${dbSchemaName} database should be '${toVersion}', but is '${currentVersion}'`);
+    }
+    logger.info(`${dbSchemaName} database was migrated from ${fromVersion} to ${currentVersion}`);
+}

package/gen-backend/dist/generator/fake-content-generator.ts/content-report.js

@@ -0,0 +1,11 @@
+export function createGeneratedContentReport() {
+    let contentCount = 0;
+    return {
+        getContentCount() {
+            return contentCount;
+        },
+        addContentCount(count) {
+            contentCount += count;
+        },
+    };
+}

package/gen-backend/dist/generator/fake-content-generator.ts/create-database-with-fake-content.js

@@ -2,19 +2,21 @@ import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentType
 import { createSimpleTranslator, } from "@paroicms/public-server-lib";
 import { getRandomImagePath } from "../lib/images-lib.js";
 import { createTaskCollector } from "../lib/tasks.js";
+import { createGeneratedContentReport } from "./content-report.js";
 import { generateLocalizedFooterMention } from "./create-node-contents.js";
 import { generateFieldSetContent, generateMultipleFieldSetContents, } from "./generate-fake-content.js";
-export async function fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle, }) {
+export async function fillSiteWithFakeContent(ctx, { regSite, siteTitle }) {
     const { service } = ctx;
-    const { fqdn } = siteConf;
+    const { fqdn } = regSite;
+    const report = createGeneratedContentReport();
     const { siteSchema, siteIds } = await service.connector.loadSiteSchemaAndIds(fqdn);
     const schemaI18n = createSimpleTranslator({
         labels: siteSchema.l10n,
         logger: ctx.logger,
     });
-    await updateSiteFields(ctx, { fqdn, siteSchema, siteId, siteTitle });
+    await updateSiteFields(ctx, report, { fqdn, siteSchema, siteTitle });
     const tasks = createTaskCollector(ctx);
-    fillRoutingDocumentAndAddChildren(ctx, tasks, {
+    fillRoutingDocumentAndAddChildren(ctx, tasks, report, {
         fqdn,
         siteSchema,
         schemaI18n,
@@ -28,15 +30,16 @@ export async function fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle
         ctx.logger.warn(`Failed to generate ${errorMessages.length} documents:\n  - ${errorMessages.join("\n  - ")}`);
     }
     ctx.logger.debug(`… Executed ${doneCount} generating tasks`);
+    return report;
 }
-function fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, nodeOptions) {
+function fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, nodeOptions) {
     const { routingIds, nodeType } = nodeOptions;
     const { siteSchema } = siteOptions;
-    tasks.add(() => updateRoutingDocument(ctx, siteOptions, nodeOptions));
+    tasks.add(() => updateRoutingDocument(ctx, report, siteOptions, nodeOptions));
     for (const listType of nodeType.lists ?? []) {
         for (const typeName of listType.parts) {
             const partType = getPartTypeByName(siteSchema, typeName);
-            tasks.add(() => addParts(ctx, siteOptions, {
+            tasks.add(() => addParts(ctx, report, siteOptions, {
                 parentNodeId: routingIds.nodeId,
                 nodeType: partType,
                 documentType: nodeType,
@@ -48,24 +51,24 @@ function fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, nodeOptions)
         const childIds = routingIds.children?.[typeName];
         if (!childIds)
             throw new Error(`Missing childIds for ${typeName}`);
-        fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, {
+        fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, {
             routingIds: childIds,
             nodeType: childType,
         });
     }
     for (const typeName of nodeType.regularChildren ?? []) {
         const childType = getRegularDocumentTypeByName(siteSchema, typeName);
-        tasks.add(() => addRegularDocuments(ctx, siteOptions, {
+        tasks.add(() => addRegularDocuments(ctx, report, siteOptions, {
             parentNodeId: routingIds.nodeId,
             nodeType: childType,
             documentType: childType,
         }));
     }
 }
-async function updateSiteFields(ctx, options) {
+async function updateSiteFields(ctx, _report, options) {
     const { service, logger } = ctx;
     logger.debug("Updating site fields…");
-    const { fqdn, siteSchema, siteId, siteTitle } = options;
+    const { fqdn, siteSchema, siteTitle } = options;
     const siteType = siteSchema.nodeTypes._site;
     const logoImageFile = getRandomImagePath();
     const fields = [
@@ -123,7 +126,7 @@ async function updateSiteFields(ctx, options) {
     await service.connector.updateSiteFields(fqdn, Object.fromEntries(fields));
     logger.debug("… Site fields updated");
 }
-async function updateRoutingDocument(ctx, siteOptions, nodeOptions) {
+async function updateRoutingDocument(ctx, report, siteOptions, nodeOptions) {
     ctx.logger.debug(`[TASK] Updating routing document "${nodeOptions.nodeType.typeName}"…`);
     const { routingIds, nodeType } = nodeOptions;
     const { fqdn, siteSchema, schemaI18n } = siteOptions;
@@ -139,8 +142,9 @@ async function updateRoutingDocument(ctx, siteOptions, nodeOptions) {
         nodeId: routingIds.nodeId,
         content: toRiDocumentContent(content, nodeType),
     });
+    report.addContentCount(1);
 }
-async function addRegularDocuments(ctx, siteOptions, nodeOptions) {
+async function addRegularDocuments(ctx, report, siteOptions, nodeOptions) {
     ctx.logger.debug(`[TASK] Adding regular documents "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
     const { fqdn, siteSchema, schemaI18n } = siteOptions;
@@ -164,8 +168,9 @@ async function addRegularDocuments(ctx, siteOptions, nodeOptions) {
         parentNodeId,
         contents: list.map((content) => toRiDocumentContent(content, nodeType)),
     });
+    report.addContentCount(list.length);
 }
-async function addParts(ctx, siteOptions, nodeOptions) {
+async function addParts(ctx, report, siteOptions, nodeOptions) {
     ctx.logger.debug(`[TASK] Adding parts "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
     const { fqdn, siteSchema, schemaI18n } = siteOptions;
@@ -189,6 +194,7 @@ async function addParts(ctx, siteOptions, nodeOptions) {
         parentNodeId,
         contents: list.map((content) => toRiPartContent(content, nodeType)),
     });
+    report.addContentCount(list.length);
 }
 function toRiDocumentContent(content, nodeType) {
     const { title, fields, featuredImage } = content;

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

@@ -1,4 +1,5 @@
 import { boolVal, listValOrUndef, strVal, strValOrUndef, } from "@paroi/data-formatters-lib";
+import { updateSession } from "../../db/db.queries.js";
 import { createPromptTemplate } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
@@ -35,6 +36,7 @@ export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = fal
     }
     if (report.valid)
         return;
+    await updateSession(ctx, { guardCountInc: 1 });
     return {
         success: false,
         language: report.language,

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

@@ -1,3 +1,4 @@
+import { updateSession } from "../../db/db.queries.js";
 import { reorderObjectKeys } from "../helpers/js-utils.js";
 import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
@@ -24,6 +25,7 @@ export async function invokeNewSiteAnalysis(ctx, input) {
         [analysis.siteProperties.language]: analysis.siteProperties.title,
     };
     if (!unusedInformation) {
+        await updateSession(ctx, { status: "analyzed", promptCountInc: 1 });
         return {
             siteTitle,
             siteSchema,
@@ -40,7 +42,8 @@ export async function invokeNewSiteAnalysis(ctx, input) {
             siteSchema,
             l10n,
         },
-    });
+    }, { asRemainingPrompt: true });
+    await updateSession(ctx, { status: "analyzed", promptCountInc: 1 });
     return {
         siteTitle,
         siteSchema: updated.siteSchema,

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

@@ -1,3 +1,4 @@
+import { updateSession } from "../../db/db.queries.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";
@@ -7,7 +8,7 @@ const prompt1Tpl = await createPromptTemplate({
 const prompt2Tpl = await createPromptTemplate({
     fileName: "update-site-schema-2-execute.md",
 });
-export async function invokeUpdateSiteSchema(ctx, input) {
+export async function invokeUpdateSiteSchema(ctx, input, { asRemainingPrompt = false } = {}) {
     const task = await invokeUpdateSiteSchemaStep1(ctx, input);
     if (!task.taskDetailsMd) {
         // no changes
@@ -21,6 +22,9 @@ export async function invokeUpdateSiteSchema(ctx, input) {
         taskDetailsMd: task.taskDetailsMd,
         generatedSchema: input.generatedSchema,
     });
+    if (!asRemainingPrompt) {
+        await updateSession(ctx, { status: "updated", promptCountInc: 1 });
+    }
     return {
         ...genSchema,
         changed: true,

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

@@ -1,17 +1,13 @@
 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 { fillSiteWithFakeContent } from "../fake-content-generator.ts/create-database-with-fake-content.js";
 import { createTheme } from "./theme-creator.js";
 export async function generateSite(ctx, input) {
-    const { service, logger, packConf } = ctx;
-    const { sitesDir, packName } = packConf;
+    const { service, logger, sitesDir, packConf: { packName }, } = ctx;
     const { generatedSchema: { l10n, siteSchema, siteTitle }, withFakeContent, } = input;
-    if (!sitesDir) {
-        throw new Error(`Site-generator plugin can generate sites only for pack with "sitesDir", but pack "${packName}" doesn't have it`);
-    }
-    const siteId = randomUUID();
+    const siteId = ctx.sessionId;
     logger.info(`Generating site: ${siteId}…`);
     const siteDir = join(sitesDir, siteId);
     await mkdir(siteDir);
@@ -23,14 +19,17 @@ export async function generateSite(ctx, input) {
         siteTitle: siteTitle.en ?? Object.values(siteTitle)[0] ?? "new-website",
     }), null, 2), "utf-8");
     await createTheme(ctx, siteDir, siteSchema);
-    const siteConf = await service.registerNewSite({
+    const regSite = await service.connector.registerNewSite({
         packName,
         siteDir,
         domain: siteId,
         version: "0.0.0",
     });
     if (withFakeContent) {
-        await fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle });
+        const report = await fillSiteWithFakeContent(ctx, { regSite, siteTitle });
+        await updateSession(ctx, {
+            contentCountInc: report.getContentCount(),
+        });
     }
     const account = {
         kind: "local",
@@ -38,8 +37,12 @@ export async function generateSite(ctx, input) {
         name: "Admin",
         password: Math.random().toString(36).substring(2, 6), // 4 random lowercase characters,
     };
-    await ctx.service.connector.createAccount(siteConf.fqdn, account, { asContactEmail: true });
-    const { siteUrl } = siteConf;
+    await ctx.service.connector.createAccount(regSite.fqdn, account, { asContactEmail: true });
+    const { siteUrl } = regSite;
+    await updateSession(ctx, {
+        status: "generated",
+        nodeTypeCount: siteSchema.nodeTypes?.length ?? 0,
+    });
     return {
         siteId,
         url: siteUrl,

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

@@ -0,0 +1,39 @@
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+let runningId;
+export function startSiteRemover(ctx) {
+    clearInterval(runningId);
+    let sitesDir;
+    runningId = setInterval(async () => {
+        if (!sitesDir)
+            return;
+        try {
+            await removeExpiredSites(ctx);
+        }
+        catch (error) {
+            ctx.logger.error("[site-remover]", error);
+        }
+    }, 1000 * 60 * 60).unref(); // Check every hour
+    return {
+        stop() {
+            clearInterval(runningId);
+        },
+    };
+}
+export async function removeExpiredSites(ctx) {
+    const { sitesDir, packConf, service } = ctx;
+    const now = new Date();
+    const expirationTime = new Date(now.getTime() - 1000 * 60 * 60 * 24 * 2); // 2 days
+    // List entries in sitesDir, filter directories named as uuidv4, and remove them.
+    const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    const entries = await readdir(sitesDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !uuidv4Regex.test(entry.name))
+            continue;
+        const dirPath = join(sitesDir, entry.name);
+        const st = await stat(dirPath);
+        if (st.ctime < expirationTime) {
+            await service.connector.removeSite(`${entry.name}.${packConf.parentDomain}`);
+        }
+    }
+}

package/gen-backend/dist/plugin.js

@@ -1,22 +1,24 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatMistralAI } from "@langchain/mistralai";
-import { strVal } from "@paroi/data-formatters-lib";
-import { pathExists } from "@paroicms/internal-server-lib";
+import { getJwtSecretSync, pathExists } from "@paroicms/internal-server-lib";
 import { ApiError, escapeHtml } from "@paroicms/public-server-lib";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { projectDir } from "./context.js";
+import { join } from "node:path";
+import { executeCommand } from "./commands/execute-command.js";
+import { SLUG, packageDir, pluginVersion } from "./context.js";
 import { formatGeneratorCommand, formatGeneratorPluginConfiguration } from "./data-format.js";
-import { executeCommand } from "./generator/actions.js";
+import { createOrOpenSiteGeneratorConnection } from "./db/db-init.js";
 import { initializeImageNames } from "./generator/lib/images-lib.js";
-const packageDir = dirname(projectDir);
-const version = strVal(JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8")).version);
-const SLUG = "site-generator";
+import { removeExpiredSites } from "./lib/site-remover.js";
 await initializeImageNames();
 const plugin = {
-    version,
+    version: pluginVersion,
     slug: SLUG,
     async siteInit(service) {
+        const { cn, logNextQuery } = await createOrOpenSiteGeneratorConnection({
+            sqliteFile: join(service.registeredSite.dataDir, "site-generator.sqlite"),
+            canCreate: true,
+            logger: service.logger,
+        });
         const pluginConf = formatGeneratorPluginConfiguration(service.configuration);
         let debugDir = pluginConf.debugDir;
         if (debugDir) {
@@ -55,6 +57,32 @@ const plugin = {
             temperature: 0.2,
             maxTokens: 50_000,
         });
+        let rawContext;
+        service.registerHook("initialized", (service) => {
+            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`);
+            }
+            rawContext = {
+                cn,
+                logNextQuery,
+                jwtSecret: getJwtSecretSync(join(service.registeredSite.dataDir, "site-generator-secret.txt")),
+                pluginConf,
+                bestModel,
+                bestModelName: bestModel.model,
+                goodModel,
+                goodModelName: goodModel.model,
+                cheapModel,
+                cheapModelName: cheapModel.model,
+                debugDir,
+                sitesDir,
+                packConf,
+                service,
+                logger: service.logger,
+            };
+            removeExpiredSites(rawContext).catch(console.error);
+        });
         service.setPublicAssetsDirectory(join(packageDir, "gen-front", "dist"));
         const scriptAttr = [
             ["type", "module"],
@@ -64,24 +92,14 @@ const plugin = {
         ];
         service.addHeadTag(`<link rel="stylesheet" href="${escapeHtml(`${service.pluginAssetsUrl}/gen-front.css`)}">`, `<script ${scriptAttr.map(([key, val]) => `${key}="${escapeHtml(val)}"`).join(" ")}></script>`);
         service.setPublicApiHandler(async (service, httpContext, relativePath) => {
+            if (!rawContext)
+                throw new Error("should be initialized");
+            const ctx = rawContext;
             const { req, res } = httpContext;
             if (relativePath !== "") {
                 res.status(404).send({ status: 404 });
                 return;
             }
-            const ctx = {
-                pluginConf,
-                packConf: service.connector.getSitePackConf(pluginConf.packName),
-                service,
-                logger: service.logger,
-                bestModel,
-                bestModelName: bestModel.model,
-                goodModel,
-                goodModelName: goodModel.model,
-                cheapModel,
-                cheapModelName: cheapModel.model,
-                debugDir,
-            };
             let command;
             try {
                 command = formatGeneratorCommand(req.body);