groove-dev 0.27.126 → 0.27.127

package/local-models/daemon-bridge.js

@@ -0,0 +1,87 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+import { existsSync, readdirSync } from 'fs';
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { pathToFileURL } from 'url';
+
+const port = 31415;
+const projectDir = process.argv[2] || process.cwd();
+
+function preflightCheck(daemonPath) {
+  if (!existsSync(daemonPath)) {
+    throw new Error(
+      `Daemon entry point not found at ${daemonPath}. ` +
+      'The app may not have been packaged correctly — try reinstalling Groove.'
+    );
+  }
+
+  const daemonDir = dirname(daemonPath);
+  const require = createRequire(daemonPath);
+  const critical = ['express', 'ws'];
+  const missing = critical.filter(dep => {
+    try { require.resolve(dep); return false; } catch { return true; }
+  });
+
+  if (missing.length) {
+    const diag = [`Missing deps: ${missing.join(', ')}`, `GROOVE_DAEMON_PATH: ${daemonPath}`];
+    let walkDir = daemonDir;
+    for (let i = 0; i < 5 && walkDir !== dirname(walkDir); i++) {
+      try {
+        const entries = readdirSync(walkDir);
+        diag.push(`${walkDir}/: [${entries.join(', ')}]`);
+      } catch { diag.push(`${walkDir}/: (unreadable)`); }
+      walkDir = dirname(walkDir);
+    }
+    throw new Error(
+      `Daemon is missing dependencies. ` +
+      `Diagnostics:\n${diag.join('\n')}\n` +
+      'The app bundle may be incomplete — try reinstalling Groove.'
+    );
+  }
+}
+
+async function main() {
+  let Daemon;
+  const daemonPath = process.env.GROOVE_DAEMON_PATH;
+
+  if (daemonPath) {
+    preflightCheck(daemonPath);
+    const mod = await import(pathToFileURL(daemonPath).href);
+    Daemon = mod.Daemon;
+  } else {
+    const mod = await import('@groove-dev/daemon');
+    Daemon = mod.Daemon;
+  }
+
+  const daemon = new Daemon({ port, projectDir });
+  await daemon.start();
+
+  process.send({ type: 'ready', port: daemon.port });
+
+  process.on('message', (msg) => {
+    if (msg.type === 'auth-token') {
+      (async () => {
+        try { await daemon.setAuthToken(msg.token); } catch (err) {
+          process.stderr.write(`[daemon-bridge] setAuthToken failed: ${err.message}\n`);
+        }
+      })();
+    }
+  });
+
+  process.on('SIGTERM', async () => {
+    await daemon.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGINT', async () => {
+    await daemon.stop();
+    process.exit(0);
+  });
+}
+
+main().catch((err) => {
+  if (process.send) {
+    process.send({ type: 'error', message: err.message });
+  }
+  process.exit(1);
+});

package/node_modules/@groove-dev/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.126",
+  "version": "0.27.127",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.126",
+  "version": "0.27.127",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -16,7 +16,7 @@ import { OllamaProvider } from './providers/ollama.js';
 import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groove-network.js';
 import { ConsentManager } from '../../../moe-training/client/index.js';
-import { validateAgentConfig, validateReasoningEffort, validateVerbosity, validateTeamMode } from './validate.js';
+import { validateAgentConfig, validateReasoningEffort, validateVerbosity, validateTeamMode, validateLabRuntimeConfig, validateLabInferenceParams, validateLabPresetConfig } from './validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from './process.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -1012,6 +1012,29 @@ export function createApi(app, daemon) {
     }
   });
 
+  app.post('/api/models/:id/import-to-ollama', async (req, res) => {
+    const model = daemon.modelManager.getModel(req.params.id);
+    if (!model) return res.status(404).json({ error: 'Model not found' });
+    const ggufPath = daemon.modelManager.getModelPath(req.params.id);
+    if (!ggufPath) return res.status(404).json({ error: 'Model file not found on disk' });
+    if (!OllamaProvider.isInstalled()) return res.status(400).json({ error: 'Ollama is not installed' });
+
+    const ollamaName = (model.id || model.filename.replace('.gguf', '')).toLowerCase().replace(/[^a-z0-9._-]/g, '-');
+    const modelfilePath = resolve(ggufPath + '.Modelfile');
+    try {
+      writeFileSync(modelfilePath, `FROM ${ggufPath}\n`);
+      const { execFileSync } = await import('child_process');
+      execFileSync('ollama', ['create', ollamaName, '-f', modelfilePath], { timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'] });
+      try { unlinkSync(modelfilePath); } catch {}
+      daemon.audit.log('model.import-ollama', { id: model.id, ollamaName });
+      daemon.broadcast({ type: 'ollama:model:imported', model: ollamaName });
+      res.json({ ok: true, ollamaName });
+    } catch (err) {
+      try { unlinkSync(modelfilePath); } catch {}
+      res.status(500).json({ error: `Import failed: ${err.message}` });
+    }
+  });
+
   app.get('/api/models/recommend', (req, res) => {
     const ramGb = parseInt(req.query.ram) || 16;
     const quant = daemon.modelManager.recommendQuantization('7B', ramGb);
@@ -6595,6 +6618,131 @@ Keep responses concise. Help them think, don't lecture them about the system the
     })();
   });
 
+  // --- Model Lab ---
+
+  app.get('/api/lab/runtimes', async (req, res) => {
+    try {
+      const runtimes = daemon.modelLab.listRuntimes();
+      const results = await Promise.all(runtimes.map(async (rt) => {
+        const status = await daemon.modelLab.getRuntimeStatus(rt);
+        return { ...rt, ...status };
+      }));
+      res.json(results);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/lab/runtimes', async (req, res) => {
+    try {
+      const config = validateLabRuntimeConfig(req.body);
+      const runtime = await daemon.modelLab.addRuntime(config);
+      res.status(201).json(runtime);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/lab/runtimes/:id', (req, res) => {
+    const removed = daemon.modelLab.removeRuntime(req.params.id);
+    if (!removed) return res.status(404).json({ error: 'Runtime not found' });
+    res.json({ ok: true });
+  });
+
+  app.post('/api/lab/runtimes/:id/test', async (req, res) => {
+    try {
+      const result = await daemon.modelLab.testRuntime(req.params.id);
+      res.json(result);
+    } catch (err) {
+      const status = err.message === 'Runtime not found' ? 404 : 500;
+      res.status(status).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/lab/runtimes/:id/models', async (req, res) => {
+    try {
+      const models = await daemon.modelLab.discoverModels(req.params.id);
+      res.json(models);
+    } catch (err) {
+      const status = err.message === 'Runtime not found' ? 404 : 500;
+      res.status(status).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/lab/inference', async (req, res) => {
+    try {
+      const params = validateLabInferenceParams(req.body);
+
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+      res.setHeader('X-Accel-Buffering', 'no');
+      res.flushHeaders();
+
+      let closed = false;
+      req.on('close', () => { closed = true; });
+
+      const stream = daemon.modelLab.streamInference(params);
+      for await (const event of stream) {
+        if (closed) break;
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+      }
+
+      if (!closed) {
+        res.write('data: [DONE]\n\n');
+        res.end();
+      }
+    } catch (err) {
+      if (!res.headersSent) {
+        res.status(400).json({ error: err.message });
+      } else {
+        res.write(`data: ${JSON.stringify({ type: 'error', error: err.message })}\n\n`);
+        res.end();
+      }
+    }
+  });
+
+  app.get('/api/lab/presets', (req, res) => {
+    res.json(daemon.modelLab.listPresets());
+  });
+
+  app.post('/api/lab/presets', (req, res) => {
+    try {
+      const config = validateLabPresetConfig(req.body);
+      const preset = daemon.modelLab.createPreset(config);
+      res.status(201).json(preset);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.patch('/api/lab/presets/:id', (req, res) => {
+    try {
+      const updates = validateLabPresetConfig({ ...req.body, name: req.body.name || 'temp' });
+      const preset = daemon.modelLab.updatePreset(req.params.id, updates);
+      if (!preset) return res.status(404).json({ error: 'Preset not found' });
+      res.json(preset);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/lab/presets/:id', (req, res) => {
+    const removed = daemon.modelLab.deletePreset(req.params.id);
+    if (!removed) return res.status(404).json({ error: 'Preset not found' });
+    res.json({ ok: true });
+  });
+
+  app.get('/api/lab/sessions', (req, res) => {
+    res.json(daemon.modelLab.listSessions());
+  });
+
+  app.get('/api/lab/sessions/:id', (req, res) => {
+    const session = daemon.modelLab.getSession(req.params.id);
+    if (!session) return res.status(404).json({ error: 'Session not found' });
+    res.json(session);
+  });
+
   // --- Wallet & earnings stubs (Base L2 — wired to real data post-mainnet) ---
 
   app.get('/api/network/wallet', networkGate, (req, res) => {

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

@@ -39,6 +39,7 @@ import { GatewayManager } from './gateways/manager.js';
 import { McpManager } from './mcp-manager.js';
 import { TunnelManager } from './tunnel-manager.js';
 import { ModelManager } from './model-manager.js';
+import { ModelLab } from './model-lab.js';
 import { LlamaServerManager } from './llama-server.js';
 import { RepoImporter } from './repo-import.js';
 import { ConversationManager } from './conversations.js';
@@ -151,6 +152,7 @@ export class Daemon {
     this.mcpManager = new McpManager(this);
     this.tunnelManager = new TunnelManager(this);
     this.repoImporter = new RepoImporter(this);
+    this.modelLab = new ModelLab(this);
     this.toys = new Toys(this);
     this.trajectoryCapture = null;