@mettlecast/domain-cli 0.2.2 → 0.2.3

package/src/commands/add-page.ts

@@ -1,11 +1,7 @@
-import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
-import { join, resolve, dirname, basename } from 'node:path';
+import { writeFile, mkdir, access } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { Readable } from 'node:stream';
-import { Parser as TarParser } from 'tar';
 import { cliLogger } from '../utils/logger.js';
-import { readScaffoldConfig } from '../utils/scaffold-config.js';
-import { fetchModulesJson, fetchModuleTarball } from '../utils/s3-fetch.js';
 import {
   type PagePattern,
   PAGE_PATTERNS,
@@ -17,9 +13,6 @@ import {
   settingsPageTemplate,
 } from '../templates/patterns/page/index.js';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const TEMPLATES_DIR = resolve(__dirname, '..', 'templates', 'dashboard-pages');
-
 /** Map from pattern name to its template function. */
 const PATTERN_TEMPLATES: Record<PagePattern, (name: string) => string> = {
   list: listPageTemplate,
@@ -44,94 +37,6 @@ export interface AddPageOptions {
   layout?: 'app' | 'auth';
 }
 
-interface PageEntry {
-  id: string;
-  category: string;
-  path: string;
-  name: string;
-}
-
-async function loadRegistry(): Promise<PageEntry[]> {
-  // Dynamic import avoids tsx compilation issues with .tsx templates
-  const mod = await import('../templates/dashboard-pages/index.js') as { PAGE_REGISTRY: readonly PageEntry[] };
-  return [...mod.PAGE_REGISTRY];
-}
-
-function getCategoryForPageId(pageId: string): string {
-  const authPages = ['login', 'signup', 'verify-email', 'forgot-password', 'reset-password', 'mfa-setup', 'mfa-verify', 'choose-org', 'accept-invitation', 'sign-out'];
-  const accountPages = ['profile', 'workspace-settings', 'members', 'api-keys', 'audit-log'];
-
-  if (authPages.includes(pageId)) return 'auth';
-  if (accountPages.includes(pageId)) return 'account';
-  return 'shell';
-}
-
-async function fetchPageFromS3(
-  scaffoldBucket: string,
-  scaffoldVersion: string,
-  pageId: string
-): Promise<string | null> {
-  try {
-    const modulesJson = await fetchModulesJson(scaffoldBucket, scaffoldVersion);
-    const frontendModule = modulesJson.modules.find(m => m.id === 'frontend');
-
-    if (!frontendModule) {
-      throw new Error(`Frontend module not found in modules.json for version ${scaffoldVersion}`);
-    }
-
-    const tarballBuffer = await fetchModuleTarball(
-      scaffoldBucket,
-      scaffoldVersion,
-      frontendModule.tarball,
-      frontendModule.sha256
-    );
-
-    // Extract the page file from the tarball
-    const pageFileName = `${pageId}.tsx`;
-    const category = getCategoryForPageId(pageId);
-    const expectedPath = `frontend/src/pages/${category}/${pageFileName}`;
-
-    let content = '';
-    const chunks: Buffer[] = [];
-
-    await new Promise<void>((resolve, reject) => {
-      const parser = new TarParser({
-        onentry: (entry) => {
-          if (entry.path === expectedPath) {
-            entry.on('data', (chunk: Buffer) => chunks.push(chunk));
-          } else {
-            entry.resume();
-          }
-        },
-      });
-      parser.on('finish', resolve);
-      parser.on('error', reject);
-      Readable.from(tarballBuffer).pipe(parser);
-    });
-
-    if (chunks.length === 0) {
-      throw new Error(`Page template not found at ${expectedPath} in frontend tarball`);
-    }
-
-    content = Buffer.concat(chunks).toString('utf-8');
-    return content;
-  } catch (err) {
-    cliLogger.warn(err, 'Failed to fetch from S3, falling back to local templates');
-    return null;
-  }
-}
-
-async function loadFromLocal(pageId: string, entry: PageEntry): Promise<string> {
-  const templatePath = join(TEMPLATES_DIR, entry.path);
-  try {
-    const content = await readFile(templatePath, 'utf8');
-    cliLogger.warn({ pageId }, 'Using local fallback template (scaffold version not available)');
-    return content;
-  } catch {
-    throw new Error(`Template file not found at ${templatePath}`);
-  }
-}
-
 export async function runAddPage(opts: AddPageOptions): Promise<void> {
   const { pageId, pattern, layout = 'app' } = opts;
 
@@ -139,86 +44,67 @@ export async function runAddPage(opts: AddPageOptions): Promise<void> {
     throw new Error(`Invalid page id "${pageId}" — must be kebab-case`);
   }
 
-  // ── Pattern mode ──
-  if (pattern) {
-    if (!PAGE_PATTERNS.includes(pattern)) {
-      const available = PAGE_PATTERNS.join(', ');
-      throw new Error(
-        `Unknown page pattern "${pattern}".\n\nAvailable patterns: ${available}`
-      );
-    }
-
-    const templateFn = PATTERN_TEMPLATES[pattern];
-    let content = templateFn(pageId);
-
-    // Prepend layout comment
-    const layoutComment = `// Layout: ${layout === 'auth' ? 'AuthLayout' : 'AppLayout'} — import and use in your router config\n\n`;
-    content = layoutComment + content;
-
-    const outDir = opts.outputDir
+  // ── .page.json output mode (default when no pattern specified) ──
+  if (!pattern) {
+    const pageJsonContent = JSON.stringify({
+      id: pageId,
+      type: 'page',
+      route: `/${pageId}`,
+      tenancy: layout === 'auth' ? 'none' : 'required',
+      title: pageId.replace(/-/g, ' ').replace(/\b\w/g, (c: string) => c.toUpperCase()),
+      layout: layout,
+      tokens: {},
+      regions: [],
+    }, null, 2) + '\n';
+
+    const pageJsonOutDir = opts.outputDir
       ? resolve(opts.outputDir)
-      : resolve(process.cwd(), 'src', 'pages', pageId);
+      : resolve(process.cwd(), 'pages');
 
-    await mkdir(outDir, { recursive: true });
+    await mkdir(pageJsonOutDir, { recursive: true });
+    const pageJsonPath = join(pageJsonOutDir, `${pageId}.page.json`);
 
-    const fileName = `${pageId}.tsx`;
-    const outPath = join(outDir, fileName);
-
-    // Refuse if target already exists
     try {
-      await access(outPath);
-      throw new Error(`File already exists at ${outPath}. Remove it first or use a different --output directory.`);
+      await access(pageJsonPath);
+      throw new Error(`File already exists at ${pageJsonPath}. Remove it first or use a different --output directory.`);
     } catch (err) {
       if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
     }
 
-    await writeFile(outPath, content, 'utf8');
+    await writeFile(pageJsonPath, pageJsonContent, 'utf8');
 
-    cliLogger.info({ pageId, pattern, layout, outPath }, 'Page scaffolded from pattern');
+    cliLogger.info({ pageId, layout, outPath: pageJsonPath }, 'Page .page.json scaffolded');
     // eslint-disable-next-line no-console
     console.log(
-      `\n✓ Page "${pageId}" (pattern: ${pattern}, layout: ${layout}) added at ${outPath}\n` +
-      `  Next: add a route in src/router.tsx for this page\n`
+      `\n✓ Page "${pageId}" (layout: ${layout}) added at ${pageJsonPath}\n` +
+      `  Next: add the page in the page builder UI or edit the .page.json directly.\n` +
+      `  To add a route, update src/router.tsx.tpl.\n`
     );
     return;
   }
 
-  // ── Registry mode (existing behaviour) ──
-  const registry = await loadRegistry();
-  const entry = registry.find(p => p.id === pageId);
-
-  if (!entry) {
-    const available = registry.map(p => p.id).join(', ');
+  // ── Pattern mode ──
+  if (!PAGE_PATTERNS.includes(pattern)) {
+    const available = PAGE_PATTERNS.join(', ');
     throw new Error(
-      `Unknown page id "${pageId}".\n\nAvailable pages: ${available}\n` +
-      `Tip: use --pattern <pattern> to scaffold with a page pattern. Available patterns: ${PAGE_PATTERNS.join(', ')}`
+      `Unknown page pattern "${pattern}".\n\nAvailable patterns: ${available}`
     );
   }
 
-  let content: string | null = null;
+  const templateFn = PATTERN_TEMPLATES[pattern];
+  let content = templateFn(pageId);
 
-  // Try S3 fetch first
-  try {
-    const config = await readScaffoldConfig(process.cwd());
-    if (config.scaffoldVersion && config.scaffoldBucket) {
-      content = await fetchPageFromS3(config.scaffoldBucket, config.scaffoldVersion, pageId);
-    }
-  } catch (err) {
-    cliLogger.debug(err, 'Could not read scaffold config');
-  }
-
-  // Fall back to local templates
-  if (!content) {
-    content = await loadFromLocal(pageId, entry);
-  }
+  // Prepend layout comment
+  const layoutComment = `// Layout: ${layout === 'auth' ? 'AuthLayout' : 'AppLayout'} — import and use in your router config\n\n`;
+  content = layoutComment + content;
 
   const outDir = opts.outputDir
     ? resolve(opts.outputDir)
-    : resolve(process.cwd(), 'src', 'pages', entry.category);
+    : resolve(process.cwd(), 'src', 'pages', pageId);
 
   await mkdir(outDir, { recursive: true });
 
-  const fileName = `${basename(entry.path)}`;
+  const fileName = `${pageId}.tsx`;
   const outPath = join(outDir, fileName);
 
   // Refuse if target already exists
@@ -231,12 +117,10 @@ export async function runAddPage(opts: AddPageOptions): Promise<void> {
 
   await writeFile(outPath, content, 'utf8');
 
-  cliLogger.info({ pageId, layout, outPath }, 'Page scaffolded');
+  cliLogger.info({ pageId, pattern, layout, outPath }, 'Page scaffolded from pattern');
   // eslint-disable-next-line no-console
   console.log(
-    `\n✓ Page "${pageId}" (layout: ${layout}) added at ${outPath}\n` +
-    `  Component: ${entry.name}\n` +
-    `  Next: import { ${entry.name} } from './${entry.category}/${basename(entry.path, '.tsx')}'\n` +
-    `  Then add a route in src/router.tsx\n`
+    `\n✓ Page "${pageId}" (pattern: ${pattern}, layout: ${layout}) added at ${outPath}\n` +
+    `  Next: add a route in src/router.tsx for this page\n`
   );
 }

package/src/commands/build-ui/component-scanner.ts

@@ -0,0 +1,70 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export interface ComponentManifestEntry {
+  id: string;
+  displayName: string;
+  filePath: string;
+  propsSchema: Record<string, unknown>;
+  fixture?: unknown;
+  category: 'ui' | 'custom';
+}
+
+function kebabToPascal(kebab: string): string {
+  return kebab
+    .split('-')
+    .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join('');
+}
+
+async function scanDir(dir: string, category: 'ui' | 'custom'): Promise<ComponentManifestEntry[]> {
+  const entries: ComponentManifestEntry[] = [];
+
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return entries;
+    }
+    throw err;
+  }
+
+  for (const file of files) {
+    if (file.endsWith('.tsx')) {
+      const id = file.slice(0, -4);
+      const displayName = kebabToPascal(id);
+      const filePath = join(dir, file);
+
+      const entry: ComponentManifestEntry = {
+        id,
+        displayName,
+        filePath,
+        propsSchema: {},
+        category,
+      };
+
+      const fixtureFilePath = join(dir, `${id}.fixture.json`);
+      try {
+        const fixtureContent = await readFile(fixtureFilePath, 'utf8');
+        entry.fixture = JSON.parse(fixtureContent);
+      } catch (err) {
+        // If fixture doesn't exist or can't be parsed, omit the field
+      }
+
+      entries.push(entry);
+    }
+  }
+
+  return entries;
+}
+
+export async function scanComponents(opts: {
+  uiDir: string;
+  customDir: string;
+}): Promise<ComponentManifestEntry[]> {
+  const uiEntries = await scanDir(opts.uiDir, 'ui');
+  const customEntries = await scanDir(opts.customDir, 'custom');
+
+  return [...uiEntries, ...customEntries];
+}

package/src/commands/build-ui/page-indexer.ts

@@ -0,0 +1,134 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+
+export interface PageRegistryEntry {
+  id: string;
+  route: string | null;
+  tenancy: string | null;
+  title: string | null;
+  tier: 1 | 2 | 3;
+  filePath: string;
+}
+
+async function readPageJsonDir(dir: string): Promise<PageRegistryEntry[]> {
+  const entries: PageRegistryEntry[] = [];
+
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return entries;
+    }
+    throw err;
+  }
+
+  for (const file of files) {
+    if (file.endsWith('.page.json')) {
+      const filePath = join(dir, file);
+      try {
+        const content = await readFile(filePath, 'utf8');
+        const pageData = JSON.parse(content);
+
+        entries.push({
+          id: pageData.id,
+          route: pageData.route ?? null,
+          tenancy: pageData.tenancy ?? null,
+          title: pageData.title ?? null,
+          tier: 1,
+          filePath,
+        });
+      } catch (err) {
+        // Skip malformed JSON files
+      }
+    }
+  }
+
+  return entries;
+}
+
+async function readCustomComponentsDir(dir: string): Promise<PageRegistryEntry[]> {
+  const entries: PageRegistryEntry[] = [];
+
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return entries;
+    }
+    throw err;
+  }
+
+  for (const file of files) {
+    if (file.endsWith('.tsx')) {
+      const id = file.slice(0, -4);
+      const filePath = join(dir, file);
+
+      entries.push({
+        id,
+        route: null,
+        tenancy: null,
+        title: null,
+        tier: 2,
+        filePath,
+      });
+    }
+  }
+
+  return entries;
+}
+
+async function walkFrontendPages(dir: string, baseDir: string): Promise<PageRegistryEntry[]> {
+  const entries: PageRegistryEntry[] = [];
+
+  let items: { name: string; isDirectory(): boolean }[];
+  try {
+    items = await readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return entries;
+    }
+    throw err;
+  }
+
+  for (const item of items) {
+    // Skip directories named _errors and shell
+    if (item.isDirectory() && (item.name === '_errors' || item.name === 'shell')) {
+      continue;
+    }
+
+    const itemPath = join(dir, item.name);
+
+    if (item.isDirectory()) {
+      const subEntries = await walkFrontendPages(itemPath, baseDir);
+      entries.push(...subEntries);
+    } else if (item.name.endsWith('.tsx')) {
+      const relPath = relative(baseDir, itemPath);
+      const id = relPath.slice(0, -4);
+
+      entries.push({
+        id,
+        route: null,
+        tenancy: null,
+        title: null,
+        tier: 3,
+        filePath: itemPath,
+      });
+    }
+  }
+
+  return entries;
+}
+
+export async function indexPages(opts: {
+  pagesDir: string;
+  customDir: string;
+  frontendPagesDir: string;
+}): Promise<PageRegistryEntry[]> {
+  const tier1 = await readPageJsonDir(opts.pagesDir);
+  const tier2 = await readCustomComponentsDir(opts.customDir);
+  const tier3 = await walkFrontendPages(opts.frontendPagesDir, opts.frontendPagesDir);
+
+  return [...tier1, ...tier2, ...tier3];
+}

package/src/commands/build-ui.ts

@@ -0,0 +1,29 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { scanComponents } from './build-ui/component-scanner.js';
+import { indexPages } from './build-ui/page-indexer.js';
+
+export async function runBuildUi(opts: { projectRoot?: string }): Promise<void> {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+
+  const components = await scanComponents({
+    uiDir: join(projectRoot, 'frontend/src/components/ui'),
+    customDir: join(projectRoot, 'frontend/src/components/custom'),
+  });
+
+  const componentManifestPath = join(projectRoot, '.mc/component-manifest.json');
+  await mkdir(join(componentManifestPath, '..'), { recursive: true });
+  await writeFile(componentManifestPath, JSON.stringify(components, null, 2), 'utf8');
+
+  const pages = await indexPages({
+    pagesDir: join(projectRoot, 'pages'),
+    customDir: join(projectRoot, 'frontend/src/components/custom'),
+    frontendPagesDir: join(projectRoot, 'frontend/src/pages'),
+  });
+
+  const pageRegistryPath = join(projectRoot, '.mc/page-manifest.json');
+  await mkdir(join(pageRegistryPath, '..'), { recursive: true });
+  await writeFile(pageRegistryPath, JSON.stringify(pages, null, 2), 'utf8');
+
+  process.stderr.write(`[build-ui] Wrote ${components.length} components and ${pages.length} pages.\n`);
+}

package/src/templates/api-skeleton.ts

@@ -21,7 +21,7 @@ function camelCase(s: string): string {
 export function apiSkeletonTemplate(domainId: string, apiId: string, tenancy: string): string {
   const tenantPath = tenancy === 'required' ? '/v1/tenants/{tenantId}' : '/v1';
   return `import { z } from 'zod';
-import { defineApi } from '../../../lib/domain-runtime';
+import { defineApi } from '@mettlecast/domain-runtime';
 
 export const ${camelCase(apiId)} = defineApi({
   id: '${apiId}',

package/src/templates/events-skeleton.ts

@@ -9,7 +9,7 @@
  */
 export function eventsSkeletonTemplate(domainId: string): string {
   return `import { z } from 'zod';
-import { defineEvent } from '../../../lib/domain-runtime';
+import { defineEvent } from '@mettlecast/domain-runtime';
 
 export const exampleEvent = defineEvent({
   id: '${domainId}.example',

package/src/templates/subscriber-skeleton.ts

@@ -14,7 +14,7 @@ export function subscriberSkeletonTemplate(
   subscriberId: string,
   eventId: string
 ): string {
-  return `import { defineSubscriber } from '../../../lib/domain-runtime';
+  return `import { defineSubscriber } from '@mettlecast/domain-runtime';
 
 export const ${subscriberId.replace(/-([a-z])/g, (_, c) => c.toUpperCase())} = defineSubscriber({
   id: '${domainId}.${subscriberId}',

package/dist/templates/dashboard-pages/index.d.ts

@@ -1,101 +0,0 @@
-export declare const PAGE_REGISTRY: readonly [{
-    readonly id: "login";
-    readonly category: "auth";
-    readonly path: "auth/login.tsx";
-    readonly name: "LoginPage";
-}, {
-    readonly id: "signup";
-    readonly category: "auth";
-    readonly path: "auth/signup.tsx";
-    readonly name: "SignupPage";
-}, {
-    readonly id: "verify-email";
-    readonly category: "auth";
-    readonly path: "auth/verify-email.tsx";
-    readonly name: "VerifyEmailPage";
-}, {
-    readonly id: "forgot-password";
-    readonly category: "auth";
-    readonly path: "auth/forgot-password.tsx";
-    readonly name: "ForgotPasswordPage";
-}, {
-    readonly id: "reset-password";
-    readonly category: "auth";
-    readonly path: "auth/reset-password.tsx";
-    readonly name: "ResetPasswordPage";
-}, {
-    readonly id: "mfa-setup";
-    readonly category: "auth";
-    readonly path: "auth/mfa-setup.tsx";
-    readonly name: "MfaSetupPage";
-}, {
-    readonly id: "mfa-verify";
-    readonly category: "auth";
-    readonly path: "auth/mfa-verify.tsx";
-    readonly name: "MfaVerifyPage";
-}, {
-    readonly id: "accept-invitation";
-    readonly category: "auth";
-    readonly path: "auth/accept-invitation.tsx";
-    readonly name: "AcceptInvitationPage";
-}, {
-    readonly id: "choose-org";
-    readonly category: "auth";
-    readonly path: "auth/choose-org.tsx";
-    readonly name: "ChooseOrgPage";
-}, {
-    readonly id: "sign-out";
-    readonly category: "auth";
-    readonly path: "auth/sign-out.tsx";
-    readonly name: "SignOutPage";
-}, {
-    readonly id: "dashboard-home";
-    readonly category: "shell";
-    readonly path: "shell/dashboard-home.tsx";
-    readonly name: "DashboardHomePage";
-}, {
-    readonly id: "not-found";
-    readonly category: "shell";
-    readonly path: "shell/not-found.tsx";
-    readonly name: "NotFoundPage";
-}, {
-    readonly id: "forbidden";
-    readonly category: "shell";
-    readonly path: "shell/forbidden.tsx";
-    readonly name: "ForbiddenPage";
-}, {
-    readonly id: "server-error";
-    readonly category: "shell";
-    readonly path: "shell/server-error.tsx";
-    readonly name: "ServerErrorPage";
-}, {
-    readonly id: "maintenance";
-    readonly category: "shell";
-    readonly path: "shell/maintenance.tsx";
-    readonly name: "MaintenancePage";
-}, {
-    readonly id: "profile";
-    readonly category: "account";
-    readonly path: "account/profile.tsx";
-    readonly name: "ProfilePage";
-}, {
-    readonly id: "workspace-settings";
-    readonly category: "account";
-    readonly path: "account/workspace-settings.tsx";
-    readonly name: "WorkspaceSettingsPage";
-}, {
-    readonly id: "members";
-    readonly category: "account";
-    readonly path: "account/members.tsx";
-    readonly name: "MembersPage";
-}, {
-    readonly id: "api-keys";
-    readonly category: "account";
-    readonly path: "account/api-keys.tsx";
-    readonly name: "ApiKeysPage";
-}, {
-    readonly id: "audit-log";
-    readonly category: "account";
-    readonly path: "account/audit-log.tsx";
-    readonly name: "AuditLogPage";
-}];

package/dist/templates/dashboard-pages/index.js

@@ -1,22 +0,0 @@
-export const PAGE_REGISTRY = [
-    { id: 'login', category: 'auth', path: 'auth/login.tsx', name: 'LoginPage' },
-    { id: 'signup', category: 'auth', path: 'auth/signup.tsx', name: 'SignupPage' },
-    { id: 'verify-email', category: 'auth', path: 'auth/verify-email.tsx', name: 'VerifyEmailPage' },
-    { id: 'forgot-password', category: 'auth', path: 'auth/forgot-password.tsx', name: 'ForgotPasswordPage' },
-    { id: 'reset-password', category: 'auth', path: 'auth/reset-password.tsx', name: 'ResetPasswordPage' },
-    { id: 'mfa-setup', category: 'auth', path: 'auth/mfa-setup.tsx', name: 'MfaSetupPage' },
-    { id: 'mfa-verify', category: 'auth', path: 'auth/mfa-verify.tsx', name: 'MfaVerifyPage' },
-    { id: 'accept-invitation', category: 'auth', path: 'auth/accept-invitation.tsx', name: 'AcceptInvitationPage' },
-    { id: 'choose-org', category: 'auth', path: 'auth/choose-org.tsx', name: 'ChooseOrgPage' },
-    { id: 'sign-out', category: 'auth', path: 'auth/sign-out.tsx', name: 'SignOutPage' },
-    { id: 'dashboard-home', category: 'shell', path: 'shell/dashboard-home.tsx', name: 'DashboardHomePage' },
-    { id: 'not-found', category: 'shell', path: 'shell/not-found.tsx', name: 'NotFoundPage' },
-    { id: 'forbidden', category: 'shell', path: 'shell/forbidden.tsx', name: 'ForbiddenPage' },
-    { id: 'server-error', category: 'shell', path: 'shell/server-error.tsx', name: 'ServerErrorPage' },
-    { id: 'maintenance', category: 'shell', path: 'shell/maintenance.tsx', name: 'MaintenancePage' },
-    { id: 'profile', category: 'account', path: 'account/profile.tsx', name: 'ProfilePage' },
-    { id: 'workspace-settings', category: 'account', path: 'account/workspace-settings.tsx', name: 'WorkspaceSettingsPage' },
-    { id: 'members', category: 'account', path: 'account/members.tsx', name: 'MembersPage' },
-    { id: 'api-keys', category: 'account', path: 'account/api-keys.tsx', name: 'ApiKeysPage' },
-    { id: 'audit-log', category: 'account', path: 'account/audit-log.tsx', name: 'AuditLogPage' },
-];