create-stitchkit 0.1.1 → 0.2.0

package/template/packages/backend/src/surface-manifest.ts

@@ -0,0 +1,117 @@
+import type { HttpMethod } from 'stitchkit/contract';
+import type { OpenApiDocument, ServiceDef } from 'stitchkit/server';
+import { listToolNames } from 'stitchkit/tools';
+
+export interface SurfaceManifestOperation {
+  service: string;
+  action: string;
+  http: Array<{ method: HttpMethod; path: string }>;
+  tools: Partial<Record<'MCP' | 'AGENT' | 'CLI', string>>;
+}
+
+function joinPath(...parts: Array<string | undefined>): string {
+  const joined = parts
+    .filter((part): part is string => Boolean(part))
+    .map((part) => part.replace(/^\/+|\/+$/g, ''))
+    .filter(Boolean)
+    .join('/');
+  return `/${joined}`;
+}
+
+function operationKey(service: string, action: string): string {
+  return `${service}\u0000${action}`;
+}
+
+function sorted(values: Iterable<string>): string[] {
+  return [...values].sort((left, right) => left.localeCompare(right));
+}
+
+function assertSameSet(
+  label: string,
+  expectedValues: Iterable<string>,
+  actualValues: Iterable<string>,
+) {
+  const expected = sorted(expectedValues);
+  const actual = sorted(actualValues);
+  if (
+    expected.length === actual.length &&
+    expected.every((value, index) => value === actual[index])
+  ) {
+    return;
+  }
+  throw new Error(
+    `${label} surface mismatch\nexpected: ${expected.join(', ') || '(empty)'}\nactual: ${actual.join(', ') || '(empty)'}`,
+  );
+}
+
+export function buildSurfaceManifest(
+  services: readonly ServiceDef[],
+  pathPrefix = '/api',
+): SurfaceManifestOperation[] {
+  const operations = new Map<string, SurfaceManifestOperation>();
+  for (const service of services) {
+    for (const method of Object.values(service.methods)) {
+      const key = operationKey(service.name, method.key);
+      if (operations.has(key)) {
+        throw new Error(`Duplicate operation identity ${service.name}.${method.key}`);
+      }
+      operations.set(key, {
+        service: service.name,
+        action: method.key,
+        http:
+          !method.expose || method.expose.includes('HTTP')
+            ? [
+                {
+                  method: method.method,
+                  path: joinPath(pathPrefix, service.prefix, method.path).replace(
+                    /:([^/]+)/g,
+                    '{$1}',
+                  ),
+                },
+              ]
+            : [],
+        tools: {},
+      });
+    }
+  }
+  for (const tool of listToolNames({ services })) {
+    const operation = operations.get(operationKey(tool.service, tool.method));
+    if (!operation) {
+      throw new Error(`Tool ${tool.name} has no contract identity`);
+    }
+    for (const transport of tool.transports) {
+      if (transport !== 'HTTP') operation.tools[transport] = tool.name;
+    }
+  }
+  return [...operations.values()].sort(
+    (left, right) =>
+      left.service.localeCompare(right.service) || left.action.localeCompare(right.action),
+  );
+}
+
+export function assertSurfaceConformance({
+  manifest,
+  openApi,
+  mcpToolNames,
+}: {
+  manifest: readonly SurfaceManifestOperation[];
+  openApi: Pick<OpenApiDocument, 'paths'>;
+  mcpToolNames: readonly string[];
+}): void {
+  assertSameSet(
+    'HTTP/OpenAPI',
+    manifest.flatMap((operation) =>
+      operation.http.map((entry) => `${entry.method}:${entry.path}`),
+    ),
+    Object.entries(openApi.paths).flatMap(([path, item]) =>
+      Object.keys(item)
+        .filter((method) => ['get', 'post', 'put', 'patch', 'delete', 'head'].includes(method))
+        .map((method) => `${method.toUpperCase()}:${path}`),
+    ),
+  );
+  assertSameSet(
+    'MCP discovery',
+    manifest.flatMap((operation) => (operation.tools.MCP ? [operation.tools.MCP] : [])),
+    mcpToolNames,
+  );
+}

package/template/packages/backend/src/surface.ts

@@ -1,13 +1,7 @@
-import type { ClientToServerEvents, ServerToClientEvents } from '@app/shared';
+import { env } from '@app/config';
 import { createSocketIOServer } from 'stitchkit/server';
-import { createRepositoryService } from './transport/repository-service';
 
 export async function createSurface() {
-  const socket = await createSocketIOServer<ServerToClientEvents, ClientToServerEvents>({
-    cors: { origin: '*' },
-  });
-  const repositoryService = createRepositoryService((snapshot) =>
-    socket.io.emit('repository:refreshed', snapshot),
-  );
-  return { socket, services: [repositoryService] };
+  const socket = await createSocketIOServer({ cors: { origin: env.CORS_ORIGIN } });
+  return { socket, services: [] };
 }

package/template/packages/backend/src/transport/lan-onboarding.ts

@@ -0,0 +1,29 @@
+import { env } from '@app/config';
+import type { RawRoute } from 'stitchkit/server';
+
+export function createLanOnboardingRoutes(): RawRoute[] {
+  if (env.NODE_ENV !== 'development' || !env.DEV_HTTPS_CA) return [];
+  const caPath = env.DEV_HTTPS_CA;
+  return [
+    {
+      method: 'GET',
+      path: '/__dev/lan-ca',
+      handler: () =>
+        new Response(Bun.file(caPath), {
+          headers: {
+            'Content-Disposition': 'attachment; filename="stitchkit-lan-root-ca.pem"',
+            'Content-Type': 'application/x-pem-file',
+          },
+        }),
+    },
+    {
+      method: 'GET',
+      path: '/__dev/lan',
+      handler: () =>
+        new Response(
+          `<!doctype html><meta name="viewport" content="width=device-width"><title>LAN HTTPS setup</title><main><h1>Trust this development CA</h1><p><a href="/__dev/lan-ca">Download the public root certificate</a>.</p><h2>iOS</h2><p>Install the downloaded profile, then enable full trust in Settings → General → About → Certificate Trust Settings.</p><h2>Android</h2><p>Install it as a CA certificate. Native development builds must explicitly allow user-installed roots.</p><p>No private key is exposed by this server.</p></main>`,
+          { headers: { 'Content-Type': 'text/html; charset=utf-8' } },
+        ),
+    },
+  ];
+}

package/template/packages/config/package.json

@@ -4,7 +4,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./src/server.ts"
+    ".": "./src/server.ts",
+    "./identity": "./src/identity.ts"
   },
   "scripts": {
     "check": "bun x tsc --noEmit",

package/template/packages/config/src/features.ts

@@ -0,0 +1 @@
+export const featureServerSchema = {};

package/template/packages/config/src/identity.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import source from '../../../app.config.json' with { type: 'json' };
+
+export const ApplicationIdentitySchema = z.object({
+  slug: z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  name: z.string().trim().min(1).max(80),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/),
+  description: z.object({
+    en: z.string().trim().min(1),
+    ru: z.string().trim().min(1),
+  }),
+});
+
+export const appIdentity = ApplicationIdentitySchema.parse(source);

package/template/packages/config/src/server.ts

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { createEnv } from '@t3-oss/env-core';
 import { config } from 'dotenv';
 import { z } from 'zod';
+import { featureServerSchema } from './features';
 
 config({ path: path.resolve(import.meta.dirname, '../../../.env'), quiet: true });
 
@@ -15,10 +16,19 @@ export const env = createEnv({
     INTERNAL_API_URL: z.url(),
     NEXT_PUBLIC_WEB_URL: z.url(),
     LOG_FORMAT: z.enum(['pretty', 'json']).default('pretty'),
-    GITHUB_REPOSITORY: z.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
-    GITHUB_CACHE_TTL_SECONDS: z.coerce.number().int().positive().default(900),
-    GITHUB_TOKEN: z.string().min(1).optional(),
+    CORS_ORIGIN: z.string().min(1).default('*'),
+    DEV_HTTPS_CERT: z.string().min(1).optional(),
+    DEV_HTTPS_KEY: z.string().min(1).optional(),
+    DEV_HTTPS_CA: z.string().min(1).optional(),
+    ...featureServerSchema,
   },
   runtimeEnv: process.env,
   emptyStringAsUndefined: true,
 });
+
+/** Preserve the host process environment while applying explicit child-process overrides. */
+export function childEnvironment(
+  overrides: Record<string, string>,
+): Record<string, string | undefined> {
+  return { ...process.env, ...overrides };
+}

package/template/packages/db/schema.prisma

@@ -6,26 +6,3 @@ generator client {
 datasource db {
   provider = "postgresql"
 }
-
-enum RepositoryVisibility {
-  PUBLIC
-  PRIVATE
-  INTERNAL
-}
-
-model RepositorySnapshot {
-  fullName            String   @id
-  description         String?
-  htmlUrl             String
-  language            String?
-  visibility          RepositoryVisibility @default(PUBLIC)
-  stars               Int
-  forks               Int
-  openIssues          Int
-  commitCount         Int
-  latestCommitSha     String?
-  latestCommitMessage String?
-  latestCommittedAt   DateTime?
-  fetchedAt           DateTime
-  expiresAt           DateTime
-}

package/template/packages/frontend/messages/en.json

@@ -1,6 +1,5 @@
 {
   "App": {
-    "title": "Stitchkit Starter",
     "description": "A compact production base with one typed contract across HTTP, MCP, agents and the browser — ready for your product, not a demo domain.",
     "heroTitle": "Build the product, not the plumbing.",
     "ui": "UI system"

package/template/packages/frontend/messages/ru.json

@@ -1,6 +1,5 @@
 {
   "App": {
-    "title": "Stitchkit Starter",
     "description": "Компактная production-база с единым типизированным контрактом для HTTP, MCP, агентов и браузера — готовая к вашему продукту, а не к демо-домену.",
     "heroTitle": "Стройте продукт, а не инфраструктурную рутину.",
     "ui": "UI-система"

package/template/packages/frontend/package.json

@@ -11,6 +11,7 @@
     "test": "bun test --pass-with-no-tests"
   },
   "dependencies": {
+    "@app/config": "workspace:*",
     "@app/db": "workspace:*",
     "@app/shared": "workspace:*",
     "@radix-ui/react-alert-dialog": "^1.1.23",

package/template/packages/frontend/src/app/[locale]/page.tsx

@@ -1,10 +1,7 @@
-import { dehydrate, HydrationBoundary } from '@tanstack/react-query';
+import { appIdentity } from '@app/config/identity';
 import type { Metadata } from 'next';
 import { getTranslations } from 'next-intl/server';
 import { LocaleSchema } from '@/i18n/locales';
-import { createServerRepositoryApi } from '@/lib/api/client';
-import { useRepository } from '@/lib/api/queries';
-import { getQueryClient } from '@/lib/query-client';
 import { createPageMetadata } from '@/lib/seo/metadata';
 import { StarterPage } from './starter-page';
 
@@ -22,23 +19,15 @@ export async function generateMetadata({
 export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
   const { locale } = await params;
   const appLocale = LocaleSchema.parse(locale);
-  const queryClient = getQueryClient();
-  const api = createServerRepositoryApi();
   const t = await getTranslations('App');
-  await queryClient.prefetchQuery({
-    queryKey: useRepository.getKey(),
-    queryFn: () => api.read(),
-  });
 
   return (
-    <HydrationBoundary state={dehydrate(queryClient)}>
-      <StarterPage
-        applicationName={t('title')}
-        applicationDescription={t('description')}
-        heroTitle={t('heroTitle')}
-        catalogueLabel={t('ui')}
-        locale={appLocale}
-      />
-    </HydrationBoundary>
+    <StarterPage
+      applicationName={appIdentity.name}
+      applicationDescription={appIdentity.description[appLocale]}
+      heroTitle={t('heroTitle')}
+      catalogueLabel={t('ui')}
+      locale={appLocale}
+    />
   );
 }

package/template/packages/frontend/src/app/[locale]/starter-page.tsx

@@ -1,7 +1,6 @@
 import { IconArrowUpRight } from '@tabler/icons-react';
 import Image from 'next/image';
 import { BrandMark } from '@/components/brand-mark';
-import { RepositorySummary } from '@/components/repository-summary';
 import { LanguageSwitcher, ThemeToggle } from '@/components/system-controls';
 import { buttonVariants } from '@/components/ui';
 import type { AppLocale } from '@/i18n/locales';
@@ -140,9 +139,9 @@ export function StarterPage({
               </div>
             </div>
 
-            <div className='mt-5 w-full'>
-              <RepositorySummary />
-            </div>
+            <p className='mt-5 text-sm text-muted-foreground'>
+              Add your first vertical feature from schema to transport and UI.
+            </p>
           </section>
         </div>
       </div>

package/template/packages/frontend/src/app/[locale]/ui/_catalogue/landing-showcase.tsx

@@ -1,5 +1,6 @@
 'use client';
 
+import { appIdentity } from '@app/config/identity';
 import { IconArrowRight, IconBraces, IconDatabase, IconWorld } from '@tabler/icons-react';
 import type { ReactNode } from 'react';
 import { BrandMark } from '@/components/brand-mark';
@@ -36,7 +37,7 @@ export function LandingHeader({ actions }: { actions?: ReactNode }) {
     <header className='flex items-center justify-between border-b border-border py-4'>
       <div className='flex items-center gap-2 font-medium'>
         <BrandMark priority />
-        Stitchkit Starter
+        {appIdentity.name}
       </div>
       <div className='flex items-center gap-2'>{actions}</div>
     </header>
@@ -152,7 +153,7 @@ export function PricingSection() {
 export function LandingFooter() {
   return (
     <footer className='flex flex-col gap-3 border-t border-border py-8 text-sm text-muted-foreground sm:flex-row sm:items-center sm:justify-between'>
-      <span>Stitchkit Starter · Built with Stitchkit</span>
+      <span>{appIdentity.name} · Built with Stitchkit</span>
       <span>Contracts · UI · Realtime · Tools</span>
     </footer>
   );

package/template/packages/frontend/src/lib/seo/pages.ts

@@ -1,7 +1,8 @@
+import { appIdentity } from '@app/config/identity';
 import { z } from 'zod';
 import type { AppLocale } from '@/i18n/locales';
 
-export const SITE_NAME = 'Stitchkit Starter';
+export const SITE_NAME = appIdentity.name;
 export const StoryIdSchema = z.enum(['components', 'themes', 'blocks']);
 export type StoryId = z.infer<typeof StoryIdSchema>;
 
@@ -42,14 +43,12 @@ const seoPages: Record<SeoPageId, SeoPageDefinition> = {
     copy: {
       en: {
         title: 'UI components',
-        description:
-          'Explore accessible actions, forms, feedback, overlays, data displays and motion components included in the Stitchkit starter.',
+        description: `Explore accessible actions, forms, feedback, overlays, data displays and motion components included in ${SITE_NAME}.`,
         eyebrow: 'UI system',
       },
       ru: {
         title: 'UI-компоненты',
-        description:
-          'Изучите доступные действия, формы, обратную связь, оверлеи, представление данных и анимации в Stitchkit Starter.',
+        description: `Изучите доступные действия, формы, обратную связь, оверлеи, представление данных и анимации в ${SITE_NAME}.`,
         eyebrow: 'UI-система',
       },
     },

package/template/packages/frontend/src/providers/index.tsx

@@ -4,14 +4,11 @@ import { TooltipProvider } from '@radix-ui/react-tooltip';
 import type { ReactNode } from 'react';
 import { Toaster } from '@/components/ui/toaster';
 import { ReactQueryProvider } from './react-query';
-import { RealtimeProvider } from './realtime';
 
 export function Providers({ children }: { children: ReactNode }) {
   return (
     <ReactQueryProvider>
-      <RealtimeProvider>
-        <TooltipProvider delayDuration={250}>{children}</TooltipProvider>
-      </RealtimeProvider>
+      <TooltipProvider delayDuration={250}>{children}</TooltipProvider>
       <Toaster />
     </ReactQueryProvider>
   );

package/template/packages/frontend/src/theme/config.ts

@@ -1,9 +1,10 @@
+import { appIdentity } from '@app/config/identity';
 import type { ThemeProviderProps } from '@wrksz/themes/next';
 
 export type AppTheme = 'light' | 'dark';
 
 export const appThemes: readonly [AppTheme, AppTheme] = ['light', 'dark'];
-export const themeStorageKey = 'stitchkit-starter-theme';
+export const themeStorageKey = `${appIdentity.slug}-theme`;
 
 export const themeProviderConfig = {
   themes: appThemes,

package/template/packages/shared/src/index.ts

@@ -1,3 +1 @@
-export * from './contracts/repository';
-export * from './events/repository';
-export * from './schemas/repository';
+export {};

package/template/scripts/dev-lan.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test';
+import { developmentEnvironment } from './dev';
+import { privateLanAddresses, selectLanAddress } from './dev-lan';
+
+describe('LAN HTTPS address selection', () => {
+  test('normal development clears every LAN-only process variable', () => {
+    expect(developmentEnvironment()).toMatchObject({
+      DEV_HTTPS_CA: '',
+      DEV_HTTPS_CERT: '',
+      DEV_HTTPS_KEY: '',
+      NODE_EXTRA_CA_CERTS: '',
+    });
+    expect(developmentEnvironment({ DEV_HTTPS_CERT: '/cert.pem' }).DEV_HTTPS_CERT).toBe(
+      '/cert.pem',
+    );
+  });
+
+  test('keeps private IPv4 interfaces and ignores public/internal addresses', () => {
+    expect(
+      privateLanAddresses({
+        eth0: [
+          {
+            address: '192.168.1.20',
+            netmask: '',
+            family: 'IPv4',
+            mac: '',
+            internal: false,
+            cidr: null,
+          },
+          {
+            address: '8.8.8.8',
+            netmask: '',
+            family: 'IPv4',
+            mac: '',
+            internal: false,
+            cidr: null,
+          },
+        ],
+        lo: [
+          {
+            address: '127.0.0.1',
+            netmask: '',
+            family: 'IPv4',
+            mac: '',
+            internal: true,
+            cidr: null,
+          },
+        ],
+      }),
+    ).toEqual(['192.168.1.20']);
+  });
+
+  test('auto-selects one address and fails on ambiguity', () => {
+    expect(selectLanAddress(['10.0.0.4'])).toBe('10.0.0.4');
+    expect(() => selectLanAddress(['10.0.0.4', '192.168.1.20'])).toThrow('ambiguous');
+    expect(() => selectLanAddress(['10.0.0.4'], '10.0.0.5')).toThrow('unavailable');
+  });
+});

package/template/scripts/dev-lan.ts

@@ -0,0 +1,176 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir, networkInterfaces } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { appIdentity } from '../packages/config/src/identity';
+import { childEnvironment, env } from '../packages/config/src/server';
+import { runDevelopment } from './dev';
+
+export function privateLanAddresses(
+  interfaces: ReturnType<typeof networkInterfaces>,
+): string[] {
+  const addresses = new Set<string>();
+  for (const entries of Object.values(interfaces)) {
+    for (const entry of entries ?? []) {
+      if (entry.family !== 'IPv4' || entry.internal) continue;
+      const [first, second] = entry.address.split('.').map(Number);
+      if (
+        first === 10 ||
+        (first === 172 && second !== undefined && second >= 16 && second <= 31) ||
+        (first === 192 && second === 168)
+      ) {
+        addresses.add(entry.address);
+      }
+    }
+  }
+  return [...addresses].sort();
+}
+
+export function selectLanAddress(addresses: readonly string[], requested?: string): string {
+  if (requested) {
+    if (!addresses.includes(requested)) {
+      throw new Error(
+        `Requested LAN address ${requested} is unavailable. Detected: ${addresses.join(', ') || '(none)'}`,
+      );
+    }
+    return requested;
+  }
+  if (addresses.length !== 1) {
+    throw new Error(
+      `LAN address is ${addresses.length === 0 ? 'unavailable' : 'ambiguous'}. Use --host <address>. Detected: ${addresses.join(', ') || '(none)'}`,
+    );
+  }
+  return addresses[0];
+}
+
+async function run(command: string[], environment?: Record<string, string>): Promise<string> {
+  const child = Bun.spawn(command, {
+    env: environment ? childEnvironment(environment) : undefined,
+    stdout: 'pipe',
+    stderr: 'inherit',
+  });
+  const output = await new Response(child.stdout).text();
+  const exitCode = await child.exited;
+  if (exitCode !== 0) throw new Error(`${command.join(' ')} failed with exit code ${exitCode}`);
+  return output.trim();
+}
+
+function requestedHost(args: readonly string[]): string | undefined {
+  const index = args.indexOf('--host');
+  if (index === -1) return undefined;
+  const value = args[index + 1];
+  if (!value) throw new Error('--host requires an IPv4 address');
+  return value;
+}
+
+async function ensureCertificates(host: string) {
+  if (!Bun.which('mkcert')) {
+    throw new Error(
+      'dev:lan requires mkcert. Install it with `brew install mkcert` (macOS/Linuxbrew) or the official prebuilt binary, then rerun.',
+    );
+  }
+  const caRoot = await run(['mkcert', '-CAROOT']);
+  const ca = join(caRoot, 'rootCA.pem');
+  if (!(await Bun.file(ca).exists())) await run(['mkcert', '-install']);
+
+  const directory = join(homedir(), '.local', 'share', appIdentity.slug, 'lan-https');
+  const cert = join(directory, 'leaf.pem');
+  const key = join(directory, 'leaf-key.pem');
+  const marker = join(directory, 'host');
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const previous = await readFile(marker, 'utf8').catch(() => '');
+  if (
+    previous.trim() !== host ||
+    !(await Bun.file(cert).exists()) ||
+    !(await Bun.file(key).exists())
+  ) {
+    await run([
+      'mkcert',
+      '-cert-file',
+      cert,
+      '-key-file',
+      key,
+      host,
+      'localhost',
+      '127.0.0.1',
+      '::1',
+    ]);
+    await writeFile(marker, `${host}\n`, { mode: 0o600 });
+  }
+  return { ca, cert, key };
+}
+
+async function isPortOccupied(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (occupied: boolean, socket?: { end(): void }) => {
+      if (settled) return;
+      settled = true;
+      resolve(occupied);
+      socket?.end();
+    };
+    void Bun.connect({
+      hostname: '127.0.0.1',
+      port,
+      socket: {
+        open: (socket) => finish(true, socket),
+        data: () => undefined,
+        close: () => finish(false),
+        error: () => finish(false),
+      },
+    }).catch(() => finish(false));
+  });
+}
+
+async function assertDevelopmentPortsAvailable(): Promise<void> {
+  const processList = await run(['pm2', 'jlist']);
+  const onlineNames = new Set(
+    z
+      .array(
+        z.object({
+          name: z.string(),
+          pm2_env: z.object({ status: z.string() }),
+        }),
+      )
+      .parse(JSON.parse(processList))
+      .filter((process) => process.pm2_env.status === 'online')
+      .map((process) => process.name),
+  );
+  const expected = new Map([
+    [env.WEB_PORT, `${appIdentity.slug}-frontend-dev`],
+    [env.API_PORT, `${appIdentity.slug}-backend-dev`],
+  ]);
+  for (const [port, owner] of expected) {
+    if ((await isPortOccupied(port)) && !onlineNames.has(owner)) {
+      throw new Error(`Port ${port} is occupied by a process outside ${owner}`);
+    }
+  }
+}
+
+if (import.meta.main) {
+  if (env.NODE_ENV !== 'development') {
+    throw new Error('dev:lan is development-only');
+  }
+  const host = selectLanAddress(
+    privateLanAddresses(networkInterfaces()),
+    requestedHost(Bun.argv),
+  );
+  await assertDevelopmentPortsAvailable();
+  const certificates = await ensureCertificates(host);
+  const apiOrigin = `https://${host}:${env.API_PORT}`;
+  const webOrigin = `https://${host}:${env.WEB_PORT}`;
+  await runDevelopment({
+    CORS_ORIGIN: webOrigin,
+    DEV_HTTPS_CA: certificates.ca,
+    DEV_HTTPS_CERT: certificates.cert,
+    DEV_HTTPS_KEY: certificates.key,
+    INTERNAL_API_URL: apiOrigin,
+    NEXT_PUBLIC_API_URL: apiOrigin,
+    NEXT_PUBLIC_WEB_URL: webOrigin,
+    NODE_EXTRA_CA_CERTS: certificates.ca,
+  });
+  console.log(`${appIdentity.name} trusted LAN development is running`);
+  console.log(`Web: ${webOrigin}/en`);
+  console.log(`API: ${apiOrigin}`);
+  console.log(`Device CA setup: ${apiOrigin}/__dev/lan`);
+}