@promptbook/cli 0.112.0-89 → 0.112.0-91

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.
  *

package/esm/index.es.js

@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-89';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-91';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -36106,6 +36106,12 @@ const PTBK_AGENTS_SERVER_DATABASE_ENV = 'PTBK_AGENTS_SERVER_DATABASE';
  * @private internal constant of `ptbk agents-server`
  */
 const PTBK_AGENTS_SERVER_SQLITE_PATH_ENV = 'PTBK_AGENTS_SERVER_SQLITE_PATH';
+/**
+ * Optional hostname used by the internal Next server.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const PTBK_HOSTNAME_ENV = 'PTBK_HOSTNAME';
 /**
  * Entropy size for the local-only token shared by the CLI pump and the Next app.
  *
@@ -36224,8 +36230,15 @@ async function resolveAgentsServerRuntimePaths() {
  * Starts the production Next server and wires its logs into the foreground dashboard.
  */
 function startNextServer(options) {
+    var _a;
     logRunnerEvent(options.logStreams.runner, 'Starting the Agents Server Next process.');
-    const commandProcess = spawn(process.execPath, [options.nextCliPath, 'start', '--port', String(options.options.port)], {
+    const nextArguments = [options.nextCliPath, 'start', '--port', String(options.options.port)];
+    const hostname = (_a = options.childEnvironment[PTBK_HOSTNAME_ENV]) === null || _a === void 0 ? void 0 : _a.trim();
+    if (hostname) {
+        nextArguments.push('--hostname', hostname);
+        logRunnerEvent(options.logStreams.runner, `Binding Agents Server Next process to ${hostname}.`);
+    }
+    const commandProcess = spawn(process.execPath, nextArguments, {
         cwd: options.runtimePaths.appPath,
         env: options.childEnvironment,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -67590,6 +67603,38 @@ const SERVER_ENVIRONMENT = {
  * Global source-of-truth table for server routing and migration targeting.
  */
 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';
+/**
+ * Loads virtual server records from the comma-separated `SERVERS` environment variable.
+ *
+ * @returns Server records with deterministic table prefixes derived from normalized domains.
+ */
+function listEnvironmentRegisteredServers() {
+    const rawServers = process.env[SERVERS_ENV_NAME];
+    if (!rawServers) {
+        return [];
+    }
+    const normalizedDomains = uniqueStrings$1(rawServers
+        .split(',')
+        .map((server) => normalizeServerDomain(server))
+        .filter((server) => 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,
+    }));
+}
 /**
  * Normalizes one raw `_Server` row and validates required fields.
  *
@@ -67710,6 +67755,39 @@ function hasHttpProtocol(value) {
 function isDefaultPortForProtocol(protocol, port) {
     return (protocol === 'http:' && port === '80') || (protocol === 'https:' && port === '443');
 }
+/**
+ * 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) {
+    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$1(values) {
+    const uniqueValues = [];
+    for (const value of values) {
+        if (!value || uniqueValues.includes(value)) {
+            continue;
+        }
+        uniqueValues.push(value);
+    }
+    return uniqueValues;
+}
 
 /**
  * SQL query used to load all registered servers in a deterministic order.
@@ -68068,7 +68146,7 @@ async function resolveDatabaseMigrationRuntimeConfiguration(logger = console) {
     const client = await createPostgresClient(connectionString);
     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
@@ -68229,6 +68307,25 @@ function uniquePrefixes(prefixes) {
     }
     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, environmentServers) {
+    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.
  *