create-stitchkit 0.1.0 → 0.2.0

package/template/docs/LAN_HTTPS.md

@@ -0,0 +1,28 @@
+# Trusted LAN HTTPS development
+
+Use this optional mode to test microphone, camera, PWA and WebRTC behavior on a
+physical device connected to the same private network:
+
+```bash
+# Install the maintained local-CA tool first:
+brew install mkcert
+
+bun run dev:lan
+# Multiple private interfaces:
+bun run dev:lan --host 192.168.1.20
+```
+
+The launcher uses mkcert, stores leaf certificates under
+`~/.local/share/<app-slug>/lan-https`, and keeps the CA in mkcert's own CAROOT.
+No certificate or machine address is written into the project. When the chosen
+address changes, only the leaf certificate is renewed.
+
+The command prints the HTTPS web/API URLs and a development-only onboarding URL.
+Open that URL on the phone to download the **public** root certificate. On iOS,
+install the profile and enable full trust under Certificate Trust Settings. On
+Android, install it as a CA certificate; native development builds must opt into
+user-installed roots. The private CA key is never served.
+
+`bun run dev` remains plain localhost HTTP. Production never reads the LAN
+certificate variables or mounts the onboarding routes.
+

package/template/e2e/starter.spec.ts

@@ -1,3 +1,4 @@
+import { appIdentity } from '@app/config/identity';
 import AxeBuilder from '@axe-core/playwright';
 import { expect, test } from '@playwright/test';
 
@@ -6,7 +7,6 @@ test('renders the hydrated starter application and catalogue', async ({ page })
   await expect(page.getByRole('heading', { level: 1 })).toContainText(
     'Build the product, not the plumbing',
   );
-  await expect(page.getByText('max-listov/stitchkit')).toBeVisible();
   await page.getByRole('link', { name: /UI system/ }).click();
   await expect(page).toHaveURL(/\/en\/ui\/components$/);
   await expect(page.getByRole('heading', { level: 1 })).toContainText('UI components');
@@ -17,7 +17,7 @@ test('publishes complete page metadata and a reachable Open Graph card', async (
   request,
 }) => {
   await page.goto('/en/ui/themes');
-  await expect(page).toHaveTitle('Theme system · Stitchkit Starter');
+  await expect(page).toHaveTitle(`Theme system · ${appIdentity.name}`);
   await expect(page.locator('link[rel="canonical"]')).toHaveAttribute(
     'href',
     /\/en\/ui\/themes$/,
@@ -39,23 +39,6 @@ test('publishes complete page metadata and a reachable Open Graph card', async (
   expect(await sitemapResponse.text()).toContain('/ru/ui/themes');
 });
 
-test('spins the refresh icon in place while its action is pending', async ({ page }) => {
-  await page.route('**/api/repository/refresh', async (route) => {
-    await new Promise((resolve) => setTimeout(resolve, 750));
-    await route.continue();
-  });
-  await page.goto('/en');
-
-  const refresh = page.getByRole('button', { name: 'Refresh repository data' });
-  await expect(refresh).toHaveCSS('height', '32px');
-  await expect(refresh).toHaveCSS('width', '32px');
-  await expect(refresh.locator('.tabler-icon-refresh')).toHaveCount(1);
-  await refresh.click();
-  await expect(refresh).toHaveAttribute('aria-busy', 'true');
-  await expect(refresh.locator('svg')).toHaveCount(1);
-  await expect(refresh.locator('.tabler-icon-refresh')).toHaveClass(/animate-spin/);
-});
-
 test('switches catalogue sections and component tabs', async ({ page }) => {
   await page.goto('/en/ui');
   await expect(page).toHaveURL(/\/en\/ui\/components$/);
@@ -176,7 +159,11 @@ test('keeps long localized navigation labels inside the mobile drawer', async ({
   expect(overflow.page).toBeLessThanOrEqual(1);
 });
 
-test('provides a server-first synchronized theme system', async ({ context, page }) => {
+test('provides a server-first synchronized theme system', async ({
+  browserName,
+  context,
+  page,
+}) => {
   const consoleProblems: string[] = [];
   page.on('console', (message) => {
     if (message.type() === 'error' || message.type() === 'warning') {
@@ -210,17 +197,25 @@ test('provides a server-first synchronized theme system', async ({ context, page
   const secondPage = await context.newPage();
   await secondPage.goto('/en/ui/themes');
   await expect(secondPage.locator('html')).toHaveClass(/dark/);
+  await expect(secondPage.getByTestId('theme-state-selected')).not.toContainText('hydrating');
+  await page.emulateMedia({ reducedMotion: 'reduce' });
   await page.getByRole('button', { name: 'Light', exact: true }).click();
+  if (browserName === 'webkit') {
+    // Playwright WebKit shares localStorage but does not dispatch cross-page storage events.
+    await secondPage.reload();
+  }
   await expect(secondPage.locator('html')).toHaveClass(/light/);
 
   await page.getByRole('button', { name: 'System', exact: true }).click();
   await expect(page.getByTestId('theme-state-selected')).toContainText('system');
   const themeCookie = (await context.cookies()).find(
-    (cookie) => cookie.name === 'stitchkit-starter-theme',
+    (cookie) => cookie.name === `${appIdentity.slug}-theme`,
   );
   expect(themeCookie?.value).toBe('system');
   await page.reload();
-  await expect(page.getByTestId('theme-state-server-cookie')).toContainText('system');
+  const serverCookieState = page.getByTestId('theme-state-server-cookie');
+  await expect(serverCookieState).toHaveCount(1);
+  await expect(serverCookieState).toContainText('system');
   expect(
     consoleProblems.filter((message) =>
       /hydration|useServerInsertedHTML|inline script/i.test(message),

package/template/ecosystem.config.cjs

@@ -1,12 +1,13 @@
 const path = require('node:path');
 const { config } = require('dotenv');
+const identity = require('./app.config.json');
 
 config({ path: path.join(__dirname, '.env'), quiet: true, override: true });
 
 module.exports = {
   apps: [
     {
-      name: 'stitchkit-starter-backend',
+      name: `${identity.slug}-backend`,
       cwd: path.join(__dirname, 'packages/backend'),
       script: 'dist/index.js',
       interpreter: 'bun',
@@ -15,7 +16,7 @@ module.exports = {
       env: { NODE_ENV: 'production' },
     },
     {
-      name: 'stitchkit-starter-frontend',
+      name: `${identity.slug}-frontend`,
       cwd: path.join(__dirname, 'packages/frontend'),
       script: 'node_modules/.bin/next',
       args: ['start', '--port', process.env.WEB_PORT, '--hostname', '0.0.0.0'],

package/template/ecosystem.dev.config.cjs

@@ -1,12 +1,27 @@
 const path = require('node:path');
 const { config } = require('dotenv');
+const identity = require('./app.config.json');
 
-config({ path: path.join(__dirname, '.env'), quiet: true, override: true });
+config({ path: path.join(__dirname, '.env'), quiet: true });
+
+const frontendArgs = ['dev', '--port', process.env.WEB_PORT, '--hostname', '0.0.0.0'];
+if (process.env.DEV_HTTPS_CERT && process.env.DEV_HTTPS_KEY) {
+  frontendArgs.push(
+    '--experimental-https',
+    '--experimental-https-key',
+    process.env.DEV_HTTPS_KEY,
+    '--experimental-https-cert',
+    process.env.DEV_HTTPS_CERT,
+  );
+  if (process.env.DEV_HTTPS_CA) {
+    frontendArgs.push('--experimental-https-ca', process.env.DEV_HTTPS_CA);
+  }
+}
 
 module.exports = {
   apps: [
     {
-      name: 'stitchkit-starter-backend-dev',
+      name: `${identity.slug}-backend-dev`,
       cwd: path.join(__dirname, 'packages/backend'),
       script: 'src/index.ts',
       interpreter: 'bun',
@@ -16,10 +31,10 @@ module.exports = {
       env: { NODE_ENV: 'development' },
     },
     {
-      name: 'stitchkit-starter-frontend-dev',
+      name: `${identity.slug}-frontend-dev`,
       cwd: path.join(__dirname, 'packages/frontend'),
       script: 'node_modules/.bin/next',
-      args: ['dev', '--port', process.env.WEB_PORT, '--hostname', '0.0.0.0'],
+      args: frontendArgs,
       interpreter: 'bun',
       autorestart: true,
       kill_timeout: 10000,

package/template/package.json

@@ -7,10 +7,11 @@
     "packages/*"
   ],
   "catalog": {
-    "stitchkit": "^0.42.0"
+    "stitchkit": "^0.45.0"
   },
   "scripts": {
     "dev": "bun scripts/dev.ts",
+    "dev:lan": "bun scripts/dev-lan.ts",
     "check": "bun run db:generate && bun run check:authored && bun run --filter '*' check",
     "check:authored": "bun scripts/check-authored.ts",
     "test": "bun run --filter '*' test",
@@ -36,10 +37,11 @@
     "dotenv": "^17.4.2"
   },
   "devDependencies": {
+    "@app/config": "workspace:*",
     "@app/shared": "workspace:*",
     "@axe-core/playwright": "^4.11.0",
     "@biomejs/biome": "^2.5.7",
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/client": "^2.0.0",
     "@playwright/test": "^1.55.0",
     "@types/bun": "^1.3.14",
     "oxc-parser": "^0.143.0",

package/template/packages/backend/package.json

@@ -16,7 +16,7 @@
     "@app/config": "workspace:*",
     "@app/db": "workspace:*",
     "@app/shared": "workspace:*",
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "@prisma/adapter-pg": "^7.9.1",
     "@socket.io/bun-engine": "^0.1.1",
     "ai": "^7.0.58",

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

@@ -1,12 +1,13 @@
 #!/usr/bin/env bun
 
+import { appIdentity } from '@app/config/identity';
 import { createCli } from 'stitchkit/cli';
 import { createSurface } from './surface';
 
 const { services, socket } = await createSurface();
 
 try {
-  await createCli({ name: 'stitchkit-starter', version: '0.1.0', services });
+  await createCli({ name: appIdentity.slug, version: appIdentity.version, services });
 } finally {
   await socket.io.close();
 }

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

@@ -1,20 +1,22 @@
 import { env } from '@app/config';
+import { appIdentity } from '@app/config/identity';
 import { wrapInRequestContext } from 'stitchkit/observability';
 import { createServer, generateOpenApiDocument, openApiRoute } from 'stitchkit/server';
-import { createMcpHandler } from 'stitchkit/tools';
+import { createMcpHandler, createMcpHttpRoute } from 'stitchkit/tools';
 import { prisma } from './lib/db';
 import { createSurface } from './surface';
 import { onError } from './transport/errors';
+import { createLanOnboardingRoutes } from './transport/lan-onboarding';
 
 async function main(): Promise<void> {
   const { services, socket } = await createSurface();
   const mcp = createMcpHandler({
-    serverInfo: { name: 'stitchkit-starter', version: '0.1.0' },
+    serverInfo: { name: appIdentity.slug, version: appIdentity.version },
     auth: () => ({ scope: 'public' }),
     services,
   });
   const openApi = generateOpenApiDocument({
-    info: { title: 'Stitchkit Starter API', version: '0.1.0' },
+    info: { title: `${appIdentity.name} API`, version: appIdentity.version },
     groups: [{ pathPrefix: '/api', services }],
   });
 
@@ -22,14 +24,15 @@ async function main(): Promise<void> {
     groups: [{ pathPrefix: '/api', services }],
     port: env.API_PORT,
     hostname: '0.0.0.0',
-    cors: { origin: '*' },
+    cors: { origin: env.CORS_ORIGIN },
     hooks: { onError },
     logging: { format: env.LOG_FORMAT },
     websocket: socket.websocket,
     rawRoutes: [
       socket.route,
       openApiRoute('/openapi.json', openApi),
-      { method: 'ALL', path: '/mcp', handler: (req) => mcp(req) },
+      createMcpHttpRoute({ path: '/mcp', handler: mcp }),
+      ...createLanOnboardingRoutes(),
       {
         method: 'GET',
         path: '/health',
@@ -37,17 +40,30 @@ async function main(): Promise<void> {
       },
     ],
     wrapFetch: (fetch) => wrapInRequestContext(fetch),
+    bun:
+      env.DEV_HTTPS_CERT && env.DEV_HTTPS_KEY
+        ? {
+            tls: {
+              cert: Bun.file(env.DEV_HTTPS_CERT),
+              key: Bun.file(env.DEV_HTTPS_KEY),
+              ...(env.DEV_HTTPS_CA && { ca: Bun.file(env.DEV_HTTPS_CA) }),
+            },
+          }
+        : undefined,
   });
 
   async function shutdown(): Promise<void> {
     server.stop();
+    await mcp.close();
     await socket.io.close();
     await prisma.$disconnect();
   }
 
   process.once('SIGTERM', shutdown);
   process.once('SIGINT', shutdown);
-  console.log(`API listening on http://127.0.0.1:${env.API_PORT}`);
+  console.log(
+    `API listening on ${env.DEV_HTTPS_CERT ? 'https' : 'http'}://127.0.0.1:${env.API_PORT}`,
+  );
 }
 
 main().catch((error: unknown) => {

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

@@ -0,0 +1,62 @@
+import { describe, expect, test } from 'bun:test';
+import { defineContract } from 'stitchkit/contract';
+import { generateOpenApiDocument, implement } from 'stitchkit/server';
+import { z } from 'zod';
+import { assertSurfaceConformance, buildSurfaceManifest } from './surface-manifest';
+
+const service = implement(
+  defineContract(
+    { prefix: 'notes' },
+    {
+      read: {
+        method: 'GET',
+        path: '/:id',
+        desc: 'Read a note',
+        params: z.object({ id: z.string() }),
+        output: z.object({ id: z.string() }),
+      },
+    },
+  ),
+  { read: ({ params }) => ({ id: params.id }) },
+);
+
+describe('surface conformance', () => {
+  test('derives matching HTTP and MCP discovery identities without calling handlers', () => {
+    const manifest = buildSurfaceManifest([service]);
+    const openApi = generateOpenApiDocument({
+      info: { title: 'Test', version: '1.0.0' },
+      groups: [{ pathPrefix: '/api', services: [service] }],
+    });
+    expect(manifest).toEqual([
+      {
+        service: 'notes',
+        action: 'read',
+        http: [{ method: 'GET', path: '/api/notes/{id}' }],
+        tools: { AGENT: 'read_note', MCP: 'read_note' },
+      },
+    ]);
+    expect(() =>
+      assertSurfaceConformance({ manifest, openApi, mcpToolNames: ['read_note'] }),
+    ).not.toThrow();
+  });
+
+  test('fails with transport-specific expected and actual diagnostics', () => {
+    const manifest = buildSurfaceManifest([service]);
+    expect(() =>
+      assertSurfaceConformance({ manifest, openApi: { paths: {} }, mcpToolNames: [] }),
+    ).toThrow('HTTP/OpenAPI surface mismatch');
+    expect(() =>
+      assertSurfaceConformance({
+        manifest: manifest.map((operation) => ({ ...operation, http: [] })),
+        openApi: { paths: {} },
+        mcpToolNames: ['unexpected'],
+      }),
+    ).toThrow('MCP discovery surface mismatch');
+  });
+
+  test('fails first on duplicate contract identity', () => {
+    expect(() => buildSurfaceManifest([service, service])).toThrow(
+      'Duplicate operation identity notes.read',
+    );
+  });
+});

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",