@promptbook/cli 0.114.0-0 → 0.114.0-10

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/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/elevenlabs/tts/route.ts

@@ -31,7 +31,7 @@ const ELEVEN_LABS_MODEL_ID = process.env.ELEVEN_LABS_MODEL_ID ?? 'eleven_multili
  *
  * @private
  */
-const ELEVEN_LABS_API_KEY = process.env.ELEVEN_LABS_API_KEY;
+const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;
 
 /**
  * Maximum number of characters that are sent to a single ElevenLabs TTS request.
@@ -89,7 +89,7 @@ export async function POST(request: NextRequest) {
         });
     }
 
-    if (!ELEVEN_LABS_API_KEY) {
+    if (!ELEVENLABS_API_KEY) {
         return new Response(
             JSON.stringify({
                 error: 'ElevenLabs API key is not configured on the server.',
@@ -153,7 +153,7 @@ export async function POST(request: NextRequest) {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
-            'xi-api-key': ELEVEN_LABS_API_KEY,
+            'xi-api-key': ELEVENLABS_API_KEY,
         },
         body: JSON.stringify({
             text: limitedText,

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({

package/apps/agents-server/src/app/api/internal/agent-goal-chat-planned-messages/route.ts

@@ -0,0 +1,146 @@
+import { NextResponse } from 'next/server';
+import { spaceTrim } from 'spacetrim';
+import { LimitReachedError } from '../../../../../../../src/errors/LimitReachedError';
+import { ParseError } from '../../../../../../../src/errors/ParseError';
+import { isTimingSafeEqualString } from '../../../../../../../src/utils/isTimingSafeEqualString';
+import { USER_CHAT_WORKER_TOKEN_HEADER } from '@/src/utils/agentProjects/agentProjectRuntimeConstants';
+import { AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS } from '@/src/utils/agentGoalChat/agentGoalChatPlannedMessageActions';
+import { resolveUserChatWorkerInternalToken } from '@/src/utils/userChat';
+
+/**
+ * Actions accepted by the internal planned-message runtime route.
+ */
+const AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS = ['set', 'list', 'cancel'] as const;
+
+/**
+ * Supported planned-message runtime action.
+ */
+type AgentGoalChatPlannedMessageAction = (typeof AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS)[number];
+
+/**
+ * Parsed internal runtime request.
+ */
+type AgentGoalChatPlannedMessageRequest = {
+    readonly action: AgentGoalChatPlannedMessageAction;
+    readonly body: Record<string, unknown>;
+};
+
+/**
+ * Keeps planned-message persistence on the Node.js runtime.
+ */
+export const runtime = 'nodejs';
+
+/**
+ * Handles planned-message commands from an Agents Server-managed coding agent.
+ */
+export async function POST(request: Request) {
+    if (!isAuthorizedInternalWorkerRequest(request)) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const plannedMessageRequest = await parseAgentGoalChatPlannedMessageRequest(request);
+        const result = await executeAgentGoalChatPlannedMessageRequest(plannedMessageRequest);
+
+        return NextResponse.json(result);
+    } catch (error) {
+        if (error instanceof ParseError) {
+            return NextResponse.json({ error: error.message }, { status: 400 });
+        }
+
+        if (error instanceof LimitReachedError) {
+            return NextResponse.json({ error: error.message }, { status: 429 });
+        }
+
+        console.error('[agent-goal-chat-planned-messages] internal route failed', error);
+        return NextResponse.json(
+            {
+                error: error instanceof Error ? error.message : 'Failed to manage planned goal-chat messages.',
+            },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * Parses one internal planned-message request body.
+ */
+async function parseAgentGoalChatPlannedMessageRequest(request: Request): Promise<AgentGoalChatPlannedMessageRequest> {
+    const rawBody = await request.json().catch(() => null);
+
+    if (!rawBody || typeof rawBody !== 'object' || Array.isArray(rawBody)) {
+        throw new ParseError('Expected a JSON object body.');
+    }
+
+    const body = rawBody as Record<string, unknown>;
+    const action = normalizeAgentGoalChatPlannedMessageAction(body.action);
+
+    return { action, body };
+}
+
+/**
+ * Executes one normalized planned-message request through the shared action service.
+ */
+async function executeAgentGoalChatPlannedMessageRequest(request: AgentGoalChatPlannedMessageRequest) {
+    const agentPermanentId = request.body.agentPermanentId;
+
+    if (request.action === 'set') {
+        return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.set({
+            agentPermanentId: normalizeAgentPermanentId(agentPermanentId),
+            milliseconds: request.body.milliseconds,
+            message: request.body.message,
+        });
+    }
+
+    if (request.action === 'list') {
+        return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.list({
+            agentPermanentId: normalizeAgentPermanentId(agentPermanentId),
+            isIncludingFinished: request.body.isIncludingFinished,
+            limit: request.body.limit,
+        });
+    }
+
+    return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.cancel({
+        agentPermanentId: normalizeAgentPermanentId(agentPermanentId),
+        timeoutId: request.body.timeoutId,
+    });
+}
+
+/**
+ * Validates one planned-message action value.
+ */
+function normalizeAgentGoalChatPlannedMessageAction(rawAction: unknown): AgentGoalChatPlannedMessageAction {
+    if (
+        typeof rawAction === 'string' &&
+        AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS.includes(rawAction as AgentGoalChatPlannedMessageAction)
+    ) {
+        return rawAction as AgentGoalChatPlannedMessageAction;
+    }
+
+    throw new ParseError(
+        spaceTrim(`
+            Invalid planned-message \`action\`.
+
+            - Use one of: \`${AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS.join('`, `')}\`.
+        `),
+    );
+}
+
+/**
+ * Validates the agent identifier before dispatching the runtime action.
+ */
+function normalizeAgentPermanentId(rawAgentPermanentId: unknown): string {
+    if (typeof rawAgentPermanentId !== 'string' || rawAgentPermanentId.trim().length === 0) {
+        throw new ParseError('Missing required `agentPermanentId` string.');
+    }
+
+    return rawAgentPermanentId.trim();
+}
+
+/**
+ * Validates the shared internal worker token.
+ */
+function isAuthorizedInternalWorkerRequest(request: Request): boolean {
+    const token = request.headers.get(USER_CHAT_WORKER_TOKEN_HEADER);
+    return isTimingSafeEqualString(token, resolveUserChatWorkerInternalToken());
+}

package/apps/agents-server/src/app/api/onboarding/book/route.ts

@@ -1,21 +1,22 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { convertManGoDraftToBook } from '@/src/utils/manGoOnboarding/manGoOnboardingAgentRuntime';
+import { generateManGoBook } from '@/src/utils/manGoOnboarding/manGoOnboardingAgentRuntime';
 import { createManGoOnboardingApiErrorResponse } from '@/src/utils/manGoOnboarding/manGoOnboardingApiResponses';
 import { readManGoOnboardingStringProperty } from '@/src/utils/manGoOnboarding/manGoOnboardingApiRequest';
 
 /**
  * Handles `POST /api/onboarding/book`.
  *
- * @param request - Incoming request with the editable draft input.
- * @returns Canonical Book-language source and validation flag.
+ * @param request - Incoming request with `agentName` and `agentBrief`.
+ * @returns Generated Book-language source.
  */
 export async function POST(request: NextRequest) {
     try {
         const body = await request.json();
-        const input = readManGoOnboardingStringProperty(body, 'input');
-        const result = await convertManGoDraftToBook({ input });
+        const agentName = readManGoOnboardingStringProperty(body, 'agentName');
+        const agentBrief = readManGoOnboardingStringProperty(body, 'agentBrief');
+        const book = await generateManGoBook({ agentName, agentBrief });
 
-        return NextResponse.json(result);
+        return NextResponse.json({ book });
     } catch (error) {
         return createManGoOnboardingApiErrorResponse(error);
     }

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

@@ -1,6 +1,6 @@
 import { serializeError } from '@promptbook-local/utils';
 import { NextRequest, NextResponse } from 'next/server';
-import { fetchUrlContent } from '../../../../../../src/commitments/USE_BROWSER/fetchUrlContent';
+import { fetchUrlContent } from '../../../../../../src/scrapers/_common/utils/fetchUrlContent';
 import { assertsError } from '../../../../../../src/errors/assertsError';
 import { getCurrentUser } from '../../../utils/getCurrentUser';
 import { assertSafeUrl } from '../../../utils/assertSafeUrl';

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

@@ -4,6 +4,7 @@ import { createThemeModeBootstrapScript } from '@/src/components/ThemeMode/creat
 import { APPLICATION_FONT_VARIABLE_CLASS_NAME } from '@/src/utils/applicationFonts';
 import type { Metadata } from 'next';
 import { cookies, headers } from 'next/headers';
+import { connection } from 'next/server';
 import { CONTENT_SECURITY_POLICY_NONCE_REQUEST_HEADER } from '../middleware/contentSecurityPolicy';
 import { getCustomJavascriptWithIntegrations } from '../database/customJavascript';
 import { getAggregatedCustomStylesheetCss } from '../database/customStylesheet';
@@ -72,6 +73,8 @@ import {
     readStalwartEmailSnapshot,
 } from '../utils/stalwart/readStalwartEmailSnapshot';
 import { readStalwartConfiguration } from '../utils/stalwart/StalwartConfiguration';
+import { isVpsSelfUpdateJobRunning } from '../utils/vpsSelfUpdate/isVpsSelfUpdateJobRunning';
+import { readVpsSelfUpdateJobSnapshot } from '../utils/vpsSelfUpdate/readPersistedVpsSelfUpdateJob';
 import { readAgentsServerFooterVersion } from '../utils/vpsSelfUpdate/readAgentsServerFooterVersion';
 import '@prisma/studio-core/ui/index.css';
 import './globals.css';
@@ -279,6 +282,25 @@ async function resolveInternalS3WarningStatus(isGlobalAdmin: boolean): Promise<b
     }
 }
 
+/**
+ * Resolves whether a standalone VPS self-update is running right now.
+ *
+ * @param isGlobalAdmin - Whether the current viewer may see VPS-wide operational details.
+ * @returns `true` when a self-update job is in progress.
+ */
+async function resolveSelfUpdateRunningStatus(isGlobalAdmin: boolean): Promise<boolean> {
+    if (!isGlobalAdmin) {
+        return false;
+    }
+
+    try {
+        return isVpsSelfUpdateJobRunning(await readVpsSelfUpdateJobSnapshot());
+    } catch (error) {
+        console.error('Failed to resolve self-update running status:', error);
+        return false;
+    }
+}
+
 /**
  * Generates metadata.
  */
@@ -349,6 +371,11 @@ export default async function RootLayout({
 }: Readonly<{
     children: React.ReactNode;
 }>) {
+    // Every page uses this request-aware layout (cookies, headers, and the current user). Tell Next.js before
+    // starting its database-backed work so a production build does not repeat that work for every static-render
+    // attempt only to discover that the route must be dynamic.
+    await connection();
+
     const layoutMetadataPromise = getMetadataMap([
         'SERVER_NAME',
         'SERVER_LOGO_URL',
@@ -394,6 +421,7 @@ export default async function RootLayout({
     const vpsEmailServerWarningPromise = isGlobalAdminPromise.then(resolveVpsEmailServerWarningStatus);
     const serversDnsWarningPromise = isGlobalAdminPromise.then(resolveServersDnsWarningStatus);
     const internalS3WarningPromise = isGlobalAdminPromise.then(resolveInternalS3WarningStatus);
+    const selfUpdateRunningPromise = isGlobalAdminPromise.then(resolveSelfUpdateRunningStatus);
     const serverVisibilityPromise = getServerVisibility();
     const agentNamingPromise = getAgentNaming();
     const organizationStatePromise = isAdminPromise.then((isAdmin) =>
@@ -494,6 +522,7 @@ export default async function RootLayout({
         isVpsEmailServerWarningShown,
         isServersDnsWarningShown,
         isInternalS3WarningShown,
+        isSelfUpdateRunning,
     ] = await Promise.all([
         isAdminPromise,
         isGlobalAdminPromise,
@@ -520,6 +549,7 @@ export default async function RootLayout({
         vpsEmailServerWarningPromise,
         serversDnsWarningPromise,
         internalS3WarningPromise,
+        selfUpdateRunningPromise,
     ]);
 
     const serverName = layoutMetadata.SERVER_NAME || 'Promptbook Agents Server';
@@ -619,6 +649,7 @@ export default async function RootLayout({
                     isVpsEmailServerWarningShown={isVpsEmailServerWarningShown}
                     isServersDnsWarningShown={isServersDnsWarningShown}
                     isInternalS3WarningShown={isInternalS3WarningShown}
+                    isSelfUpdateRunning={isSelfUpdateRunning}
                     isExperimentalPwaAppEnabled={isExperimentalPwaAppEnabled}
                     controlPanelOptionAvailability={controlPanelOptionAvailability}
                     defaultServerLanguage={serverLanguage}