groove-dev 0.27.70 → 0.27.72

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

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

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

@@ -2,7 +2,7 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import express from 'express';
-import { resolve, dirname, join, sep, relative } from 'path';
+import { resolve, dirname, join, sep, relative, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, unlinkSync, renameSync, rmSync, createReadStream, copyFileSync, realpathSync } from 'fs';
 import { spawn, execFile, execFileSync } from 'child_process';
@@ -10,7 +10,7 @@ import { createHash, randomUUID } from 'crypto';
 import { hostname, networkInterfaces, homedir } from 'os';
 import { StringDecoder } from 'string_decoder';
 import { lookup as mimeLookup } from './mimetypes.js';
-import { listProviders, getProvider } from './providers/index.js';
+import { listProviders, getProvider, clearInstallCache, getProviderMetadata, getProviderPath, setProviderPaths } from './providers/index.js';
 import { OllamaProvider } from './providers/ollama.js';
 import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groove-network.js';
@@ -441,12 +441,18 @@ export function createApi(app, daemon) {
   // List available providers
   app.get('/api/providers', (req, res) => {
     const providers = listProviders();
-    // Enrich with credential status
     for (const p of providers) {
       p.hasKey = daemon.credentials.hasKey(p.id);
       if (p.id === 'claude-code') {
         p.authStatus = ClaudeCodeProvider.getAuthStatus();
       }
+      const meta = getProviderMetadata(p.id);
+      if (meta) {
+        p.setupGuide = meta.setupGuide;
+        p.authMethods = meta.authMethods;
+      }
+      const customPath = getProviderPath(p.id);
+      if (customPath) p.providerPath = customPath;
     }
     res.json(providers);
   });
@@ -576,6 +582,271 @@ export function createApi(app, daemon) {
     }
   });
 
+  // --- Provider Management (install, login, set-path, verify) ---
+
+  const MANAGEABLE_PROVIDERS = new Set(['claude-code', 'codex', 'gemini']);
+
+  app.post('/api/providers/:id/install', (req, res) => {
+    const { id } = req.params;
+    if (!MANAGEABLE_PROVIDERS.has(id)) {
+      return res.status(400).json({ error: `Invalid provider. Valid: ${[...MANAGEABLE_PROVIDERS].join(', ')}` });
+    }
+
+    const INSTALL_PACKAGES = {
+      'claude-code': '@anthropic-ai/claude-code',
+      'codex': '@openai/codex',
+      'gemini': '@google/gemini-cli',
+    };
+    const pkg = INSTALL_PACKAGES[id];
+
+    res.setHeader('Content-Type', 'application/x-ndjson');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    res.setHeader('Cache-Control', 'no-cache');
+
+    const write = (obj) => {
+      try { res.write(JSON.stringify(obj) + '\n'); } catch { /* client disconnected */ }
+    };
+
+    write({ status: 'installing', output: `Installing ${pkg}...`, progress: 0 });
+
+    const proc = spawn('npm', ['install', '-g', pkg], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
+      env: { ...process.env, NODE_ENV: undefined },
+    });
+
+    let output = '';
+    let errOutput = '';
+
+    proc.stdout.on('data', (data) => {
+      output += data.toString();
+      write({ status: 'installing', output: data.toString().trim(), progress: 50 });
+    });
+
+    proc.stderr.on('data', (data) => {
+      errOutput += data.toString();
+      const line = data.toString().trim();
+      if (line) write({ status: 'installing', output: line, progress: 50 });
+    });
+
+    proc.on('close', (code) => {
+      clearInstallCache();
+      const providerObj = getProvider(id);
+      const installed = providerObj ? providerObj.constructor.isInstalled() : false;
+
+      if (code === 0 && installed) {
+        write({ status: 'complete', output: `${pkg} installed successfully`, progress: 100, installed: true });
+        daemon.audit.log('provider.install', { provider: id, pkg, success: true });
+        daemon.broadcast({ type: 'provider:status-changed', provider: id });
+      } else {
+        const reason = code !== 0
+          ? (errOutput || output).slice(-500)
+          : 'Install succeeded but provider binary not found in PATH';
+        write({ status: 'error', output: reason, progress: 100, installed: false });
+        daemon.audit.log('provider.install', { provider: id, pkg, success: false, code });
+      }
+      res.end();
+    });
+
+    proc.on('error', (err) => {
+      write({ status: 'error', output: `Failed to start npm: ${err.message}`, progress: 100, installed: false });
+      res.end();
+    });
+
+    req.on('close', () => {
+      try { proc.kill(); } catch { /* already exited */ }
+    });
+  });
+
+  app.post('/api/providers/:id/login', async (req, res) => {
+    const { id } = req.params;
+    if (!MANAGEABLE_PROVIDERS.has(id)) {
+      return res.status(400).json({ error: `Invalid provider. Valid: ${[...MANAGEABLE_PROVIDERS].join(', ')}` });
+    }
+
+    if (id === 'gemini') {
+      return res.json({ status: 'not-supported', message: 'Gemini uses API key authentication. Set your key in Settings.' });
+    }
+
+    if (id === 'claude-code') {
+      const providerObj = getProvider(id);
+      if (!providerObj || !providerObj.constructor.isInstalled()) {
+        return res.status(400).json({ error: 'Claude Code is not installed. Install it first.' });
+      }
+      daemon.audit.log('provider.login.started', { provider: id });
+      try {
+        const result = await ClaudeCodeProvider.startLogin();
+        clearInstallCache();
+        daemon.broadcast({ type: 'provider:status-changed', provider: id });
+        return res.json(result);
+      } catch (err) {
+        return res.status(500).json({ status: 'error', error: err.message });
+      }
+    }
+
+    if (id === 'codex') {
+      const providerObj = getProvider(id);
+      if (!providerObj || !providerObj.constructor.isInstalled()) {
+        return res.status(400).json({ error: 'Codex is not installed. Install it first.' });
+      }
+
+      const { method, key } = req.body || {};
+
+      if (key) {
+        daemon.audit.log('provider.login.started', { provider: id, method: 'api-key' });
+        try {
+          const result = await providerObj.constructor.onKeySet(key);
+          clearInstallCache();
+          daemon.broadcast({ type: 'provider:status-changed', provider: id });
+          return res.json({ status: result.ok ? 'authenticated' : 'error', ...result });
+        } catch (err) {
+          return res.status(500).json({ status: 'error', error: err.message });
+        }
+      }
+
+      if (method === 'chatgpt-plus') {
+        daemon.audit.log('provider.login.started', { provider: id, method: 'chatgpt-plus' });
+        return new Promise((resolve) => {
+          let responded = false;
+          const respond = (data, status) => {
+            if (responded) return;
+            responded = true;
+            clearInstallCache();
+            daemon.broadcast({ type: 'provider:status-changed', provider: id });
+            if (status) res.status(status).json(data);
+            else res.json(data);
+            resolve();
+          };
+
+          const proc = spawn('codex', ['login'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true,
+          });
+          let stdout = '';
+          let stderr = '';
+          proc.stdout.on('data', (d) => { stdout += d.toString(); });
+          proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+          const timeout = setTimeout(() => {
+            const urlMatch = (stdout + stderr).match(/https:\/\/\S+/);
+            respond(urlMatch
+              ? { status: 'pending', url: urlMatch[0] }
+              : { status: 'pending', message: 'Login started — check your browser' });
+          }, 5000);
+
+          proc.on('close', (code) => {
+            clearTimeout(timeout);
+            respond(code === 0
+              ? { status: 'authenticated' }
+              : { status: 'error', error: stderr.slice(-200) || `Login failed (exit ${code})` });
+          });
+
+          proc.on('error', (err) => {
+            clearTimeout(timeout);
+            respond({ status: 'error', error: err.message }, 500);
+          });
+        });
+      }
+
+      return res.status(400).json({ error: 'Provide either { key: "..." } or { method: "chatgpt-plus" }' });
+    }
+  });
+
+  app.post('/api/providers/:id/set-path', async (req, res) => {
+    const { id } = req.params;
+    if (!MANAGEABLE_PROVIDERS.has(id)) {
+      return res.status(400).json({ error: `Invalid provider. Valid: ${[...MANAGEABLE_PROVIDERS].join(', ')}` });
+    }
+
+    const { path: customPath } = req.body || {};
+    if (!customPath || typeof customPath !== 'string') {
+      return res.status(400).json({ error: 'path is required' });
+    }
+    if (customPath.length > 500) {
+      return res.status(400).json({ error: 'Path too long' });
+    }
+    if (!isAbsolute(customPath)) {
+      return res.status(400).json({ error: 'Path must be absolute' });
+    }
+
+    if (!existsSync(customPath)) {
+      return res.status(400).json({ error: `Path does not exist: ${customPath}` });
+    }
+
+    try {
+      const stat = statSync(customPath);
+      if (!stat.isFile()) {
+        return res.status(400).json({ error: 'Path must point to a file, not a directory' });
+      }
+      const mode = stat.mode;
+      const isExecutable = !!(mode & 0o111);
+      if (!isExecutable) {
+        return res.status(400).json({ error: 'File is not executable' });
+      }
+    } catch (err) {
+      return res.status(400).json({ error: `Cannot stat path: ${err.message}` });
+    }
+
+    if (!daemon.config.providerPaths) daemon.config.providerPaths = {};
+    daemon.config.providerPaths[id] = customPath;
+
+    const { saveConfig } = await import('./firstrun.js');
+    saveConfig(daemon.grooveDir, daemon.config);
+
+    setProviderPaths(daemon.config.providerPaths);
+    clearInstallCache();
+
+    daemon.audit.log('provider.setPath', { provider: id, path: customPath });
+    daemon.broadcast({ type: 'provider:status-changed', provider: id });
+
+    res.json({ ok: true, path: customPath });
+  });
+
+  app.post('/api/providers/:id/verify', async (req, res) => {
+    const { id } = req.params;
+    if (!MANAGEABLE_PROVIDERS.has(id)) {
+      return res.status(400).json({ error: `Invalid provider. Valid: ${[...MANAGEABLE_PROVIDERS].join(', ')}` });
+    }
+
+    clearInstallCache();
+    const providerObj = getProvider(id);
+    if (!providerObj) {
+      return res.json({ installed: false, authenticated: false, version: null, error: 'Unknown provider' });
+    }
+
+    const installed = providerObj.constructor.isInstalled();
+    let authenticated = false;
+    let version = null;
+    let error = null;
+
+    if (installed) {
+      const authStatus = providerObj.constructor.isAuthenticated?.();
+      authenticated = !!(authStatus?.authenticated);
+
+      const command = providerObj.constructor.command;
+      const customPath = getProviderPath(id);
+      const bin = customPath || command;
+
+      try {
+        version = execFileSync(bin, ['--version'], {
+          encoding: 'utf8',
+          timeout: 5000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          shell: true,
+        }).trim();
+      } catch (err) {
+        version = null;
+        error = `Version check failed: ${err.message?.slice(0, 200) || 'unknown error'}`;
+      }
+    } else {
+      error = 'Provider not installed';
+    }
+
+    daemon.broadcast({ type: 'provider:status-changed', provider: id });
+
+    res.json({ installed, authenticated, version, error });
+  });
+
   // --- Local Models (GGUF via HuggingFace) ---
 
   app.get('/api/models/installed', (req, res) => {
@@ -765,7 +1036,7 @@ export function createApi(app, daemon) {
     }
     try {
       daemon.setProjectDir(dirPath);
-      editorRootDir = daemon.projectDir;
+      editorRootOverride = null;
       res.json({ projectDir: daemon.projectDir, recentProjects: daemon.config.recentProjects || [] });
     } catch (err) {
       res.status(400).json({ error: err.message });
@@ -2392,12 +2663,13 @@ Keep responses concise. Help them think, don't lecture them about the system the
     return LANG_MAP[ext] || 'text';
   }
 
-  const IGNORED_NAMES = new Set(['.git', 'node_modules', '.DS_Store', '.groove', '__pycache__', '.next', '.cache', 'dist', 'coverage']);
+  const IGNORED_NAMES = new Set(['.DS_Store', '__pycache__']);
 
-  // Editor root directory — defaults to projectDir but can be changed at runtime
-  let editorRootDir = daemon.projectDir;
+  // Editor root directory — always tracks daemon.projectDir unless explicitly
+  // overridden via POST /api/files/root. Reset on project-dir change.
+  let editorRootOverride = null;
 
-  function getEditorRoot() { return editorRootDir; }
+  function getEditorRoot() { return editorRootOverride || daemon.projectDir; }
 
   function validateFilePath(relPath, projectDir) {
     if (!relPath || typeof relPath !== 'string') return { error: 'path is required' };
@@ -2421,13 +2693,12 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   // Get/set the editor working directory
   app.get('/api/files/root', (req, res) => {
-    res.json({ root: editorRootDir });
+    res.json({ root: getEditorRoot() });
   });
 
   app.post('/api/files/root', (req, res) => {
     const { root } = req.body || {};
     if (!root || typeof root !== 'string') return res.status(400).json({ error: 'root path is required' });
-    // Must be absolute and exist
     if (!root.startsWith('/')) return res.status(400).json({ error: 'root must be an absolute path' });
     if (root.includes('\0') || root.includes('..')) return res.status(400).json({ error: 'Invalid path' });
     if (!existsSync(root)) return res.status(404).json({ error: 'Directory not found' });
@@ -2435,9 +2706,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const stat = statSync(root);
       if (!stat.isDirectory()) return res.status(400).json({ error: 'Path is not a directory' });
     } catch { return res.status(400).json({ error: 'Cannot access directory' }); }
-    editorRootDir = root;
+    editorRootOverride = root;
     daemon.audit.log('editor.root.set', { root });
-    res.json({ ok: true, root: editorRootDir });
+    res.json({ ok: true, root: getEditorRoot() });
   });
 
   // File tree — returns dirs + files for a given path
@@ -2462,18 +2733,22 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const raw = readdirSync(fullPath, { withFileTypes: true });
       const entries = [];
 
-      // Dirs first (sorted), then files (sorted)
-      const isDir = (e) => {
+      const dirs = raw.filter((e) => {
+        if (e.name === '.DS_Store') return false;
         if (e.isDirectory()) return true;
-        if (e.isSymbolicLink()) { try { return statSync(resolve(fullPath, e.name)).isDirectory(); } catch { return false; } }
+        if (e.isSymbolicLink()) {
+          try { return statSync(resolve(fullPath, e.name)).isDirectory(); }
+          catch { return true; }
+        }
         return false;
-      };
-      const dirs = raw.filter((e) => isDir(e) && !IGNORED_NAMES.has(e.name) && !e.name.startsWith('.'))
-        .sort((a, b) => a.name.localeCompare(b.name));
+      }).sort((a, b) => a.name.localeCompare(b.name));
       const files = raw.filter((e) => {
-        if (e.name.startsWith('.')) return false;
+        if (e.name === '.DS_Store') return false;
         if (e.isFile()) return true;
-        if (e.isSymbolicLink()) { try { return statSync(resolve(fullPath, e.name)).isFile(); } catch { return false; } }
+        if (e.isSymbolicLink()) {
+          try { return statSync(resolve(fullPath, e.name)).isFile(); }
+          catch { return false; }
+        }
         return false;
       }).sort((a, b) => a.name.localeCompare(b.name));
 
@@ -2483,7 +2758,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
         let hasChildren = false;
         try {
           const children = readdirSync(childFull, { withFileTypes: true });
-          hasChildren = children.some((c) => !c.name.startsWith('.') && !IGNORED_NAMES.has(c.name));
+          hasChildren = children.some((c) => c.name !== '.DS_Store');
         } catch { /* unreadable */ }
         entries.push({ name: d.name, type: 'dir', path: childPath, hasChildren });
       }
@@ -3809,6 +4084,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
     const proc = spawn('npm', ['install', '-g', pkg], {
       stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
       env: { ...process.env, NODE_ENV: undefined },
     });
 
@@ -3831,9 +4107,11 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const installed = providerObj ? providerObj.constructor.isInstalled() : false;
 
       if (code === 0 && installed) {
+        clearInstallCache();
         write({ status: 'complete', output: `${pkg} installed successfully`, progress: 100, installed: true });
         daemon.audit.log('onboarding.installProvider', { provider, pkg, success: true });
         daemon.broadcast({ type: 'onboarding:provider-installed', provider });
+        daemon.broadcast({ type: 'provider:status-changed', provider });
       } else {
         const reason = code !== 0
           ? (errOutput || output).slice(-500)

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

@@ -45,6 +45,7 @@ import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 import { bindDaemon as bindGrooveNetworkDaemon } from './providers/groove-network.js';
+import { setProviderPaths } from './providers/index.js';
 
 const DEFAULT_PORT = 31415;
 const DEFAULT_HOST = '127.0.0.1';
@@ -113,6 +114,8 @@ export class Daemon {
       this.config = loadConfig(this.grooveDir);
     }
 
+    if (this.config.providerPaths) setProviderPaths(this.config.providerPaths);
+
     // Initialize core components
     this.state = new StateManager(this.grooveDir);
     this.registry = new Registry(this.state);

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

@@ -36,4 +36,12 @@ export class Provider {
   streamChat(messages, model, apiKey, onChunk, onDone, onError) {
     return null;
   }
+
+  static setupGuide() {
+    return { installSteps: [], authMethods: [], authInstructions: {} };
+  }
+
+  static authMethods() {
+    return [];
+  }
 }

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

@@ -336,8 +336,62 @@ export class ClaudeCodeProvider extends Provider {
     const child = cpSpawn('claude', ['auth', 'login', '--claudeai'], {
       detached: true,
       stdio: 'ignore',
+      shell: true,
     });
     child.unref();
     return { pid: child.pid };
   }
+
+  static setupGuide() {
+    return {
+      installSteps: ['Installing Claude Code...', 'This may take a minute'],
+      authMethods: ['subscription', 'api-key'],
+      authInstructions: {
+        subscriptionLoginHelp: 'Sign in with your Anthropic account',
+      },
+    };
+  }
+
+  static authMethods() {
+    return ['subscription', 'api-key'];
+  }
+
+  static async startLogin() {
+    return new Promise((resolve) => {
+      const child = cpSpawn('claude', ['auth', 'login', '--claudeai'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true,
+      });
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', (d) => { stdout += d.toString(); });
+      child.stderr.on('data', (d) => { stderr += d.toString(); });
+
+      const timeout = setTimeout(() => {
+        const urlMatch = (stdout + stderr).match(/https:\/\/\S+/);
+        if (urlMatch) {
+          resolve({ status: 'pending', url: urlMatch[0], pid: child.pid });
+        } else {
+          resolve({ status: 'pending', message: 'Login started — check your browser', pid: child.pid });
+        }
+      }, 3000);
+
+      child.on('close', (code) => {
+        clearTimeout(timeout);
+        if (code === 0) {
+          resolve({ status: 'authenticated' });
+        } else {
+          const urlMatch = (stdout + stderr).match(/https:\/\/\S+/);
+          resolve(urlMatch
+            ? { status: 'pending', url: urlMatch[0], pid: child.pid }
+            : { status: 'error', error: stderr.slice(-200) || `Login failed (exit ${code})` });
+        }
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeout);
+        resolve({ status: 'error', error: err.message });
+      });
+    });
+  }
 }

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

@@ -72,6 +72,7 @@ export class CodexProvider extends Provider {
     return new Promise((res) => {
       const proc = spawn('codex', ['login', '--with-api-key'], {
         stdio: ['pipe', 'pipe', 'pipe'],
+        shell: true,
         timeout: 15000,
       });
       let stderr = '';
@@ -323,4 +324,19 @@ export class CodexProvider extends Provider {
         return null;
     }
   }
+
+  static setupGuide() {
+    return {
+      installSteps: ['Installing Codex CLI...', 'This may take a minute'],
+      authMethods: ['api-key', 'chatgpt-plus'],
+      authInstructions: {
+        apiKeyHelp: 'Get your API key from platform.openai.com/api-keys',
+        chatgptPlusHelp: 'Sign in with your ChatGPT Plus account',
+      },
+    };
+  }
+
+  static authMethods() {
+    return ['api-key', 'chatgpt-plus'];
+  }
 }

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

@@ -219,4 +219,18 @@ export class GeminiProvider extends Provider {
         return null;
     }
   }
+
+  static setupGuide() {
+    return {
+      installSteps: ['Installing Gemini CLI...', 'This may take a minute'],
+      authMethods: ['api-key'],
+      authInstructions: {
+        keyInstructions: 'Get your API key from aistudio.google.com',
+      },
+    };
+  }
+
+  static authMethods() {
+    return ['api-key'];
+  }
 }

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

@@ -2,6 +2,7 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { execSync } from 'child_process';
+import { dirname as pathDirname, delimiter as pathDelimiter } from 'path';
 import { ClaudeCodeProvider } from './claude-code.js';
 import { CodexProvider } from './codex.js';
 import { GeminiProvider } from './gemini.js';
@@ -11,6 +12,30 @@ import { GrooveNetworkProvider } from './groove-network.js';
 
 // Electron forks may not inherit the full shell PATH, causing `which` to miss
 // globally-installed CLI tools. Augment PATH with common npm global bin dirs.
+// Custom provider paths from config are prepended when setProviderPaths() is called.
+let _providerPaths = {};
+
+export function setProviderPaths(paths) {
+  _providerPaths = paths || {};
+  _augmentPathWithCustomPaths();
+}
+
+function _augmentPathWithCustomPaths() {
+  const cur = process.env.PATH || '';
+  const dirs = [];
+  for (const p of Object.values(_providerPaths)) {
+    if (p && typeof p === 'string') {
+      const dir = pathDirname(p);
+      if (dir && !cur.split(pathDelimiter).includes(dir)) dirs.push(dir);
+    }
+  }
+  if (dirs.length) process.env.PATH = [...dirs, cur].join(pathDelimiter);
+}
+
+export function getProviderPath(id) {
+  return (_providerPaths && _providerPaths[id]) || null;
+}
+
 (function augmentPath() {
   const extra = ['/usr/local/bin', '/opt/homebrew/bin'];
   try {
@@ -78,3 +103,14 @@ export function listProviders() {
 export function getInstalledProviders() {
   return listProviders().filter((p) => p.installed);
 }
+
+export function getProviderMetadata(id) {
+  const p = providers[id];
+  if (!p) return null;
+  return {
+    id,
+    setupGuide: p.constructor.setupGuide?.() || { installSteps: [], authMethods: [], authInstructions: {} },
+    authMethods: p.constructor.authMethods?.() || [],
+    installCommand: p.constructor.installCommand(),
+  };
+}