@shnitzel/plugscout 0.3.10 → 0.3.12

package/dist/interfaces/cli/client-setup.js

@@ -1,24 +1,111 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-const PLUGSCOUT_MCP_VALUE = { command: 'npx', args: ['plugscout', 'mcp'] };
+const PLUGSCOUT_MCP_STDIO = { command: 'npx', args: ['plugscout', 'mcp'] };
+const PLUGSCOUT_MCP_ZED = { command: { path: 'npx', args: ['plugscout', 'mcp'] } };
+function claudeDesktopConfigPath() {
+    if (process.platform === 'win32') {
+        return path.join(process.env['APPDATA'] ?? os.homedir(), 'Claude', 'claude_desktop_config.json');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    return path.join(os.homedir(), '.config', 'claude-desktop', 'claude_desktop_config.json');
+}
+function openCodeConfigPath() {
+    if (process.platform === 'win32') {
+        return path.join(process.env['APPDATA'] ?? os.homedir(), 'opencode', 'config.json');
+    }
+    return path.join(os.homedir(), '.config', 'opencode', 'config.json');
+}
+export const CLIENT_DEFS = {
+    cursor: {
+        label: 'Cursor IDE',
+        supportsProjectScope: true,
+        getConfigPath(scope) {
+            return scope === 'project'
+                ? path.join(process.cwd(), '.cursor', 'mcp.json')
+                : path.join(os.homedir(), '.cursor', 'mcp.json');
+        },
+        containerPath: ['mcpServers'],
+        entryValue: PLUGSCOUT_MCP_STDIO,
+    },
+    gemini: {
+        label: 'Gemini CLI',
+        supportsProjectScope: false,
+        getConfigPath() {
+            return path.join(os.homedir(), '.gemini', 'settings.json');
+        },
+        containerPath: ['mcpServers'],
+        entryValue: PLUGSCOUT_MCP_STDIO,
+    },
+    'claude-desktop': {
+        label: 'Claude Desktop',
+        supportsProjectScope: false,
+        getConfigPath() {
+            return claudeDesktopConfigPath();
+        },
+        containerPath: ['mcpServers'],
+        entryValue: PLUGSCOUT_MCP_STDIO,
+    },
+    windsurf: {
+        label: 'Windsurf',
+        supportsProjectScope: false,
+        getConfigPath() {
+            return path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+        },
+        containerPath: ['mcpServers'],
+        entryValue: PLUGSCOUT_MCP_STDIO,
+    },
+    opencode: {
+        label: 'OpenCode',
+        supportsProjectScope: false,
+        getConfigPath() {
+            return openCodeConfigPath();
+        },
+        containerPath: ['mcp'],
+        entryValue: PLUGSCOUT_MCP_STDIO,
+    },
+    zed: {
+        label: 'Zed',
+        supportsProjectScope: false,
+        getConfigPath() {
+            return path.join(os.homedir(), '.config', 'zed', 'settings.json');
+        },
+        containerPath: ['context_servers'],
+        entryValue: PLUGSCOUT_MCP_ZED,
+    },
+};
+export const VALID_CLIENT_KINDS = Object.keys(CLIENT_DEFS);
 export function getConfigPath(client, scope) {
-    if (client === 'cursor') {
-        if (scope === 'project') {
-            return path.join(process.cwd(), '.cursor', 'mcp.json');
+    return CLIENT_DEFS[client].getConfigPath(scope);
+}
+function navigateContainer(obj, keys) {
+    let current = obj;
+    for (const key of keys) {
+        const next = current[key];
+        if (next === undefined || next === null || typeof next !== 'object' || Array.isArray(next)) {
+            current[key] = {};
         }
-        return path.join(os.homedir(), '.cursor', 'mcp.json');
+        current = current[key];
     }
-    return path.join(os.homedir(), '.gemini', 'settings.json');
+    return current;
 }
 export async function getClientMcpConfigStatus(client, scope) {
-    const configPath = getConfigPath(client, scope);
+    const def = CLIENT_DEFS[client];
+    const configPath = def.getConfigPath(scope);
     try {
         const raw = await fs.readFile(configPath, 'utf8');
         const config = JSON.parse(raw);
-        const mcpServers = config.mcpServers;
-        const configured = !!(mcpServers?.plugscout);
-        return { configured, configPath };
+        let container = config;
+        for (const key of def.containerPath) {
+            const next = container[key];
+            if (next === undefined || typeof next !== 'object' || next === null || Array.isArray(next)) {
+                return { configured: false, configPath };
+            }
+            container = next;
+        }
+        return { configured: !!container['plugscout'], configPath };
     }
     catch {
         return { configured: false, configPath };
@@ -26,8 +113,9 @@ export async function getClientMcpConfigStatus(client, scope) {
 }
 export async function writeClientMcpConfig(options) {
     const { client, force = false } = options;
-    const scope = client === 'gemini' ? 'user' : options.scope;
-    const configPath = getConfigPath(client, scope);
+    const def = CLIENT_DEFS[client];
+    const scope = def.supportsProjectScope ? options.scope : 'user';
+    const configPath = def.getConfigPath(scope);
     let existing = {};
     try {
         const raw = await fs.readFile(configPath, 'utf8');
@@ -36,25 +124,21 @@ export async function writeClientMcpConfig(options) {
     catch {
         // file doesn't exist yet — start empty
     }
-    const mcpServers = existing.mcpServers ?? {};
-    const current = mcpServers.plugscout;
+    const container = navigateContainer(existing, def.containerPath);
+    const current = container['plugscout'];
     if (current !== undefined) {
-        const isSame = JSON.stringify(current) === JSON.stringify(PLUGSCOUT_MCP_VALUE);
-        if (isSame) {
+        const isSame = JSON.stringify(current) === JSON.stringify(def.entryValue);
+        if (isSame)
             return { status: 'already-configured', configPath };
-        }
         if (!force) {
             throw new Error(`plugscout already exists in ${configPath} with a different value. Use --force to overwrite.`);
         }
     }
-    const updated = {
-        ...existing,
-        mcpServers: { ...mcpServers, plugscout: PLUGSCOUT_MCP_VALUE }
-    };
+    container['plugscout'] = def.entryValue;
     const dir = path.dirname(configPath);
     await fs.mkdir(dir, { recursive: true });
     const tmpPath = `${configPath}.plugscout.tmp`;
-    await fs.writeFile(tmpPath, `${JSON.stringify(updated, null, 2)}\n`, 'utf8');
+    await fs.writeFile(tmpPath, `${JSON.stringify(existing, null, 2)}\n`, 'utf8');
     await fs.rename(tmpPath, configPath);
     return { status: 'written', configPath };
 }

package/dist/interfaces/cli/doctor.js

@@ -5,7 +5,7 @@ import fs from 'node:fs/promises';
 import { getStaleRegistries, loadSyncState } from '../../catalog/sync-state.js';
 import { loadCatalogItems } from '../../catalog/repository.js';
 import { hasLegacySkillSh, resolveSkillsRuntime } from '../../install/dependencies.js';
-import { getClientMcpConfigStatus } from './client-setup.js';
+import { getClientMcpConfigStatus, CLIENT_DEFS } from './client-setup.js';
 export async function runDoctorChecks(projectPath = '.') {
     const checks = [];
     checks.push(checkSkillsRuntime());
@@ -88,6 +88,64 @@ export async function runDoctorChecks(projectPath = '.') {
     catch {
         checks.push({ name: 'Gemini MCP config', status: 'warn', message: 'Could not read Gemini MCP config', suggestion: 'Run: plugscout client setup --client gemini' });
     }
+    // Claude Desktop check
+    const claudeDesktopConfigPath = CLIENT_DEFS['claude-desktop'].getConfigPath('user');
+    const claudeDesktopPresent = spawnSync('which', ['claude'], { encoding: 'utf8' }).status === 0 ||
+        await fs.access(path.dirname(claudeDesktopConfigPath)).then(() => true).catch(() => false) ||
+        await fs.access(path.join('/', 'Applications', 'Claude.app')).then(() => true).catch(() => false);
+    checks.push(claudeDesktopPresent
+        ? { name: 'Claude Desktop', status: 'pass', message: 'Claude Desktop detected' }
+        : { name: 'Claude Desktop', status: 'warn', message: 'Claude Desktop not detected', suggestion: 'Install from https://claude.ai/download' });
+    // Claude Desktop MCP config check
+    try {
+        const claudeStatus = await getClientMcpConfigStatus('claude-desktop', 'user');
+        checks.push(claudeStatus.configured
+            ? { name: 'Claude Desktop MCP', status: 'pass', message: `plugscout wired in ${claudeStatus.configPath}` }
+            : { name: 'Claude Desktop MCP', status: 'warn', message: 'plugscout not in Claude Desktop config', suggestion: 'Run: plugscout client setup --client claude-desktop' });
+    }
+    catch {
+        checks.push({ name: 'Claude Desktop MCP', status: 'warn', message: 'Could not read Claude Desktop config', suggestion: 'Run: plugscout client setup --client claude-desktop' });
+    }
+    // Windsurf check
+    checks.push(checkBinary('windsurf', { suggestion: 'Install Windsurf from https://windsurf.ai' }));
+    // Windsurf MCP config check
+    try {
+        const windsurfStatus = await getClientMcpConfigStatus('windsurf', 'user');
+        checks.push(windsurfStatus.configured
+            ? { name: 'Windsurf MCP config', status: 'pass', message: `plugscout wired in ${windsurfStatus.configPath}` }
+            : { name: 'Windsurf MCP config', status: 'warn', message: 'plugscout not in Windsurf MCP config', suggestion: 'Run: plugscout client setup --client windsurf' });
+    }
+    catch {
+        checks.push({ name: 'Windsurf MCP config', status: 'warn', message: 'Could not read Windsurf MCP config', suggestion: 'Run: plugscout client setup --client windsurf' });
+    }
+    // OpenCode check
+    checks.push(checkBinary('opencode', { suggestion: 'Install OpenCode: npm install -g opencode-ai' }));
+    // OpenCode MCP config check
+    try {
+        const opencodeStatus = await getClientMcpConfigStatus('opencode', 'user');
+        checks.push(opencodeStatus.configured
+            ? { name: 'OpenCode MCP config', status: 'pass', message: `plugscout wired in ${opencodeStatus.configPath}` }
+            : { name: 'OpenCode MCP config', status: 'warn', message: 'plugscout not in OpenCode config', suggestion: 'Run: plugscout client setup --client opencode' });
+    }
+    catch {
+        checks.push({ name: 'OpenCode MCP config', status: 'warn', message: 'Could not read OpenCode config', suggestion: 'Run: plugscout client setup --client opencode' });
+    }
+    // Zed check
+    const zedInstalled = spawnSync('which', ['zed'], { encoding: 'utf8' }).status === 0 ||
+        await fs.access(path.join('/', 'Applications', 'Zed.app')).then(() => true).catch(() => false);
+    checks.push(zedInstalled
+        ? { name: 'Zed', status: 'pass', message: 'Zed detected' }
+        : { name: 'Zed', status: 'warn', message: 'Zed not detected', suggestion: 'Install Zed from https://zed.dev' });
+    // Zed MCP config check
+    try {
+        const zedStatus = await getClientMcpConfigStatus('zed', 'user');
+        checks.push(zedStatus.configured
+            ? { name: 'Zed MCP config', status: 'pass', message: `plugscout wired in ${zedStatus.configPath}` }
+            : { name: 'Zed MCP config', status: 'warn', message: 'plugscout not in Zed settings', suggestion: 'Run: plugscout client setup --client zed' });
+    }
+    catch {
+        checks.push({ name: 'Zed MCP config', status: 'warn', message: 'Could not read Zed settings', suggestion: 'Run: plugscout client setup --client zed' });
+    }
     return checks;
 }
 function checkSkillsRuntime() {

package/dist/interfaces/cli/index.js

@@ -30,7 +30,7 @@ import { hasFlag, readCsvList, readFlag, readKinds, readLimit, readSort } from '
 import { renderHomeScreen, renderInteractiveHome } from './ui/home.js';
 import { handleMcp } from './mcp.js';
 import { writeWebReport } from './ui/web-report.js';
-import { checkForUpdateNow, maybeNotifyAboutUpdate, RELEASE_DOWNLOAD_URL } from './update-check.js';
+import { applyUpdate, checkForUpdateNow, maybeNotifyAboutUpdate, RELEASE_DOWNLOAD_URL } from './update-check.js';
 const COMMAND_ALIASES = {
     home: 'home',
     about: 'about',
@@ -860,38 +860,65 @@ async function handleQuarantine(args) {
 async function handleClient(args) {
     const subcommand = args[0];
     if (subcommand !== 'setup') {
-        throw new Error('Usage: client setup --client cursor|gemini [--scope user|project] [--force]');
+        throw new Error('Usage: client setup --client cursor|gemini|claude-desktop|windsurf|opencode|zed [--scope user|project] [--force]');
     }
+    const { writeClientMcpConfig, CLIENT_DEFS, VALID_CLIENT_KINDS } = await import('./client-setup.js');
     const clientFlag = readFlag(args, '--client');
-    if (clientFlag !== 'cursor' && clientFlag !== 'gemini') {
-        throw new Error('Usage: client setup --client cursor|gemini');
+    if (!clientFlag || !VALID_CLIENT_KINDS.includes(clientFlag)) {
+        throw new Error(`Usage: client setup --client ${VALID_CLIENT_KINDS.join('|')}`);
     }
     const scopeFlag = readFlag(args, '--scope') ?? 'user';
     if (scopeFlag !== 'user' && scopeFlag !== 'project') {
         throw new Error('--scope must be user or project');
     }
-    if (clientFlag === 'gemini' && scopeFlag === 'project') {
-        logger.warn('Gemini CLI only supports user scope; falling back to user scope.');
+    const def = CLIENT_DEFS[clientFlag];
+    if (!def.supportsProjectScope && scopeFlag === 'project') {
+        logger.warn(`${def.label} only supports user scope; falling back to user scope.`);
     }
     const force = hasFlag(args, '--force');
-    const { writeClientMcpConfig } = await import('./client-setup.js');
-    const result = await writeClientMcpConfig({ client: clientFlag, scope: scopeFlag, force });
+    const result = await writeClientMcpConfig({
+        client: clientFlag,
+        scope: scopeFlag,
+        force
+    });
     if (result.status === 'already-configured') {
         console.log(`plugscout already configured in ${result.configPath}`);
     }
     else {
         console.log(`plugscout MCP config written: ${result.configPath}`);
-        printHint(`Restart ${clientFlag === 'cursor' ? 'Cursor IDE' : 'Gemini CLI'} for the change to take effect.`);
+        printHint(`Restart ${def.label} for the change to take effect.`);
     }
 }
 async function handleUpgrade(args) {
     const subcommand = args[0] ?? 'check';
+    if (subcommand === 'apply') {
+        const result = await applyUpdate();
+        renderApplyResult(result);
+        return;
+    }
     if (subcommand !== 'check') {
-        throw new Error('Usage: upgrade check');
+        throw new Error('Usage: upgrade check | upgrade apply');
     }
     const result = await checkForUpdateNow();
     renderUpgradeResult(result);
 }
+function renderApplyResult(result) {
+    if (result.status === 'upgraded') {
+        console.log(`PlugScout upgraded: v${result.fromVersion} -> v${result.toVersion}`);
+        return;
+    }
+    if (result.status === 'already-latest') {
+        console.log(`PlugScout is already up to date (v${result.currentVersion}).`);
+        return;
+    }
+    if (result.status === 'no-release') {
+        console.log('No published release found yet.');
+        console.log(`Releases: ${RELEASE_DOWNLOAD_URL}`);
+        return;
+    }
+    console.log(`Upgrade failed: ${result.detail}`);
+    console.log(`Manual install: npm install -g @shnitzel/plugscout@latest`);
+}
 function renderUpgradeResult(result) {
     if (result.status === 'no-release') {
         console.log('No published release found yet.');
@@ -910,7 +937,7 @@ function renderUpgradeResult(result) {
         return;
     }
     console.log(`New PlugScout version available: v${result.currentVersion} -> v${result.latestVersion}`);
-    console.log(`Download: ${RELEASE_DOWNLOAD_URL}`);
+    console.log(`Upgrade: plugscout upgrade apply   |   Download: ${RELEASE_DOWNLOAD_URL}`);
 }
 function sortRecommendations(recommendations, sort) {
     const sorted = [...recommendations];
@@ -1036,8 +1063,9 @@ function printHelp() {
     console.log('Other');
     console.log('  about');
     console.log('  web [--out .plugscout/report.html] [--kind ...] [--limit n] [--open]');
-    console.log('  client setup --client cursor|gemini [--scope user|project] [--force]');
+    console.log('  client setup --client cursor|gemini|claude-desktop|windsurf|opencode|zed [--scope user|project] [--force]');
     console.log('  upgrade check');
+    console.log('  upgrade apply                  auto-install latest version via npm');
     console.log('  help');
     console.log('');
     console.log('Kind aliases');
@@ -1057,6 +1085,10 @@ function printHelp() {
     console.log('  plugscout show --id claude-connector:asana');
     console.log('  plugscout client setup --client cursor');
     console.log('  plugscout client setup --client gemini');
+    console.log('  plugscout client setup --client claude-desktop');
+    console.log('  plugscout client setup --client windsurf');
+    console.log('  plugscout client setup --client opencode');
+    console.log('  plugscout client setup --client zed');
     console.log('  plugscout sync --kind cursor-extension,gemini-extension');
     console.log('');
     console.log('Global options');

package/dist/interfaces/cli/update-check.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
 import semver from 'semver';
 import { readJsonFile, writeJsonFile } from '../../lib/json.js';
 import { getPackagePath, getStatePath } from '../../lib/paths.js';
@@ -80,7 +81,7 @@ export async function maybeNotifyAboutUpdate(options = {}) {
         return;
     }
     console.log(`New PlugScout version available: v${currentVersion} -> v${state.latestVersion}`);
-    console.log(`Download: ${RELEASE_DOWNLOAD_URL}`);
+    console.log(`Upgrade: plugscout upgrade apply   |   Download: ${RELEASE_DOWNLOAD_URL}`);
     await saveUpdateCheckState({
         ...state,
         source: 'github-releases',
@@ -113,6 +114,32 @@ export async function checkForUpdateNow() {
     }
     return { status: 'up-to-date', currentVersion, latestVersion: result.latestVersion };
 }
+export async function applyUpdate() {
+    const currentVersion = await loadCurrentVersion();
+    const release = await lookupLatestReleaseVersion();
+    if (release.status === 'error') {
+        return { status: 'error', currentVersion, detail: 'Could not reach GitHub releases API.' };
+    }
+    if (release.status === 'no-release') {
+        return { status: 'no-release', currentVersion };
+    }
+    if (!isVersionNewer(release.latestVersion, currentVersion)) {
+        return { status: 'already-latest', currentVersion, latestVersion: release.latestVersion };
+    }
+    const pkg = '@shnitzel/plugscout@latest';
+    const result = spawnSync('npm', ['install', '-g', pkg], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        return { status: 'error', currentVersion, detail: `npm install -g ${pkg} exited with ${result.status ?? 'signal'}` };
+    }
+    await saveUpdateCheckState({
+        ...(await loadUpdateCheckState()),
+        source: 'github-releases',
+        lastCheckedAt: new Date().toISOString(),
+        latestVersion: release.latestVersion,
+        lastNotifiedVersion: release.latestVersion
+    });
+    return { status: 'upgraded', fromVersion: currentVersion, toVersion: release.latestVersion };
+}
 async function lookupLatestReleaseVersion() {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shnitzel/plugscout",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Claude plugins + Claude connectors + Copilot extensions + Skills + MCP security intelligence framework",
   "private": false,
   "type": "module",