clishop 1.1.0 → 1.2.0

package/dist/index.js

@@ -831,7 +831,7 @@ Addresses for agent "${agent.name}":
         country: countryInfo.code,
         instructions: instructionsInput || void 0
       });
-      if (setDefault) {
+      if (setDefault || !agent.defaultAddressId) {
         updateAgent(agent.name, { defaultAddressId: res.data.address.id });
       }
       spinner.succeed(chalk3.green(`Address "${answers.label}" added.`));
@@ -858,6 +858,11 @@ Addresses for agent "${agent.name}":
       if (agent.defaultAddressId === id) {
         updateAgent(agent.name, { defaultAddressId: void 0 });
       }
+      const remainingRes = await api.get("/addresses", { params: { agent: agent.name } });
+      const remaining = remainingRes.data.addresses || [];
+      if (remaining.length === 1) {
+        updateAgent(agent.name, { defaultAddressId: remaining[0].id });
+      }
     } catch (error) {
       handleApiError(error);
     }
@@ -927,7 +932,7 @@ async function runSetupWizard() {
   console.log();
   console.log(chalk4.bold.cyan("      W E L C O M E   T O   C L I S H O P"));
   console.log(chalk4.dim("      Order anything from your terminal."));
-  console.log(chalk4.dim(`      Build: ${"2026-03-01T16:04:21.702Z"}`));
+  console.log(chalk4.dim(`      Build: ${"2026-03-03T18:27:22.112Z"}`));
   console.log();
   divider(chalk4.cyan);
   console.log();
@@ -2108,21 +2113,22 @@ function registerSearchCommands(program2) {
       }
       if (!shipToCountry && !shipToCity && !shipToPostalCode && !opts.shipTo) {
         const agent = getActiveAgent();
-        if (agent.defaultAddressId) {
-          try {
-            spinner.text = `Resolving default address...`;
-            const addrRes = await api.get("/addresses");
-            const addresses = addrRes.data.addresses || [];
-            const defaultAddr = addresses.find((a) => a.id === agent.defaultAddressId);
-            if (defaultAddr) {
-              shipToCountry = defaultAddr.country;
-              shipToCity = defaultAddr.city;
-              shipToPostalCode = defaultAddr.postalCode;
-              shipToRegion = defaultAddr.region || void 0;
-              spinner.text = `Searching for "${query}" (delivering to: ${[shipToCity, shipToCountry].filter(Boolean).join(", ")})...`;
+        try {
+          spinner.text = `Resolving default address...`;
+          const addrRes = await api.get("/addresses");
+          const addresses = addrRes.data.addresses || [];
+          const resolved = agent.defaultAddressId && addresses.find((a) => a.id === agent.defaultAddressId) || addresses[0];
+          if (resolved) {
+            shipToCountry = resolved.country;
+            shipToCity = resolved.city;
+            shipToPostalCode = resolved.postalCode;
+            shipToRegion = resolved.region || void 0;
+            if (!agent.defaultAddressId) {
+              updateAgent(agent.name, { defaultAddressId: resolved.id });
             }
-          } catch {
+            spinner.text = `Searching for "${query}" (delivering to: ${[shipToCity, shipToCountry].filter(Boolean).join(", ")})...`;
           }
+        } catch {
         }
       }
       if (!shipToCountry) {
@@ -4581,7 +4587,7 @@ function registerFeedbackCommands(program2) {
 
 // src/index.ts
 var program = new Command();
-program.name("clishop").version("0.3.1").description(
+program.name("clishop").version("1.1.0").description(
   chalk15.bold("CLISHOP") + ' \u2014 Order anything from your terminal.\n\n  Use agents to set safety limits, addresses, and payment methods.\n  The "default" agent is used when no agent is specified.'
 ).option("--agent <name>", "Use a specific agent for this command").hook("preAction", (thisCommand) => {
   const agentOpt = thisCommand.opts().agent;

package/dist/mcp.js

@@ -13810,7 +13810,7 @@ function safeCall(fn) {
 var server = new McpServer(
   {
     name: "clishop",
-    version: "0.3.1"
+    version: "1.2.0"
   },
   {
     capabilities: {
@@ -14101,9 +14101,12 @@ server.registerTool("add_address", {
       taxId: args.taxId || void 0,
       instructions: args.instructions || void 0
     });
-    if (args.setDefault && res.data.address?.id) {
-      const { updateAgent } = await import("./config-WZBIQWME.js");
-      updateAgent(agent.name, { defaultAddressId: res.data.address.id });
+    if (res.data.address?.id) {
+      const shouldSetDefault = args.setDefault || !agent.defaultAddressId;
+      if (shouldSetDefault) {
+        const { updateAgent } = await import("./config-WZBIQWME.js");
+        updateAgent(agent.name, { defaultAddressId: res.data.address.id });
+      }
     }
     return res.data;
   });
@@ -14123,8 +14126,18 @@ server.registerTool("remove_address", {
   }
 }, async (args) => {
   return safeCall(async () => {
+    const agent = getActiveAgent();
     const api = getApiClient();
     await api.delete(`/addresses/${args.addressId}`);
+    const { updateAgent } = await import("./config-WZBIQWME.js");
+    if (agent.defaultAddressId === args.addressId) {
+      updateAgent(agent.name, { defaultAddressId: void 0 });
+    }
+    const remaining = await api.get("/addresses", { params: { agent: agent.name } });
+    const addresses = remaining.data.addresses || [];
+    if (addresses.length === 1) {
+      updateAgent(agent.name, { defaultAddressId: addresses[0].id });
+    }
     return { success: true, message: "Address removed." };
   });
 });
@@ -14415,6 +14428,551 @@ server.registerTool("submit_feedback", {
     return res.data;
   });
 });
+server.registerTool("add_product_review", {
+  title: "Add Product Review",
+  description: "Write a review for a product. Rating is on a 1-10 scale.",
+  inputSchema: {
+    productId: external_exports.string().describe("Product ID to review"),
+    rating: external_exports.number().min(1).max(10).describe("Rating from 1 (terrible) to 10 (perfect)"),
+    title: external_exports.string().describe("Review title"),
+    body: external_exports.string().describe("Review body text"),
+    orderId: external_exports.string().optional().describe("Associated order ID (optional)")
+  },
+  annotations: {
+    title: "Add Product Review",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.post(`/products/${args.productId}/reviews`, {
+      rating: args.rating,
+      title: args.title,
+      body: args.body,
+      orderId: args.orderId || void 0
+    });
+    return res.data;
+  });
+});
+server.registerTool("add_store_review", {
+  title: "Add Store Review",
+  description: "Write a review for a store. Rating is on a 1-10 scale.",
+  inputSchema: {
+    storeId: external_exports.string().describe("Store ID to review"),
+    rating: external_exports.number().min(1).max(10).describe("Rating from 1 (terrible) to 10 (perfect)"),
+    title: external_exports.string().describe("Review title"),
+    body: external_exports.string().describe("Review body text"),
+    orderId: external_exports.string().optional().describe("Associated order ID (optional)")
+  },
+  annotations: {
+    title: "Add Store Review",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.post(`/stores/${args.storeId}/reviews`, {
+      rating: args.rating,
+      title: args.title,
+      body: args.body,
+      orderId: args.orderId || void 0
+    });
+    return res.data;
+  });
+});
+server.registerTool("list_reviews", {
+  title: "List My Reviews",
+  description: "List all product and store reviews you have written.",
+  inputSchema: {},
+  annotations: {
+    title: "List My Reviews",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async () => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get("/reviews/mine");
+    return res.data;
+  });
+});
+server.registerTool("get_product_rating", {
+  title: "Get Product Rating",
+  description: "View rating details for a product including review count, Bayesian average, and effective cap.",
+  inputSchema: {
+    productId: external_exports.string().describe("Product ID")
+  },
+  annotations: {
+    title: "Get Product Rating",
+    readOnlyHint: true,
+    openWorldHint: true
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get(`/products/${args.productId}/rating`);
+    return res.data;
+  });
+});
+server.registerTool("get_store_rating", {
+  title: "Get Store Rating",
+  description: "View rating details for a store including review count, Bayesian average, and effective cap.",
+  inputSchema: {
+    storeId: external_exports.string().describe("Store ID")
+  },
+  annotations: {
+    title: "Get Store Rating",
+    readOnlyHint: true,
+    openWorldHint: true
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get(`/stores/${args.storeId}/rating`);
+    return res.data;
+  });
+});
+server.registerTool("delete_review", {
+  title: "Delete Review",
+  description: "Delete one of your reviews (product or store).",
+  inputSchema: {
+    reviewId: external_exports.string().describe("Review ID to delete"),
+    isStoreReview: external_exports.boolean().optional().describe("Set to true if this is a store review (default: product review)")
+  },
+  annotations: {
+    title: "Delete Review",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const endpoint = args.isStoreReview ? `/stores/reviews/${args.reviewId}` : `/products/reviews/${args.reviewId}`;
+    await api.delete(endpoint);
+    return { success: true, message: "Review deleted." };
+  });
+});
+server.registerTool("list_advertise_requests", {
+  title: "List Advertise Requests",
+  description: "List your advertised requests where vendors can bid to fulfill them.",
+  inputSchema: {
+    status: external_exports.enum(["open", "closed", "accepted", "cancelled", "expired"]).optional().describe("Filter by status"),
+    page: external_exports.number().optional().describe("Page number")
+  },
+  annotations: {
+    title: "List Advertise Requests",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get("/advertise", {
+      params: { status: args.status, page: args.page }
+    });
+    return res.data;
+  });
+});
+server.registerTool("get_advertise_request", {
+  title: "Get Advertise Request",
+  description: "View an advertised request and its vendor bids.",
+  inputSchema: {
+    advertiseId: external_exports.string().describe("Advertise request ID")
+  },
+  annotations: {
+    title: "Get Advertise Request",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get(`/advertise/${args.advertiseId}`);
+    return res.data;
+  });
+});
+server.registerTool("accept_advertise_bid", {
+  title: "Accept Advertise Bid",
+  description: "Accept a vendor's bid on your advertised request. All other bids will be automatically rejected.",
+  inputSchema: {
+    advertiseId: external_exports.string().describe("Advertise request ID"),
+    bidId: external_exports.string().describe("Bid ID to accept")
+  },
+  annotations: {
+    title: "Accept Advertise Bid",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.post(`/advertise/${args.advertiseId}/bids/${args.bidId}/accept`);
+    return res.data;
+  });
+});
+server.registerTool("reject_advertise_bid", {
+  title: "Reject Advertise Bid",
+  description: "Reject a vendor's bid on your advertised request.",
+  inputSchema: {
+    advertiseId: external_exports.string().describe("Advertise request ID"),
+    bidId: external_exports.string().describe("Bid ID to reject")
+  },
+  annotations: {
+    title: "Reject Advertise Bid",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.post(`/advertise/${args.advertiseId}/bids/${args.bidId}/reject`);
+    return res.data;
+  });
+});
+server.registerTool("cancel_advertise_request", {
+  title: "Cancel Advertise Request",
+  description: "Cancel an open advertised request.",
+  inputSchema: {
+    advertiseId: external_exports.string().describe("Advertise request ID to cancel")
+  },
+  annotations: {
+    title: "Cancel Advertise Request",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.post(`/advertise/${args.advertiseId}/cancel`);
+    return res.data;
+  });
+});
+server.registerTool("get_support_ticket", {
+  title: "Get Support Ticket",
+  description: "View a support ticket and its full message history.",
+  inputSchema: {
+    ticketId: external_exports.string().describe("Support ticket ID")
+  },
+  annotations: {
+    title: "Get Support Ticket",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get(`/support/${args.ticketId}`);
+    return res.data;
+  });
+});
+server.registerTool("reply_to_support_ticket", {
+  title: "Reply to Support Ticket",
+  description: "Send a reply message to an existing support ticket.",
+  inputSchema: {
+    ticketId: external_exports.string().describe("Support ticket ID"),
+    message: external_exports.string().describe("Reply message text")
+  },
+  annotations: {
+    title: "Reply to Support Ticket",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.post(`/support/${args.ticketId}/reply`, {
+      message: args.message
+    });
+    return res.data;
+  });
+});
+server.registerTool("close_support_ticket", {
+  title: "Close Support Ticket",
+  description: "Close a resolved support ticket.",
+  inputSchema: {
+    ticketId: external_exports.string().describe("Support ticket ID to close")
+  },
+  annotations: {
+    title: "Close Support Ticket",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.patch(`/support/${args.ticketId}/status`, { status: "closed" });
+    return res.data;
+  });
+});
+server.registerTool("create_agent", {
+  title: "Create Agent",
+  description: "Create a new agent (safety profile) with spending limits and category restrictions.",
+  inputSchema: {
+    name: external_exports.string().describe("Agent name (e.g. 'work', 'personal', 'gifts')"),
+    maxOrderAmount: external_exports.number().optional().describe("Max order amount in dollars (e.g. 100)"),
+    requireConfirmation: external_exports.boolean().optional().describe("Require confirmation before ordering (default: true)"),
+    allowedCategories: external_exports.array(external_exports.string()).optional().describe("Only allow these categories"),
+    blockedCategories: external_exports.array(external_exports.string()).optional().describe("Block these categories")
+  },
+  annotations: {
+    title: "Create Agent",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const { createAgent } = await import("./config-WZBIQWME.js");
+    const agent = createAgent(args.name, {
+      maxOrderAmount: args.maxOrderAmount,
+      requireConfirmation: args.requireConfirmation ?? true,
+      allowedCategories: args.allowedCategories,
+      blockedCategories: args.blockedCategories
+    });
+    return { success: true, agent };
+  });
+});
+server.registerTool("switch_agent", {
+  title: "Switch Active Agent",
+  description: "Switch which agent (safety profile) is active. The active agent controls spending limits and defaults.",
+  inputSchema: {
+    name: external_exports.string().describe("Agent name to switch to")
+  },
+  annotations: {
+    title: "Switch Active Agent",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const { setActiveAgent } = await import("./config-WZBIQWME.js");
+    setActiveAgent(args.name);
+    return { success: true, activeAgent: args.name };
+  });
+});
+server.registerTool("get_agent", {
+  title: "Get Agent Details",
+  description: "Show details of a specific agent (safety profile) including limits, categories, and defaults.",
+  inputSchema: {
+    name: external_exports.string().optional().describe("Agent name (defaults to active agent)")
+  },
+  annotations: {
+    title: "Get Agent Details",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const { getAgent, getConfig: getConfig2 } = await import("./config-WZBIQWME.js");
+    const agentName = args.name || getConfig2().get("activeAgent");
+    const agent = getAgent(agentName);
+    if (!agent) throw new Error(`Agent "${agentName}" not found.`);
+    return { agent, isActive: agentName === getConfig2().get("activeAgent") };
+  });
+});
+server.registerTool("update_agent", {
+  title: "Update Agent",
+  description: "Update an agent's settings (spending limits, category restrictions, confirmation preference).",
+  inputSchema: {
+    name: external_exports.string().optional().describe("Agent name (defaults to active agent)"),
+    maxOrderAmount: external_exports.number().optional().describe("Max order amount in dollars"),
+    requireConfirmation: external_exports.boolean().optional().describe("Require confirmation before ordering"),
+    allowedCategories: external_exports.array(external_exports.string()).optional().describe("Only allow these categories (empty = all)"),
+    blockedCategories: external_exports.array(external_exports.string()).optional().describe("Block these categories (empty = none)"),
+    defaultAddressId: external_exports.string().optional().describe("Default shipping address ID"),
+    defaultPaymentMethodId: external_exports.string().optional().describe("Default payment method ID")
+  },
+  annotations: {
+    title: "Update Agent",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const { updateAgent, getAgent, getConfig: getConfig2 } = await import("./config-WZBIQWME.js");
+    const agentName = args.name || getConfig2().get("activeAgent");
+    const existing = getAgent(agentName);
+    if (!existing) throw new Error(`Agent "${agentName}" not found.`);
+    const updates = {};
+    if (args.maxOrderAmount !== void 0) updates.maxOrderAmount = args.maxOrderAmount;
+    if (args.requireConfirmation !== void 0) updates.requireConfirmation = args.requireConfirmation;
+    if (args.allowedCategories !== void 0) updates.allowedCategories = args.allowedCategories;
+    if (args.blockedCategories !== void 0) updates.blockedCategories = args.blockedCategories;
+    if (args.defaultAddressId !== void 0) updates.defaultAddressId = args.defaultAddressId;
+    if (args.defaultPaymentMethodId !== void 0) updates.defaultPaymentMethodId = args.defaultPaymentMethodId;
+    const updated = updateAgent(agentName, updates);
+    return { success: true, agent: updated };
+  });
+});
+server.registerTool("get_spending_limit", {
+  title: "Get Spending Limit",
+  description: "View the current monthly spending limit.",
+  inputSchema: {},
+  annotations: {
+    title: "Get Spending Limit",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async () => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get("/spending-limit");
+    return res.data;
+  });
+});
+server.registerTool("set_spending_limit", {
+  title: "Set Spending Limit",
+  description: "Change your monthly spending limit. May require email confirmation for security.",
+  inputSchema: {
+    amountInDollars: external_exports.number().min(1).describe("New monthly spending limit in dollars (minimum $1)")
+  },
+  annotations: {
+    title: "Set Spending Limit",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const limitInCents = Math.round(args.amountInDollars * 100);
+    const res = await api.patch("/spending-limit", { limitInCents });
+    return res.data;
+  });
+});
+server.registerTool("remove_payment_method", {
+  title: "Remove Payment Method",
+  description: "Remove a saved payment method by its ID.",
+  inputSchema: {
+    paymentMethodId: external_exports.string().describe("Payment method ID to remove")
+  },
+  annotations: {
+    title: "Remove Payment Method",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    await api.delete(`/payment-methods/${args.paymentMethodId}`);
+    const { getActiveAgent: getActiveAgent2, updateAgent } = await import("./config-WZBIQWME.js");
+    const agent = getActiveAgent2();
+    if (agent.defaultPaymentMethodId === args.paymentMethodId) {
+      updateAgent(agent.name, { defaultPaymentMethodId: void 0 });
+    }
+    return { success: true, message: "Payment method removed." };
+  });
+});
+server.registerTool("set_default_payment_method", {
+  title: "Set Default Payment Method",
+  description: "Set the default payment method for the active agent.",
+  inputSchema: {
+    paymentMethodId: external_exports.string().describe("Payment method ID to set as default")
+  },
+  annotations: {
+    title: "Set Default Payment Method",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const { getActiveAgent: getActiveAgent2, updateAgent } = await import("./config-WZBIQWME.js");
+    const agent = getActiveAgent2();
+    updateAgent(agent.name, { defaultPaymentMethodId: args.paymentMethodId });
+    return { success: true, message: `Default payment for agent "${agent.name}" set to ${args.paymentMethodId}.` };
+  });
+});
+server.registerTool("set_default_address", {
+  title: "Set Default Address",
+  description: "Set the default shipping address for the active agent.",
+  inputSchema: {
+    addressId: external_exports.string().describe("Address ID to set as default")
+  },
+  annotations: {
+    title: "Set Default Address",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const { getActiveAgent: getActiveAgent2, updateAgent } = await import("./config-WZBIQWME.js");
+    const agent = getActiveAgent2();
+    updateAgent(agent.name, { defaultAddressId: args.addressId });
+    return { success: true, message: `Default address for agent "${agent.name}" set to ${args.addressId}.` };
+  });
+});
+server.registerTool("list_feedback", {
+  title: "List Feedback",
+  description: "List your submitted bug reports and suggestions.",
+  inputSchema: {
+    type: external_exports.enum(["bug", "suggestion"]).optional().describe("Filter by feedback type"),
+    status: external_exports.string().optional().describe("Filter by status (open, acknowledged, in_progress, fixed, wont_fix, closed)")
+  },
+  annotations: {
+    title: "List Feedback",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get("/feedback", {
+      params: {
+        ...args.type ? { type: args.type } : {},
+        ...args.status ? { status: args.status } : {}
+      }
+    });
+    return res.data;
+  });
+});
+server.registerTool("get_feedback", {
+  title: "Get Feedback Details",
+  description: "View details of a specific bug report or suggestion by ID.",
+  inputSchema: {
+    feedbackId: external_exports.string().describe("Feedback ID")
+  },
+  annotations: {
+    title: "Get Feedback Details",
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+}, async (args) => {
+  return safeCall(async () => {
+    const api = getApiClient();
+    const res = await api.get(`/feedback/${args.feedbackId}`);
+    return res.data;
+  });
+});
 async function startMcpServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);