@fload-ai/mcp 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,37 +1,52 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/config.ts
-import "dotenv/config";
-import { readFileSync, existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function loadConfig() {
-  const apiKey = process.env.FLOAD_API_KEY;
-  const apiUrl = process.env.FLOAD_API_URL || "https://api.fload.com";
-  if (apiKey) {
-    return { apiKey, apiUrl };
+// src/api-client.ts
+var FloadApiClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
   }
-  const configPath = join(homedir(), ".fload", "config.json");
-  if (existsSync(configPath)) {
-    try {
-      const configData = JSON.parse(readFileSync(configPath, "utf-8"));
-      if (configData.apiKey) {
-        return {
-          apiKey: configData.apiKey,
-          apiUrl: configData.apiUrl || apiUrl
-        };
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        ...options.headers
       }
-    } catch (error) {
-      console.error("Failed to parse config file:", error);
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      throw new Error(error.message || `API error: ${response.status}`);
     }
+    return response.json();
   }
-  throw new Error(
-    'Fload MCP requires an API key. Set FLOAD_API_KEY environment variable or create ~/.fload/config.json with {"apiKey": "fload_sk_..."}'
-  );
-}
+  async get(path, params) {
+    const searchParams = new URLSearchParams();
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0)
+          searchParams.set(key, String(value));
+      }
+    }
+    const query = searchParams.toString();
+    return this.request(`${path}${query ? `?${query}` : ""}`);
+  }
+  async post(path, body) {
+    return this.request(path, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async patch(path, body) {
+    return this.request(path, {
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+};
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -199,6 +214,19 @@ var getReviewsSchema = z2.object({
   limit: z2.number().int().min(1).max(200).default(50).describe("Maximum number of reviews to return"),
   sortBy: z2.enum(["date", "rating"]).default("date").describe("Sort reviews by date or rating")
 });
+var generateReviewReplySchema = z2.object({
+  reviewId: z2.string().describe("The review UUID to generate a reply for"),
+  assetId: z2.string().uuid().describe("The app UUID the review belongs to")
+});
+var sendReviewReplySchema = z2.object({
+  reviewId: z2.string().describe("The review UUID to reply to"),
+  assetId: z2.string().uuid().describe("The app UUID the review belongs to"),
+  response: z2.string().describe("The reply text to send")
+});
+var translateReviewSchema = z2.object({
+  reviewId: z2.string().describe("The review UUID to translate"),
+  assetId: z2.string().uuid().describe("The app UUID the review belongs to")
+});
 async function getReviews(input, client) {
   try {
     let assetId = input.assetId;
@@ -278,6 +306,82 @@ async function getReviews(input, client) {
     };
   }
 }
+async function generateReviewReply(input, client) {
+  try {
+    const response = await client.post(`/api/reviews/${input.reviewId}/generate-reply`, {
+      assetId: input.assetId
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function sendReviewReply(input, client) {
+  try {
+    const response = await client.post(`/api/reviews/${input.reviewId}/respond`, {
+      assetId: input.assetId,
+      response: input.response
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function translateReview(input, client) {
+  try {
+    const response = await client.post(`/api/reviews/${input.reviewId}/translate`, {
+      assetId: input.assetId
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
 
 // src/tools/analytics.ts
 import { z as z3 } from "zod";
@@ -507,6 +611,19 @@ var getAgentRunHistorySchema = z4.object({
   assetId: z4.string().uuid().optional().describe("App UUID to filter runs"),
   limit: z4.number().int().min(1).max(100).default(20).describe("Maximum number of runs to return")
 });
+var triggerAgentRunSchema = z4.object({
+  agentId: z4.string().describe("The agent ID to trigger a run for"),
+  assetId: z4.string().uuid().optional().describe("Optional app UUID to run the agent against")
+});
+var pauseAgentSchema = z4.object({
+  agentId: z4.string().describe("The agent ID to pause")
+});
+var resumeAgentSchema = z4.object({
+  agentId: z4.string().describe("The agent ID to resume")
+});
+var getAgentActivitySchema = z4.object({
+  agentId: z4.string().describe("The agent ID to get activity for")
+});
 async function listAgents(_input, client) {
   try {
     let apiAgents = null;
@@ -643,6 +760,101 @@ async function getAgentRunHistory(input, client) {
     };
   }
 }
+async function triggerAgentRun(input, client) {
+  try {
+    const body = {};
+    if (input.assetId)
+      body.assetId = input.assetId;
+    const response = await client.post(`/api/agents/${input.agentId}/run`, body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function pauseAgent(input, client) {
+  try {
+    const response = await client.post(`/api/agents/${input.agentId}/pause`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function resumeAgent(input, client) {
+  try {
+    const response = await client.post(`/api/agents/${input.agentId}/resume`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAgentActivity(input, client) {
+  try {
+    const response = await client.get(`/api/agents/${input.agentId}/activity`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
 
 // src/tools/anomalies.ts
 import { z as z5 } from "zod";
@@ -657,6 +869,15 @@ var getAnomaliesSchema = z5.object({
   excludeDismissed: z5.boolean().default(true).describe("Exclude dismissed anomalies (default: true)"),
   limit: z5.number().int().min(1).max(100).default(50).describe("Maximum number of anomalies to return")
 });
+var getAnomalyDetailSchema = z5.object({
+  id: z5.string().uuid().describe("The anomaly UUID to get details for")
+});
+var acknowledgeAnomalySchema = z5.object({
+  id: z5.string().uuid().describe("The anomaly UUID to acknowledge")
+});
+var dismissAnomalySchema = z5.object({
+  id: z5.string().uuid().describe("The anomaly UUID to dismiss")
+});
 async function getAnomalies(input, client) {
   try {
     const params = {
@@ -721,22 +942,91 @@ async function getAnomalies(input, client) {
     };
   }
 }
-
-// src/tools/ads.ts
-import { z as z6 } from "zod";
-var getAdsPerformanceSchema = z6.object({
-  assetId: z6.string().uuid().optional().describe("Filter by app UUID"),
-  platform: z6.enum(["apple_search_ads", "google_ads", "meta_ads", "tiktok_ads"]).optional().describe("Filter by ad platform"),
-  fromDate: z6.string().optional().describe("Start date for performance data (YYYY-MM-DD)"),
-  toDate: z6.string().optional().describe("End date for performance data (YYYY-MM-DD)"),
-  limit: z6.number().int().min(1).max(100).default(50).describe("Maximum number of campaigns to return")
-});
-async function getAdsPerformance(input, client) {
+async function getAnomalyDetail(input, client) {
   try {
-    const params = {
-      limit: input.limit
+    const response = await client.get(`/api/anomalies/${input.id}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
     };
-    if (input.assetId)
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function acknowledgeAnomaly(input, client) {
+  try {
+    const response = await client.patch(`/api/anomalies/${input.id}/acknowledge`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function dismissAnomaly(input, client) {
+  try {
+    const response = await client.patch(`/api/anomalies/${input.id}/dismiss`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/ads.ts
+import { z as z6 } from "zod";
+var getAdsPerformanceSchema = z6.object({
+  assetId: z6.string().uuid().optional().describe("Filter by app UUID"),
+  platform: z6.enum(["apple_search_ads", "google_ads", "meta_ads", "tiktok_ads"]).optional().describe("Filter by ad platform"),
+  fromDate: z6.string().optional().describe("Start date for performance data (YYYY-MM-DD)"),
+  toDate: z6.string().optional().describe("End date for performance data (YYYY-MM-DD)"),
+  limit: z6.number().int().min(1).max(100).default(50).describe("Maximum number of campaigns to return")
+});
+async function getAdsPerformance(input, client) {
+  try {
+    const params = {
+      limit: input.limit
+    };
+    if (input.assetId)
       params.assetId = input.assetId;
     if (input.platform)
       params.platform = input.platform;
@@ -1030,262 +1320,658 @@ async function rejectAction(input, client) {
   }
 }
 
-// src/server.ts
-async function createMcpServer(config, client) {
-  console.error("[Fload MCP] Server initializing...");
-  const server = new McpServer({
-    name: "fload",
-    version: "0.1.0"
-  });
-  const rateLimiter = new RateLimiter(100, 6e4);
-  function wrapTool(toolName, handler) {
+// src/tools/aso.ts
+import { z as z11 } from "zod";
+var getAsoSummarySchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get ASO summary for")
+});
+var getAsoRecommendationsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get ASO recommendations for")
+});
+var getAsoKeywordsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get keyword intelligence for"),
+  locale: z11.string().optional().describe('Locale code to filter keywords (e.g., "en-US", "de-DE"). Returns all locales if omitted.')
+});
+var getAsoExperimentsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to list ASO experiments for"),
+  status: z11.enum(["proposed", "approved", "applied", "measuring", "completed", "reverted"]).optional().describe("Filter experiments by status"),
+  limit: z11.number().int().min(1).max(100).default(20).describe("Maximum number of experiments to return"),
+  offset: z11.number().int().min(0).default(0).describe("Number of experiments to skip for pagination")
+});
+var getAsoLocaleSnapshotsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get locale snapshots for")
+});
+var triggerAsoAnalysisSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to trigger ASO analysis for")
+});
+async function getAsoSummary(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/aso/summary`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoRecommendations(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/aso/recommendations`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoKeywords(input, client) {
+  try {
+    const params = {};
+    if (input.locale)
+      params.locale = input.locale;
+    const response = await client.get(`/api/assets/${input.assetId}/aso/keyword-intelligence`, params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoExperiments(input, client) {
+  try {
+    const params = {
+      limit: input.limit,
+      offset: input.offset
+    };
+    if (input.status)
+      params.status = input.status;
+    const response = await client.get(`/api/assets/${input.assetId}/aso/experiments`, params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoLocaleSnapshots(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/aso/locale-snapshots`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function triggerAsoAnalysis(input, client) {
+  try {
+    const response = await client.post(`/api/assets/${input.assetId}/aso/analyze`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/chat.ts
+import { z as z12 } from "zod";
+var listConversationsSchema = z12.object({
+  limit: z12.number().int().min(1).max(100).default(20).describe("Maximum number of conversations to return")
+});
+var getConversationMessagesSchema = z12.object({
+  conversationId: z12.string().uuid().describe("The conversation UUID to get messages for")
+});
+var sendChatMessageSchema = z12.object({
+  message: z12.string().describe("The message to send to the AI chat"),
+  conversationId: z12.string().uuid().optional().describe("Existing conversation UUID to continue. Starts a new conversation if omitted."),
+  agentType: z12.string().optional().describe("Agent type to use for the conversation (e.g., review, monitoring, forecasting)")
+});
+async function listConversations(input, client) {
+  try {
+    const response = await client.get("/api/chat/conversations", {
+      limit: input.limit
+    });
+    const conversations = response.data || response.conversations || response;
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            totalConversations: Array.isArray(conversations) ? conversations.length : 0,
+            conversations
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getConversationMessages(input, client) {
+  try {
+    const response = await client.get(`/api/chat/messages/${input.conversationId}`);
+    const messages = response.data || response.messages || response;
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            conversationId: input.conversationId,
+            totalMessages: Array.isArray(messages) ? messages.length : 0,
+            messages
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function sendChatMessage(input, client) {
+  try {
+    const body = {
+      message: input.message
+    };
+    if (input.conversationId)
+      body.conversationId = input.conversationId;
+    if (input.agentType)
+      body.agentType = input.agentType;
+    const response = await client.post("/api/chat", body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/index.ts
+function registerTools(server, client, options = {}) {
+  const rateLimiter = options.rateLimiter ?? new RateLimiter(100, 6e4);
+  function wrapTool(_toolName, handler) {
     return async (input) => {
       const rateCheck = rateLimiter.check("default");
       if (!rateCheck.allowed) {
         return {
-          content: [{
-            type: "text",
-            text: `Rate limit exceeded. Try again in ${Math.ceil(rateCheck.retryAfterMs / 1e3)}s. Limit: 100 requests/minute.`
-          }],
+          content: [
+            {
+              type: "text",
+              text: `Rate limit exceeded. Try again in ${Math.ceil(
+                rateCheck.retryAfterMs / 1e3
+              )}s. Limit: 100 requests/minute.`
+            }
+          ],
           isError: true
         };
       }
       return handler(input, client);
     };
   }
-  server.registerTool(
+  function tool(name, title, description, schema, handler, annotations) {
+    server.registerTool(
+      name,
+      {
+        title,
+        description,
+        inputSchema: schema.shape,
+        annotations: { title, ...annotations }
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      wrapTool(name, handler)
+    );
+  }
+  tool(
     "list_apps",
-    {
-      description: "List all mobile apps in your Fload organization. Returns app metadata including name, bundle ID, platform (iOS/Android), icon URL, and category.",
-      inputSchema: listAppsSchema.shape
-    },
-    wrapTool("list_apps", listApps)
+    "List apps",
+    "List all mobile apps in your Fload organization. Returns app metadata including name, bundle ID, platform (iOS/Android), icon URL, and category.",
+    listAppsSchema,
+    listApps,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_app_details",
-    {
-      description: "Get detailed information about a specific app, including metadata, connected data sources (App Store Connect, Google Play Console), and sync status. Provide either assetId (UUID) or bundleId.",
-      inputSchema: getAppDetailsSchema.shape
-    },
-    wrapTool("get_app_details", getAppDetails)
+    "Get app details",
+    "Get detailed information about a specific app, including metadata, connected data sources (App Store Connect, Google Play Console), and sync status. Provide either assetId (UUID) or bundleId.",
+    getAppDetailsSchema,
+    getAppDetails,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_reviews",
-    {
-      description: "Get app reviews with flexible filtering. Filter by app (assetId or bundleId), platform, rating (1-5 stars), replied status, and date range. Returns reviews with metadata, author, body text, and reply status. Useful for sentiment analysis, support workflows, and review management.",
-      inputSchema: getReviewsSchema.shape
-    },
-    wrapTool("get_reviews", getReviews)
+    "Get reviews",
+    "Get app reviews with flexible filtering. Filter by app (assetId or bundleId), platform, rating (1-5 stars), replied status, and date range. Returns reviews with metadata, author, body text, and reply status. Useful for sentiment analysis, support workflows, and review management.",
+    getReviewsSchema,
+    getReviews,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
+    "generate_review_reply",
+    "Generate review reply (AI draft)",
+    "Generate an AI draft reply for an app review. The AI uses the review context and any configured agent settings (tone, custom instructions) to craft a response. Returns the generated draft text. Does not publish \u2014 call send_review_reply or approve_action to publish the draft.",
+    generateReviewReplySchema,
+    generateReviewReply,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+  tool(
+    "send_review_reply",
+    "Send review reply",
+    "Send a reply to an app review on the App Store or Google Play. The response text will be submitted as the developer response. This is a write operation that publishes the reply publicly \u2014 treat as destructive (cannot be silently undone).",
+    sendReviewReplySchema,
+    sendReviewReply,
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+  );
+  tool(
+    "translate_review",
+    "Translate review",
+    "Translate a review to English. Useful for reviews written in other languages. Returns the translated text. Does not modify the review in Fload.",
+    translateReviewSchema,
+    translateReview,
+    { readOnlyHint: true, openWorldHint: true }
+  );
+  tool(
     "discover_metrics",
-    {
-      description: "Discover what metrics are available for an app. Returns all available metrics organized by category (revenue, downloads, subscriptions, engagement, ads). Always call this first before querying metrics to know what data exists.",
-      inputSchema: discoverMetricsSchema.shape
-    },
-    wrapTool("discover_metrics", discoverMetrics)
+    "Discover available metrics",
+    "Discover what metrics are available for an app. Returns all available metrics organized by category (revenue, downloads, subscriptions, engagement, ads). Always call this first before querying metrics to know what data exists.",
+    discoverMetricsSchema,
+    discoverMetrics,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_metrics",
-    {
-      description: "Query metric timeseries data for an app. Supports 30+ metrics (proceeds, totalDownloads, activeSubs, sessions, crashes, adSpend, etc.). Can query multiple metrics at once. Supports dimensional breakdowns (by country, platform, campaign). Use discover_metrics first to see available metrics.",
-      inputSchema: getMetricsSchema.shape
-    },
-    wrapTool("get_metrics", getMetrics)
+    "Get metrics",
+    "Query metric timeseries data for an app. Supports 30+ metrics (proceeds, totalDownloads, activeSubs, sessions, crashes, adSpend, etc.). Can query multiple metrics at once. Supports dimensional breakdowns (by country, platform, campaign). Use discover_metrics first to see available metrics.",
+    getMetricsSchema,
+    getMetrics,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "discover_dimensions",
-    {
-      description: "Discover available dimensions for breaking down metrics (e.g., country, platform, app version, campaign). Optionally get the available values for a specific dimension.",
-      inputSchema: discoverDimensionsSchema.shape
-    },
-    wrapTool("discover_dimensions", discoverDimensions)
+    "Discover available dimensions",
+    "Discover available dimensions for breaking down metrics (e.g., country, platform, app version, campaign). Optionally get the available values for a specific dimension.",
+    discoverDimensionsSchema,
+    discoverDimensions,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "list_agents",
-    {
-      description: "List all available AI agents in the Fload platform with their current status. Returns agent types (review, monitoring, forecasting, growth, aso, ads, product, submission_review) and configuration status.",
-      inputSchema: listAgentsSchema.shape
-    },
-    wrapTool("list_agents", listAgents)
+    "List agents",
+    "List all available AI agents in the Fload platform with their current status. Returns agent types (review, monitoring, forecasting, growth, aso, ads, product, submission_review) and configuration status.",
+    listAgentsSchema,
+    listAgents,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_agent_details",
-    {
-      description: "Get detailed configuration and status for a specific agent type. For the review agent, returns per-asset settings (mode, tone, custom instructions). For the product agent, returns latest run details.",
-      inputSchema: getAgentDetailsSchema.shape
-    },
-    wrapTool("get_agent_details", getAgentDetails)
+    "Get agent details",
+    "Get detailed configuration and status for a specific agent type. For the review agent, returns per-asset settings (mode, tone, custom instructions). For the product agent, returns latest run details.",
+    getAgentDetailsSchema,
+    getAgentDetails,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_agent_run_history",
-    {
-      description: "Get run history for a specific agent type. Currently available for the product agent (BrowserStack app installation runs). Returns run status, timing, and error details.",
-      inputSchema: getAgentRunHistorySchema.shape
-    },
-    wrapTool("get_agent_run_history", getAgentRunHistory)
+    "Get agent run history",
+    "Get run history for a specific agent type. Currently available for the product agent (BrowserStack app installation runs). Returns run status, timing, and error details.",
+    getAgentRunHistorySchema,
+    getAgentRunHistory,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "trigger_agent_run",
+    "Trigger agent run",
+    "Trigger a manual run for an agent. Optionally specify an asset (app) to run the agent against. Returns the triggered run details. Reversible in the sense that agent runs can be paused or dismissed.",
+    triggerAgentRunSchema,
+    triggerAgentRun,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+  tool(
+    "pause_agent",
+    "Pause agent",
+    "Pause a running agent. The agent will stop processing until resumed. Reversible via resume_agent.",
+    pauseAgentSchema,
+    pauseAgent,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  );
+  tool(
+    "resume_agent",
+    "Resume agent",
+    "Resume a paused agent. The agent will continue processing from where it left off. Reversible via pause_agent.",
+    resumeAgentSchema,
+    resumeAgent,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
+    "get_agent_activity",
+    "Get agent activity",
+    "Get the recent activity log for an agent. Returns a chronological list of actions the agent has taken, including timestamps, event types, and details.",
+    getAgentActivitySchema,
+    getAgentActivity,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
     "get_anomalies",
-    {
-      description: "Get detected anomalies (unusual metric changes) for your apps. Filter by app, severity (low/medium/high/critical), type (surge/decline), status, metric name, and date range. Returns actual vs expected values, deviation percentage, confidence, and suggested actions.",
-      inputSchema: getAnomaliesSchema.shape
-    },
-    wrapTool("get_anomalies", getAnomalies)
+    "Get anomalies",
+    "Get detected anomalies (unusual metric changes) for your apps. Filter by app, severity (low/medium/high/critical), type (surge/decline), status, metric name, and date range. Returns actual vs expected values, deviation percentage, confidence, and suggested actions.",
+    getAnomaliesSchema,
+    getAnomalies,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_anomaly_detail",
+    "Get anomaly detail",
+    "Get full detail for a single anomaly including chart data. Returns the anomaly metadata, actual vs expected values, and historical metric data points for visualization.",
+    getAnomalyDetailSchema,
+    getAnomalyDetail,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "acknowledge_anomaly",
+    "Acknowledge anomaly",
+    'Mark an anomaly as acknowledged. This updates the anomaly status from "new" to "acknowledged", indicating it has been reviewed but not dismissed. Reversible \u2014 anomaly can be reset or dismissed later.',
+    acknowledgeAnomalySchema,
+    acknowledgeAnomaly,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  );
+  tool(
+    "dismiss_anomaly",
+    "Dismiss anomaly",
+    'Dismiss an anomaly. This updates the anomaly status to "dismissed", removing it from active alerts. Dismissed anomalies are excluded from queries by default. Soft state change \u2014 the anomaly row is preserved and can be un-dismissed later.',
+    dismissAnomalySchema,
+    dismissAnomaly,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_ads_performance",
-    {
-      description: "Get ad campaign performance data across platforms (Apple Search Ads, Google Ads, Meta Ads, TikTok Ads). Returns campaign metadata, status, and for Apple Search Ads includes daily performance snapshots (spend, impressions, taps, installs, CPI, TTR, conversion rate).",
-      inputSchema: getAdsPerformanceSchema.shape
-    },
-    wrapTool("get_ads_performance", getAdsPerformance)
+    "Get ads performance",
+    "Get ad campaign performance data across platforms (Apple Search Ads, Google Ads, Meta Ads, TikTok Ads). Returns campaign metadata, status, and for Apple Search Ads includes daily performance snapshots (spend, impressions, taps, installs, CPI, TTR, conversion rate).",
+    getAdsPerformanceSchema,
+    getAdsPerformance,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_growth_audit",
-    {
-      description: "Get a comprehensive growth audit for an app. Synthesizes data from review sentiment analysis, recent anomalies, valuation trends, and connector health into an actionable growth assessment.",
-      inputSchema: getGrowthAuditSchema.shape
-    },
-    wrapTool("get_growth_audit", getGrowthAudit)
+    "Get growth audit",
+    "Get a comprehensive growth audit for an app. Synthesizes data from review sentiment analysis, recent anomalies, valuation trends, and connector health into an actionable growth assessment.",
+    getGrowthAuditSchema,
+    getGrowthAudit,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_growth_score",
-    {
-      description: "Get a calculated growth score (0-100) and grade (A-F) for an app. The score is based on app store rating, valuation trend, recent anomalies, review sentiment, and data connector health. Includes a breakdown of scoring factors.",
-      inputSchema: getGrowthScoreSchema.shape
-    },
-    wrapTool("get_growth_score", getGrowthScore)
+    "Get growth score",
+    "Get a calculated growth score (0-100) and grade (A-F) for an app. The score is based on app store rating, valuation trend, recent anomalies, review sentiment, and data connector health. Includes a breakdown of scoring factors.",
+    getGrowthScoreSchema,
+    getGrowthScore,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_forecasts",
-    {
-      description: "Get valuation-based forecasts and trend analysis for an app. Returns historical valuation data points, trend statistics (direction, volatility), and simple linear projections. For detailed metric forecasting with statistical models, use the platform dashboard.",
-      inputSchema: getForecastsSchema.shape
-    },
-    wrapTool("get_forecasts", getForecasts)
+    "Get forecasts",
+    "Get valuation-based forecasts and trend analysis for an app. Returns historical valuation data points, trend statistics (direction, volatility), and simple linear projections. For detailed metric forecasting with statistical models, use the platform dashboard.",
+    getForecastsSchema,
+    getForecasts,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_dashboard_overview",
-    {
-      description: "Get an aggregated dashboard overview for the organization. Returns portfolio summary (apps, valuations, ratings), data connector health status, and alerts (recent anomalies, pending review drafts).",
-      inputSchema: getDashboardOverviewSchema.shape
-    },
-    wrapTool("get_dashboard_overview", getDashboardOverview)
+    "Get dashboard overview",
+    "Get an aggregated dashboard overview for the organization. Returns portfolio summary (apps, valuations, ratings), data connector health status, and alerts (recent anomalies, pending review drafts).",
+    getDashboardOverviewSchema,
+    getDashboardOverview,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "list_pending_actions",
-    {
-      description: "List pending actions awaiting approval. Currently shows AI-generated review draft replies that have not been sent yet. Includes the original review context and the drafted reply. Filter by app.",
-      inputSchema: listPendingActionsSchema.shape
-    },
-    wrapTool("list_pending_actions", listPendingActions)
+    "List pending actions",
+    "List pending actions awaiting approval. Currently shows AI-generated review draft replies that have not been sent yet. Includes the original review context and the drafted reply. Filter by app.",
+    listPendingActionsSchema,
+    listPendingActions,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "approve_action",
-    {
-      description: "Approve a pending action (e.g., a review draft reply). This marks the reply for sending. Optionally edit the reply text before approving.",
-      inputSchema: approveActionSchema.shape
-    },
-    wrapTool("approve_action", approveAction)
+    "Approve pending action",
+    "Approve a pending action (e.g., a review draft reply). Approving a review reply publishes it to the store \u2014 treat as destructive (publicly visible, cannot be silently undone). Optionally edit the reply text before approving.",
+    approveActionSchema,
+    approveAction,
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
   );
-  server.registerTool(
+  tool(
     "reject_action",
-    {
-      description: "Reject a pending action (e.g., delete a review draft reply). The draft will be permanently removed.",
-      inputSchema: rejectActionSchema.shape
-    },
-    wrapTool("reject_action", rejectAction)
+    "Reject pending action",
+    "Reject a pending action (e.g., delete a review draft reply). The draft will be permanently removed. Destructive \u2014 not recoverable without regenerating the draft.",
+    rejectActionSchema,
+    rejectAction,
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_summary",
+    "Get ASO summary",
+    "Get the ASO (App Store Optimization) score, health status, and overview for an app. Returns an overall optimization score and key ASO health indicators. Use this for a quick snapshot of how well an app is optimized for store search and discovery.",
+    getAsoSummarySchema,
+    getAsoSummary,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_recommendations",
+    "Get ASO recommendations",
+    "Get actionable ASO recommendations for an app, including suggested improvements to the title, subtitle, keywords, and description. Each recommendation explains the rationale and expected impact on search visibility.",
+    getAsoRecommendationsSchema,
+    getAsoRecommendations,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_keywords",
+    "Get ASO keywords",
+    'Get keyword intelligence for an app \u2014 current keyword rankings, search volume estimates, difficulty scores, and competitor keyword data. Optionally filter by locale (e.g., "en-US"). Useful for identifying keyword opportunities and tracking ranking changes.',
+    getAsoKeywordsSchema,
+    getAsoKeywords,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_experiments",
+    "Get ASO experiments",
+    "List ASO experiments (A/B tests and metadata changes) for an app. Filter by status: proposed, approved, applied, measuring, completed, or reverted. Returns experiment details, variants, and results when available. Supports pagination.",
+    getAsoExperimentsSchema,
+    getAsoExperiments,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_locale_snapshots",
+    "Get ASO locale snapshots",
+    "Get current App Store and Google Play listing snapshots across all locales for an app. Returns the live title, subtitle, keywords, description, and promotional text for each locale. Useful for auditing localized metadata consistency.",
+    getAsoLocaleSnapshotsSchema,
+    getAsoLocaleSnapshots,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "trigger_aso_analysis",
+    "Trigger ASO analysis",
+    "Trigger a new ASO analysis run for an app. This kicks off a fresh evaluation of the app's store listing metadata, keyword rankings, and competitive positioning. Results will be reflected in subsequent calls to get_aso_summary and get_aso_recommendations.",
+    triggerAsoAnalysisSchema,
+    triggerAsoAnalysis,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+  tool(
+    "list_conversations",
+    "List conversations",
+    "List chat conversations in the Fload AI chat. Returns conversation metadata including title, creation date, and last message preview. Use limit to control how many are returned.",
+    listConversationsSchema,
+    listConversations,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_conversation_messages",
+    "Get conversation messages",
+    "Get all messages in a specific chat conversation. Returns the full message history including user messages and AI responses with timestamps and roles.",
+    getConversationMessagesSchema,
+    getConversationMessages,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "send_chat_message",
+    "Send chat message",
+    "Send a message to the Fload AI chat assistant. Starts a new conversation if no conversationId is provided, or continues an existing one. Optionally specify an agentType to route to a specialized agent (review, monitoring, forecasting, etc.). Adds a message to your chat history \u2014 not publicly visible.",
+    sendChatMessageSchema,
+    sendChatMessage,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
   );
-  const toolCount = 18;
-  console.error(`[Fload MCP] Registered ${toolCount} tools`);
+}
+
+// src/server.ts
+async function createMcpServer(_config, client) {
+  console.error("[Fload MCP] Server initializing...");
+  const server = new McpServer({
+    name: "fload",
+    version: "0.1.0"
+  });
+  registerTools(server, client);
+  console.error("[Fload MCP] Registered tools");
   return server;
 }
 
-// src/api-client.ts
-var FloadApiClient = class {
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-  }
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(error.message || `API error: ${response.status}`);
-    }
-    return response.json();
-  }
-  async get(path, params) {
-    const searchParams = new URLSearchParams();
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0)
-          searchParams.set(key, String(value));
-      }
-    }
-    const query = searchParams.toString();
-    return this.request(`${path}${query ? `?${query}` : ""}`);
-  }
-  async post(path, body) {
-    return this.request(path, {
-      method: "POST",
-      body: body ? JSON.stringify(body) : void 0
-    });
-  }
-  async patch(path, body) {
-    return this.request(path, {
-      method: "PATCH",
-      body: body ? JSON.stringify(body) : void 0
-    });
-  }
-  async delete(path) {
-    return this.request(path, { method: "DELETE" });
+// src/config.ts
+import "dotenv/config";
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function loadConfig() {
+  const apiKey = process.env.FLOAD_API_KEY;
+  const apiUrl = process.env.FLOAD_API_URL || "https://api.fload.com";
+  if (apiKey) {
+    return { apiKey, apiUrl };
   }
-};
-
-// src/index.ts
-async function main() {
-  try {
-    console.error("[Fload MCP] Starting server...");
-    const config = loadConfig();
-    console.error("[Fload MCP] Configuration loaded");
-    console.error(`[Fload MCP] API URL: ${config.apiUrl}`);
-    const client = new FloadApiClient(config.apiUrl, config.apiKey);
+  const configPath = join(homedir(), ".fload", "config.json");
+  if (existsSync(configPath)) {
     try {
-      await client.get("/api/assets", { limit: 1, offset: 0 });
-      console.error("[Fload MCP] API connection verified");
+      const configData = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (configData.apiKey) {
+        return {
+          apiKey: configData.apiKey,
+          apiUrl: configData.apiUrl || apiUrl
+        };
+      }
     } catch (error) {
-      console.error("[Fload MCP] Warning: API connection test failed:", error instanceof Error ? error.message : error);
-      console.error("[Fload MCP] Continuing anyway \u2014 API may become available");
+      console.error("Failed to parse config file:", error);
     }
-    const server = await createMcpServer(config, client);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("[Fload MCP] Server running on stdio");
-  } catch (error) {
-    console.error("[Fload MCP] Fatal error:", error);
-    process.exit(1);
   }
+  throw new Error(
+    'Fload MCP requires an API key. Set FLOAD_API_KEY environment variable or create ~/.fload/config.json with {"apiKey": "fload_sk_..."}'
+  );
 }
-process.on("SIGINT", () => {
-  console.error("[Fload MCP] Shutting down...");
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  console.error("[Fload MCP] Shutting down...");
-  process.exit(0);
-});
-main().catch((error) => {
-  console.error("[Fload MCP] Unhandled error:", error);
-  process.exit(1);
-});
+export {
+  FloadApiClient,
+  RateLimiter,
+  createMcpServer,
+  loadConfig,
+  registerTools
+};
 //# sourceMappingURL=index.js.map