@agilemonster/mcp-server 1.0.22 → 1.0.24

package/dist/deploy-profile.js

@@ -1,6 +1,34 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+/**
+ * Second check on this side of the wire: the server only sends a binding's route as confirmed to the account
+ * that set it, but what runs in a shell on this computer is decided HERE. If the confirmed fields name a
+ * setter and it is not this machine's account, the route is demoted to a proposal.
+ * `ownerId` null = this machine's account could not be determined; the fields are left as the server sent them.
+ */
+export function trustBoundRoute(bound, ownerId) {
+    if (!bound)
+        return null;
+    const setBy = (bound.deploy_set_by || '').trim();
+    const hasRoute = Boolean((bound.deploy_method || '').trim() || (bound.deploy_command || '').trim());
+    if (!hasRoute || !setBy || !ownerId || setBy === ownerId)
+        return bound;
+    return {
+        ...bound,
+        deploy_method: null,
+        deploy_command: null,
+        deploy_source: null,
+        proposal: bound.proposal || {
+            method: bound.deploy_method,
+            command: bound.deploy_command,
+            live_url: bound.live_url,
+            source: bound.deploy_source || 'auto',
+            set_by: setBy,
+            set_by_name: null,
+        },
+    };
+}
 // ---------------------------------------------------------------------------
 // Small helpers
 // ---------------------------------------------------------------------------
@@ -898,8 +926,43 @@ export function resolveDeployProfile(projectPath, options = {}) {
     }
     if (bound && boundSource === 'user') {
         const method = normalizeMethod(bound.deploy_method);
+        // The server only sends source "user" to the account that set the route (see trustBoundRoute)
         if (method)
-            return pinned(method, bound.deploy_command || null, 'user', 'set by a teammate in Agile Monster');
+            return pinned(method, bound.deploy_command || null, 'user', 'set by you in Agile Monster');
+    }
+    // A route someone else set on the board. It may steer this machine towards something it could have run
+    // unasked anyway (push and let CI deploy, refresh the detected Compose stack). Anything that puts THEIR
+    // command line, a deploy script, a cloud CLI or a manual dispatch on this computer is asked about once;
+    // only the machine owner's answer on the card confirms it, and it is then remembered locally.
+    const proposal = bound?.proposal || null;
+    const proposalSource = (proposal?.source || '').toLowerCase();
+    const fromProposal = () => {
+        const method = normalizeMethod(proposal?.method);
+        if (!method)
+            return null;
+        const match = candidateFor(method);
+        const theirCommand = isRunnableCommand(proposal?.command) ? (proposal?.command).trim() : null;
+        const custom = theirCommand !== null && theirCommand !== (match?.command || null);
+        const sensitive = requiresConfirmation({ method, dispatchOnly: Boolean(match?.dispatchOnly) });
+        if (!custom && sensitive && !match?.command)
+            return null; // nothing concrete to run or to confirm
+        if (!custom && !match && method !== 'manual' && method !== 'none')
+            return null; // does not apply to this checkout
+        const last = memory?.last_success || null;
+        const ranHereBefore = Boolean(last) && normalizeMethod(last?.method) === method && ((last?.command || '').trim() || null) === (theirCommand || match?.command || null);
+        const needsConfirmation = !ranHereBefore && (custom || sensitive);
+        const who = (proposal?.set_by_name || '').trim() || 'a teammate';
+        const what = proposalSource === 'verified' ? `verified by a deployment on ${who}'s machine` : `set by ${who} in Agile Monster`;
+        return {
+            ...pinned(method, theirCommand, 'proposed', needsConfirmation ? `${what}; not confirmed on this computer yet` : what),
+            confidence: needsConfirmation ? 'medium' : 'high',
+            needsConfirmation,
+        };
+    };
+    if (proposal && proposalSource === 'user') {
+        const proposed = fromProposal();
+        if (proposed)
+            return proposed;
     }
     // What worked last time, as long as it has not started failing since
     const last = memory?.last_success || null;
@@ -917,6 +980,11 @@ export function resolveDeployProfile(projectPath, options = {}) {
             return pinned(method, bound.deploy_command || null, 'verified', 'verified by an earlier deployment recorded in Agile Monster');
         }
     }
+    if (proposal && proposalSource === 'verified') {
+        const proposed = fromProposal();
+        if (proposed)
+            return proposed;
+    }
     const top = candidates[0];
     if (!top) {
         return {

package/dist/deploy-runner.js

@@ -973,7 +973,9 @@ export async function runDeployment(req) {
         log.info('deploy.needs_confirmation', { card: req.cardId, project: req.projectPath, method: profile.method, command: profile.command });
         return result({
             errorKind: 'needs_confirmation',
-            errorDetail: `This project looks like it deploys with ${methodLabel(profile.method)}${profile.command ? ` (\`${profile.command}\`)` : ''}, but I have never run that here and nobody has confirmed it.`,
+            errorDetail: profile.source === 'proposed'
+                ? `On the board this project is set to deploy with ${methodLabel(profile.method)}${profile.command ? ` (\`${profile.command}\`)` : ''}, but that was not set from this computer's account and has never been confirmed here.`
+                : `This project looks like it deploys with ${methodLabel(profile.method)}${profile.command ? ` (\`${profile.command}\`)` : ''}, but I have never run that here and nobody has confirmed it.`,
         });
     }
     const git = await commitAndPush(req, profile, pushPolicy);

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { AgileMonsterClient } from './client.js';
-import { Card } from './types.js';
+import { ActiveClaim, Card } from './types.js';
+import { BoundProfile } from './deploy-profile.js';
 export declare function createServer(client?: AgileMonsterClient): Server<{
     method: string;
     params?: {
@@ -35,7 +36,24 @@ export declare function createServer(client?: AgileMonsterClient): Server<{
         } | undefined;
     } | undefined;
 }>;
-export declare function collectProjectSourceFiles(projectPath: string, keywords: string[]): string[];
+export declare function collectProjectSourceFiles(projectPath: string, keywords: string[], phrases?: string[]): string[];
+/**
+ * The board binding's deploy profile for a card, as this machine may use it. A route that another account
+ * set arrives as a proposal (or is demoted to one here): see trustBoundRoute and resolveDeployProfile.
+ */
+export declare function boundProfileOf(card: Partial<Card>, ownerId: string | null): BoundProfile;
+/**
+ * The id under which this process claims cards. The server keeps a claim for the session that made it, so
+ * the id is stable for the life of the process. Background runs start with `auto-pulse-`: only those are
+ * re-queued automatically when they stop responding.
+ */
+export declare function sessionRunRef(kind: 'background' | 'interactive', provider?: string): string;
+export declare function holdClaim(cardId: string, runRef: string): void;
+/** The agent did something with the card: its claim is still in use. */
+export declare function touchClaim(cardId: string): void;
+export declare function releaseClaim(cardId: string): void;
+/** What the next pulse reports as held by this process. */
+export declare function activeClaims(now?: number): ActiveClaim[];
 /**
  * Roll back edits left behind by a worker that died mid-card. A file is only restored if it still holds
  * exactly what that worker wrote — anything the developer touched since is left alone.
@@ -46,6 +64,10 @@ export declare function recoverEditJournals(): number;
  * Anchored to the start of the title so "Add a restart button to the server page" is not one.
  */
 export declare function isRedeployOnlyCard(card: Pick<Card, 'title'>): boolean;
+/** The part of a build log that names the problem, without colour codes. Falls back to the last lines. */
+export declare function buildErrorExcerpt(output: string, maxLines?: number, maxChars?: number): string;
+/** Exact phrases the requester put in quotes ("Recently active projects"): the strongest pointer to the right file. */
+export declare function quotedPhrases(text: string): string[];
 export declare function executeQueuedCardAutonomously(client: AgileMonsterClient, card: Card, projectPath: string): Promise<boolean>;
 /**
  * Finish a card the human approved into Done (or flagged as `deploying`).