@agilemonster/mcp-server 1.0.7 → 1.0.8

package/dist/client.d.ts

@@ -1,5 +1,5 @@
-import { AgileMonsterProjectConfig, Board, BoardAgentConfig, Card, ContextResponse, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.7";
+import { AgileMonsterProjectConfig, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
+export declare const MCP_SERVER_VERSION = "1.0.8";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -35,7 +35,13 @@ export declare class AgileMonsterClient {
         provider?: string;
         projectName?: string;
         projectPath?: string;
+        discoveredProjects?: DiscoveredProject[];
     }): Promise<PulseResponse>;
+    /**
+     * Scan the developer's local workspace roots (sibling folders in parent dev dir, ~/dev, ~/Projects, etc.)
+     * to discover real project folders so the web UI can auto-match and let the user pick from a dropdown.
+     */
+    discoverLocalProjects(): DiscoveredProject[];
     listAssigned(provider?: string, status?: string, boardId?: string, workspaceId?: string): Promise<{
         provider: string;
         cards: Card[];

package/dist/client.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-export const MCP_SERVER_VERSION = '1.0.7';
+import { execSync } from 'node:child_process';
+export const MCP_SERVER_VERSION = '1.0.8';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -194,9 +195,98 @@ export class AgileMonsterClient {
                 project_name: options.projectName,
                 project_path: options.projectPath,
                 mcp_version: MCP_SERVER_VERSION,
+                discovered_projects: options.discoveredProjects,
             }),
         });
     }
+    /**
+     * Scan the developer's local workspace roots (sibling folders in parent dev dir, ~/dev, ~/Projects, etc.)
+     * to discover real project folders so the web UI can auto-match and let the user pick from a dropdown.
+     */
+    discoverLocalProjects() {
+        const roots = new Set();
+        const parentDir = path.dirname(this.cwd);
+        if (parentDir && parentDir !== '/' && parentDir !== this.cwd) {
+            roots.add(parentDir);
+        }
+        const homedir = process.env.HOME || process.env.USERPROFILE || '';
+        if (homedir) {
+            for (const sub of ['dev', 'Projects', 'Code', 'repos', 'Developer']) {
+                const candidate = path.join(homedir, sub);
+                if (fs.existsSync(candidate)) {
+                    roots.add(candidate);
+                }
+            }
+        }
+        const projectMarkers = [
+            '.git',
+            '.agilemonster.json',
+            'package.json',
+            'pubspec.yaml',
+            'composer.json',
+            'pyproject.toml',
+            'requirements.txt',
+            'Cargo.toml',
+            'go.mod',
+            'Podfile',
+            'CMakeLists.txt',
+            'frontend-flutter',
+            'frontend-nextjs',
+            'backend-php',
+            'src',
+            'lib',
+            'app',
+        ];
+        const ignoreNames = /^(untitled folder.*|node_modules|vendor|dist|build|archive.*|.*backup.*|\..*)$/i;
+        const found = new Map();
+        for (const root of roots) {
+            let entries = [];
+            try {
+                entries = fs.readdirSync(root, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const name = entry.name.trim();
+                if (!name || ignoreNames.test(name))
+                    continue;
+                if (/\s\d+$/.test(name))
+                    continue; // skip "Folder 2", "Folder 3" copies
+                const fullPath = path.join(root, name);
+                let isProject = false;
+                for (const marker of projectMarkers) {
+                    if (fs.existsSync(path.join(fullPath, marker))) {
+                        isProject = true;
+                        break;
+                    }
+                }
+                if (!isProject)
+                    continue;
+                let gitRemote = null;
+                if (fs.existsSync(path.join(fullPath, '.git'))) {
+                    try {
+                        gitRemote =
+                            execSync('git config --get remote.origin.url', {
+                                cwd: fullPath,
+                                stdio: ['ignore', 'pipe', 'ignore'],
+                            })
+                                .toString()
+                                .trim() || null;
+                    }
+                    catch { }
+                }
+                found.set(fullPath, {
+                    name,
+                    path: fullPath,
+                    git_remote: gitRemote,
+                });
+            }
+        }
+        return Array.from(found.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
     async listAssigned(provider = 'any', status, boardId, workspaceId) {
         const params = new URLSearchParams();
         if (provider)

package/dist/server.js

@@ -789,18 +789,82 @@ function triggerBackgroundSelfUpdate() {
 export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
     const notifiedCardIds = new Set();
     let updateTriggered = false;
+    let pulseCount = 0;
+    const autoProvisionSavedBindings = (apiKey, bindings) => {
+        for (const b of bindings) {
+            const projPath = (b.project_path || '').trim();
+            if (!projPath || !fs.existsSync(projPath))
+                continue;
+            const amConfigPath = path.join(projPath, '.agilemonster.json');
+            let needsWrite = true;
+            if (fs.existsSync(amConfigPath)) {
+                try {
+                    const existing = JSON.parse(fs.readFileSync(amConfigPath, 'utf8'));
+                    if (existing?.board_id === b.board_id) {
+                        needsWrite = false;
+                    }
+                }
+                catch { }
+            }
+            if (needsWrite) {
+                try {
+                    fs.writeFileSync(amConfigPath, JSON.stringify({
+                        workspace_id: b.workspace_id,
+                        board_id: b.board_id,
+                        board_name: b.board_name,
+                        project_name: b.project_name || path.basename(projPath),
+                        project_path: projPath,
+                        provider: b.provider || 'cursor',
+                        review_list: 'In Review',
+                        done_list: 'Done',
+                        api_key: apiKey,
+                    }, null, 2), 'utf8');
+                    // Also ensure .cursor/mcp.json and .mcp.json exist in that bound project folder
+                    const mcpPayload = JSON.stringify({
+                        mcpServers: {
+                            agilemonster: {
+                                command: 'npx',
+                                args: ['-y', '@agilemonster/mcp-server@latest'],
+                                env: {
+                                    AGILEMONSTER_API_KEY: apiKey,
+                                    AGILEMONSTER_API_URL: 'https://api.agilemonster.com',
+                                },
+                            },
+                        },
+                    }, null, 2);
+                    const cursorDir = path.join(projPath, '.cursor');
+                    if (!fs.existsSync(cursorDir))
+                        fs.mkdirSync(cursorDir, { recursive: true });
+                    const cursorMcp = path.join(cursorDir, 'mcp.json');
+                    if (!fs.existsSync(cursorMcp))
+                        fs.writeFileSync(cursorMcp, mcpPayload, 'utf8');
+                    const claudeMcp = path.join(projPath, '.mcp.json');
+                    if (!fs.existsSync(claudeMcp))
+                        fs.writeFileSync(claudeMcp, mcpPayload, 'utf8');
+                }
+                catch { }
+            }
+        }
+    };
     const runPulse = async () => {
         try {
             const config = client.loadProjectConfig();
-            if (!config?.board_id || !client.getApiKey()) {
+            const apiKey = client.getApiKey();
+            if (!config?.board_id || !apiKey) {
                 return;
             }
+            const includeDiscovery = pulseCount === 0 || pulseCount % 15 === 0;
+            pulseCount++;
             const res = await client.pulse({
                 boardId: config.board_id,
                 provider: 'any',
                 projectName: config.project_name || path.basename(process.cwd()),
                 projectPath: config.project_path || process.cwd(),
+                discoveredProjects: includeDiscovery ? client.discoverLocalProjects() : undefined,
             });
+            if (res.saved_bindings && res.saved_bindings.length > 0) {
+                autoProvisionSavedBindings(apiKey, res.saved_bindings);
+            }
             const queued = res.queued_cards || [];
             syncIdeTaskRules(config.board_name || 'Board', queued);
             for (const card of queued) {

package/dist/types.d.ts

@@ -75,12 +75,25 @@ export interface PulseVersionInfo {
     force_update_requested: boolean;
     update_command: string;
 }
+export interface DiscoveredProject {
+    name: string;
+    path: string;
+    git_remote?: string | null;
+}
 export interface PulseResponse {
     board_id: string;
     pulsed_at: string;
     queued_cards: Card[];
     in_progress_cards: Card[];
     version: PulseVersionInfo;
+    saved_bindings?: Array<{
+        board_id: string;
+        board_name: string;
+        workspace_id: string;
+        provider: string;
+        project_name: string;
+        project_path?: string | null;
+    }>;
 }
 export interface ContextResponse {
     matched_board: Board | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilemonster/mcp-server",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "type": "module",
   "description": "Official Model Context Protocol (MCP) server & Orchestrator for Agile Monster (Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf)",
   "main": "dist/server.js",