@cyberismo/backend 1.1.2 → 1.3.0

package/src/domain/templates/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as templateService from './service.js';
@@ -40,10 +30,10 @@ router.get('/', requireRole(UserRole.Reader), async (c) => {
   if (isSSGContext(c)) {
     return c.json([]);
   }
-  const commands = c.get('commands');
+  const ws = c.get('ws');
 
   try {
-    const response = await templateService.getTemplatesWithDetails(commands);
+    const response = await templateService.getTemplatesWithDetails(ws);
     return c.json(response);
   } catch (error) {
     return c.json(
@@ -85,10 +75,10 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', createTemplateSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { identifier } = c.req.valid('json');
 
-    await templateService.createTemplate(commands, identifier);
+    await templateService.createTemplate(ws, identifier);
     return c.json({ message: 'Template created successfully' });
   },
 );
@@ -131,11 +121,11 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', addTemplateCardSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { template, cardType, parentKey, count } = c.req.valid('json');
 
     const added = await templateService.addTemplateCard(
-      commands,
+      ws,
       template,
       cardType,
       parentKey,

package/src/domain/templates/schema.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { z } from 'zod';
 import { identifierSchema } from '../../common/validationSchemas.js';

package/src/domain/templates/service.ts

@@ -1,36 +1,23 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
+import type { Workspace } from '@cyberismo/data-handler';
 import { resourceName } from '@cyberismo/data-handler';
 
-export async function getTemplatesWithDetails(commands: CommandManager) {
-  const response = await commands.showCmd.showTemplatesWithDetails();
+export async function getTemplatesWithDetails(ws: Workspace) {
+  const response = await ws.resources.contents('templates');
   if (!response) {
     throw new Error('No templates found');
   }
   return response;
 }
 
-export async function createTemplate(
-  commands: CommandManager,
-  templateName: string,
-) {
-  await commands.createCmd.createTemplate(templateName, '');
+export async function createTemplate(ws: Workspace, templateName: string) {
+  await ws.resources.create(templateName, 'templates', {});
 }
 
 export async function addTemplateCard(
-  commands: CommandManager,
+  ws: Workspace,
   template: string,
   cardType: string,
   parentKey?: string,
@@ -40,7 +27,7 @@ export async function addTemplateCard(
   if (type !== 'templates') {
     throw new Error('Invalid template resource');
   }
-  const added = await commands.createCmd.addCards(
+  const added = await ws.cards.addToTemplate(
     cardType,
     identifier,
     parentKey,

package/src/domain/tree/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as treeService from './service.js';
@@ -35,12 +25,12 @@ const router = new Hono();
  *         description: project_path not set or other internal error
  */
 router.get('/', requireRole(UserRole.Reader), async (c: AppContext) => {
-  const commands = c.get('commands');
+  const ws = c.get('ws');
   const tree = c.get('tree');
 
   try {
     const response = await treeService.getCardTree(
-      commands,
+      ws,
       isSSGContext(c),
       tree?.cardKey,
       tree?.recursive,

package/src/domain/tree/service.ts

@@ -1,35 +1,24 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
+import type { Workspace } from '@cyberismo/data-handler';
 
 /**
  * Returns the card tree of the project
- * @param commands command manager used for the query
+ * @param ws command manager used for the query
  * @param isSsg whether the context is static site generation
  * @param cardKey optional card key to start the tree from
  * @param recursive if false, includes only the given card. Otherwise, includes all child cards recursively.
  * @returns
  */
 export async function getCardTree(
-  commands: CommandManager,
+  ws: Workspace,
   isSsg: boolean,
   cardKey?: string,
   recursive?: boolean,
-): ReturnType<typeof commands.calculateCmd.runQuery> {
-  return commands.calculateCmd.runQuery(
-    'tree',
-    isSsg ? 'exportedSite' : 'localApp',
-    { cardKey, recursive },
-  );
+): ReturnType<typeof ws.queries.runQuery> {
+  return ws.queries.runQuery('tree', isSsg ? 'exportedSite' : 'localApp', {
+    cardKey,
+    recursive,
+  });
 }

package/src/domain/workflows/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as workflowService from './service.js';
@@ -50,10 +40,10 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', createWorkflowSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { identifier } = c.req.valid('json');
 
-    await workflowService.createWorkflow(commands, identifier);
+    await workflowService.createWorkflow(ws, identifier);
     return c.json({ message: 'Workflow created successfully' });
   },
 );

package/src/domain/workflows/schema.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { z } from 'zod';
 import { identifierSchema } from '../../common/validationSchemas.js';

package/src/domain/workflows/service.ts

@@ -1,21 +1,8 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
+import type { Workspace } from '@cyberismo/data-handler';
 
-export async function createWorkflow(
-  commands: CommandManager,
-  workflowName: string,
-) {
-  await commands.createCmd.createWorkflow(workflowName, '');
+export async function createWorkflow(ws: Workspace, workflowName: string) {
+  await ws.resources.create(workflowName, 'workflows', {});
 }

package/src/export.ts

@@ -1,37 +1,33 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import fs from 'node:fs/promises';
 
-import type { CommandManager } from '@cyberismo/data-handler';
+import {
+  SYSTEM_ACTOR,
+  type ProjectDirectory,
+  type Workspace,
+} from '@cyberismo/data-handler';
 import { createApp } from './app.js';
 import { MockAuthProvider } from './auth/mock.js';
-import type { ProjectRegistry } from './project-registry.js';
 import { cp } from 'node:fs/promises';
 import { staticFrontendDirRelative } from './utils.js';
-import type { QueryResult } from '@cyberismo/data-handler/types/queries';
+import type { QueryResult, ProjectErrors } from '@cyberismo/model';
 import { toSSG } from 'hono/ssg';
 import type { TreeOptions } from './types.js';
 import {
   findAllCards,
   findRelevantAttachments,
 } from './domain/cards/service.js';
+import { CARD_ROUTES_PER_KEY } from './domain/cards/lib.js';
 
 export interface ExportSiteOptions extends TreeOptions {
   defaultProject?: string;
 }
 
 const _cardQueryCache = new Map<string, Promise<QueryResult<'card'>[]>>();
+/** Label for errors from routes that belong to no project. */
+const SHARED_ROUTES = '(shared)';
 const OVERHEAD_CALLS = 6; // estimated number of overhead calls during export in addition to card exports
 
 /**
@@ -45,19 +41,19 @@ export function reset() {
 /**
  * Get the card query result for a given card key. Should only be called during
  * static site generation
- * @param commands - CommandManager instance for the project.
+ * @param ws - Handle of the project.
  * @param cardKey - Key of the card to get the query result for.
  * @returns The card query result for the given card key.
  */
 export async function getCardQueryResult(
-  commands: CommandManager,
+  ws: Workspace,
   cardKey?: string,
 ): Promise<QueryResult<'card'>[]> {
-  const prefix = commands.project.configuration.cardKeyPrefix;
+  const prefix = ws.settings.prefix;
   if (!_cardQueryCache.has(prefix)) {
     _cardQueryCache.set(
       prefix,
-      commands.calculateCmd.runQuery('card', 'exportedSite', {}),
+      ws.queries.runQuery('card', 'exportedSite', {}),
     );
   }
   return _cardQueryCache.get(prefix)!.then((results) => {
@@ -75,21 +71,21 @@ export async function getCardQueryResult(
 /**
  * Export the site to a given directory.
  * Note: Do not call this function in parallel.
- * @param registry - ProjectRegistry holding all project CommandManagers.
+ * @param directory - Directory the exported projects are opened from.
  * @param exportDir - Directory to export to.
  * @param options - Export options.
  * @param options.recursive - Whether to export cards recursively.
  * @param options.cardKey - Key of the card to export. If not provided, all cards will be exported.
  * @param options.defaultProject - Default project prefix to write into config.json.
  * @param onProgress - Optional progress callback function.
- * @returns An object containing any errors that occurred during export.
+ * @returns Errors that occurred during export, grouped by project.
  */
 export async function exportSite(
-  registry: ProjectRegistry,
+  directory: ProjectDirectory,
   exportDir?: string,
   options?: ExportSiteOptions,
   onProgress?: (current: number, total: number) => void,
-): Promise<{ errors: string[] }> {
+): Promise<{ errors: ProjectErrors[] }> {
   exportDir = exportDir || 'static';
   const { defaultProject, ...treeOpts } = options ?? {};
   const opts: TreeOptions = {
@@ -97,12 +93,10 @@ export async function exportSite(
     ...treeOpts,
   };
 
-  if (defaultProject && !registry.has(defaultProject)) {
+  const prefixes = (await directory.list()).map((p) => p.prefix);
+  if (defaultProject && !prefixes.includes(defaultProject)) {
     throw new Error(
-      `Default project '${defaultProject}' is not in the registry. Available: ${registry
-        .list()
-        .map((p) => p.prefix)
-        .join(', ')}`,
+      `Default project '${defaultProject}' is not in the registry. Available: ${prefixes.join(', ')}`,
     );
   }
 
@@ -110,7 +104,7 @@ export async function exportSite(
     process.env.CYBERISMO_DEFAULT_PROJECT = defaultProject;
   }
 
-  const app = createApp(new MockAuthProvider(), registry, opts, true);
+  const app = createApp(new MockAuthProvider(), directory, opts, prefixes);
 
   // copy whole frontend to the same directory
   await cp(staticFrontendDirRelative, exportDir, { recursive: true });
@@ -119,56 +113,71 @@ export async function exportSite(
 
   // estimate total based on the number of cards to export across all projects
   let total = OVERHEAD_CALLS;
-  for (const commands of registry.values()) {
-    const cards = await findAllCards(commands, opts);
-    const attachments = await findRelevantAttachments(commands, opts);
-    total += cards.length + attachments.length;
+  for (const prefix of prefixes) {
+    const ws = await directory.open(prefix, SYSTEM_ACTOR);
+    const cards = await findAllCards(ws, opts);
+    const attachments = await findRelevantAttachments(ws, opts);
+    total += cards.length * CARD_ROUTES_PER_KEY + attachments.length;
   }
 
-  // Actual export with progress reporting
+  // One pass per project so an error is attributed to the project whose route
+  // produced it (the response itself carries no project). Shared routes get
+  // their own pass so each route is emitted exactly once.
+  const projectOf = (pathname: string) =>
+    prefixes.find((p) => {
+      const base = `/api/projects/${p}`;
+      return pathname === base || pathname.startsWith(`${base}/`);
+    });
+
   let done = 0;
   onProgress?.(done, total);
-  const errors: string[] = [];
-  await toSSG(app, fs, {
-    dir: exportDir,
-    concurrency: 5,
-    plugins: [
-      {
-        beforeRequestHook: (req) => {
-          const url = new URL(req.url);
-          // Skip MCP routes — they require session state and are not part of the static site
-          if (url.pathname.startsWith('/mcp')) {
-            return false;
-          }
-          // Skip OIDC/well-known routes — not relevant for static export
-          if (url.pathname.startsWith('/.well-known')) {
-            return false;
-          }
-          return req;
-        },
-        afterResponseHook: async (response) => {
-          if (![200, 201, 204].includes(response.status)) {
-            const error = await response.json();
-            if (
-              typeof error === 'object' &&
-              error != null &&
-              'error' in error &&
-              typeof error.error === 'string'
-            ) {
-              errors.push(error.error);
+  const errors: ProjectErrors[] = [];
+  for (const scope of [undefined, ...prefixes]) {
+    const scopeErrors: string[] = [];
+    await toSSG(app, fs, {
+      dir: exportDir,
+      concurrency: 5,
+      plugins: [
+        {
+          beforeRequestHook: (req) => {
+            const url = new URL(req.url);
+            // Skip MCP routes — they require session state and are not part of the static site
+            if (url.pathname.startsWith('/mcp')) {
+              return false;
+            }
+            // Skip OIDC/well-known routes — not relevant for static export
+            if (url.pathname.startsWith('/.well-known')) {
+              return false;
             }
-            return false; // ignore route
-          }
-          done++;
-          if (done > total) {
-            total = done; // adjust total if underestimated
-          }
-          onProgress?.(done, total);
-          return response;
+            return projectOf(url.pathname) === scope ? req : false;
+          },
+          afterResponseHook: async (response) => {
+            if (![200, 201, 204].includes(response.status)) {
+              const error = await response.json();
+              if (
+                typeof error === 'object' &&
+                error != null &&
+                'error' in error &&
+                typeof error.error === 'string'
+              ) {
+                scopeErrors.push(error.error);
+              }
+              return false; // ignore route
+            }
+            done++;
+            if (done > total) {
+              total = done; // adjust total if underestimated
+            }
+            onProgress?.(done, total);
+            return response;
+          },
         },
-      },
-    ],
-  });
+      ],
+    });
+    if (scopeErrors.length > 0) {
+      errors.push({ prefix: scope ?? SHARED_ROUTES, errors: scopeErrors });
+    }
+  }
   return {
     errors,
   };

package/src/index.ts

@@ -1,33 +1,23 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
-import { serve } from '@hono/node-server';
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import type { Env, Schema } from 'hono';
 import { Hono } from 'hono';
 import { serveStatic } from '@hono/node-server/serve-static';
 import path from 'node:path';
 import { readFile } from 'node:fs/promises';
-import { findFreePort } from './utils.js';
+import { listen } from './utils.js';
+import { startPolicyPolling } from './overlay.js';
 import { createApp } from './app.js';
 import type { AuthProvider } from './auth/types.js';
-import type { ProjectRegistry } from './project-registry.js';
+import type { ProjectDirectory } from '@cyberismo/data-handler';
 export { MockAuthProvider } from './auth/mock.js';
 export type { MockUserConfig } from './auth/mock.js';
 export type { AuthProvider } from './auth/types.js';
 export { exportSite, type ExportSiteOptions } from './export.js';
-export { ProjectRegistry } from './project-registry.js';
 
 const DEFAULT_PORT = 3000;
-const DEFAULT_MAX_PORT = DEFAULT_PORT + 100;
+const MAX_PORT_ATTEMPTS = 100;
 
 /**
  * Preview the exported site
@@ -45,59 +35,53 @@ export async function previewSite(dir: string, findPort: boolean = true) {
     return c.html(file.toString());
   });
 
-  let port = parseInt(process.env.PORT || DEFAULT_PORT.toString(), 10);
-
-  if (findPort) {
-    port = await findFreePort(port, DEFAULT_MAX_PORT);
-  }
-  startApp(app, port);
+  const port = parseInt(process.env.PORT || DEFAULT_PORT.toString(), 10);
+  await startApp(app, port, findPort);
 }
 
 /**
  * Start the server
  * @param authProvider - Authentication provider
- * @param registry - ProjectRegistry holding all project CommandManagers
+ * @param directory - Directory the projects are opened from
  * @param findPort - If true, find a free port
  */
 export async function startServer(
   authProvider: AuthProvider,
-  registry: ProjectRegistry,
+  directory: ProjectDirectory,
   findPort: boolean = true,
   multiProjectRoot?: string,
 ) {
   const useOsAssigned = process.env.CYBERISMO_E2E_OSPORT === 'true';
-  let port = useOsAssigned
+  const port = useOsAssigned
     ? 0
     : parseInt(process.env.PORT || DEFAULT_PORT.toString(), 10);
-  if (findPort && !useOsAssigned) {
-    port = await findFreePort(port, DEFAULT_MAX_PORT);
-  }
+  startPolicyPolling(async () =>
+    (await directory.list()).map((p) => ({ prefix: p.prefix })),
+  );
   const app = createApp(
     authProvider,
-    registry,
+    directory,
+    undefined,
     undefined,
-    false,
     multiProjectRoot,
   );
-  startApp(app, port);
+  await startApp(app, port, findPort && !useOsAssigned);
 }
 
-function startApp<E extends Env, S extends Schema, P extends string>(
+async function startApp<E extends Env, S extends Schema, P extends string>(
   app: Hono<E, S, P>,
   port: number,
+  findPort: boolean,
 ) {
-  serve(
-    {
-      fetch: app.fetch,
-      port: port,
-      hostname: process.env.HOST || '127.0.0.1',
-    },
-    (info) => {
-      console.log(`Running Cyberismo app on http://localhost:${info.port}`);
-      console.log('Press Control+C to stop.');
-      // When spawned with stdio: [..., 'ipc'], publish the bound port to the parent.
-      // No-op in normal startup (process.send is undefined without an IPC channel).
-      process.send?.({ type: 'listening', port: info.port });
-    },
+  const bound = await listen(
+    app.fetch,
+    port,
+    process.env.HOST || '127.0.0.1',
+    findPort ? port + MAX_PORT_ATTEMPTS : port,
   );
+  console.log(`Running Cyberismo app on http://localhost:${bound.port}`);
+  console.log('Press Control+C to stop.');
+  // When spawned with stdio: [..., 'ipc'], publish the bound port to the parent.
+  // No-op in normal startup (process.send is undefined without an IPC channel).
+  process.send?.({ type: 'listening', port: bound.port });
 }