@cyberismo/backend 0.0.26 → 1.0.0

package/src/domain/projects/index.ts

@@ -12,11 +12,17 @@
 */
 
 import { Hono } from 'hono';
+import { zValidator } from '../../middleware/zvalidator.js';
 import type { ProjectRegistry } from '../../project-registry.js';
-import { requireRole } from '../../middleware/auth.js';
+import { requireRole, getCurrentUser } from '../../middleware/auth.js';
 import { UserRole } from '../../types.js';
+import { createProjectSchema, cloneProjectSchema } from './schema.js';
+import * as projectsService from './service.js';
 
-export function createProjectsRouter(registry: ProjectRegistry) {
+export function createProjectsRouter(
+  registry: ProjectRegistry,
+  multiProjectRoot?: string,
+) {
   const router = new Hono();
 
   /**
@@ -32,8 +38,114 @@ export function createProjectsRouter(registry: ProjectRegistry) {
    *         description: Unauthorized
    */
   router.get('/', requireRole(UserRole.Reader), (c) => {
-    return c.json(registry.list());
+    return c.json({
+      projects: registry.list(),
+      canCreateProjects: !!multiProjectRoot,
+    });
   });
 
+  /**
+   * @swagger
+   * /api/projects:
+   *   post:
+   *     summary: Create a new project
+   *     description: Creates a new project on disk, initializes git, adds default hub
+   */
+  router.post(
+    '/',
+    requireRole(UserRole.Editor),
+    zValidator('json', createProjectSchema),
+    async (c) => {
+      if (!multiProjectRoot) {
+        return c.json(
+          { error: 'Project creation is not available in single-project mode' },
+          403,
+        );
+      }
+
+      const params = c.req.valid('json');
+
+      if (registry.has(params.prefix)) {
+        return c.json(
+          { error: `Project with prefix '${params.prefix}' already exists` },
+          409,
+        );
+      }
+
+      try {
+        const result = await projectsService.createProject(
+          registry,
+          multiProjectRoot,
+          params,
+          getCurrentUser(c),
+        );
+        return c.json(result, 201);
+      } catch (error) {
+        return c.json(
+          {
+            error:
+              error instanceof Error
+                ? error.message
+                : 'Failed to create project',
+          },
+          500,
+        );
+      }
+    },
+  );
+
+  /**
+   * @swagger
+   * /api/projects/clone:
+   *   post:
+   *     summary: Clone a project from a git repository
+   *     description: Clones a git repo and registers discovered projects
+   */
+  router.post(
+    '/clone',
+    requireRole(UserRole.Editor),
+    zValidator('json', cloneProjectSchema),
+    async (c) => {
+      if (!multiProjectRoot) {
+        return c.json(
+          { error: 'Project cloning is not available in single-project mode' },
+          403,
+        );
+      }
+
+      const { url } = c.req.valid('json');
+
+      try {
+        const result = await projectsService.cloneProject(
+          registry,
+          multiProjectRoot,
+          url,
+        );
+
+        if (result.projects.length === 0) {
+          return c.json(
+            {
+              error: 'All projects in the cloned repository already exist',
+              skippedDuplicates: result.skippedDuplicates,
+            },
+            409,
+          );
+        }
+
+        return c.json(result, 201);
+      } catch (error) {
+        return c.json(
+          {
+            error:
+              error instanceof Error
+                ? error.message
+                : 'Failed to clone repository',
+          },
+          500,
+        );
+      }
+    },
+  );
+
   return router;
 }

package/src/domain/projects/schema.ts

@@ -0,0 +1,42 @@
+/**
+  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/>.
+*/
+
+import { z } from 'zod';
+import { Validate } from '@cyberismo/data-handler';
+
+export const createProjectSchema = z.object({
+  name: z
+    .string()
+    .min(1, 'Project name is required')
+    .refine((s) => Validate.isValidProjectName(s), {
+      message: 'Invalid project name',
+    }),
+  prefix: z
+    .string()
+    .min(3, 'Prefix must be at least 3 characters')
+    .max(10, 'Prefix must be at most 10 characters')
+    .refine((s) => Validate.validatePrefix(s), {
+      message: 'Prefix must contain only lowercase letters',
+    }),
+  category: z.string().optional().default(''),
+  description: z.string().optional().default(''),
+});
+
+export const cloneProjectSchema = z.object({
+  url: z
+    .string()
+    .min(1, 'Repository URL is required')
+    .refine((s) => s.startsWith('https://') || s.startsWith('git@'), {
+      message: 'URL must start with https:// or git@',
+    }),
+});

package/src/domain/projects/service.ts

@@ -0,0 +1,98 @@
+/**
+  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/>.
+*/
+
+import { join } from 'node:path';
+import {
+  CommandManager,
+  Create,
+  scanForProjects,
+} from '@cyberismo/data-handler';
+import type { ProjectRegistry } from '../../project-registry.js';
+
+export interface CreateProjectParams {
+  name: string;
+  prefix: string;
+  category?: string;
+  description?: string;
+}
+
+export interface CreateProjectResult {
+  prefix: string;
+  name: string;
+  category?: string;
+  description?: string;
+}
+
+export async function createProject(
+  registry: ProjectRegistry,
+  rootPath: string,
+  params: CreateProjectParams,
+  user?: { name: string; email: string } | null,
+): Promise<CreateProjectResult> {
+  const { name, prefix, category, description } = params;
+  const projectPath = join(rootPath, prefix);
+
+  const commands = await CommandManager.createProjectWithDefaults(
+    projectPath,
+    params,
+    {
+      ...registry.options,
+      gitUser: user ?? undefined,
+    },
+  );
+
+  registry.add(prefix, commands);
+
+  return {
+    prefix,
+    name,
+    category: category || undefined,
+    description: description || undefined,
+  };
+}
+
+export interface CloneProjectResult {
+  projects: { prefix: string; name: string }[];
+  skippedDuplicates?: string[];
+}
+
+export async function cloneProject(
+  registry: ProjectRegistry,
+  rootPath: string,
+  url: string,
+): Promise<CloneProjectResult> {
+  const clonedPath = await Create.cloneProject(url, rootPath);
+  const scanned = await scanForProjects(clonedPath);
+
+  const registered: { prefix: string; name: string }[] = [];
+  const skippedDuplicates: string[] = [];
+
+  for (const project of scanned) {
+    if (registry.has(project.prefix)) {
+      skippedDuplicates.push(project.prefix);
+      continue;
+    }
+    const commands = new CommandManager(project.path, registry.options);
+    await commands.initialize();
+    registry.add(project.prefix, commands);
+    registered.push({
+      prefix: project.prefix,
+      name: project.name,
+    });
+  }
+
+  return {
+    projects: registered,
+    ...(skippedDuplicates.length > 0 && { skippedDuplicates }),
+  };
+}

package/src/domain/resources/index.ts

@@ -12,8 +12,9 @@
 */
 
 import { Hono } from 'hono';
+import { ssgParams } from 'hono/ssg';
 import * as resourceService from './service.js';
-import type { ResourceValidationResponse } from '../../types.js';
+import type { AppContext, ResourceValidationResponse } from '../../types.js';
 import { UserRole } from '../../types.js';
 import { resourceParamsSchema } from '../../common/validationSchemas.js';
 import { zValidator } from '../../middleware/zvalidator.js';
@@ -183,6 +184,10 @@ router.delete(
 router.get(
   '/:prefix/workflows/:identifier/graph',
   requireRole(UserRole.Reader),
+  ssgParams(async (c: AppContext) => {
+    const commands = c.get('commands');
+    return resourceService.listWorkflowGraphParams(commands);
+  }),
   zValidator('param', workflowGraphParamsSchema),
   zValidator('query', workflowGraphQuerySchema),
   async (c) => {

package/src/domain/resources/service.ts

@@ -469,6 +469,21 @@ export async function validateResource(
   };
 }
 
+/**
+ * Lists the path params for every workflow resource in the project.
+ * @param commands Command manager.
+ * @returns One `{ prefix, identifier }` entry per workflow resource.
+ */
+export async function listWorkflowGraphParams(
+  commands: CommandManager,
+): Promise<{ prefix: string; identifier: string }[]> {
+  const workflows = await commands.showCmd.showResources('workflows');
+  return workflows.map((name) => {
+    const { prefix, identifier } = resourceName(name);
+    return { prefix, identifier };
+  });
+}
+
 /**
  * Renders the built-in state-machine graph for a single workflow.
  * When `cardKey` is provided, the card's current workflowState is

package/src/export.ts

@@ -11,15 +11,13 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
-import path from 'node:path';
-
-import fs, { readFile } from 'node:fs/promises';
+import fs from 'node:fs/promises';
 
 import type { CommandManager } from '@cyberismo/data-handler';
 import { createApp } from './app.js';
 import { MockAuthProvider } from './auth/mock.js';
 import type { ProjectRegistry } from './project-registry.js';
-import { cp, writeFile } from 'node:fs/promises';
+import { cp } from 'node:fs/promises';
 import { staticFrontendDirRelative } from './utils.js';
 import type { QueryResult } from '@cyberismo/data-handler/types/queries';
 import { toSSG } from 'hono/ssg';
@@ -108,21 +106,14 @@ export async function exportSite(
     );
   }
 
+  if (defaultProject) {
+    process.env.CYBERISMO_DEFAULT_PROJECT = defaultProject;
+  }
+
   const app = createApp(new MockAuthProvider(), registry, opts, true);
 
   // copy whole frontend to the same directory
   await cp(staticFrontendDirRelative, exportDir, { recursive: true });
-  // read config file and change export to true
-  const config = await readFile(path.join(exportDir, 'config.json'), 'utf-8');
-  const configJson = JSON.parse(config);
-  configJson.staticMode = true;
-  if (defaultProject) {
-    configJson.defaultProject = defaultProject;
-  }
-  await writeFile(
-    path.join(exportDir, 'config.json'),
-    JSON.stringify(configJson),
-  );
 
   reset();
 

package/src/index.ts

@@ -64,13 +64,22 @@ export async function startServer(
   authProvider: AuthProvider,
   registry: ProjectRegistry,
   findPort: boolean = true,
+  multiProjectRoot?: string,
 ) {
-  let port = parseInt(process.env.PORT || DEFAULT_PORT.toString(), 10);
-
-  if (findPort) {
+  const useOsAssigned = process.env.CYBERISMO_E2E_OSPORT === 'true';
+  let port = useOsAssigned
+    ? 0
+    : parseInt(process.env.PORT || DEFAULT_PORT.toString(), 10);
+  if (findPort && !useOsAssigned) {
     port = await findFreePort(port, DEFAULT_MAX_PORT);
   }
-  const app = createApp(authProvider, registry);
+  const app = createApp(
+    authProvider,
+    registry,
+    undefined,
+    false,
+    multiProjectRoot,
+  );
   startApp(app, port);
 }
 
@@ -87,6 +96,9 @@ function startApp<E extends Env, S extends Schema, P extends string>(
     (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 });
     },
   );
 }

package/src/main.ts

@@ -91,16 +91,10 @@ if (args.export) {
         : undefined,
   });
 } else {
-  if (projects.length === 0) {
-    console.error(
-      `No projects found in "${projectPath}". Cannot start the server without at least one project.`,
-    );
-    process.exit(1);
-  }
   const autocommit = process.env.CYBERISMO_AUTOCOMMIT === 'true';
   const registry = await ProjectRegistry.fromScannedProjects(projects, {
     autocommit,
   });
   const authProvider = createAuthProvider();
-  await startServer(authProvider, registry);
+  await startServer(authProvider, registry, true, projectPath);
 }

package/src/project-registry.ts

@@ -34,8 +34,13 @@ export interface ScannedProject {
 
 export class ProjectRegistry implements ProjectProvider {
   private projects: Map<string, CommandManager> = new Map();
+  readonly options: ConstructorParameters<typeof CommandManager>[1];
 
-  constructor(entries: ProjectRegistryEntry[] = []) {
+  constructor(
+    entries: ProjectRegistryEntry[] = [],
+    options?: ConstructorParameters<typeof CommandManager>[1],
+  ) {
+    this.options = options;
     for (const entry of entries) {
       this.add(entry.prefix, entry.commands);
     }
@@ -82,6 +87,21 @@ export class ProjectRegistry implements ProjectProvider {
     this.projects.clear();
   }
 
+  /**
+   * Replace all registered projects atomically. Disposes existing
+   * CommandManagers, then installs the new entries. Used by the test-mode
+   * reset endpoint to swap project state without restarting the Hono app.
+   */
+  async replace(entries: ProjectRegistryEntry[]): Promise<void> {
+    for (const commands of this.projects.values()) {
+      commands.project.dispose();
+    }
+    this.projects.clear();
+    for (const entry of entries) {
+      this.projects.set(entry.prefix, entry.commands);
+    }
+  }
+
   /**
    * Create a single-project registry from a CommandManager.
    * Used by export mode and tests where only one project is needed.
@@ -105,6 +125,6 @@ export class ProjectRegistry implements ProjectProvider {
       await commands.initialize();
       entries.push({ prefix: project.prefix, commands });
     }
-    return new ProjectRegistry(entries);
+    return new ProjectRegistry(entries, options);
   }
 }

package/dist/public/assets/architecture-7EHR7CIX-BhpB9ddF.js

@@ -1 +0,0 @@
-import{x as e}from"./mermaid-parser.core-Dz__fM3g.js";export{e as createArchitectureServices};