@elliotding/ai-agent-mcp 0.1.8 → 0.1.10

package/src/tools/sync-resources.ts

@@ -21,7 +21,11 @@ import * as path from 'path';
 import { logger, logToolCall, logToolStep, logToolResult } from '../utils/logger';
 import { apiClient } from '../api/client';
 import { multiSourceGitManager } from '../git/multi-source-manager';
-import { getCursorResourcePath, getCursorTypeDir, getCursorRootDir } from '../utils/cursor-paths';
+import {
+  getCursorResourcePath,
+  getCursorTypeDirForClient,
+  getCursorRootDirForClient,
+} from '../utils/cursor-paths';
 import { MCPServerError } from '../types/errors';
 import type {
   SyncResourcesParams,
@@ -283,10 +287,24 @@ export async function syncResources(params: unknown): Promise<ToolResult<SyncRes
         // reading the files directly from the local git checkout.
         let resourceFiles = downloadResult.files;
         if (resourceFiles.length === 0) {
-          const gitType = sub.type as 'rule' | 'mcp';
-          const gitFiles = await multiSourceGitManager.readResourceFiles(sub.name, gitType as any);
+          logger.info(
+            { resourceId: sub.id, resourceName: sub.name, type: sub.type },
+            'sync_resources: API returned no files — triggering git-checkout fallback',
+          );
+          const gitType = sub.type as 'command' | 'skill' | 'rule' | 'mcp';
+          const gitFiles = await multiSourceGitManager.readResourceFiles(sub.name, gitType);
           if (gitFiles.length > 0) {
             resourceFiles = gitFiles;
+            logger.info(
+              {
+                resourceId: sub.id,
+                resourceName: sub.name,
+                type: sub.type,
+                fileCount: resourceFiles.length,
+                files: resourceFiles.map((f) => f.path),
+              },
+              'sync_resources: git-checkout fallback succeeded',
+            );
             logToolStep('sync_resources', 'Loaded resource files from local git checkout', {
               resourceId: sub.id,
               fileCount: resourceFiles.length,
@@ -294,7 +312,7 @@ export async function syncResources(params: unknown): Promise<ToolResult<SyncRes
           } else {
             logger.warn(
               { resourceId: sub.id, resourceName: sub.name, type: sub.type },
-              'No files found via API or local git — skipping resource',
+              'sync_resources: git-checkout fallback found no files — marking resource failed',
             );
             tally.failed++;
             details.push({ id: sub.id, name: sub.name, action: 'failed', version: resourceVersion });
@@ -305,48 +323,84 @@ export async function syncResources(params: unknown): Promise<ToolResult<SyncRes
         // ── MCP resource ──────────────────────────────────────────────────────
         // Read mcp-config.json to determine Format A (local executable, has
         // "command" field) vs Format B (remote URL map, no "command" field).
+        //
+        // IMPORTANT: all paths in LocalAction instructions must use the CLIENT-side
+        // helper (tilde-based) so they resolve correctly on the user's machine,
+        // not on this (possibly remote Linux) server.
         if (sub.type === 'mcp') {
           const mcpConfigFile = resourceFiles.find(
             (f) => path.basename(f.path) === 'mcp-config.json',
           );
-          const mcpJsonPath = path.join(getCursorRootDir(), 'mcp.json');
+          // ~/.cursor/mcp.json on the user's machine
+          const mcpJsonPath = `${getCursorRootDirForClient()}/mcp.json`;
+
+          logger.info(
+            {
+              resourceId: sub.id,
+              resourceName: sub.name,
+              mcpJsonPath,
+              hasMcpConfigFile: !!mcpConfigFile,
+              availableFiles: resourceFiles.map((f) => f.path),
+            },
+            'sync_resources: processing MCP resource',
+          );
 
           if (mcpConfigFile) {
             let cfg: Record<string, unknown> = {};
             try { cfg = JSON.parse(mcpConfigFile.content) as Record<string, unknown>; }
-            catch { /* malformed — cfg stays empty */ }
+            catch {
+              logger.warn(
+                { resourceId: sub.id, resourceName: sub.name },
+                'sync_resources: failed to parse mcp-config.json — treating as empty config',
+              );
+            }
 
             if (typeof cfg['command'] === 'string') {
               // ── Format A: local executable ──────────────────────────────────
-              // Queue write_file for each resource file + merge_mcp_json for entry.
-              const installDir = path.join(getCursorTypeDir('mcp'), sub.name);
+              const installDir = `${getCursorTypeDirForClient('mcp')}/${sub.name}`;
+              const writeActions: string[] = [];
               for (const file of resourceFiles) {
                 const normalised = path.normalize(file.path);
                 if (normalised.startsWith('..')) continue;
-                localActions.push({ action: 'write_file', path: path.join(installDir, normalised), content: file.content });
+                const fileDest = `${installDir}/${normalised}`;
+                localActions.push({ action: 'write_file', path: fileDest, content: file.content });
+                writeActions.push(fileDest);
               }
               const env = (cfg['env'] ?? {}) as Record<string, string>;
               const missingEnv = Object.entries(env).filter(([, v]) => v === '').map(([k]) => k);
-              // Resolve relative args to the install directory.
               const looksLikePath = (a: string) =>
-                a.startsWith('./') || a.startsWith('../') || a.includes(path.sep) || /\.\w+$/.test(a);
+                a.startsWith('./') || a.startsWith('../') || a.includes('/') || /\.\w+$/.test(a);
               const args = ((cfg['args'] ?? []) as string[]).map((a) =>
-                path.isAbsolute(a) || !looksLikePath(a) ? a : path.join(installDir, a),
+                path.isAbsolute(a) || !looksLikePath(a) ? a : `${installDir}/${a.replace(/^\.\//, '')}`,
               );
+              const serverName = (cfg['name'] as string | undefined) ?? sub.name;
               localActions.push({
                 action: 'merge_mcp_json',
                 mcp_json_path: mcpJsonPath,
-                server_name: (cfg['name'] as string | undefined) ?? sub.name,
+                server_name: serverName,
                 entry: { ...cfg, args },
                 ...(missingEnv.length > 0 ? {
                   missing_env: missingEnv,
                   setup_hint: `Fill in env vars in ${mcpJsonPath} under mcpServers["${sub.name}"]: ${missingEnv.join(', ')}.`,
                 } : {}),
               });
+              logger.info(
+                {
+                  resourceId: sub.id,
+                  resourceName: sub.name,
+                  format: 'A',
+                  installDir,
+                  mcpJsonPath,
+                  serverName,
+                  writeFiles: writeActions,
+                  missingEnv,
+                },
+                'sync_resources: MCP Format A — write_file + merge_mcp_json actions queued',
+              );
               logToolStep('sync_resources', 'Local-executable MCP: write_file + merge_mcp_json queued', { resourceId: sub.id });
             } else {
               // ── Format B: remote URL map ────────────────────────────────────
-              // cfg IS the mcpServers map; one merge_mcp_json action per key.
+              const queuedServers: string[] = [];
               for (const [serverName, entry] of Object.entries(cfg)) {
                 const e = entry as Record<string, unknown>;
                 const env = (e['env'] ?? {}) as Record<string, string>;
@@ -361,29 +415,57 @@ export async function syncResources(params: unknown): Promise<ToolResult<SyncRes
                     setup_hint: `Fill in env vars in ${mcpJsonPath} under mcpServers["${serverName}"]: ${missingEnv.join(', ')}.`,
                   } : {}),
                 });
+                queuedServers.push(serverName);
               }
+              logger.info(
+                {
+                  resourceId: sub.id,
+                  resourceName: sub.name,
+                  format: 'B',
+                  mcpJsonPath,
+                  serverKeys: queuedServers,
+                },
+                'sync_resources: MCP Format B — merge_mcp_json actions queued',
+              );
               logToolStep('sync_resources', 'Remote-URL MCP: merge_mcp_json queued', {
                 resourceId: sub.id, serverKeys: Object.keys(cfg),
               });
             }
           } else {
-            // No mcp-config.json: heuristic fallback — find entry point file.
-            const installDir = path.join(getCursorTypeDir('mcp'), sub.name);
+            // No mcp-config.json: heuristic fallback
+            const installDir = `${getCursorTypeDirForClient('mcp')}/${sub.name}`;
+            const writeActions: string[] = [];
             for (const file of resourceFiles) {
               const normalised = path.normalize(file.path);
               if (normalised.startsWith('..')) continue;
-              localActions.push({ action: 'write_file', path: path.join(installDir, normalised), content: file.content });
+              const fileDest = `${installDir}/${normalised}`;
+              localActions.push({ action: 'write_file', path: fileDest, content: file.content });
+              writeActions.push(fileDest);
             }
             const jsEntry = resourceFiles.find((f) => f.path.endsWith('.js'));
             const pyEntry = resourceFiles.find((f) => f.path.endsWith('.py'));
             const entryFile = jsEntry ?? pyEntry ?? resourceFiles[0];
             const cmd = jsEntry ? 'node' : 'python3';
+            const entryPath = `${installDir}/${entryFile?.path ?? ''}`;
             localActions.push({
               action: 'merge_mcp_json',
-              mcp_json_path: path.join(getCursorRootDir(), 'mcp.json'),
+              mcp_json_path: mcpJsonPath,
               server_name: sub.name,
-              entry: { command: cmd, args: [path.join(installDir, entryFile?.path ?? '')] },
+              entry: { command: cmd, args: [entryPath] },
             });
+            logger.info(
+              {
+                resourceId: sub.id,
+                resourceName: sub.name,
+                format: 'heuristic',
+                installDir,
+                mcpJsonPath,
+                cmd,
+                entryPath,
+                writeFiles: writeActions,
+              },
+              'sync_resources: MCP heuristic fallback — write_file + merge_mcp_json actions queued',
+            );
             logToolStep('sync_resources', 'MCP heuristic fallback: write_file + merge_mcp_json queued', { resourceId: sub.id });
           }
 
@@ -394,8 +476,10 @@ export async function syncResources(params: unknown): Promise<ToolResult<SyncRes
 
         // ── Rule resource ─────────────────────────────────────────────────────
         // Return write_file actions; the AI writes the files locally.
+        // Use client-side path so the path resolves on the user's machine.
         if (sub.type === 'rule') {
-          const typeDir = getCursorTypeDir(sub.type);
+          const typeDir = getCursorTypeDirForClient(sub.type);
+          const writeActions: string[] = [];
 
           for (const file of resourceFiles) {
             const normalised = path.normalize(file.path);
@@ -403,13 +487,26 @@ export async function syncResources(params: unknown): Promise<ToolResult<SyncRes
               logger.warn({ resourceId: sub.id, filePath: file.path }, 'Skipping suspicious file path');
               continue;
             }
+            const destPath = `${typeDir}/${normalised}`;
             localActions.push({
               action: 'write_file',
-              path: path.join(typeDir, normalised),
+              path: destPath,
               content: file.content,
             });
+            writeActions.push(destPath);
           }
 
+          logger.info(
+            {
+              resourceId: sub.id,
+              resourceName: sub.name,
+              typeDir,
+              fileCount: writeActions.length,
+              destPaths: writeActions,
+            },
+            'sync_resources: Rule — write_file actions queued for AI',
+          );
+
           tally.synced++;
           details.push({ id: sub.id, name: sub.name, action: 'synced', version: resourceVersion });
           logToolStep('sync_resources', 'Rule: write_file actions queued for AI', {

package/src/tools/uninstall-resource.ts

@@ -6,12 +6,9 @@
  * For directory-based resources (skill, mcp) the entire install directory is removed.
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
 import { logger, logToolCall } from '../utils/logger';
-import { filesystemManager } from '../filesystem/manager';
 import { apiClient } from '../api/client';
-import { getCursorTypeDir, getCursorRootDir } from '../utils/cursor-paths.js';
+import { getCursorTypeDirForClient, getCursorRootDirForClient } from '../utils/cursor-paths.js';
 import { MCPServerError, createValidationError } from '../types/errors';
 import type { UninstallResourceParams, UninstallResourceResult, LocalAction, ToolResult } from '../types/tools';
 import { promptManager } from '../prompts/index.js';
@@ -93,48 +90,30 @@ export async function uninstallResource(params: unknown): Promise<ToolResult<Uni
     logger.debug({ pattern }, 'Building local uninstall actions for Rule/MCP resource...');
 
     const localActions: LocalAction[] = [];
-    const mcpJsonPath = path.join(getCursorRootDir(), 'mcp.json');
-
-    // Rule: delete matching .md/.mdc files from ~/.cursor/rules/
-    try {
-      const rulesDir = getCursorTypeDir('rule');
-      const ruleFiles = await filesystemManager.listFiles(rulesDir, /\.(md|mdc)$/);
-      for (const relName of ruleFiles) {
-        const baseName = path.basename(relName).replace(/\.(md|mdc)$/, '');
-        if (baseName === pattern || baseName.includes(pattern) || relName.includes(pattern)) {
-          const absPath = path.join(rulesDir, relName);
-          localActions.push({ action: 'delete_file', path: absPath });
-          removedResources.push({ id: baseName, name: baseName, path: absPath });
-        }
-      }
-    } catch { /* rules dir may not exist */ }
-
-    // MCP: delete install directory + remove mcp.json entry
-    try {
-      const mcpDir = getCursorTypeDir('mcp');
-      const entries = await fs.readdir(mcpDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        if (entry.name === pattern || entry.name.includes(pattern)) {
-          const dirPath = path.join(mcpDir, entry.name);
-          localActions.push({ action: 'delete_file', path: dirPath, recursive: true });
-          localActions.push({ action: 'remove_mcp_json_entry', mcp_json_path: mcpJsonPath, server_name: entry.name });
-          removedResources.push({ id: entry.name, name: entry.name, path: dirPath });
-        }
-      }
-    } catch { /* mcp-servers dir may not exist */ }
-
-    // Also check Remote-URL MCPs whose entry is only in mcp.json (no local dir).
-    // The pattern might match a server name in mcp.json directly.
-    if (localActions.filter(a => a.action === 'remove_mcp_json_entry').length === 0) {
-      // Add a conditional remove action — the AI will check if the key exists.
-      localActions.push({
-        action: 'remove_mcp_json_entry',
-        mcp_json_path: mcpJsonPath,
-        server_name: pattern,
-      });
+    // Use client-side tilde-based paths; the MCP server may be running remotely
+    // and its os.homedir() would resolve to the server's home, not the user's.
+    const mcpJsonPath = `${getCursorRootDirForClient()}/mcp.json`;
+
+    // Rule: queue delete for ~/.cursor/rules/<pattern>.mdc and .md variants.
+    // We cannot scan the server's filesystem for the user's rules, so we emit
+    // delete actions for the two common extensions and let the AI skip missing files.
+    const rulesDir = getCursorTypeDirForClient('rule');
+    for (const ext of ['.mdc', '.md']) {
+      const filePath = `${rulesDir}/${pattern}${ext}`;
+      localActions.push({ action: 'delete_file', path: filePath });
+      removedResources.push({ id: pattern, name: pattern, path: filePath });
     }
 
+    // MCP: queue delete of install directory (Format A) + remove mcp.json entry.
+    // For Format B (remote URL only) there is no local directory, but we still
+    // need to remove the mcp.json entry — the AI will skip the delete if the
+    // directory does not exist.
+    const mcpDir = getCursorTypeDirForClient('mcp');
+    const mcpInstallDir = `${mcpDir}/${pattern}`;
+    localActions.push({ action: 'delete_file', path: mcpInstallDir, recursive: true });
+    localActions.push({ action: 'remove_mcp_json_entry', mcp_json_path: mcpJsonPath, server_name: pattern });
+    removedResources.push({ id: pattern, name: pattern, path: mcpInstallDir });
+
     if (removedResources.length === 0 && localActions.length === 0) {
       throw createValidationError(
         pattern,

package/src/utils/cursor-paths.ts

@@ -29,6 +29,11 @@ export const CURSOR_TYPE_DIRS: Record<string, string> = {
  *
  * macOS / Linux : ~/.cursor
  * Windows       : %APPDATA%\Cursor\User
+ *
+ * NOTE: Only use this when running code on the USER's local machine.
+ * When generating paths for LocalAction instructions (which are executed by the
+ * AI on the user's machine, not on this server), use getCursorRootDirForClient()
+ * instead to avoid returning the server's home directory.
  */
 export function getCursorRootDir(): string {
   if (process.platform === 'win32') {
@@ -40,6 +45,40 @@ export function getCursorRootDir(): string {
   return path.join(os.homedir(), '.cursor');
 }
 
+/**
+ * Returns a platform-neutral Cursor root path for use in LocalAction instructions.
+ *
+ * LocalAction paths are sent to the AI Agent running on the USER's local machine,
+ * not executed on this (possibly remote) server.  Using os.homedir() here would
+ * produce the server's home directory (e.g. /root/.cursor on a Linux server),
+ * which is wrong when the user is on macOS or Windows.
+ *
+ * We return a tilde-prefixed path ("~/.cursor") which the AI / shell on the
+ * user's machine will expand to the correct home directory automatically.
+ * For Windows we still return the APPDATA-relative form as a hint, but note
+ * that the AI is expected to expand %APPDATA% on the client side.
+ */
+export function getCursorRootDirForClient(): string {
+  // Return a portable ~-based path; the AI on the user's machine expands it.
+  return '~/.cursor';
+}
+
+/**
+ * Returns the Cursor subdirectory for a given resource type, using a
+ * client-side portable path (tilde-based).  Use this when building paths
+ * that will be included in LocalAction instructions.
+ */
+export function getCursorTypeDirForClient(resourceType: string): string {
+  const subdir = CURSOR_TYPE_DIRS[resourceType.toLowerCase()];
+  if (!subdir) {
+    throw new Error(
+      `Unknown resource type "${resourceType}". ` +
+      `Supported types: ${Object.keys(CURSOR_TYPE_DIRS).join(', ')}`
+    );
+  }
+  return `${getCursorRootDirForClient()}/${subdir}`;
+}
+
 /**
  * Returns the Cursor subdirectory for a given resource type.
  *