@bod.ee/db 0.7.0

package/cli.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env bun
+import { BodDB } from './index.ts';
+import { existsSync, mkdirSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { cpus, totalmem } from 'os';
+
+const args = process.argv.slice(2);
+const flags: Record<string, string> = {};
+let configPath: string | undefined;
+
+// Parse args
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '--help' || arg === '-h') { printHelp(); process.exit(0); }
+  if (arg === '--version' || arg === '-v') { printVersion(); process.exit(0); }
+  if (arg === '--init') { await initConfig(args[i + 1]); process.exit(0); }
+  if (arg.startsWith('--')) {
+    const [key, val] = arg.slice(2).split('=');
+    const booleanFlags = ['memory'];
+    if (val != null) {
+      flags[key] = val;
+    } else if (booleanFlags.includes(key)) {
+      flags[key] = 'true';
+    } else {
+      flags[key] = args[++i] ?? '';
+    }
+  } else if (!configPath) {
+    configPath = arg;
+  }
+}
+
+// Load config file
+let options: Record<string, unknown> = {};
+if (configPath) {
+  const abs = resolve(configPath);
+  if (configPath.endsWith('.ts') || configPath.endsWith('.js')) {
+    const mod = await import(abs);
+    options = { ...(mod.default ?? mod.config ?? mod) };
+  } else if (configPath.endsWith('.json')) {
+    const text = require('fs').readFileSync(abs, 'utf-8');
+    const parsed = JSON.parse(text);
+    options = { ...(parsed.config ?? parsed) };
+  }
+}
+
+// CLI flags override config
+if (flags.port) options.port = parseInt(flags.port, 10);
+if (flags.path) options.path = flags.path;
+if (flags.memory) options.path = ':memory:';
+
+// Ensure db directory exists
+const dbPath = (options.path as string) ?? ':memory:';
+if (dbPath !== ':memory:') {
+  const dir = dirname(resolve(dbPath));
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+const db = await BodDB.create(options as any);
+const server = db.serve();
+const port = server?.port ?? options.port ?? 4400;
+
+const line = (s: string) => `  │ ${s.padEnd(36)}│`;
+console.log([
+  '',
+  '  ┌──────────────────────────────────────┐',
+  line(` BodDB v${getVersion()}`),
+  '  ├──────────────────────────────────────┤',
+  line(` Port:    ${port}`),
+  line(` DB:      ${dbPath === ':memory:' ? ':memory:' : resolve(dbPath)}`),
+  line(` Config:  ${configPath ?? 'defaults'}`),
+  line(''),
+  line(` REST:    http://localhost:${port}`),
+  line(` WS:      ws://localhost:${port}`),
+  '  └──────────────────────────────────────┘',
+  '',
+].join('\n'));
+
+// Admin stats (for admin UI stats bar)
+if (options.transport?.staticRoutes) {
+  const { statSync } = require('fs');
+  let lastCpu = process.cpuUsage();
+  let lastTime = performance.now();
+  let lastOsCpus = cpus();
+  const systemCpuPercent = (): number => {
+    const cur = cpus();
+    let idleDelta = 0, totalDelta = 0;
+    for (let i = 0; i < cur.length; i++) {
+      const prev = lastOsCpus[i]?.times ?? cur[i].times;
+      const c = cur[i].times;
+      idleDelta += c.idle - prev.idle;
+      totalDelta += (c.user + c.nice + c.sys + c.irq + c.idle) - (prev.user + prev.nice + prev.sys + prev.irq + prev.idle);
+    }
+    lastOsCpus = cur;
+    return totalDelta > 0 ? +((1 - idleDelta / totalDelta) * 100).toFixed(1) : 0;
+  };
+  setInterval(() => {
+    if (!db.subs.subscriberCount('_admin')) return;
+    const now = performance.now();
+    const cpu = process.cpuUsage();
+    const elapsedUs = (now - lastTime) * 1000;
+    const cpuPercent = +((cpu.user - lastCpu.user + cpu.system - lastCpu.system) / elapsedUs * 100).toFixed(1);
+    lastCpu = cpu; lastTime = now;
+    const mem = process.memoryUsage();
+    const nodeCount = (db.storage.db.query('SELECT COUNT(*) as n FROM nodes WHERE mq_status IS NULL').get() as any).n;
+    let dbSizeMb = 0;
+    try { dbSizeMb = +(statSync(resolve(dbPath)).size / 1024 / 1024).toFixed(2); } catch {}
+    db.set('_admin/stats', {
+      process: { cpuPercent, heapUsedMb: +(mem.heapUsed / 1024 / 1024).toFixed(2), rssMb: +(mem.rss / 1024 / 1024).toFixed(2), uptimeSec: Math.floor(process.uptime()) },
+      db: { nodeCount, sizeMb: dbSizeMb },
+      system: { cpuCores: cpus().length, totalMemMb: +(totalmem() / 1024 / 1024).toFixed(0), cpuPercent: systemCpuPercent() },
+      subs: db.subs.subscriberCount(),
+      clients: db.transport?.clientCount ?? 0,
+      ts: Date.now(),
+    });
+  }, 1000);
+}
+
+// Graceful shutdown
+process.on('SIGINT', () => { db.close(); process.exit(0); });
+process.on('SIGTERM', () => { db.close(); process.exit(0); });
+
+function getVersion(): string {
+  try { return require('./package.json').version; } catch { return '0.0.0'; }
+}
+
+function printVersion() {
+  console.log(`bod-db v${getVersion()}`);
+}
+
+function printHelp() {
+  console.log(`
+  bod-db — embedded reactive database
+
+  Usage:
+    bod-db [config]          Start server with config file (.ts/.js/.json)
+    bod-db --init [path]     Generate a starter config file
+
+  Options:
+    --port <n>               Override port (default: 4400)
+    --path <file>            Override SQLite path
+    --memory                 Use in-memory database
+    -v, --version            Print version
+    -h, --help               Show this help
+
+  Examples:
+    bod-db                   Start with defaults (memory, port 4400)
+    bod-db config.ts         Start with config file
+    bod-db --port 3000       Start on port 3000
+    bod-db config.ts --port 5000   Config + port override
+    bod-db --init            Generate ./bod.config.ts
+`);
+}
+
+async function initConfig(dest?: string) {
+  const target = resolve(dest ?? 'bod.config.ts');
+  if (existsSync(target)) {
+    console.log(`  ✗ ${target} already exists`);
+    process.exit(1);
+  }
+  const template = `import type { BodDBOptions } from 'bod-db';
+
+export default {
+  path: './.tmp/bod.db',
+  port: 4400,
+  sweepInterval: 60000,
+  rules: {
+    '': { read: true, write: true },
+  },
+  indexes: {},
+  fts: {},
+  vectors: { dimensions: 384 },
+  mq: { visibilityTimeout: 30, maxDeliveries: 5 },
+} satisfies Partial<BodDBOptions>;
+`;
+  require('fs').writeFileSync(target, template);
+  console.log(`  ✓ Created ${target}`);
+}

package/client.ts

@@ -0,0 +1,2 @@
+export { BodClient, BodClientOptions, ValueSnapshot, ClientQueryBuilder, StreamReader, MQReader, MQMessageSnapshot } from './src/client/BodClient.ts';
+export type { ChildEvent, StreamEventSnapshot } from './src/client/BodClient.ts';

package/config.ts

@@ -0,0 +1,20 @@
+import type { BodDBOptions } from './src/server/BodDB.ts';
+
+export default {
+  path: './.tmp/bod.db',
+  port: 4400,
+  sweepInterval: 60000,
+  rules: {
+    '': { read: true, write: true },
+  },
+  indexes: {
+    'users': ['role', 'createdAt'],
+    'posts': ['authorId', 'createdAt', 'likes'],
+  },
+  fts: {},
+  vectors: { dimensions: 384 },
+  mq: { visibilityTimeout: 30, maxDeliveries: 5 },
+  compact: {
+    'events/logs': { maxAge: 86400 },
+  },
+} satisfies Partial<BodDBOptions>;

package/deploy/.env.example

@@ -0,0 +1 @@
+SSH_KEY_PATH=~/.ssh/id_ed25519

package/deploy/base.yaml

@@ -0,0 +1,18 @@
+droplet:
+  host: 157.151.221.191
+  user: ubuntu
+ssh:
+  privateKey: ~/.ssh/oracle_cloud
+app:
+  user: ubuntu
+runtime:
+  host: 0.0.0.0
+  nodeEnv: production
+service:
+  restart: always
+  restartSec: 2
+  killSignal: SIGINT
+https:
+  email: admin@livshitz.com
+deploy:
+  excludes: [.git, node_modules, .tmp, tests, .claude, .cursor, bun.lock, data]

package/deploy/boddb-logs.yaml

@@ -0,0 +1,10 @@
+app:
+  name: boddb-logs
+  dir: /opt/boddb-logs
+runtime:
+  port: 4401
+service:
+  name: boddb-logs
+  execStart: /home/ubuntu/.bun/bin/bun run cli.ts deploy/prod-logs.config.ts
+https:
+  domain: db-logs.bod.ee

package/deploy/boddb.yaml

@@ -0,0 +1,10 @@
+app:
+  name: boddb
+  dir: /opt/boddb
+runtime:
+  port: 4400
+service:
+  name: boddb
+  execStart: /home/ubuntu/.bun/bin/bun run cli.ts deploy/prod.config.ts
+https:
+  domain: db-main.bod.ee

package/deploy/demo.html

@@ -0,0 +1,196 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>BodDB Remote Demo</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: system-ui, sans-serif; background: #0a0a0a; color: #e0e0e0; padding: 2rem; max-width: 800px; margin: 0 auto; }
+  h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+  h2 { font-size: 1.1rem; margin: 1.5rem 0 0.5rem; color: #888; }
+  .status { padding: 0.5rem 1rem; border-radius: 6px; margin-bottom: 1rem; font-size: 0.9rem; }
+  .status.connected { background: #0a2e0a; border: 1px solid #1a5c1a; }
+  .status.disconnected { background: #2e0a0a; border: 1px solid #5c1a1a; }
+  .status.connecting { background: #2e2e0a; border: 1px solid #5c5c1a; }
+  .log { background: #111; border: 1px solid #333; border-radius: 6px; padding: 1rem; max-height: 200px; overflow-y: auto; font-family: monospace; font-size: 0.85rem; line-height: 1.6; }
+  .log .time { color: #666; }
+  .log .op { color: #6cf; }
+  .log .data { color: #8f8; }
+  .log .err { color: #f66; }
+  .controls { display: flex; gap: 0.5rem; flex-wrap: wrap; margin: 0.5rem 0; }
+  button { background: #222; border: 1px solid #444; color: #e0e0e0; padding: 0.4rem 0.8rem; border-radius: 4px; cursor: pointer; font-size: 0.85rem; }
+  button:hover { background: #333; }
+  input { background: #111; border: 1px solid #333; color: #e0e0e0; padding: 0.4rem 0.6rem; border-radius: 4px; font-size: 0.85rem; font-family: monospace; }
+  .row { display: flex; gap: 0.5rem; align-items: center; margin: 0.3rem 0; }
+  .live-value { background: #0a1a2e; border: 1px solid #1a3a5c; border-radius: 6px; padding: 1rem; font-family: monospace; font-size: 0.9rem; min-height: 3rem; white-space: pre-wrap; }
+  small { color: #666; }
+  #url { width: 300px; }
+</style>
+</head>
+<body>
+
+<h1>BodDB Remote Demo</h1>
+<div class="row">
+  <input id="url" value="wss://db-main.bod.ee" placeholder="wss://...">
+  <button onclick="doConnect()">Connect</button>
+  <button onclick="doDisconnect()">Disconnect</button>
+</div>
+<div id="status" class="status disconnected">Disconnected</div>
+
+<h2>CRUD</h2>
+<div class="controls">
+  <button onclick="doSet()">Set demo/hello</button>
+  <button onclick="doGet()">Get demo/hello</button>
+  <button onclick="doDelete()">Delete demo/hello</button>
+  <button onclick="doPush()">Push to demo/logs</button>
+  <button onclick="doGetLogs()">Get demo/logs</button>
+</div>
+
+<h2>Live Subscription <small>(demo/counter)</small></h2>
+<div class="controls">
+  <button onclick="doSubscribe()">Subscribe</button>
+  <button onclick="doUnsubscribe()">Unsubscribe</button>
+  <button onclick="doIncrement()">Increment</button>
+</div>
+<div id="live" class="live-value">—</div>
+
+<h2>Event Log</h2>
+<div id="log" class="log"></div>
+
+<script>
+let ws = null;
+let msgId = 0;
+let pending = {};
+let subActive = false;
+
+function log(op, data, isErr) {
+  const el = document.getElementById('log');
+  const time = new Date().toLocaleTimeString();
+  const cls = isErr ? 'err' : 'data';
+  el.innerHTML += `<div><span class="time">${time}</span> <span class="op">[${op}]</span> <span class="${cls}">${typeof data === 'string' ? data : JSON.stringify(data)}</span></div>`;
+  el.scrollTop = el.scrollHeight;
+}
+
+function setStatus(s) {
+  const el = document.getElementById('status');
+  el.textContent = s.charAt(0).toUpperCase() + s.slice(1);
+  el.className = 'status ' + s;
+}
+
+function send(op, params) {
+  return new Promise((resolve, reject) => {
+    const id = String(++msgId);
+    pending[id] = { resolve, reject };
+    ws.send(JSON.stringify({ id, op, ...params }));
+    setTimeout(() => { if (pending[id]) { delete pending[id]; reject(new Error('timeout')); } }, 10000);
+  });
+}
+
+function doConnect() {
+  if (ws && ws.readyState === WebSocket.OPEN) return;
+  const url = document.getElementById('url').value;
+  setStatus('connecting');
+  ws = new WebSocket(url);
+  ws.onopen = () => { setStatus('connected'); log('connect', 'Connected to ' + url); };
+  ws.onclose = () => { setStatus('disconnected'); log('close', 'Disconnected'); };
+  ws.onerror = (e) => { log('error', 'WebSocket error', true); };
+  ws.onmessage = (e) => {
+    const msg = JSON.parse(e.data);
+    // subscription event
+    if (msg.type === 'value') {
+      document.getElementById('live').textContent = JSON.stringify(msg.data, null, 2);
+      log('sub:value', { path: msg.path, data: msg.data });
+      return;
+    }
+    // request response
+    if (msg.id && pending[msg.id]) {
+      const p = pending[msg.id];
+      delete pending[msg.id];
+      if (msg.ok) p.resolve(msg.data);
+      else p.reject(new Error(msg.error));
+    }
+  };
+}
+
+function doDisconnect() { if (ws) { ws.close(); ws = null; subActive = false; } }
+
+async function timed(op, fn) {
+  const t0 = performance.now();
+  try {
+    const result = await fn();
+    const ms = (performance.now() - t0).toFixed(1);
+    return { result, ms };
+  } catch (e) {
+    const ms = (performance.now() - t0).toFixed(1);
+    log(op, `${e.message} (${ms}ms)`, true);
+    throw e;
+  }
+}
+
+async function doSet() {
+  try {
+    const { ms } = await timed('set', () => send('set', { path: 'demo/hello', value: { message: 'Hello from browser!', ts: Date.now() } }));
+    log('set', `demo/hello written (${ms}ms)`);
+  } catch (e) {}
+}
+
+async function doGet() {
+  try {
+    const { result, ms } = await timed('get', () => send('get', { path: 'demo/hello' }));
+    log('get', { data: result, ms: ms + 'ms' });
+  } catch (e) {}
+}
+
+async function doDelete() {
+  try {
+    const { ms } = await timed('delete', () => send('delete', { path: 'demo/hello' }));
+    log('delete', `demo/hello deleted (${ms}ms)`);
+  } catch (e) {}
+}
+
+async function doPush() {
+  try {
+    const { result, ms } = await timed('push', () => send('push', { path: 'demo/logs', value: { msg: 'event-' + Date.now(), ts: Date.now() } }));
+    log('push', `pushed key: ${result} (${ms}ms)`);
+  } catch (e) {}
+}
+
+async function doGetLogs() {
+  try {
+    const { result, ms } = await timed('get', () => send('get', { path: 'demo/logs' }));
+    log('get', { data: result, ms: ms + 'ms' });
+  } catch (e) {}
+}
+
+async function doSubscribe() {
+  if (subActive) return;
+  try {
+    const { ms } = await timed('sub', () => send('sub', { path: 'demo/counter', event: 'value' }));
+    subActive = true;
+    log('sub', `subscribed to demo/counter (${ms}ms)`);
+  } catch (e) {}
+}
+
+async function doUnsubscribe() {
+  if (!subActive) return;
+  try {
+    const { ms } = await timed('unsub', () => send('unsub', { path: 'demo/counter', event: 'value' }));
+    subActive = false;
+    document.getElementById('live').textContent = '—';
+    log('unsub', `unsubscribed from demo/counter (${ms}ms)`);
+  } catch (e) {}
+}
+
+async function doIncrement() {
+  try {
+    const t0 = performance.now();
+    const cur = await send('get', { path: 'demo/counter' });
+    await send('set', { path: 'demo/counter', value: (typeof cur === 'number' ? cur : 0) + 1 });
+    const ms = (performance.now() - t0).toFixed(1);
+    log('set', `demo/counter incremented (${ms}ms total)`);
+  } catch (e) { log('set', e.message, true); }
+}
+</script>
+</body>
+</html>

package/deploy/deploy.ts

@@ -0,0 +1,32 @@
+// Usage: bun run deploy/deploy.ts <instance> [bootstrap|deploy|logs|ssh|provision]
+// Deep-merges deploy/base.yaml + deploy/<instance>.yaml, writes .tmp/vmdrop.yaml, runs vmdrop
+
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { parse, stringify } from 'yaml';
+
+const [instance, cmd = 'deploy', ...rest] = process.argv.slice(2);
+if (!instance) { console.error('Usage: bun deploy/deploy.ts <instance> [cmd]'); process.exit(1); }
+
+const base = parse(readFileSync('deploy/base.yaml', 'utf8'));
+const override = parse(readFileSync(`deploy/${instance}.yaml`, 'utf8'));
+const merged = deepMerge(base, override);
+
+mkdirSync('.tmp', { recursive: true });
+writeFileSync('.tmp/vmdrop.yaml', stringify(merged));
+
+const proc = Bun.spawn(['bunx', 'vmdrop', cmd, '--config', '.tmp/vmdrop.yaml', ...rest], {
+  stdio: ['inherit', 'inherit', 'inherit'],
+});
+await proc.exited;
+process.exit(proc.exitCode ?? 0);
+
+function deepMerge(a: any, b: any): any {
+  if (!b) return a;
+  const result = { ...a };
+  for (const key of Object.keys(b)) {
+    result[key] = (typeof a[key] === 'object' && typeof b[key] === 'object' && !Array.isArray(b[key]))
+      ? deepMerge(a[key], b[key])
+      : b[key];
+  }
+  return result;
+}

package/deploy/prod-logs.config.ts

@@ -0,0 +1,15 @@
+export default {
+  path: './data/bod.db',
+  port: 4401,
+  sweepInterval: 60000,
+  rules: { '': { read: true, write: true } },
+  indexes: {},
+  fts: {},
+  mq: { visibilityTimeout: 30, maxDeliveries: 5 },
+  transport: {
+    staticRoutes: {
+      '/admin': './admin/ui.html',
+      '/': './admin/ui.html',
+    },
+  },
+}

package/deploy/prod.config.ts

@@ -0,0 +1,15 @@
+export default {
+  path: './data/bod.db',
+  port: 4400,
+  sweepInterval: 60000,
+  rules: { '': { read: true, write: true } },
+  indexes: {},
+  fts: {},
+  mq: { visibilityTimeout: 30, maxDeliveries: 5 },
+  transport: {
+    staticRoutes: {
+      '/admin': './admin/ui.html',
+      '/': './admin/ui.html',
+    },
+  },
+}

package/index.ts

@@ -0,0 +1,20 @@
+export { BodDB, BodDBOptions } from './src/server/BodDB.ts';
+export type { TransactionProxy } from './src/server/BodDB.ts';
+export { StorageEngine, StorageEngineOptions, generatePushId } from './src/server/StorageEngine.ts';
+export { SubscriptionEngine } from './src/server/SubscriptionEngine.ts';
+export { QueryEngine } from './src/server/QueryEngine.ts';
+export { RulesEngine, RulesEngineOptions } from './src/server/RulesEngine.ts';
+export type { RuleContext, PathRule } from './src/server/RulesEngine.ts';
+export { Transport, TransportOptions } from './src/server/Transport.ts';
+export { FTSEngine, FTSEngineOptions } from './src/server/FTSEngine.ts';
+export { VectorEngine, VectorEngineOptions } from './src/server/VectorEngine.ts';
+export { StreamEngine, StreamEngineOptions } from './src/server/StreamEngine.ts';
+export { MQEngine, MQEngineOptions } from './src/server/MQEngine.ts';
+export type { MQMessage } from './src/server/MQEngine.ts';
+export type { StreamEvent, CompactOptions, CompactResult, StreamSnapshot } from './src/server/StreamEngine.ts';
+export { FileAdapter, FileAdapterOptions } from './src/server/FileAdapter.ts';
+export { compileRule } from './src/server/ExpressionRules.ts';
+export { increment, serverTimestamp, arrayUnion, arrayRemove, ref } from './src/shared/transforms.ts';
+export * from './src/shared/protocol.ts';
+export * from './src/shared/errors.ts';
+export { normalizePath, validatePath, ancestors, parentPath, pathKey, prefixEnd, flatten, reconstruct } from './src/shared/pathUtils.ts';

package/mcp.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+import { BodClient } from './src/client/BodClient.ts';
+import { MCPAdapter } from './src/server/MCPAdapter.ts';
+
+const args = process.argv.slice(2);
+const flags: Record<string, string> = {};
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '--help' || arg === '-h') { printHelp(); process.exit(0); }
+  if (arg.startsWith('--')) {
+    const [key, val] = arg.slice(2).split('=');
+    const booleanFlags = ['stdio', 'http'];
+    if (val != null) flags[key] = val;
+    else if (booleanFlags.includes(key)) flags[key] = 'true';
+    else flags[key] = args[++i] ?? '';
+  }
+}
+
+const url = flags.url ?? `ws://localhost:${flags.port ?? '4400'}`;
+const mode = flags.http ? 'http' : 'stdio';
+
+const client = new BodClient({ url });
+try {
+  await client.connect();
+} catch (e: any) {
+  console.error(`Failed to connect to ${url} — is BodDB running? (${e.message ?? e})`);
+  process.exit(1);
+}
+console.error(`bod-db MCP connected to ${url}`);
+
+const mcp = new MCPAdapter(client);
+
+if (mode === 'stdio') {
+  mcp.serveStdio();
+} else {
+  const httpPort = parseInt(flags['http-port'] ?? flags.port ?? '4401', 10);
+  const handler = mcp.httpHandler();
+  Bun.serve({ port: httpPort, fetch: handler });
+  console.error(`bod-db MCP HTTP on http://localhost:${httpPort}`);
+}
+
+process.on('SIGINT', () => process.exit(0));
+process.on('SIGTERM', () => process.exit(0));
+
+function printHelp() {
+  console.log(`
+  bod-db-mcp — MCP client for a running BodDB server
+
+  Usage:
+    bod-db-mcp [options]
+
+  Transport (pick one):
+    --stdio              Line-delimited JSON-RPC on stdin/stdout (default)
+    --http               HTTP POST JSON-RPC server
+
+  Options:
+    --url <ws://...>     BodDB server URL (default: ws://localhost:4400)
+    --port <n>           Shorthand for --url ws://localhost:<n>
+    --http-port <n>      HTTP listen port when using --http (default: 4401)
+    -h, --help           Show this help
+
+  Examples:
+    bod-db-mcp --stdio
+    bod-db-mcp --stdio --port 4400
+    bod-db-mcp --http --http-port 4401
+
+  Claude Code .mcp.json:
+    {
+      "mcpServers": {
+        "bod-db": {
+          "command": "bun",
+          "args": ["run", "${import.meta.dir}/mcp.ts", "--stdio"]
+        }
+      }
+    }
+`);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@bod.ee/db",
+  "version": "0.7.0",
+  "module": "index.ts",
+  "type": "module",
+  "bin": {
+    "bod-db": "cli.ts",
+    "bod-db-mcp": "mcp.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "yaml": "^2.8.2"
+  },
+  "scripts": {
+    "admin": "bun --watch run admin/server.ts",
+    "serve": "bun run cli.ts",
+    "start": "bun run cli.ts config.ts",
+    "publish-lib": "bun publish --access public",
+    "mcp": "bun run mcp.ts --stdio",
+    "deploy": "bun run deploy/deploy.ts boddb deploy",
+    "deploy-logs-db": "bun run deploy/deploy.ts boddb-logs ",
+    "deploy:bootstrap": "bun run deploy/deploy.ts boddb bootstrap",
+    "deploy:logs": "bun run deploy/deploy.ts boddb logs",
+    "deploy:ssh": "bun run deploy/deploy.ts boddb ssh"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/react.ts

@@ -0,0 +1 @@
+export { useValue, useChildren, useQuery, useMutation } from './src/react/hooks.ts';