@promptbook/cli 0.113.0-8 → 0.114.0-0

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

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { resolveAgentsServerSqliteDatabasePath } from './resolveAgentsServerSqliteDatabasePath';
+import { resolveServerSqliteDatabasePath } from './resolveServerSqliteDatabasePath';
 
 /**
  * Shape of the `better-sqlite3` module constructor loaded at runtime.
@@ -40,44 +41,75 @@ export type AgentsServerSqliteStatement = {
 };
 
 /**
- * Cached SQLite database connection.
+ * Cached SQLite database connections keyed by absolute database file path.
  */
-let agentsServerSqliteDatabase: AgentsServerSqliteDatabase | null = null;
+const sqliteDatabaseByPath = new Map<string, AgentsServerSqliteDatabase>();
 
 /**
- * Opens and initializes the shared local SQLite database.
+ * Opens and initializes one SQLite database file, caching the connection per path.
  *
- * @returns Shared SQLite database connection.
+ * @param databasePath - Absolute path of the SQLite database file.
+ * @returns Cached SQLite database connection.
  *
  * @private exported from Agents Server SQLite utilities
  */
-export function $provideAgentsServerSqliteDatabase(): AgentsServerSqliteDatabase {
-    if (agentsServerSqliteDatabase) {
-        return agentsServerSqliteDatabase;
+export function $provideSqliteDatabaseAtPath(databasePath: string): AgentsServerSqliteDatabase {
+    const cachedDatabase = sqliteDatabaseByPath.get(databasePath);
+    if (cachedDatabase) {
+        return cachedDatabase;
     }
 
-    const databasePath = resolveAgentsServerSqliteDatabasePath();
     const databaseDirectory = dirname(databasePath);
-
     if (!existsSync(databaseDirectory)) {
         mkdirSync(databaseDirectory, { recursive: true });
     }
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const BetterSqlite = require('better-sqlite3') as BetterSqliteConstructor;
-    agentsServerSqliteDatabase = new BetterSqlite(databasePath);
-    agentsServerSqliteDatabase.pragma('journal_mode = WAL');
-    agentsServerSqliteDatabase.pragma('foreign_keys = ON');
+    const database = new BetterSqlite(databasePath);
+    database.pragma('journal_mode = WAL');
+    database.pragma('foreign_keys = ON');
 
-    return agentsServerSqliteDatabase;
+    sqliteDatabaseByPath.set(databasePath, database);
+    return database;
 }
 
 /**
- * Closes the cached SQLite connection and resets adapter state for isolated tests.
+ * Opens the VPS-wide SQLite registry database.
+ *
+ * This database is owned by the super-admin and holds only VPS-level data,
+ * most importantly the `_Server` table listing all servers running on this VPS.
+ * Server-scoped data (agents, projects, metadata, users, ...) lives in isolated
+ * per-server databases provided by `$provideServerSqliteDatabase`.
+ *
+ * @returns Shared VPS registry SQLite database connection.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function $provideVpsRegistrySqliteDatabase(): AgentsServerSqliteDatabase {
+    return $provideSqliteDatabaseAtPath(resolveAgentsServerSqliteDatabasePath());
+}
+
+/**
+ * Opens the isolated SQLite database of one server namespace.
+ *
+ * @param tablePrefix - Stable server namespace key, or an empty string for the default server.
+ * @returns Per-server SQLite database connection.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function $provideServerSqliteDatabase(tablePrefix: string): AgentsServerSqliteDatabase {
+    return $provideSqliteDatabaseAtPath(resolveServerSqliteDatabasePath(tablePrefix));
+}
+
+/**
+ * Closes all cached SQLite connections and resets adapter state for isolated tests.
  *
  * @private exported from Agents Server SQLite utilities
  */
 export function $resetAgentsServerSqliteDatabaseForTests(): void {
-    agentsServerSqliteDatabase?.close?.();
-    agentsServerSqliteDatabase = null;
+    for (const database of sqliteDatabaseByPath.values()) {
+        database.close?.();
+    }
+    sqliteDatabaseByPath.clear();
 }

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

@@ -0,0 +1,18 @@
+import { $provideServer } from '../../tools/$provideServer';
+import type { AgentsServerSqliteDatabase } from './$provideAgentsServerSqliteDatabase';
+import { resolveServerSqliteDatabaseForTablePrefix } from './resolveLocalSqliteTableLocation';
+
+/**
+ * Opens the isolated SQLite database of the server handling the current request.
+ *
+ * Used by raw-SQL features (for example the embedded database admin) so every
+ * server administrator only ever sees the data of their own server.
+ *
+ * @returns Isolated SQLite database of the current server.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export async function $provideCurrentServerSqliteDatabase(): Promise<AgentsServerSqliteDatabase> {
+    const { tablePrefix } = await $provideServer();
+    return resolveServerSqliteDatabaseForTablePrefix(tablePrefix);
+}

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

@@ -1,11 +1,10 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-import {
-    $provideAgentsServerSqliteDatabase,
-    $resetAgentsServerSqliteDatabaseForTests,
-} from './$provideAgentsServerSqliteDatabase';
+import { $resetAgentsServerSqliteDatabaseForTests } from './$provideAgentsServerSqliteDatabase';
 import { ensureTable } from './localSqliteSupabase/ensureTable';
 import { resolveReadIndexColumns, resolveTableBaseName } from './localSqliteSupabase/localSqliteTableSchema';
 import { LocalSqliteSupabaseClient } from './localSqliteSupabase/LocalSqliteSupabaseClient';
+import { resolveLocalSqliteTableLocation } from './resolveLocalSqliteTableLocation';
+import { invalidateStandaloneServerRegistryCache } from './standaloneServerRegistryStore';
 
 /**
  * Cached Supabase-shaped local client.
@@ -13,37 +12,40 @@ import { LocalSqliteSupabaseClient } from './localSqliteSupabase/LocalSqliteSupa
 let localSqliteSupabase: SupabaseClient | null = null;
 
 /**
- * Provides a Supabase-shaped client backed by a local SQLite database.
+ * Provides a Supabase-shaped client backed by isolated local SQLite databases.
+ *
+ * Table names are routed per query: VPS-level tables go to the VPS registry
+ * database while server-prefixed tables go to the isolated database file of
+ * the owning server, so servers cannot leak data into each other.
  */
 export function $provideLocalSqliteSupabase(): SupabaseClient {
     if (localSqliteSupabase) {
         return localSqliteSupabase;
     }
 
-    localSqliteSupabase = new LocalSqliteSupabaseClient(
-        $provideAgentsServerSqliteDatabase(),
-    ) as unknown as SupabaseClient;
+    localSqliteSupabase = new LocalSqliteSupabaseClient(resolveLocalSqliteTableLocation) as unknown as SupabaseClient;
     return localSqliteSupabase;
 }
 
 /**
- * Closes the cached SQLite connection and resets adapter state for isolated tests.
+ * Closes all cached SQLite connections and resets adapter state for isolated tests.
  */
 export function $resetLocalSqliteSupabaseForTests(): void {
     $resetAgentsServerSqliteDatabaseForTests();
+    invalidateStandaloneServerRegistryCache();
     localSqliteSupabase = null;
 }
 
 /**
  * Ensures read indexes for a table that is queried through direct SQLite SQL.
  *
- * @param tableName - Actual table name, including any server prefix.
+ * @param tableName - Logical table name, including any server prefix.
  *
  * @private internal SQLite utility of Agents Server
  */
 export function ensureLocalSqliteTableReadIndexes(tableName: string): void {
-    const database = $provideAgentsServerSqliteDatabase();
-    const tableBaseName = resolveTableBaseName(tableName);
+    const { database, localTableName } = resolveLocalSqliteTableLocation(tableName);
+    const tableBaseName = resolveTableBaseName(localTableName);
 
-    ensureTable(database, tableName, resolveReadIndexColumns(tableBaseName));
+    ensureTable(database, localTableName, resolveReadIndexColumns(tableBaseName));
 }

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/LocalSqliteSupabaseClient.ts

@@ -1,21 +1,33 @@
 import type { TODO_any } from '@promptbook-local/types';
 import type { AgentsServerSqliteDatabase } from '../$provideAgentsServerSqliteDatabase';
+import type { LocalSqliteTableLocation } from '../resolveLocalSqliteTableLocation';
 import type { LocalSqliteSelectOptions, LocalSqliteUpsertOptions } from './localSqliteTypes';
 import { LocalSqliteQueryBuilder } from './LocalSqliteQueryBuilder';
 
+/**
+ * Resolver routing one logical table name to its isolated SQLite database.
+ *
+ * @private type of `LocalSqliteSupabaseClient`
+ */
+export type LocalSqliteTableLocationResolver = (tableName: string) => LocalSqliteTableLocation;
+
 /**
  * Supabase-shaped client with only the table query surface used by Agents Server.
  *
+ * Every table access is routed through the location resolver, so each server
+ * namespace transparently works with its own isolated SQLite database file.
+ *
  * @private class of `$provideLocalSqliteSupabase`
  */
 export class LocalSqliteSupabaseClient {
-    public constructor(private readonly database: AgentsServerSqliteDatabase) {}
+    public constructor(private readonly resolveTableLocation: LocalSqliteTableLocationResolver) {}
 
     /**
-     * Starts a query for one SQLite table.
+     * Starts a query for one logical SQLite table.
      */
     public from(tableName: string): LocalSqliteTable {
-        return new LocalSqliteTable(this.database, tableName);
+        const { database, localTableName } = this.resolveTableLocation(tableName);
+        return new LocalSqliteTable(database, localTableName);
     }
 }
 

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/localSqliteTableSchema.ts

@@ -51,7 +51,10 @@ const TEXT_COLUMNS_BY_TABLE = new Map<string, ReadonlySet<string>>([['Metadata',
  *
  * @private constant of `$provideLocalSqliteSupabase`
  */
-const INTEGER_COLUMNS_BY_TABLE = new Map<string, ReadonlySet<string>>([['ServerLimit', new Set(['value'])]]);
+const INTEGER_COLUMNS_BY_TABLE = new Map<string, ReadonlySet<string>>([
+    ['File', new Set(['fileSize'])],
+    ['ServerLimit', new Set(['value'])],
+]);
 
 /**
  * Boolean columns stored as integers by SQLite and restored as booleans.
@@ -79,7 +82,7 @@ const TEXT_PRIMARY_KEY_TABLES = new Set([
  * @private constant of `$provideLocalSqliteSupabase`
  */
 const UNIQUE_INDEX_COLUMNS_BY_TABLE = new Map<string, ReadonlyArray<ReadonlyArray<string>>>([
-    ['_Server', [['name'], ['domain']]],
+    ['_Server', [['name'], ['domain'], ['tablePrefix']]],
     ['Metadata', [['key']]],
     ['ServerLimit', [['key']]],
     ['Agent', [['permanentId']]],

package/apps/agents-server/src/database/sqlite/resolveLocalSqliteTableLocation.ts

@@ -0,0 +1,104 @@
+import {
+    $provideServerSqliteDatabase,
+    $provideVpsRegistrySqliteDatabase,
+    type AgentsServerSqliteDatabase,
+} from './$provideAgentsServerSqliteDatabase';
+import { listStandaloneServerTablePrefixes } from './standaloneServerRegistryStore';
+
+/**
+ * Physical location of one logical (possibly prefixed) table name.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export type LocalSqliteTableLocation = {
+    /**
+     * SQLite database holding the table.
+     */
+    readonly database: AgentsServerSqliteDatabase;
+
+    /**
+     * Table name inside the resolved database (without any server prefix).
+     */
+    readonly localTableName: string;
+};
+
+/**
+ * Routes one logical table name to its isolated SQLite database.
+ *
+ * This is the single choke point implementing standalone server isolation:
+ * - VPS-level tables (names starting with `_`, such as `_Server`) live in the VPS registry database.
+ * - Tables prefixed with a registered server prefix (such as `server_ClientA_Agent`) live in that
+ *   server's own database file under the unprefixed base name (such as `Agent`).
+ * - Everything else (for example localhost development without registered servers) lives in the
+ *   shared `default` server database under its unchanged name.
+ *
+ * @param tableName - Logical table name as produced by `$getTableName`.
+ * @returns Database connection and the table name valid inside it.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function resolveLocalSqliteTableLocation(tableName: string): LocalSqliteTableLocation {
+    if (tableName.startsWith('_')) {
+        return {
+            database: $provideVpsRegistrySqliteDatabase(),
+            localTableName: tableName,
+        };
+    }
+
+    const serverTablePrefix = resolveLongestMatchingServerTablePrefix(tableName);
+    if (serverTablePrefix !== null) {
+        return {
+            database: $provideServerSqliteDatabase(serverTablePrefix),
+            localTableName: tableName.slice(serverTablePrefix.length),
+        };
+    }
+
+    return {
+        database: $provideServerSqliteDatabase(''),
+        localTableName: tableName,
+    };
+}
+
+/**
+ * Resolves the isolated SQLite database used by one server table prefix.
+ *
+ * Uses the same longest-prefix matching as `resolveLocalSqliteTableLocation`,
+ * so raw-SQL callers and the Supabase-shaped adapter always agree on which
+ * database file one server namespace lives in.
+ *
+ * @param tablePrefix - Server table prefix as resolved by `$provideServer`.
+ * @returns Isolated per-server database, or the default server database for unregistered prefixes.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function resolveServerSqliteDatabaseForTablePrefix(tablePrefix: string): AgentsServerSqliteDatabase {
+    const serverTablePrefix = resolveLongestMatchingServerTablePrefix(tablePrefix);
+    return $provideServerSqliteDatabase(serverTablePrefix ?? '');
+}
+
+/**
+ * Finds the longest registered server prefix that starts the given table name.
+ *
+ * The longest match wins so a server prefix which is itself a prefix of another
+ * server prefix can never capture the other server's tables.
+ *
+ * @param tableName - Logical table name.
+ * @returns Matching server prefix or `null`.
+ *
+ * @private function of `resolveLocalSqliteTableLocation`
+ */
+function resolveLongestMatchingServerTablePrefix(tableName: string): string | null {
+    let longestMatchingPrefix: string | null = null;
+
+    for (const tablePrefix of listStandaloneServerTablePrefixes()) {
+        if (!tableName.startsWith(tablePrefix)) {
+            continue;
+        }
+
+        if (longestMatchingPrefix === null || tablePrefix.length > longestMatchingPrefix.length) {
+            longestMatchingPrefix = tablePrefix;
+        }
+    }
+
+    return longestMatchingPrefix;
+}

package/apps/agents-server/src/database/sqlite/resolveServerSqliteDatabasePath.ts

@@ -0,0 +1,72 @@
+import { dirname, join } from 'path';
+import { spaceTrim } from 'spacetrim';
+import { DatabaseError } from '../../../../../src/errors/DatabaseError';
+import { resolveAgentsServerSqliteDatabasePath } from './resolveAgentsServerSqliteDatabasePath';
+
+/**
+ * Database key used for requests that do not belong to any registered server,
+ * for example localhost development traffic before any server is registered.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export const DEFAULT_SERVER_SQLITE_DATABASE_KEY = 'default';
+
+/**
+ * Directory name (next to the VPS registry database) holding one SQLite file per registered server.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+const SERVER_SQLITE_DATABASES_DIRECTORY_NAME = 'servers';
+
+/**
+ * Pattern of characters allowed inside one per-server database key.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+const SERVER_SQLITE_DATABASE_KEY_PATTERN = /^[A-Za-z0-9_]+$/u;
+
+/**
+ * Resolves the isolated SQLite database file path for one server namespace.
+ *
+ * Each registered server has its own SQLite database file so servers on one VPS
+ * cannot leak agents, projects, metadata or any other data into each other.
+ *
+ * @param tablePrefix - Stable server namespace key such as `server_ClientA_`, or an empty string for the default server.
+ * @returns Absolute path of the per-server SQLite database file.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export function resolveServerSqliteDatabasePath(tablePrefix: string): string {
+    const registryDatabasePath = resolveAgentsServerSqliteDatabasePath();
+    const databaseKey = resolveServerSqliteDatabaseKey(tablePrefix);
+
+    return join(dirname(registryDatabasePath), SERVER_SQLITE_DATABASES_DIRECTORY_NAME, `${databaseKey}.sqlite`);
+}
+
+/**
+ * Converts one server table prefix into a safe database file key.
+ *
+ * @param tablePrefix - Stable server namespace key, or an empty string for the default server.
+ * @returns Validated file-name-safe database key.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export function resolveServerSqliteDatabaseKey(tablePrefix: string): string {
+    const normalizedTablePrefix = tablePrefix.trim().replace(/_+$/u, '');
+
+    if (normalizedTablePrefix === '') {
+        return DEFAULT_SERVER_SQLITE_DATABASE_KEY;
+    }
+
+    if (!SERVER_SQLITE_DATABASE_KEY_PATTERN.test(normalizedTablePrefix)) {
+        throw new DatabaseError(
+            spaceTrim(`
+                Cannot resolve a per-server SQLite database file for table prefix \`${tablePrefix}\`.
+
+                The prefix may contain only letters, numbers, and underscores.
+            `),
+        );
+    }
+
+    return normalizedTablePrefix;
+}