@promptbook/cli 0.112.0-93 → 0.112.0-96

package/apps/agents-server/src/app/admin/servers/useServersRegistryState.ts

@@ -138,6 +138,11 @@ type DeleteCurrentServerConfirmationResult = {
  * @private function of <ServersClient/>
  */
 type UseServersRegistryStateResult = {
+    /**
+     * Whether the current viewer can mutate server rows.
+     */
+    readonly canEdit: boolean;
+
     /**
      * Server resolved from the current request domain.
      */
@@ -429,12 +434,13 @@ function useServersRegistryDraftState(servers: ReadonlyArray<ManagedServerRow>)
  */
 function useServersRegistryReloadAction(options: {
     readonly replaceServerDrafts: (servers: ReadonlyArray<ManagedServerRow>) => void;
+    readonly setCanEdit: (canEdit: boolean) => void;
     readonly setCurrentServerId: (currentServerId: number | null) => void;
     readonly setError: (error: string | null) => void;
     readonly setLoading: (isLoading: boolean) => void;
     readonly setServers: (servers: ManagedServerRow[]) => void;
 }) {
-    const { replaceServerDrafts, setCurrentServerId, setError, setLoading, setServers } = options;
+    const { replaceServerDrafts, setCanEdit, setCurrentServerId, setError, setLoading, setServers } = options;
 
     return useCallback(async () => {
         setLoading(true);
@@ -444,13 +450,14 @@ function useServersRegistryReloadAction(options: {
             const payload = await ServersRegistryApi.fetchServers();
             setServers([...payload.servers]);
             setCurrentServerId(payload.currentServerId);
+            setCanEdit(payload.canEdit);
             replaceServerDrafts(payload.servers);
         } catch (loadError) {
             setError(resolveServersRegistryActionErrorMessage(loadError, 'Failed to load servers.'));
         } finally {
             setLoading(false);
         }
-    }, [replaceServerDrafts, setCurrentServerId, setError, setLoading, setServers]);
+    }, [replaceServerDrafts, setCanEdit, setCurrentServerId, setError, setLoading, setServers]);
 }
 
 /**
@@ -618,6 +625,7 @@ function useDeleteCurrentServerAction(options: {
  */
 export function useServersRegistryState(): UseServersRegistryStateResult {
     const [servers, setServers] = useState<ManagedServerRow[]>([]);
+    const [canEdit, setCanEdit] = useState(false);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState<string | null>(null);
     const [currentServerId, setCurrentServerId] = useState<number | null>(null);
@@ -635,6 +643,7 @@ export function useServersRegistryState(): UseServersRegistryStateResult {
 
     const reloadServers = useServersRegistryReloadAction({
         replaceServerDrafts,
+        setCanEdit,
         setCurrentServerId,
         setError,
         setLoading,
@@ -671,6 +680,7 @@ export function useServersRegistryState(): UseServersRegistryStateResult {
     });
 
     return {
+        canEdit,
         currentServer,
         currentServerId,
         deletingServerId,

package/apps/agents-server/src/app/api/admin/code-runners/route.ts

@@ -0,0 +1,104 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { NextResponse } from 'next/server';
+import { isUserGlobalAdmin } from '@/src/utils/isUserGlobalAdmin';
+import {
+    applyVpsCodeRunnerConfiguration,
+    listVpsEnvironmentVariables,
+    updateVpsEnvironmentVariables,
+} from '@/src/utils/vpsConfiguration';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Loads configured code-runner settings from the editable VPS environment.
+ */
+export async function GET() {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const snapshot = await listVpsEnvironmentVariables();
+        const environmentByKey = Object.fromEntries(
+            snapshot.variables.map((variable) => [variable.key, variable.value]),
+        ) as Record<string, string>;
+
+        return NextResponse.json({
+            agent: environmentByKey.PTBK_AGENT || process.env.PTBK_AGENT || 'github-copilot',
+            model: environmentByKey.PTBK_MODEL || process.env.PTBK_MODEL || 'gpt-5.4',
+            thinkingLevel: environmentByKey.PTBK_THINKING_LEVEL || process.env.PTBK_THINKING_LEVEL || 'xhigh',
+            status: await resolveRunnerStatus(environmentByKey.PTBK_AGENT || process.env.PTBK_AGENT || 'github-copilot'),
+        });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to load code-runner configuration.' },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * Updates code-runner environment variables.
+ */
+export async function PATCH(request: Request) {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const body = (await request.json().catch(() => null)) as
+            | {
+                  readonly agent?: string;
+                  readonly model?: string;
+                  readonly thinkingLevel?: string;
+                  readonly applyRuntimeConfiguration?: boolean;
+              }
+            | null;
+
+        if (!body) {
+            return NextResponse.json({ error: 'Code-runner payload is required.' }, { status: 400 });
+        }
+
+        await updateVpsEnvironmentVariables({
+            PTBK_AGENT: body.agent || '',
+            PTBK_MODEL: body.model || '',
+            PTBK_THINKING_LEVEL: body.thinkingLevel || '',
+        });
+
+        const response = await GET();
+        const payload = (await response.json()) as Record<string, unknown>;
+
+        return NextResponse.json({
+            ...payload,
+            applyResult: body.applyRuntimeConfiguration ? await applyVpsCodeRunnerConfiguration() : null,
+        });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to update code-runner configuration.' },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * Resolves a short runner-authentication status for the configured runner.
+ *
+ * @param agent - Runner id.
+ * @returns Human-readable status.
+ */
+async function resolveRunnerStatus(agent: string): Promise<string> {
+    if (agent !== 'github-copilot') {
+        return 'Status check is currently available for GitHub Copilot CLI only.';
+    }
+
+    try {
+        const { stdout, stderr } = await execFileAsync('copilot', ['auth', 'status'], {
+            timeout: 10_000,
+            maxBuffer: 128 * 1024,
+        });
+        return [stdout, stderr].filter(Boolean).join('\n').trim() || 'GitHub Copilot CLI returned no status output.';
+    } catch (error) {
+        return error instanceof Error ? error.message : 'GitHub Copilot CLI status check failed.';
+    }
+}

package/apps/agents-server/src/app/api/admin/database/studio/route.ts

@@ -0,0 +1,113 @@
+import { serializeError, type StudioBFFRequest } from '@prisma/studio-core/data/bff';
+import { NextResponse } from 'next/server';
+import {
+    $provideDatabaseAdminExecutor,
+    type DatabaseAdminExecutor,
+    type DatabaseAdminQuery,
+} from '../../../../../database/$provideDatabaseAdminExecutor';
+import { isUserGlobalAdmin } from '../../../../../utils/isUserGlobalAdmin';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * Handles Embedded Prisma Studio SQL requests for the configured Agents Server database.
+ *
+ * @param request - Incoming Studio BFF request.
+ * @returns Studio-compatible JSON response.
+ */
+export async function POST(request: Request): Promise<NextResponse> {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+    }
+
+    let payload: StudioBFFRequest;
+
+    try {
+        payload = (await request.json()) as StudioBFFRequest;
+    } catch (error) {
+        return NextResponse.json([serializeError(error)], { status: 400 });
+    }
+
+    return handleDatabaseAdminStudioRequest($provideDatabaseAdminExecutor(), payload);
+}
+
+/**
+ * Resolves one Studio BFF payload against the raw database executor.
+ *
+ * @param executor - Raw SQL executor for the active database backend.
+ * @param payload - Studio BFF request payload.
+ * @returns Studio-compatible JSON response.
+ */
+async function handleDatabaseAdminStudioRequest(
+    executor: DatabaseAdminExecutor,
+    payload: StudioBFFRequest,
+): Promise<NextResponse> {
+    try {
+        switch (payload.procedure) {
+            case 'query':
+                return NextResponse.json([null, await executor.execute(payload.query as DatabaseAdminQuery)]);
+
+            case 'sequence':
+                return handleDatabaseAdminStudioSequence(executor, payload.sequence as readonly [
+                    DatabaseAdminQuery,
+                    DatabaseAdminQuery,
+                ]);
+
+            case 'transaction':
+                return NextResponse.json([
+                    null,
+                    await executor.executeTransaction(payload.queries as ReadonlyArray<DatabaseAdminQuery>),
+                ]);
+
+            case 'sql-lint':
+                return NextResponse.json([
+                    null,
+                    await executor.lintSql({
+                        schemaVersion: payload.schemaVersion,
+                        sql: payload.sql,
+                    }),
+                ]);
+
+            default:
+                return NextResponse.json([serializeError(new Error('Invalid database admin procedure.'))], {
+                    status: 400,
+                });
+        }
+    } catch (error) {
+        return NextResponse.json([serializeError(error)]);
+    }
+}
+
+/**
+ * Executes a two-step Studio sequence, preserving the response shape expected by the BFF client.
+ *
+ * @param executor - Raw SQL executor for the active database backend.
+ * @param sequence - Exactly two Studio-generated queries.
+ * @returns Studio-compatible sequence response.
+ */
+async function handleDatabaseAdminStudioSequence(
+    executor: DatabaseAdminExecutor,
+    sequence: readonly [DatabaseAdminQuery, DatabaseAdminQuery],
+): Promise<NextResponse> {
+    const [firstQuery, secondQuery] = sequence;
+
+    try {
+        const firstResult = await executor.execute(firstQuery);
+
+        try {
+            const secondResult = await executor.execute(secondQuery);
+            return NextResponse.json([
+                [null, firstResult],
+                [null, secondResult],
+            ]);
+        } catch (error) {
+            return NextResponse.json([
+                [null, firstResult],
+                [serializeError(error)],
+            ]);
+        }
+    } catch (error) {
+        return NextResponse.json([[serializeError(error)]]);
+    }
+}

package/apps/agents-server/src/app/api/admin/environment/route.ts

@@ -0,0 +1,65 @@
+import { NextResponse } from 'next/server';
+import {
+    applyVpsRuntimeConfiguration,
+    listVpsEnvironmentVariables,
+    updateVpsEnvironmentVariables,
+} from '@/src/utils/vpsConfiguration';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
+import { isUserGlobalAdmin } from '@/src/utils/isUserGlobalAdmin';
+
+/**
+ * Loads `.env` variables visible in the admin UI.
+ */
+export async function GET() {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        return NextResponse.json({
+            ...(await listVpsEnvironmentVariables()),
+            canEdit: await isUserGlobalAdmin(),
+        });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to load environment variables.' },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * Persists editable `.env` variables and optionally reapplies VPS runtime configuration.
+ */
+export async function PATCH(request: Request) {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const body = (await request.json().catch(() => null)) as
+            | {
+                  readonly variables?: Record<string, string>;
+                  readonly applyRuntimeConfiguration?: boolean;
+              }
+            | null;
+
+        if (!body || typeof body.variables !== 'object' || body.variables === null) {
+            return NextResponse.json({ error: 'Variables payload is required.' }, { status: 400 });
+        }
+
+        const snapshot = await updateVpsEnvironmentVariables(body.variables);
+        const applyResult = body.applyRuntimeConfiguration ? await applyVpsRuntimeConfiguration() : null;
+
+        return NextResponse.json({
+            ...snapshot,
+            canEdit: true,
+            applyResult,
+        });
+    } catch (error) {
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to update environment variables.' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/admin/logs/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server';
+import { isUserGlobalAdmin } from '@/src/utils/isUserGlobalAdmin';
+import { readVpsPm2Logs } from '@/src/utils/vpsConfiguration';
+
+/**
+ * Loads recent pm2 logs for the standalone Agents Server process.
+ */
+export async function GET(request: Request) {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const url = new URL(request.url);
+        const rawLines = Number.parseInt(url.searchParams.get('lines') || '200', 10);
+        const lineCount = Number.isFinite(rawLines) ? Math.min(Math.max(rawLines, 20), 1000) : 200;
+        return NextResponse.json(await readVpsPm2Logs(lineCount));
+    } catch (error) {
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to load pm2 logs.' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/admin/servers/[serverId]/route.ts

@@ -1,7 +1,12 @@
 import { NextResponse } from 'next/server';
+import { isAgentsServerSqliteMode } from '../../../../../database/agentsServerDatabaseMode';
 import { resolveCurrentServerRegistryContext } from '../../../../../utils/currentServerRegistryContext';
 import { isUserGlobalAdmin } from '../../../../../utils/isUserGlobalAdmin';
-import { createServerPublicUrl } from '../../../../../utils/serverRegistry';
+import {
+    createServerPublicUrl,
+    listEnvironmentRegisteredServers,
+    normalizeServerDomain,
+} from '../../../../../utils/serverRegistry';
 import {
     assertGlobalAdminAccess,
     deleteManagedServer,
@@ -10,6 +15,11 @@ import {
     updateManagedServer,
     type UpdateServerInput,
 } from '../../../../../utils/serverManagement';
+import {
+    applyVpsRuntimeConfiguration,
+    listConfiguredVpsDomains,
+    updateConfiguredVpsDomains,
+} from '../../../../../utils/vpsConfiguration';
 
 /**
  * Updates editable `_Server` fields for one registered server.
@@ -24,8 +34,15 @@ export async function PATCH(request: Request, context: { params: Promise<{ serve
 
         const { serverId } = await context.params;
         const body = (await request.json()) as Omit<UpdateServerInput, 'id'>;
+        const parsedServerId = parseManagedServerId(serverId);
+
+        if (isAgentsServerSqliteMode()) {
+            const updatedServer = await updateStandaloneVpsServerDomain(parsedServerId, body.domain);
+            return NextResponse.json({ server: updatedServer });
+        }
+
         const updatedServer = await updateManagedServer({
-            id: parseManagedServerId(serverId),
+            id: parsedServerId,
             ...body,
         });
 
@@ -52,9 +69,19 @@ export async function DELETE(_request: Request, context: { params: Promise<{ ser
         assertGlobalAdminAccess(await isUserGlobalAdmin());
 
         const { serverId } = await context.params;
+        const parsedServerId = parseManagedServerId(serverId);
+
+        if (isAgentsServerSqliteMode()) {
+            await deleteStandaloneVpsServerDomain(parsedServerId);
+            return NextResponse.json({
+                success: true,
+                redirectUrl: null,
+            });
+        }
+
         const currentContext = await resolveCurrentServerRegistryContext();
         const nextServerId = await deleteManagedServer({
-            serverId: parseManagedServerId(serverId),
+            serverId: parsedServerId,
             currentServerId: currentContext.currentServer?.id ?? null,
         });
         const nextServer =
@@ -76,3 +103,52 @@ export async function DELETE(_request: Request, context: { params: Promise<{ ser
         );
     }
 }
+
+/**
+ * Updates a virtual standalone VPS server by replacing its domain in `SERVERS`.
+ *
+ * @param serverId - Virtual server id.
+ * @param rawDomain - Replacement domain.
+ * @returns Updated virtual server row.
+ */
+async function updateStandaloneVpsServerDomain(serverId: number, rawDomain: string) {
+    const normalizedDomain = normalizeServerDomain(rawDomain);
+    if (!normalizedDomain) {
+        throw new Error('A valid domain is required.');
+    }
+
+    const servers = listEnvironmentRegisteredServers();
+    const serverIndex = servers.findIndex((server) => server.id === serverId);
+    if (serverIndex === -1) {
+        throw new Error(`Standalone VPS server ${serverId} was not found.`);
+    }
+
+    const domains = await listConfiguredVpsDomains();
+    const nextDomains = domains.map((domain, index) => (index === serverIndex ? normalizedDomain : domain));
+    await updateConfiguredVpsDomains(nextDomains);
+    await applyVpsRuntimeConfiguration();
+
+    const updatedServer = listEnvironmentRegisteredServers().find((server) => server.domain === normalizedDomain);
+    if (!updatedServer) {
+        throw new Error(`Standalone VPS server ${normalizedDomain} was not persisted.`);
+    }
+
+    return updatedServer;
+}
+
+/**
+ * Deletes a virtual standalone VPS server by removing its domain from `SERVERS`.
+ *
+ * @param serverId - Virtual server id.
+ */
+async function deleteStandaloneVpsServerDomain(serverId: number): Promise<void> {
+    const servers = listEnvironmentRegisteredServers();
+    const serverIndex = servers.findIndex((server) => server.id === serverId);
+    if (serverIndex === -1) {
+        throw new Error(`Standalone VPS server ${serverId} was not found.`);
+    }
+
+    const domains = await listConfiguredVpsDomains();
+    await updateConfiguredVpsDomains(domains.filter((_domain, index) => index !== serverIndex));
+    await applyVpsRuntimeConfiguration();
+}

package/apps/agents-server/src/app/api/admin/servers/route.ts

@@ -1,12 +1,24 @@
 import { NextResponse } from 'next/server';
+import { isAgentsServerSqliteMode } from '../../../../database/agentsServerDatabaseMode';
 import { resolveCurrentServerRegistryContext } from '../../../../utils/currentServerRegistryContext';
+import { isUserAdmin } from '../../../../utils/isUserAdmin';
 import { isUserGlobalAdmin } from '../../../../utils/isUserGlobalAdmin';
+import {
+    createServerPublicUrl,
+    listEnvironmentRegisteredServers,
+    normalizeServerDomain,
+} from '../../../../utils/serverRegistry';
 import {
     assertGlobalAdminAccess,
     createManagedServer,
     resolveManagedServerErrorStatus,
     type CreateServerInput,
 } from '../../../../utils/serverManagement';
+import {
+    applyVpsRuntimeConfiguration,
+    listConfiguredVpsDomains,
+    updateConfiguredVpsDomains,
+} from '../../../../utils/vpsConfiguration';
 
 /**
  * Lists all registered servers together with the server resolved from the current domain.
@@ -15,12 +27,15 @@ import {
  */
 export async function GET() {
     try {
-        assertGlobalAdminAccess(await isUserGlobalAdmin());
+        if (!(await isUserAdmin())) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
 
         const context = await resolveCurrentServerRegistryContext();
         return NextResponse.json({
             servers: context.registeredServers,
             currentServerId: context.currentServer?.id ?? null,
+            canEdit: await isUserGlobalAdmin(),
         });
     } catch (error) {
         return NextResponse.json(
@@ -43,6 +58,26 @@ export async function POST(request: Request) {
         assertGlobalAdminAccess(await isUserGlobalAdmin());
 
         const body = (await request.json()) as CreateServerInput;
+        if (isAgentsServerSqliteMode()) {
+            const normalizedDomain = normalizeServerDomain(body.domain);
+            if (!normalizedDomain) {
+                return NextResponse.json({ error: 'A valid domain is required.' }, { status: 400 });
+            }
+
+            const existingDomains = await listConfiguredVpsDomains();
+            await updateConfiguredVpsDomains([...existingDomains, normalizedDomain]);
+            await applyVpsRuntimeConfiguration();
+            const createdServer = listEnvironmentRegisteredServers().find((server) => server.domain === normalizedDomain);
+
+            return NextResponse.json(
+                {
+                    server: createdServer ?? null,
+                    publicUrl: createServerPublicUrl(normalizedDomain).href,
+                },
+                { status: 201 },
+            );
+        }
+
         const result = await createManagedServer(body);
 
         if (!result.ok) {

package/apps/agents-server/src/app/layout.tsx

@@ -46,6 +46,7 @@ import {
     CONTROL_PANEL_OPTION_AVAILABILITY_METADATA_KEYS,
     getControlPanelOptionAvailability,
 } from '../utils/getControlPanelOptionAvailability';
+import '@prisma/studio-core/ui/index.css';
 import './globals.css';
 
 /**

package/apps/agents-server/src/app/page.tsx

@@ -1,15 +1,39 @@
 import { headers } from 'next/headers';
+import Link from 'next/link';
+import { redirect } from 'next/navigation';
 import { $sideEffect } from '../../../../src/utils/organization/$sideEffect';
+import { ForbiddenPage } from '../components/ForbiddenPage/ForbiddenPage';
 import { HomepagePrimarySections } from '../components/Homepage/HomepagePrimarySections';
 import { $provideServer } from '../tools/$provideServer';
 import { isUserAdmin } from '../utils/isUserAdmin';
+import { isUserGlobalAdmin } from '../utils/isUserGlobalAdmin';
+import {
+    createServerPublicUrl,
+    listRegisteredServersUsingServiceRole,
+    resolveRegisteredServerByHost,
+    type ServerRecord,
+} from '../utils/serverRegistry';
 import { getHomePageAgents } from './_data/getHomePageAgents';
 
 /**
  * Renders the simplified agents home page with local and federated agents.
  */
 export default async function HomePage() {
-    $sideEffect(/* Note: [??] This will ensure dynamic rendering of page and avoid Next.js pre-render */ headers());
+    const headerStore = await headers();
+    $sideEffect(/* Note: [??] This will ensure dynamic rendering of page and avoid Next.js pre-render */ headerStore);
+
+    const ipAddressRouting = await resolveIpAddressRouting(headerStore.get('host'));
+    if (ipAddressRouting === 'LOGIN') {
+        return <ForbiddenPage />;
+    }
+
+    if (ipAddressRouting === 'CONFIGURE') {
+        redirect('/admin/servers?setup=1');
+    }
+
+    if (Array.isArray(ipAddressRouting)) {
+        return <IpAddressDomainChooser servers={ipAddressRouting} />;
+    }
 
     const [{ publicUrl }, isAdmin, { agents, folders, homepageMessage, currentUser }] = await Promise.all([
         $provideServer(),
@@ -32,3 +56,79 @@ export default async function HomePage() {
         </div>
     );
 }
+
+/**
+ * Resolves special raw-IP behavior for standalone VPS access.
+ *
+ * @param host - Request host header.
+ * @returns Routing instruction or `null` when normal homepage rendering should continue.
+ */
+async function resolveIpAddressRouting(host: string | null): Promise<'LOGIN' | 'CONFIGURE' | ReadonlyArray<ServerRecord> | null> {
+    if (!host || !isIpAddressHost(host)) {
+        return null;
+    }
+
+    const registeredServers = await listRegisteredServersUsingServiceRole().catch(() => []);
+    if (resolveRegisteredServerByHost(host, registeredServers)) {
+        return null;
+    }
+
+    if (registeredServers.length === 0) {
+        return (await isUserGlobalAdmin()) ? 'CONFIGURE' : 'LOGIN';
+    }
+
+    if (registeredServers.length === 1) {
+        redirect(createServerPublicUrl(registeredServers[0]!.domain).href);
+    }
+
+    return registeredServers;
+}
+
+/**
+ * Checks whether the request host is a raw IPv4 or IPv6 address.
+ *
+ * @param host - Raw host header.
+ * @returns `true` for IP-address access.
+ */
+function isIpAddressHost(host: string): boolean {
+    const hostname = host
+        .trim()
+        .replace(/^\[(.+)\](?::\d+)?$/u, '$1')
+        .replace(/:\d+$/u, '');
+
+    return /^\d{1,3}(?:\.\d{1,3}){3}$/u.test(hostname) || hostname.includes(':');
+}
+
+/**
+ * Simple domain chooser shown when a raw IP has multiple configured domains.
+ *
+ * @param props - Configured server list.
+ */
+function IpAddressDomainChooser(props: { readonly servers: ReadonlyArray<ServerRecord> }) {
+    return (
+        <div className="min-h-screen bg-slate-50 px-4 py-24">
+            <div className="mx-auto max-w-2xl space-y-6">
+                <div>
+                    <h1 className="text-3xl font-light text-slate-900">Choose a domain</h1>
+                    <p className="mt-2 text-sm text-slate-600">
+                        This VPS has multiple Agents Server domains configured. Open the domain you want to use.
+                    </p>
+                </div>
+                <div className="grid gap-3">
+                    {props.servers.map((server) => {
+                        const url = createServerPublicUrl(server.domain).href;
+                        return (
+                            <Link
+                                key={server.id}
+                                href={url}
+                                className="rounded-xl border border-slate-200 bg-white px-4 py-3 text-sm font-semibold text-slate-800 shadow-sm transition hover:border-blue-300 hover:text-blue-700"
+                            >
+                                {server.domain}
+                            </Link>
+                        );
+                    })}
+                </div>
+            </div>
+        </div>
+    );
+}