@promptbook/cli 0.112.0-88 → 0.112.0-90

package/apps/agents-server/next.config.ts

@@ -1,4 +1,5 @@
 import type { NextConfig } from 'next';
+import { readdirSync } from 'fs';
 import path from 'path';
 
 /**
@@ -9,6 +10,21 @@ import path from 'path';
  */
 const nextDistDir = process.env.NEXT_DIST_DIR || '.next';
 
+/**
+ * Dependency root passed by `ptbk agents-server` when the bundled app is copied into a project cache.
+ */
+const agentsServerNodeModulesPath = process.env.PTBK_AGENTS_SERVER_NODE_MODULES_PATH;
+
+/**
+ * Whether the CLI-owned build should skip duplicate validation already covered by repository tests.
+ */
+const isNextValidationIgnored = process.env.PTBK_AGENTS_SERVER_IGNORE_NEXT_VALIDATION === 'true';
+
+/**
+ * Exact aliases for local generated Promptbook package entrypoints.
+ */
+const promptbookLocalPackageAliases = createPromptbookLocalPackageAliases();
+
 /**
  * Map of next config.
  */
@@ -17,7 +33,13 @@ const nextConfig: NextConfig = {
     // <- TODO: [🐱‍🚀][🧠] How to properly build Next.js app, for both Vercel and Doceker?
 
     distDir: nextDistDir,
-    serverExternalPackages: ['pg', '@napi-rs/canvas'],
+    eslint: {
+        ignoreDuringBuilds: isNextValidationIgnored,
+    },
+    serverExternalPackages: ['pg', '@napi-rs/canvas', 'playwright', 'playwright-core'],
+    typescript: {
+        ignoreBuildErrors: isNextValidationIgnored,
+    },
 
     experimental: {
         externalDir: true,
@@ -29,12 +51,25 @@ const nextConfig: NextConfig = {
 
         resolveAlias: {
             '@': path.resolve(__dirname),
-            '@common': path.resolve(__dirname, '../common'),
-            '@promptbook-local': path.resolve(__dirname, '../../src/_packages'),
+            '@common': path.resolve(__dirname, '../_common'),
+            ...promptbookLocalPackageAliases,
         },
     },
 
     webpack(config, { isServer }) {
+        config.resolve.alias = {
+            ...config.resolve.alias,
+            '@': path.resolve(__dirname),
+            '@common': path.resolve(__dirname, '../_common'),
+            ...promptbookLocalPackageAliases,
+        };
+
+        if (agentsServerNodeModulesPath) {
+            config.resolve.modules = Array.from(
+                new Set([...(config.resolve.modules || ['node_modules']), agentsServerNodeModulesPath]),
+            );
+        }
+
         // Exclude Node.js-only modules from client bundle
         if (!isServer) {
             config.resolve.fallback = {
@@ -81,3 +116,23 @@ const nextConfig: NextConfig = {
 };
 
 export default nextConfig;
+
+/**
+ * Creates webpack/Turbopack aliases from imports like `@promptbook-local/core` to generated local sources.
+ */
+function createPromptbookLocalPackageAliases(): Record<string, string> {
+    const packagesIndexPath = path.resolve(__dirname, '../../src/_packages');
+
+    try {
+        return Object.fromEntries(
+            readdirSync(packagesIndexPath)
+                .filter((filename) => filename.endsWith('.index.ts'))
+                .map((filename) => [
+                    `@promptbook-local/${filename.replace(/\.index\.ts$/u, '')}`,
+                    path.resolve(packagesIndexPath, filename),
+                ]),
+        );
+    } catch {
+        return {};
+    }
+}

package/apps/agents-server/src/database/ensureAutomaticDatabaseMigrations.ts

@@ -3,6 +3,7 @@ import {
     resolveDatabaseMigrationConnectionStringFromEnvironment,
     runDatabaseMigrations,
 } from './runDatabaseMigrations';
+import { listEnvironmentRegisteredServers } from '../utils/serverRegistry';
 
 /**
  * Opt-out environment flag for automatic runtime migrations.
@@ -24,7 +25,13 @@ const automaticDatabaseMigrationPromiseByPrefix = new Map<string, Promise<void>>
  * @private internal startup helper for Agents Server runtime
  */
 export async function ensureAutomaticDatabaseMigrations(): Promise<void> {
-    return ensureAutomaticDatabaseMigrationsForPrefix(process.env.SUPABASE_TABLE_PREFIX || '');
+    const environmentServerPrefixes = listEnvironmentRegisteredServers().map((server) => server.tablePrefix);
+
+    if (environmentServerPrefixes.length === 0) {
+        return ensureAutomaticDatabaseMigrationsForPrefix(process.env.SUPABASE_TABLE_PREFIX || '');
+    }
+
+    await Promise.all(environmentServerPrefixes.map((prefix) => ensureAutomaticDatabaseMigrationsForPrefix(prefix)));
 }
 
 /**

package/apps/agents-server/src/database/runDatabaseMigrations.ts

@@ -16,6 +16,7 @@ import { listRegisteredServersFromDatabase } from './listRegisteredServersFromDa
 import { migratePrefix } from './migratePrefix';
 import { readMigrationFiles, resolveMigrationsDirectory } from './resolveMigrationsDirectory';
 import { selectPrefixesForMigration } from './selectPrefixesForMigration';
+import { listEnvironmentRegisteredServers } from '../utils/serverRegistry';
 
 /**
  * Allowed values describing who applied a migration record.
@@ -175,7 +176,10 @@ export async function resolveDatabaseMigrationRuntimeConfiguration(
     try {
         await client.connect();
 
-        const registeredServers = await listRegisteredServersFromDatabase(client);
+        const registeredServers = mergeRegisteredServers(
+            await listRegisteredServersFromDatabase(client),
+            listEnvironmentRegisteredServers(),
+        );
         const hasExplicitDefaultPrefix = process.env[SUPABASE_TABLE_PREFIX_ENV_NAME] !== undefined;
         const configuredPrefixes = uniquePrefixes([
             ...(hasExplicitDefaultPrefix
@@ -355,6 +359,32 @@ function uniquePrefixes(prefixes: ReadonlyArray<string>): Array<string> {
     return result;
 }
 
+/**
+ * Combines database and environment registry rows, keeping database rows authoritative.
+ *
+ * @param databaseServers - Persistent `_Server` rows.
+ * @param environmentServers - Virtual rows derived from `SERVERS`.
+ * @returns Merged rows without duplicate domains.
+ */
+function mergeRegisteredServers(
+    databaseServers: ReadonlyArray<ServerRecord>,
+    environmentServers: ReadonlyArray<ServerRecord>,
+): Array<ServerRecord> {
+    const seenDomains = new Set(databaseServers.map((server) => server.domain));
+    const mergedServers = [...databaseServers];
+
+    for (const environmentServer of environmentServers) {
+        if (seenDomains.has(environmentServer.domain)) {
+            continue;
+        }
+
+        mergedServers.push(environmentServer);
+        seenDomains.add(environmentServer.domain);
+    }
+
+    return mergedServers;
+}
+
 /**
  * Creates one PostgreSQL client using the lazily loaded `pg` package.
  *

package/apps/agents-server/src/database/sqlite/$provideLocalSqliteSupabase.ts

@@ -750,11 +750,11 @@ class LocalSqliteQueryBuilder implements PromiseLike<LocalSqliteQueryResult> {
      */
     private selectMatchingRowids(): Array<number | bigint> {
         const where = this.createWhereClause();
-        const sql = `SELECT rowid FROM ${quoteIdentifier(this.tableName)} ${where.sql}`;
+        const sql = `SELECT rowid AS "__rowid" FROM ${quoteIdentifier(this.tableName)} ${where.sql}`;
         return this.database
             .prepare(sql)
             .all(...where.values)
-            .map((row) => row.rowid as number | bigint);
+            .map((row) => row.__rowid as number | bigint);
     }
 
     /**

package/apps/agents-server/src/middleware/createMiddlewareRequestContext.ts

@@ -37,7 +37,7 @@ export async function createMiddlewareRequestContext(request: NextRequest): Prom
     const requestIp = getRequestIp(request);
     const host = request.headers.get('host');
     const supabase = getMiddlewareSupabase();
-    const registeredServers = supabase ? await loadRegisteredServers() : [];
+    const registeredServers = supabase || process.env.SERVERS ? await loadRegisteredServers() : [];
     const { canQueryServerTables, customDomainResolution, tablePrefixForRequest } = await resolveMiddlewareServerRouting(
         {
             host,

package/apps/agents-server/src/tools/$provideServer.ts

@@ -38,6 +38,33 @@ const getCachedProvidedServer = cache(async (): Promise<ProvidedServer> => {
     const xPromptbookServer = headersList.get('x-promptbook-server');
 
     if (isAgentsServerSqliteMode()) {
+        if (isLocalDevelopmentHost(requestHost)) {
+            return {
+                id: null,
+                publicUrl: resolveFallbackPublicUrl(requestHost),
+                tablePrefix: SUPABASE_TABLE_PREFIX,
+            };
+        }
+
+        const registeredServers = await listRegisteredServersUsingServiceRole();
+        if (registeredServers.length > 0) {
+            const { currentServer: resolvedSqliteServer } = resolveServerSelection({
+                host: requestHost,
+                forwardedServerHost: xPromptbookServer,
+                registeredServers,
+            });
+
+            if (!resolvedSqliteServer) {
+                throw new Error(`Server with host "${requestHost}" is not registered in SERVERS`);
+            }
+
+            return {
+                id: resolvedSqliteServer.id,
+                publicUrl: createServerPublicUrl(resolvedSqliteServer.domain),
+                tablePrefix: resolvedSqliteServer.tablePrefix,
+            };
+        }
+
         return {
             id: null,
             publicUrl: resolveFallbackPublicUrl(requestHost),

package/apps/agents-server/src/utils/serverRegistry.ts

@@ -62,6 +62,16 @@ const SERVER_REGISTRY_SELECT = 'id,name,environment,domain,tablePrefix,createdAt
  */
 const SERVER_REGISTRY_TABLE_NAME = '_Server';
 
+/**
+ * Environment variable with comma-separated standalone server domains.
+ */
+const SERVERS_ENV_NAME = 'SERVERS';
+
+/**
+ * Stable timestamp used by virtual server records derived from environment variables.
+ */
+const ENVIRONMENT_SERVER_TIMESTAMP = '1970-01-01T00:00:00.000Z';
+
 /**
  * In-memory cache TTL for repeated registry lookups inside one runtime process.
  */
@@ -127,8 +137,10 @@ export async function listRegisteredServers(supabase: Pick<SupabaseClient, 'from
 export async function listRegisteredServersUsingServiceRole(options?: {
     readonly forceRefresh?: boolean;
 }): Promise<Array<ServerRecord>> {
+    const environmentServers = listEnvironmentRegisteredServers();
+
     if (isAgentsServerSqliteMode()) {
-        return [];
+        return environmentServers;
     }
 
     const shouldReuseCache =
@@ -137,7 +149,7 @@ export async function listRegisteredServersUsingServiceRole(options?: {
         Date.now() - cachedServerRegistry.loadedAt < SERVER_REGISTRY_CACHE_TTL_MS;
 
     if (shouldReuseCache) {
-        return cachedServerRegistry!.serversPromise;
+        return mergeRegisteredServers(await cachedServerRegistry!.serversPromise, environmentServers);
     }
 
     const serversPromise = listRegisteredServers(getServerRegistryClient());
@@ -147,7 +159,7 @@ export async function listRegisteredServersUsingServiceRole(options?: {
     };
 
     try {
-        return await serversPromise;
+        return mergeRegisteredServers(await serversPromise, environmentServers);
     } catch (error) {
         if (cachedServerRegistry?.serversPromise === serversPromise) {
             cachedServerRegistry = null;
@@ -156,6 +168,35 @@ export async function listRegisteredServersUsingServiceRole(options?: {
     }
 }
 
+/**
+ * Loads virtual server records from the comma-separated `SERVERS` environment variable.
+ *
+ * @returns Server records with deterministic table prefixes derived from normalized domains.
+ */
+export function listEnvironmentRegisteredServers(): Array<ServerRecord> {
+    const rawServers = process.env[SERVERS_ENV_NAME];
+    if (!rawServers) {
+        return [];
+    }
+
+    const normalizedDomains = uniqueStrings(
+        rawServers
+            .split(',')
+            .map((server) => normalizeServerDomain(server))
+            .filter((server): server is string => Boolean(server)),
+    );
+
+    return normalizedDomains.map((domain, index) => ({
+        id: -(index + 1),
+        name: domain,
+        environment: SERVER_ENVIRONMENT.PRODUCTION,
+        domain,
+        tablePrefix: buildEnvironmentServerTablePrefix(domain),
+        createdAt: ENVIRONMENT_SERVER_TIMESTAMP,
+        updatedAt: ENVIRONMENT_SERVER_TIMESTAMP,
+    }));
+}
+
 /**
  * Finds one registered server by incoming host header.
  *
@@ -404,3 +445,76 @@ function hasHttpProtocol(value: string): boolean {
 function isDefaultPortForProtocol(protocol: string, port: string): boolean {
     return (protocol === 'http:' && port === '80') || (protocol === 'https:' && port === '443');
 }
+
+/**
+ * Combines database and environment registry rows, keeping database rows authoritative.
+ *
+ * @param databaseServers - Persistent `_Server` rows.
+ * @param environmentServers - Virtual rows derived from `SERVERS`.
+ * @returns Merged rows without duplicate domains.
+ */
+function mergeRegisteredServers(
+    databaseServers: ReadonlyArray<ServerRecord>,
+    environmentServers: ReadonlyArray<ServerRecord>,
+): Array<ServerRecord> {
+    const seenDomains = new Set<string>();
+    const mergedServers = [...databaseServers];
+
+    for (const databaseServer of databaseServers) {
+        const normalizedDomain = normalizeServerDomain(databaseServer.domain);
+        if (normalizedDomain) {
+            seenDomains.add(normalizedDomain);
+        }
+    }
+
+    for (const environmentServer of environmentServers) {
+        const normalizedDomain = normalizeServerDomain(environmentServer.domain);
+        if (!normalizedDomain || seenDomains.has(normalizedDomain)) {
+            continue;
+        }
+
+        mergedServers.push(environmentServer);
+        seenDomains.add(normalizedDomain);
+    }
+
+    return mergedServers;
+}
+
+/**
+ * Builds a deterministic table prefix from a normalized domain.
+ *
+ * @param domain - Normalized server domain.
+ * @returns Prefix such as `server_www_example_com_`.
+ */
+function buildEnvironmentServerTablePrefix(domain: string): string {
+    const prefixSuffix = domain
+        .toLowerCase()
+        .replace(/-/gu, '_dash_')
+        .replace(/\./gu, '_')
+        .replace(/:/gu, '_port_')
+        .replace(/[^a-z0-9_]/gu, '_')
+        .replace(/_+/gu, '_')
+        .replace(/^_+|_+$/gu, '');
+
+    return `server_${prefixSuffix}_`;
+}
+
+/**
+ * Deduplicates non-empty strings while preserving input order.
+ *
+ * @param values - Raw string values.
+ * @returns Unique non-empty strings.
+ */
+function uniqueStrings(values: ReadonlyArray<string>): Array<string> {
+    const uniqueValues: Array<string> = [];
+
+    for (const value of values) {
+        if (!value || uniqueValues.includes(value)) {
+            continue;
+        }
+
+        uniqueValues.push(value);
+    }
+
+    return uniqueValues;
+}

package/esm/apps/agents-server/src/utils/serverRegistry.d.ts

@@ -65,6 +65,12 @@ export declare function listRegisteredServers(supabase: Pick<SupabaseClient, 'fr
 export declare function listRegisteredServersUsingServiceRole(options?: {
     readonly forceRefresh?: boolean;
 }): Promise<Array<ServerRecord>>;
+/**
+ * Loads virtual server records from the comma-separated `SERVERS` environment variable.
+ *
+ * @returns Server records with deterministic table prefixes derived from normalized domains.
+ */
+export declare function listEnvironmentRegisteredServers(): Array<ServerRecord>;
 /**
  * Finds one registered server by incoming host header.
  *