@promptbook/cli 0.112.0-93 → 0.112.0-96

package/apps/agents-server/src/components/Header/buildHeaderSystemMenuItems.ts

@@ -28,6 +28,7 @@ type HeaderTranslate = (key: ServerTranslationKey, variables?: Readonly<Record<s
 type SystemCategoryLabel =
     | 'My Account'
     | 'Utilities'
+    | 'Super Admin'
     | 'Administration'
     | 'Monitoring & Usage'
     | 'Integrations & Keys'
@@ -54,6 +55,7 @@ type BuildHeaderSystemMenuItemsOptions = {
 const SYSTEM_CATEGORY_ICON_MAP: Record<SystemCategoryLabel, LucideIcon> = {
     'My Account': UserRound,
     Utilities: Wrench,
+    'Super Admin': Settings2,
     Administration: Settings2,
     'Monitoring & Usage': BarChart3,
     'Integrations & Keys': KeyRound,
@@ -67,6 +69,7 @@ const SYSTEM_CATEGORY_ICON_MAP: Record<SystemCategoryLabel, LucideIcon> = {
 const SYSTEM_CATEGORY_TRANSLATION_KEY_MAP: Record<SystemCategoryLabel, ServerTranslationKey> = {
     'My Account': 'header.myAccount',
     Utilities: 'header.utilities',
+    'Super Admin': 'header.superAdmin',
     Administration: 'header.administration',
     'Monitoring & Usage': 'header.monitoringAndUsage',
     'Integrations & Keys': 'header.integrationsAndKeys',
@@ -187,16 +190,35 @@ export function buildHeaderSystemMenuItems({
         ];
     }
 
-    const administrationSystemItems: SubMenuItem[] = [
+    const superAdminSystemItems: SubMenuItem[] = [
+        {
+            label: translate('header.servers'),
+            href: '/admin/servers',
+            isBold: true,
+        },
+        {
+            label: translate('header.environmentVariables'),
+            href: '/admin/environment',
+        },
         ...(isGlobalAdmin
             ? [
                   {
-                      label: translate('header.servers'),
-                      href: '/admin/servers',
-                      isBold: true,
+                      label: translate('header.database'),
+                      href: '/admin/database',
+                  } as SubMenuItem,
+                  {
+                      label: translate('header.logs'),
+                      href: '/admin/logs',
+                  } as SubMenuItem,
+                  {
+                      label: translate('header.codeRunners'),
+                      href: '/admin/code-runners',
                   } as SubMenuItem,
               ]
             : []),
+    ];
+
+    const administrationSystemItems: SubMenuItem[] = [
         {
             label: translate('header.models'),
             href: '/admin/models',
@@ -311,6 +333,7 @@ export function buildHeaderSystemMenuItems({
     return [
         ...createSystemCategory('My Account', userAccountSystemItems, translate),
         ...createSystemCategory('Utilities', utilitiesSystemItems, translate),
+        ...createSystemCategory('Super Admin', superAdminSystemItems, translate),
         ...createSystemCategory('Administration', administrationSystemItems, translate),
         ...createSystemCategory('Monitoring & Usage', monitoringAndUsageSystemItems, translate),
         ...createSystemCategory('Integrations & Keys', integrationsAndKeysSystemItems, translate),

package/apps/agents-server/src/database/$provideClientSql.ts

@@ -1,5 +1,6 @@
 import { $isRunningInNode } from '@promptbook-local/utils';
 import { Pool } from 'pg';
+import { resolvePostgresConnectionString } from './resolvePostgresConnectionString';
 
 /**
  * SQL tagged-template executor used by server routes and utilities.
@@ -48,13 +49,8 @@ export async function $provideClientSql(): Promise<ClientSqlExecutor> {
     }
 
     if (!clientPool) {
-        const connectionString = process.env.POSTGRES_URL || process.env.DATABASE_URL;
-        if (!connectionString) {
-            throw new Error('Environment variable `POSTGRES_URL` or `DATABASE_URL` must be defined.');
-        }
-
         clientPool = new Pool({
-            connectionString,
+            connectionString: resolvePostgresConnectionString(),
             ssl: { rejectUnauthorized: false },
         });
     }

package/apps/agents-server/src/database/$provideDatabaseAdminExecutor.ts

@@ -0,0 +1,273 @@
+import type { StudioBFFSqlLintDetails, StudioBFFSqlLintResult } from '@prisma/studio-core/data/bff';
+import { Pool, type PoolClient } from 'pg';
+import { isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
+import { resolvePostgresConnectionString } from './resolvePostgresConnectionString';
+import {
+    $provideAgentsServerSqliteDatabase,
+    type AgentsServerSqliteDatabase,
+} from './sqlite/$provideAgentsServerSqliteDatabase';
+
+/**
+ * Query shape sent by Embedded Prisma Studio adapters.
+ *
+ * @private internal utility of Agents Server database admin
+ */
+export type DatabaseAdminQuery = {
+    readonly sql: string;
+    readonly parameters?: ReadonlyArray<unknown>;
+    readonly transformations?: Partial<Record<string, 'json-parse'>>;
+};
+
+/**
+ * SQL executor surface required by the Embedded Prisma Studio BFF endpoint.
+ *
+ * @private internal utility of Agents Server database admin
+ */
+export type DatabaseAdminExecutor = {
+    readonly execute: (query: DatabaseAdminQuery) => Promise<Array<Record<string, unknown>>>;
+    readonly executeTransaction: (
+        queries: ReadonlyArray<DatabaseAdminQuery>,
+    ) => Promise<Array<Array<Record<string, unknown>>>>;
+    readonly lintSql: (details: StudioBFFSqlLintDetails) => Promise<StudioBFFSqlLintResult>;
+};
+
+/**
+ * Shared PostgreSQL pool for Embedded Prisma Studio requests.
+ */
+let databaseAdminPostgresPool: Pool | null = null;
+
+/**
+ * Provides a raw SQL executor for the configured Agents Server database backend.
+ *
+ * @returns Database admin executor for the active database mode.
+ *
+ * @private exported from Agents Server database utilities
+ */
+export function $provideDatabaseAdminExecutor(): DatabaseAdminExecutor {
+    return isAgentsServerSqliteMode() ? $provideSqliteDatabaseAdminExecutor() : $providePostgresDatabaseAdminExecutor();
+}
+
+/**
+ * Provides the PostgreSQL raw SQL executor used by Embedded Prisma Studio.
+ *
+ * @returns PostgreSQL-backed database admin executor.
+ */
+function $providePostgresDatabaseAdminExecutor(): DatabaseAdminExecutor {
+    const pool = $provideDatabaseAdminPostgresPool();
+
+    return {
+        execute: (query) => executePostgresDatabaseAdminQuery(pool, query),
+        executeTransaction: (queries) => executePostgresDatabaseAdminTransaction(pool, queries),
+        lintSql: (details) => Promise.resolve({ diagnostics: [], schemaVersion: details.schemaVersion }),
+    };
+}
+
+/**
+ * Provides the SQLite raw SQL executor used by Embedded Prisma Studio.
+ *
+ * @returns SQLite-backed database admin executor.
+ */
+function $provideSqliteDatabaseAdminExecutor(): DatabaseAdminExecutor {
+    const database = $provideAgentsServerSqliteDatabase();
+
+    return {
+        execute: (query) => Promise.resolve(executeSqliteDatabaseAdminQuery(database, query)),
+        executeTransaction: (queries) =>
+            Promise.resolve(
+                database.transaction((transactionQueries: ReadonlyArray<DatabaseAdminQuery>) =>
+                    transactionQueries.map((query) => executeSqliteDatabaseAdminQuery(database, query)),
+                )(queries),
+            ),
+        lintSql: (details) => Promise.resolve({ diagnostics: [], schemaVersion: details.schemaVersion }),
+    };
+}
+
+/**
+ * Provides the shared PostgreSQL connection pool for raw database admin access.
+ *
+ * @returns Shared PostgreSQL pool.
+ */
+function $provideDatabaseAdminPostgresPool(): Pool {
+    if (!databaseAdminPostgresPool) {
+        databaseAdminPostgresPool = new Pool({
+            connectionString: resolvePostgresConnectionString(),
+            ssl: { rejectUnauthorized: false },
+        });
+    }
+
+    return databaseAdminPostgresPool;
+}
+
+/**
+ * Executes one PostgreSQL query for Embedded Prisma Studio.
+ *
+ * @param client - PostgreSQL pool or transaction client.
+ * @param query - SQL query generated by Embedded Prisma Studio.
+ * @returns JSON-safe result rows.
+ */
+async function executePostgresDatabaseAdminQuery(
+    client: Pick<Pool | PoolClient, 'query'>,
+    query: DatabaseAdminQuery,
+): Promise<Array<Record<string, unknown>>> {
+    const result = await client.query(query.sql, normalizeDatabaseAdminParameters(query.parameters));
+    return normalizeDatabaseAdminRows(query, result.rows as Array<Record<string, unknown>>);
+}
+
+/**
+ * Executes PostgreSQL queries inside one database transaction.
+ *
+ * @param pool - Shared PostgreSQL pool.
+ * @param queries - SQL queries generated by Embedded Prisma Studio.
+ * @returns Ordered result sets for each query.
+ */
+async function executePostgresDatabaseAdminTransaction(
+    pool: Pool,
+    queries: ReadonlyArray<DatabaseAdminQuery>,
+): Promise<Array<Array<Record<string, unknown>>>> {
+    const client = await pool.connect();
+
+    try {
+        await client.query('BEGIN');
+        const results: Array<Array<Record<string, unknown>>> = [];
+
+        for (const query of queries) {
+            results.push(await executePostgresDatabaseAdminQuery(client, query));
+        }
+
+        await client.query('COMMIT');
+        return results;
+    } catch (error) {
+        await client.query('ROLLBACK').catch(() => undefined);
+        throw error;
+    } finally {
+        client.release();
+    }
+}
+
+/**
+ * Executes one SQLite query for Embedded Prisma Studio.
+ *
+ * @param database - Shared SQLite database.
+ * @param query - SQL query generated by Embedded Prisma Studio.
+ * @returns JSON-safe result rows.
+ */
+function executeSqliteDatabaseAdminQuery(
+    database: AgentsServerSqliteDatabase,
+    query: DatabaseAdminQuery,
+): Array<Record<string, unknown>> {
+    const statement = database.prepare(query.sql);
+    const parameters = normalizeDatabaseAdminParameters(query.parameters);
+    const isReader = statement.reader === true;
+    const rows = isReader ? statement.all(...parameters) : [];
+
+    if (!isReader) {
+        statement.run(...parameters);
+    }
+
+    return normalizeDatabaseAdminRows(query, rows);
+}
+
+/**
+ * Normalizes query parameters before passing them into SQL drivers.
+ *
+ * @param parameters - Query parameters generated by Embedded Prisma Studio.
+ * @returns Parameters safe to bind to PostgreSQL or SQLite.
+ */
+function normalizeDatabaseAdminParameters(parameters: ReadonlyArray<unknown> = []): Array<unknown> {
+    return parameters.map((value) => (value === undefined ? null : value));
+}
+
+/**
+ * Applies Studio result transformations and converts rows into JSON-safe objects.
+ *
+ * @param query - SQL query whose transformations should be applied.
+ * @param rows - Raw database rows.
+ * @returns JSON-safe transformed rows.
+ */
+function normalizeDatabaseAdminRows(
+    query: DatabaseAdminQuery,
+    rows: ReadonlyArray<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+    return rows.map((row) => normalizeDatabaseAdminRow(applyDatabaseAdminQueryTransformations(query, row)));
+}
+
+/**
+ * Applies one query's declared result transformations to a row.
+ *
+ * @param query - SQL query whose transformations should be applied.
+ * @param row - Raw database row.
+ * @returns Transformed row.
+ */
+function applyDatabaseAdminQueryTransformations(
+    query: DatabaseAdminQuery,
+    row: Record<string, unknown>,
+): Record<string, unknown> {
+    const transformations = query.transformations;
+
+    if (!transformations || Object.keys(transformations).length === 0) {
+        return row;
+    }
+
+    const transformedRow = { ...row };
+
+    for (const [column, transformation] of Object.entries(transformations)) {
+        if (transformation !== 'json-parse' || typeof transformedRow[column] !== 'string') {
+            continue;
+        }
+
+        try {
+            transformedRow[column] = JSON.parse(transformedRow[column] as string);
+        } catch (error) {
+            console.error(`Failed to JSON.parse database admin column "${column}".`, error);
+        }
+    }
+
+    return transformedRow;
+}
+
+/**
+ * Converts one database row into values that can be returned via `NextResponse.json`.
+ *
+ * @param row - Database row.
+ * @returns JSON-safe row.
+ */
+function normalizeDatabaseAdminRow(row: Record<string, unknown>): Record<string, unknown> {
+    return Object.fromEntries(
+        Object.entries(row).map(([key, value]) => [key, normalizeDatabaseAdminValue(value)]),
+    ) as Record<string, unknown>;
+}
+
+/**
+ * Converts one database value into a JSON-safe representation.
+ *
+ * @param value - Database value.
+ * @returns JSON-safe value.
+ */
+function normalizeDatabaseAdminValue(value: unknown): unknown {
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+        return value.toString('base64');
+    }
+
+    if (Array.isArray(value)) {
+        return value.map(normalizeDatabaseAdminValue);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+        return Object.fromEntries(
+            Object.entries(value as Record<string, unknown>).map(([key, childValue]) => [
+                key,
+                normalizeDatabaseAdminValue(childValue),
+            ]),
+        );
+    }
+
+    return value;
+}

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

@@ -0,0 +1,26 @@
+import spaceTrim from 'spacetrim';
+import { DatabaseError } from '../../../../src/errors/DatabaseError';
+
+/**
+ * Resolves the PostgreSQL connection string used by Supabase-backed Agents Server database access.
+ *
+ * @returns PostgreSQL connection string.
+ * @throws DatabaseError when neither supported environment variable is configured.
+ *
+ * @private exported from Agents Server database utilities
+ */
+export function resolvePostgresConnectionString(): string {
+    const connectionString = process.env.POSTGRES_URL || process.env.DATABASE_URL;
+
+    if (!connectionString) {
+        throw new DatabaseError(
+            spaceTrim(`
+                Environment variable \`POSTGRES_URL\` or \`DATABASE_URL\` must be defined.
+
+                Configure one of these variables to use the Supabase/PostgreSQL database backend.
+            `),
+        );
+    }
+
+    return connectionString;
+}

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

@@ -0,0 +1,83 @@
+import { existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { resolveAgentsServerSqliteDatabasePath } from './resolveAgentsServerSqliteDatabasePath';
+
+/**
+ * Shape of the `better-sqlite3` module constructor loaded at runtime.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export type BetterSqliteConstructor = new (path: string) => AgentsServerSqliteDatabase;
+
+/**
+ * Minimal `better-sqlite3` database surface shared by Agents Server SQLite utilities.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export type AgentsServerSqliteDatabase = {
+    readonly pragma: (source: string) => unknown;
+    readonly exec: (source: string) => void;
+    readonly prepare: (source: string) => AgentsServerSqliteStatement;
+    readonly transaction: <TArguments extends ReadonlyArray<unknown>, TResult>(
+        fn: (...args: TArguments) => TResult,
+    ) => (...args: TArguments) => TResult;
+    readonly close?: () => void;
+};
+
+/**
+ * Minimal `better-sqlite3` prepared statement surface shared by Agents Server SQLite utilities.
+ *
+ * @private internal SQLite utility of Agents Server
+ */
+export type AgentsServerSqliteStatement = {
+    readonly reader?: boolean;
+    readonly all: (...values: ReadonlyArray<unknown>) => Array<Record<string, unknown>>;
+    readonly get: (...values: ReadonlyArray<unknown>) => Record<string, unknown> | undefined;
+    readonly run: (...values: ReadonlyArray<unknown>) => {
+        readonly changes: number;
+        readonly lastInsertRowid: number | bigint;
+    };
+};
+
+/**
+ * Cached SQLite database connection.
+ */
+let agentsServerSqliteDatabase: AgentsServerSqliteDatabase | null = null;
+
+/**
+ * Opens and initializes the shared local SQLite database.
+ *
+ * @returns Shared SQLite database connection.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function $provideAgentsServerSqliteDatabase(): AgentsServerSqliteDatabase {
+    if (agentsServerSqliteDatabase) {
+        return agentsServerSqliteDatabase;
+    }
+
+    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');
+
+    return agentsServerSqliteDatabase;
+}
+
+/**
+ * Closes the cached SQLite connection and resets adapter state for isolated tests.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function $resetAgentsServerSqliteDatabaseForTests(): void {
+    agentsServerSqliteDatabase?.close?.();
+    agentsServerSqliteDatabase = null;
+}

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

@@ -1,8 +1,10 @@
-import { existsSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { TODO_any } from '@promptbook-local/types';
-import { resolveAgentsServerSqliteDatabasePath } from './resolveAgentsServerSqliteDatabasePath';
+import {
+    $provideAgentsServerSqliteDatabase,
+    $resetAgentsServerSqliteDatabaseForTests,
+    type AgentsServerSqliteDatabase,
+} from './$provideAgentsServerSqliteDatabase';
 
 /**
  * Minimal query result shape consumed by Agents Server Supabase call sites.
@@ -63,33 +65,6 @@ type LocalSqliteUpsertOptions = {
     readonly onConflict?: string;
 };
 
-/**
- * Shape of the `better-sqlite3` module constructor loaded at runtime.
- */
-type BetterSqliteConstructor = new (path: string) => BetterSqliteDatabase;
-
-/**
- * Minimal `better-sqlite3` database surface used by this adapter.
- */
-type BetterSqliteDatabase = {
-    readonly pragma: (source: string) => unknown;
-    readonly exec: (source: string) => void;
-    readonly prepare: (source: string) => BetterSqliteStatement;
-    readonly close?: () => void;
-};
-
-/**
- * Minimal `better-sqlite3` prepared statement surface used by this adapter.
- */
-type BetterSqliteStatement = {
-    readonly all: (...values: ReadonlyArray<unknown>) => Array<Record<string, unknown>>;
-    readonly get: (...values: ReadonlyArray<unknown>) => Record<string, unknown> | undefined;
-    readonly run: (...values: ReadonlyArray<unknown>) => {
-        readonly changes: number;
-        readonly lastInsertRowid: number | bigint;
-    };
-};
-
 /**
  * Columns whose values are persisted as JSON text in local SQLite.
  */
@@ -170,11 +145,6 @@ const DEFAULT_UPSERT_CONFLICT_COLUMNS_BY_TABLE = new Map<string, ReadonlyArray<s
     ['ServerLimit', ['key']],
 ]);
 
-/**
- * Cached SQLite database connection.
- */
-let sqliteDatabase: BetterSqliteDatabase | null = null;
-
 /**
  * Cached Supabase-shaped local client.
  */
@@ -188,7 +158,7 @@ export function $provideLocalSqliteSupabase(): SupabaseClient {
         return localSqliteSupabase;
     }
 
-    localSqliteSupabase = new LocalSqliteSupabaseClient(getSqliteDatabase()) as unknown as SupabaseClient;
+    localSqliteSupabase = new LocalSqliteSupabaseClient($provideAgentsServerSqliteDatabase()) as unknown as SupabaseClient;
     return localSqliteSupabase;
 }
 
@@ -196,40 +166,15 @@ export function $provideLocalSqliteSupabase(): SupabaseClient {
  * Closes the cached SQLite connection and resets adapter state for isolated tests.
  */
 export function $resetLocalSqliteSupabaseForTests(): void {
-    sqliteDatabase?.close?.();
-    sqliteDatabase = null;
+    $resetAgentsServerSqliteDatabaseForTests();
     localSqliteSupabase = null;
 }
 
-/**
- * Opens and initializes the shared local SQLite database.
- */
-function getSqliteDatabase(): BetterSqliteDatabase {
-    if (sqliteDatabase) {
-        return sqliteDatabase;
-    }
-
-    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;
-    sqliteDatabase = new BetterSqlite(databasePath);
-    sqliteDatabase.pragma('journal_mode = WAL');
-    sqliteDatabase.pragma('foreign_keys = ON');
-
-    return sqliteDatabase;
-}
-
 /**
  * Supabase-shaped client with only the table query surface used by Agents Server.
  */
 class LocalSqliteSupabaseClient {
-    public constructor(private readonly database: BetterSqliteDatabase) {}
+    public constructor(private readonly database: AgentsServerSqliteDatabase) {}
 
     /**
      * Starts a query for one SQLite table.
@@ -244,7 +189,7 @@ class LocalSqliteSupabaseClient {
  */
 class LocalSqliteTable {
     public constructor(
-        private readonly database: BetterSqliteDatabase,
+        private readonly database: AgentsServerSqliteDatabase,
         private readonly tableName: string,
     ) {}
 
@@ -304,7 +249,7 @@ class LocalSqliteQueryBuilder implements PromiseLike<LocalSqliteQueryResult> {
     private isReturningSelection = false;
 
     public constructor(
-        private readonly database: BetterSqliteDatabase,
+        private readonly database: AgentsServerSqliteDatabase,
         private readonly tableName: string,
     ) {}
 
@@ -851,7 +796,11 @@ type ParsedPostgrestFilter = {
 /**
  * Ensures a table and all required columns exist.
  */
-function ensureTable(database: BetterSqliteDatabase, tableName: string, requiredColumns: ReadonlyArray<string>): void {
+function ensureTable(
+    database: AgentsServerSqliteDatabase,
+    tableName: string,
+    requiredColumns: ReadonlyArray<string>,
+): void {
     const tableBaseName = resolveTableBaseName(tableName);
     const primaryKey = TEXT_PRIMARY_KEY_TABLES.has(tableBaseName)
         ? '"id" TEXT PRIMARY KEY'
@@ -886,7 +835,7 @@ function ensureTable(database: BetterSqliteDatabase, tableName: string, required
 /**
  * Creates known unique indexes after required columns exist.
  */
-function ensureUniqueIndexes(database: BetterSqliteDatabase, tableName: string, tableBaseName: string): void {
+function ensureUniqueIndexes(database: AgentsServerSqliteDatabase, tableName: string, tableBaseName: string): void {
     const uniqueIndexes = UNIQUE_INDEX_COLUMNS_BY_TABLE.get(tableBaseName) || [];
 
     for (const columns of uniqueIndexes) {
@@ -900,7 +849,7 @@ function ensureUniqueIndexes(database: BetterSqliteDatabase, tableName: string,
  * Inserts one row into the table.
  */
 function insertRow(
-    database: BetterSqliteDatabase,
+    database: AgentsServerSqliteDatabase,
     tableName: string,
     row: Record<string, unknown>,
 ): { readonly lastInsertRowid: number | bigint } {
@@ -921,7 +870,7 @@ function insertRow(
  * Updates one row by SQLite rowid.
  */
 function updateRowid(
-    database: BetterSqliteDatabase,
+    database: AgentsServerSqliteDatabase,
     tableName: string,
     rowid: number | bigint,
     row: Record<string, unknown>,
@@ -940,7 +889,7 @@ function updateRowid(
  * Finds the rowid matching an upsert conflict target.
  */
 function findConflictRowid(
-    database: BetterSqliteDatabase,
+    database: AgentsServerSqliteDatabase,
     tableName: string,
     row: Record<string, unknown>,
     conflictColumns: ReadonlyArray<string>,
@@ -960,7 +909,7 @@ function findConflictRowid(
  * Selects rows by rowids for a mutation returning clause.
  */
 function selectRowsByRowids(
-    database: BetterSqliteDatabase,
+    database: AgentsServerSqliteDatabase,
     tableName: string,
     rowids: ReadonlyArray<number | bigint>,
     selectedColumns: ReadonlyArray<string>,

package/apps/agents-server/src/languages/ServerTranslationKeys.ts

@@ -126,6 +126,7 @@ export const SERVER_TRANSLATION_KEYS = [
     'header.changePassword',
     'header.menuLabel',
     'header.myAccount',
+    'header.superAdmin',
     'header.administration',
     'header.monitoringAndUsage',
     'header.integrationsAndKeys',
@@ -140,6 +141,10 @@ export const SERVER_TRANSLATION_KEYS = [
     'header.viewAllUsers',
     'header.createNewUser',
     'header.servers',
+    'header.environmentVariables',
+    'header.database',
+    'header.logs',
+    'header.codeRunners',
     'header.models',
     'header.openApiDocumentation',
     'header.apiTokens',