@agentrhq/webcmd 0.2.1 → 0.2.3

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;
+  },
+});

package/clis/district/showtimes.js

@@ -0,0 +1,433 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import {
+  BASE,
+  DEFAULT_LOCATION,
+  browserLocation,
+  districtHeaders,
+  fetchMovieSessions,
+} from './_lib.js';
+
+function validateText(raw, name, max = 160) {
+  const value = String(raw || '').trim();
+  if (!value) throw new ArgumentError(`${name} is required`);
+  if (value.length > max) throw new ArgumentError(`${name} must be ${max} characters or fewer`);
+  return value;
+}
+
+function validateOptionalText(raw, name, max = 120) {
+  if (raw == null || raw === '') return '';
+  return validateText(raw, name, max);
+}
+
+function validateLimit(raw) {
+  const limit = Number(raw ?? 50);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 200) {
+    throw new ArgumentError('limit must be an integer from 1 to 200');
+  }
+  return limit;
+}
+
+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 validateCityKey(raw) {
+  if (raw == null || raw === '') return '';
+  const cityKey = String(raw).trim().toLowerCase();
+  if (!/^[a-z0-9-]+$/.test(cityKey)) {
+    throw new ArgumentError('city-key must contain only lowercase letters, numbers, and hyphens');
+  }
+  return cityKey;
+}
+
+function validateDate(raw) {
+  if (raw == null || raw === '') return '';
+  const date = String(raw).trim();
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new ArgumentError('date must be in YYYY-MM-DD format');
+  return date;
+}
+
+function validateClock(raw, name) {
+  if (raw == null || raw === '') return null;
+  const value = String(raw).trim();
+  const match = value.match(/^([01]?\d|2[0-3]):([0-5]\d)$/);
+  if (!match) throw new ArgumentError(`${name} must be in HH:MM 24-hour format`);
+  return Number(match[1]) * 60 + Number(match[2]);
+}
+
+function normalize(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function stateKey(value) {
+  return normalize(value).replace(/\s+/g, '-');
+}
+
+function slugify(value) {
+  return String(value || '')
+    .trim()
+    .replace(/[\W_]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase();
+}
+
+function extractContentId(value) {
+  const match = String(value || '').match(/(?:MV)?(\d{4,})/i);
+  return match ? match[1] : '';
+}
+
+function isDistrictMovieUrl(value) {
+  try {
+    const url = new URL(value, BASE);
+    return url.hostname.endsWith('district.in') && /\/movies\/.+MV\d+/i.test(url.pathname);
+  } catch {
+    return false;
+  }
+}
+
+function makeBookingUrl(movieUrl, cityKey) {
+  const url = new URL(movieUrl, BASE);
+  const match = url.pathname.match(/^\/movies\/(.+?)-movie-tickets(?:-in-[a-z0-9-]+)?-MV(\d+)/i);
+  if (!match) throw new ArgumentError('movie must be a District movie URL or a movie search query');
+  url.pathname = `/movies/${match[1]}-movie-tickets-in-${cityKey}-MV${match[2]}`;
+  return url;
+}
+
+async function searchMovie(query, loc) {
+  const body = {
+    get_search_results_request_type: 1,
+    post_body: { hp_selected_tab_id: 'home_v2' },
+    search_id: crypto.randomUUID(),
+    keyword: query,
+    tab_id: 'movies',
+  };
+
+  const resp = await fetch(`${BASE}/gw/web/search`, {
+    method: 'POST',
+    headers: {
+      ...districtHeaders({ loc, referer: `${BASE}/search` }),
+      'Content-Type': 'application/json',
+      Origin: BASE,
+      'x-available-tabs': 'movies',
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!resp.ok) throw new CommandExecutionError(`district movie search failed: HTTP ${resp.status}`);
+  const data = await resp.json();
+  const movie = (Array.isArray(data?.results) ? data.results : []).find((item) => {
+    return String(item.entity_type || '') === 'EntityTypeMovie' && item.id;
+  });
+  if (!movie) throw new EmptyResultError('district showtimes', `No movie result found for "${query}"`);
+  return `${BASE}/movies/${slugify(movie.display_title)}-movie-tickets-MV${movie.id}`;
+}
+
+async function fetchLocationSearch(body) {
+  const resp = await fetch(`${BASE}/gw/web/get_location_search`, {
+    method: 'POST',
+    headers: {
+      ...districtHeaders({ loc: DEFAULT_LOCATION, referer: BASE }),
+      'Content-Type': 'application/json',
+      Origin: BASE,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!resp.ok) throw new CommandExecutionError(`district location search failed: HTTP ${resp.status}`);
+  return resp.json();
+}
+
+function distanceKm(aLat, aLng, bLat, bLng) {
+  const toRad = (deg) => (deg * Math.PI) / 180;
+  const r = 6371;
+  const dLat = toRad(bLat - aLat);
+  const dLng = toRad(bLng - aLng);
+  const lat1 = toRad(aLat);
+  const lat2 = toRad(bLat);
+  const a = Math.sin(dLat / 2) ** 2
+    + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+  return 2 * r * Math.asin(Math.sqrt(a));
+}
+
+function nearestCity(entity, cities) {
+  const lat = Number(entity.lat);
+  const lng = Number(entity.long);
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
+  let nearest = null;
+  for (const city of cities) {
+    const cityLat = Number(city.city_lat);
+    const cityLng = Number(city.city_long);
+    if (!Number.isFinite(cityLat) || !Number.isFinite(cityLng)) continue;
+    const km = distanceKm(lat, lng, cityLat, cityLng);
+    if (!nearest || km < nearest.km) nearest = { city, km };
+  }
+  return nearest && nearest.km <= 80 ? nearest.city : null;
+}
+
+function cityToLocation(city, source = 'city') {
+  return {
+    cityId: city.city_id,
+    pCityId: city.city_id,
+    long: Number(city.city_long),
+    lat: Number(city.city_lat),
+    pCityKey: String(city.city_key || '').toLowerCase(),
+    pStateKey: stateKey(city.state_name),
+    countryId: '1',
+    placeType: 'GOOGLE_PLACE',
+    placeId: '',
+    subzoneId: '',
+    cityName: String(city.city_name || ''),
+    pCityName: String(city.city_name || ''),
+    source,
+  };
+}
+
+function entityToLocation(entity, city, source = 'near') {
+  const base = city ? cityToLocation(city, source) : { ...DEFAULT_LOCATION, source };
+  return {
+    ...base,
+    long: Number(entity.long || base.long),
+    lat: Number(entity.lat || base.lat),
+    placeType: entity.google_place_id ? 'GOOGLE_PLACE' : 'POI',
+    placeId: String(entity.google_place_id || entity.poi_id || ''),
+    cityName: String(city?.city_name || base.cityName || ''),
+    pCityName: String(city?.city_name || base.pCityName || ''),
+    source,
+  };
+}
+
+async function resolveLocationQuery(query, preferCity) {
+  const [searchData, allData] = await Promise.all([
+    fetchLocationSearch({ searched_text: query }),
+    fetchLocationSearch({}),
+  ]);
+  const cities = Array.isArray(allData?.cities) ? allData.cities : [];
+  const q = normalize(query);
+  if (preferCity) {
+    const exactCity = cities.find((city) => {
+      return [city.city_name, city.cleaned_city_name, city.city_key].map(normalize).includes(q);
+    });
+    if (exactCity) return cityToLocation(exactCity, 'city');
+  }
+
+  const entities = Array.isArray(searchData?.entities) ? searchData.entities : [];
+  const entity = preferCity
+    ? entities.find((item) => String(item.entity_type || '').includes('CITY')) || entities[0]
+    : entities.find((item) => normalize(item.title) === q) || entities[0];
+  if (!entity) throw new EmptyResultError('district showtimes', `No location found for "${query}"`);
+  const city = String(entity.entity_type || '').includes('CITY')
+    ? cities.find((item) => normalize(item.city_name) === normalize(entity.title) || normalize(item.city_key) === q)
+    : nearestCity(entity, cities);
+  return String(entity.entity_type || '').includes('CITY')
+    ? cityToLocation(city || { city_id: '', city_key: '', city_lat: entity.lat, city_long: entity.long, city_name: entity.title, state_name: '' }, 'city')
+    : entityToLocation(entity, city, 'near');
+}
+
+async function resolveCityKey(cityKey) {
+  const allData = await fetchLocationSearch({});
+  const city = (Array.isArray(allData?.cities) ? allData.cities : []).find((item) => {
+    return normalize(item.city_key) === normalize(cityKey);
+  });
+  return city ? cityToLocation(city, 'city-key') : { ...DEFAULT_LOCATION, pCityKey: cityKey, source: 'city-key' };
+}
+
+function extractNextData(html) {
+  const match = html.match(/<script id="__NEXT_DATA__" type="application\/json">([\s\S]*?)<\/script>/);
+  if (!match) throw new CommandExecutionError('District booking page did not include session data');
+  try {
+    return JSON.parse(match[1]);
+  } catch (err) {
+    throw new CommandExecutionError(`District session data could not be parsed: ${err.message}`);
+  }
+}
+
+function pricesFor(areas) {
+  return (Array.isArray(areas) ? areas : [])
+    .map((area) => Number(area.price))
+    .filter((price) => Number.isFinite(price));
+}
+
+function moneyRange(areas) {
+  const prices = pricesFor(areas);
+  if (!prices.length) return '';
+  const min = Math.min(...prices);
+  const max = Math.max(...prices);
+  return min === max ? `INR ${min}` : `INR ${min}-${max}`;
+}
+
+function formatDateTime(value, options) {
+  if (!value) return '';
+  const date = new Date(`${value}Z`);
+  if (Number.isNaN(date.getTime())) return '';
+  return new Intl.DateTimeFormat('en-IN', { timeZone: 'Asia/Kolkata', ...options }).format(date);
+}
+
+function sessionMinute(value) {
+  const time = formatDateTime(value, { hour: '2-digit', minute: '2-digit', hour12: false });
+  const match = time.match(/^(\d{2}):(\d{2})$/);
+  return match ? Number(match[1]) * 60 + Number(match[2]) : null;
+}
+
+function languageFor(movie) {
+  const languages = Array.isArray(movie.languages) ? movie.languages : [];
+  return String(movie.primary_language || languages[0] || '').trim();
+}
+
+function matchesText(value, filter) {
+  return !filter || normalize(value).includes(normalize(filter));
+}
+
+function rowsFromPayload(payload, loc, formatId, contentId, filters, limit) {
+  const movie = payload?.meta?.movie || {};
+  const selectedDate = payload?.meta?.selectedShowDate || '';
+  const language = languageFor(movie);
+  const cinemas = [
+    ...(Array.isArray(payload?.pageData?.nearbyCinemas) ? payload.pageData.nearbyCinemas : []),
+    ...(Array.isArray(payload?.pageData?.farCinemas) ? payload.pageData.farCinemas : []),
+  ];
+
+  const rows = [];
+  for (const cinema of cinemas) {
+    const info = cinema.cinemaInfo || {};
+    const cinemaName = String(info.name || info.label || '');
+    if (!matchesText(cinemaName, filters.cinema)) continue;
+
+    for (const session of Array.isArray(cinema.sessions) ? cinema.sessions : []) {
+      const minute = sessionMinute(session.showTime);
+      const format = String(session.scrnFmt || '');
+      const prices = pricesFor(session.areas);
+      if (filters.after != null && minute != null && minute < filters.after) continue;
+      if (filters.before != null && minute != null && minute > filters.before) continue;
+      if (filters.maxPrice && prices.length && Math.min(...prices) > filters.maxPrice) continue;
+      if (!matchesText(language, filters.language)) continue;
+      if (!matchesText(format, filters.quality)) continue;
+
+      const encSessionId = String(session.encSessionId || `${session.cid}-${session.sid}-${String(session.mid || '').toLowerCase()}-${session.cid}`);
+      rows.push({
+        rank: rows.length + 1,
+        movie: String(movie.name || ''),
+        language,
+        date: selectedDate || formatDateTime(session.showTime, { year: 'numeric', month: '2-digit', day: '2-digit' }),
+        time: formatDateTime(session.showTime, { hour: '2-digit', minute: '2-digit', hour12: true }),
+        cinema: cinemaName,
+        format,
+        priceRange: moneyRange(session.areas),
+        available: Number(session.avail || 0),
+        showId: encSessionId,
+        formatId: String(formatId || session.mcd || ''),
+        url: `${BASE}/movies/seat-layout/${formatId || session.mcd}?encsessionid=${encodeURIComponent(encSessionId)}&freeseating=false&fromsessions=true&type=MOVIES&contentid=${contentId}&fromdate=${selectedDate}&citykey=${encodeURIComponent(loc.pCityKey || '')}`,
+      });
+      if (rows.length >= limit) return rows;
+    }
+  }
+  return rows;
+}
+
+async function resolveLocation(page, args) {
+  const city = validateOptionalText(args.city, 'city');
+  const near = validateOptionalText(args.near, 'near');
+  const cityKey = validateCityKey(args['city-key']);
+  if (near) return resolveLocationQuery(near, false);
+  if (city) return resolveLocationQuery(city, true);
+  if (cityKey) return resolveCityKey(cityKey);
+  return browserLocation(page);
+}
+
+cli({
+  site: 'district',
+  name: 'showtimes',
+  aliases: ['shows'],
+  access: 'read',
+  description: 'List District movie showtimes with location, time, cinema, language, price, and format filters',
+  domain: 'www.district.in',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  args: [
+    { name: 'movie', positional: true, required: true, help: 'Movie name or District movie URL' },
+    { name: 'date', help: 'Show date in YYYY-MM-DD format; defaults to District selected date' },
+    { name: 'city', help: 'District city name/key, for example Bangalore or Bengaluru' },
+    { name: 'near', help: 'Area, mall, or locality to search near, for example Indiranagar' },
+    { name: 'city-key', help: 'Legacy District city key override, for example bengaluru' },
+    { name: 'after', help: 'Only shows at or after HH:MM, 24-hour time' },
+    { name: 'before', help: 'Only shows at or before HH:MM, 24-hour time' },
+    { name: 'cinema', help: 'Filter cinema/theatre name, for example PVR, INOX, Orion' },
+    { name: 'language', help: 'Filter movie language, for example English, Hindi, Kannada' },
+    { name: 'max-price', type: 'float', help: 'Only shows with at least one ticket class at or below this price' },
+    { name: 'quality', help: 'Generic format/quality filter, for example 2D, 3D, IMAX, IMAX 3D, 4DX' },
+    { name: 'limit', type: 'int', default: 50, help: 'Maximum showtime rows to return (1-200)' },
+  ],
+  columns: [
+    'rank',
+    'movie',
+    'language',
+    'date',
+    'time',
+    'cinema',
+    'format',
+    'priceRange',
+    'available',
+    'showId',
+    'formatId',
+    'url',
+  ],
+  func: async (page, args) => {
+    const movieInput = validateText(args.movie, 'movie');
+    const date = validateDate(args.date);
+    const limit = validateLimit(args.limit);
+    const filters = {
+      after: validateClock(args.after, 'after'),
+      before: validateClock(args.before, 'before'),
+      cinema: validateOptionalText(args.cinema, 'cinema'),
+      language: validateOptionalText(args.language, 'language'),
+      maxPrice: validateMoney(args['max-price'], 'max-price'),
+      quality: validateOptionalText(args.quality, 'quality'),
+    };
+    const loc = await resolveLocation(page, args);
+    if (!loc.pCityKey) throw new CommandExecutionError('Could not resolve District city key for showtimes');
+
+    const movieUrl = isDistrictMovieUrl(movieInput) ? movieInput : await searchMovie(movieInput, loc);
+    const contentId = extractContentId(movieUrl);
+    const bookingUrl = makeBookingUrl(movieUrl, loc.pCityKey);
+    if (date) bookingUrl.searchParams.set('fromdate', date);
+
+    const resp = await fetch(bookingUrl, {
+      headers: districtHeaders({
+        loc,
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        referer: movieUrl,
+      }),
+    });
+    if (!resp.ok) throw new CommandExecutionError(`district booking page failed: HTTP ${resp.status}`);
+
+    const nextData = extractNextData(await resp.text());
+    const state = nextData.props?.pageProps?.initialState?.movies || {};
+    const formatId = state.queryState?.frmtid || Object.keys(state.movieSessions || {})[0] || '';
+    const payload = await fetchMovieSessions({
+      loc,
+      contentId,
+      formatId,
+      date,
+      referer: bookingUrl.toString(),
+    });
+
+    const showDates = Array.isArray(payload?.meta?.showDates) ? payload.meta.showDates : [];
+    if (date && showDates.length && !showDates.includes(date)) {
+      throw new EmptyResultError('district showtimes', `No showtimes found for ${date}; available dates: ${showDates.join(', ')}`);
+    }
+
+    const rows = rowsFromPayload(payload, loc, formatId, contentId, filters, limit);
+    if (!rows.length) throw new EmptyResultError('district showtimes', `No showtimes matched the requested filters for "${movieInput}"`);
+    return rows;
+  },
+});

package/clis/practo/appointment.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { driveJson, normalizeAppointmentId } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'appointment',
+  access: 'read',
+  description: 'Show logged-in Practo Drive appointment details',
+  domain: 'drive.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  siteSession: 'persistent',
+  args: [{ name: 'appointment_id', positional: true, required: true, help: 'Appointment id from `practo appointments`' }],
+  columns: ['appointment_id', 'status', 'summary'],
+  func: async (page, kwargs) => {
+    const id = normalizeAppointmentId(kwargs.appointment_id);
+    const data = await driveJson(page, `/api/record/v2/appointment/${encodeURIComponent(id)}`);
+    return [{ appointment_id: id, status: data?.status || data?.data?.status || '', summary: JSON.stringify(data?.data ?? data).slice(0, 1000) }];
+  },
+});

package/clis/practo/appointments.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { driveJson } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'appointments',
+  access: 'read',
+  description: 'List logged-in Practo Drive appointments',
+  domain: 'drive.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  siteSession: 'persistent',
+  args: [],
+  columns: ['appointment_id', 'doctor', 'practice', 'time', 'status'],
+  func: async (page) => {
+    const data = await driveJson(page, '/api/record/v2/appointments');
+    const list = Array.isArray(data?.data) ? data.data : [];
+    return list.map((item) => ({
+      appointment_id: String(item.id || item.appointment_id || item.object_identifier || ''),
+      doctor: item.doctor_name || item.provider_name || item.doctor?.name || '',
+      practice: item.practice_name || item.establishment_name || item.practice?.name || '',
+      time: item.appointment_time || item.scheduled_at || item.from_time || '',
+      status: item.status || item.state || '',
+    }));
+  },
+});

package/clis/practo/book-confirm.js

@@ -0,0 +1,35 @@
+import { ArgumentError, CommandExecutionError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { bookingPreviewFromPageData, normalizeConfirm, prepareBookingPage, submitBookingPage } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'book-confirm',
+  access: 'write',
+  description: 'Confirm a Practo clinic visit booking after explicit confirmation',
+  domain: 'www.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  args: [
+    { name: 'practice_doctor_id', positional: true, required: true, help: 'Practo practice_doctor_id' },
+    { name: 'time', required: true, help: 'Slot time YYYY-MM-DD HH:mm:ss' },
+    { name: 'profile-url', required: false, help: 'Doctor profile_url from `practo search`, used to build a canonical booking URL' },
+    { name: 'confirm', type: 'boolean', default: false, help: 'Required. Set --confirm true to create the appointment.' },
+  ],
+  columns: ['status', 'practice_doctor_id', 'time', 'url'],
+  func: async (page, kwargs) => {
+    if (!normalizeConfirm(kwargs.confirm)) {
+      throw new ArgumentError('Refusing to book appointment without --confirm true', 'Example: webcmd practo book-confirm 859054 --time "2026-07-10 10:30:00" --confirm true');
+    }
+    const prepared = await prepareBookingPage(page, kwargs);
+    const preview = bookingPreviewFromPageData(prepared.data, prepared.context)[0];
+    if (preview.requires_payment) {
+      throw new CommandExecutionError('This Practo slot appears to require online payment; stopping before payment.');
+    }
+    const result = await submitBookingPage(page);
+    return [{ status: 'submitted', practice_doctor_id: prepared.context.practiceDoctorId, time: prepared.context.slotTime, url: result.url || prepared.context.url }];
+  },
+});

package/clis/practo/book-preview.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { bookingPreviewFromPageData, prepareBookingPage } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'book-preview',
+  access: 'read',
+  description: 'Preview Practo booking details for a selected slot without confirming',
+  domain: 'www.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  siteSession: 'persistent',
+  args: [
+    { name: 'practice_doctor_id', positional: true, required: true, help: 'Practo practice_doctor_id' },
+    { name: 'time', required: true, help: 'Slot time YYYY-MM-DD HH:mm:ss' },
+    { name: 'profile-url', required: false, help: 'Doctor profile_url from `practo search`, used to build a canonical booking URL' },
+  ],
+  columns: ['practice_doctor_id', 'time', 'amount', 'prepaid', 'payment_mode', 'requires_payment', 'confirm_button', 'booking_url'],
+  func: async (page, kwargs) => {
+    const prepared = await prepareBookingPage(page, kwargs);
+    return bookingPreviewFromPageData(prepared.data, prepared.context);
+  },
+});

package/clis/practo/booking-link.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { buildBookingUrl, findSlot, normalizePracticeDoctorId, rowsForSlots } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'booking-link',
+  access: 'read',
+  description: 'Build a Practo booking URL for a selected slot without confirming it',
+  domain: 'www.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'practice_doctor_id', positional: true, required: true, help: 'Practo practice_doctor_id' },
+    { name: 'time', required: true, help: 'Slot time YYYY-MM-DD HH:mm:ss' },
+    { name: 'profile-url', required: false, help: 'Doctor profile_url from `practo search`, used to build a canonical booking URL' },
+  ],
+  columns: ['practice_doctor_id', 'time', 'booking_url'],
+  func: async (page, kwargs) => {
+    const practiceDoctorId = normalizePracticeDoctorId(kwargs.practice_doctor_id);
+    const slot = findSlot(await rowsForSlots(page, practiceDoctorId), kwargs.time);
+    return [{ practice_doctor_id: practiceDoctorId, time: slot.time, booking_url: buildBookingUrl({ practiceDoctorId, slotTime: slot.time, appointmentToken: slot.appointment_token, amount: slot.amount, prepaid: slot.prepaid, profileUrl: kwargs['profile-url'] }) }];
+  },
+});

package/clis/practo/cancel.js

@@ -0,0 +1,29 @@
+import { ArgumentError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { cancelAppointment, normalizeAppointmentId, normalizeConfirm } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'cancel',
+  access: 'write',
+  description: 'Cancel a logged-in Practo Drive appointment after explicit confirmation',
+  domain: 'drive.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  args: [
+    { name: 'appointment_id', positional: true, required: true, help: 'Appointment id from `practo appointments`' },
+    { name: 'confirm', type: 'boolean', default: false, help: 'Required. Set --confirm true to cancel the appointment.' },
+  ],
+  columns: ['status', 'appointment_id'],
+  func: async (page, kwargs) => {
+    const id = normalizeAppointmentId(kwargs.appointment_id);
+    if (!normalizeConfirm(kwargs.confirm)) {
+      throw new ArgumentError('Refusing to cancel appointment without --confirm true', 'Example: webcmd practo cancel <appointment_id> --confirm true');
+    }
+    await cancelAppointment(page, id);
+    return [{ status: 'cancelled', appointment_id: id }];
+  },
+});