@rubytech/create-maxy 1.0.499 → 1.0.501

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/lib/loop-api.ts

@@ -10,7 +10,7 @@ import { decrypt } from "./crypto.js";
 //   For each key:                        │
 //     1. Decrypt API key                 │
 //     2. Check permissions               │
-//     3. HTTP GET → Loop API V2          │
+//     3. HTTP GET/POST/PUT → Loop API V2 │
 //   │                                    │
 //   ▼                                    │
 //   Promise.allSettled → merge results   │
@@ -114,13 +114,116 @@ export async function loopGet<T>(
   }
 }
 
+/**
+ * Make a POST request to the Loop API V2.
+ * For write operations: create viewings, record feedback, submit enquiries, etc.
+ * Returns parsed JSON response. Treats 204 as success with empty result.
+ */
+export async function loopPost<T>(
+  apiKey: string,
+  path: string,
+  body: unknown,
+  toolName: string,
+  teamName: string
+): Promise<T> {
+  const url = `${LOOP_BASE_URL}${path}`;
+  const start = Date.now();
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "X-Api-Key": apiKey,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+
+  const duration = Date.now() - start;
+  console.error(
+    `[loop] WRITE ${toolName} team=${teamName} endpoint=POST ${path} status=${response.status} duration=${duration}ms`
+  );
+
+  if (response.status === 204) {
+    return { success: true } as unknown as T;
+  }
+
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    throw new LoopApiError(response.status, teamName, path, errorBody);
+  }
+
+  const text = await response.text();
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    throw new Error(
+      `Loop returned non-JSON response for team=${teamName} path=${path} ` +
+      `(status=${response.status}, length=${text.length})`
+    );
+  }
+}
+
+/**
+ * Make a PUT request to the Loop API V2.
+ * For update operations: batch matching, submit quotes, update preferences, etc.
+ */
+export async function loopPut<T>(
+  apiKey: string,
+  path: string,
+  body: unknown,
+  toolName: string,
+  teamName: string
+): Promise<T> {
+  const url = `${LOOP_BASE_URL}${path}`;
+  const start = Date.now();
+
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: {
+      "X-Api-Key": apiKey,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+
+  const duration = Date.now() - start;
+  console.error(
+    `[loop] WRITE ${toolName} team=${teamName} endpoint=PUT ${path} status=${response.status} duration=${duration}ms`
+  );
+
+  if (response.status === 204) {
+    return { success: true } as unknown as T;
+  }
+
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    throw new LoopApiError(response.status, teamName, path, errorBody);
+  }
+
+  const text = await response.text();
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    throw new Error(
+      `Loop returned non-JSON response for team=${teamName} path=${path} ` +
+      `(status=${response.status}, length=${text.length})`
+    );
+  }
+}
+
 export class LoopApiError extends Error {
   constructor(
     public readonly status: number,
     public readonly teamName: string,
-    public readonly path: string
+    public readonly path: string,
+    public readonly responseBody?: string
   ) {
-    super(`Loop API returned ${status} for team=${teamName} path=${path}`);
+    const detail = responseBody ? ` — ${responseBody.slice(0, 200)}` : "";
+    super(`Loop API returned ${status} for team=${teamName} path=${path}${detail}`);
     this.name = "LoopApiError";
   }
 }
@@ -244,6 +347,40 @@ export async function aggregateAcrossTeams<T>(
   return { results, failures, skipped, totalTeams: allKeys.length };
 }
 
+/**
+ * Resolve a single team's API key with permission checking.
+ * Handles key loading, decryption, and permission validation.
+ * Used for both reads and writes that target a specific team — no fan-out.
+ */
+export async function withTeamKey<T>(
+  accountId: string,
+  teamName: string,
+  endpointGroup: string,
+  toolName: string,
+  execute: (apiKey: string) => Promise<T>
+): Promise<T> {
+  const allKeys = await loadTeamKeys(accountId);
+  if (allKeys.length === 0) {
+    throw new Error("No Loop teams registered. Use loop-key-register to add team API keys.");
+  }
+
+  const key = allKeys.find((k) => k.teamName === teamName);
+  if (!key) {
+    const available = allKeys.map((k) => k.teamName).join(", ");
+    throw new Error(`Team "${teamName}" not found. Available teams: ${available}`);
+  }
+
+  if (!key.permissions.includes(endpointGroup)) {
+    throw new Error(
+      `Team "${teamName}" does not have ${endpointGroup} permission. ` +
+      `Current permissions: ${key.permissions.join(", ")}`
+    );
+  }
+
+  const apiKey = decrypt(key.encryptedKey);
+  return execute(apiKey);
+}
+
 /**
  * Format an aggregation result into a human-readable text response.
  */

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/customer-preferences.ts

@@ -0,0 +1,60 @@
+import { loopGet, loopPost, withTeamKey } from "../lib/loop-api.js";
+
+type PreferencesAction = "read" | "write";
+
+interface LoopCustomerPreferences {
+  personCode?: number;
+  preferences?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+interface LoopBooleanResponse {
+  success?: boolean;
+  [key: string]: unknown;
+}
+
+export async function customerPreferences(params: {
+  accountId: string;
+  teamName: string;
+  personCode: number;
+  action: PreferencesAction;
+  preferences?: Record<string, unknown>;
+}): Promise<string> {
+  const { accountId, teamName, personCode, action } = params;
+
+  if (action === "read") {
+    const result = await withTeamKey<LoopCustomerPreferences>(
+      accountId, teamName, "customer", "loop-customer-preferences",
+      async (apiKey) => {
+        return loopGet<LoopCustomerPreferences>(
+          apiKey, `/customer/preferences/${personCode}`,
+          "loop-customer-preferences", teamName
+        );
+      }
+    );
+
+    if (!result || (Array.isArray(result) && result.length === 0)) {
+      return `No preferences found for person ${personCode} via team "${teamName}".`;
+    }
+    return JSON.stringify(result, null, 2);
+  }
+
+  if (action === "write") {
+    if (!params.preferences) {
+      throw new Error("preferences object is required when action is 'write'.");
+    }
+
+    await withTeamKey<LoopBooleanResponse>(
+      accountId, teamName, "customer", "loop-customer-preferences",
+      async (apiKey) => {
+        return loopPost<LoopBooleanResponse>(
+          apiKey, `/customer/preferences/${personCode}`,
+          params.preferences!, "loop-customer-preferences", teamName
+        );
+      }
+    );
+    return `Preferences updated for person ${personCode} via team "${teamName}".`;
+  }
+
+  throw new Error(`Unknown action: ${action}. Use "read" or "write".`);
+}

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/feedback.ts

@@ -0,0 +1,80 @@
+import {
+  loopGet,
+  loopPost,
+  withTeamKey,
+} from "../lib/loop-api.js";
+
+type Department = "sales" | "lettings";
+
+interface LoopViewingFeedback {
+  viewingId?: number;
+  propertyAddress?: string;
+  date?: string;
+  attendeeName?: string;
+  feedback?: string;
+  rating?: number;
+  status?: string;
+  [key: string]: unknown;
+}
+
+interface LoopBooleanResponse {
+  success?: boolean;
+  [key: string]: unknown;
+}
+
+export async function feedbackGet(params: {
+  accountId: string;
+  teamName: string;
+  viewingId: number;
+  department: Department;
+}): Promise<string> {
+  const { accountId, teamName, viewingId, department } = params;
+
+  const result = await withTeamKey<LoopViewingFeedback>(
+    accountId,
+    teamName,
+    "feedback",
+    "loop-feedback-get",
+    async (apiKey) => {
+      const path = `/feedback/residential/${department}/viewings/${viewingId}`;
+      return loopGet<LoopViewingFeedback>(apiKey, path, "loop-feedback-get", teamName);
+    }
+  );
+
+  if (!result || (Array.isArray(result) && result.length === 0)) {
+    return `No feedback found for viewing ${viewingId} (${department}) via team "${teamName}".`;
+  }
+
+  const f = result;
+  const lines = [`**Feedback for viewing ${viewingId}**`];
+  if (f.propertyAddress) lines.push(`Property: ${f.propertyAddress}`);
+  if (f.date) lines.push(`Date: ${f.date}`);
+  if (f.attendeeName) lines.push(`Attendee: ${f.attendeeName}`);
+  if (f.rating != null) lines.push(`Rating: ★${f.rating}`);
+  if (f.status) lines.push(`Status: ${f.status}`);
+  if (f.feedback) lines.push(`Feedback: ${f.feedback}`);
+  return lines.join("\n");
+}
+
+export async function feedbackSubmit(params: {
+  accountId: string;
+  teamName: string;
+  viewingId: number;
+  department: Department;
+  feedback: string;
+}): Promise<string> {
+  const { accountId, teamName, viewingId, department, feedback } = params;
+
+  await withTeamKey<LoopBooleanResponse>(
+    accountId,
+    teamName,
+    "feedback",
+    "loop-feedback-submit",
+    async (apiKey) => {
+      const path = `/feedback/residential/${department}/viewings/${viewingId}/feedback`;
+      return loopPost<LoopBooleanResponse>(apiKey, path, { result: feedback }, "loop-feedback-submit", teamName);
+    }
+  );
+
+  return `Feedback submitted for viewing ${viewingId} (${department}) via team "${teamName}".`;
+}

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/key-register.ts

@@ -10,7 +10,7 @@ interface LoopTeamResponse {
   [key: string]: unknown;
 }
 
-const ALL_PERMISSIONS = ["properties", "people", "viewings", "feedback", "team"];
+const ALL_PERMISSIONS = ["properties", "people", "viewings", "feedback", "team", "marketing", "customer", "supplier"];
 
 export async function keyRegister(params: {
   teamName: string;

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/marketing-enquiry.ts

@@ -0,0 +1,105 @@
+import { loopGet, loopPost, loopPut, withTeamKey } from "../lib/loop-api.js";
+
+type EnquiryAction = "seller-enquiry" | "autoresponder-get" | "autoresponder-answers" | "autoresponder-details" | "autoresponder-refer";
+
+interface LoopBooleanResponse {
+  success?: boolean;
+  [key: string]: unknown;
+}
+
+interface LoopAutoResponderDetails {
+  id?: number;
+  questions?: unknown[];
+  enquiryDetails?: unknown;
+  [key: string]: unknown;
+}
+
+export async function marketingEnquiry(params: {
+  accountId: string;
+  teamName: string;
+  action: EnquiryAction;
+  // For seller-enquiry
+  sellerEnquiryData?: Record<string, unknown>;
+  // For autoresponder actions
+  autoResponderId?: number;
+  autoResponderKey?: string;
+  // For autoresponder-answers
+  answers?: unknown[];
+  // For autoresponder-details
+  details?: Record<string, unknown>;
+}): Promise<string> {
+  const { accountId, teamName, action } = params;
+
+  if (action === "seller-enquiry") {
+    await withTeamKey<LoopBooleanResponse>(
+      accountId, teamName, "marketing", "loop-marketing-enquiry",
+      async (apiKey) => {
+        return loopPost<LoopBooleanResponse>(
+          apiKey, "/marketing/enquiries/seller",
+          params.sellerEnquiryData ?? {}, "loop-marketing-enquiry", teamName
+        );
+      }
+    );
+    return `Seller enquiry submitted via team "${teamName}".`;
+  }
+
+  if (!params.autoResponderId || !params.autoResponderKey) {
+    throw new Error("autoResponderId and autoResponderKey are required for autoresponder actions.");
+  }
+  const id = params.autoResponderId;
+  const key = params.autoResponderKey;
+
+  if (action === "autoresponder-get") {
+    const result = await withTeamKey<LoopAutoResponderDetails>(
+      accountId, teamName, "marketing", "loop-marketing-enquiry",
+      async (apiKey) => {
+        return loopGet<LoopAutoResponderDetails>(
+          apiKey, `/marketing/enquiries/auto-responder/${id}/${key}`,
+          "loop-marketing-enquiry", teamName
+        );
+      }
+    );
+    return JSON.stringify(result, null, 2);
+  }
+
+  if (action === "autoresponder-answers") {
+    await withTeamKey<LoopBooleanResponse>(
+      accountId, teamName, "marketing", "loop-marketing-enquiry",
+      async (apiKey) => {
+        return loopPut<LoopBooleanResponse>(
+          apiKey, `/marketing/enquiries/auto-responder/${id}/answers/${key}`,
+          params.answers ?? [], "loop-marketing-enquiry", teamName
+        );
+      }
+    );
+    return `Auto-responder answers submitted for enquiry ${id} via team "${teamName}".`;
+  }
+
+  if (action === "autoresponder-details") {
+    await withTeamKey<LoopBooleanResponse>(
+      accountId, teamName, "marketing", "loop-marketing-enquiry",
+      async (apiKey) => {
+        return loopPut<LoopBooleanResponse>(
+          apiKey, `/marketing/enquiries/auto-responder/${id}/details/${key}`,
+          params.details ?? {}, "loop-marketing-enquiry", teamName
+        );
+      }
+    );
+    return `Auto-responder details updated for enquiry ${id} via team "${teamName}".`;
+  }
+
+  if (action === "autoresponder-refer") {
+    await withTeamKey<LoopBooleanResponse>(
+      accountId, teamName, "marketing", "loop-marketing-enquiry",
+      async (apiKey) => {
+        return loopPut<LoopBooleanResponse>(
+          apiKey, `/marketing/enquiries/auto-responder/${id}/refer/${key}`,
+          {}, "loop-marketing-enquiry", teamName
+        );
+      }
+    );
+    return `Enquiry ${id} referred via team "${teamName}".`;
+  }
+
+  throw new Error(`Unknown action: ${action}`);
+}

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/marketing-match-batch.ts

@@ -0,0 +1,48 @@
+import {
+  aggregateAcrossTeams,
+  formatAggregationResult,
+  loopPut,
+} from "../lib/loop-api.js";
+
+interface LoopMatchingSummary {
+  id?: number;
+  address?: string;
+  price?: number;
+  type?: string;
+  bedrooms?: number;
+  [key: string]: unknown;
+}
+
+type Department = "sales" | "lettings";
+
+export async function marketingMatchBatch(params: {
+  accountId: string;
+  propertyIds: number[];
+  department: Department;
+  teamName?: string;
+}): Promise<string> {
+  const { accountId, propertyIds, department, teamName } = params;
+
+  const result = await aggregateAcrossTeams<LoopMatchingSummary>(
+    accountId,
+    "marketing",
+    "loop-marketing-match-batch",
+    async (apiKey, team) => {
+      const prefix = department === "lettings" ? "/marketing/rentals" : "/marketing";
+      const path = `${prefix}/matching/other-matches`;
+      const data = await loopPut<LoopMatchingSummary[]>(apiKey, path, propertyIds, "loop-marketing-match-batch", team);
+      return Array.isArray(data) ? data : [];
+    },
+    { teamName }
+  );
+
+  return formatAggregationResult(
+    result,
+    (p) => {
+      const price = p.price ? ` — £${p.price.toLocaleString("en-GB")}` : "";
+      const beds = p.bedrooms ? ` ${p.bedrooms}bed` : "";
+      return `- ${p.address ?? "Unknown"}${price}${beds}`;
+    },
+    "matching properties"
+  );
+}

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/marketing-match-request.ts

@@ -0,0 +1,37 @@
+import { loopPost, withTeamKey } from "../lib/loop-api.js";
+
+type Department = "sales" | "lettings";
+type MatchAction = "viewing" | "information" | "callback";
+
+interface LoopBooleanResponse {
+  success?: boolean;
+  [key: string]: unknown;
+}
+
+export async function marketingMatchRequest(params: {
+  accountId: string;
+  teamName: string;
+  propertyId: number;
+  department: Department;
+  action: MatchAction;
+  name?: string;
+  email?: string;
+  phone?: string;
+  message?: string;
+}): Promise<string> {
+  const { accountId, teamName, propertyId, department, action, ...body } = params;
+
+  await withTeamKey<LoopBooleanResponse>(
+    accountId,
+    teamName,
+    "marketing",
+    "loop-marketing-match-request",
+    async (apiKey) => {
+      const prefix = department === "lettings" ? "/marketing/rentals" : "/marketing";
+      const path = `${prefix}/matching/${propertyId}/${action}`;
+      return loopPost<LoopBooleanResponse>(apiKey, path, body, "loop-marketing-match-request", teamName);
+    }
+  );
+
+  return `${action} request submitted for matching property ${propertyId} (${department}) via team "${teamName}".`;
+}

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/marketing-match.ts

@@ -0,0 +1,78 @@
+import {
+  aggregateAcrossTeams,
+  formatAggregationResult,
+  loopGet,
+} from "../lib/loop-api.js";
+
+interface LoopMatchingProperty {
+  id?: number;
+  address?: string;
+  price?: number;
+  type?: string;
+  bedrooms?: number;
+  status?: string;
+  description?: string;
+  [key: string]: unknown;
+}
+
+interface LoopMatchingTeamProfile {
+  name?: string;
+  address?: string;
+  phone?: string;
+  email?: string;
+  logoUrl?: string;
+  [key: string]: unknown;
+}
+
+type Department = "sales" | "lettings";
+
+export async function marketingMatchDetail(params: {
+  accountId: string;
+  propertyId: number;
+  department: Department;
+  includeTeamProfile?: boolean;
+  teamName?: string;
+}): Promise<string> {
+  const { accountId, propertyId, department, includeTeamProfile = false, teamName } = params;
+
+  const result = await aggregateAcrossTeams<LoopMatchingProperty>(
+    accountId,
+    "marketing",
+    "loop-marketing-match",
+    async (apiKey, team) => {
+      const prefix = department === "lettings" ? "/marketing/rentals" : "/marketing";
+      const path = `${prefix}/matching/${propertyId}`;
+      const data = await loopGet<LoopMatchingProperty>(apiKey, path, "loop-marketing-match", team);
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        if (includeTeamProfile) {
+          const profilePath = `${prefix}/matching/${propertyId}/team-profile`;
+          const profile = await loopGet<LoopMatchingTeamProfile>(apiKey, profilePath, "loop-marketing-match", team).catch(() => null);
+          if (profile) {
+            (data as Record<string, unknown>)._teamProfile = profile;
+          }
+        }
+        return [data];
+      }
+      return [];
+    },
+    { teamName }
+  );
+
+  return formatAggregationResult(
+    result,
+    (p) => {
+      const lines = [`**${p.address ?? "Unknown address"}**`];
+      if (p.price) lines.push(`Price: £${p.price.toLocaleString("en-GB")}`);
+      if (p.type) lines.push(`Type: ${p.type}`);
+      if (p.bedrooms) lines.push(`Bedrooms: ${p.bedrooms}`);
+      if (p.status) lines.push(`Status: ${p.status}`);
+      if (p.description) lines.push(`\n${p.description}`);
+      const profile = (p as Record<string, unknown>)._teamProfile as LoopMatchingTeamProfile | undefined;
+      if (profile) {
+        lines.push(`\n**Team:** ${profile.name ?? ""} — ${profile.address ?? ""} | ${profile.phone ?? ""} | ${profile.email ?? ""}`);
+      }
+      return lines.join("\n");
+    },
+    "matching property details"
+  );
+}

package/payload/premium-plugins/real-agency/plugins/real-agency-loop/mcp/src/tools/people-detail.ts

@@ -0,0 +1,63 @@
+import {
+  aggregateAcrossTeams,
+  formatAggregationResult,
+  loopGet,
+} from "../lib/loop-api.js";
+
+interface LoopPersonDetail {
+  id?: number;
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  phone?: string;
+  mobile?: string;
+  type?: string;
+  address?: string;
+  postcode?: string;
+  notes?: string;
+  [key: string]: unknown;
+}
+
+type PeopleRole = "buyers" | "sellers" | "renters" | "landlords";
+
+export async function peopleDetail(params: {
+  accountId: string;
+  personId: number;
+  role?: PeopleRole;
+  teamName?: string;
+}): Promise<string> {
+  const { accountId, personId, role, teamName } = params;
+
+  const result = await aggregateAcrossTeams<LoopPersonDetail>(
+    accountId,
+    "people",
+    "loop-people-detail",
+    async (apiKey, team) => {
+      const basePath = role ? `/people/${role}` : "/people";
+      const path = `${basePath}/${personId}`;
+      const data = await loopGet<LoopPersonDetail>(apiKey, path, "loop-people-detail", team);
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        return [data];
+      }
+      return [];
+    },
+    { teamName }
+  );
+
+  return formatAggregationResult(
+    result,
+    (p) => {
+      const name = [p.firstName, p.lastName].filter(Boolean).join(" ") || "Unknown";
+      const lines = [`**${name}**`];
+      if (p.type) lines.push(`Type: ${p.type}`);
+      if (p.email) lines.push(`Email: ${p.email}`);
+      if (p.phone) lines.push(`Phone: ${p.phone}`);
+      if (p.mobile) lines.push(`Mobile: ${p.mobile}`);
+      if (p.address) lines.push(`Address: ${p.address}`);
+      if (p.postcode) lines.push(`Postcode: ${p.postcode}`);
+      if (p.notes) lines.push(`Notes: ${p.notes}`);
+      return lines.join("\n");
+    },
+    "person details"
+  );
+}