groove-dev 0.27.44 → 0.27.47

package/node_modules/@groove-dev/daemon/src/api.js

@@ -6,6 +6,8 @@ import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, unlinkSync, renameSync, rmSync, createReadStream, copyFileSync, realpathSync } from 'fs';
 import { spawn, execFile } from 'child_process';
+import { createHash } from 'crypto';
+import { hostname, networkInterfaces, homedir } from 'os';
 import { lookup as mimeLookup } from './mimetypes.js';
 import { listProviders, getProvider } from './providers/index.js';
 import { OllamaProvider } from './providers/ollama.js';
@@ -3720,6 +3722,623 @@ Keep responses concise. Help them think, don't lecture them about the system the
     }
   });
 
+  // --- Groove Network (Beta) ---
+
+  // Offline fallback allowlist — used only when groovedev.ai is unreachable
+  // so beta testers aren't locked out by network failures.
+  const BETA_CODES_FALLBACK = new Set([
+    'GROOVE-NET-ALPHA-001',
+    'GROOVE-NET-ALPHA-002',
+    'GROOVE-NET-ALPHA-003',
+    'GROOVE-NET-ALPHA-004',
+    'GROOVE-NET-ALPHA-005',
+  ]);
+
+  const BETA_VALIDATE_URL = 'https://groovedev.ai/api/beta/validate';
+
+  function getMachineId() {
+    const nets = networkInterfaces();
+    const macs = [];
+    for (const name of Object.keys(nets)) {
+      for (const iface of nets[name] || []) {
+        if (iface.mac && iface.mac !== '00:00:00:00:00:00') macs.push(iface.mac);
+      }
+    }
+    macs.sort();
+    return createHash('sha256').update(`${hostname()}|${macs.join(',')}`).digest('hex');
+  }
+
+  async function validateCodeWithServer(code) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+      const response = await fetch(BETA_VALIDATE_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ code, machineId: getMachineId() }),
+        signal: controller.signal,
+      });
+      if (!response.ok && response.status !== 200) {
+        return { ok: false, reason: 'http', status: response.status };
+      }
+      const body = await response.json();
+      return { ok: true, result: body };
+    } catch (err) {
+      return { ok: false, reason: 'network', error: err.message };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  function isNetworkUnlocked() {
+    return !!(daemon.config?.networkBeta?.unlocked);
+  }
+
+  function networkGate(req, res, next) {
+    // Return 404 (not 403) so the feature is invisible until unlocked.
+    if (!isNetworkUnlocked()) return res.status(404).json({ error: 'Not found' });
+    next();
+  }
+
+  async function persistConfig() {
+    const { saveConfig } = await import('./firstrun.js');
+    saveConfig(daemon.grooveDir, daemon.config);
+  }
+
+  app.get('/api/beta/status', (req, res) => {
+    res.json({ unlocked: isNetworkUnlocked() });
+  });
+
+  app.post('/api/beta/activate', async (req, res) => {
+    const { code } = req.body || {};
+    if (typeof code !== 'string' || code.length > 64 || !/^[A-Z0-9-]+$/.test(code)) {
+      return res.status(400).json({ error: 'Invalid code format' });
+    }
+
+    const remote = await validateCodeWithServer(code);
+
+    let valid = false;
+    let message = 'Invalid invite code';
+    let expiresAt = null;
+    let features = [];
+    let source = 'server';
+
+    if (remote.ok && remote.result && typeof remote.result === 'object') {
+      valid = remote.result.valid === true;
+      if (typeof remote.result.message === 'string') message = remote.result.message;
+      if (typeof remote.result.expiresAt === 'string' || remote.result.expiresAt === null) {
+        expiresAt = remote.result.expiresAt || null;
+      }
+      if (Array.isArray(remote.result.features)) features = remote.result.features;
+    } else {
+      // Offline fallback — only trust the hardcoded list when we can't reach the server
+      source = 'fallback';
+      if (BETA_CODES_FALLBACK.has(code)) {
+        valid = true;
+        message = 'Activated (offline)';
+        features = ['network-node', 'network-consumer'];
+      } else {
+        message = 'Invalid invite code';
+      }
+    }
+
+    if (!valid) {
+      daemon.audit.log('beta.activate.denied', { codePrefix: code.slice(0, 10), source });
+      return res.status(200).json({ unlocked: false, message });
+    }
+
+    daemon.config.networkBeta = {
+      ...(daemon.config.networkBeta || {}),
+      unlocked: true,
+      code,
+      expiresAt,
+      features,
+    };
+    await persistConfig();
+    daemon.audit.log('beta.activate', { codePrefix: code.slice(0, 10), source, features });
+    daemon.broadcast({ type: 'config:updated' });
+    res.json({ unlocked: true, message, expiresAt, features });
+  });
+
+  // Re-validate stored code against groovedev.ai. Called at daemon startup
+  // so revoked or expired codes lock the feature automatically. Non-blocking.
+  daemon.revalidateBetaCode = async function revalidateBetaCode() {
+    const cfg = daemon.config?.networkBeta;
+    if (!cfg?.unlocked || !cfg?.code) return;
+    const remote = await validateCodeWithServer(cfg.code);
+    // If we couldn't reach the server, keep the current unlocked state —
+    // network failures must not lock out beta users.
+    if (!remote.ok || !remote.result || typeof remote.result !== 'object') return;
+    if (remote.result.valid === true) {
+      // Refresh features/expiresAt from server in case they changed
+      const next = {
+        ...cfg,
+        expiresAt: typeof remote.result.expiresAt === 'string' ? remote.result.expiresAt : null,
+        features: Array.isArray(remote.result.features) ? remote.result.features : (cfg.features || []),
+      };
+      if (JSON.stringify(next) !== JSON.stringify(cfg)) {
+        daemon.config.networkBeta = next;
+        await persistConfig();
+        daemon.broadcast({ type: 'config:updated' });
+      }
+      return;
+    }
+    // Server says invalid — revoke
+    daemon.config.networkBeta = {
+      ...cfg,
+      unlocked: false,
+      code: null,
+      expiresAt: null,
+      features: [],
+    };
+    await persistConfig();
+    daemon.audit.log('beta.revoked', { reason: remote.result.message || 'server denied' });
+    daemon.broadcast({ type: 'config:updated' });
+  };
+
+  app.post('/api/beta/deactivate', async (req, res) => {
+    // Stop the node if it's running before locking the feature away.
+    try {
+      if (daemon.networkNode?.proc && !daemon.networkNode.proc.killed) {
+        daemon.networkNode.proc.kill('SIGINT');
+      }
+    } catch { /* ignore */ }
+    daemon.networkNode = {
+      active: false, status: 'stopped', pid: null, proc: null,
+      nodeId: null, layers: null, model: null, sessions: 0,
+      hardware: null, startedAt: null, events: [],
+    };
+    daemon.config.networkBeta = {
+      ...(daemon.config.networkBeta || {}),
+      unlocked: false,
+      code: null,
+    };
+    await persistConfig();
+    daemon.audit.log('beta.deactivate', {});
+    daemon.broadcast({ type: 'config:updated' });
+    res.json({ unlocked: false });
+  });
+
+  // Network node lifecycle (gated)
+
+  function snapshotNode() {
+    const n = daemon.networkNode || {};
+    return {
+      active: !!n.active,
+      status: n.status || 'stopped',
+      nodeId: n.nodeId || null,
+      layers: n.layers || null,
+      model: n.model || null,
+      sessions: n.sessions || 0,
+      hardware: n.hardware || null,
+      installed: !!(daemon.config?.networkBeta?.installed),
+    };
+  }
+
+  function eventLevel(event) {
+    if (event === 'error' || event === 'crashed') return 'error';
+    if (event === 'exit' || event === 'stopping' || event === 'disconnected') return 'warning';
+    if (event === 'connected' || event === 'node registered' || event === 'shard loaded') return 'success';
+    if (event === 'serving session' || event === 'session complete' || event === 'session ended') return 'session';
+    return 'info';
+  }
+
+  function pushNodeEvent(event, details) {
+    const d = details || {};
+    const message = typeof d.msg === 'string' ? d.msg
+      : typeof d.message === 'string' ? d.message
+      : typeof d.line === 'string' ? d.line
+      : event;
+    const entry = {
+      timestamp: new Date().toISOString(),
+      event,
+      level: eventLevel(event),
+      message,
+      details: details || null,
+    };
+    daemon.networkNode.events = daemon.networkNode.events || [];
+    daemon.networkNode.events.push(entry);
+    if (daemon.networkNode.events.length > 200) {
+      daemon.networkNode.events = daemon.networkNode.events.slice(-200);
+    }
+    daemon.broadcast({ type: 'network:node:event', data: entry });
+  }
+
+  function normalizeHardware(caps) {
+    if (!caps || typeof caps !== 'object') return null;
+    const formatMb = (mb) => (Number.isFinite(mb) && mb > 0)
+      ? (mb >= 1024 ? `${(mb / 1024).toFixed(mb >= 10240 ? 0 : 1)} GB` : `${mb} MB`)
+      : null;
+    const vram = formatMb(caps.vram_mb);
+    const ram = formatMb(caps.ram_mb);
+    return {
+      device: caps.device || null,
+      gpu: caps.gpu_model || null,
+      memory: vram || ram || null,
+      vram,
+      ram,
+      cpuCores: caps.cpu_cores || null,
+      bandwidthMbps: caps.bandwidth_mbps || null,
+      maxContext: caps.max_context_length || null,
+    };
+  }
+
+  function broadcastNodeStatus() {
+    daemon.broadcast({ type: 'network:node:status', data: snapshotNode() });
+  }
+
+  app.get('/api/network/node/status', networkGate, (req, res) => {
+    res.json(snapshotNode());
+  });
+
+  app.post('/api/network/node/start', networkGate, (req, res) => {
+    if (daemon.networkNode?.active) {
+      return res.status(409).json({ error: 'Node already running' });
+    }
+
+    const cfg = daemon.config.networkBeta || {};
+    const relay = cfg.relayUrl || 'localhost:8770';
+    const device = cfg.devicePreference || 'auto';
+    const maxContext = Number.isFinite(cfg.maxContext) ? cfg.maxContext : 4096;
+
+    // Resolve deploy path (handles ~ and defaults to ~/Desktop/groove-deploy)
+    let deployPath = cfg.deployPath || null;
+    if (!deployPath) {
+      deployPath = resolve(process.env.HOME || '', 'Desktop/groove-deploy');
+    } else if (deployPath.startsWith('~/')) {
+      deployPath = resolve(process.env.HOME || '', deployPath.slice(2));
+    }
+
+    if (!existsSync(deployPath)) {
+      return res.status(400).json({ error: `Deploy path not found: ${deployPath}` });
+    }
+
+    const args = [
+      '-m', 'src.node.server',
+      '--relay', relay,
+      '--device', device,
+      '--max-context', String(maxContext),
+    ];
+
+    let proc;
+    try {
+      proc = spawn('python', args, {
+        cwd: deployPath,
+        env: { ...process.env, PYTHONUNBUFFERED: '1' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (err) {
+      return res.status(500).json({ error: `Failed to spawn node: ${err.message}` });
+    }
+
+    daemon.networkNode = {
+      active: true,
+      status: 'starting',
+      pid: proc.pid,
+      proc,
+      nodeId: null,
+      layers: null,
+      model: null,
+      sessions: 0,
+      hardware: null,
+      startedAt: Date.now(),
+      events: [],
+    };
+
+    pushNodeEvent('starting', { pid: proc.pid, relay, device });
+    broadcastNodeStatus();
+
+    let stderrBuf = '';
+    proc.stderr.on('data', (chunk) => {
+      stderrBuf += chunk.toString();
+      let idx;
+      while ((idx = stderrBuf.indexOf('\n')) !== -1) {
+        const line = stderrBuf.slice(0, idx).trim();
+        stderrBuf = stderrBuf.slice(idx + 1);
+        if (!line) continue;
+        if (line[0] !== '{') {
+          pushNodeEvent('log', { line });
+          continue;
+        }
+        let entry;
+        try { entry = JSON.parse(line); } catch { pushNodeEvent('log', { line }); continue; }
+        const msg = entry.msg || entry.event || '';
+        let changed = false;
+        if (entry.node_id && entry.node_id !== daemon.networkNode.nodeId) {
+          daemon.networkNode.nodeId = entry.node_id; changed = true;
+        }
+        if (msg === 'node registered' || msg === 'connected') {
+          daemon.networkNode.status = 'connected'; changed = true;
+        }
+        if (msg === 'shard loaded' || entry.layer_start !== undefined) {
+          if (entry.layer_start !== undefined && entry.layer_end !== undefined) {
+            daemon.networkNode.layers = [entry.layer_start, entry.layer_end]; changed = true;
+          }
+          if (entry.model_name) { daemon.networkNode.model = entry.model_name; changed = true; }
+        }
+        if (msg === 'serving session') {
+          daemon.networkNode.sessions = (daemon.networkNode.sessions || 0) + 1; changed = true;
+        }
+        if (msg === 'session complete' || msg === 'session ended') {
+          daemon.networkNode.sessions = Math.max(0, (daemon.networkNode.sessions || 0) - 1); changed = true;
+        }
+        if (entry.capabilities || entry.hardware) {
+          daemon.networkNode.hardware = normalizeHardware(entry.capabilities || entry.hardware); changed = true;
+        }
+        pushNodeEvent(msg || 'log', entry);
+        if (changed) broadcastNodeStatus();
+      }
+    });
+
+    proc.stdout.on('data', (chunk) => {
+      const line = chunk.toString().trim();
+      if (line) pushNodeEvent('stdout', { line });
+    });
+
+    proc.on('error', (err) => {
+      daemon.networkNode.status = 'error';
+      pushNodeEvent('error', { message: err.message });
+      broadcastNodeStatus();
+    });
+
+    proc.on('exit', (code, signal) => {
+      daemon.networkNode.active = false;
+      daemon.networkNode.status = 'stopped';
+      daemon.networkNode.pid = null;
+      daemon.networkNode.proc = null;
+      pushNodeEvent('exit', { code, signal });
+      broadcastNodeStatus();
+    });
+
+    daemon.audit.log('network.node.start', { pid: proc.pid, relay, device });
+    res.status(202).json({ started: true, ...snapshotNode() });
+  });
+
+  app.post('/api/network/node/stop', networkGate, (req, res) => {
+    const node = daemon.networkNode;
+    if (!node?.active || !node.proc) {
+      return res.status(409).json({ error: 'Node not running' });
+    }
+    try {
+      node.proc.kill('SIGINT');
+    } catch (err) {
+      return res.status(500).json({ error: `Failed to stop node: ${err.message}` });
+    }
+    daemon.networkNode.status = 'stopping';
+    pushNodeEvent('stopping', { pid: node.pid });
+    broadcastNodeStatus();
+    daemon.audit.log('network.node.stop', { pid: node.pid });
+    res.json({ stopping: true });
+  });
+
+  app.get('/api/network/status', networkGate, (req, res) => {
+    // Mocked relay status until the relay /status HTTP endpoint lands.
+    // Shape matches the spec in groove-comms/GETTING-STARTED.md.
+    const node = daemon.networkNode || {};
+    const selfNode = node.active && node.nodeId ? [{
+      node_id: node.nodeId,
+      device: node.hardware?.device || 'auto',
+      layers: node.layers || [0, 0],
+      status: node.status === 'connected' ? 'active' : node.status,
+    }] : [];
+    const coverage = node.layers ? (node.layers[1] - node.layers[0]) : 0;
+    res.json({
+      nodes: selfNode,
+      models: ['Qwen/Qwen2.5-0.5B'],
+      coverage,
+      totalLayers: 24,
+      activeSessions: node.sessions || 0,
+    });
+  });
+
+  // --- Network package install/uninstall ---
+
+  const NETWORK_REPO_URL = 'https://github.com/grooveai-dev/groove-network.git';
+  const NETWORK_VERSION = 'v0.1.0';
+
+  function networkRoot() {
+    return resolve(homedir(), '.groove', 'network');
+  }
+
+  // Defensive: only permit fs ops on paths that resolve inside ~/.groove/.
+  function isInsideGrooveHome(target) {
+    const home = resolve(homedir(), '.groove') + '/';
+    const full = resolve(target) + '/';
+    return full.startsWith(home);
+  }
+
+  function broadcastInstallProgress(step, message, percent) {
+    daemon.broadcast({
+      type: 'network:install:progress',
+      data: { step, message, percent },
+    });
+  }
+
+  app.get('/api/network/install/status', networkGate, (req, res) => {
+    const installPath = networkRoot();
+    const installed = existsSync(resolve(installPath, 'setup.sh'));
+    res.json({
+      installed,
+      path: installed ? installPath : null,
+      version: installed ? (daemon.config?.networkBeta?.version || null) : null,
+    });
+  });
+
+  app.post('/api/network/install', networkGate, async (req, res) => {
+    if (daemon.networkInstall?.running) {
+      return res.status(409).json({ error: 'Install already in progress' });
+    }
+    if (daemon.config?.networkBeta?.installed) {
+      return res.status(400).json({ error: 'Network package already installed' });
+    }
+
+    const installPath = networkRoot();
+    if (!isInsideGrooveHome(installPath)) {
+      return res.status(500).json({ error: 'Invalid install path' });
+    }
+
+    // Refuse to clone over an existing directory — avoids surprising merges.
+    if (existsSync(installPath)) {
+      return res.status(400).json({ error: 'Install path already exists; uninstall first' });
+    }
+
+    daemon.networkInstall = { running: true, startedAt: Date.now() };
+    res.status(200).json({ status: 'installing' });
+
+    // Run the install asynchronously; progress flows over WebSocket.
+    (async () => {
+      const cleanup = () => {
+        try {
+          if (existsSync(installPath) && isInsideGrooveHome(installPath)) {
+            rmSync(installPath, { recursive: true, force: true });
+          }
+        } catch { /* ignore */ }
+      };
+
+      const fail = (message) => {
+        cleanup();
+        broadcastInstallProgress('error', message, -1);
+        daemon.audit.log('network.install.failed', { message });
+        daemon.networkInstall = { running: false };
+      };
+
+      try {
+        // Build clone URL with optional PAT
+        const pat = daemon.credentials?.getKey?.('github-pat') || null;
+        const cloneUrl = pat
+          ? NETWORK_REPO_URL.replace('https://', `https://${pat}@`)
+          : NETWORK_REPO_URL;
+
+        broadcastInstallProgress('cloning', 'Cloning network package...', 0);
+
+        const cloneArgs = ['clone', '--branch', NETWORK_VERSION, '--depth', '1', cloneUrl, installPath];
+        const clone = spawn('git', cloneArgs, {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        });
+
+        let cloneErr = '';
+        clone.stderr.on('data', (chunk) => {
+          const s = chunk.toString();
+          cloneErr += s;
+          // git writes progress to stderr — relay last line as status.
+          const line = s.split('\n').map((l) => l.trim()).filter(Boolean).pop();
+          if (line) broadcastInstallProgress('cloning', line, 5);
+        });
+
+        const cloneCode = await new Promise((resolveClone) => {
+          clone.on('error', (err) => resolveClone({ code: -1, err: err.message }));
+          clone.on('close', (code) => resolveClone({ code }));
+        });
+
+        if (cloneCode.code !== 0) {
+          const hint = cloneErr.trim().split('\n').slice(-1)[0] || 'git clone failed';
+          return fail(`Clone failed: ${hint}`);
+        }
+
+        broadcastInstallProgress('cloned', 'Repository cloned', 10);
+
+        // Run setup.sh --json from the install directory
+        const setup = spawn('bash', ['setup.sh', '--json'], {
+          cwd: installPath,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          env: { ...process.env, PYTHONUNBUFFERED: '1' },
+        });
+
+        daemon.networkInstall.proc = setup;
+
+        let stdoutBuf = '';
+        setup.stdout.on('data', (chunk) => {
+          stdoutBuf += chunk.toString();
+          let idx;
+          while ((idx = stdoutBuf.indexOf('\n')) !== -1) {
+            const line = stdoutBuf.slice(0, idx).trim();
+            stdoutBuf = stdoutBuf.slice(idx + 1);
+            if (!line) continue;
+            if (line[0] !== '{') continue;
+            try {
+              const event = JSON.parse(line);
+              const step = typeof event.step === 'string' ? event.step : 'progress';
+              const message = typeof event.message === 'string' ? event.message : '';
+              const percent = Number.isFinite(event.percent) ? event.percent : null;
+              broadcastInstallProgress(step, message, percent);
+            } catch { /* non-JSON line, ignore */ }
+          }
+        });
+
+        let stderrBuf = '';
+        setup.stderr.on('data', (chunk) => {
+          stderrBuf += chunk.toString();
+        });
+
+        const setupResult = await new Promise((resolveSetup) => {
+          setup.on('error', (err) => resolveSetup({ code: -1, err: err.message }));
+          setup.on('close', (code) => resolveSetup({ code }));
+        });
+
+        if (setupResult.code !== 0) {
+          const hint = stderrBuf.trim().split('\n').slice(-1)[0] || `setup.sh exited ${setupResult.code}`;
+          return fail(`Setup failed: ${hint}`);
+        }
+
+        daemon.config.networkBeta = {
+          ...(daemon.config.networkBeta || {}),
+          installed: true,
+          deployPath: installPath,
+          version: NETWORK_VERSION,
+        };
+        await persistConfig();
+        daemon.broadcast({ type: 'config:updated' });
+        broadcastInstallProgress('done', 'Network package installed', 100);
+        daemon.audit.log('network.install', { path: installPath, version: NETWORK_VERSION });
+        daemon.networkInstall = { running: false };
+      } catch (err) {
+        fail(err?.message || 'Install failed');
+      }
+    })();
+  });
+
+  app.post('/api/network/uninstall', networkGate, async (req, res) => {
+    if (daemon.networkInstall?.running) {
+      return res.status(409).json({ error: 'Install in progress; wait for it to finish' });
+    }
+
+    // Stop the running node first (reuse existing stop logic).
+    try {
+      const node = daemon.networkNode;
+      if (node?.active && node.proc && !node.proc.killed) {
+        try { node.proc.kill('SIGINT'); } catch { /* ignore */ }
+        daemon.networkNode.status = 'stopping';
+        pushNodeEvent('stopping', { pid: node.pid, reason: 'uninstall' });
+        broadcastNodeStatus();
+      }
+    } catch { /* ignore */ }
+
+    const installPath = networkRoot();
+    if (!isInsideGrooveHome(installPath)) {
+      return res.status(500).json({ error: 'Invalid install path' });
+    }
+
+    try {
+      if (existsSync(installPath)) {
+        rmSync(installPath, { recursive: true, force: true });
+      }
+    } catch (err) {
+      return res.status(500).json({ error: `Failed to remove install: ${err.message}` });
+    }
+
+    daemon.config.networkBeta = {
+      ...(daemon.config.networkBeta || {}),
+      installed: false,
+      deployPath: null,
+      version: null,
+    };
+    await persistConfig();
+    daemon.broadcast({ type: 'config:updated' });
+    daemon.audit.log('network.uninstall', { path: installPath });
+    res.json({ status: 'uninstalled' });
+  });
+
   // Serve GUI static files (built GUI) — no-cache headers to prevent stale bundles
   const guiPath = process.env.GROOVE_GUI_PATH || resolve(__dirname, '../../gui/dist');
   app.use(express.static(guiPath, { etag: false, maxAge: 0, lastModified: false }));

package/node_modules/@groove-dev/daemon/src/firstrun.js

@@ -25,6 +25,16 @@ const DEFAULT_CONFIG = {
     autoRotate: true,
     tokenCeilingPerAgent: 5_000_000,
   },
+  networkBeta: {
+    unlocked: false,
+    code: null,
+    relayUrl: 'localhost:8770',
+    devicePreference: 'auto',
+    maxContext: 4096,
+    deployPath: null,
+    installed: false,
+    version: null,
+  },
   recentProjects: [],
 };
 
@@ -137,6 +147,7 @@ export function loadConfig(grooveDir) {
     const merged = { ...DEFAULT_CONFIG, ...saved };
     // Deep-merge safety subtree so partial user config doesn't drop defaults
     merged.safety = { ...DEFAULT_CONFIG.safety, ...(saved.safety || {}) };
+    merged.networkBeta = { ...DEFAULT_CONFIG.networkBeta, ...(saved.networkBeta || {}) };
     return merged;
   } catch {
     return { ...DEFAULT_CONFIG };