spritecook-mcp 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "spritecook-mcp",
-  "version": "0.2.4",
+  "version": "0.2.6",
+  "mcpName": "ai.spritecook/generate",
   "description": "SpriteCook MCP Server - Connect your AI agent (Cursor, VS Code, Claude) to SpriteCook for pixel art and game asset generation.",
   "keywords": [
     "spritecook",

package/src/editors.mjs

@@ -4,6 +4,8 @@ import { homedir } from 'node:os';
 import { success, warn, info } from './ui.mjs';
 import { getMcpUrl } from './config.mjs';
 
+// ── Read existing key ───────────────────────────────────────────────────
+
 /**
  * Try to read an existing SpriteCook API key from any detected editor config.
  * Returns the key string or null if none found.
@@ -12,64 +14,71 @@ export function readExistingKey() {
   const cwd = process.cwd();
   const home = homedir();
 
-  // Check Cursor .cursor/mcp.json
-  try {
-    const cursorConfig = join(cwd, '.cursor', 'mcp.json');
-    if (existsSync(cursorConfig)) {
-      const config = JSON.parse(readFileSync(cursorConfig, 'utf-8'));
-      const auth = config?.mcpServers?.spritecook?.headers?.Authorization;
-      if (auth && auth.startsWith('Bearer sc_live_')) {
-        return auth.replace('Bearer ', '');
-      }
+  const keyFrom = (config, ...path) => {
+    let obj = config;
+    for (const p of path) { obj = obj?.[p]; }
+    if (typeof obj === 'string' && obj.startsWith('Bearer sc_live_')) {
+      return obj.replace('Bearer ', '');
     }
-  } catch { /* ignore */ }
+    return null;
+  };
 
-  // Check VS Code .vscode/settings.json
-  try {
-    const vscodeConfig = join(cwd, '.vscode', 'settings.json');
-    if (existsSync(vscodeConfig)) {
-      const config = JSON.parse(readFileSync(vscodeConfig, 'utf-8'));
-      const auth = config?.mcp?.servers?.spritecook?.headers?.Authorization;
-      if (auth && auth.startsWith('Bearer sc_live_')) {
-        return auth.replace('Bearer ', '');
-      }
-    }
-  } catch { /* ignore */ }
+  const tryFile = (filePath, ...keyPath) => {
+    try {
+      if (!existsSync(filePath)) return null;
+      const config = JSON.parse(readFileSync(filePath, 'utf-8'));
+      return keyFrom(config, ...keyPath);
+    } catch { return null; }
+  };
 
-  // Check Claude Desktop
-  try {
-    const claudePath = getClaudeDesktopConfigPath();
-    if (claudePath && existsSync(claudePath)) {
-      const config = JSON.parse(readFileSync(claudePath, 'utf-8'));
-      const auth = config?.mcpServers?.spritecook?.headers?.Authorization;
-      if (auth && auth.startsWith('Bearer sc_live_')) {
-        return auth.replace('Bearer ', '');
-      }
-    }
-  } catch { /* ignore */ }
+  // Cursor project
+  const k1 = tryFile(join(cwd, '.cursor', 'mcp.json'), 'mcpServers', 'spritecook', 'headers', 'Authorization');
+  if (k1) return k1;
+  // Cursor global
+  const k1g = tryFile(join(home, '.cursor', 'mcp.json'), 'mcpServers', 'spritecook', 'headers', 'Authorization');
+  if (k1g) return k1g;
+
+  // VS Code project (new mcp.json format)
+  const k2 = tryFile(join(cwd, '.vscode', 'mcp.json'), 'servers', 'spritecook', 'headers', 'Authorization');
+  if (k2) return k2;
+  // VS Code legacy (settings.json)
+  const k2b = tryFile(join(cwd, '.vscode', 'settings.json'), 'mcp', 'servers', 'spritecook', 'headers', 'Authorization');
+  if (k2b) return k2b;
+
+  // Claude Desktop
+  const claudeDesktop = getClaudeDesktopConfigPath();
+  if (claudeDesktop) {
+    const k3 = tryFile(claudeDesktop, 'mcpServers', 'spritecook', 'headers', 'Authorization');
+    if (k3) return k3;
+  }
 
-  // Check Claude Code
-  try {
-    const claudeCode1 = join(home, '.claude.json');
-    const claudeCode2 = join(home, '.claude', 'settings.json');
-    const path = existsSync(claudeCode2) ? claudeCode2 : claudeCode1;
-    if (existsSync(path)) {
-      const config = JSON.parse(readFileSync(path, 'utf-8'));
-      const auth = config?.mcpServers?.spritecook?.headers?.Authorization;
-      if (auth && auth.startsWith('Bearer sc_live_')) {
-        return auth.replace('Bearer ', '');
-      }
-    }
-  } catch { /* ignore */ }
+  // Claude Code
+  const k4a = tryFile(join(home, '.claude', 'settings.json'), 'mcpServers', 'spritecook', 'headers', 'Authorization');
+  if (k4a) return k4a;
+  const k4b = tryFile(join(home, '.claude.json'), 'mcpServers', 'spritecook', 'headers', 'Authorization');
+  if (k4b) return k4b;
+
+  // Antigravity
+  const antigravity = getAntigravityConfigPath();
+  const k5 = tryFile(antigravity, 'mcpServers', 'spritecook', 'headers', 'Authorization');
+  if (k5) return k5;
+
+  // Windsurf
+  const windsurf = getWindsurfConfigPath();
+  if (windsurf) {
+    const k6 = tryFile(windsurf, 'mcpServers', 'spritecook', 'headers', 'Authorization');
+    if (k6) return k6;
+  }
 
-  // Check Antigravity
+  // Codex (TOML - just search for the key string)
   try {
-    const antigravityPath = getAntigravityConfigPath();
-    if (antigravityPath && existsSync(antigravityPath)) {
-      const config = JSON.parse(readFileSync(antigravityPath, 'utf-8'));
-      const auth = config?.mcpServers?.spritecook?.headers?.Authorization;
-      if (auth && auth.startsWith('Bearer sc_live_')) {
-        return auth.replace('Bearer ', '');
+    const codexGlobal = join(home, '.codex', 'config.toml');
+    const codexProject = join(cwd, '.codex', 'config.toml');
+    for (const p of [codexProject, codexGlobal]) {
+      if (existsSync(p)) {
+        const text = readFileSync(p, 'utf-8');
+        const match = text.match(/bearer_token\s*=\s*"(sc_live_[^"]+)"/);
+        if (match) return match[1];
       }
     }
   } catch { /* ignore */ }
@@ -77,15 +86,12 @@ export function readExistingKey() {
   return null;
 }
 
-/**
- * Detect if the terminal is running inside a specific editor via env vars.
- */
+// ── Environment detection ───────────────────────────────────────────────
+
 function isRunningInCursor() {
-  // Cursor sets CURSOR_CHANNEL or has "cursor" in TERM_PROGRAM / VSCODE_GIT_IPC_HANDLE
   const env = process.env;
   if (env.CURSOR_CHANNEL) return true;
   if (env.TERM_PROGRAM === 'cursor') return true;
-  // Cursor is a VS Code fork - check for cursor-specific paths in common env vars
   const ipcHandle = env.VSCODE_GIT_IPC_HANDLE || env.VSCODE_IPC_HOOK_CLI || '';
   if (ipcHandle.toLowerCase().includes('cursor')) return true;
   return false;
@@ -93,10 +99,8 @@ function isRunningInCursor() {
 
 function isRunningInAntigravity() {
   const env = process.env;
-  // Antigravity may set its own env vars or identify via TERM_PROGRAM
   if (env.ANTIGRAVITY_CHANNEL) return true;
   if (env.TERM_PROGRAM === 'antigravity') return true;
-  // Antigravity is a VS Code fork - check for antigravity-specific paths
   const ipcHandle = env.VSCODE_GIT_IPC_HANDLE || env.VSCODE_IPC_HOOK_CLI || '';
   if (ipcHandle.toLowerCase().includes('antigravity')) return true;
   return false;
@@ -111,12 +115,25 @@ function isRunningInVSCode() {
   return false;
 }
 
+function isRunningInWindsurf() {
+  const env = process.env;
+  if (env.TERM_PROGRAM === 'windsurf') return true;
+  const ipcHandle = env.VSCODE_GIT_IPC_HANDLE || env.VSCODE_IPC_HOOK_CLI || '';
+  if (ipcHandle.toLowerCase().includes('windsurf') || ipcHandle.toLowerCase().includes('codeium')) return true;
+  return false;
+}
+
+// ── Editor definitions ──────────────────────────────────────────────────
+
 /**
- * Detect which editors/IDEs are available and return a list of
- * { name, detected, configPath, write(apiKey) } objects.
- *
- * Detection uses both folder existence AND environment variables,
- * so editors are found even in fresh projects without config folders.
+ * Each editor defines:
+ *  - name: display name
+ *  - detected: boolean heuristic
+ *  - scopes: available MCP scopes ('project' and/or 'global')
+ *  - defaultScope: recommended default scope
+ *  - write(apiKey, scope): writer function
+ *  - configPath(scope): return the path that will be written
+ *  - skillDirs: { project, global } paths for skill installation
  */
 export function detectEditors() {
   const cwd = process.cwd();
@@ -124,55 +141,128 @@ export function detectEditors() {
   const editors = [];
 
   const inCursor = isRunningInCursor();
-  const inVSCode = isRunningInVSCode() && !inCursor; // Cursor is a VS Code fork
+  const inVSCode = isRunningInVSCode() && !inCursor && !isRunningInAntigravity() && !isRunningInWindsurf();
+  const inAntigravity = isRunningInAntigravity();
+  const inWindsurf = isRunningInWindsurf();
 
-  // Cursor - project-level .cursor/mcp.json
-  const cursorDir = join(cwd, '.cursor');
+  // ── Cursor ──────────────────────────────────────────────────
   editors.push({
     name: 'Cursor',
-    detected: existsSync(cursorDir) || inCursor,
-    configPath: join(cursorDir, 'mcp.json'),
-    write: (apiKey) => writeCursorConfig(cursorDir, apiKey),
+    detected: existsSync(join(cwd, '.cursor')) || inCursor,
+    scopes: ['project', 'global'],
+    defaultScope: 'project',
+    configPath: (scope) => scope === 'global'
+      ? join(home, '.cursor', 'mcp.json')
+      : join(cwd, '.cursor', 'mcp.json'),
+    write: (apiKey, scope) => writeCursorConfig(
+      scope === 'global' ? join(home, '.cursor') : join(cwd, '.cursor'),
+      apiKey
+    ),
+    skillDirs: {
+      project: join(cwd, '.cursor', 'skills', 'spritecook'),
+      global: join(home, '.cursor', 'skills', 'spritecook'),
+    },
   });
 
-  // VS Code - project-level .vscode/settings.json
-  const vscodeDir = join(cwd, '.vscode');
+  // ── VS Code ─────────────────────────────────────────────────
+  // Skills: project .github/skills/, global ~/.copilot/skills/
   editors.push({
     name: 'VS Code',
-    detected: existsSync(vscodeDir) || inVSCode,
-    configPath: join(vscodeDir, 'settings.json'),
-    write: (apiKey) => writeVSCodeConfig(vscodeDir, apiKey),
+    detected: existsSync(join(cwd, '.vscode')) || inVSCode,
+    scopes: ['project', 'global'],
+    defaultScope: 'project',
+    configPath: (scope) => scope === 'global'
+      ? getVSCodeGlobalMcpPath()
+      : join(cwd, '.vscode', 'mcp.json'),
+    write: (apiKey, scope) => scope === 'global'
+      ? writeVSCodeGlobalConfig(apiKey)
+      : writeVSCodeProjectConfig(join(cwd, '.vscode'), apiKey),
+    skillDirs: {
+      project: join(cwd, '.github', 'skills', 'spritecook'),
+      global: join(home, '.copilot', 'skills', 'spritecook'),
+    },
   });
 
-  // Claude Desktop - platform-specific
+  // ── Claude Desktop ──────────────────────────────────────────
   const claudeDesktopPath = getClaudeDesktopConfigPath();
   editors.push({
     name: 'Claude Desktop',
     detected: claudeDesktopPath ? existsSync(join(claudeDesktopPath, '..')) : false,
-    configPath: claudeDesktopPath,
+    scopes: ['global'],
+    defaultScope: 'global',
+    configPath: () => claudeDesktopPath,
     write: (apiKey) => writeClaudeDesktopConfig(claudeDesktopPath, apiKey),
+    skillDirs: {
+      project: join(cwd, '.claude', 'skills', 'spritecook'),
+      global: join(home, '.claude', 'skills', 'spritecook'),
+    },
   });
 
-  // Claude Code - ~/.claude.json or ~/.claude/settings.json
-  const claudeCodePath1 = join(home, '.claude.json');
+  // ── Claude Code ─────────────────────────────────────────────
   const claudeCodePath2 = join(home, '.claude', 'settings.json');
+  const claudeCodePath1 = join(home, '.claude.json');
   const claudeCodeDetected = existsSync(claudeCodePath1) || existsSync(claudeCodePath2);
   const claudeCodeConfigPath = existsSync(claudeCodePath2) ? claudeCodePath2 : claudeCodePath1;
   editors.push({
     name: 'Claude Code',
     detected: claudeCodeDetected,
-    configPath: claudeCodeConfigPath,
+    scopes: ['global'],
+    defaultScope: 'global',
+    configPath: () => claudeCodeConfigPath,
     write: (apiKey) => writeClaudeCodeConfig(claudeCodeConfigPath, apiKey),
+    skillDirs: {
+      project: join(cwd, '.claude', 'skills', 'spritecook'),
+      global: join(home, '.claude', 'skills', 'spritecook'),
+    },
   });
 
-  // Antigravity (Google) - user-level mcp_config.json
+  // ── Antigravity (Google) ────────────────────────────────────
   const antigravityPath = getAntigravityConfigPath();
-  const antigravityDetected = isRunningInAntigravity() || (antigravityPath ? existsSync(join(antigravityPath, '..')) : false);
   editors.push({
     name: 'Antigravity',
-    detected: antigravityDetected,
-    configPath: antigravityPath,
+    detected: inAntigravity || (antigravityPath ? existsSync(join(antigravityPath, '..')) : false),
+    scopes: ['global'],
+    defaultScope: 'global',
+    configPath: () => antigravityPath,
     write: (apiKey) => writeAntigravityConfig(antigravityPath, apiKey),
+    skillDirs: {
+      project: join(cwd, '.agent', 'skills', 'spritecook'),
+      global: join(home, '.gemini', 'antigravity', 'skills', 'spritecook'),
+    },
+  });
+
+  // ── Windsurf (Codeium) ──────────────────────────────────────
+  const windsurfPath = getWindsurfConfigPath();
+  editors.push({
+    name: 'Windsurf',
+    detected: inWindsurf || (windsurfPath ? existsSync(join(windsurfPath, '..')) : false),
+    scopes: ['global'],
+    defaultScope: 'global',
+    configPath: () => windsurfPath,
+    write: (apiKey) => writeWindsurfConfig(windsurfPath, apiKey),
+    skillDirs: {
+      project: null, // Windsurf uses Cascade / AGENTS.md, no standard skills dir
+      global: null,
+    },
+  });
+
+  // ── Codex (OpenAI) ──────────────────────────────────────────
+  const codexGlobalPath = join(home, '.codex', 'config.toml');
+  const codexProjectPath = join(cwd, '.codex', 'config.toml');
+  editors.push({
+    name: 'Codex',
+    detected: existsSync(codexGlobalPath) || existsSync(codexProjectPath),
+    scopes: ['project', 'global'],
+    defaultScope: 'global',
+    configPath: (scope) => scope === 'project' ? codexProjectPath : codexGlobalPath,
+    write: (apiKey, scope) => writeCodexConfig(
+      scope === 'project' ? codexProjectPath : codexGlobalPath,
+      apiKey,
+    ),
+    skillDirs: {
+      project: join(cwd, '.agents', 'skills', 'spritecook'),
+      global: join(home, '.agents', 'skills', 'spritecook'),
+    },
   });
 
   return editors;
@@ -188,8 +278,10 @@ export function writeConfigs(editors, apiKey) {
 
   for (const editor of editors) {
     try {
-      editor.write(apiKey);
-      success(`${editor.configPath}`);
+      const scope = editor._chosenScope || editor.defaultScope;
+      editor.write(apiKey, scope);
+      const path = typeof editor.configPath === 'function' ? editor.configPath(scope) : editor.configPath;
+      success(`${path}`);
       written++;
     } catch (err) {
       warn(`Failed to write ${editor.name} config: ${err.message}`);
@@ -205,80 +297,93 @@ function writeCursorConfig(cursorDir, apiKey) {
   const configPath = join(cursorDir, 'mcp.json');
   const mcpUrl = getMcpUrl();
 
-  // Read existing config or start fresh
   let config = {};
   if (existsSync(configPath)) {
-    try {
-      config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    } catch {
-      // Corrupted file, start fresh
-    }
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
   }
 
-  // Merge the spritecook server entry
   if (!config.mcpServers) config.mcpServers = {};
   config.mcpServers.spritecook = {
     url: mcpUrl,
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
+    headers: { Authorization: `Bearer ${apiKey}` },
   };
 
   ensureDir(cursorDir);
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
 
-function writeVSCodeConfig(vscodeDir, apiKey) {
-  const configPath = join(vscodeDir, 'settings.json');
+function writeVSCodeProjectConfig(vscodeDir, apiKey) {
+  // VS Code now uses .vscode/mcp.json with root key "servers"
+  const configPath = join(vscodeDir, 'mcp.json');
   const mcpUrl = getMcpUrl();
 
-  // Read existing config or start fresh
   let config = {};
   if (existsSync(configPath)) {
-    try {
-      config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    } catch {
-      // Corrupted file, start fresh
-    }
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
   }
 
-  // Merge into mcp.servers without overwriting other servers
-  if (!config.mcp) config.mcp = {};
-  if (!config.mcp.servers) config.mcp.servers = {};
-  config.mcp.servers.spritecook = {
+  if (!config.servers) config.servers = {};
+  config.servers.spritecook = {
     type: 'http',
     url: mcpUrl,
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
+    headers: { Authorization: `Bearer ${apiKey}` },
   };
 
   ensureDir(vscodeDir);
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
 
+function writeVSCodeGlobalConfig(apiKey) {
+  const configPath = getVSCodeGlobalMcpPath();
+  const mcpUrl = getMcpUrl();
+
+  let config = {};
+  if (existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
+  }
+
+  if (!config.servers) config.servers = {};
+  config.servers.spritecook = {
+    type: 'http',
+    url: mcpUrl,
+    headers: { Authorization: `Bearer ${apiKey}` },
+  };
+
+  ensureDir(join(configPath, '..'));
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
 function writeClaudeDesktopConfig(configPath, apiKey) {
-  if (!configPath) {
-    warn('Claude Desktop config path not found for this platform.');
-    return;
+  if (!configPath) { warn('Claude Desktop config path not found.'); return; }
+  const mcpUrl = getMcpUrl();
+
+  let config = {};
+  if (existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
   }
+
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers.spritecook = {
+    url: mcpUrl,
+    headers: { Authorization: `Bearer ${apiKey}` },
+  };
+
+  ensureDir(join(configPath, '..'));
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
+function writeClaudeCodeConfig(configPath, apiKey) {
   const mcpUrl = getMcpUrl();
 
   let config = {};
   if (existsSync(configPath)) {
-    try {
-      config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    } catch {
-      // Start fresh
-    }
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
   }
 
   if (!config.mcpServers) config.mcpServers = {};
   config.mcpServers.spritecook = {
     url: mcpUrl,
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
+    headers: { Authorization: `Bearer ${apiKey}` },
   };
 
   ensureDir(join(configPath, '..'));
@@ -286,63 +391,74 @@ function writeClaudeDesktopConfig(configPath, apiKey) {
 }
 
 function writeAntigravityConfig(configPath, apiKey) {
-  if (!configPath) {
-    warn('Antigravity config path not found for this platform.');
-    return;
-  }
+  if (!configPath) { warn('Antigravity config path not found.'); return; }
   const mcpUrl = getMcpUrl();
 
   let config = {};
   if (existsSync(configPath)) {
-    try {
-      config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    } catch {
-      // Start fresh
-    }
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
   }
 
   if (!config.mcpServers) config.mcpServers = {};
   config.mcpServers.spritecook = {
     serverUrl: mcpUrl,
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
+    headers: { Authorization: `Bearer ${apiKey}` },
   };
 
   ensureDir(join(configPath, '..'));
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
 
-function writeClaudeCodeConfig(configPath, apiKey) {
+function writeWindsurfConfig(configPath, apiKey) {
+  if (!configPath) { warn('Windsurf config path not found.'); return; }
   const mcpUrl = getMcpUrl();
 
   let config = {};
   if (existsSync(configPath)) {
-    try {
-      config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    } catch {
-      // Start fresh
-    }
+    try { config = JSON.parse(readFileSync(configPath, 'utf-8')); } catch { /* start fresh */ }
   }
 
   if (!config.mcpServers) config.mcpServers = {};
   config.mcpServers.spritecook = {
     url: mcpUrl,
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
+    headers: { Authorization: `Bearer ${apiKey}` },
   };
 
   ensureDir(join(configPath, '..'));
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
 
-// ── Helpers ─────────────────────────────────────────────────────────────
+function writeCodexConfig(configPath, apiKey) {
+  const mcpUrl = getMcpUrl();
+
+  // Read existing or start fresh TOML
+  let content = '';
+  if (existsSync(configPath)) {
+    try { content = readFileSync(configPath, 'utf-8'); } catch { /* start fresh */ }
+  }
+
+  // Remove any existing [mcp_servers.spritecook] block
+  content = content.replace(/\[mcp_servers\.spritecook\][^\[]*/, '');
+
+  // Append the new block
+  const block = [
+    '',
+    '[mcp_servers.spritecook]',
+    `url = "${mcpUrl}"`,
+    `bearer_token = "${apiKey}"`,
+    '',
+  ].join('\n');
+
+  content = content.trimEnd() + '\n' + block;
+
+  ensureDir(join(configPath, '..'));
+  writeFileSync(configPath, content, 'utf-8');
+}
+
+// ── Path Helpers ────────────────────────────────────────────────────────
 
 function getAntigravityConfigPath() {
-  const home = homedir();
-  // Antigravity stores MCP config at ~/.gemini/antigravity/mcp_config.json on all platforms
-  return join(home, '.gemini', 'antigravity', 'mcp_config.json');
+  return join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
 }
 
 function getClaudeDesktopConfigPath() {
@@ -359,10 +475,47 @@ function getClaudeDesktopConfigPath() {
   if (platform === 'linux') {
     return join(home, '.config', 'Claude', 'claude_desktop_config.json');
   }
+  return null;
+}
+
+function getWindsurfConfigPath() {
+  const platform = process.platform;
+  const home = homedir();
 
+  if (platform === 'darwin') {
+    return join(home, '.codeium', 'windsurf', 'mcp_config.json');
+  }
+  if (platform === 'win32') {
+    const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming');
+    return join(appData, 'Codeium', 'Windsurf', 'mcp_config.json');
+  }
+  if (platform === 'linux') {
+    // Try both common paths
+    const p1 = join(home, '.codeium', 'windsurf', 'mcp_config.json');
+    const p2 = join(home, '.config', 'Codeium', 'Windsurf', 'mcp_config.json');
+    if (existsSync(p2)) return p2;
+    return p1;
+  }
   return null;
 }
 
+function getVSCodeGlobalMcpPath() {
+  const platform = process.platform;
+  const home = homedir();
+
+  if (platform === 'darwin') {
+    return join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json');
+  }
+  if (platform === 'win32') {
+    const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming');
+    return join(appData, 'Code', 'User', 'mcp.json');
+  }
+  if (platform === 'linux') {
+    return join(home, '.config', 'Code', 'User', 'mcp.json');
+  }
+  return join(home, '.vscode', 'mcp.json'); // fallback
+}
+
 function ensureDir(dir) {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });

package/src/setup.mjs

@@ -67,8 +67,8 @@ export async function run() {
 
   const editors = detectEditors();
 
-  // Always show all editors - detected ones are pre-selected, others are selectable too
-  const response = await prompts({
+  // Let user select which editors to configure
+  const editorResponse = await prompts({
     type: 'multiselect',
     name: 'editors',
     message: 'Configure MCP for:',
@@ -81,7 +81,7 @@ export async function run() {
     instructions: false,
   });
 
-  const selected = editors.filter((e) => response.editors?.includes(e.name));
+  const selected = editors.filter((e) => editorResponse.editors?.includes(e.name));
 
   if (selected.length === 0) {
     warn('No editors selected. Skipping config.');
@@ -89,6 +89,30 @@ export async function run() {
     info('You can configure manually later. Your API key:');
     console.log(`  ${chalk.dim(apiKey.slice(0, 16) + '...')}`);
   } else {
+    // Ask about scope for editors that support both project and global
+    const multiScopeEditors = selected.filter((e) => e.scopes.length > 1);
+    if (multiScopeEditors.length > 0) {
+      console.log();
+      const scopeResponse = await prompts({
+        type: 'select',
+        name: 'scope',
+        message: 'Install MCP config:',
+        choices: [
+          { title: 'This project only (recommended)', value: 'project', description: 'Writes to project config files' },
+          { title: 'Global (all projects)', value: 'global', description: 'Writes to user-level config' },
+        ],
+        initial: 0,
+      });
+
+      const chosenScope = scopeResponse.scope || 'project';
+      for (const e of selected) {
+        if (e.scopes.includes(chosenScope)) {
+          e._chosenScope = chosenScope;
+        }
+        // Editors with only 1 scope keep their default
+      }
+    }
+
     console.log();
     info('Writing MCP config...');
     const written = writeConfigs(selected, apiKey);
@@ -100,7 +124,7 @@ export async function run() {
 
   // ── Step 4: Optional agent skill ─────────────────────────────────
   step(4, 'Agent Skill (optional)');
-  await maybeInstallSkill(selected);
+  await maybeInstallSkill();
 
   // ── Done ──────────────────────────────────────────────────────────
   const configuredNames = selected.map((e) => e.name);

package/src/skill.mjs

@@ -1,123 +1,37 @@
-import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
 import prompts from 'prompts';
 import { success, info, warn } from './ui.mjs';
-import { getApiBase } from './config.mjs';
-
-/** Fetch the latest skill document from the SpriteCook API. */
-async function fetchLatestSkill() {
-  try {
-    const res = await fetch(`${getApiBase()}/v1/public/agent-skill`);
-    if (res.ok) {
-      const text = await res.text();
-      if (text && text.length > 50) return text;
-    }
-  } catch {
-    // Network error, fall through to bundled fallback
-  }
-  return null;
-}
-
-// Bundled fallback (used when the API is unreachable)
-const FALLBACK_SKILL = `# SpriteCook - AI Game Asset Generator
-
-Use SpriteCook MCP tools when the user needs pixel art, detailed sprites, game assets, icons, tilesets, textures, or UI elements for a game project.
-
-## Available Tools
-
-### generate_pixel_art
-Generate game art from a text prompt. Key params: prompt (required), width, height, pixel, bg_mode, theme, style, mode, reference_asset_id, edit_asset_id.
-
-### check_job_status
-Check progress of a generation job by job_id.
-
-### get_credit_balance
-Check remaining credits and subscription tier.
-
-For full documentation visit: https://spritecook.ai/agents
-`;
-
-// Map editor names to their project-level skill directory (.<editor>/skills/spritecook/)
-const EDITOR_SKILL_DIRS = {
-  'Cursor': '.cursor',
-  'VS Code': '.vscode',
-  'Antigravity': '.antigravity',
-  'Claude Desktop': '.claude',
-  'Claude Code': '.claude',
-};
 
 /**
- * Determine which skill install targets are relevant based on selected editors.
- * Each selected editor gets a local project skill at .<editor>/skills/spritecook/SKILL.md.
- * Returns an array of { name, dir, path, exists } objects (deduplicated by path).
+ * Install or update the SpriteCook agent skill using the standard
+ * `npx skills add` CLI. This handles editor detection and correct
+ * file placement for all supported editors automatically.
  */
-function getSkillTargets(selectedEditors) {
-  const cwd = process.cwd();
-  const targets = [];
-  const seenPaths = new Set();
-
-  for (const editor of (selectedEditors || [])) {
-    const dotDir = EDITOR_SKILL_DIRS[editor.name];
-    if (!dotDir) continue;
-
-    const dir = join(cwd, dotDir, 'skills', 'spritecook');
-    const path = join(dir, 'SKILL.md');
-
-    // Deduplicate (e.g. Claude Desktop & Claude Code both use .claude)
-    if (seenPaths.has(path)) continue;
-    seenPaths.add(path);
-
-    targets.push({ name: editor.name, dir, path, exists: existsSync(path) });
-  }
-
-  return targets;
-}
-
-/**
- * Optionally install or update the SpriteCook agent skill.
- * Supports Cursor (.cursor/skills/) and Antigravity (.antigravity/skills/).
- * Always fetches the latest version from the API.
- */
-export async function maybeInstallSkill(selectedEditors) {
-  const targets = getSkillTargets(selectedEditors);
-
-  if (targets.length === 0) {
-    return; // No supported editors for skills
+export async function maybeInstallSkill() {
+  info('The agent skill teaches your AI how to generate sprites autonomously.');
+  const response = await prompts({
+    type: 'confirm',
+    name: 'install',
+    message: 'Install SpriteCook agent skill? (highly recommended)',
+    initial: true,
+  });
+
+  if (!response.install) {
+    return;
   }
 
-  const allExist = targets.every(t => t.exists);
-  const anyExist = targets.some(t => t.exists);
+  info('Installing skill via npx skills add SpriteCook/skills...');
 
-  if (allExist) {
-    // Silently update all
-    info('Updating agent skill to latest version...');
-  } else {
-    const editorNames = targets.filter(t => !t.exists).map(t => t.name).join(' & ');
-    const response = await prompts({
-      type: 'confirm',
-      name: 'install',
-      message: `Install SpriteCook agent skill for ${editorNames}? (helps AI use SpriteCook proactively)`,
-      initial: true,
+  try {
+    const npxCmd = platform() === 'win32' ? 'npx.cmd' : 'npx';
+    execSync(`${npxCmd} -y skills add SpriteCook/skills`, {
+      stdio: 'inherit',
+      timeout: 60_000,
     });
-
-    if (!response.install) {
-      return;
-    }
-  }
-
-  // Fetch latest from API, fall back to bundled version
-  const content = await fetchLatestSkill() || FALLBACK_SKILL;
-
-  for (const target of targets) {
-    if (!existsSync(target.dir)) {
-      mkdirSync(target.dir, { recursive: true });
-    }
-    writeFileSync(target.path, content, 'utf-8');
-
-    if (target.exists) {
-      success(`${target.name} skill updated.`);
-    } else {
-      success(`${target.name} skill installed at ${target.path}`);
-    }
+    success('Agent skill installed.');
+  } catch (err) {
+    warn('Skill install failed. You can install it manually later:');
+    console.log('  npx skills add SpriteCook/skills');
   }
 }