@cyberismo/backend 1.2.0 → 1.3.1

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,32 +1,25 @@
-/**
-  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 type { ProjectErrors } from './project-errors.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;
@@ -48,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) => {
@@ -78,7 +71,7 @@ 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.
@@ -88,7 +81,7 @@ export async function getCardQueryResult(
  * @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,
@@ -100,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(', ')}`,
     );
   }
 
@@ -113,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 });
@@ -122,16 +113,16 @@ 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;
   }
 
   // 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 prefixes = registry.list().map((p) => p.prefix);
   const projectOf = (pathname: string) =>
     prefixes.find((p) => {
       const base = `/api/projects/${p}`;

package/src/frontend.ts

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import type { Context, MiddlewareHandler } from 'hono';
+import { every } from 'hono/combine';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { readFile } from 'node:fs/promises';
+
+/**
+ * index.html names the hashed bundles of one build, so the browser must
+ * revalidate it on every load. A cached copy from an earlier build would
+ * request bundles that no longer exist and leave the page blank.
+ */
+export const INDEX_CACHE_CONTROL = 'no-cache';
+
+/** Bundles under /assets/ carry a content hash, so they never change. */
+export const ASSET_CACHE_CONTROL = 'public, max-age=31536000, immutable';
+
+/** True for paths of the hashed bundles Vite emits. */
+export function isAssetPath(requestPath: string): boolean {
+  return requestPath.startsWith('/assets/');
+}
+
+/**
+ * Serves the built frontend from `root`, with cache headers that keep a
+ * browser from pairing an old index.html with a newer build.
+ */
+export function serveFrontend(root: string): MiddlewareHandler {
+  // Only files served from disk get these headers, not the responses of
+  // later handlers that serveStatic falls through to.
+  const servedFromDisk = new WeakSet<Context>();
+  return every(
+    async (c, next) => {
+      await next();
+      if (!servedFromDisk.has(c)) return;
+      if (c.res.headers.get('Content-Type')?.startsWith('text/html')) {
+        c.res.headers.set('Cache-Control', INDEX_CACHE_CONTROL);
+      } else if (isAssetPath(c.req.path)) {
+        c.res.headers.set('Cache-Control', ASSET_CACHE_CONTROL);
+      }
+    },
+    serveStatic({ root, onFound: (_path, c) => void servedFromDisk.add(c) }),
+  );
+}
+
+/**
+ * Answers a path that matched no route and no file. Client-side routes get
+ * index.html; a missing bundle gets a 404, since index.html served as a
+ * script fails to load and leaves the page blank.
+ */
+export async function frontendFallback(c: Context, indexPath: string) {
+  if (isAssetPath(c.req.path)) {
+    return c.text('Not Found', 404);
+  }
+  const file = await readFile(indexPath);
+  c.header('Cache-Control', INDEX_CACHE_CONTROL);
+  return c.html(file.toString());
+}

package/src/index.ts

@@ -1,35 +1,22 @@
-/**
-  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 { frontendFallback, serveFrontend } from './frontend.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';
-export { formatProjectErrors, type ProjectErrors } from './project-errors.js';
 
 const DEFAULT_PORT = 3000;
-const DEFAULT_MAX_PORT = DEFAULT_PORT + 100;
+const MAX_PORT_ATTEMPTS = 100;
 
 /**
  * Preview the exported site
@@ -38,69 +25,61 @@ const DEFAULT_MAX_PORT = DEFAULT_PORT + 100;
  */
 export async function previewSite(dir: string, findPort: boolean = true) {
   const app = new Hono();
-  app.use(serveStatic({ root: dir }));
+  app.use(serveFrontend(dir));
   app.get('*', async (c) => {
     if (c.req.path.startsWith('/api/')) {
       return c.json({ error: 'Resource not found' }, 404);
     }
-    const file = await readFile(path.join(dir, 'index.html'));
-    return c.html(file.toString());
+    return frontendFallback(c, path.join(dir, 'index.html'));
   });
 
-  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(() => registry.list().map((p) => ({ prefix: p.prefix })));
+  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 });
 }

package/src/main.ts

@@ -1,23 +1,13 @@
-/**
-  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 { scanForProjects } from '@cyberismo/data-handler';
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { localFolder } from '@cyberismo/data-handler';
 import { startServer } from './index.js';
 import { exportSite } from './export.js';
 import { MockAuthProvider } from './auth/mock.js';
 import { KeycloakAuthProvider } from './auth/keycloak.js';
 import type { AuthProvider } from './auth/types.js';
-import { ProjectRegistry } from './project-registry.js';
-import { formatProjectErrors } from './project-errors.js';
+import { formatProjectErrors } from '@cyberismo/model';
 import { gitOptionsFromEnv } from './utils.js';
 import { parseArgs } from 'node:util';
 import dotenv from 'dotenv';
@@ -60,9 +50,21 @@ function createAuthProvider(): AuthProvider {
 }
 
 const projectPath = process.env.npm_config_project_path || process.cwd();
-let projects;
+
+const { values: args } = parseArgs({
+  options: {
+    export: { type: 'boolean', default: false },
+    'default-project': { type: 'string' },
+  },
+  strict: false,
+});
+
+let opened;
 try {
-  projects = await scanForProjects(projectPath);
+  opened = await localFolder(
+    projectPath,
+    args.export ? undefined : gitOptionsFromEnv(),
+  );
 } catch (error) {
   console.error(
     error instanceof Error
@@ -71,17 +73,11 @@ try {
   );
   process.exit(1);
 }
-
-const { values: args } = parseArgs({
-  options: {
-    export: { type: 'boolean', default: false },
-    'default-project': { type: 'string' },
-  },
-  strict: false,
-});
+const { directory, failed } = opened;
 
 if (args.export) {
-  if (projects.length === 0) {
+  const projects = await directory.list();
+  if (projects.length === 0 && failed.length === 0) {
     console.error('No projects found to export.');
     process.exit(1);
   }
@@ -89,16 +85,14 @@ if (args.export) {
     typeof args['default-project'] === 'string'
       ? args['default-project']
       : undefined;
-  const { registry, failed } =
-    await ProjectRegistry.fromScannedProjects(projects);
   if (
-    registry.list().length === 0 ||
+    projects.length === 0 ||
     failed.some((f) => f.prefix === defaultProject)
   ) {
     console.error(formatProjectErrors(failed));
     process.exit(1);
   }
-  const { errors: exportErrors } = await exportSite(registry, undefined, {
+  const { errors: exportErrors } = await exportSite(directory, undefined, {
     defaultProject,
   });
   const errors = [...failed, ...exportErrors];
@@ -107,13 +101,9 @@ if (args.export) {
     process.exit(1);
   }
 } else {
-  const { registry, failed } = await ProjectRegistry.fromScannedProjects(
-    projects,
-    gitOptionsFromEnv(),
-  );
   if (failed.length > 0) {
     console.error(formatProjectErrors(failed));
   }
   const authProvider = createAuthProvider();
-  await startServer(authProvider, registry, true, projectPath);
+  await startServer(authProvider, directory, true, projectPath);
 }

package/src/middleware/auth.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2026
-  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 { Context, MiddlewareHandler } from 'hono';
 import type { UserInfo } from '../types.js';

package/src/middleware/commandManager.ts

@@ -1,81 +1,66 @@
-/**
-    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 { Context, MiddlewareHandler } from 'hono';
-import type { CommandManager } from '@cyberismo/data-handler';
+import type { ActorRef } from '@cyberismo/model';
+import type { ProjectDirectory, Workspace } from '@cyberismo/data-handler';
 import { getCurrentUser } from './auth.js';
-import type { ProjectRegistry } from '../project-registry.js';
+import { UserRole, type UserInfo } from '../types.js';
 import type { ProjectEvents } from '../domain/events/project-events.js';
+import type { EventsByProject } from '../domain/events/events-by-project.js';
 
 // Extend Hono Context type to include our custom properties
 declare module 'hono' {
   interface ContextVariableMap {
-    commands: CommandManager;
+    ws: Workspace;
     events: ProjectEvents;
     projectPath: string;
-    registry: ProjectRegistry;
+    directory: ProjectDirectory;
+    eventsByProject: EventsByProject;
   }
 }
 
-/**
- * Set CommandManager on context and run the next handler as the authenticated user.
- */
-async function runWithCommands(
-  c: Context,
-  commands: CommandManager,
-  next: () => Promise<void>,
-) {
-  const user = getCurrentUser(c);
-  if (!user) {
-    throw new Error('CommandManager expects a user');
-  }
-  c.set('commands', commands);
-  c.set('projectPath', commands.project.basePath);
-  await commands.runAsAuthor({ name: user.name, email: user.email }, () =>
-    next(),
-  );
+/** The actor a user acts as. */
+export function actorOf(user: UserInfo): ActorRef {
+  return {
+    kind: user.role === UserRole.Connector ? 'connector' : 'user',
+    id: user.id,
+    name: user.name,
+  };
 }
 
-// TODO: Remove once MCP is made project-scoped via attachProjectRegistry
-export const attachCommandManager = (
-  commands: CommandManager,
-): MiddlewareHandler => {
-  return (c, next) => runWithCommands(c, commands, next);
-};
-
 /**
- * Middleware that resolves the project from the registry and sets the
- * CommandManager on context.
+ * Middleware that opens the authenticated user's handle over the project
+ * and puts it, with the project's events and the directory, on the context.
+ * An unknown project is refused with ProjectNotFoundError (404).
  *
- * @param registry - Project registry to look up projects.
+ * @param directory - Directory the project is opened from.
+ * @param events - Events of the directory's projects.
  * @param fixedPrefix - When provided, used instead of the `:prefix` route
  *   param. This is needed in export/SSG mode where routes are mounted at
  *   concrete paths (e.g. `/api/projects/decision/...`) with no dynamic param.
  */
-export const attachProjectRegistry = (
-  registry: ProjectRegistry,
+export const attachProjectDirectory = (
+  directory: ProjectDirectory,
+  events: EventsByProject,
   fixedPrefix?: string,
 ): MiddlewareHandler => {
   return async (c: Context, next) => {
-    c.set('registry', registry);
     const prefix = c.req.param('prefix') ?? fixedPrefix;
     if (!prefix) {
       return c.json({ error: 'Project prefix is required' }, 400);
     }
-    const commands = registry.get(prefix);
-    if (!commands) {
-      return c.json({ error: `Project '${prefix}' not found` }, 404);
+    const user = getCurrentUser(c);
+    if (!user) {
+      throw new Error('A project handle expects a user');
     }
-    c.set('events', registry.eventsFor(commands));
-    return runWithCommands(c, commands, next);
+    const identity = { name: user.name, email: user.email };
+    const ws = await directory.open(prefix, actorOf(user), identity);
+    c.set('directory', directory);
+    c.set('eventsByProject', events);
+    c.set('events', await events.for(prefix));
+    c.set('ws', ws);
+    c.set('projectPath', ws.path);
+    await next();
   };
 };

package/src/middleware/tree.ts

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import type { Next } from 'hono';
 import type { AppContext, TreeOptions } from '../types.js';
 

package/src/middleware/zvalidator.ts

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import { zValidator as zv } from '@hono/zod-validator';
 import type { ZodType } from 'zod';
 import type { ValidationTargets } from 'hono';