@striderlabs/mcp-gap 0.1.0

package/src/index.ts

@@ -0,0 +1,515 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import {
+  Brand,
+  checkLoginStatus,
+  initiateLogin,
+  logout,
+  searchProducts,
+  getProductDetails,
+  checkStoreInventory,
+  addToCart,
+  viewCart,
+  proceedToCheckout,
+  getRewardsInfo,
+  trackOrder,
+  findStores,
+  initiateReturn,
+  getSizeGuide,
+} from './browser.js';
+
+const server = new Server(
+  {
+    name: 'mcp-gap',
+    version: '0.1.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  },
+);
+
+const BRANDS: Brand[] = ['gap', 'old-navy', 'banana-republic', 'athleta'];
+const BRAND_DESCRIPTION = '"gap" | "old-navy" | "banana-republic" | "athleta"';
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'gap_status',
+      description: 'Check your Gap Inc. account login status and session information.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+    {
+      name: 'gap_login',
+      description: 'Get instructions and a URL to log in to your Gap Inc. account.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          brand: {
+            type: 'string',
+            description: `Brand login page to use: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: [],
+      },
+    },
+    {
+      name: 'gap_logout',
+      description: 'Log out of your Gap Inc. account and clear saved session data.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+    {
+      name: 'gap_search',
+      description:
+        'Search for products across Gap Inc. brands (Gap, Old Navy, Banana Republic, Athleta). Returns product names, prices, and URLs.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: {
+            type: 'string',
+            description: 'Search query (e.g. "slim jeans", "floral dress", "running shorts")',
+          },
+          brand: {
+            type: 'string',
+            description: `Brand to search: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+          max_results: {
+            type: 'number',
+            description: 'Maximum number of results to return (default: 10, max: 30)',
+          },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'gap_product_details',
+      description:
+        'Get detailed product information including available sizes, colors, fit type, materials, and pricing.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          product_url: {
+            type: 'string',
+            description: 'Full product page URL (from gap_search results)',
+          },
+          brand: {
+            type: 'string',
+            description: `Product brand: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: ['product_url'],
+      },
+    },
+    {
+      name: 'gap_store_inventory',
+      description: 'Check if a product is available in stores near a given zip code.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          product_id: {
+            type: 'string',
+            description: 'Product ID (from gap_product_details)',
+          },
+          zip_code: {
+            type: 'string',
+            description: 'Zip code to search near (e.g. "10001")',
+          },
+          brand: {
+            type: 'string',
+            description: `Product brand: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: ['product_id', 'zip_code'],
+      },
+    },
+    {
+      name: 'gap_add_to_cart',
+      description: 'Add a product to your shopping bag with a specific size and color.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          product_url: {
+            type: 'string',
+            description: 'Full product page URL',
+          },
+          size: {
+            type: 'string',
+            description: 'Size to add (e.g. "M", "32x30", "8"). Use gap_product_details to see available sizes.',
+          },
+          color: {
+            type: 'string',
+            description: 'Color to select (e.g. "Navy", "Black"). Use gap_product_details to see available colors.',
+          },
+          quantity: {
+            type: 'number',
+            description: 'Quantity to add (default: 1)',
+          },
+        },
+        required: ['product_url', 'size', 'color'],
+      },
+    },
+    {
+      name: 'gap_view_cart',
+      description: 'View the contents of your shopping bag including items, quantities, and totals.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          brand: {
+            type: 'string',
+            description: `Brand cart to view: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: [],
+      },
+    },
+    {
+      name: 'gap_checkout',
+      description:
+        'Get checkout URL and instructions to complete your purchase. Reviews payment, shipping, and Gap Cash options.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          brand: {
+            type: 'string',
+            description: `Brand checkout: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: [],
+      },
+    },
+    {
+      name: 'gap_rewards',
+      description:
+        'Check your Gap Cash balance, rewards points, member tier, and upcoming rewards.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          brand: {
+            type: 'string',
+            description: `Brand rewards page: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: [],
+      },
+    },
+    {
+      name: 'gap_track_order',
+      description: 'Track an order by order ID to see status, estimated delivery, and tracking information.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          order_id: {
+            type: 'string',
+            description: 'Order ID from your confirmation email or account order history',
+          },
+          brand: {
+            type: 'string',
+            description: `Brand the order was placed with: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: ['order_id'],
+      },
+    },
+    {
+      name: 'gap_find_stores',
+      description: 'Find Gap Inc. store locations near a given zip code, with hours, phone, and distance.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          zip_code: {
+            type: 'string',
+            description: 'Zip code to search near (e.g. "10001")',
+          },
+          brand: {
+            type: 'string',
+            description: `Filter by brand: ${BRAND_DESCRIPTION}. Leave blank to show all brands.`,
+          },
+          radius: {
+            type: 'number',
+            description: 'Search radius in miles (default: 25)',
+          },
+        },
+        required: ['zip_code'],
+      },
+    },
+    {
+      name: 'gap_initiate_return',
+      description: 'Start a return for an item from a previous order. Provides return instructions and label information.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          order_id: {
+            type: 'string',
+            description: 'Order ID containing the item to return',
+          },
+          item_name: {
+            type: 'string',
+            description: 'Name or description of the item to return',
+          },
+          reason: {
+            type: 'string',
+            description:
+              'Return reason (e.g. "Wrong size", "Changed my mind", "Defective", "Not as described")',
+          },
+          brand: {
+            type: 'string',
+            description: `Brand the order was placed with: ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: ['order_id', 'item_name', 'reason'],
+      },
+    },
+    {
+      name: 'gap_size_guide',
+      description:
+        'Get size guide information for Gap Inc. clothing categories including measurements in US sizes.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          category: {
+            type: 'string',
+            description: 'Clothing category: "tops", "bottoms", "shoes", or "kids"',
+          },
+          brand: {
+            type: 'string',
+            description: `Brand (may affect sizing recommendations): ${BRAND_DESCRIPTION}. Defaults to "gap".`,
+          },
+        },
+        required: ['category'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'gap_status': {
+        const status = await checkLoginStatus();
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(status, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'gap_login': {
+        const brand = (args?.brand as Brand) || 'gap';
+        if (!BRANDS.includes(brand)) {
+          throw new Error(`Invalid brand. Must be one of: ${BRANDS.join(', ')}`);
+        }
+        const result = await initiateLogin(brand);
+        return {
+          content: [{ type: 'text', text: `${result.instructions}\n\nLogin URL: ${result.url}` }],
+        };
+      }
+
+      case 'gap_logout': {
+        await logout();
+        return {
+          content: [{ type: 'text', text: 'Successfully logged out and cleared session data.' }],
+        };
+      }
+
+      case 'gap_search': {
+        if (!args?.query) throw new Error('query is required');
+        const brand = (args.brand as Brand) || 'gap';
+        if (!BRANDS.includes(brand)) throw new Error(`Invalid brand. Must be one of: ${BRANDS.join(', ')}`);
+        const maxResults = Math.min(Number(args.max_results) || 10, 30);
+        const products = await searchProducts(String(args.query), brand, maxResults);
+        if (products.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `No products found for "${args.query}" on ${brand}. Try a different search term or brand.`,
+              },
+            ],
+          };
+        }
+        return {
+          content: [{ type: 'text', text: JSON.stringify(products, null, 2) }],
+        };
+      }
+
+      case 'gap_product_details': {
+        if (!args?.product_url) throw new Error('product_url is required');
+        const brand = (args.brand as Brand) || 'gap';
+        const details = await getProductDetails(String(args.product_url), brand);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(details, null, 2) }],
+        };
+      }
+
+      case 'gap_store_inventory': {
+        if (!args?.product_id) throw new Error('product_id is required');
+        if (!args?.zip_code) throw new Error('zip_code is required');
+        const brand = (args.brand as Brand) || 'gap';
+        const inventory = await checkStoreInventory(
+          String(args.product_id),
+          String(args.zip_code),
+          brand,
+        );
+        if (inventory.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `No store inventory results found for product ${args.product_id} near ${args.zip_code}. The item may only be available online.`,
+              },
+            ],
+          };
+        }
+        return {
+          content: [{ type: 'text', text: JSON.stringify(inventory, null, 2) }],
+        };
+      }
+
+      case 'gap_add_to_cart': {
+        if (!args?.product_url) throw new Error('product_url is required');
+        if (!args?.size) throw new Error('size is required');
+        if (!args?.color) throw new Error('color is required');
+        const quantity = Number(args.quantity) || 1;
+        const result = await addToCart(
+          String(args.product_url),
+          String(args.size),
+          String(args.color),
+          quantity,
+        );
+        return {
+          content: [
+            {
+              type: 'text',
+              text: result.success
+                ? `✓ ${result.message}${result.cartItemCount !== undefined ? ` (Bag now has ${result.cartItemCount} items)` : ''}`
+                : `⚠ ${result.message}`,
+            },
+          ],
+        };
+      }
+
+      case 'gap_view_cart': {
+        const brand = (args?.brand as Brand) || 'gap';
+        const cart = await viewCart(brand);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(cart, null, 2) }],
+        };
+      }
+
+      case 'gap_checkout': {
+        const brand = (args?.brand as Brand) || 'gap';
+        const checkout = await proceedToCheckout(brand);
+        return {
+          content: [{ type: 'text', text: `${checkout.instructions}\n\nCheckout URL: ${checkout.url}` }],
+        };
+      }
+
+      case 'gap_rewards': {
+        const brand = (args?.brand as Brand) || 'gap';
+        const rewards = await getRewardsInfo(brand);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(rewards, null, 2) }],
+        };
+      }
+
+      case 'gap_track_order': {
+        if (!args?.order_id) throw new Error('order_id is required');
+        const brand = (args.brand as Brand) || 'gap';
+        const order = await trackOrder(String(args.order_id), brand);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(order, null, 2) }],
+        };
+      }
+
+      case 'gap_find_stores': {
+        if (!args?.zip_code) throw new Error('zip_code is required');
+        const brand = args.brand ? (args.brand as Brand) : undefined;
+        if (brand && !BRANDS.includes(brand)) {
+          throw new Error(`Invalid brand. Must be one of: ${BRANDS.join(', ')}`);
+        }
+        const radius = Number(args.radius) || 25;
+        const stores = await findStores(String(args.zip_code), brand, radius);
+        if (stores.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `No stores found near ${args.zip_code}${brand ? ` for ${brand}` : ''}. Try a different zip code or expand your radius.`,
+              },
+            ],
+          };
+        }
+        return {
+          content: [{ type: 'text', text: JSON.stringify(stores, null, 2) }],
+        };
+      }
+
+      case 'gap_initiate_return': {
+        if (!args?.order_id) throw new Error('order_id is required');
+        if (!args?.item_name) throw new Error('item_name is required');
+        if (!args?.reason) throw new Error('reason is required');
+        const brand = (args.brand as Brand) || 'gap';
+        const returnResult = await initiateReturn(
+          String(args.order_id),
+          String(args.item_name),
+          String(args.reason),
+          brand,
+        );
+        return {
+          content: [{ type: 'text', text: JSON.stringify(returnResult, null, 2) }],
+        };
+      }
+
+      case 'gap_size_guide': {
+        if (!args?.category) throw new Error('category is required');
+        const brand = (args.brand as Brand) || 'gap';
+        const guide = getSizeGuide(String(args.category), brand);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(guide, null, 2) }],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${msg}\n\nIf this is a login issue, use gap_login to authenticate first.`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}