@promptbook/cli 0.114.0-3 → 0.114.0-31

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

@@ -0,0 +1,201 @@
+import { NextResponse } from 'next/server';
+import { spaceTrim } from 'spacetrim';
+import { LimitReachedError } from '../../../../../../../src/errors/LimitReachedError';
+import { NotFoundError } from '../../../../../../../src/errors/NotFoundError';
+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 { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { resolveUserChatWorkerInternalToken } from '@/src/utils/userChat';
+
+/**
+ * Actions accepted by the internal planned-message runtime route.
+ */
+const AGENT_GOAL_CHAT_PLANNED_MESSAGE_REQUEST_ACTIONS = ['set', 'update', '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 });
+        }
+
+        if (error instanceof NotFoundError) {
+            return NextResponse.json({ error: error.message }, { status: 404 });
+        }
+
+        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 = await resolveCanonicalAgentPermanentId(request.body.agentPermanentId);
+
+    if (request.action === 'set') {
+        return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.set({
+            agentPermanentId,
+            ...createPlannedMessageScheduleRequest(request.body),
+            message: request.body.message,
+        });
+    }
+
+    if (request.action === 'update') {
+        return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.update({
+            agentPermanentId,
+            timeoutId: request.body.timeoutId,
+            ...createPlannedMessageScheduleRequest(request.body),
+            ...(request.body.message === undefined ? {} : { message: request.body.message }),
+        });
+    }
+
+    if (request.action === 'list') {
+        return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.list({
+            agentPermanentId,
+            isIncludingFinished: request.body.isIncludingFinished,
+            limit: request.body.limit,
+        });
+    }
+
+    return await AGENT_GOAL_CHAT_PLANNED_MESSAGE_ACTIONS.cancel({
+        agentPermanentId,
+        timeoutId: request.body.timeoutId,
+    });
+}
+
+/**
+ * Collects the schedule fields of one internal planned-message request.
+ *
+ * A field which is not part of the request body stays absent, so one update changes only what it
+ * really names and everything else keeps its stored value.
+ *
+ * @param body - Parsed request body.
+ * @returns Schedule fields passed to the shared planned-message actions.
+ */
+function createPlannedMessageScheduleRequest(body: Record<string, unknown>): Record<string, unknown> {
+    return {
+        ...(body.milliseconds === undefined ? {} : { milliseconds: body.milliseconds }),
+        ...(body.cronExpression === undefined ? {} : { cronExpression: body.cronExpression }),
+        ...(body.startsAt === undefined ? {} : { startsAt: body.startsAt }),
+        ...(body.endsAt === undefined ? {} : { endsAt: body.endsAt }),
+        ...(body.maxRunCount === undefined ? {} : { maxRunCount: body.maxRunCount }),
+    };
+}
+
+/**
+ * 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('`, `')}\`.
+        `),
+    );
+}
+
+/**
+ * Resolves an agent identifier to its canonical permanent id before persistence.
+ *
+ * Coding runners identify local folders with lowercase ids, while goal-chat and
+ * timeout records use the canonical database id.
+ *
+ * @param rawAgentPermanentId - Untrusted identifier from the internal runtime request.
+ * @returns The canonical permanent id of the active agent.
+ */
+async function resolveCanonicalAgentPermanentId(rawAgentPermanentId: unknown): Promise<string> {
+    if (typeof rawAgentPermanentId !== 'string' || rawAgentPermanentId.trim().length === 0) {
+        throw new ParseError('Missing required `agentPermanentId` string.');
+    }
+
+    const requestedAgentIdentifier = rawAgentPermanentId.trim();
+    const collection = await $provideAgentCollectionForServer();
+    const agent = await collection.findAgentBasicInformation(requestedAgentIdentifier);
+    const agentPermanentId = agent?.permanentId?.trim();
+
+    if (!agentPermanentId) {
+        throw new NotFoundError(
+            spaceTrim(`
+                Agent \`${requestedAgentIdentifier}\` was not found.
+
+                **Note:** Planned messages can only be managed for an active Agents Server agent.
+            `),
+        );
+    }
+
+    return agentPermanentId;
+}
+
+/**
+ * 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/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

@@ -73,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';
@@ -280,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.
  */
@@ -400,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) =>
@@ -500,6 +522,7 @@ export default async function RootLayout({
         isVpsEmailServerWarningShown,
         isServersDnsWarningShown,
         isInternalS3WarningShown,
+        isSelfUpdateRunning,
     ] = await Promise.all([
         isAdminPromise,
         isGlobalAdminPromise,
@@ -526,6 +549,7 @@ export default async function RootLayout({
         vpsEmailServerWarningPromise,
         serversDnsWarningPromise,
         internalS3WarningPromise,
+        selfUpdateRunningPromise,
     ]);
 
     const serverName = layoutMetadata.SERVER_NAME || 'Promptbook Agents Server';
@@ -625,6 +649,7 @@ export default async function RootLayout({
                     isVpsEmailServerWarningShown={isVpsEmailServerWarningShown}
                     isServersDnsWarningShown={isServersDnsWarningShown}
                     isInternalS3WarningShown={isInternalS3WarningShown}
+                    isSelfUpdateRunning={isSelfUpdateRunning}
                     isExperimentalPwaAppEnabled={isExperimentalPwaAppEnabled}
                     controlPanelOptionAvailability={controlPanelOptionAvailability}
                     defaultServerLanguage={serverLanguage}

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

@@ -11,10 +11,10 @@ import { isUserAdmin } from '../utils/isUserAdmin';
 import { isUserGlobalAdmin } from '../utils/isUserGlobalAdmin';
 import {
     createServerPublicUrl,
-    listRegisteredServersUsingServiceRole,
     resolveRegisteredServerByHost,
     type ServerRecord,
 } from '../utils/serverRegistry';
+import { listRegisteredServersUsingServiceRole } from '../utils/serverRegistryNode';
 import { isStandaloneVpsRawIpBootstrapActive } from '../utils/standaloneVpsRawIpBootstrap';
 import { getHomePageAgents } from './_data/getHomePageAgents';
 

package/apps/agents-server/src/app/superadmin/servers/ServersRegistryTable.tsx

@@ -2,10 +2,10 @@
 
 import { Fragment } from 'react';
 import { ArrowRightLeft, Bot, ExternalLink, Loader2, Mail, RefreshCcw, Save } from 'lucide-react';
-import { AgentProjectDnsInstructions } from '../../../components/AgentProjectDnsInstructions/AgentProjectDnsInstructions';
 import { DnsRecordsInstructions } from '../../../components/DnsRecordsInstructions/DnsRecordsInstructions';
 import { useServerLanguage } from '../../../components/ServerLanguage/ServerLanguageProvider';
 import type { ServerLanguageCode } from '../../../languages/ServerLanguageRegistry';
+import { createServerDnsRecordsSections } from '../../../utils/dnsRecords/createServerDnsRecordsSections';
 import { formatServerLanguageHumanReadableDate } from '../../../utils/localization/formatServerLanguageHumanReadableDate';
 import { AdminSortableTableHeaderCell } from '../../admin/_components/AdminSortableTableHeaderCell';
 import { useAdminTableSorting } from '../../admin/_components/adminTableSorting';
@@ -244,6 +244,7 @@ function ServersRegistryTableRow(props: ServersRegistryTableRowProps) {
     const hasProjectDnsIssue = projectDomains.some((projectDomain) =>
         isManagedServerDnsDiagnosticIssue(projectDomain.dnsDiagnostic),
     );
+    const generatedProjectDomain = projectDomains.find((projectDomain) => !projectDomain.customDomain)?.domain ?? null;
     const columnCount = isStandaloneVps ? 6 : 8;
 
     return (
@@ -341,10 +342,10 @@ function ServersRegistryTableRow(props: ServersRegistryTableRowProps) {
                         <a
                             href={`https://${server.domain}/admin/email-server`}
                             className={`${SECONDARY_BUTTON_CLASS_NAME} px-2 py-1 text-xs`}
-                            title={`MX, SPF, DKIM, and DMARC instructions for ${server.domain}`}
+                            title={`Agent addresses and the generated DKIM zone of ${server.domain}`}
                         >
                             <Mail className="h-3.5 w-3.5" />
-                            Mail DNS
+                            Email server
                         </a>
                         <button
                             type="button"
@@ -390,57 +391,54 @@ function ServersRegistryTableRow(props: ServersRegistryTableRowProps) {
             </tr>
             <tr className="bg-sky-50/50">
                 <td colSpan={columnCount} className="px-4 py-4">
-                    <ProjectDomainsPanel
-                        projectDomains={projectDomains}
-                        publicIpAddress={dnsDiagnostic?.publicIpAddress}
-                        serverDomain={server.domain}
-                    />
+                    <ProjectDomainsPanel projectDomains={projectDomains} />
                 </td>
             </tr>
-            {hasDnsIssue && dnsDiagnostic ? (
-                <tr className="bg-amber-50/70">
-                    <td colSpan={columnCount} className="px-4 py-4">
-                        <DnsRecordsInstructions
-                            description={dnsDiagnostic.summary}
-                            domain={server.domain}
-                            recordSelection="one"
-                            records={dnsDiagnostic.expectedRecords}
-                            providerGuides={dnsDiagnostic.providerGuides}
-                            resolvedAddresses={dnsDiagnostic.resolvedAddresses}
-                            title={
+            <tr className="bg-amber-50/70">
+                <td colSpan={columnCount} className="px-4 py-4">
+                    <DnsRecordsInstructions
+                        description="Everything this server needs at its DNS provider - its own domain, the generated project domains, and its email. Add all of them at once with the Cloudflare wizard below."
+                        domain={server.domain}
+                        providerGuides={dnsDiagnostic?.providerGuides}
+                        sections={createServerDnsRecordsSections({
+                            serverDomain: server.domain,
+                            dnsDiagnostic,
+                            isProjectDnsIssue: hasProjectDnsIssue,
+                            projectDomain: generatedProjectDomain,
+                        })}
+                        title={
+                            hasDnsIssue || hasProjectDnsIssue ? (
                                 <>
                                     DNS setup needs attention for <span className="font-mono">{server.domain}</span>
                                 </>
-                            }
-                        />
-                    </td>
-                </tr>
-            ) : null}
+                            ) : (
+                                <>
+                                    DNS setup for <span className="font-mono">{server.domain}</span>
+                                </>
+                            )
+                        }
+                    />
+                </td>
+            </tr>
         </>
     );
 }
 
 /**
- * Renders assigned project domains and preventive DNS guidance for one server.
+ * Renders the project domains assigned to one server.
+ *
+ * Their DNS setup intentionally lives in the one shared DNS manual of the server instead of in this listing.
  */
 function ProjectDomainsPanel({
-    publicIpAddress,
     projectDomains,
-    serverDomain,
 }: {
-    readonly publicIpAddress: string | null | undefined;
     readonly projectDomains: NonNullable<ManagedServerRow['projectDomains']>;
-    readonly serverDomain: string;
 }) {
     const projectDomainSorting = useAdminTableSorting<ProjectDomainRow, ProjectDomainsTableSortField>({
         rows: projectDomains,
         defaultSortBy: 'projectName',
         resolveSortValue: resolveProjectDomainSortValue,
     });
-    const generatedProjectDomain = projectDomains.find((projectDomain) => !projectDomain.customDomain)?.domain ?? null;
-    const hasProjectDnsIssue = projectDomains.some((projectDomain) =>
-        isManagedServerDnsDiagnosticIssue(projectDomain.dnsDiagnostic),
-    );
 
     return (
         <div className="space-y-3 rounded-lg border border-sky-200 bg-sky-50 px-4 py-4 text-sm text-sky-950">
@@ -535,12 +533,6 @@ function ProjectDomainsPanel({
                     </table>
                 </div>
             )}
-            <AgentProjectDnsInstructions
-                isDnsIssue={hasProjectDnsIssue}
-                projectDomain={generatedProjectDomain}
-                publicIpAddress={publicIpAddress}
-                serverDomain={serverDomain}
-            />
         </div>
     );
 }

package/apps/agents-server/src/app/system/user-wallet/UserWalletDraft.ts

@@ -56,7 +56,7 @@ type UserWalletRecordRequestPayload = Omit<CreateUserWalletRecordOptions, 'userI
 const USE_EMAIL_SMTP_WALLET_SCHEMA_TEXT = formatWalletJsonSchemaForTextarea(USE_EMAIL_SMTP_WALLET_SECRET_JSON_SCHEMA);
 
 /**
- * Returns true when record identity matches USE EMAIL SMTP credentials.
+ * Returns true when record identity matches the agent email SMTP credentials.
  *
  * @private function of UserWalletClient
  */
@@ -219,7 +219,7 @@ export function clearSensitiveUserWalletDraftFields(draft: UserWalletDraft): Use
 }
 
 /**
- * Applies SMTP defaults to simplify USE EMAIL setup.
+ * Applies SMTP defaults to simplify agent email setup.
  *
  * @private function of UserWalletClient
  */

package/apps/agents-server/src/components/AgentNaming/legacyAgentTextTranslations.cs.yaml

@@ -479,9 +479,16 @@
 "Loading messages…": "Načítám zprávy…"
 "No messages found.": "Nebyly nalezeny žádné zprávy."
 "Sender/Recipients": "Odesílatel/Příjemci"
+"Sender": "Odesílatel"
+"Recipients": "Příjemci"
+"From": "Od"
+"To": "Komu"
 "Content": "Obsah"
 "Pending": "Čeká"
 "Sent": "Odesláno"
+"Received": "Přijato"
+"Failed": "Selhalo"
+"Complete log": "Kompletní log"
 "Error simulation": "Simulace chyb"
 "Unhandled API throw": "Nezachycený pád API"
 "Handled API 500 response": "Zachycená API odpověď 500"

package/apps/agents-server/src/components/AgentProfile/AgentCapabilityChips.tsx

@@ -3,13 +3,10 @@ import {
     Book,
     Calendar,
     Code,
-    Clock8Icon,
     ExternalLink,
     FileText,
-    Globe,
     Link,
     MapPin,
-    Search,
     Shield,
     ShieldAlert,
     ShieldQuestionMarkIcon,
@@ -33,11 +30,6 @@ export const HOMEPAGE_CAPABILITY_CHIPS_LIMIT = 3;
  */
 export const AGENT_PROFILE_CAPABILITY_CHIPS_LIMIT = 7;
 
-/**
- * Capability types omitted from homepage agent cards.
- */
-export const AGENT_CARD_HIDDEN_CAPABILITY_TYPES: ReadonlyArray<AgentCapability['type']> = ['time'];
-
 /**
  * Constant for max individual knowledge chips.
  */
@@ -49,19 +41,7 @@ const MAX_INDIVIDUAL_KNOWLEDGE_CHIPS = 2;
 const CAPABILITY_PRIORITY_BUCKETS: ReadonlyArray<ReadonlyArray<AgentCapability['type']>> = [
     ['team'],
     ['inheritance', 'import'],
-    [
-        'browser',
-        'search-engine',
-        'timeout',
-        'time',
-        'user-location',
-        'image-generator',
-        'email',
-        'privacy',
-        'project',
-        'calendar',
-        'wallet',
-    ],
+    ['user-location', 'image-generator', 'privacy', 'project', 'calendar'],
     ['knowledge'],
 ];
 
@@ -188,11 +168,8 @@ export function AgentCapabilityChips({
 
                 const Icon =
                     {
-                        Globe,
-                        Search,
                         Book,
                         FileText,
-                        Clock: Clock8Icon,
                         SquareArrowOutUpRight,
                         SquareArrowUpRight,
                         ShieldAlert,

package/apps/agents-server/src/components/AgentProfile/AgentProfile.tsx

@@ -1,4 +1,6 @@
 'use client';
+import { spaceTrim } from 'spacetrim';
+
 
 import { colorToDataUrl } from '@promptbook-local/color';
 import { AgentBasicInformation, string_agent_permanent_id, string_url } from '@promptbook-local/types';
@@ -104,6 +106,13 @@ export function AgentProfile(props: AgentProfileProps) {
     // Dynamic Font Loading
     const fontString = meta.font;
     const primaryFontFamily = fontString ? (fontString.split(',')[0] || '').trim().replace(/['"]/g, '') : '';
+    const PRIMARY_FONT_IMPORT_STYLES = primaryFontFamily
+        ? spaceTrim(
+              (block) => `
+                  @import url('https://fonts.googleapis.com/css2?family=${block(encodeURIComponent(primaryFontFamily))}:wght@400;600;700&display=swap');
+              `,
+          )
+        : '';
     let fontStyle: React.CSSProperties = {};
 
     if (fontString) {
@@ -120,9 +129,7 @@ export function AgentProfile(props: AgentProfileProps) {
     return (
         <>
             {primaryFontFamily && (
-                <style jsx global>{`
-                    @import url('https://fonts.googleapis.com/css2?family=${encodeURIComponent(primaryFontFamily)}:wght@400;600;700&display=swap');
-                `}</style>
+                <style jsx global>{PRIMARY_FONT_IMPORT_STYLES}</style>
             )}
 
             {/* Full-screen background with agent color */}