@promptbook/cli 0.114.0-2 → 0.114.0-21

package/apps/agents-server/src/app/agents/[agentName]/projectReferenceActions.ts

@@ -0,0 +1,61 @@
+'use server';
+
+import { resolveAgentProjectsAccess } from '@/src/utils/agentProjects/agentProjectAccess';
+import type { AgentProjectReferenceInfo } from '@/src/utils/agentProjects/AgentProjectReferenceInfo';
+import { listAgentProjectNames } from '@/src/utils/agentProjects/listAgentProjectNames';
+import { resolveAgentChatProjectReferences } from '@/src/utils/agentProjects/resolveAgentChatProjectReferences';
+
+/**
+ * Reloads the project references of one open chat when the agent's set of projects changed.
+ *
+ * A chat renders every mention of a project as a project chip built from these references, so a project
+ * created while the chat stays open must reach the browser without a page reload. Building the references
+ * walks every project folder, therefore the project names the chat already knows decide whether that work
+ * is done at all.
+ *
+ * @param agentPermanentId - Permanent id of the agent owning the projects.
+ * @param knownProjectNames - Project directory names the open chat already renders.
+ * @returns Fresh project references, or `null` when the agent owns exactly the known projects.
+ */
+export async function $refreshAgentProjectChatReferencesAction(
+    agentPermanentId: string,
+    knownProjectNames: ReadonlyArray<string>,
+): Promise<ReadonlyArray<AgentProjectReferenceInfo> | null> {
+    const projectsAccess = await resolveAgentProjectsAccess(agentPermanentId);
+
+    if (!projectsAccess.isProjectOverviewVisible) {
+        return [];
+    }
+
+    const projectNames = await listAgentProjectNames(agentPermanentId);
+
+    if (areAgentProjectNamesEqual(projectNames, knownProjectNames)) {
+        return null;
+    }
+
+    return await resolveAgentChatProjectReferences({ agentPermanentId, projectsAccess });
+}
+
+/**
+ * Compares two collections of project directory names ignoring their order and letter case.
+ *
+ * @param firstProjectNames - Project names listed on the server.
+ * @param secondProjectNames - Project names reported by the open chat.
+ * @returns Whether both collections describe the same projects.
+ */
+function areAgentProjectNamesEqual(
+    firstProjectNames: ReadonlyArray<string>,
+    secondProjectNames: ReadonlyArray<string>,
+): boolean {
+    if (firstProjectNames.length !== secondProjectNames.length) {
+        return false;
+    }
+
+    const normalizedSecondProjectNames = new Set(
+        secondProjectNames.map((secondProjectName) => secondProjectName.toLowerCase()),
+    );
+
+    return firstProjectNames.every((firstProjectName) =>
+        normalizedSecondProjectNames.has(firstProjectName.toLowerCase()),
+    );
+}

package/apps/agents-server/src/app/agents/[agentName]/projectRuntimeActions.ts

@@ -0,0 +1,97 @@
+'use server';
+
+import { revalidatePath } from 'next/cache';
+import { NotAllowed } from '../../../../../../src/errors/NotAllowed';
+import { spaceTrim } from '../../../../../../src/utils/organization/spaceTrim';
+import { resolveAgentProjectsAccess } from '@/src/utils/agentProjects/agentProjectAccess';
+import { buildAgentProjectProfileHref } from '@/src/utils/agentProjects/agentProjectHrefs';
+import type { AgentProjectRuntimeActionResult } from '@/src/utils/agentProjects/AgentProjectRuntimeActionResult';
+import {
+    startAgentProjectRuntime,
+    terminateAgentProjectRuntimeForProject,
+} from '@/src/utils/agentProjects/agentProjectRuntimeRegistry';
+import { resolveCurrentAgentProjectServerDomain } from '@/src/utils/agentProjects/resolveCurrentAgentProjectServerDomain';
+
+/**
+ * Starts one project after checking the current user's access.
+ *
+ * @param agentPermanentId - Permanent id of the agent owning the project.
+ * @param projectName - Project directory name.
+ * @returns Browser-safe state of the started runtime.
+ */
+export async function $startAgentProjectRuntimeAction(
+    agentPermanentId: string,
+    projectName: string,
+): Promise<AgentProjectRuntimeActionResult> {
+    await assertProjectRuntimeActionAccess(agentPermanentId, projectName, 'start');
+
+    const runtime = await startAgentProjectRuntime({
+        agentPermanentId,
+        projectName,
+        serverDomain: await resolveCurrentAgentProjectServerDomain(),
+    });
+    revalidateProjectRuntimePaths(agentPermanentId, projectName);
+
+    return {
+        isRunning: runtime.isRunning,
+        projectUrl: runtime.publicUrl || null,
+    };
+}
+
+/**
+ * Stops one project after checking the current user's access.
+ *
+ * @param agentPermanentId - Permanent id of the agent owning the project.
+ * @param projectName - Project directory name.
+ * @returns Browser-safe state of the stopped runtime.
+ */
+export async function $stopAgentProjectRuntimeAction(
+    agentPermanentId: string,
+    projectName: string,
+): Promise<AgentProjectRuntimeActionResult> {
+    await assertProjectRuntimeActionAccess(agentPermanentId, projectName, 'stop');
+
+    const runtime = await terminateAgentProjectRuntimeForProject({ agentPermanentId, projectName });
+    revalidateProjectRuntimePaths(agentPermanentId, projectName);
+
+    return {
+        isRunning: false,
+        projectUrl: runtime?.publicUrl || null,
+    };
+}
+
+/**
+ * Checks that the current user can perform a project runtime action.
+ *
+ * @param agentPermanentId - Permanent id of the agent owning the project.
+ * @param projectName - Project directory name.
+ * @param actionName - Human-readable action used in an access error.
+ */
+async function assertProjectRuntimeActionAccess(
+    agentPermanentId: string,
+    projectName: string,
+    actionName: 'start' | 'stop',
+): Promise<void> {
+    const access = await resolveAgentProjectsAccess(agentPermanentId);
+
+    if (!access.isProjectDetailsVisible) {
+        throw new NotAllowed(
+            spaceTrim(`
+                You are not allowed to ${actionName} project \`${projectName}\`.
+            `),
+        );
+    }
+}
+
+/**
+ * Revalidates pages which show project runtime state.
+ *
+ * @param agentPermanentId - Permanent id of the agent owning the project.
+ * @param projectName - Project directory name.
+ */
+function revalidateProjectRuntimePaths(agentPermanentId: string, projectName: string): void {
+    revalidatePath(buildAgentProjectProfileHref(agentPermanentId, projectName));
+    revalidatePath('/admin/projects');
+    revalidatePath('/superadmin/resource-monitor');
+    revalidatePath('/superadmin/servers');
+}

package/apps/agents-server/src/app/agents/[agentName]/projects/[projectName]/actions.ts

@@ -1,15 +1,9 @@
 'use server';
 
-import { revalidatePath } from 'next/cache';
-import { NotAllowed } from '../../../../../../../../src/errors/NotAllowed';
-import { spaceTrim } from '../../../../../../../../src/utils/organization/spaceTrim';
-import { resolveAgentProjectsAccess } from '@/src/utils/agentProjects/agentProjectAccess';
-import { buildAgentProjectProfileHref } from '@/src/utils/agentProjects/agentProjectHrefs';
 import {
-    startAgentProjectRuntime,
-    terminateAgentProjectRuntimeForProject,
-} from '@/src/utils/agentProjects/agentProjectRuntimeRegistry';
-import { resolveCurrentAgentProjectServerDomain } from '@/src/utils/agentProjects/resolveCurrentAgentProjectServerDomain';
+    $startAgentProjectRuntimeAction,
+    $stopAgentProjectRuntimeAction,
+} from '../../projectRuntimeActions';
 
 /**
  * Starts one project from its project page.
@@ -21,14 +15,7 @@ export async function $startAgentProjectRuntimeFromProjectPageAction(
     agentPermanentId: string,
     projectName: string,
 ): Promise<void> {
-    await assertProjectRuntimeActionAccess(agentPermanentId, projectName, 'start');
-
-    await startAgentProjectRuntime({
-        agentPermanentId,
-        projectName,
-        serverDomain: await resolveCurrentAgentProjectServerDomain(),
-    });
-    revalidateProjectRuntimePaths(agentPermanentId, projectName);
+    await $startAgentProjectRuntimeAction(agentPermanentId, projectName);
 }
 
 /**
@@ -41,37 +28,5 @@ export async function $terminateAgentProjectRuntimeFromProjectPageAction(
     agentPermanentId: string,
     projectName: string,
 ): Promise<void> {
-    await assertProjectRuntimeActionAccess(agentPermanentId, projectName, 'terminate');
-
-    await terminateAgentProjectRuntimeForProject({ agentPermanentId, projectName });
-    revalidateProjectRuntimePaths(agentPermanentId, projectName);
-}
-
-/**
- * Checks that the current user can perform a project runtime action.
- */
-async function assertProjectRuntimeActionAccess(
-    agentPermanentId: string,
-    projectName: string,
-    actionName: 'start' | 'terminate',
-): Promise<void> {
-    const access = await resolveAgentProjectsAccess(agentPermanentId);
-
-    if (!access.isProjectDetailsVisible) {
-        throw new NotAllowed(
-            spaceTrim(`
-                You are not allowed to ${actionName} project \`${projectName}\`.
-            `),
-        );
-    }
-}
-
-/**
- * Revalidates pages that show project runtime state.
- */
-function revalidateProjectRuntimePaths(agentPermanentId: string, projectName: string): void {
-    revalidatePath(buildAgentProjectProfileHref(agentPermanentId, projectName));
-    revalidatePath('/admin/projects');
-    revalidatePath('/superadmin/resource-monitor');
-    revalidatePath('/superadmin/servers');
+    await $stopAgentProjectRuntimeAction(agentPermanentId, projectName);
 }

package/apps/agents-server/src/app/agents/[agentName]/projects/[projectName]/page.tsx

@@ -9,7 +9,6 @@ import {
     ExternalLinkIcon,
     FileIcon,
     FolderIcon,
-    FolderKanbanIcon,
     GitBranchIcon,
     PlayIcon,
     PlugZapIcon,
@@ -19,6 +18,7 @@ import {
 import Link from 'next/link';
 import { notFound } from 'next/navigation';
 import { AgentProjectDnsWarning } from '@/src/components/AgentProjects/AgentProjectDnsWarning';
+import { AgentProjectIcon } from '@/src/components/AgentProjects/AgentProjectIcon';
 import { AgentProjectRuntimeStatusBadge } from '@/src/components/AgentProjects/AgentProjectRuntimeStatusBadge';
 import { ForbiddenPage } from '@/src/components/ForbiddenPage/ForbiddenPage';
 import { isAgentsServerSqliteMode } from '@/src/database/agentsServerDatabaseMode';
@@ -467,7 +467,7 @@ function ProjectProfileHeader({
                 <div className="min-w-0">
                     <p className="text-xs font-semibold uppercase tracking-[0.22em] text-gray-400">Project</p>
                     <h1 className="mt-1 flex min-w-0 items-center gap-2 text-3xl font-light text-gray-900">
-                        <FolderKanbanIcon className="h-7 w-7 shrink-0 text-gray-400" aria-hidden />
+                        <AgentProjectIcon agentPermanentId={agentPermanentId} project={project} size="header" />
                         <span className="truncate">{project.displayName}</span>
                     </h1>
                     {project.displayName !== project.projectName && (

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

@@ -2,7 +2,9 @@ import { NextResponse } from 'next/server';
 import { seedCoreAgents } from '../../../../../database/seedCoreAgents';
 import { reinstateDefaultAgents } from '../../../../../database/reinstateDefaultAgents';
 import { $provideServer } from '../../../../../tools/$provideServer';
+import { $invalidateProvidedAgentReferenceResolverCache } from '../../../../../utils/agentReferenceResolver/$provideAgentReferenceResolver';
 import { invalidateCachedActiveOrganizationSnapshots } from '../../../../../utils/agentOrganization/loadAgentOrganizationState';
+import { invalidateCachedServerAgentRuntime } from '../../../../../utils/cachedServerAgentRuntime';
 import { isUserAdmin } from '../../../../../utils/isUserAdmin';
 
 /**
@@ -47,7 +49,9 @@ export async function POST(request: Request) {
                 ? (await seedCoreAgents({ tablePrefix })).createdAgentNames
                 : (await reinstateDefaultAgents({ tablePrefix })).createdAgentNames;
 
-        // Note: Drop the short-lived organization snapshot cache so the newly created agents appear immediately.
+        // Note: These direct collection writes bypass the normal collection decoration that invalidates these caches.
+        $invalidateProvidedAgentReferenceResolverCache();
+        invalidateCachedServerAgentRuntime();
         invalidateCachedActiveOrganizationSnapshots();
 
         return NextResponse.json({ scope, createdAgentNames });

package/apps/agents-server/src/app/api/admin/dns-records/cloudflare/route.ts

@@ -2,8 +2,9 @@ import { NextResponse } from 'next/server';
 import { spaceTrim } from 'spacetrim';
 import { NotFoundError } from '../../../../../../../../src/errors/NotFoundError';
 import { applyCloudflareDnsRecordInstructions } from '../../../../../utils/cloudflare/applyCloudflareDnsRecordInstructions';
-import type { DnsRecordInstruction, DnsRecordSelection } from '../../../../../utils/dnsRecords/DnsRecordInstruction';
-import { resolveDnsRecordBatchPlan } from '../../../../../utils/dnsRecords/resolveDnsRecordBatchPlan';
+import type { DnsRecordGroup } from '../../../../../utils/dnsRecords/DnsRecordInstruction';
+import { countDnsRecordGroupRecords } from '../../../../../utils/dnsRecords/dnsRecordGroups';
+import { resolveDnsRecordBatchPlanForGroups } from '../../../../../utils/dnsRecords/resolveDnsRecordBatchPlan';
 import { isUserAdmin } from '../../../../../utils/isUserAdmin';
 import { isUserGlobalAdmin } from '../../../../../utils/isUserGlobalAdmin';
 
@@ -22,14 +23,9 @@ type CloudflareDnsWizardRequestBody = {
     readonly domain?: string;
 
     /**
-     * Whether all shown records or one shown alternative has to be configured.
+     * Record groups shown in the DNS manual, each one with its own all-or-one rule.
      */
-    readonly recordSelection?: DnsRecordSelection;
-
-    /**
-     * DNS records shown in the DNS manual.
-     */
-    readonly records?: ReadonlyArray<DnsRecordInstruction>;
+    readonly recordGroups?: ReadonlyArray<DnsRecordGroup>;
 };
 
 /**
@@ -45,13 +41,13 @@ export async function POST(request: Request) {
 
     const body = ((await request.json().catch(() => null)) || {}) as CloudflareDnsWizardRequestBody;
     const domain = (body.domain || '').trim();
-    const records = body.records || [];
+    const recordGroups = normalizeCloudflareDnsWizardRecordGroups(body.recordGroups);
 
-    if (!domain || records.length === 0) {
+    if (!domain || countDnsRecordGroupRecords(recordGroups) === 0) {
         return NextResponse.json(
             {
                 error: spaceTrim(`
-                    Both \`domain\` and \`records\` are required to import DNS records into Cloudflare.
+                    Both \`domain\` and \`recordGroups\` are required to import DNS records into Cloudflare.
                 `),
             },
             { status: 400 },
@@ -79,10 +75,7 @@ export async function POST(request: Request) {
 
     // Note: The batch plan is resolved again on the server, so that placeholder values and record alternatives can
     //       never be written into Cloudflare even when the browser sends them.
-    const { applicableRecords } = resolveDnsRecordBatchPlan({
-        records,
-        recordSelection: body.recordSelection === 'one' ? 'one' : 'all',
-    });
+    const { applicableRecords } = resolveDnsRecordBatchPlanForGroups(recordGroups);
 
     if (applicableRecords.length === 0) {
         return NextResponse.json(
@@ -114,3 +107,20 @@ export async function POST(request: Request) {
         );
     }
 }
+
+/**
+ * Normalizes the record groups sent by the browser into trustworthy server-side groups.
+ *
+ * @param recordGroups - Record groups of the request body.
+ * @returns Record groups whose all-or-one rule is always one of the supported values.
+ *
+ * @private function of `POST`
+ */
+function normalizeCloudflareDnsWizardRecordGroups(
+    recordGroups: ReadonlyArray<DnsRecordGroup> | undefined,
+): ReadonlyArray<DnsRecordGroup> {
+    return (recordGroups || []).map((recordGroup) => ({
+        recordSelection: recordGroup.recordSelection === 'one' ? 'one' : 'all',
+        records: recordGroup.records || [],
+    }));
+}

package/apps/agents-server/src/app/api/admin/planned-messages/[timeoutId]/route.ts

@@ -0,0 +1,80 @@
+import { NextResponse } from 'next/server';
+import { ParseError } from '../../../../../../../../src/errors/ParseError';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
+import { cancelManagedPlannedMessage } from '@/src/utils/plannedMessageManager/cancelManagedPlannedMessage';
+import { parsePlannedMessageManagerUpdateRequest } from '@/src/utils/plannedMessageManager/parsePlannedMessageManagerUpdateRequest';
+import { updateManagedPlannedMessage } from '@/src/utils/plannedMessageManager/updateManagedPlannedMessage';
+
+/**
+ * Keeps planned-message persistence on the Node.js runtime.
+ */
+export const runtime = 'nodejs';
+
+/**
+ * Changes the schedule, the text, or the paused state of one planned message of any agent.
+ */
+export async function PATCH(request: Request, { params }: { params: Promise<{ timeoutId: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const timeoutId = decodeURIComponent((await params).timeoutId);
+
+    try {
+        const updateRequest = parsePlannedMessageManagerUpdateRequest(await request.json().catch(() => null));
+        const updateResult = await updateManagedPlannedMessage(timeoutId, updateRequest);
+
+        if (updateResult.status === 'not_found') {
+            return NextResponse.json({ error: 'Planned message not found.' }, { status: 404 });
+        }
+
+        if (updateResult.status === 'busy') {
+            return NextResponse.json(
+                { error: 'This planned message is waking its agent right now, so its plan cannot be changed.' },
+                { status: 409 },
+            );
+        }
+
+        return NextResponse.json({ plannedMessage: updateResult.plannedMessage });
+    } catch (error) {
+        if (error instanceof ParseError) {
+            return NextResponse.json({ error: error.message }, { status: 400 });
+        }
+
+        console.error('[admin-planned-message] update failed', { timeoutId, error });
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to update the planned message.' },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * Cancels one planned message of any agent, so it never wakes that agent again.
+ */
+export async function DELETE(request: Request, { params }: { params: Promise<{ timeoutId: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const timeoutId = decodeURIComponent((await params).timeoutId);
+
+    try {
+        const cancelResult = await cancelManagedPlannedMessage(timeoutId);
+
+        if (cancelResult === 'not_found') {
+            return NextResponse.json(
+                { error: 'There is no planned message to cancel under this id.' },
+                { status: 404 },
+            );
+        }
+
+        return NextResponse.json({ ok: true });
+    } catch (error) {
+        console.error('[admin-planned-message] cancel failed', { timeoutId, error });
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Failed to cancel the planned message.' },
+            { status: 500 },
+        );
+    }
+}

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

@@ -0,0 +1,19 @@
+import { NextResponse } from 'next/server';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
+import { getPlannedMessageManagerResponse } from '@/src/utils/plannedMessageManager/getPlannedMessageManagerResponse';
+
+/**
+ * Lists every planned message of every agent for the admin planned-message manager.
+ */
+export async function GET() {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        return NextResponse.json(await getPlannedMessageManagerResponse());
+    } catch (error) {
+        console.error('[admin-planned-message] listing failed', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/emails/incoming/stalwart/route.ts

@@ -5,6 +5,7 @@ import { ParseError } from '../../../../../../../../src/errors/ParseError';
 import { spaceTrim } from '../../../../../../../../src/utils/organization/spaceTrim';
 import type { StalwartMtaHookPayload } from '../../../../../message-providers/email/stalwart/StalwartMtaHookPayload';
 import { parseInboundStalwartEmail } from '../../../../../message-providers/email/stalwart/parseInboundStalwartEmail';
+import { $provideServer } from '../../../../../tools/$provideServer';
 import { processInboundAgentEmail } from '../../../../../utils/email/processInboundAgentEmail';
 import { NextRequest, NextResponse } from 'next/server';
 
@@ -16,6 +17,12 @@ export async function POST(request: NextRequest) {
         verifyStalwartMtaHookAuthorization(request.headers.get('authorization'));
         const payload = (await request.json()) as StalwartMtaHookPayload;
         const parsedEmail = await parseInboundStalwartEmail(payload);
+
+        // Note: `request.nextUrl` describes the internal listener this process was reached on, so behind
+        //       the VPS reverse proxy its hostname is `localhost` and never the mail domain. The server
+        //       registry is the single source of truth which already decides the database namespace of
+        //       this request, so the mail domain and the worker origin are taken from it as well.
+        const { publicUrl } = await $provideServer();
         const result = await processInboundAgentEmail({
             email: parsedEmail.email,
             envelope: {
@@ -23,8 +30,8 @@ export async function POST(request: NextRequest) {
                 recipients: parsedEmail.envelopeRecipients,
                 queueId: parsedEmail.queueId,
             },
-            domain: request.nextUrl.hostname,
-            origin: request.nextUrl.origin,
+            domain: publicUrl.hostname,
+            origin: publicUrl.origin,
         });
 
         return NextResponse.json({