@agentrhq/webcmd 0.2.1 → 0.2.2

package/clis/district/search.js

@@ -0,0 +1,218 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+
+const BASE = 'https://www.district.in';
+const GUEST_TOKEN = '1212';
+const DEFAULT_LOCATION = {
+  cityId: 1,
+  pCityId: '57',
+  long: 77.1165992,
+  lat: 28.4080424,
+  pCityKey: 'gurgaon',
+  pStateKey: 'haryana',
+  countryId: '1',
+  placeType: 'GOOGLE_PLACE',
+  placeId: 'ChIJQ3GqXwAZDTkR2IGBwuLDcCk',
+  subzoneId: '645',
+  cityName: 'Delhi NCR',
+  pCityName: 'Gurugram',
+};
+const TAB_MAP = new Map([
+  ['all', 'all'],
+  ['dining', 'dining'],
+  ['events', 'events'],
+  ['movies', 'movies'],
+  ['stores', 'shopping'],
+  ['shopping', 'shopping'],
+  ['activities', 'attraction'],
+  ['attraction', 'attraction'],
+  ['play', 'play'],
+]);
+
+function validateQuery(raw) {
+  const query = String(raw || '').trim();
+  if (!query) throw new ArgumentError('query is required');
+  if (query.length > 120) throw new ArgumentError('query must be 120 characters or fewer');
+  return query;
+}
+
+function validateLimit(raw) {
+  const limit = Number(raw ?? 20);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new ArgumentError('limit must be an integer from 1 to 100');
+  }
+  return limit;
+}
+
+function validateTab(raw) {
+  const value = String(raw || 'all').trim().toLowerCase();
+  const tab = TAB_MAP.get(value);
+  if (!tab) {
+    throw new ArgumentError('tab must be one of all, dining, events, movies, stores, activities, or play');
+  }
+  return tab;
+}
+
+function slugify(value) {
+  return String(value || '')
+    .trim()
+    .replace(/[\W_]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase();
+}
+
+function absoluteUrl(path) {
+  if (!path) return '';
+  try {
+    return new URL(path, BASE).toString();
+  } catch {
+    return '';
+  }
+}
+
+function categoryFor(item) {
+  const display = String(item.domain_title || item.display_subtitle || '').trim();
+  if (display) return display.toLowerCase();
+  return String(item.entity_type || '')
+    .replace(/^EntityType/i, '')
+    .replace(/^Res$/i, 'restaurant')
+    .toLowerCase() || 'result';
+}
+
+function urlFor(item) {
+  const meta = item.metadata || {};
+  const type = String(item.entity_type || '');
+  if (meta.web_deeplink) return absoluteUrl(meta.web_deeplink);
+  if (type === 'EntityTypeMovie') return absoluteUrl(`/movies/${slugify(item.display_title)}-movie-tickets-MV${item.id}`);
+  if (type === 'EntityTypeEvent') return absoluteUrl(`/events/${meta.slug || slugify(item.display_title)}-buy-tickets`);
+  if (type === 'EntityTypeArtist') return absoluteUrl(`/events/${meta.slug || slugify(item.display_title)}/artist`);
+  if (type === 'EntityTypeRes') return absoluteUrl(`/dining${meta.seo_url || ''}`);
+  if (type === 'EntityTypeStore') return absoluteUrl(`/stores/${meta.slug || ''}`);
+  return '';
+}
+
+function locationHeaders() {
+  const loc = DEFAULT_LOCATION;
+  return {
+    'x-city-id': String(loc.cityId),
+    'x-pcity-id': String(loc.pCityId),
+    'x-user-lng': String(loc.long),
+    'x-user-lat': String(loc.lat),
+    'x-pcity-key': loc.pCityKey,
+    'x-pstate-key': loc.pStateKey,
+    'x-country-id': loc.countryId,
+    'x-place-type': loc.placeType,
+    'x-place-id': loc.placeId,
+    'x-gps-lat': String(loc.lat),
+    'x-gps-lng': String(loc.long),
+    'x-subzone-id': loc.subzoneId,
+    'x-available-tabs': 'movies,events,dining,attr_home,attraction,play,shopping,ipl',
+    'x-city-name': loc.cityName,
+    'x-pcity-name': loc.pCityName,
+  };
+}
+
+function headersFor(tab) {
+  return {
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-IN,en;q=0.9',
+    'Content-Type': 'application/json',
+    Origin: BASE,
+    Referer: `${BASE}/search`,
+    'User-Agent': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko) Chrome Safari/537.36',
+    'x-guest-token': GUEST_TOKEN,
+    'x-app-type': 'ed_web',
+    'x-client-id': 'district-web',
+    'x-app-version': '11.11.1',
+    'x-device-id': crypto.randomUUID(),
+    'x-is-granular-loc': 'false',
+    'x-is-events-supported': 'true',
+    'x-is-movies-supported': 'true',
+    'x-is-dining-supported': 'true',
+    'x-gps-permission-given': '0',
+    'x-available-tabs': tab === 'all' ? 'movies,events,dining' : tab,
+    ...locationHeaders(),
+  };
+}
+
+function rowFor(item, index) {
+  const meta = item.metadata || {};
+  const url = urlFor(item);
+  return {
+    rank: index + 1,
+    title: String(item.display_title || '').trim(),
+    category: categoryFor(item),
+    date: String(meta.date_string_v2 || '').trim(),
+    venue: String(meta.venue_name || meta.address || meta.poi_display_title || '').trim(),
+    price: String(meta.price_string_v2 || meta.offer || meta.instore_offer_text || '').trim(),
+    url,
+  };
+}
+
+cli({
+  site: 'district',
+  name: 'search',
+  aliases: ['s'],
+  access: 'read',
+  description: 'Search District by Zomato across movies, events, dining, stores, activities, and play',
+  domain: 'www.district.in',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    {
+      name: 'query',
+      positional: true,
+      required: true,
+      help: 'Search query, for example "hamlet" or "arijit"',
+    },
+    {
+      name: 'limit',
+      type: 'int',
+      default: 20,
+      help: 'Maximum rows to return (1-100)',
+    },
+    {
+      name: 'tab',
+      default: 'all',
+      help: 'Search tab: all, dining, events, movies, stores, activities, or play',
+    },
+  ],
+  columns: ['rank', 'title', 'category', 'date', 'venue', 'price', 'url'],
+  func: async (args) => {
+    const query = validateQuery(args.query);
+    const limit = validateLimit(args.limit);
+    const tab = validateTab(args.tab);
+    const body = {
+      get_search_results_request_type: 1,
+      post_body: { hp_selected_tab_id: tab === 'attraction' ? 'attractions_home' : 'home_v2' },
+      search_id: crypto.randomUUID(),
+      keyword: query,
+      tab_id: tab,
+    };
+
+    const resp = await fetch(`${BASE}/gw/web/search`, {
+      method: 'POST',
+      headers: headersFor(tab),
+      body: JSON.stringify(body),
+    });
+
+    if (!resp.ok) {
+      throw new CommandExecutionError(`district search request failed: HTTP ${resp.status}`);
+    }
+
+    const data = await resp.json();
+    if (data?.status?.status === 'STATUS_FAILURE') {
+      throw new CommandExecutionError(data.status.message || 'district search request failed');
+    }
+
+    const items = Array.isArray(data?.results) ? data.results : [];
+    if (!items.length) {
+      throw new EmptyResultError('district search', `No results found for "${query}"`);
+    }
+
+    return items
+      .map(rowFor)
+      .filter((row) => row.title && row.url)
+      .slice(0, limit);
+  },
+});

package/clis/district/seats.js

@@ -0,0 +1,233 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { ArgumentError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import {
+  makeSeatUrl,
+  openSeatMap,
+  resolveSeatTarget,
+  validateTimeout,
+} from './_lib.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 30;
+const DEFAULT_LIMIT = 100;
+
+function validateLimit(raw) {
+  const limit = Number(raw ?? DEFAULT_LIMIT);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 300) {
+    throw new ArgumentError('limit must be an integer from 1 to 300');
+  }
+  return limit;
+}
+
+function validateCount(raw) {
+  if (raw == null || raw === '') return 0;
+  const count = Number(raw);
+  if (!Number.isInteger(count) || count < 1 || count > 10) {
+    throw new ArgumentError('count must be an integer from 1 to 10');
+  }
+  return count;
+}
+
+function validateMoney(raw, name) {
+  if (raw == null || raw === '') return 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0) throw new ArgumentError(`${name} must be a positive number`);
+  return value;
+}
+
+function normalizeClass(raw) {
+  return String(raw || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function validateBoolean(raw, name) {
+  if (raw == null || raw === '' || raw === false) return false;
+  if (raw === true) return true;
+  const value = String(raw).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(value)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(value)) return false;
+  throw new ArgumentError(`${name} must be a boolean flag`);
+}
+
+async function extractSeats(page, target, url) {
+  return page.evaluate(`
+    (() => {
+      const showId = ${JSON.stringify(target.showId)};
+      const formatId = ${JSON.stringify(target.formatId)};
+      const url = ${JSON.stringify(url)};
+      const parseAria = (aria) => {
+        const seatClass = (aria.match(/class\\s+(.+?),\\s+row/i) || [])[1] || '';
+        const row = (aria.match(/row\\s+([^,]+),\\s+column/i) || [])[1] || '';
+        const column = Number((aria.match(/column\\s+(\\d+)/i) || [])[1] || 0);
+        const price = Number((aria.match(/price\\s+(\\d+)/i) || [])[1] || 0);
+        const flags = [];
+        if (/disabled friendly/i.test(aria)) flags.push('disabled_friendly');
+        if (/wheel\\s*companion|wheelCompanion/i.test(aria)) flags.push('wheel_companion');
+        return { seatClass: seatClass.trim(), row: row.trim(), column, price, flags };
+      };
+
+      return [...document.querySelectorAll('#available-seat')].map((el, index) => {
+        const aria = el.getAttribute('aria-label') || '';
+        const label = (el.querySelector('label')?.innerText || el.innerText || '').replace(/\\s+/g, ' ').trim();
+        const parsed = parseAria(aria);
+        return {
+          rank: index + 1,
+          seat: parsed.row && label ? parsed.row + label : label,
+          row: parsed.row,
+          number: label,
+          column: parsed.column,
+          seatClass: parsed.seatClass,
+          price: parsed.price,
+          status: 'available',
+          flags: parsed.flags.join(','),
+          showId,
+          formatId,
+          url,
+        };
+      }).filter((seat) => seat.seat && seat.row && seat.number && seat.seatClass);
+    })()
+  `);
+}
+
+function applyFilters(rows, { seatClass, maxPrice }) {
+  return rows.filter((row) => {
+    if (seatClass && !normalizeClass(row.seatClass).includes(seatClass)) return false;
+    if (maxPrice && Number(row.price) > maxPrice) return false;
+    return true;
+  });
+}
+
+function groupKey(row) {
+  return [row.row, row.seatClass, row.price].join('|');
+}
+
+function consecutiveWindow(rows, count) {
+  const sorted = [...rows].sort((a, b) => a.column - b.column);
+  for (let start = 0; start <= sorted.length - count; start += 1) {
+    const window = sorted.slice(start, start + count);
+    const consecutive = window.every((row, index) => index === 0 || row.column === window[index - 1].column + 1);
+    if (consecutive) return window;
+  }
+  return [];
+}
+
+function chooseSeats(rows, { count, together }) {
+  if (!count) return rows;
+  if (!together) return rows.slice(0, count);
+
+  const grouped = new Map();
+  for (const row of rows) {
+    const key = groupKey(row);
+    grouped.set(key, [...(grouped.get(key) || []), row]);
+  }
+
+  for (const group of grouped.values()) {
+    const picked = consecutiveWindow(group, count);
+    if (picked.length) return picked;
+  }
+  return [];
+}
+
+cli({
+  site: 'district',
+  name: 'seats',
+  access: 'read',
+  description: 'List available seats for a District movie showtime',
+  domain: 'www.district.in',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  args: [
+    {
+      name: 'show',
+      positional: true,
+      required: true,
+      help: 'District seat-layout URL or showId from district showtimes',
+    },
+    {
+      name: 'format-id',
+      help: 'District formatId from showtimes; required when show is a showId',
+    },
+    {
+      name: 'content-id',
+      help: 'District content id; required when show is a showId',
+    },
+    {
+      name: 'class',
+      help: 'Optional seat class filter, e.g. premium, premium xl, or recliner',
+    },
+    {
+      name: 'count',
+      type: 'int',
+      help: 'Number of seats to choose (1-10); without count, seats are listed normally',
+    },
+    {
+      name: 'together',
+      help: 'Require selected seats to be adjacent when count is provided',
+    },
+    {
+      name: 'max-price',
+      type: 'float',
+      help: 'Maximum price per seat',
+    },
+    {
+      name: 'limit',
+      type: 'int',
+      default: DEFAULT_LIMIT,
+      help: 'Maximum seats to return (1-300)',
+    },
+    {
+      name: 'timeout',
+      type: 'int',
+      default: DEFAULT_TIMEOUT_SECONDS,
+      help: 'Maximum seconds to wait for the seat map to render',
+    },
+  ],
+  columns: [
+    'rank',
+    'seat',
+    'row',
+    'number',
+    'column',
+    'seatClass',
+    'price',
+    'status',
+    'flags',
+    'showId',
+    'formatId',
+    'url',
+  ],
+  func: async (page, args) => {
+    const target = resolveSeatTarget(args);
+    const limit = validateLimit(args.limit);
+    const count = validateCount(args.count);
+    const timeout = validateTimeout(args.timeout, { def: DEFAULT_TIMEOUT_SECONDS, min: 5, max: 180 });
+    const seatClass = normalizeClass(args.class);
+    const together = validateBoolean(args.together, 'together');
+    const maxPrice = validateMoney(args['max-price'], 'max-price');
+    const url = makeSeatUrl(target);
+
+    await openSeatMap(page, target, timeout);
+
+    let rows = await extractSeats(page, target, url);
+    rows = applyFilters(rows, { seatClass, maxPrice });
+    rows = chooseSeats(rows, { count, together }).slice(0, limit).map((row, index) => ({ ...row, rank: index + 1 }));
+
+    if (!rows.length) {
+      const constraints = [
+        seatClass ? `class matching "${seatClass}"` : '',
+        maxPrice ? `price <= ${maxPrice}` : '',
+        count ? `${count} seat${count === 1 ? '' : 's'}` : '',
+        together ? 'together' : '',
+      ].filter(Boolean).join(', ');
+      const detail = constraints ? `No available seats found for ${constraints}` : 'No available seats found';
+      throw new EmptyResultError('district seats', detail);
+    }
+    return rows;
+  },
+});

package/clis/district/set-location.js

@@ -0,0 +1,82 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { ArgumentError, CommandExecutionError } from '@agentrhq/webcmd/errors';
+import {
+  applyLocationViaPicker,
+  validateTimeout,
+} from './_lib.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 45;
+
+function validateLocation(raw) {
+  const location = String(raw || '').trim();
+  if (!location) throw new ArgumentError('location is required');
+  if (location.length > 120) throw new ArgumentError('location must be 120 characters or fewer');
+  return location;
+}
+
+function validateRank(raw) {
+  const rank = Number(raw ?? 1);
+  if (!Number.isInteger(rank) || rank < 1 || rank > 20) {
+    throw new ArgumentError('rank must be an integer from 1 to 20');
+  }
+  return rank;
+}
+
+cli({
+  site: 'district',
+  name: 'set-location',
+  aliases: ['setlocation'],
+  access: 'write',
+  description: 'Set the District browser session location for movie booking filters',
+  domain: 'www.district.in',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  args: [
+    {
+      name: 'location',
+      positional: true,
+      required: true,
+      help: 'City, area, mall, or locality, for example "Bangalore" or "Indiranagar"',
+    },
+    {
+      name: 'rank',
+      type: 'int',
+      default: 1,
+      help: 'Pick the Nth District location result (1-20), default: 1',
+    },
+    {
+      name: 'timeout',
+      type: 'int',
+      default: DEFAULT_TIMEOUT_SECONDS,
+      help: 'Maximum seconds to wait for the picker and location change',
+    },
+  ],
+  columns: [
+    'status',
+    'name',
+    'city',
+    'state',
+    'cityKey',
+    'cityId',
+    'placeId',
+    'subzoneId',
+    'lat',
+    'lng',
+    'availableTabs',
+    'source',
+  ],
+  func: async (page, args) => {
+    const location = validateLocation(args.location);
+    const rank = validateRank(args.rank);
+    const timeout = validateTimeout(args.timeout, { def: DEFAULT_TIMEOUT_SECONDS, min: 10, max: 180 });
+
+    const row = await applyLocationViaPicker(page, location, timeout, rank);
+    if (!row.cityKey || !row.cityId) {
+      throw new CommandExecutionError('District location was selected, but normalized city metadata could not be read');
+    }
+    return row;
+  },
+});