@promptbook/cli 0.114.0-5 → 0.114.0-8

package/apps/agents-server/src/utils/agentGoalChat/scheduleAgentGoalChatModifiedNote.ts

@@ -0,0 +1,82 @@
+import { debounce } from '@promptbook-local/utils';
+import type { ProvidedServer } from '@/src/tools/$provideServer';
+import { runWithServerContextOverride } from '@/src/tools/serverContextOverride';
+import { recordAgentGoalChatLifecycleNote } from './recordAgentGoalChatLifecycleNote';
+
+/**
+ * Delay after the final persisted book update before the goal chat receives one modification note.
+ */
+export const AGENT_GOAL_CHAT_MODIFIED_NOTE_DEBOUNCE_DELAY_MS = 60_000;
+
+/**
+ * Agent identity used to write one delayed book-modification note.
+ *
+ * @private function of scheduleAgentGoalChatModifiedNote
+ */
+type AgentGoalChatModifiedNote = {
+    readonly agentPermanentId: string;
+    readonly agentName: string;
+    readonly server: ProvidedServer;
+};
+
+/**
+ * Runs delayed work under the server that owned the source update.
+ *
+ * @private function of scheduleAgentGoalChatModifiedNote
+ */
+type RunWithServerContext = (
+    server: ProvidedServer,
+    callback: () => Promise<void>,
+) => Promise<void>;
+
+/**
+ * Creates an independent one-minute debounce for each agent's goal-chat modification note.
+ *
+ * @private function of scheduleAgentGoalChatModifiedNote
+ */
+export function createAgentGoalChatModifiedNoteScheduler(options?: {
+    readonly recordAgentGoalChatLifecycleNote?: typeof recordAgentGoalChatLifecycleNote;
+    readonly runWithServerContextOverride?: RunWithServerContext;
+}): (agentGoalChatModifiedNote: AgentGoalChatModifiedNote) => void {
+    const debouncedNoteRecordersByServerAndAgent = new Map<
+        string,
+        ((agentGoalChatModifiedNote: AgentGoalChatModifiedNote) => void) & { cancel: () => void }
+    >();
+    const recordLifecycleNote = options?.recordAgentGoalChatLifecycleNote || recordAgentGoalChatLifecycleNote;
+    const runWithServerContext = options?.runWithServerContextOverride || runWithServerContextOverride;
+
+    return (agentGoalChatModifiedNote: AgentGoalChatModifiedNote) => {
+        const agentGoalChatModifiedNoteKey = createAgentGoalChatModifiedNoteKey(agentGoalChatModifiedNote);
+        let debouncedNoteRecorder = debouncedNoteRecordersByServerAndAgent.get(agentGoalChatModifiedNoteKey);
+
+        if (!debouncedNoteRecorder) {
+            debouncedNoteRecorder = debounce((latestAgentGoalChatModifiedNote: AgentGoalChatModifiedNote) => {
+                debouncedNoteRecordersByServerAndAgent.delete(agentGoalChatModifiedNoteKey);
+                void runWithServerContext(latestAgentGoalChatModifiedNote.server, () =>
+                    recordLifecycleNote({
+                        event: 'MODIFIED',
+                        agentPermanentId: latestAgentGoalChatModifiedNote.agentPermanentId,
+                        agentName: latestAgentGoalChatModifiedNote.agentName,
+                    }),
+                );
+            }, AGENT_GOAL_CHAT_MODIFIED_NOTE_DEBOUNCE_DELAY_MS);
+            debouncedNoteRecordersByServerAndAgent.set(agentGoalChatModifiedNoteKey, debouncedNoteRecorder);
+        }
+
+        debouncedNoteRecorder(agentGoalChatModifiedNote);
+    };
+}
+
+/**
+ * Schedules one best-effort goal-chat note after the latest book update of each agent.
+ */
+export const scheduleAgentGoalChatModifiedNote = createAgentGoalChatModifiedNoteScheduler();
+
+/**
+ * Creates the per-server, per-agent key used to keep independent note debounces separate.
+ *
+ * @private function of scheduleAgentGoalChatModifiedNote
+ */
+function createAgentGoalChatModifiedNoteKey(agentGoalChatModifiedNote: AgentGoalChatModifiedNote): string {
+    return JSON.stringify([agentGoalChatModifiedNote.server.tablePrefix, agentGoalChatModifiedNote.agentPermanentId]);
+}

package/apps/agents-server/src/utils/agentGoalChat.ts

@@ -0,0 +1,19 @@
+export { AGENT_GOAL_CHAT_TITLE } from './agentGoalChat/agentGoalChatConstants';
+export {
+    AGENT_GOAL_CHAT_ID_PREFIX,
+    buildAgentGoalChatId,
+    isAgentGoalChatId,
+} from './agentGoalChat/agentGoalChatIdentity';
+export { appendAgentGoalChatNote } from './agentGoalChat/appendAgentGoalChatNote';
+export { canAccessAgentGoalChat } from './agentGoalChat/canAccessAgentGoalChat';
+export {
+    createAgentGoalChatCancelledPlannedMessageNoteContent,
+    createAgentGoalChatLifecycleNoteContent,
+    createAgentGoalChatPlannedMessageNoteContent,
+} from './agentGoalChat/createAgentGoalChatNoteContent';
+export { ensureAgentGoalChat } from './agentGoalChat/ensureAgentGoalChat';
+export { prependAgentGoalChatSummarySeed } from './agentGoalChat/prependAgentGoalChatSummarySeed';
+export { recordAgentGoalChatLifecycleNote } from './agentGoalChat/recordAgentGoalChatLifecycleNote';
+export { resolveAgentGoalChatOwnerUserId } from './agentGoalChat/resolveAgentGoalChatOwnerUserId';
+export { scheduleAgentGoalChatModifiedNote } from './agentGoalChat/scheduleAgentGoalChatModifiedNote';
+export type { AgentGoalChatLifecycleEvent } from './agentGoalChat/createAgentGoalChatNoteContent';

package/apps/agents-server/src/utils/agentProjects/AgentProjectInfo.ts

@@ -12,7 +12,8 @@ export type AgentProjectInfo = {
     readonly projectName: string;
 
     /**
-     * User-facing name of the project, resolved from the README heading when available.
+     * User-facing name of the project, resolved from the README heading, the `index.html` title
+     * or the humanized project directory name.
      */
     readonly displayName: string;
 
@@ -26,6 +27,14 @@ export type AgentProjectInfo = {
      */
     readonly readmeFileName: string | null;
 
+    /**
+     * Path of the project icon relative to the project root, or `null` when the project has no icon.
+     *
+     * The icon is the favicon linked by the project `index.html` or a favicon found in one of the
+     * conventional locations; a project without one is shown with an icon made of its initials.
+     */
+    readonly faviconRelativePath: string | null;
+
     /**
      * Path of the project relative to the agent folder root, for example `projects/my-website`.
      */

package/apps/agents-server/src/utils/agentProjects/AgentProjectReferenceInfo.ts

@@ -5,7 +5,7 @@ import type { AgentProjectInfo } from './AgentProjectInfo';
  */
 export type AgentProjectReferenceInfo = Pick<
     AgentProjectInfo,
-    'projectName' | 'displayName' | 'description' | 'sizeBytes'
+    'projectName' | 'displayName' | 'description' | 'sizeBytes' | 'faviconRelativePath'
 > & {
     /**
      * Whether the project currently accepts requests on its assigned runtime port.
@@ -13,7 +13,10 @@ export type AgentProjectReferenceInfo = Pick<
     readonly isRunning?: boolean;
 
     /**
-     * Public runtime URL when the project has been assigned a runtime, otherwise `null`.
+     * Stable public project URL when the project has an assigned runtime or domain, otherwise `null`.
+     *
+     * The URL stays the same while the project is stopped so that the project stays recognizable
+     * wherever it is referenced.
      */
     readonly projectUrl?: string | null;
 };

package/apps/agents-server/src/utils/agentProjects/agentProjectFileNames.ts

@@ -0,0 +1,21 @@
+/**
+ * HTML entrypoint filenames recognized at the root of one agent project, ordered by priority.
+ *
+ * The static project server serves the first existing one of them for a directory request, so the
+ * same list decides which file describes the project — its `<title>` and its favicon.
+ */
+export const AGENT_PROJECT_INDEX_HTML_FILE_NAMES = ['index.html', 'index.htm'] as const;
+
+/**
+ * Conventional favicon locations searched inside one agent project, ordered by priority.
+ *
+ * They are used only when the project `index.html` does not link its icon explicitly.
+ */
+export const AGENT_PROJECT_CONVENTIONAL_FAVICON_RELATIVE_PATHS = [
+    'favicon.ico',
+    'favicon.svg',
+    'favicon.png',
+    'public/favicon.ico',
+    'public/favicon.svg',
+    'public/favicon.png',
+] as const;

package/apps/agents-server/src/utils/agentProjects/agentProjectHrefs.ts

@@ -43,17 +43,6 @@ export function buildAgentProjectProfileHref(agentPermanentId: string, projectNa
     return `${buildAgentProjectsDashboardHref(agentPermanentId)}/${encodeURIComponent(projectName)}`;
 }
 
-/**
- * Builds the href prefix serving files from one agent project.
- *
- * @param agentPermanentId - Permanent id of the agent.
- * @param projectName - Project directory name.
- * @returns Project file href prefix.
- */
-export function buildAgentProjectFilesHrefPrefix(agentPermanentId: string, projectName: string): string {
-    return `${buildAgentProjectProfileHref(agentPermanentId, projectName)}/files/`;
-}
-
 /**
  * Builds the href of one project on its owning server.
  *
@@ -118,6 +107,26 @@ export function buildAgentProjectFileHref(
     return `${buildAgentProjectProfileHref(agentPermanentId, projectName)}/files/${encodedFilePath}`;
 }
 
+/**
+ * Builds the href serving one raw file of one agent project on its owning server.
+ *
+ * @param options - Project file and server identity.
+ * @returns Server-scoped raw project file href.
+ */
+export function buildAgentProjectFileHrefForServer(options: {
+    readonly agentPermanentId: string;
+    readonly projectName: string;
+    readonly fileRelativePath: string;
+    readonly serverDomain: string | null;
+    readonly currentServerDomain: string | null;
+}): string {
+    return buildAgentProjectHrefForServer(
+        buildAgentProjectFileHref(options.agentPermanentId, options.projectName, options.fileRelativePath),
+        options.serverDomain,
+        options.currentServerDomain,
+    );
+}
+
 /**
  * Builds the href opening one project in browser VS Code.
  *

package/apps/agents-server/src/utils/agentProjects/agentProjectsPaths.ts

@@ -61,18 +61,28 @@ export function parseAgentPermanentIdFromDirectoryName(agentDirectoryName: strin
 }
 
 /**
- * Asserts that one path segment coming from a URL cannot escape its parent directory.
+ * Returns whether one path segment stays inside its parent directory.
  *
  * @param pathSegment - Single decoded path segment (project name or one file path part).
- * @param segmentPurpose - Human-readable description used in the error message.
- * @throws {NotAllowed} When the segment is empty or attempts path traversal.
+ * @returns `true` when the segment is non-empty and cannot escape its parent directory.
  */
-export function assertSafeAgentProjectPathSegment(pathSegment: string, segmentPurpose: string): void {
+export function isSafeAgentProjectPathSegment(pathSegment: string): boolean {
     const isTraversalSegment = pathSegment === '.' || pathSegment === '..';
     const hasPathSeparator = pathSegment.includes('/') || pathSegment.includes('\\');
     const hasNullByte = pathSegment.includes('\0');
 
-    if (pathSegment.length === 0 || isTraversalSegment || hasPathSeparator || hasNullByte) {
+    return pathSegment.length > 0 && !isTraversalSegment && !hasPathSeparator && !hasNullByte;
+}
+
+/**
+ * Asserts that one path segment coming from a URL cannot escape its parent directory.
+ *
+ * @param pathSegment - Single decoded path segment (project name or one file path part).
+ * @param segmentPurpose - Human-readable description used in the error message.
+ * @throws {NotAllowed} When the segment is empty or attempts path traversal.
+ */
+export function assertSafeAgentProjectPathSegment(pathSegment: string, segmentPurpose: string): void {
+    if (!isSafeAgentProjectPathSegment(pathSegment)) {
         throw new NotAllowed(
             spaceTrim(`
                 Invalid ${segmentPurpose} \`${pathSegment}\`.

package/apps/agents-server/src/utils/agentProjects/createAgentProjectInitials.ts

@@ -0,0 +1,36 @@
+import { humanizeAgentProjectName } from './humanizeAgentProjectName';
+
+/**
+ * Maximum count of letters shown in one project initials icon.
+ */
+const AGENT_PROJECT_INITIALS_MAX_LENGTH = 3;
+
+/**
+ * Matches the first letter or digit of one word of a project name.
+ */
+const PROJECT_NAME_WORD_INITIAL_REGEX = /[\p{L}\p{N}]/u;
+
+/**
+ * Initials used for a project whose name has no letters and no digits at all.
+ */
+const AGENT_PROJECT_FALLBACK_INITIALS = '#';
+
+/**
+ * Creates the initials shown for one project which has no favicon.
+ *
+ * For example `prague-murders-map` becomes `PMM`.
+ *
+ * @param projectName - Project directory name.
+ * @returns Up to three uppercase initials of the project name.
+ */
+export function createAgentProjectInitials(projectName: string): string {
+    const projectInitials = humanizeAgentProjectName(projectName)
+        .split(/\s+/u)
+        .map((projectNameWord) => PROJECT_NAME_WORD_INITIAL_REGEX.exec(projectNameWord)?.[0] || '')
+        .filter((projectNameInitial) => projectNameInitial !== '')
+        .slice(0, AGENT_PROJECT_INITIALS_MAX_LENGTH)
+        .join('')
+        .toUpperCase();
+
+    return projectInitials || AGENT_PROJECT_FALLBACK_INITIALS;
+}

package/apps/agents-server/src/utils/agentProjects/createAgentProjectMarkdownReferences.ts

@@ -1,6 +1,6 @@
 import type { MarkdownInlineReference } from '@promptbook-local/types';
 import type { AgentProjectReferenceInfo } from './AgentProjectReferenceInfo';
-import { buildAgentProjectFilesHrefPrefix, buildAgentProjectProfileHref } from './agentProjectHrefs';
+import { buildAgentProjectProfileHref } from './agentProjectHrefs';
 
 /**
  * Markdown inline reference data consumed by chat markdown rendering.
@@ -31,7 +31,11 @@ type AgentProjectMarkdownReferenceInfo = Pick<
 >;
 
 /**
- * Creates markdown references that render known `[[project-name]]` tokens as project profile chips.
+ * Creates markdown references rendering every mention of one project as a project chip.
+ *
+ * One project is mentioned either by its display name in chat prose, its `[[project-name]]` token,
+ * a link into its project page or files, or its public project URL. All of them render the same chip
+ * showing the project name together with its running state.
  *
  * @param options - Agent and project metadata.
  * @returns Inline markdown references for the shared chat renderer.
@@ -42,17 +46,15 @@ export function createAgentProjectMarkdownReferences(
     return options.projects.map((project) => {
         const projectProfileHref = buildAgentProjectProfileHref(options.agentPermanentId, project.projectName);
         const projectUrl = project.projectUrl || null;
+        const label = project.displayName || project.projectName;
 
         return {
             reference: project.projectName,
-            label: project.displayName || project.projectName,
+            sourceTextAliases: [label],
+            label,
             href: projectProfileHref,
-            sourceHrefPrefixes: [
-                projectProfileHref,
-                buildAgentProjectFilesHrefPrefix(options.agentPermanentId, project.projectName),
-                ...(projectUrl ? [projectUrl] : []),
-            ],
-            title: project.description || project.displayName || project.projectName,
+            sourceHrefPrefixes: [projectProfileHref, ...(projectUrl ? [projectUrl] : [])],
+            title: project.description || label,
             menu: {
                 status: {
                     label: project.isRunning ? 'Project is running' : 'Project is not running',

package/apps/agents-server/src/utils/agentProjects/createAgentProjectsDnsRecordsSection.ts

@@ -0,0 +1,113 @@
+import type { DnsRecordsSection, DnsRecordsSectionVariant } from '../dnsRecords/DnsRecordsSection';
+import { createAgentProjectDnsRecord } from './createAgentProjectDnsRecords';
+
+/**
+ * Inputs of the generated project domain DNS section.
+ *
+ * @private helper for the Agents Server project DNS instructions
+ */
+type CreateAgentProjectsDnsRecordsSectionOptions = {
+    /**
+     * Whether at least one generated project domain currently fails DNS verification.
+     */
+    readonly isDnsIssue?: boolean;
+
+    /**
+     * Example generated project domain used by the single-project variants, when one already exists.
+     */
+    readonly projectDomain?: string | null;
+
+    /**
+     * Public VPS IP address, when known by the server.
+     */
+    readonly publicIpAddress: string | null | undefined;
+
+    /**
+     * Base server domain used by generated project domains.
+     */
+    readonly serverDomain: string;
+};
+
+/**
+ * Creates the DNS section which publishes the generated agent project domains.
+ *
+ * Exactly one of the variants has to be configured, because the wildcard and the single-project records as well as
+ * the A and the CNAME records would collide on the same hostname.
+ *
+ * @param options - Server domain, example project domain, and the public VPS IP address.
+ * @returns Generated project domain section.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function createAgentProjectsDnsRecordsSection(
+    options: CreateAgentProjectsDnsRecordsSectionOptions,
+): DnsRecordsSection {
+    return {
+        id: 'agent-projects',
+        title: `Project domains under ${options.serverDomain}`,
+        description: `Project URLs use a subdomain of ${options.serverDomain}. Configure exactly one of the following setups; do not add both the single-project and the wildcard records, or both the A and the CNAME record for the same hostname.`,
+        variantsLabel: 'Project domain setup',
+        variants: [
+            createAgentProjectsDnsRecordsSectionVariant(options, { isWildcardDomain: true, isCnameRecord: true }),
+            createAgentProjectsDnsRecordsSectionVariant(options, { isWildcardDomain: true, isCnameRecord: false }),
+            createAgentProjectsDnsRecordsSectionVariant(options, { isWildcardDomain: false, isCnameRecord: true }),
+            createAgentProjectsDnsRecordsSectionVariant(options, { isWildcardDomain: false, isCnameRecord: false }),
+        ],
+        statusSummary: options.isDnsIssue
+            ? 'One or more generated project domains do not resolve to this VPS yet. The recommended wildcard CNAME setup is selected below.'
+            : null,
+        isDnsIssue: options.isDnsIssue,
+    };
+}
+
+/**
+ * Creates one selectable generated project domain setup.
+ *
+ * @param options - Inputs of the whole section.
+ * @param variant - Selected domain coverage and record type.
+ * @returns One section variant with its single DNS record.
+ *
+ * @private function of `createAgentProjectsDnsRecordsSection`
+ */
+function createAgentProjectsDnsRecordsSectionVariant(
+    options: CreateAgentProjectsDnsRecordsSectionOptions,
+    variant: {
+        /**
+         * Whether the variant covers every generated project domain.
+         */
+        readonly isWildcardDomain: boolean;
+
+        /**
+         * Whether the variant uses a CNAME instead of an A record.
+         */
+        readonly isCnameRecord: boolean;
+    },
+): DnsRecordsSectionVariant {
+    const { isCnameRecord, isWildcardDomain } = variant;
+
+    return {
+        id: `${isWildcardDomain ? 'wildcard' : 'single-project'}-${isCnameRecord ? 'cname' : 'a'}`,
+        label: isWildcardDomain
+            ? isCnameRecord
+                ? 'Wildcard CNAME (all projects, recommended)'
+                : 'Wildcard A record (all projects)'
+            : isCnameRecord
+            ? 'Single project CNAME'
+            : 'Single project A record',
+        description: isWildcardDomain
+            ? `This covers all generated project domains under ${options.serverDomain}.`
+            : options.projectDomain
+            ? `This covers one project, for example ${options.projectDomain}. Repeat it for each project that needs a public URL.`
+            : 'This covers one generated project. Replace the project name placeholder above with its full hostname.',
+        recordSelection: 'one',
+        records: [
+            createAgentProjectDnsRecord({
+                isCnameRecord,
+                isWildcardDomain,
+                projectDomain: options.projectDomain,
+                publicIpAddress: options.publicIpAddress,
+                serverDomain: options.serverDomain,
+            }),
+        ],
+    };
+}

package/apps/agents-server/src/utils/agentProjects/createStaticAgentProjectServer.ts

@@ -3,15 +3,11 @@ import { readdir, readFile, stat } from 'fs/promises';
 import { basename, isAbsolute, join, relative, resolve } from 'path';
 import { NotAllowed } from '../../../../../src/errors/NotAllowed';
 import { spaceTrim } from '../../../../../src/utils/organization/spaceTrim';
+import { AGENT_PROJECT_INDEX_HTML_FILE_NAMES } from './agentProjectFileNames';
 import { assertSafeAgentProjectPathSegment } from './agentProjectsPaths';
 import { isMissingPathError } from './isMissingPathError';
 import { resolveAgentProjectFileContentType } from './resolveAgentProjectFileContentType';
 
-/**
- * Filenames served automatically when a request targets a project directory.
- */
-const STATIC_DIRECTORY_INDEX_FILENAMES = ['index.html', 'index.htm'] as const;
-
 /**
  * HTML content type used for generated static directory listings.
  */
@@ -170,7 +166,7 @@ async function serveStaticProjectDirectory(options: {
     readonly directoryPath: string;
     readonly response: ServerResponse;
 }): Promise<void> {
-    for (const indexFileName of STATIC_DIRECTORY_INDEX_FILENAMES) {
+    for (const indexFileName of AGENT_PROJECT_INDEX_HTML_FILE_NAMES) {
         const indexFilePath = join(options.directoryPath, indexFileName);
         const indexFileStats = await stat(indexFilePath).catch((error) => {
             if (isMissingPathError(error)) {

package/apps/agents-server/src/utils/agentProjects/humanizeAgentProjectName.ts

@@ -0,0 +1,25 @@
+import { capitalize } from '@promptbook-local/utils';
+
+/**
+ * Separators used between the words of one project directory name.
+ */
+const AGENT_PROJECT_NAME_WORD_SEPARATOR_REGEX = /[-_.\s]+/g;
+
+/**
+ * Converts one project directory name into a human-readable project name.
+ *
+ * For example `prague-murders-map` becomes `Prague Murders Map`.
+ *
+ * @param projectName - Project directory name.
+ * @returns Human-readable project name, or the original name when it cannot be humanized.
+ */
+export function humanizeAgentProjectName(projectName: string): string {
+    const humanizedProjectName = projectName
+        .trim()
+        .split(AGENT_PROJECT_NAME_WORD_SEPARATOR_REGEX)
+        .filter((projectNameWord) => projectNameWord !== '')
+        .map((projectNameWord) => capitalize(projectNameWord))
+        .join(' ');
+
+    return humanizedProjectName || projectName;
+}

package/apps/agents-server/src/utils/agentProjects/listAgentProjectChatReferences.ts

@@ -1,6 +1,7 @@
 import type { AgentProjectReferenceInfo } from './AgentProjectReferenceInfo';
 import { listAgentProjectRuntimes } from './agentProjectRuntimeRegistry';
 import { listAgentProjects } from './listAgentProjects';
+import { resolveAgentProjectPublicUrls } from './resolveAgentProjectPublicUrls';
 
 /**
  * Lists browser-safe project references enriched with their current runtime state for chat.
@@ -11,7 +12,11 @@ import { listAgentProjects } from './listAgentProjects';
 export async function listAgentProjectChatReferences(
     agentPermanentId: string,
 ): Promise<ReadonlyArray<AgentProjectReferenceInfo>> {
-    const [projects, runtimes] = await Promise.all([listAgentProjects(agentPermanentId), listAgentProjectRuntimes()]);
+    const [projects, runtimes, publicUrlByProjectName] = await Promise.all([
+        listAgentProjects(agentPermanentId),
+        listAgentProjectRuntimes(),
+        resolveAgentProjectPublicUrls(agentPermanentId),
+    ]);
     const runtimeByProjectName = new Map(
         runtimes
             .filter((runtime) => runtime.agentPermanentId.toLowerCase() === agentPermanentId.toLowerCase())
@@ -19,15 +24,17 @@ export async function listAgentProjectChatReferences(
     );
 
     return projects.map((project) => {
-        const runtime = runtimeByProjectName.get(project.projectName.toLowerCase());
+        const normalizedProjectName = project.projectName.toLowerCase();
+        const runtime = runtimeByProjectName.get(normalizedProjectName);
 
         return {
             projectName: project.projectName,
             displayName: project.displayName,
             description: project.description,
             sizeBytes: project.sizeBytes,
+            faviconRelativePath: project.faviconRelativePath ?? null,
             isRunning: runtime?.isRunning ?? false,
-            projectUrl: runtime?.publicUrl ?? null,
+            projectUrl: runtime?.publicUrl ?? publicUrlByProjectName.get(normalizedProjectName) ?? null,
         };
     });
 }