@agentrhq/webcmd 0.2.2 → 0.2.4

package/clis/blinkit/location.js

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { DOMAIN, gotoBlinkit, normalizeLocationState } from './utils.js';
+
+const LOCATION_EVALUATE = `
+  (() => {
+    const readJson = (key) => {
+      try { return JSON.parse(localStorage.getItem(key) || 'null'); } catch { return null; }
+    };
+    return window.__reduxStore__?.getState?.()?.data?.location || readJson('location') || {};
+  })()
+`;
+
+cli({
+  site: 'blinkit',
+  name: 'location',
+  access: 'read',
+  description: 'Show the selected Blinkit delivery location',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [],
+  columns: ['selected', 'label', 'area', 'city', 'pincode', 'hasCoordinates', 'source'],
+  func: async (page) => {
+    await gotoBlinkit(page, '/');
+    if (page.wait) await page.wait(1);
+    return [normalizeLocationState(await page.evaluate(LOCATION_EVALUATE))];
+  },
+});
+

package/clis/blinkit/place-order.js

@@ -0,0 +1,78 @@
+import { ArgumentError, CommandExecutionError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { DOMAIN, ensureCartHasItems, ensureLoggedIn, openCartPanel, readCartState, summarizeCartResponse } from './utils.js';
+
+function buildPlaceOrderEvaluate() {
+  return `
+    (async () => {
+      const finalLabels = [/^place order$/i, /^pay( now)?$/i, /^cash on delivery$/i];
+      const buttons = Array.from(document.querySelectorAll('button, [role="button"], a'));
+      const target = buttons.find((node) => {
+        const text = (node.innerText || node.textContent || '').trim().replace(/\\s+/g, ' ');
+        return text && finalLabels.some((pattern) => pattern.test(text));
+      });
+      if (!target) {
+        return { ok: false, status: 'blocked', message: 'No final place-order/payment button is visible. Complete address/payment selection in the browser checkout first.' };
+      }
+      target.click();
+      await new Promise((resolve) => setTimeout(resolve, 3500));
+      const text = document.body.innerText || '';
+      const orderMatch = text.match(/order(?:\\s+id)?[:#\\s-]*([A-Z0-9-]{6,})/i);
+      if (/payment failed|try again|could not/i.test(text)) {
+        return { ok: false, status: 'failed', message: 'Blinkit reported a payment/order failure', url: location.href };
+      }
+      return { ok: true, status: orderMatch ? 'placed' : 'submitted', orderId: orderMatch?.[1] || '', url: location.href };
+    })()
+  `;
+}
+
+cli({
+  site: 'blinkit',
+  name: 'place-order',
+  access: 'write',
+  description: 'Submit the visible Blinkit final order/payment action. Requires --confirm.',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  args: [
+    { name: 'confirm', type: 'bool', default: false, help: 'Required acknowledgement that this may place/pay for a real order' },
+  ],
+  columns: ['status', 'confirmed', 'itemCount', 'payable', 'orderId', 'url', 'message'],
+  func: async (page, kwargs) => {
+    if (!kwargs.confirm) {
+      return [{
+        status: 'no-op',
+        confirmed: false,
+        message: 'Pass --confirm to submit a real Blinkit order/payment action.',
+      }];
+    }
+    if (kwargs.confirm !== true) throw new ArgumentError('--confirm must be a boolean flag');
+
+    await openCartPanel(page);
+    const state = await readCartState(page);
+    ensureLoggedIn(state, 'blinkit place-order');
+    const summary = summarizeCartResponse(state);
+    ensureCartHasItems(summary);
+    if (summary.checkoutBlocked) throw new CommandExecutionError('Blinkit checkout is blocked for this cart');
+
+    const result = await page.evaluate(buildPlaceOrderEvaluate()).catch((error) => {
+      throw new CommandExecutionError(`blinkit place-order failed: ${error?.message || error}`);
+    });
+    if (!result?.status) throw new CommandExecutionError('blinkit place-order returned no status');
+    return [{
+      status: result.status,
+      confirmed: true,
+      itemCount: summary.itemCount,
+      payable: summary.payable,
+      orderId: result.orderId || '',
+      url: result.url || '',
+      message: result.message || '',
+    }];
+  },
+});
+
+export const __test__ = {
+  buildPlaceOrderEvaluate,
+};

package/clis/blinkit/product.js

@@ -0,0 +1,63 @@
+import { CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { DOMAIN, normalizeProductSnippet, requireProductId, resolveCoordinates } from './utils.js';
+
+function buildProductEvaluate(productId, lat, lon) {
+  return `
+    (async () => {
+      const headers = { lat: ${JSON.stringify(lat)}, lon: ${JSON.stringify(lon)}, app_client: 'consumer_web' };
+      const resp = await fetch('/v1/layout/product/' + ${JSON.stringify(productId)}, { method: 'POST', credentials: 'include', headers });
+      const raw = await resp.text();
+      let json;
+      try { json = JSON.parse(raw); } catch { return { ok: false, status: resp.status, error: raw.slice(0, 200) }; }
+      if (!resp.ok || json.error) return { ok: false, status: resp.status, error: json.error || json.message || raw.slice(0, 200) };
+      return { ok: true, snippets: json?.response?.snippets || [] };
+    })()
+  `;
+}
+
+function normalizeProduct(snippets, productId) {
+  const title = snippets.find((snippet) => snippet?.widget_type === 'text_right_icons_rating_snippet_type');
+  const strip = snippets.find((snippet) => snippet?.widget_type === 'product_atc_strip');
+  const row = normalizeProductSnippet(strip) ?? normalizeProductSnippet(title);
+  if (!row) return null;
+  const titleText = title?.data?.title?.text;
+  return { ...row, productId, name: titleText || row.name };
+}
+
+cli({
+  site: 'blinkit',
+  name: 'product',
+  access: 'read',
+  description: 'Read Blinkit product details for a delivery location',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'productId', required: true, positional: true, help: 'Blinkit product id' },
+    { name: 'lat', help: 'Delivery latitude (defaults to current Blinkit browser location)' },
+    { name: 'lon', help: 'Delivery longitude (defaults to current Blinkit browser location)' },
+  ],
+  columns: ['productId', 'name', 'brand', 'variant', 'price', 'mrp', 'currency', 'inventory', 'available', 'imageUrl', 'url'],
+  func: async (page, kwargs) => {
+    const productId = requireProductId(kwargs.productId);
+    await page.goto(`https://blinkit.com/prn/x/prid/${productId}`).catch((error) => {
+      throw new CommandExecutionError(`blinkit product navigation failed: ${error?.message || error}`);
+    });
+    const { lat, lon } = await resolveCoordinates(page, kwargs);
+    const result = await page.evaluate(buildProductEvaluate(productId, lat, lon)).catch((error) => {
+      throw new CommandExecutionError(`blinkit product request failed: ${error?.message || error}`);
+    });
+    if (!result?.ok) {
+      throw new CommandExecutionError(`blinkit product failed: HTTP ${result?.status ?? 'unknown'} ${result?.error ?? ''}`.trim());
+    }
+    const row = normalizeProduct(result.snippets ?? [], productId);
+    if (!row) throw new EmptyResultError('blinkit product', `No product data for ${productId}`);
+    return [row];
+  },
+});
+
+export const __test__ = {
+  normalizeProduct,
+};

package/clis/blinkit/search.js

@@ -0,0 +1,89 @@
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { BASE, MAX_LIMIT, normalizeProductSnippet, parseCoordinate, parseLimit, parsePrice, resolveCoordinates } from './utils.js';
+
+function buildSearchEvaluate(query, limit, lat, lon) {
+  return `
+    (async () => {
+      const query = ${JSON.stringify(query)};
+      const limit = ${limit};
+      const headers = {
+        lat: ${JSON.stringify(lat)},
+        lon: ${JSON.stringify(lon)},
+        app_client: 'consumer_web'
+      };
+      const rows = [];
+      let url = '/v1/layout/search?q=' + encodeURIComponent(query) + '&search_type=type_to_search';
+
+      for (let page = 0; url && rows.length < limit && page < 8; page += 1) {
+        const resp = await fetch(url, { method: 'POST', credentials: 'include', headers });
+        const raw = await resp.text();
+        let json;
+        try {
+          json = JSON.parse(raw);
+        } catch {
+          return { ok: false, status: resp.status, error: raw.slice(0, 200) };
+        }
+        if (!resp.ok || json.error) {
+          return { ok: false, status: resp.status, error: json.error || json.message || raw.slice(0, 200) };
+        }
+        const snippets = Array.isArray(json?.response?.snippets) ? json.response.snippets : [];
+        rows.push(...snippets.filter((snippet) => snippet?.widget_type === 'product_card_snippet_type_2'));
+        url = json?.response?.pagination?.next_url || '';
+      }
+
+      return { ok: true, rows: rows.slice(0, limit) };
+    })()
+  `;
+}
+
+cli({
+  site: 'blinkit',
+  name: 'search',
+  access: 'read',
+  description: 'Search Blinkit products for a delivery location',
+  domain: 'blinkit.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'query', required: true, positional: true, help: 'Search keyword' },
+    { name: 'limit', type: 'int', default: 20, help: `Max results (max ${MAX_LIMIT})` },
+    { name: 'lat', help: 'Delivery latitude (defaults to current Blinkit browser location)' },
+    { name: 'lon', help: 'Delivery longitude (defaults to current Blinkit browser location)' },
+  ],
+  columns: ['rank', 'productId', 'name', 'brand', 'variant', 'price', 'mrp', 'currency', 'inventory', 'available', 'imageUrl', 'url'],
+  func: async (page, kwargs) => {
+    const query = String(kwargs.query ?? '').trim();
+    if (!query) throw new ArgumentError('query cannot be empty');
+
+    const limit = parseLimit(kwargs.limit);
+    const pageUrl = `${BASE}/s/?q=${encodeURIComponent(query)}`;
+    await page.goto(pageUrl).catch((error) => {
+      throw new CommandExecutionError(`blinkit search navigation failed: ${error?.message || error}`);
+    });
+    const { lat, lon } = await resolveCoordinates(page, kwargs);
+
+    const result = await page.evaluate(buildSearchEvaluate(query, limit, lat, lon)).catch((error) => {
+      throw new CommandExecutionError(`blinkit search request failed: ${error?.message || error}`);
+    });
+    if (!result?.ok) {
+      throw new CommandExecutionError(`blinkit search failed: HTTP ${result?.status ?? 'unknown'} ${result?.error ?? ''}`.trim());
+    }
+
+    const rows = (result.rows ?? [])
+      .map((snippet, index) => normalizeProductSnippet(snippet, index + 1))
+      .filter(Boolean);
+    if (!rows.length) {
+      throw new EmptyResultError('blinkit search', `No products matched "${query}" at ${lat},${lon}`);
+    }
+    return rows;
+  },
+});
+
+export const __test__ = {
+  normalizeSnippet: normalizeProductSnippet,
+  parseCoordinate,
+  parseLimit,
+  parsePrice,
+};

package/clis/blinkit/utils.js

@@ -0,0 +1,223 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+
+export const BASE = 'https://blinkit.com';
+export const DOMAIN = 'blinkit.com';
+export const DEFAULT_LAT = '28.413333';
+export const DEFAULT_LON = '77.072833';
+export const MAX_LIMIT = 48;
+
+export function parseLimit(raw) {
+  if (raw === undefined || raw === null || raw === '') return 20;
+  const limit = Number(raw);
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+    throw new ArgumentError(`--limit must be an integer between 1 and ${MAX_LIMIT}`);
+  }
+  return limit;
+}
+
+export function parseQuantity(raw) {
+  const quantity = raw === undefined || raw === null || raw === '' ? 1 : Number(raw);
+  if (!Number.isInteger(quantity) || quantity < 1 || quantity > 12) {
+    throw new ArgumentError('--quantity must be an integer between 1 and 12');
+  }
+  return quantity;
+}
+
+export function parseCoordinate(raw, label, fallback) {
+  const value = raw === undefined || raw === null || raw === '' ? fallback : String(raw);
+  const n = Number(value);
+  const max = label === 'lat' ? 90 : 180;
+  if (!Number.isFinite(n) || n < -max || n > max) {
+    throw new ArgumentError(`--${label} must be a number between ${-max} and ${max}`);
+  }
+  return String(n);
+}
+
+export async function resolveCoordinates(page, kwargs = {}) {
+  const explicitLat = kwargs.lat !== undefined && kwargs.lat !== null && kwargs.lat !== '';
+  const explicitLon = kwargs.lon !== undefined && kwargs.lon !== null && kwargs.lon !== '';
+  const location = explicitLat && explicitLon ? null : await page.evaluate(`
+    (() => {
+      const readJson = (key) => {
+        try { return JSON.parse(localStorage.getItem(key) || 'null'); } catch { return null; }
+      };
+      const coords = window.__reduxStore__?.getState?.()?.data?.location?.coords || readJson('location')?.coords || {};
+      return { lat: coords.lat, lon: coords.lon };
+    })()
+  `).catch(() => null);
+  return {
+    lat: parseCoordinate(explicitLat ? kwargs.lat : location?.lat, 'lat', DEFAULT_LAT),
+    lon: parseCoordinate(explicitLon ? kwargs.lon : location?.lon, 'lon', DEFAULT_LON),
+  };
+}
+
+export function normalizeLocationState(location = {}) {
+  const coords = location.coords || {};
+  return {
+    selected: Boolean(location.locality || location.area || location.city || location.pinCode || location.pincode || coords.lat || coords.lon),
+    label: String(location.label || location.name || location.type || '').trim(),
+    area: String(location.locality || location.area || location.landmark || '').trim(),
+    city: String(location.city || location.cityName || '').trim(),
+    pincode: String(location.pinCode || location.pincode || location.pin || '').trim(),
+    hasCoordinates: Boolean(coords.lat || coords.lon),
+    source: 'browser',
+  };
+}
+
+export function requireProductId(raw) {
+  const value = String(raw ?? '').trim();
+  const match = value.match(/(?:prid\/)?(\d{3,})$/) || value.match(/\/prid\/(\d{3,})/);
+  if (!match) throw new ArgumentError('productId must be a Blinkit product id, for example 19512');
+  return match[1];
+}
+
+export function parsePrice(text) {
+  const match = String(text ?? '').replace(/,/g, '').match(/(\d+(?:\.\d+)?)/);
+  return match ? Number(match[1]) : null;
+}
+
+export function text(node) {
+  return String(node?.text ?? '').trim();
+}
+
+export function productUrl(productId) {
+  return productId ? `${BASE}/prn/x/prid/${productId}` : '';
+}
+
+export function normalizeProductSnippet(snippet, rank = undefined) {
+  const data = snippet?.data ?? {};
+  const cart = data.atc_action?.add_to_cart?.cart_item
+    ?? data.stepper_data_v2?.increment_actions?.default?.find((action) => action?.add_to_cart)?.add_to_cart?.cart_item
+    ?? data.rfc_actions_v2?.default?.find((action) => action?.remove_from_cart)?.remove_from_cart?.cart_item
+    ?? {};
+  const productId = String(data.product_id ?? data.meta?.product_id ?? cart.product_id ?? data.identity?.id ?? '').trim();
+  const name = text(data.display_name) || text(data.name) || text(data.title) || String(cart.product_name ?? cart.display_name ?? '').trim();
+  if (!productId || !name) return null;
+
+  const price = cart.price ?? parsePrice(text(data.normal_price) || text(data.info_text));
+  const mrp = cart.mrp ?? parsePrice(text(data.mrp));
+  return {
+    ...(rank === undefined ? {} : { rank }),
+    productId,
+    name,
+    brand: text(data.brand_name) || String(cart.brand ?? '').trim(),
+    variant: text(data.variant) || String(cart.unit ?? '').trim(),
+    price: Number.isFinite(Number(price)) ? Number(price) : null,
+    mrp: Number.isFinite(Number(mrp)) ? Number(mrp) : null,
+    currency: 'INR',
+    inventory: Number.isFinite(Number(data.inventory ?? cart.inventory)) ? Number(data.inventory ?? cart.inventory) : null,
+    available: data.is_sold_out === true ? false : data.product_state !== 'unavailable',
+    imageUrl: data.image?.url || cart.image_url || '',
+    url: productUrl(productId),
+  };
+}
+
+export function normalizeCartItem(item, fallbackId = '') {
+  const product = item?.product ?? item ?? {};
+  const productId = String(product.product_id ?? item?.product_id ?? fallbackId ?? '').trim();
+  const quantity = Number(item?.quantity ?? product.quantity ?? 0);
+  if (!productId || !quantity) return null;
+  const price = Number(product.price ?? product.unit_price ?? parsePrice(product.total_price));
+  return {
+    productId,
+    name: String(product.name ?? product.product_name ?? product.display_name ?? '').trim(),
+    variant: String(product.unit ?? '').trim(),
+    price: Number.isFinite(price) ? price : null,
+    quantity,
+    total: Number.isFinite(price) ? price * quantity : null,
+    inventory: Number.isFinite(Number(product.inventory_limit ?? product.inventory)) ? Number(product.inventory_limit ?? product.inventory) : null,
+    merchantId: String(product.merchant_id ?? '').trim(),
+    imageUrl: product.image_url || product.image_url_v2 || product.png_image_url || '',
+  };
+}
+
+export function summarizeCartResponse(response) {
+  const cartData = response?.cart_data ?? {};
+  const bill = cartData.bill_details ?? {};
+  const items = Array.isArray(cartData.items)
+    ? cartData.items.map((item) => normalizeCartItem(item)).filter(Boolean)
+    : [];
+  const storedItems = response?.storedCart?.items && typeof response.storedCart.items === 'object'
+    ? Object.entries(response.storedCart.items).map(([id, item]) => normalizeCartItem(item, id)).filter(Boolean)
+    : [];
+  const finalItems = items.length ? items : storedItems;
+  return {
+    status: finalItems.length ? 'ok' : 'empty',
+    itemCount: Number(bill.total_items ?? response?.storedCart?.count ?? finalItems.reduce((sum, item) => sum + item.quantity, 0) ?? 0),
+    itemsTotal: Number(bill.total_cost ?? response?.storedCart?.total ?? 0),
+    deliveryCharge: Number(bill.delivery_charge ?? 0),
+    handlingCharge: Number(bill.additional_charge ?? 0),
+    payable: Number(bill.payable_amount ?? bill.bill_total ?? response?.storedCart?.total ?? 0),
+    cartState: response?.cart_state ?? cartData.cart_state ?? response?.storedCart?.cart_state ?? '',
+    checkoutBlocked: Boolean(cartData.checkout_block_details),
+    validations: (cartData.validations ?? []).map((validation) => validation?.code).filter(Boolean).join(','),
+    items: finalItems,
+  };
+}
+
+export async function gotoBlinkit(page, path = '/') {
+  await page.goto(`${BASE}${path}`).catch((error) => {
+    throw new CommandExecutionError(`blinkit navigation failed: ${error?.message || error}`);
+  });
+}
+
+export async function openCartPanel(page) {
+  await gotoBlinkit(page, '/');
+  await page.wait(1);
+  await page.evaluate(`
+    (() => {
+      const nodes = Array.from(document.querySelectorAll('[role="button"], header div, header button, header a'));
+      const target = nodes
+        .filter((node) => {
+          const value = node.innerText || node.textContent || '';
+          return /My Cart/i.test(value) || (/\\d+\\s+items?/i.test(value) && /₹\\s*\\d+/i.test(value));
+        })
+        .sort((a, b) => (a.innerText || a.textContent || '').length - (b.innerText || b.textContent || '').length)[0];
+      target?.dispatchEvent?.(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+      return Boolean(target);
+    })()
+  `).catch((error) => {
+    throw new CommandExecutionError(`blinkit cart open failed: ${error?.message || error}`);
+  });
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    await page.wait(1);
+    const ready = await page.evaluate(`
+      (() => Boolean(window.__reduxStore__?.getState?.()?.ui?.cart?.cartScreen?.cartResponse?.cart_data))
+    `).catch(() => false);
+    if (ready) return;
+  }
+}
+
+export async function readCartState(page) {
+  const result = await page.evaluate(`
+    (() => {
+      const readJson = (key) => {
+        try { return JSON.parse(localStorage.getItem(key) || 'null'); } catch { return null; }
+      };
+      const state = window.__reduxStore__?.getState?.();
+      const response = state?.ui?.cart?.cartScreen?.cartResponse || null;
+      return {
+        ok: true,
+        loggedIn: !/^Login$/m.test(document.body.innerText || '') && Boolean(readJson('auth')?.accessToken || state?.data?.auth?.accessToken),
+        response,
+        storedCart: state?.data?.cart || readJson('cart') || null,
+        checkout: state?.ui?.checkout || readJson('checkout') || null,
+        location: state?.data?.location || readJson('location') || null,
+      };
+    })()
+  `).catch((error) => {
+    throw new CommandExecutionError(`blinkit cart state read failed: ${error?.message || error}`);
+  });
+  if (!result?.ok) throw new CommandExecutionError('blinkit cart state read failed');
+  return result;
+}
+
+export function ensureLoggedIn(state, action = 'Blinkit command') {
+  if (!state?.loggedIn) {
+    throw new AuthRequiredError(DOMAIN, `${action} requires a logged-in Blinkit browser session. Run webcmd blinkit login first.`);
+  }
+}
+
+export function ensureCartHasItems(summary) {
+  if (!summary.itemCount) throw new EmptyResultError('blinkit cart', 'Cart is empty');
+}

package/clis/district/checkout.js

@@ -94,6 +94,63 @@ async function selectRequestedSeats(page, requestedSeats, timeout) {
   return selected;
 }
 
+async function readSelectedSeats(page) {
+  const seats = await page.evaluate(`
+    (() => {
+      return [...document.querySelectorAll('#selected-seat span,[aria-label^="selected class"]')].map((el) => {
+        const aria = el.getAttribute('aria-label') || '';
+        const row = ((aria.match(/row\\s+([^,\\s]+)/i) || [])[1] || '').trim().toUpperCase();
+        const number = (el.querySelector('label')?.innerText || el.innerText || '').replace(/\\s+/g, '').trim();
+        return row && number ? row + number : '';
+      }).filter(Boolean);
+    })()
+  `);
+  return Array.isArray(seats) ? seats : [];
+}
+
+async function toggleSeat(page, seat) {
+  const result = await page.evaluate(`
+    (() => {
+      const wanted = ${JSON.stringify(seat)};
+      const candidates = [...document.querySelectorAll('#available-seat,[id="selected-seat"] span,[aria-label*="seat"]')];
+      const parse = (el) => {
+        const aria = el.getAttribute('aria-label') || '';
+        const row = ((aria.match(/row\\s+([^,\\s]+)/i) || [])[1] || '').trim().toUpperCase();
+        const number = (el.querySelector('label')?.innerText || el.innerText || '').replace(/\\s+/g, '').trim();
+        return row && number ? row + number : '';
+      };
+      const target = candidates.find((el) => parse(el) === wanted);
+      if (!target) return { ok: false, message: wanted + ' was not found in the seat map' };
+      target.click();
+      return { ok: true };
+    })()
+  `);
+  if (!result?.ok) throw new CommandExecutionError(result?.message || `Could not toggle ${seat}`);
+}
+
+/**
+ * District remembers the last ticket quantity per profile and auto-selects
+ * that many adjacent seats on the first click, so the selection can contain
+ * seats nobody asked for. Deselect extras, reselect anything knocked out,
+ * and refuse to proceed until the selection matches the request exactly.
+ */
+async function reconcileSelection(page, requestedSeats, timeout) {
+  const wanted = new Set(requestedSeats);
+  const deadline = Date.now() + timeout * 1000;
+  let selected = await readSelectedSeats(page);
+  while (Date.now() < deadline) {
+    const extras = selected.filter((seat) => !wanted.has(seat));
+    const missing = requestedSeats.filter((seat) => !selected.includes(seat));
+    if (!extras.length && !missing.length) return;
+    for (const seat of [...extras, ...missing]) await toggleSeat(page, seat);
+    await page.wait(0.5);
+    selected = await readSelectedSeats(page);
+  }
+  throw new CommandExecutionError(
+    `District kept the selection at ${selected.join(', ') || 'no seats'} while ${requestedSeats.join(', ')} was requested; a pending booking or sticky ticket count may be interfering — open the browser tab to inspect`,
+  );
+}
+
 async function clickProceed(page, timeout) {
   const result = await page.evaluate(`
     (() => {
@@ -272,7 +329,20 @@ cli({
 
     await dismissSeatDrawer(page);
     const selected = await selectRequestedSeats(page, seats, timeout);
+    await reconcileSelection(page, seats, timeout);
     await clickProceed(page, timeout);
-    return extractReview(page, target, selected, timeout);
+    const review = await extractReview(page, target, selected, timeout);
+
+    // Final contract check: the review page is the last stop before money
+    // moves, so a resumed pending order or re-expanded selection must fail
+    // loudly here rather than hand the user the wrong tickets to pay for.
+    const reviewSeats = String(review.seats || '').split(/\s*,\s*/).filter(Boolean).sort().join(',');
+    const requested = [...seats].sort().join(',');
+    if (reviewSeats && reviewSeats !== requested) {
+      throw new CommandExecutionError(
+        `District review shows seats ${review.seats} but ${seats.join(', ')} was requested; open the browser tab and correct the order before paying`,
+      );
+    }
+    return review;
   },
 });

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