groove-dev 0.27.124 → 0.27.125

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.124",
+  "version": "0.27.125",
   "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.124",
+  "version": "0.27.125",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -493,6 +493,8 @@ export function createApi(app, daemon) {
 
   // --- Ollama ---
 
+  const isValidModelId = (id) => typeof id === 'string' && id.length > 0 && id.length < 200 && /^[a-zA-Z0-9._:/-]+$/.test(id);
+
   app.get('/api/providers/ollama/hardware', (req, res) => {
     res.json(OllamaProvider.getSystemHardware());
   });
@@ -507,6 +509,7 @@ export function createApi(app, daemon) {
   app.post('/api/providers/ollama/pull', async (req, res) => {
     const { model } = req.body;
     if (!model) return res.status(400).json({ error: 'model is required' });
+    if (!isValidModelId(model)) return res.status(400).json({ error: 'Invalid model ID' });
     if (!OllamaProvider.isInstalled()) {
       const install = OllamaProvider.installCommand();
       return res.status(400).json({ error: `Ollama is not installed. Install with: ${install.command}` });
@@ -541,6 +544,7 @@ export function createApi(app, daemon) {
   });
 
   app.delete('/api/providers/ollama/models/:model', (req, res) => {
+    if (!isValidModelId(req.params.model)) return res.status(400).json({ error: 'Invalid model ID' });
     if (!OllamaProvider.isInstalled()) return res.status(400).json({ error: 'Ollama is not installed' });
     const success = OllamaProvider.deleteModel(req.params.model);
     if (success) {
@@ -604,6 +608,65 @@ export function createApi(app, daemon) {
     }
   });
 
+  app.get('/api/providers/ollama/running', async (req, res) => {
+    if (!OllamaProvider.isInstalled()) return res.json({ models: [] });
+    const serverRunning = await OllamaProvider.isServerRunning();
+    if (!serverRunning) return res.json({ models: [] });
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const apiRes = await fetch('http://localhost:11434/api/ps', { signal: controller.signal });
+      clearTimeout(timeout);
+      if (!apiRes.ok) return res.json({ models: [] });
+      const data = await apiRes.json();
+      const models = (data.models || []).map((m) => ({
+        name: m.name || m.model || '',
+        size: m.size || 0,
+        vram: m.size_vram ?? m.size ?? 0,
+        expires: m.expires_at || null,
+      }));
+      res.json({ models });
+    } catch {
+      res.json({ models: OllamaProvider.getRunningModels() });
+    }
+  });
+
+  app.post('/api/providers/ollama/load', async (req, res) => {
+    const { model } = req.body;
+    if (!model) return res.status(400).json({ error: 'model is required' });
+    if (!isValidModelId(model)) return res.status(400).json({ error: 'Invalid model ID' });
+    if (!OllamaProvider.isInstalled()) return res.status(400).json({ error: 'Ollama is not installed' });
+    const serverRunning = await OllamaProvider.isServerRunning();
+    if (!serverRunning) return res.status(400).json({ error: 'Ollama server is not running' });
+    try {
+      await OllamaProvider.loadModel(model);
+      daemon.broadcast({ type: 'ollama:model:loaded', model });
+      daemon.audit.log('ollama.model.load', { model });
+      res.json({ ok: true, model });
+    } catch (err) {
+      daemon.broadcast({ type: 'model:error', model, error: err.message });
+      res.status(500).json({ error: `Failed to load model: ${err.message}` });
+    }
+  });
+
+  app.post('/api/providers/ollama/unload', async (req, res) => {
+    const { model } = req.body;
+    if (!model) return res.status(400).json({ error: 'model is required' });
+    if (!isValidModelId(model)) return res.status(400).json({ error: 'Invalid model ID' });
+    if (!OllamaProvider.isInstalled()) return res.status(400).json({ error: 'Ollama is not installed' });
+    const serverRunning = await OllamaProvider.isServerRunning();
+    if (!serverRunning) return res.status(400).json({ error: 'Ollama server is not running' });
+    try {
+      await OllamaProvider.unloadModel(model);
+      daemon.broadcast({ type: 'ollama:model:unloaded', model });
+      daemon.audit.log('ollama.model.unload', { model });
+      res.json({ ok: true });
+    } catch (err) {
+      daemon.broadcast({ type: 'model:error', model, error: err.message });
+      res.status(500).json({ error: `Failed to unload model: ${err.message}` });
+    }
+  });
+
   // --- Provider Management (install, login, set-path, verify) ---
 
   const MANAGEABLE_PROVIDERS = new Set(['claude-code', 'codex', 'gemini']);
@@ -967,6 +1030,59 @@ export function createApi(app, daemon) {
     res.json({ models: recommended, hardware });
   });
 
+  // --- Ollama Running Models ---
+
+  app.get('/api/models/status', async (req, res) => {
+    const installed = OllamaProvider.isInstalled();
+    if (!installed) return res.json({ serverRunning: false, runningModels: [], installedModels: [], hardware: OllamaProvider.getSystemHardware() });
+    const serverRunning = await OllamaProvider.isServerRunning();
+    const runningModels = serverRunning ? OllamaProvider.getRunningModels() : [];
+    const installedModels = OllamaProvider.getInstalledModels();
+    const hardware = OllamaProvider.getSystemHardware();
+    res.json({ serverRunning, runningModels, installedModels, hardware });
+  });
+
+  app.get('/api/models/running', async (req, res) => {
+    if (!OllamaProvider.isInstalled()) return res.json([]);
+    const serverRunning = await OllamaProvider.isServerRunning();
+    if (!serverRunning) return res.json([]);
+    res.json(OllamaProvider.getRunningModels());
+  });
+
+  app.post('/api/models/:id/load', async (req, res) => {
+    const modelId = req.params.id;
+    if (!modelId) return res.status(400).json({ error: 'model id is required' });
+    if (!OllamaProvider.isInstalled()) return res.status(400).json({ error: 'Ollama is not installed' });
+    const serverRunning = await OllamaProvider.isServerRunning();
+    if (!serverRunning) return res.status(400).json({ error: 'Ollama server is not running' });
+    try {
+      const result = await OllamaProvider.loadModel(modelId);
+      daemon.broadcast({ type: 'model:loaded', model: modelId });
+      daemon.audit.log('model.load', { model: modelId });
+      res.json(result);
+    } catch (err) {
+      daemon.broadcast({ type: 'model:error', model: modelId, error: err.message });
+      res.status(500).json({ error: `Failed to load model: ${err.message}` });
+    }
+  });
+
+  app.post('/api/models/:id/unload', async (req, res) => {
+    const modelId = req.params.id;
+    if (!modelId) return res.status(400).json({ error: 'model id is required' });
+    if (!OllamaProvider.isInstalled()) return res.status(400).json({ error: 'Ollama is not installed' });
+    const serverRunning = await OllamaProvider.isServerRunning();
+    if (!serverRunning) return res.status(400).json({ error: 'Ollama server is not running' });
+    try {
+      const result = await OllamaProvider.unloadModel(modelId);
+      daemon.broadcast({ type: 'model:unloaded', model: modelId });
+      daemon.audit.log('model.unload', { model: modelId });
+      res.json(result);
+    } catch (err) {
+      daemon.broadcast({ type: 'model:error', model: modelId, error: err.message });
+      res.status(500).json({ error: `Failed to unload model: ${err.message}` });
+    }
+  });
+
   app.get('/api/llama/status', (req, res) => {
     res.json(daemon.llamaServer.getStatus());
   });
@@ -3916,8 +4032,14 @@ Keep responses concise. Help them think, don't lecture them about the system the
     // JS imports: from '/' and import('/')
     out = out.replace(/(from\s+(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
     out = out.replace(/(import\s*\(\s*(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    // JS bare import: import '/path'
+    out = out.replace(/(import\s+(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
     // CSS url()
     out = out.replace(/(url\s*\(\s*(["']?))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    // CSS @import '/path'
+    out = out.replace(/(@import\s+(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    // Vite base assignments: globalThis.__vite_base = "/" or window.__vite_base = "/"
+    out = out.replace(/((?:globalThis|window)\.__vite_base\s*=\s*(["']))\/(?=["'])/g, `$1${proxyBase}/`);
     return out;
   }
 

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

@@ -131,7 +131,13 @@ export class PreviewService {
           result = await this._launchStatic(teamId, baseDir, preview);
         }
       } else {
-        result = await this._launchStatic(teamId, baseDir, preview);
+        const distDir = resolve(baseDir, 'dist');
+        const openFile = (preview.openPath || 'index.html').replace(/^\/+/, '');
+        if (existsSync(resolve(distDir, openFile))) {
+          result = await this._launchStatic(teamId, distDir, { ...preview, openPath: openFile });
+        } else {
+          result = await this._launchStatic(teamId, baseDir, preview);
+        }
       }
     } else if (preview.kind === 'dev-server') {
       if (this._needsPreBuild(baseDir)) {
@@ -250,14 +256,31 @@ export class PreviewService {
   _runBuild(teamId, baseDir) {
     const pkgPath = resolve(baseDir, 'package.json');
     if (!existsSync(pkgPath)) return { failed: true, reason: 'no package.json for build' };
+    let pkg;
     try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
       if (!pkg.scripts?.build) return { failed: true, reason: 'no build script' };
     } catch { return { failed: true, reason: 'malformed package.json' }; }
+
+    const isVite = ['vite.config.js', 'vite.config.ts', 'vite.config.mjs']
+      .some((f) => existsSync(resolve(baseDir, f)));
+
+    let command = 'npm run build';
+    const buildScript = (pkg.scripts.build || '').trim();
+
+    if (isVite && /^(tsc\s*&&\s*)?vite\s+build\s*$/.test(buildScript)) {
+      command = `npm run build -- --base=./`;
+    }
+
+    const env = { ...process.env };
+    if (isVite && command === 'npm run build') {
+      env.VITE_BASE = './';
+    }
+
     try {
-      console.log(`[Groove:Preview] Running npm run build in ${baseDir}`);
-      this.daemon.audit?.log('preview.build', { teamId, baseDir });
-      execSync('npm run build', { cwd: baseDir, timeout: 120_000, stdio: 'pipe' });
+      console.log(`[Groove:Preview] Running ${command} in ${baseDir}`);
+      this.daemon.audit?.log('preview.build', { teamId, baseDir, command });
+      execSync(command, { cwd: baseDir, timeout: 120_000, stdio: 'pipe', env });
       return null;
     } catch (err) {
       return { failed: true, reason: `build failed: ${err.message?.slice(0, 300)}` };

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

@@ -6,6 +6,8 @@ import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, writ
 import { resolve, dirname, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { getProvider, getInstalledProviders, resolveProviderCommand } from './providers/index.js';
+import { LocalProvider } from './providers/local.js';
+import { OllamaProvider } from './providers/ollama.js';
 import { AgentLoop } from './agent-loop.js';
 import { validateAgentConfig } from './validate.js';
 
@@ -735,6 +737,25 @@ export class ProcessManager {
       );
     }
 
+    // Pre-flight for local model providers: ensure Ollama server is running and model is installed
+    if (providerName === 'local' || providerName === 'ollama') {
+      try {
+        await LocalProvider.ensureServerRunning();
+      } catch (err) {
+        const agent = registry.add({ ...config, provider: providerName, status: 'error' });
+        registry.update(agent.id, { status: 'error', error: 'Ollama server failed to start' });
+        this.daemon.broadcast({ type: 'model:error', agentId: agent.id, error: err.message });
+        throw new Error('Ollama server failed to start: ' + err.message);
+      }
+      if (config.model && config.model !== 'auto') {
+        const installed = OllamaProvider.getInstalledModels();
+        const modelInstalled = installed.some((m) => m.id === config.model || config.model.startsWith(m.id.split(':')[0]));
+        if (!modelInstalled) {
+          throw new Error(`Model '${config.model}' is not installed. Pull it first with: ollama pull ${config.model}`);
+        }
+      }
+    }
+
     // Validate explicit model against provider's supported models
     if (config.model && config.model !== 'auto' && provider.constructor.models) {
       const valid = provider.constructor.models.some(m => m.id === config.model);

package/node_modules/@groove-dev/daemon/src/providers/local.js

@@ -59,27 +59,13 @@ export class LocalProvider extends Provider {
 
   // Only return models that are actually installed and ready to use
   static get models() {
-    const installed = [];
+    if (!LocalProvider._hasOllama()) return [];
 
-    // Ollama installed models
-    if (LocalProvider._hasOllama()) {
-      try {
-        const ollamaModels = OllamaProvider.getInstalledModels();
-        for (const m of ollamaModels) {
-          installed.push({
-            id: m.id, name: m.name || m.id,
-            tier: m.tier || 'medium', category: m.category || 'general',
-          });
-        }
-      } catch { /* Ollama not running */ }
-    }
-
-    // If nothing installed, show a hint instead of a blank list
-    if (installed.length === 0) {
-      return [{ id: '_none', name: 'No models installed — pull one with: ollama pull qwen2.5-coder:7b', tier: 'medium', disabled: true }];
-    }
-
-    return installed;
+    const ollamaModels = OllamaProvider.getInstalledModels();
+    return ollamaModels.map((m) => ({
+      id: m.id, name: m.name || m.id,
+      tier: m.tier || 'medium', category: m.category || 'general',
+    }));
   }
 
   // Full catalog for the Models browser (includes uninstalled)
@@ -123,6 +109,19 @@ export class LocalProvider extends Provider {
     return OllamaProvider.getInstalledModels();
   }
 
+  static async ensureServerRunning() {
+    if (!LocalProvider._hasOllama()) {
+      throw new Error('Ollama binary not found. Install with: ' + OllamaProvider.installCommand().command);
+    }
+    if (await OllamaProvider.isServerRunning()) return true;
+    OllamaProvider.startServer();
+    for (let i = 0; i < 20; i++) {
+      await new Promise((r) => setTimeout(r, 500));
+      if (await OllamaProvider.isServerRunning()) return true;
+    }
+    throw new Error('Ollama server failed to start within 10s');
+  }
+
   /**
    * Get configuration for the agent loop runtime.
    * Called by ProcessManager when useAgentLoop is true.

package/node_modules/@groove-dev/daemon/src/providers/ollama.js

@@ -1,8 +1,7 @@
 // GROOVE — Ollama Provider (Local Models)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { execSync } from 'child_process';
-import { execFile } from 'child_process';
+import { execSync, execFile, execFileSync } from 'child_process';
 import os from 'os';
 import { Provider } from './base.js';
 
@@ -246,9 +245,73 @@ export class OllamaProvider extends Provider {
     });
   }
 
+  static getRunningModels() {
+    try {
+      const output = execSync('ollama ps', { encoding: 'utf8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] });
+      const lines = output.split('\n').slice(1).filter(Boolean);
+      return lines.map((line) => {
+        const parts = line.split(/\s+/);
+        return {
+          id: parts[0] || '',
+          name: parts[0] || '',
+          size: parts[1] || '',
+          vram: parts[2] || '',
+          processor: parts[3] || '',
+          until: parts.slice(4).join(' ') || '',
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  static async loadModel(modelId) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 60000);
+    try {
+      const res = await fetch('http://localhost:11434/api/generate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ model: modelId, prompt: '', keep_alive: '10m' }),
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Ollama API ${res.status}: ${text.slice(0, 200)}`);
+      }
+      return { loaded: true, model: modelId };
+    } catch (err) {
+      clearTimeout(timeout);
+      throw err;
+    }
+  }
+
+  static async unloadModel(modelId) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10000);
+    try {
+      const res = await fetch('http://localhost:11434/api/generate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ model: modelId, prompt: '', keep_alive: 0 }),
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Ollama API ${res.status}: ${text.slice(0, 200)}`);
+      }
+      return { unloaded: true, model: modelId };
+    } catch (err) {
+      clearTimeout(timeout);
+      throw err;
+    }
+  }
+
   static deleteModel(modelId) {
     try {
-      execSync(`ollama rm ${modelId}`, { encoding: 'utf8', timeout: 30000 });
+      execFileSync('ollama', ['rm', modelId], { encoding: 'utf8', timeout: 30000 });
       return true;
     } catch {
       return false;