synabun 1.3.0

package/neural-interface/templates/CLAUDE-template.md

@@ -0,0 +1,211 @@
+# SynaBun — Persistent Vector Memory for AI Coding Tools
+
+Persistent vector memory via SQLite + local Transformers.js embeddings. Memories survive across sessions.
+
+---
+
+## Memory Ruleset
+
+> Portable ruleset — copy into any project's `CLAUDE.md`. Copy button in Neural Interface: Settings > Connections > Claude Code > Copy Ruleset.
+
+### Tools
+
+| Tool | Purpose |
+|------|---------|
+| `remember` | Store memory (content, category, project, tags, importance, related_files) |
+| `recall` | Semantic search across memories |
+| `forget` / `restore` | Trash / restore a memory by ID |
+| `reflect` | Update existing memory (importance, tags, content, category) |
+| `memories` | List recent or stats (recent, by-category, by-project) |
+| `sync` | Detect stale memories (file content changed) |
+| `category_create/update/delete/list` | Manage category hierarchy |
+
+### Auto-Recall
+
+- Session start: `recall` current project context
+- Topic mentioned: `recall` what you know
+- Before decisions: `recall` past decisions
+- Debugging: `recall` similar bugs
+
+### Auto-Remember (MANDATORY)
+
+After ANY task (bug fix, feature, refactor, config change, investigation, architecture decision), MUST `remember` BEFORE responding.
+
+**Steps:**
+1. `remember` — what + why + how, appropriate category, set project, related_files, importance (5=routine, 6-7=significant, 8+=critical), and 3-5 tags
+
+`remember` now returns the full UUID and accepts all fields (tags, importance) directly. No need to recall+reflect afterward.
+
+**NOT triggered by:** Simple Q&A, file reads with no findings, trivial typos.
+
+**Importance:** 1-2=trivial, 3-4=low, 5=normal, 6-7=significant, 8-9=critical, 10=foundational. User says "remember this" → 8+. Architecture decisions → 8+. API quirks → 6+.
+
+### Response Ordering (IMPORTANT)
+
+When finishing a task, structure your response as:
+1. Call `remember` (and any other memory tools) **FIRST**
+2. Write your completion summary / final message **LAST**
+
+Tool call results appear above text within a single response, so the summary naturally ends up at the bottom where the user sees it. This prevents memory tool calls from burying your completion message under noise.
+
+**Never** write your summary first and then call memory tools — the stop hook will block you, forcing a new response of memory tool calls that pushes your summary off-screen.
+
+### Category Selection
+
+1. Match existing child → use it
+2. Parent fits but no child → `category_create` child → use it
+3. Nothing fits → `category_create` parent + child → use it
+
+Never store directly in parent categories.
+
+### Tool Quirks
+
+- `remember` returns the full UUID and accepts tags + importance directly.
+- `reflect` requires FULL UUID — use the one returned by `remember`, or `recall` to find existing memories.
+- Sequential MCP calls only — never parallel.
+
+### Plan Mode (MANDATORY)
+
+When in plan mode and you need clarification or have questions:
+- **ALWAYS** use `AskUserQuestion` to present options — never write questions as plain text
+- Load the tool via `ToolSearch` first if its schema is not yet available
+- Structure as distinct choices (2-4 options per question, max 4 questions)
+- Use for approach clarification BEFORE finalizing the plan
+- Use `ExitPlanMode` (not AskUserQuestion) for final plan approval
+
+### Multi-Select Questions
+
+When using `AskUserQuestion`, set `multiSelect: true` when options are NOT mutually exclusive — i.e., the user could reasonably want more than one. Examples: selecting multiple features, tags, effects, or follow-up actions. Keep single-select (default) for inherently exclusive choices (one model, one style, one dimension).
+
+---
+
+## Coexistence with Other Tools
+
+When running SynaBun alongside other memory or code intelligence tools (CogniLayer, mem0, etc.):
+
+**SynaBun owns ALL memory operations:**
+- Storing information: `remember`
+- Searching past context: `recall`
+- Updating memories: `reflect`
+- Deleting/restoring: `forget` / `restore`
+- Browsing: `memories`
+- Stale detection: `sync`
+- Categories: `category` (create/update/delete/list)
+
+**Other tools** should be restricted to their non-memory capabilities only (e.g., AST-based code search, code impact analysis).
+
+**Enforcement rule for CLAUDE.md / project instructions:**
+```
+For ALL memory operations (store, search, recall, update, delete), use SynaBun tools exclusively.
+[OtherTool] is restricted to [specific use case, e.g., code_search, code_context, code_impact].
+Never use [OtherTool] for remembering, recalling, or reflecting on past work.
+```
+
+If you notice the AI defaulting to another tool's memory features, add the enforcement rule above to your project's `CLAUDE.md`.
+
+---
+
+## Condensed Rulesets
+
+### Cursor
+```
+# Memory: SynaBun MCP (SQLite + local embeddings)
+## Tools: remember, recall, forget, restore, reflect, memories, sync, category_create/update/delete/list
+## Rules
+- Session start: recall project context
+- After any task: remember what+why+how with tags + importance (MANDATORY)
+- Response ordering: call remember FIRST, then write your summary LAST. Never summary-then-tools.
+- Bug fixes: importance 7+. Architecture: 8+. User says "remember this": 8+
+- remember returns full UUID. Use reflect only to update existing memories.
+- Sequential MCP calls only
+- Scale: 1-2=trivial, 5=normal, 7=significant, 9=critical, 10=foundational
+- Plan mode: ALWAYS use AskUserQuestion for questions — never plain text. Use ExitPlanMode for plan approval.
+- AskUserQuestion: use multiSelect: true when options aren't mutually exclusive (multiple tags, features, effects, actions).
+```
+
+### Generic
+```
+## Memory: SynaBun MCP
+Tools: remember, recall, forget, restore, reflect, memories, sync, category_*
+- Recall at session start. Remember after every task with tags + importance (MANDATORY).
+- Response ordering: call remember FIRST, then write your summary LAST. Never summary-then-tools.
+- remember returns full UUID. reflect is for updating existing memories.
+- Sequential calls only. Scale: 1-2=trivial, 5=normal, 7=significant, 9=critical
+- Plan mode: ALWAYS use AskUserQuestion for questions — never plain text. Use ExitPlanMode for plan approval.
+- AskUserQuestion: use multiSelect: true when options aren't mutually exclusive (multiple tags, features, effects, actions).
+```
+
+### Gemini
+```
+## Memory: SynaBun MCP
+Tools: remember, recall, forget, restore, reflect, memories, sync, category_*
+- Recall at session start. Remember after every task with tags + importance (MANDATORY).
+- Response ordering: call remember FIRST, then write your summary LAST. Never summary-then-tools.
+- remember returns full UUID. reflect is for updating existing memories.
+- Sequential calls only. Scale: 1-2=trivial, 5=normal, 7=significant, 9=critical
+- Plan mode: ALWAYS use AskUserQuestion for questions — never plain text. Use ExitPlanMode for plan approval.
+- AskUserQuestion: use multiSelect: true when options aren't mutually exclusive (multiple tags, features, effects, actions).
+```
+
+### Codex
+```
+## Memory: SynaBun MCP
+Tools: remember, recall, forget, restore, reflect, memories, sync, category_*
+- Recall at session start. Remember after every task with tags + importance (MANDATORY).
+- Response ordering: call remember FIRST, then write your summary LAST. Never summary-then-tools.
+- remember returns full UUID. reflect is for updating existing memories.
+- Sequential calls only. Scale: 1-2=trivial, 5=normal, 7=significant, 9=critical
+- Plan mode: ALWAYS use AskUserQuestion for questions — never plain text. Use ExitPlanMode for plan approval.
+- AskUserQuestion: use multiSelect: true when options aren't mutually exclusive (multiple tags, features, effects, actions).
+```
+
+---
+
+## Hook System
+
+7 Claude Code hooks in `hooks/claude-code/`, registered in `~/.claude/settings.json`.
+
+| Hook | Script | Purpose |
+|------|--------|---------|
+| SessionStart | `session-start.mjs` | Greeting, boot sequence, compaction recovery, loop detection, session registration. |
+| UserPromptSubmit | `prompt-submit.mjs` | Tiered recall nudges, loop iteration injection, category tree on first threshold. |
+| PreCompact | `pre-compact.mjs` | Caches session data, sets pending-compact flag. |
+| Stop | `stop.mjs` | Combined obligations: compaction, loops, task memory, user learning, conversation turns, auto-store, unstored plans. |
+| PreToolUse | `pre-websearch.mjs` | Blocks WebSearch/WebFetch during active browser sessions. |
+| PostToolUse | `post-remember.mjs` | Tracks edits. Clears flags on remember. User learning flag management. |
+| PostToolUse | `post-plan.mjs` | Auto-stores plans in memory when exiting plan mode. |
+
+**Compaction chain:** PreCompact → flag → SessionStart injects → Claude remembers(conversations) → PostToolUse clears → Stop allows.
+**Task chain:** PostToolUse tracks edits → Stop blocks at 3+ → Claude remembers → cleared.
+
+---
+
+## Category System
+
+Stored in `mcp-server/data/custom-categories-{connId}.json`. Managed via MCP tools or Neural Interface UI.
+
+Descriptions are routing instructions: `"ONLY for deal/pricing memories"` not `"Pricing and stores"`.
+
+---
+
+## Development
+
+```
+synabun/
+├── mcp-server/          # TS MCP server → dist/ (npm run build)
+├── hooks/claude-code/   # 7 hook scripts (.mjs, ESM)
+├── neural-interface/    # Express server + public/ + templates/
+│   ├── public/          # index.html, onboarding.html, shared/ (modular JS/CSS)
+│   └── templates/       # CLAUDE-template.md (source of truth for rulesets)
+├── skills/              # Claude Code skill definitions
+├── data/                # Runtime flags, features, API keys
+└── .env                 # All config (optional overrides)
+```
+
+```bash
+node neural-interface/server.js                    # UI on :3344
+cd mcp-server && npm run build                     # Build MCP
+claude mcp add SynaBun -s user -- node ".../mcp-server/run.mjs"
+```
+
+**Architecture:** SQLite database (data/memory.db), local Transformers.js embeddings (384 dims), per-connection categories, ESM hooks, modular Neural Interface (vanilla JS + Three.js, shared/ modules), paths from `resolve(__dirname, '..')`.

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "synabun",
+  "version": "1.3.0",
+  "description": "Persistent vector memory for AI assistants",
+  "license": "Apache-2.0",
+  "author": "The SynaBun Authors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danilokhury/Synabun.git"
+  },
+  "homepage": "https://synabun.ai",
+  "type": "module",
+  "bin": {
+    "synabun": "setup.js"
+  },
+  "files": [
+    "setup.js",
+    "postinstall.js",
+    "mcp-server/package.json",
+    "mcp-server/tsconfig.json",
+    "mcp-server/src/",
+    "mcp-server/run.mjs",
+    "mcp-server/data/.gitkeep",
+    "neural-interface/package.json",
+    "neural-interface/server.js",
+    "neural-interface/public/",
+    "neural-interface/templates/",
+    "neural-interface/scripts/",
+    "hooks/",
+    "skills/",
+    "data/.gitkeep",
+    "CLAUDE.md",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "start": "node setup.js",
+    "postinstall": "node postinstall.js"
+  },
+  "keywords": [
+    "claude",
+    "memory",
+    "mcp",
+    "vector",
+    "embeddings",
+    "ai",
+    "persistent-memory",
+    "claude-code"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/postinstall.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun — NPM postinstall script
+ *
+ * Runs automatically after `npm install -g synabun`.
+ * Installs subdependencies and builds the MCP server.
+ * Does NOT start the server — that's setup.js / `synabun` command.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── ANSI color helpers ──
+
+const c = {
+  reset:  '\x1b[0m',
+  dim:    '\x1b[2m',
+  cyan:   '\x1b[36m',
+  green:  '\x1b[32m',
+  yellow: '\x1b[33m',
+  red:    '\x1b[31m',
+};
+
+function ok(msg)   { console.log(`  ${c.green}\u2713${c.reset} ${msg}`); }
+function warn(msg) { console.log(`  ${c.yellow}!${c.reset} ${msg}`); }
+function fail(msg) { console.log(`  ${c.red}\u2717${c.reset} ${msg}`); }
+function info(msg) { console.log(`  ${c.cyan}\u2192${c.reset} ${msg}`); }
+
+// ── Ensure data directories exist ──
+
+function ensureDirectories() {
+  const dirs = [
+    resolve(__dirname, 'data'),
+    resolve(__dirname, 'mcp-server', 'data'),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+// ── Dependency installation ──
+
+function needsInstall(dir) {
+  return !existsSync(resolve(dir, 'node_modules', '.package-lock.json'));
+}
+
+function installDeps(name, dir) {
+  if (!needsInstall(dir)) {
+    ok(`${name} dependencies already installed`);
+    return;
+  }
+
+  info(`Installing ${name} dependencies...`);
+  try {
+    execSync('npm install', {
+      cwd: dir,
+      stdio: 'inherit',
+      timeout: 300_000,
+    });
+    ok(`${name} dependencies installed`);
+  } catch (err) {
+    fail(`Failed to install ${name} dependencies`);
+    console.error(err.stderr?.toString() || err.message);
+    process.exit(1);
+  }
+}
+
+// ── node-pty native rebuild ──
+
+function rebuildPty() {
+  const rebuildScript = resolve(__dirname, 'neural-interface', 'scripts', 'rebuild-pty.js');
+  if (!existsSync(rebuildScript)) {
+    warn('rebuild-pty.js not found, skipping native rebuild');
+    return;
+  }
+
+  info('Rebuilding node-pty native addon...');
+  try {
+    execSync(`node "${rebuildScript}"`, {
+      cwd: resolve(__dirname, 'neural-interface'),
+      stdio: 'inherit',
+      timeout: 120_000,
+    });
+    ok('node-pty rebuilt');
+  } catch (err) {
+    warn('node-pty rebuild failed (terminal features may not work)');
+  }
+}
+
+// ── MCP server build ──
+
+function buildMcpServer() {
+  const distIndex = resolve(__dirname, 'mcp-server', 'dist', 'index.js');
+  if (existsSync(distIndex)) {
+    ok('MCP server already built');
+    return;
+  }
+
+  info('Building MCP server...');
+  try {
+    execSync('npm run build', {
+      cwd: resolve(__dirname, 'mcp-server'),
+      stdio: 'pipe',
+      timeout: 60_000,
+    });
+    ok('MCP server built');
+  } catch (err) {
+    fail('MCP server build failed');
+    console.error(err.stderr?.toString() || err.message);
+    process.exit(1);
+  }
+}
+
+// ── Main ──
+
+function main() {
+  console.log(`\n  ${c.cyan}SynaBun${c.reset} ${c.dim}postinstall${c.reset}\n`);
+
+  ensureDirectories();
+  installDeps('Neural Interface', resolve(__dirname, 'neural-interface'));
+  installDeps('MCP Server', resolve(__dirname, 'mcp-server'));
+  rebuildPty();
+  buildMcpServer();
+
+  console.log(`\n  ${c.green}\u2713${c.reset} Setup complete. Run ${c.cyan}synabun${c.reset} to start.\n`);
+}
+
+main();

package/setup.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun — Single-command setup & launch
+ *
+ * Usage: node setup.js   (or: npm start)
+ *
+ * 1. Checks Node.js version (>=22)
+ * 2. Installs npm deps for neural-interface/ and mcp-server/
+ * 3. Builds the MCP server TypeScript (if dist/ is missing or stale)
+ * 4. Starts the Neural Interface Express server
+ * 5. Auto-opens browser to onboarding wizard (or main page if setup complete)
+ */
+
+import { execSync, spawn, exec } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { platform } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── ANSI color helpers ──
+
+const c = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  dim:    '\x1b[2m',
+  cyan:   '\x1b[36m',
+  green:  '\x1b[32m',
+  yellow: '\x1b[33m',
+  red:    '\x1b[31m',
+};
+
+function ok(msg)   { console.log(`  ${c.green}\u2713${c.reset} ${msg}`); }
+function warn(msg) { console.log(`  ${c.yellow}!${c.reset} ${msg}`); }
+function fail(msg) { console.log(`  ${c.red}\u2717${c.reset} ${msg}`); }
+function info(msg) { console.log(`  ${c.cyan}\u2192${c.reset} ${msg}`); }
+
+// ── Phase 1: Prerequisite checks ──
+
+function checkNodeVersion() {
+  const [major] = process.versions.node.split('.').map(Number);
+  if (major < 22) {
+    fail(`Node.js 22+ required, found v${process.versions.node}`);
+    process.exit(1);
+  }
+  ok(`Node.js v${process.versions.node}`);
+}
+
+// ── Phase 2: Dependency installation ──
+
+function needsInstall(dir) {
+  // Check for .package-lock.json which npm creates after a successful install
+  // A bare node_modules/ directory (e.g. from a failed npx or partial install) is not enough
+  return !existsSync(resolve(dir, 'node_modules', '.package-lock.json'));
+}
+
+function installDeps(name, dir) {
+  if (!needsInstall(dir)) {
+    ok(`${name} dependencies already installed`);
+    return;
+  }
+
+  info(`Installing ${name} dependencies...`);
+  try {
+    execSync('npm install', {
+      cwd: dir,
+      stdio: 'inherit',
+      timeout: 300_000,
+    });
+    ok(`${name} dependencies installed`);
+  } catch (err) {
+    fail(`Failed to install ${name} dependencies`);
+    console.error(err.stderr?.toString() || err.message);
+    process.exit(1);
+  }
+}
+
+// ── Phase 3: Playwright Chromium (for browser automation) ──
+
+function installPlaywrightChromium() {
+  const niDir = resolve(__dirname, 'neural-interface');
+  // Check if already installed by resolving the executable path
+  try {
+    const result = execSync('node -e "const pw=require(\'playwright\');const p=pw.chromium.executablePath();process.stdout.write(p)"', {
+      cwd: niDir, encoding: 'utf8', timeout: 10_000,
+    });
+    if (existsSync(result)) {
+      ok('Playwright Chromium already installed');
+      return;
+    }
+  } catch { /* not installed */ }
+
+  info('Installing Playwright Chromium (for browser automation)...');
+  try {
+    execSync('npx playwright install chromium', {
+      cwd: niDir,
+      stdio: 'inherit',
+      timeout: 120_000,
+    });
+    ok('Playwright Chromium installed');
+  } catch (err) {
+    // Non-fatal — system Chrome will be used as fallback
+    console.log('  (optional) Playwright Chromium install failed — system Chrome will be used');
+  }
+}
+
+// ── Phase 4: MCP server build ──
+
+function needsBuild() {
+  const distIndex = resolve(__dirname, 'mcp-server', 'dist', 'index.js');
+  if (!existsSync(distIndex)) return true;
+
+  const srcIndex = resolve(__dirname, 'mcp-server', 'src', 'index.ts');
+  try {
+    return statSync(srcIndex).mtimeMs > statSync(distIndex).mtimeMs;
+  } catch {
+    return true;
+  }
+}
+
+function buildMcpServer() {
+  if (!needsBuild()) {
+    ok('MCP server already built');
+    return;
+  }
+
+  info('Building MCP server...');
+  try {
+    execSync('npm run build', {
+      cwd: resolve(__dirname, 'mcp-server'),
+      stdio: 'pipe',
+      timeout: 60_000,
+    });
+    ok('MCP server built');
+  } catch (err) {
+    fail('MCP server build failed');
+    console.error(err.stderr?.toString() || err.message);
+    process.exit(1);
+  }
+}
+
+// ── Phase 4: Setup state detection ──
+
+function isSetupComplete() {
+  const envPath = resolve(__dirname, '.env');
+  try {
+    const content = readFileSync(envPath, 'utf-8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('SETUP_COMPLETE=')) {
+        return trimmed.split('=')[1] === 'true';
+      }
+    }
+  } catch {}
+  return false;
+}
+
+// ── Phase 5: Server launch + browser open ──
+
+function openBrowser(url) {
+  const plat = platform();
+  const fallback = () => { warn('Could not open browser automatically'); info(`Open manually: ${url}`); };
+
+  if (plat === 'win32') {
+    exec(`start "" "${url}"`, (err) => { if (err) fallback(); });
+  } else if (plat === 'darwin') {
+    exec(`open "${url}"`, (err) => { if (err) fallback(); });
+  } else {
+    exec(`xdg-open "${url}"`, (err) => { if (err) fallback(); });
+  }
+}
+
+function startServer() {
+  const serverPath = resolve(__dirname, 'neural-interface', 'server.js');
+
+  info('Starting Neural Interface server...');
+  console.log('');
+
+  const child = spawn('node', [serverPath], {
+    cwd: resolve(__dirname, 'neural-interface'),
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  let opened = false;
+  const setupComplete = isSetupComplete();
+
+  child.stdout.on('data', (data) => {
+    process.stdout.write(data.toString());
+
+    if (!opened && data.toString().includes('Server:')) {
+      opened = true;
+      const port = data.toString().match(/Server:\s+http:\/\/localhost:(\d+)/)?.[1] || '3344';
+      const url = `http://localhost:${port}${setupComplete ? '/' : '/onboarding.html'}`;
+
+      if (!setupComplete) setTimeout(() => openBrowser(url), 1500);
+    }
+  });
+
+  child.stderr.on('data', (data) => {
+    process.stderr.write(data.toString());
+  });
+
+  child.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      fail(`Server exited with code ${code}`);
+      process.exit(code);
+    }
+  });
+
+  // Clean shutdown on Ctrl+C
+  process.on('SIGINT', () => { child.kill('SIGINT'); process.exit(0); });
+  process.on('SIGTERM', () => { child.kill('SIGTERM'); process.exit(0); });
+}
+
+// ── Main ──
+
+function main() {
+  console.log('');
+  console.log(`  ${c.cyan}╔═══════════════════════════════════╗${c.reset}`);
+  console.log(`  ${c.cyan}║${c.reset}                                   ${c.cyan}║${c.reset}`);
+  console.log(`  ${c.cyan}║${c.reset}   ${c.bold}${c.cyan}[██] [██]${c.reset}   ${c.bold}${c.cyan}SynaBun${c.reset}             ${c.cyan}║${c.reset}`);
+  console.log(`  ${c.cyan}║${c.reset}                                   ${c.cyan}║${c.reset}`);
+  console.log(`  ${c.cyan}║${c.reset}   ${c.dim}Persistent Vector Memory${c.reset}       ${c.cyan}║${c.reset}`);
+  console.log(`  ${c.cyan}║${c.reset}                                   ${c.cyan}║${c.reset}`);
+  console.log(`  ${c.cyan}╚═══════════════════════════════════╝${c.reset}`);
+  console.log(`           ${c.dim}synabun.ai${c.reset}`);
+  console.log('');
+
+  // Prerequisites
+  checkNodeVersion();
+  console.log('');
+
+  // Dependencies
+  installDeps('Neural Interface', resolve(__dirname, 'neural-interface'));
+  installDeps('MCP Server', resolve(__dirname, 'mcp-server'));
+  console.log('');
+
+  // Playwright browser
+  installPlaywrightChromium();
+  console.log('');
+
+  // Build
+  buildMcpServer();
+  console.log('');
+
+  // State
+  if (isSetupComplete()) {
+    ok('Setup already complete');
+  } else {
+    info('First-time setup \u2014 opening onboarding wizard');
+  }
+  console.log('');
+
+  // Launch
+  startServer();
+}
+
+main();