@agilemonster/mcp-server 1.0.16 → 1.0.21

package/README.md

@@ -74,7 +74,7 @@ This generates:
 
 ## 🛠️ Available MCP Tools
 
-Agents have access to 8 purpose-built lifecycle tools:
+Agents have access to these purpose-built lifecycle tools:
 
 | Tool | Purpose |
 | :--- | :--- |
@@ -86,6 +86,32 @@ Agents have access to 8 purpose-built lifecycle tools:
 | `agilemonster_add_progress` | Logs implementation progress notes to task comments. |
 | `agilemonster_submit_for_review` | Marks work complete, moves card to Review column, reassigns to human member for confirmation, and posts test instructions. |
 | `agilemonster_create_followup_tasks` | Creates follow-up cards (e.g. "Deploy to Test", "Deploy to Production", "Write integration tests"). |
+| `agilemonster_get_deploy_profile` | How this project deploys: route, exact command, confidence, the evidence behind it, alternatives, and recent outcomes. |
+| `agilemonster_record_deployment` | Records how a deployment went (or pins the route the user stated) so every later task deploys the same proven way. |
+
+---
+
+## 🚀 How deployment is decided (and remembered)
+
+Cards started from the Agile Monster web app run in the background without your IDE's context, so the
+server works out how a project ships from evidence and from what worked before:
+
+1. **Explicit** — `.agilemonster/deploy.json` in the repo (`{"method": "docker_compose", "command": "...", "live_url": "..."}`), or a route pinned with `agilemonster_record_deployment({ pin: true })` / a card reply.
+2. **Learned** — the last deployment that was verified on this machine.
+3. **Evidence, ranked** — a deploy workflow that really fires on a push to the checked-out branch (path filters and `workflow_run` chains included) › a deploy script › a cloud CLI config › the Docker Compose stack that is running from this folder (reused with its exact project name and files) › a compose file › a plain `git push`.
+
+What the runner guarantees:
+
+- **Commits only the files it changed** — never `git add -A`; local files holding your API key are filtered and added to `.git/info/exclude`.
+- **Verifies before claiming "Deployed"** — deploy workflow run for that commit, container state and health, script exit code, and a smoke check of a URL you provided. A guessed URL can never fail a deploy.
+- **Asks once, then remembers** — an unconfirmed deploy script, cloud CLI or manually-dispatched workflow is not run on a guess. Reply on the card with `deploy: <command or method>` to confirm; `retry` re-runs only the deployment, not the code change.
+- **Heals what it can** — starts Docker Desktop/OrbStack if it is installed but stopped, rebases and re-pushes when the remote moved ahead, retries network errors, and falls back to the next route when the chosen one plainly does not apply.
+- **Never reports a slow pipeline as failed** — a CI run that outlives the wait is marked pending and re-checked on later pulses; the outcome is posted on the card.
+
+State lives outside your repositories: `~/.agilemonster/projects/` (per-project deployment history) and
+`~/.agilemonster/logs/daemon.jsonl` (structured daemon log).
+
+Card reply syntax: `retry` · `deploy: github_actions` · `deploy: docker_compose` · `deploy: manual` · `deploy: ./deploy/deploy.sh` · `live url: https://example.com`
 
 ---
 

package/dist/client.d.ts

@@ -1,5 +1,5 @@
-import { AgileMonsterProjectConfig, AutonomousStepResponse, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.16";
+import { AgileMonsterProjectConfig, AutonomousStepResponse, CardComment, DeployReport, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
+export declare const MCP_SERVER_VERSION = "1.0.21";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -40,7 +40,13 @@ export declare class AgileMonsterClient {
             default_model?: string | null;
             models: Record<string, string> | string[];
         }>;
+        installedAgents?: string[];
     }): Promise<PulseResponse>;
+    /**
+     * Cross-platform detection of AI coding agents installed on this computer.
+     * Checks for Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf, Aider.
+     */
+    static detectInstalledAgents(): string[];
     /**
      * Discover live models installed/configured across the developer's local AI coding agents
      * (Codex, Cursor, Claude Code, Hermes, Antigravity) so the Agile Monster app & website
@@ -51,13 +57,18 @@ export declare class AgileMonsterClient {
         models: Record<string, string>;
     }>;
     /**
-     * Auto-detect build command, deployment method, deploy script, and live URL for a project repository.
+     * Describe how a project folder builds and deploys, for the server's project/board bindings.
+     * Backed by the evidence-ranked resolver (running containers, real workflow triggers, deploy scripts,
+     * project docs) plus this machine's deployment memory, so what the web app shows matches what will run.
      */
-    static inspectProjectProfile(fullPath: string, name: string): {
+    static inspectProjectProfile(fullPath: string, _name?: string): {
         build_command: string | null;
         deploy_method: string | null;
         deploy_command: string | null;
         live_url: string | null;
+        deploy_source: string;
+        deploy_confidence: string;
+        deploy_evidence: string;
     };
     /**
      * Scan the developer's local workspace roots (sibling folders in parent dev dir, ~/dev, ~/Projects, etc.)
@@ -88,6 +99,12 @@ export declare class AgileMonsterClient {
     }>): Promise<{
         tasks: Card[];
     }>;
+    listComments(cardId: string): Promise<CardComment[]>;
+    /**
+     * Tell the server how a deployment went so the board binding learns the verified route (or the failure).
+     * Older backends do not have this endpoint; that must never break a deployment.
+     */
+    reportDeployment(report: DeployReport): Promise<boolean>;
     autonomousStep(payload: {
         card_id: string;
         action: 'select_files' | 'generate_edits';

package/dist/client.js

@@ -1,7 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
-export const MCP_SERVER_VERSION = '1.0.16';
+import { resolveDeployProfile } from './deploy-profile.js';
+import { loadMemory } from './deploy-memory.js';
+import { stripRemoteCredentials } from './redact.js';
+export const MCP_SERVER_VERSION = '1.0.21';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -85,7 +88,7 @@ export class AgileMonsterClient {
         catch {
             // Ignore reading error
         }
-        this.cachedConfig = null;
+        // Not cached: bootstrap may write the file while this server is running, and the tools must then see it
         return null;
     }
     saveProjectConfig(config, dir) {
@@ -155,7 +158,7 @@ export class AgileMonsterClient {
         if (boardId)
             params.set('board_id', boardId);
         if (gitRemote)
-            params.set('git_remote', gitRemote);
+            params.set('git_remote', stripRemoteCredentials(gitRemote));
         if (detectedIdes && detectedIdes.length > 0) {
             params.set('detected_ides', detectedIdes.join(','));
         }
@@ -180,13 +183,14 @@ export class AgileMonsterClient {
                 agents,
                 project_name: projectName,
                 project_path: projectPath,
-                git_remote: gitRemote,
+                git_remote: gitRemote ? stripRemoteCredentials(gitRemote) : gitRemote,
                 mcp_version: MCP_SERVER_VERSION,
                 connected: true,
             }),
         });
     }
     async pulse(options) {
+        const installed = options.installedAgents || AgileMonsterClient.detectInstalledAgents();
         return this.request('/api/agent/pulse', {
             method: 'POST',
             body: JSON.stringify({
@@ -197,9 +201,73 @@ export class AgileMonsterClient {
                 mcp_version: MCP_SERVER_VERSION,
                 discovered_projects: options.discoveredProjects,
                 discovered_models: options.discoveredModels,
+                installed_agents: installed,
             }),
         });
     }
+    /**
+     * Cross-platform detection of AI coding agents installed on this computer.
+     * Checks for Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf, Aider.
+     */
+    static detectInstalledAgents() {
+        const homedir = process.env.HOME || process.env.USERPROFILE || '';
+        const detected = new Set();
+        const exists = (...p) => {
+            try {
+                const full = path.join(...p);
+                return fs.existsSync(full);
+            }
+            catch {
+                return false;
+            }
+        };
+        // 1. Antigravity
+        if (exists(homedir, '.gemini') ||
+            exists(homedir, '.antigravity') ||
+            Boolean(process.env.ANTIGRAVITY_APP_DATA_DIR) ||
+            Boolean(process.env.GEMINI_CLI)) {
+            detected.add('antigravity');
+        }
+        // 2. Cursor
+        if (exists(homedir, '.cursor') ||
+            exists(homedir, 'Library', 'Application Support', 'Cursor') ||
+            exists(process.env.APPDATA || '', 'Cursor') ||
+            exists(homedir, '.config', 'Cursor') ||
+            exists(process.cwd(), '.cursor')) {
+            detected.add('cursor');
+        }
+        // 3. Claude Code
+        if (exists(homedir, '.claude') ||
+            exists(homedir, '.claude.json') ||
+            exists(homedir, '.config', 'claude') ||
+            exists(process.cwd(), '.mcp.json')) {
+            detected.add('claude_code');
+        }
+        // 4. Codex
+        if (exists(homedir, '.codex') ||
+            exists(process.cwd(), '.codex')) {
+            detected.add('codex');
+        }
+        // 5. Hermes
+        if (exists(homedir, '.hermes') ||
+            exists(homedir, '.local', 'bin', 'hermes')) {
+            detected.add('hermes');
+        }
+        // 6. Windsurf
+        if (exists(homedir, '.codeium', 'windsurf') ||
+            exists(homedir, '.windsurf') ||
+            exists(homedir, 'Library', 'Application Support', 'Windsurf') ||
+            exists(process.env.APPDATA || '', 'Windsurf') ||
+            exists(homedir, '.config', 'Windsurf')) {
+            detected.add('windsurf');
+        }
+        // 7. Aider
+        if (exists(homedir, '.aider') ||
+            exists(homedir, '.aider.conf.yml')) {
+            detected.add('aider');
+        }
+        return Array.from(detected);
+    }
     /**
      * Discover live models installed/configured across the developer's local AI coding agents
      * (Codex, Cursor, Claude Code, Hermes, Antigravity) so the Agile Monster app & website
@@ -328,103 +396,35 @@ export class AgileMonsterClient {
         return result;
     }
     /**
-     * Auto-detect build command, deployment method, deploy script, and live URL for a project repository.
+     * Describe how a project folder builds and deploys, for the server's project/board bindings.
+     * Backed by the evidence-ranked resolver (running containers, real workflow triggers, deploy scripts,
+     * project docs) plus this machine's deployment memory, so what the web app shows matches what will run.
      */
-    static inspectProjectProfile(fullPath, name) {
-        let buildCmd = null;
-        let deployMethod = null;
-        let deployCmd = null;
-        let liveUrl = null;
-        // 1. Detect Build Command
+    static inspectProjectProfile(fullPath, _name) {
         try {
-            const fePkg = path.join(fullPath, 'frontend', 'package.json');
-            const rootPkg = path.join(fullPath, 'package.json');
-            if (fs.existsSync(fePkg)) {
-                const pkg = JSON.parse(fs.readFileSync(fePkg, 'utf8'));
-                if (pkg?.scripts?.build) {
-                    buildCmd = fs.existsSync(path.join(fullPath, 'frontend', 'pnpm-lock.yaml'))
-                        ? 'cd frontend && pnpm run build'
-                        : 'cd frontend && npm run build';
-                }
-            }
-            else if (fs.existsSync(rootPkg)) {
-                const pkg = JSON.parse(fs.readFileSync(rootPkg, 'utf8'));
-                if (pkg?.scripts?.build) {
-                    buildCmd = fs.existsSync(path.join(fullPath, 'pnpm-lock.yaml'))
-                        ? 'pnpm run build'
-                        : 'npm run build';
-                }
-            }
-            else if (fs.existsSync(path.join(fullPath, 'frontend-flutter', 'pubspec.yaml'))) {
-                buildCmd = 'cd frontend-flutter && flutter analyze';
-            }
-            else if (fs.existsSync(path.join(fullPath, 'pubspec.yaml'))) {
-                buildCmd = 'flutter analyze';
-            }
+            const profile = resolveDeployProfile(fullPath, { memory: loadMemory(fullPath) });
+            const source = profile.source === 'explicit' ? 'user' : profile.source === 'learned' || profile.source === 'verified' ? 'verified' : 'auto';
+            return {
+                build_command: profile.buildCommand,
+                deploy_method: profile.method === 'none' ? null : profile.method,
+                deploy_command: profile.command,
+                live_url: profile.liveUrl,
+                deploy_source: source,
+                deploy_confidence: profile.confidence,
+                deploy_evidence: profile.evidence.slice(0, 3).join(' · ').slice(0, 480),
+            };
         }
-        catch { }
-        // 2. Detect Deploy Method & Command
-        try {
-            const deploySh = path.join(fullPath, 'deploy', 'deploy.sh');
-            const scriptsDeploySh = path.join(fullPath, 'scripts', 'deploy.sh');
-            if (fs.existsSync(deploySh)) {
-                deployMethod = 'deploy_script';
-                const content = fs.readFileSync(deploySh, 'utf8');
-                deployCmd = content.includes('--skip-preflight')
-                    ? './deploy/deploy.sh --skip-preflight'
-                    : './deploy/deploy.sh';
-            }
-            else if (fs.existsSync(scriptsDeploySh)) {
-                deployMethod = 'deploy_script';
-                deployCmd = './scripts/deploy.sh';
-            }
-            else if (fs.existsSync(path.join(fullPath, '.github', 'workflows'))) {
-                deployMethod = 'github_actions';
-                deployCmd = 'git push origin HEAD (GitHub Actions CI/CD)';
-            }
-            else if (fs.existsSync(path.join(fullPath, 'docker-compose.yml'))) {
-                deployMethod = 'docker_compose';
-                deployCmd = 'docker compose up -d --build';
-            }
-            else if (fs.existsSync(path.join(fullPath, '.git'))) {
-                deployMethod = 'git_push';
-                deployCmd = 'git push origin HEAD';
-            }
-        }
-        catch { }
-        // 3. Detect Live URL
-        try {
-            for (const docFile of ['CLAUDE.md', 'AGENTS.md', 'README.md', '.env']) {
-                const docPath = path.join(fullPath, docFile);
-                if (fs.existsSync(docPath)) {
-                    const text = fs.readFileSync(docPath, 'utf8').slice(0, 6000);
-                    const urlMatch = text.match(/https:\/\/(?:www\.)?([a-z0-9-]+\.(?:com|ai|io|app|dev|org|net))\b/i);
-                    if (urlMatch && !/github\.com|openai\.com|anthropic\.com|googleapis\.com|npmjs\.com|localhost/i.test(urlMatch[0])) {
-                        liveUrl = urlMatch[0];
-                        break;
-                    }
-                }
-            }
-            if (!liveUrl) {
-                const clean = name.toLowerCase().replace(/^nieuw\.games[-_]*/i, '');
-                if (/^[a-z0-9-]+\.(com|ai|io|app|dev|org|net)$/i.test(clean)) {
-                    liveUrl = `https://${clean}`;
-                }
-                else if (clean === 'meerlink') {
-                    liveUrl = 'https://meerlink.com';
-                }
-                else if (clean === 'werkinghard' || clean === 'workinghard') {
-                    liveUrl = 'https://werkinghard.com';
-                }
-            }
+        catch {
+            return {
+                build_command: null,
+                deploy_method: null,
+                deploy_command: null,
+                live_url: null,
+                deploy_source: 'auto',
+                deploy_confidence: 'low',
+                deploy_evidence: '',
+            };
         }
-        catch { }
-        return {
-            build_command: buildCmd,
-            deploy_method: deployMethod,
-            deploy_command: deployCmd,
-            live_url: liveUrl,
-        };
     }
     /**
      * Scan the developer's local workspace roots (sibling folders in parent dev dir, ~/dev, ~/Projects, etc.)
@@ -496,12 +496,10 @@ export class AgileMonsterClient {
                 if (fs.existsSync(path.join(fullPath, '.git'))) {
                     try {
                         gitRemote =
-                            execSync('git config --get remote.origin.url', {
+                            stripRemoteCredentials(execSync('git config --get remote.origin.url', {
                                 cwd: fullPath,
                                 stdio: ['ignore', 'pipe', 'ignore'],
-                            })
-                                .toString()
-                                .trim() || null;
+                            }).toString()) || null;
                     }
                     catch { }
                 }
@@ -608,6 +606,26 @@ export class AgileMonsterClient {
             body: JSON.stringify({ provider, tasks }),
         });
     }
+    async listComments(cardId) {
+        const res = await this.request(`/api/cards/${cardId}/comments`);
+        return Array.isArray(res) ? res : res?.comments || [];
+    }
+    /**
+     * Tell the server how a deployment went so the board binding learns the verified route (or the failure).
+     * Older backends do not have this endpoint; that must never break a deployment.
+     */
+    async reportDeployment(report) {
+        try {
+            await this.request('/api/agent/deploy-report', {
+                method: 'POST',
+                body: JSON.stringify({ ...report, mcp_version: MCP_SERVER_VERSION }),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async autonomousStep(payload) {
         return this.request('/api/agent/autonomous-step', {
             method: 'POST',

package/dist/deploy-memory.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Machine-local deployment memory, one file per project folder.
+ *
+ * This is the feedback loop that was missing: every deployment attempt (from the daemon or reported
+ * by an IDE agent) is recorded here, so the next card starts from "what worked last time" instead of
+ * re-guessing — and a method that keeps failing because it does not apply gets demoted instead of retried.
+ *
+ * Lives in ~/.agilemonster/projects/ (never inside the repository, so it can never be committed).
+ */
+export interface DeployAttempt {
+    at: string;
+    card_id?: string | null;
+    method: string;
+    command?: string | null;
+    ok: boolean;
+    pending?: boolean;
+    kind?: string | null;
+    error?: string | null;
+    commit?: string | null;
+    duration_ms?: number;
+    reported_by?: string | null;
+}
+export interface MethodFailures {
+    count: number;
+    last_kind: string | null;
+    last_error: string | null;
+    last_at: string;
+    /** The failure says the method does not apply here (as opposed to a real deploy breaking). */
+    wrong_method: boolean;
+}
+/** A deployment whose CI run had not finished when the daemon stopped waiting; re-checked on later pulses. */
+export interface PendingVerification {
+    card_id: string;
+    card_title: string;
+    provider: string;
+    sha: string;
+    branch: string;
+    workflow_names: string[];
+    started_at: string;
+    run_url?: string | null;
+}
+/** What the agent changed for a card whose deployment has not succeeded (or not run) yet. */
+export interface CardDeployState {
+    stage: 'deploy_failed' | 'awaiting_approval';
+    files: string[];
+    summary: string;
+    verification_steps: string;
+    diff: string;
+    commit: string | null;
+    at: string;
+    attempts: number;
+    last_error?: string | null;
+    /** Set when the agent asked "may I deploy with X?": a plain "yes"/"retry" then confirms X. */
+    pending_confirmation?: {
+        method: string;
+        command: string | null;
+    } | null;
+}
+export interface ProjectMemory {
+    project_path: string;
+    updated_at: string;
+    explicit?: {
+        method: string;
+        command?: string | null;
+        live_url?: string | null;
+        notes?: string | null;
+        set_by?: string | null;
+        set_at: string;
+    } | null;
+    last_success?: {
+        method: string;
+        command?: string | null;
+        live_url?: string | null;
+        at: string;
+        commit?: string | null;
+        card_id?: string | null;
+    } | null;
+    failures: Record<string, MethodFailures>;
+    history: DeployAttempt[];
+    pending: PendingVerification[];
+    cards: Record<string, CardDeployState>;
+    /**
+     * Cards this machine already shipped (kept apart from the rolling history, so approving a card long after
+     * its review-time deployment never looks like "not deployed yet" and triggers a second one).
+     */
+    deployed_cards: Record<string, {
+        at: string;
+        commit: string | null;
+        method: string;
+        verified: boolean;
+    }>;
+}
+export declare function memoryFileFor(projectPath: string): string;
+/**
+ * Recover "how the last deployment worked" from the activity log earlier daemon versions wrote into the
+ * project (`.agilemonster/ACTIVITY.md`), so projects that already deployed successfully keep their route
+ * instead of starting from a fresh guess.
+ */
+export declare function parseLastDeploymentFromActivityLog(logText: string): {
+    method: string;
+    command: null;
+} | null;
+export declare function loadMemory(projectPath: string): ProjectMemory;
+export declare function saveMemory(memory: ProjectMemory): void;
+/** Record the outcome of an attempt and update what the project "knows" about its own deployment. */
+export declare function recordAttempt(projectPath: string, attempt: Omit<DeployAttempt, 'at'> & {
+    live_url?: string | null;
+    wrong_method?: boolean;
+    /** The change went out but nothing could confirm the deployment (no CI run found, `gh` unavailable). */
+    unverified?: boolean;
+}): ProjectMemory;
+export declare function setExplicitProfile(projectPath: string, explicit: {
+    method: string;
+    command?: string | null;
+    live_url?: string | null;
+    notes?: string | null;
+    set_by?: string | null;
+}): ProjectMemory;
+export declare function setCardState(projectPath: string, cardId: string, state: CardDeployState | null): void;
+export declare function getCardState(projectPath: string, cardId: string): CardDeployState | null;
+export declare function addPendingVerification(projectPath: string, pending: PendingVerification): void;
+export declare function removePendingVerification(projectPath: string, cardId: string): void;