@promptbook/cli 0.113.0-9 → 0.114.0-1

package/apps/agents-server/src/app/api/admin/{code-runners → harness-auth}/authentication/route.ts

@@ -1,34 +1,34 @@
 import {
-    getCodeRunnerAuthenticationSession,
-    getLatestCodeRunnerAuthenticationSession,
-    startCodeRunnerAuthenticationSession,
-    stopCodeRunnerAuthenticationSession,
-    subscribeToCodeRunnerAuthenticationSession,
-    writeCodeRunnerAuthenticationSessionInput,
-} from '@/src/utils/codeRunnerAuthentication';
+    getHarnessAuthenticationSession,
+    getLatestHarnessAuthenticationSession,
+    startHarnessAuthenticationSession,
+    stopHarnessAuthenticationSession,
+    subscribeToHarnessAuthenticationSession,
+    writeHarnessAuthenticationSessionInput,
+} from '@/src/utils/harnessAuthentication';
 import { createAdminTerminalRouteHandlers } from '@/src/utils/createAdminTerminalRouteHandlers';
-import { readConfiguredCodeRunner } from '@/src/utils/codeRunnerConfiguration';
+import { readConfiguredHarness } from '@/src/utils/harnessConfiguration';
 
 export const runtime = 'nodejs';
 export const dynamic = 'force-dynamic';
 
 /**
- * Shared route handlers for the code-runner authentication terminal.
+ * Shared route handlers for the harness authentication terminal.
  */
 const authenticationTerminalRouteHandlers = createAdminTerminalRouteHandlers(
     {
         async getLatestSession() {
-            const { agent } = await readConfiguredCodeRunner();
-            return getLatestCodeRunnerAuthenticationSession(agent);
+            const { harness } = await readConfiguredHarness();
+            return getLatestHarnessAuthenticationSession(harness);
         },
-        getSession: getCodeRunnerAuthenticationSession,
+        getSession: getHarnessAuthenticationSession,
         async startSession() {
-            const { agent } = await readConfiguredCodeRunner();
-            return startCodeRunnerAuthenticationSession(agent);
+            const { harness } = await readConfiguredHarness();
+            return startHarnessAuthenticationSession(harness);
         },
-        writeSessionInput: writeCodeRunnerAuthenticationSessionInput,
-        stopSession: stopCodeRunnerAuthenticationSession,
-        subscribeToSession: subscribeToCodeRunnerAuthenticationSession,
+        writeSessionInput: writeHarnessAuthenticationSessionInput,
+        stopSession: stopHarnessAuthenticationSession,
+        subscribeToSession: subscribeToHarnessAuthenticationSession,
     },
     {
         loadErrorMessage: 'Failed to load the authentication session.',

package/apps/agents-server/src/app/api/admin/{code-runners → harness-auth}/route.ts

@@ -1,13 +1,13 @@
 import { NextResponse } from 'next/server';
 import { isUserGlobalAdmin } from '@/src/utils/isUserGlobalAdmin';
-import { readConfiguredCodeRunner, resolveCodeRunnerStatus } from '@/src/utils/codeRunnerConfiguration';
+import { readConfiguredHarness, resolveHarnessAuthenticationStatus } from '@/src/utils/harnessConfiguration';
 import {
-    applyVpsCodeRunnerConfiguration,
+    applyVpsHarnessConfiguration,
     updateVpsEnvironmentVariables,
 } from '@/src/utils/vpsConfiguration';
 
 /**
- * Loads configured code-runner settings from the editable VPS environment.
+ * Loads configured harness settings from the editable VPS environment.
  */
 export async function GET() {
     if (!(await isUserGlobalAdmin())) {
@@ -15,22 +15,24 @@ export async function GET() {
     }
 
     try {
-        const configuredCodeRunner = await readConfiguredCodeRunner();
+        const configuredHarness = await readConfiguredHarness();
+        const authenticationStatus = await resolveHarnessAuthenticationStatus(configuredHarness.harness);
 
         return NextResponse.json({
-            ...configuredCodeRunner,
-            status: await resolveCodeRunnerStatus(configuredCodeRunner.agent),
+            ...configuredHarness,
+            status: authenticationStatus.status,
+            codexLoginMethod: authenticationStatus.codexLoginMethod,
         });
     } catch (error) {
         return NextResponse.json(
-            { error: error instanceof Error ? error.message : 'Failed to load code-runner configuration.' },
+            { error: error instanceof Error ? error.message : 'Failed to load harness configuration.' },
             { status: 500 },
         );
     }
 }
 
 /**
- * Updates code-runner environment variables.
+ * Updates harness environment variables.
  */
 export async function PATCH(request: Request) {
     if (!(await isUserGlobalAdmin())) {
@@ -40,7 +42,7 @@ export async function PATCH(request: Request) {
     try {
         const body = (await request.json().catch(() => null)) as
             | {
-                  readonly agent?: string;
+                  readonly harness?: string;
                   readonly model?: string;
                   readonly thinkingLevel?: string;
                   readonly applyRuntimeConfiguration?: boolean;
@@ -48,11 +50,11 @@ export async function PATCH(request: Request) {
             | null;
 
         if (!body) {
-            return NextResponse.json({ error: 'Code-runner payload is required.' }, { status: 400 });
+            return NextResponse.json({ error: 'Harness payload is required.' }, { status: 400 });
         }
 
         await updateVpsEnvironmentVariables({
-            PTBK_HARNESS: body.agent || '',
+            PTBK_HARNESS: body.harness || '',
             PTBK_MODEL: body.model || '',
             PTBK_THINKING_LEVEL: body.thinkingLevel || '',
         });
@@ -62,11 +64,11 @@ export async function PATCH(request: Request) {
 
         return NextResponse.json({
             ...payload,
-            applyResult: body.applyRuntimeConfiguration ? await applyVpsCodeRunnerConfiguration() : null,
+            applyResult: body.applyRuntimeConfiguration ? await applyVpsHarnessConfiguration() : null,
         });
     } catch (error) {
         return NextResponse.json(
-            { error: error instanceof Error ? error.message : 'Failed to update code-runner configuration.' },
+            { error: error instanceof Error ? error.message : 'Failed to update harness configuration.' },
             { status: 500 },
         );
     }

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

@@ -1,12 +1,9 @@
 import { NextResponse } from 'next/server';
 import { isAgentsServerSqliteMode } from '../../../../../database/agentsServerDatabaseMode';
+import type { ServerRecord } from '../../../../../utils/serverRegistry';
 import { resolveCurrentServerRegistryContext } from '../../../../../utils/currentServerRegistryContext';
 import { isUserGlobalAdmin } from '../../../../../utils/isUserGlobalAdmin';
-import {
-    createServerPublicUrl,
-    listEnvironmentRegisteredServers,
-    normalizeServerDomain,
-} from '../../../../../utils/serverRegistry';
+import { createServerPublicUrl, normalizeServerDomain } from '../../../../../utils/serverRegistry';
 import {
     assertGlobalAdminAccess,
     deleteManagedServer,
@@ -15,7 +12,7 @@ import {
     updateManagedServer,
     type UpdateServerInput,
 } from '../../../../../utils/serverManagement';
-import { applyStandaloneVpsServerMetadata } from '../../../../../utils/serverManagement/standaloneVpsServerMetadata';
+import { applyServerMetadata } from '../../../../../utils/serverManagement/standaloneVpsServerMetadata';
 import {
     applyVpsRuntimeConfiguration,
     listConfiguredVpsDomains,
@@ -37,18 +34,15 @@ export async function PATCH(request: Request, context: { params: Promise<{ serve
         const body = (await request.json()) as Omit<UpdateServerInput, 'id'>;
         const parsedServerId = parseManagedServerId(serverId);
 
-        if (isAgentsServerSqliteMode()) {
-            const updatedServer = await updateStandaloneVpsServerDomain(parsedServerId, body.domain);
-            await applyStandaloneVpsServerMetadata({
-                tablePrefix: updatedServer.tablePrefix,
-                name: body.name,
-            });
-            return NextResponse.json({ server: updatedServer });
-        }
-
-        const updatedServer = await updateManagedServer({
-            id: parsedServerId,
-            ...body,
+        const updatedServer = isAgentsServerSqliteMode()
+            ? await updateStandaloneVpsServer(parsedServerId, body)
+            : await updateManagedServer({
+                  id: parsedServerId,
+                  ...body,
+              });
+        await applyServerMetadata({
+            server: updatedServer,
+            name: updatedServer.name,
         });
 
         return NextResponse.json({ server: updatedServer });
@@ -93,7 +87,7 @@ export async function DELETE(_request: Request, context: { params: Promise<{ ser
             nextServerId === null
                 ? null
                 : currentContext.registeredServers.find((server) => server.id === nextServerId) ?? null;
-        const redirectUrl = nextServer ? new URL('/admin/servers', createServerPublicUrl(nextServer.domain)).href : null;
+        const redirectUrl = nextServer ? new URL('/superadmin/servers', createServerPublicUrl(nextServer.domain)).href : null;
 
         return NextResponse.json({
             success: true,
@@ -110,50 +104,62 @@ export async function DELETE(_request: Request, context: { params: Promise<{ ser
 }
 
 /**
- * Updates a virtual standalone VPS server by replacing its domain in `SERVERS`.
+ * Updates one registered standalone VPS server in the VPS registry database.
+ *
+ * The server keeps its id and its isolated per-server SQLite database; only the
+ * domain (and name) change, so no server data is lost or leaked by renames.
  *
- * @param serverId - Virtual server id.
- * @param rawDomain - Replacement domain.
- * @returns Updated virtual server row.
+ * @param serverId - Registry server id.
+ * @param input - Replacement domain and optional name.
+ * @returns Updated registry row.
  */
-async function updateStandaloneVpsServerDomain(serverId: number, rawDomain: string) {
-    const normalizedDomain = normalizeServerDomain(rawDomain);
-    if (!normalizedDomain) {
+async function updateStandaloneVpsServer(
+    serverId: number,
+    input: { readonly domain?: string; readonly name?: string },
+): Promise<ServerRecord> {
+    const normalizedDomain = input.domain === undefined ? undefined : normalizeServerDomain(input.domain) ?? undefined;
+    if (input.domain !== undefined && !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({ isProcessRestartEnabled: false });
-
-    const updatedServer = listEnvironmentRegisteredServers().find((server) => server.domain === normalizedDomain);
-    if (!updatedServer) {
-        throw new Error(`Standalone VPS server ${normalizedDomain} was not persisted.`);
+    const { getStandaloneServerById, updateStandaloneServer } = await import(
+        '../../../../../database/sqlite/standaloneServerRegistryStore'
+    );
+    const previousServer = getStandaloneServerById(serverId);
+    const updatedServer = updateStandaloneServer(serverId, {
+        domain: normalizedDomain,
+        name: input.name,
+    });
+
+    if (previousServer && previousServer.domain !== updatedServer.domain) {
+        const domains = await listConfiguredVpsDomains();
+        const replacedDomains = domains.map((domain) =>
+            domain === previousServer.domain ? updatedServer.domain : domain,
+        );
+        await updateConfiguredVpsDomains(
+            replacedDomains.includes(updatedServer.domain)
+                ? replacedDomains
+                : [...replacedDomains, updatedServer.domain],
+        );
+        await applyVpsRuntimeConfiguration({ isProcessRestartEnabled: false });
     }
 
     return updatedServer;
 }
 
 /**
- * Deletes a virtual standalone VPS server by removing its domain from `SERVERS`.
+ * Deletes one registered standalone VPS server.
+ *
+ * The registration row and its domain are removed, while the isolated
+ * per-server SQLite database file stays on disk so no data is destroyed silently.
  *
- * @param serverId - Virtual server id.
+ * @param serverId - Registry 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 { deleteStandaloneServer } = await import('../../../../../database/sqlite/standaloneServerRegistryStore');
+    const deletedServer = deleteStandaloneServer(serverId);
 
     const domains = await listConfiguredVpsDomains();
-    await updateConfiguredVpsDomains(domains.filter((_domain, index) => index !== serverIndex));
+    await updateConfiguredVpsDomains(domains.filter((domain) => domain !== deletedServer.domain));
     await applyVpsRuntimeConfiguration({ isProcessRestartEnabled: false });
 }

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

@@ -3,14 +3,27 @@ import { spaceTrim } from 'spacetrim';
 import { DatabaseError } from '../../../../../../../src/errors/DatabaseError';
 import { isAgentsServerSqliteMode } from '../../../../database/agentsServerDatabaseMode';
 import { seedDefaultAgents } from '../../../../database/seedDefaultAgents';
+import {
+    buildAgentProjectProfileHrefForServer,
+    buildAgentProjectsDashboardHrefForServer,
+} from '../../../../utils/agentProjects/agentProjectHrefs';
+import { listAgentProjectDomainRecords } from '../../../../utils/agentProjects/agentProjectRuntimeDomains';
+import {
+    createAgentProjectDnsDiagnosticLookup,
+    createAgentProjectDnsDiagnosticLookupKey,
+    listAgentProjectDnsDiagnostics,
+} from '../../../../utils/agentProjects/listAgentProjectDnsDiagnostics';
 import { resolveCurrentServerRegistryContext } from '../../../../utils/currentServerRegistryContext';
 import { isUserAdmin } from '../../../../utils/isUserAdmin';
 import { isUserGlobalAdmin } from '../../../../utils/isUserGlobalAdmin';
+import { loadLocalAgentSourceSnapshot } from '../../../../utils/localChatRunner/ensureLocalAgentFolder';
 import { buildServerTablePrefix } from '../../../../utils/buildServerTablePrefix';
 import {
     createServerPublicUrl,
-    listEnvironmentRegisteredServers,
+    isServerEnvironment,
     normalizeServerDomain,
+    SERVER_ENVIRONMENT,
+    type ServerRecord,
 } from '../../../../utils/serverRegistry';
 import {
     assertGlobalAdminAccess,
@@ -20,16 +33,23 @@ import {
 } from '../../../../utils/serverManagement';
 import { ManagedServerInputNormalizer } from '../../../../utils/serverManagement/ManagedServerInputNormalizer';
 import {
-    applyStandaloneVpsServerMetadata,
+    applyServerMetadata,
     resolveStandaloneVpsServerDisplayName,
 } from '../../../../utils/serverManagement/standaloneVpsServerMetadata';
 import { createStandaloneVpsDomainDnsDiagnostic } from '../../../../utils/standaloneVpsDnsDiagnostics';
+import { runWithVpsServerSetupTask } from '../../../../utils/vpsTask/runWithVpsServerSetupTask';
+import { runWithServerContextOverride } from '../../../../tools/serverContextOverride';
 import {
     applyVpsRuntimeConfiguration,
     listConfiguredVpsDomains,
     updateConfiguredVpsDomains,
 } from '../../../../utils/vpsConfiguration';
 
+/**
+ * Separator used in agent-owner lookup keys.
+ */
+const AGENT_PROJECT_OWNER_LOOKUP_KEY_SEPARATOR = '::';
+
 /**
  * Lists all registered servers together with the server resolved from the current domain.
  *
@@ -42,15 +62,67 @@ export async function GET() {
         }
 
         const context = await resolveCurrentServerRegistryContext();
-        const servers = isAgentsServerSqliteMode()
+        const isStandaloneVps = isAgentsServerSqliteMode();
+        const serversWithoutProjectDomains = isStandaloneVps
             ? await createStandaloneVpsServersResponse(context.registeredServers)
             : context.registeredServers;
+        const projectDomainRecords = await listAgentProjectDomainRecords();
+        const agentNameByProjectOwner = await createAgentNameLookup(projectDomainRecords, context.registeredServers);
+        const currentServerDomain = context.currentServer?.domain || context.hostServer?.domain || null;
+        const servers = await Promise.all(
+            serversWithoutProjectDomains.map(async (server) => {
+                const serverProjectDomainRecords = projectDomainRecords.filter(
+                    (record) => normalizeServerDomain(record.serverDomain) === normalizeServerDomain(server.domain),
+                );
+                const projectDnsDiagnosticByProject = createAgentProjectDnsDiagnosticLookup(
+                    isStandaloneVps
+                        ? await listAgentProjectDnsDiagnostics({
+                              projectDomainRecords: serverProjectDomainRecords,
+                              publicIpAddress: process.env.PTBK_PUBLIC_IP_ADDRESS,
+                              serverDomain: server.domain,
+                          })
+                        : [],
+                );
+
+                return {
+                    ...server,
+                    projectDomains: serverProjectDomainRecords.map((record) => ({
+                        agentPermanentId: record.agentPermanentId,
+                        agentName:
+                            agentNameByProjectOwner.get(
+                                createAgentProjectOwnerLookupKey(record.serverDomain, record.agentPermanentId),
+                            ) ?? null,
+                        agentProjectsHref: buildAgentProjectsDashboardHrefForServer({
+                            agentPermanentId: record.agentPermanentId,
+                            serverDomain: server.domain,
+                            currentServerDomain,
+                        }),
+                        projectName: record.projectName,
+                        customDomain: record.customDomain,
+                        domain: record.domain,
+                        publicUrl: record.publicUrl,
+                        projectHref: buildAgentProjectProfileHrefForServer({
+                            agentPermanentId: record.agentPermanentId,
+                            projectName: record.projectName,
+                            serverDomain: server.domain,
+                            currentServerDomain,
+                        }),
+                        dnsDiagnostic:
+                            projectDnsDiagnosticByProject.get(
+                                createAgentProjectDnsDiagnosticLookupKey(record.agentPermanentId, record.projectName),
+                            )?.dnsDiagnostic ?? null,
+                        assignedAt: record.assignedAt,
+                        updatedAt: record.updatedAt,
+                    })),
+                };
+            }),
+        );
 
         return NextResponse.json({
             servers,
             currentServerId: context.currentServer?.id ?? null,
             canEdit: await isUserGlobalAdmin(),
-            isStandaloneVps: isAgentsServerSqliteMode(),
+            isStandaloneVps,
         });
     } catch (error) {
         return NextResponse.json(
@@ -62,6 +134,72 @@ export async function GET() {
     }
 }
 
+/**
+ * Loads readable agent names for project-domain rows without making a stale domain record fail the server registry.
+ *
+ * @param projectDomainRecords - Project domains whose owners need labels.
+ * @param registeredServers - Servers that own the project-domain records.
+ * @returns Project-owner names keyed by owning server and permanent agent id.
+ */
+async function createAgentNameLookup(
+    projectDomainRecords: Awaited<ReturnType<typeof listAgentProjectDomainRecords>>,
+    registeredServers: ReadonlyArray<ServerRecord>,
+): Promise<ReadonlyMap<string, string | null>> {
+    const serverByDomain = new Map<string, ServerRecord>();
+
+    for (const server of registeredServers) {
+        const serverDomain = normalizeServerDomain(server.domain);
+
+        if (serverDomain) {
+            serverByDomain.set(serverDomain, server);
+        }
+    }
+    const projectDomainRecordByOwner = new Map<string, (typeof projectDomainRecords)[number]>();
+
+    for (const projectDomainRecord of projectDomainRecords) {
+        projectDomainRecordByOwner.set(
+            createAgentProjectOwnerLookupKey(projectDomainRecord.serverDomain, projectDomainRecord.agentPermanentId),
+            projectDomainRecord,
+        );
+    }
+
+    const agentNames = await Promise.all(
+        [...projectDomainRecordByOwner.entries()].map(async ([projectOwnerLookupKey, projectDomainRecord]) => {
+            const server = serverByDomain.get(normalizeServerDomain(projectDomainRecord.serverDomain) || '');
+
+            if (!server) {
+                return [projectOwnerLookupKey, null] as const;
+            }
+
+            const agentSnapshot = await runWithServerContextOverride(
+                {
+                    id: server.id,
+                    publicUrl: createServerPublicUrl(server.domain),
+                    tablePrefix: server.tablePrefix,
+                },
+                () => loadLocalAgentSourceSnapshot(projectDomainRecord.agentPermanentId),
+            ).catch(() => null);
+
+            return [projectOwnerLookupKey, agentSnapshot?.agentName || null] as const;
+        }),
+    );
+
+    return new Map(agentNames);
+}
+
+/**
+ * Creates a stable lookup key for one server-scoped project owner.
+ *
+ * @param serverDomain - Domain of the server that owns the agent.
+ * @param agentPermanentId - Permanent id of the agent.
+ * @returns Case-insensitive project-owner lookup key.
+ */
+function createAgentProjectOwnerLookupKey(serverDomain: string, agentPermanentId: string): string {
+    return [normalizeServerDomain(serverDomain) || '', agentPermanentId.toLowerCase()].join(
+        AGENT_PROJECT_OWNER_LOOKUP_KEY_SEPARATOR,
+    );
+}
+
 /**
  * Enriches standalone VPS server rows with display metadata and DNS diagnostics.
  *
@@ -98,34 +236,21 @@ export async function POST(request: Request) {
 
         const body = withEnvironmentAdminUser((await request.json()) as CreateServerInput);
         if (isAgentsServerSqliteMode()) {
-            const isDefaultAgentsInstalled = body.isDefaultAgentsInstalled !== false;
             const normalizedDomain = normalizeServerDomain(body.domain);
             if (!normalizedDomain) {
                 return NextResponse.json({ error: 'A valid domain is required.' }, { status: 400 });
             }
-            const tablePrefix = normalizeStandaloneVpsCreateServerTablePrefix(body);
-
-            const existingDomains = await listConfiguredVpsDomains();
-            await updateConfiguredVpsDomains([...existingDomains, normalizedDomain], { tablePrefix });
-            await applyVpsRuntimeConfiguration({ isProcessRestartEnabled: false });
-            const createdServer = listEnvironmentRegisteredServers().find((server) => server.domain === normalizedDomain);
-            if (createdServer) {
-                await applyStandaloneVpsServerMetadata({
-                    tablePrefix: createdServer.tablePrefix,
-                    name: body.name,
-                    iconUrl: body.iconUrl,
-                });
-            }
-            if (isDefaultAgentsInstalled) {
-                await seedDefaultAgents({ tablePrefix });
-            }
+            const serverName = body.name?.trim() || normalizedDomain;
 
-            return NextResponse.json(
+            return runWithVpsServerSetupTask(
                 {
-                    server: createdServer ?? null,
-                    publicUrl: createServerPublicUrl(normalizedDomain).href,
+                    taskName: `Server setup: ${serverName}`,
+                    chatId: normalizedDomain,
+                    serverName,
+                    serverDomain: normalizedDomain,
                 },
-                { status: 201 },
+                () => createStandaloneVpsServer(body, normalizedDomain),
+                (response) => response.status < 400,
             );
         }
 
@@ -159,6 +284,53 @@ export async function POST(request: Request) {
     }
 }
 
+/**
+ * Creates and provisions one standalone VPS server.
+ *
+ * @param body - Create-server request payload.
+ * @param normalizedDomain - Validated server domain.
+ * @returns Create response.
+ *
+ * @private function of `POST`
+ */
+async function createStandaloneVpsServer(body: CreateServerInput, normalizedDomain: string): Promise<NextResponse> {
+    const isDefaultAgentsInstalled = body.isDefaultAgentsInstalled !== false;
+    const tablePrefix = normalizeStandaloneVpsCreateServerTablePrefix(body);
+
+    // Note: The VPS registry database is the source of truth for the server list.
+    //       Its unique table prefix selects the new server's own isolated SQLite database.
+    const { createStandaloneServer } = await import('../../../../database/sqlite/standaloneServerRegistryStore');
+    const createdServer = createStandaloneServer({
+        name: body.name?.trim() || normalizedDomain,
+        environment: isServerEnvironment(body.environment) ? body.environment : SERVER_ENVIRONMENT.PRODUCTION,
+        domain: normalizedDomain,
+        tablePrefix,
+    });
+
+    // Note: `SERVERS` stays a projection of the registry for nginx/certbot provisioning
+    //       and Edge middleware host matching; it no longer defines table prefixes.
+    const existingDomains = await listConfiguredVpsDomains();
+    await updateConfiguredVpsDomains([...existingDomains, normalizedDomain]);
+    await applyVpsRuntimeConfiguration({ isProcessRestartEnabled: false });
+
+    await applyServerMetadata({
+        server: createdServer,
+        name: body.name,
+        iconUrl: body.iconUrl,
+    });
+    if (isDefaultAgentsInstalled) {
+        await seedDefaultAgents({ tablePrefix });
+    }
+
+    return NextResponse.json(
+        {
+            server: createdServer,
+            publicUrl: createServerPublicUrl(normalizedDomain).href,
+        },
+        { status: 201 },
+    );
+}
+
 /**
  * Uses the installer-managed environment admin when the browser no longer collects admin credentials.
  *

package/apps/agents-server/src/app/api/admin/vps/chat-tasks/cancel-all/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from 'next/server';
+import { getCurrentUser } from '@/src/utils/getCurrentUser';
+import { isUserGlobalAdmin } from '@/src/utils/isUserGlobalAdmin';
+import { cancelAllActiveAdminChatTasks } from '@/src/utils/cancelAllActiveAdminChatTasks';
+import { readRequiredAdminReason } from '@/src/utils/readRequiredAdminReason';
+
+/**
+ * Requests cancellation for every active durable chat task across all servers on the VPS.
+ */
+export async function POST(request: Request) {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const reason = await readRequiredAdminReason(request);
+    if (!reason) {
+        return NextResponse.json({ error: 'A non-empty reason is required.' }, { status: 400 });
+    }
+
+    try {
+        const actor = (await getCurrentUser())?.username || 'admin';
+        const summary = await cancelAllActiveAdminChatTasks({
+            actor,
+            reason,
+            requestOrigin: new URL(request.url).origin,
+            isVpsWide: true,
+        });
+
+        return NextResponse.json({ ok: true, ...summary });
+    } catch (error) {
+        console.error('[admin-chat-task] VPS-wide cancel-all failed', error);
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to cancel all VPS-wide tasks.' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/admin/vps/chat-tasks/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getVpsAdminChatTasksResponse } from '@/src/utils/getVpsAdminChatTasksResponse';
+import { isUserGlobalAdmin } from '@/src/utils/isUserGlobalAdmin';
+
+/**
+ * Lists durable background chat tasks aggregated across every server on the VPS.
+ *
+ * Restricted to the environment-backed superadmin because it reads across all servers on the VPS.
+ */
+export async function GET(request: NextRequest) {
+    if (!(await isUserGlobalAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const result = await getVpsAdminChatTasksResponse(request.nextUrl.searchParams);
+        if (result.status !== 200) {
+            return NextResponse.json({ error: result.error }, { status: result.status });
+        }
+
+        return NextResponse.json(result.response);
+    } catch (error) {
+        console.error('[admin-chat-task] VPS-wide listing failed', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}