@runsnative/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,96 @@
+# @runsnative/mcp-server
+
+RunsNative MCP server — gives any MCP-capable agent access to RunsNative component docs, foundations, design exercises, and theme inference.
+
+Docs content is read from a local checkout of the [runsnative repo](https://github.com/KUKAMANGA-ENTERPRISES/runsnative) via `RUNSNATIVE_CONTENT_ROOT`. A cloud content API (no clone required, updates propagate without reinstalling) is in rollout; once live, the env var becomes optional and the server falls back to the cloud automatically.
+
+## Quick install
+
+Add one block to your MCP client config, pointing `RUNSNATIVE_CONTENT_ROOT` at the `content/` directory of a runsnative checkout.
+
+### Claude Desktop
+
+**macOS** — `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Windows** — `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "runsnative": {
+      "command": "npx",
+      "args": ["-y", "@runsnative/mcp-server"],
+      "env": {
+        "RUNSNATIVE_CONTENT_ROOT": "/path/to/runsnative/content"
+      }
+    }
+  }
+}
+```
+
+### Claude Code / Cursor (project-scoped)
+
+Add `.mcp.json` to your project root:
+
+```json
+{
+  "mcpServers": {
+    "runsnative": {
+      "command": "npx",
+      "args": ["-y", "@runsnative/mcp-server"],
+      "env": {
+        "RUNSNATIVE_CONTENT_ROOT": "/path/to/runsnative/content"
+      }
+    }
+  }
+}
+```
+
+## Authoring skill
+
+Once the MCP server is connected, load the RunsNative authoring skill to give your agent full component-authoring guidance. The skill is served at:
+
+```
+https://runsnative.org/ai/authoring-skill
+```
+
+Paste that URL into Claude's "Add custom skill" dialog, or add it to your agent's system prompt as a skill reference. The MCP tools and the authoring skill work together — the skill tells the agent *how* to author; the tools give it the live content.
+
+## Tools provided
+
+| Tool | Description |
+|---|---|
+| `list_components` | List all available RunsNative components |
+| `get_component` | Fetch usage, style, code, or accessibility docs for a component |
+| `list_composition_patterns` | List composition patterns (recipes) for complete UI surfaces — sign-in form, dashboard shell, chat room, etc. |
+| `get_composition_pattern` | Fetch the full pattern for a named recipe: preview spec, framework code examples, accessibility notes, customization guidance |
+| `get_foundation` | Fetch a specific foundation doc |
+| `get_step` | Fetch a specific step within an exercise |
+| `search_docs` | Semantic search across all RunsNative docs |
+| `list_exercises` | List available design exercises |
+| `start_exercise` | Start a design exercise |
+| `infer_theme` | Infer a RunsNative theme from a URL or description |
+| `infer_brand_theme` | Infer a theme from brand imagery |
+| `surface_preview` | Render a component fixture inside an MCP App iframe (RUN-477 sandbox verification, not a production surface) |
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `RUNSNATIVE_API_URL` | `https://api.runsnative.org/mcp` | Override the content API base URL (e.g. point at `wrangler dev` locally) |
+| `RUNSNATIVE_CACHE_DIR` | `~/.runsnative/cache` | Override the local content cache directory |
+| `RUNSNATIVE_CONTENT_ROOT` | *(unset)* | Set to use local content instead of the cloud API. For developers working in the RunsNative repo |
+| `RUNSNATIVE_TENANT_TOKEN` | *(unset)* | Bearer token for tenant-specific content access |
+
+## Requirements
+
+- Node.js 18 or later
+
+## For RunsNative repo developers
+
+If you're working inside the RunsNative repo, use the `.mcp.json` at the repo root. It points at `packages/mcp-server/dist/index.js` directly and sets `RUNSNATIVE_CONTENT_ROOT` so you get live content from your working tree without hitting the cloud API.
+
+Build first:
+
+```bash
+cd packages/mcp-server && npm run build
+```

package/dist/content.js

@@ -0,0 +1,324 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const VALID_TABS = ['usage', 'style', 'code', 'accessibility'];
+// Content store root — same directory the dotorg-site reads from.
+// fileURLToPath handles Windows drive letters correctly (avoids /C:/C:/ doubling).
+const CONTENT_ROOT = fileURLToPath(new URL('../../../content', import.meta.url));
+export function validateContentRoot() {
+    if (!existsSync(CONTENT_ROOT)) {
+        throw new Error(`Content store not found at ${CONTENT_ROOT}. ` +
+            `Run from the runsnative repo root or set RUNSNATIVE_CONTENT_ROOT.`);
+    }
+}
+export function isValidTab(tab) {
+    return VALID_TABS.includes(tab);
+}
+export async function getComponent(name, tab) {
+    if (!isValidTab(tab)) {
+        throw new RangeError(`Unknown tab "${tab}". Valid tabs: ${VALID_TABS.join(', ')}.`);
+    }
+    const filePath = join(CONTENT_ROOT, 'components', name, `${tab}.md`);
+    if (!existsSync(filePath)) {
+        throw new RangeError(`Component "${name}" has no "${tab}" tab. ` +
+            `Check content/components/${name}/${tab}.md exists and status is "ready".`);
+    }
+    return readFile(filePath, 'utf8');
+}
+// ---------------------------------------------------------------------------
+// Frontmatter parser — no external deps; handles simple key: value pairs.
+// Supports string, number, and bare boolean values. Does not handle YAML arrays.
+// ---------------------------------------------------------------------------
+export function parseFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const result = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+        if (key)
+            result[key] = value;
+    }
+    return result;
+}
+export async function listComponentMeta(includeDrafts = false) {
+    const componentsDir = join(CONTENT_ROOT, 'components');
+    if (!existsSync(componentsDir))
+        return [];
+    const entries = await readdir(componentsDir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const indexPath = join(componentsDir, entry.name, 'index.md');
+        if (!existsSync(indexPath))
+            continue;
+        const raw = await readFile(indexPath, 'utf8');
+        const fm = parseFrontmatter(raw);
+        const status = fm.status ?? 'unknown';
+        if (!includeDrafts && status !== 'ready')
+            continue;
+        results.push({
+            name: entry.name,
+            title: fm.title ?? entry.name,
+            element_tag: fm.element_tag ?? `run-${entry.name}`,
+            surface: fm.surface ?? 'unknown',
+            status,
+            purpose: fm.purpose ?? '',
+        });
+    }
+    return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function getFoundation(name) {
+    const filePath = join(CONTENT_ROOT, 'foundations', `${name}.md`);
+    if (!existsSync(filePath)) {
+        throw new RangeError(`Foundation "${name}" not found. ` +
+            `Check content/foundations/${name}.md exists.`);
+    }
+    return readFile(filePath, 'utf8');
+}
+export async function listFoundations() {
+    const foundationsDir = join(CONTENT_ROOT, 'foundations');
+    if (!existsSync(foundationsDir))
+        return [];
+    const entries = await readdir(foundationsDir);
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.md'))
+            continue;
+        const filePath = join(foundationsDir, entry);
+        const raw = await readFile(filePath, 'utf8');
+        const fm = parseFrontmatter(raw);
+        const name = entry.replace(/\.md$/, '');
+        results.push({
+            foundation: name,
+            title: fm.title ?? name,
+            description: fm.description ?? '',
+        });
+    }
+    return results.sort((a, b) => a.foundation.localeCompare(b.foundation));
+}
+function tokenize(text) {
+    return text.toLowerCase().match(/[a-z0-9_-]+/g) ?? [];
+}
+function excerpt(text, query, maxLen = 100) {
+    const tokens = tokenize(query);
+    const lower = text.toLowerCase();
+    let bestIdx = 0;
+    let bestScore = 0;
+    for (const token of tokens) {
+        const idx = lower.indexOf(token);
+        if (idx !== -1 && lower.split(token).length > bestScore) {
+            bestScore = lower.split(token).length;
+            bestIdx = Math.max(0, idx - 20);
+        }
+    }
+    const slice = text.slice(bestIdx, bestIdx + maxLen).replace(/\s+/g, ' ').trim();
+    return bestIdx > 0 ? `…${slice}` : slice;
+}
+function scoreDoc(text, queryTokens) {
+    const tokens = tokenize(text);
+    const freq = {};
+    for (const t of tokens)
+        freq[t] = (freq[t] ?? 0) + 1;
+    let score = 0;
+    for (const qt of queryTokens) {
+        if (freq[qt])
+            score += 1 + Math.log(freq[qt]);
+    }
+    return score;
+}
+export async function searchDocs(query, limit = 5) {
+    if (!query.trim())
+        return [];
+    const queryTokens = tokenize(query);
+    const candidates = [];
+    // Index component tabs
+    const componentsDir = join(CONTENT_ROOT, 'components');
+    if (existsSync(componentsDir)) {
+        const componentDirs = await readdir(componentsDir, { withFileTypes: true });
+        for (const dir of componentDirs) {
+            if (!dir.isDirectory())
+                continue;
+            for (const tab of VALID_TABS) {
+                const filePath = join(componentsDir, dir.name, `${tab}.md`);
+                if (!existsSync(filePath))
+                    continue;
+                const text = await readFile(filePath, 'utf8');
+                const score = scoreDoc(text, queryTokens);
+                if (score > 0) {
+                    candidates.push({
+                        type: 'component',
+                        name: dir.name,
+                        tab,
+                        excerpt: excerpt(text, query),
+                        score,
+                    });
+                }
+            }
+        }
+    }
+    // Index foundations
+    const foundationsDir = join(CONTENT_ROOT, 'foundations');
+    if (existsSync(foundationsDir)) {
+        const entries = await readdir(foundationsDir);
+        for (const entry of entries) {
+            if (!entry.endsWith('.md'))
+                continue;
+            const filePath = join(foundationsDir, entry);
+            const text = await readFile(filePath, 'utf8');
+            const score = scoreDoc(text, queryTokens);
+            if (score > 0) {
+                candidates.push({
+                    type: 'foundation',
+                    name: entry.replace(/\.md$/, ''),
+                    excerpt: excerpt(text, query),
+                    score,
+                });
+            }
+        }
+    }
+    return candidates
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}
+export async function listRecipeMeta() {
+    const recipesDir = join(CONTENT_ROOT, 'recipes');
+    if (!existsSync(recipesDir))
+        return [];
+    const entries = await readdir(recipesDir);
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.md'))
+            continue;
+        if (entry === '_index.md')
+            continue;
+        const filePath = join(recipesDir, entry);
+        const raw = await readFile(filePath, 'utf8');
+        const fm = parseFrontmatter(raw);
+        const name = entry.replace(/\.md$/, '');
+        results.push({
+            name,
+            title: fm['title'] ?? name,
+            group: fm['recipe-group'] ?? '',
+            status: fm['status'] ?? 'unknown',
+        });
+    }
+    return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function getRecipe(name) {
+    const filePath = join(CONTENT_ROOT, 'recipes', `${name}.md`);
+    if (!existsSync(filePath)) {
+        const available = (await listRecipeMeta()).map(r => r.name).join(', ');
+        throw new RangeError(`Recipe "${name}" not found. Available patterns: ${available || 'none'}.`);
+    }
+    return readFile(filePath, 'utf8');
+}
+function stripFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/);
+    if (!match)
+        return raw;
+    return raw.slice(match[0].length);
+}
+function extractSection(text, heading) {
+    // Split on ## boundaries, find the matching section, return its body.
+    // Regex lookahead approach breaks in /m mode because $ matches every line end.
+    const sections = text.split(/(?=^## )/m);
+    for (const section of sections) {
+        const headingLine = section.split(/\r?\n/)[0] ?? '';
+        if (headingLine.trim() === `## ${heading}`) {
+            const newlineIdx = section.indexOf('\n');
+            return newlineIdx !== -1 ? section.slice(newlineIdx).trim() : '';
+        }
+    }
+    return '';
+}
+export async function listExerciseMeta(includeDrafts = false) {
+    const exercisesDir = join(CONTENT_ROOT, 'exercises');
+    if (!existsSync(exercisesDir))
+        return [];
+    const entries = await readdir(exercisesDir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const indexPath = join(exercisesDir, entry.name, 'index.md');
+        if (!existsSync(indexPath))
+            continue;
+        const raw = await readFile(indexPath, 'utf8');
+        const fm = parseFrontmatter(raw);
+        const status = fm.status ?? 'unknown';
+        if (!includeDrafts && status !== 'ready')
+            continue;
+        results.push({
+            name: entry.name,
+            title: fm.title ?? entry.name,
+            tagline: fm.tagline ?? '',
+            activity_type: fm.activity_type ?? 'unknown',
+            difficulty: fm.difficulty ?? 'unknown',
+            estimated_minutes: parseInt(fm.estimated_minutes ?? '0', 10),
+            status,
+        });
+    }
+    return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function getExerciseDetail(name) {
+    const exercisesDir = join(CONTENT_ROOT, 'exercises');
+    const indexPath = join(exercisesDir, name, 'index.md');
+    if (!existsSync(indexPath)) {
+        throw new RangeError(`Exercise "${name}" not found. Check content/exercises/${name}/index.md exists.`);
+    }
+    const raw = await readFile(indexPath, 'utf8');
+    const fm = parseFrontmatter(raw);
+    const body = stripFrontmatter(raw);
+    const stepsDir = join(exercisesDir, name, 'steps');
+    const steps = [];
+    if (existsSync(stepsDir)) {
+        const stepFiles = (await readdir(stepsDir)).filter(f => f.endsWith('.md')).sort();
+        for (const file of stepFiles) {
+            const stepRaw = await readFile(join(stepsDir, file), 'utf8');
+            const stepFm = parseFrontmatter(stepRaw);
+            steps.push({
+                step: parseInt(stepFm.step ?? '0', 10),
+                slug: stepFm.slug ?? file.replace(/^\d+-/, '').replace(/\.md$/, ''),
+                title: stepFm.title ?? file,
+            });
+        }
+    }
+    steps.sort((a, b) => a.step - b.step);
+    return {
+        exercise: name,
+        title: fm.title ?? name,
+        overview: body.trim(),
+        steps,
+    };
+}
+export async function getExerciseStep(name, step) {
+    const exercisesDir = join(CONTENT_ROOT, 'exercises');
+    const stepsDir = join(exercisesDir, name, 'steps');
+    if (!existsSync(stepsDir)) {
+        throw new RangeError(`Exercise "${name}" not found.`);
+    }
+    const stepFiles = (await readdir(stepsDir)).filter(f => f.endsWith('.md')).sort();
+    const targetFile = stepFiles.find(f => /^(\d+)-/.exec(f)?.[1] === String(step));
+    if (!targetFile) {
+        throw new RangeError(`Step ${step} not found in exercise "${name}". ` +
+            `Valid steps: 1–${stepFiles.length}.`);
+    }
+    const raw = await readFile(join(stepsDir, targetFile), 'utf8');
+    const fm = parseFrontmatter(raw);
+    const body = stripFrontmatter(raw);
+    const goal = extractSection(body, 'Goal');
+    return {
+        exercise: name,
+        step,
+        title: fm.title ?? targetFile,
+        goal,
+        content: body.trim(),
+    };
+}

package/dist/http-server.js

@@ -0,0 +1,213 @@
+import { createServer as createHttpServer } from 'node:http';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { runInferencePipeline } from './inferrer/pipeline.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+async function callGenerateTokenBundle(config) {
+    const mod = await import('../../components/shared/token-engine.js');
+    return mod.generateTokenBundle(config);
+}
+async function getBackend() {
+    return import('../../brand-toolkit-backend/dist/index.js');
+}
+async function getSchema() {
+    return import('../../components/shared/brand-toolkit-config.js');
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+function sendJson(res, status, body) {
+    const json = JSON.stringify(body, null, 2);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+    });
+    res.end(json);
+}
+async function buildBrandToolkitConfig(body) {
+    const now = new Date().toISOString();
+    const candidate = {
+        id: randomUUID(),
+        customerId: body['customerId'],
+        brandId: body['brandId'],
+        parentConfigId: null,
+        theme: body['theme'],
+        style: body['style'] ?? 'default',
+        icons: body['icons'] ?? 'material',
+        audio: body['audio'] ?? { level: 'none' },
+        voice: body['voice'] ?? { type: 'preset', preset: 'professional' },
+        imagery: body['imagery'] ?? { involvement: 'supplied' },
+        createdAt: now,
+        updatedAt: now,
+    };
+    const { BrandToolkitConfigSchema } = await getSchema();
+    const result = BrandToolkitConfigSchema.safeParse(candidate);
+    if (!result.success) {
+        return {
+            ok: false,
+            status: 422,
+            body: {
+                error: 'Invalid brand toolkit config',
+                violations: result.error.issues.map(i => i.message),
+            },
+        };
+    }
+    return { ok: true, config: result.data };
+}
+function buildResolvedConfig(theme, customerId, brandId, sourceConfigId) {
+    return {
+        customerId,
+        brandId,
+        sourceConfigId,
+        theme,
+        style: 'default',
+        icons: 'material',
+        audio: { level: 'none' },
+        voice: { type: 'preset', preset: 'professional' },
+        imagery: { involvement: 'supplied' },
+    };
+}
+// ── Request handler ───────────────────────────────────────────────────────────
+async function handler(req, res) {
+    const method = req.method ?? 'GET';
+    const url = req.url ?? '/';
+    if (method === 'GET' && (url === '/' || url === '/brand-toolkit')) {
+        try {
+            const htmlPath = join(__dirname, '../../showcase/brand-toolkit.html');
+            const html = readFileSync(htmlPath, 'utf8');
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(html);
+        }
+        catch {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('brand-toolkit.html not found. Ensure packages/showcase/brand-toolkit.html exists.');
+        }
+        return;
+    }
+    if (method === 'OPTIONS') {
+        res.writeHead(204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+        });
+        res.end();
+        return;
+    }
+    if (method === 'POST' && url === '/api/infer') {
+        let body;
+        try {
+            body = JSON.parse(await readBody(req));
+        }
+        catch {
+            return sendJson(res, 400, { error: 'Request body must be valid JSON' });
+        }
+        if (typeof body !== 'object' || body === null ||
+            typeof body['url'] !== 'string') {
+            return sendJson(res, 400, { error: '{ url: string } required' });
+        }
+        const targetUrl = body['url'];
+        const result = await runInferencePipeline(targetUrl);
+        if (!result.ok)
+            return sendJson(res, 422, { error: result.error.message, code: result.error.code });
+        return sendJson(res, 200, result.result);
+    }
+    if (method === 'POST' && url === '/api/config') {
+        let body;
+        try {
+            body = JSON.parse(await readBody(req));
+        }
+        catch {
+            return sendJson(res, 400, { error: 'Request body must be valid JSON' });
+        }
+        const result = await buildBrandToolkitConfig(body);
+        if (!result.ok)
+            return sendJson(res, result.status, result.body);
+        const backend = await getBackend();
+        await backend.saveConfig(result.config);
+        return sendJson(res, 200, result.config);
+    }
+    if (method === 'GET' && url.startsWith('/api/config/')) {
+        const pathPart = url.split('?')[0];
+        const segments = pathPart.split('/').filter(Boolean);
+        // Expect: ['api', 'config', customerId, brandId]
+        if (segments.length !== 4) {
+            return sendJson(res, 400, { error: 'Expected /api/config/:customerId/:brandId' });
+        }
+        const customerId = decodeURIComponent(segments[2]);
+        const brandId = decodeURIComponent(segments[3]);
+        const backend = await getBackend();
+        const config = await backend.loadConfig(customerId, brandId);
+        if (!config)
+            return sendJson(res, 404, { error: 'not found' });
+        return sendJson(res, 200, config);
+    }
+    if (method === 'POST' && url === '/api/generate') {
+        let body;
+        try {
+            body = JSON.parse(await readBody(req));
+        }
+        catch {
+            return sendJson(res, 400, { error: 'Request body must be valid JSON' });
+        }
+        const buildResult = await buildBrandToolkitConfig(body);
+        if (!buildResult.ok)
+            return sendJson(res, buildResult.status, buildResult.body);
+        const config = buildResult.config;
+        const backend = await getBackend();
+        await backend.saveConfig(config);
+        const resolved = buildResolvedConfig(config.theme, config.customerId, config.brandId, config.id);
+        const engineResult = await callGenerateTokenBundle(resolved);
+        if (!engineResult.ok) {
+            return sendJson(res, 422, { error: engineResult.error.message, code: engineResult.error.code });
+        }
+        await backend.saveBundle(engineResult.bundle);
+        return sendJson(res, 200, {
+            bundle: engineResult.bundle,
+            configId: config.id,
+            engineVersion: engineResult.bundle.engineVersion,
+            generatedAt: engineResult.bundle.generatedAt,
+        });
+    }
+    sendJson(res, 404, { error: `Unknown route: ${method} ${url}` });
+}
+// ── Server ────────────────────────────────────────────────────────────────────
+export function startServer(port = 3201) {
+    const server = createHttpServer((req, res) => {
+        handler(req, res).catch(err => {
+            console.error('Unhandled handler error:', err);
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Internal server error' }));
+            }
+        });
+    });
+    server.listen(port, () => {
+        console.log(`RunsNative inferrer HTTP server listening on http://localhost:${port}`);
+        console.log(`  UI:       http://localhost:${port}/brand-toolkit`);
+        console.log(`  Config:   POST http://localhost:${port}/api/config   { customerId, brandId, theme, ... }`);
+        console.log(`  Generate: POST http://localhost:${port}/api/generate { customerId, brandId, theme, ... }`);
+    });
+    return server;
+}
+// ── Entry point ───────────────────────────────────────────────────────────────
+const isMain = process.argv[1] === __filename;
+if (isMain) {
+    const PORT = parseInt(process.env['INFERRER_PORT'] ?? '3201', 10);
+    const server = startServer(PORT);
+    async function shutdown() {
+        const backend = await getBackend();
+        await backend.closePool();
+        server.close();
+    }
+    process.on('SIGTERM', () => { shutdown().catch(console.error); });
+    process.on('SIGINT', () => { shutdown().catch(console.error); });
+}