@agentrhq/webcmd 0.2.2 → 0.2.4

package/clis/bigbasket/utils.js

@@ -0,0 +1,207 @@
+import { ArgumentError, CommandExecutionError } from '@agentrhq/webcmd/errors';
+
+export const SITE = 'bigbasket';
+export const DOMAIN = 'www.bigbasket.com';
+export const HOME_URL = 'https://www.bigbasket.com/';
+export const CART_URL = 'https://www.bigbasket.com/basket/';
+export const CHECKOUT_URL = 'https://www.bigbasket.com/checkout/';
+
+export function cleanText(value) {
+  return typeof value === 'string'
+    ? value.replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim()
+    : '';
+}
+
+export function parseMoney(value) {
+  const text = cleanText(String(value ?? ''));
+  if (!text) return null;
+  const match = text.replace(/,/g, '').match(/(\d+(?:\.\d+)?)/);
+  if (!match) return null;
+  const num = Number(match[1]);
+  return Number.isFinite(num) ? num : null;
+}
+
+function normalizeAvailability(value) {
+  const text = cleanText(value);
+  if (/instock$/i.test(text) || /\bin stock\b/i.test(text)) return 'In stock';
+  if (/outofstock$/i.test(text) || /out of stock|unavailable/i.test(text)) return 'Out of stock';
+  return text;
+}
+
+export function parseLimitArg(raw, fallback, max) {
+  if (raw === undefined || raw === null || raw === '') return fallback;
+  const num = Number(raw);
+  if (!Number.isInteger(num) || num < 1 || num > max) {
+    throw new ArgumentError(`--limit must be an integer between 1 and ${max} (got ${raw})`);
+  }
+  return num;
+}
+
+export function parseQuantityArg(raw, fallback, max) {
+  if (raw === undefined || raw === null || raw === '') return fallback;
+  const num = Number(raw);
+  if (!Number.isInteger(num) || num < 1 || num > max) {
+    throw new ArgumentError(`--quantity must be an integer between 1 and ${max} (got ${raw})`);
+  }
+  return num;
+}
+
+export function buildSearchUrl(query) {
+  const normalized = cleanText(query);
+  if (!normalized) throw new ArgumentError('bigbasket search query cannot be empty');
+  return `${HOME_URL}ps/?q=${encodeURIComponent(normalized)}`;
+}
+
+export function toBigBasketUrl(value) {
+  const text = cleanText(value);
+  if (!text) return '';
+  try {
+    const url = new URL(text.startsWith('http') ? text : text.startsWith('/') ? text : `/${text}`, HOME_URL);
+    if (url.hostname !== DOMAIN) {
+      throw new Error('not bigbasket');
+    }
+    url.hash = '';
+    return url.toString();
+  } catch {
+    return '';
+  }
+}
+
+export function resolveCategoryUrl(input) {
+  const text = cleanText(input);
+  if (!text) throw new ArgumentError('bigbasket category requires a category URL or slug');
+  if (!text.startsWith('http') && !text.includes('/')) {
+    throw new ArgumentError('bigbasket category expects a category path such as fruits-vegetables/vegetables');
+  }
+  const prefixed = text.startsWith('http') || text.startsWith('/pc/') ? text : `/pc/${text.replace(/^\/+/, '')}/`;
+  const url = toBigBasketUrl(prefixed);
+  if (!url || !new URL(url).pathname.startsWith('/pc/')) {
+    throw new ArgumentError('bigbasket category expects a BigBasket /pc/<category>/ URL or slug');
+  }
+  return url;
+}
+
+export function resolveProductInput(input) {
+  const text = cleanText(input);
+  if (!text) throw new ArgumentError('bigbasket product requires a product ID or URL');
+  if (/^\d{4,}$/.test(text)) {
+    return { productId: text, url: `${HOME_URL}pd/${text}/` };
+  }
+  const url = toBigBasketUrl(text);
+  if (!url) throw new ArgumentError('bigbasket product expects a BigBasket product ID or /pd/<id>/ URL');
+  const match = new URL(url).pathname.match(/^\/pd\/(\d{4,})(?:\/|$)/);
+  if (!match) throw new ArgumentError('bigbasket product expects a BigBasket product ID or /pd/<id>/ URL');
+  return { productId: match[1], url };
+}
+
+export function normalizeProductRow(raw, rank) {
+  const url = toBigBasketUrl(raw.url || raw.href || '');
+  const productId = cleanText(raw.product_id || raw.productId || raw.id || url.match(/\/pd\/(\d{4,})/)?.[1] || '');
+  return {
+    rank: rank + 1,
+    product_id: productId,
+    title: cleanText(raw.title || raw.name),
+    brand: cleanText(raw.brand),
+    pack_size: cleanText(raw.pack_size || raw.packSize || raw.size),
+    price: parseMoney(raw.price),
+    mrp: parseMoney(raw.mrp || raw.original_price || raw.originalPrice),
+    discount: cleanText(raw.discount),
+    availability: normalizeAvailability(raw.availability || raw.stock),
+    url,
+  };
+}
+
+function parseJsonObject(raw) {
+  try {
+    const value = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+export function normalizeLocationState(raw = {}) {
+  const info = parseJsonObject(raw.selectedAddressInfo || raw.selected_address_info || raw.address);
+  const pincode = cleanText(String(info.pin || info.pincode || raw.pin || raw.pincode || ''));
+  return {
+    selected: Boolean(raw.selected_address_id || raw.selectedAddressId || info.id || pincode),
+    label: cleanText(info.nick || info.nickname || raw.label || raw.nick),
+    area: cleanText(info.area || info.locality || raw.area),
+    city: cleanText(info.city_name || info.city || raw.city),
+    pincode,
+    source: raw.selectedAddressInfo || raw.selected_address_info ? 'selectedAddressInfo' : '',
+  };
+}
+
+export async function safeGoto(page, url, label) {
+  await page.goto(url).catch((error) => {
+    throw new CommandExecutionError(`${label} navigation failed: ${error?.message || error}`);
+  });
+}
+
+export function productCardsEvaluate(limit) {
+  return `
+    (() => {
+      const limit = ${Number(limit) || 20};
+      const clean = (value) => value == null ? '' : String(value).replace(/\\s+/g, ' ').trim();
+      const leafText = (root) => Array.from(root.querySelectorAll('*'))
+        .filter((node) => node.children.length === 0)
+        .map((node) => clean(node.textContent))
+        .filter(Boolean);
+      const anchors = Array.from(document.querySelectorAll('a[href*="/pd/"]'));
+      const byProductId = new Map();
+      const rows = [];
+
+      for (const anchor of anchors) {
+        const href = anchor.href || anchor.getAttribute('href') || '';
+        const productId = href.match(/\\/pd\\/(\\d{4,})/)?.[1] || '';
+        if (!productId) continue;
+
+        const root = anchor.closest('li, article, [data-testid], [class*="Product"], [class*="product"], [class*="SKU"], [class*="sku"]') || anchor;
+        const productAnchors = Array.from(root.querySelectorAll('a[href*="/pd/"]'))
+          .filter((node) => (node.href || node.getAttribute('href') || '').includes('/pd/' + productId + '/'));
+        const titleAnchor = productAnchors.find((node) => clean(node.textContent)) || anchor;
+        const titleParam = (() => {
+          try { return clean(new URL(href, location.origin).searchParams.get('t_s')); } catch { return ''; }
+        })();
+        const texts = leafText(root);
+        const joined = texts.join(' | ');
+        const brand = clean(titleAnchor.querySelector('span')?.textContent);
+        const visibleTitle =
+          clean(titleAnchor.getAttribute('title')) ||
+          clean(titleAnchor.querySelector('h1,h2,h3,[class*="name"],[class*="Name"]')?.textContent) ||
+          clean(titleAnchor.textContent).replace(brand, '').trim() ||
+          texts.find((text) => /[A-Za-z]/.test(text) && !/₹|rs\\.?|add|cart|off/i.test(text)) ||
+          '';
+        const title = !visibleTitle || visibleTitle === brand ? titleParam : visibleTitle;
+        const price = texts.find((text) => /₹|rs\\.?/i.test(text) && !/mrp/i.test(text)) || '';
+        const mrp = texts.find((text) => /mrp/i.test(text)) || '';
+        const discount = texts.find((text) => /%\\s*off|save/i.test(text)) || '';
+        const packSize = texts.find((text) => /\\b\\d+(?:\\.\\d+)?\\s*(?:kg|g|gm|ml|l|ltr|pcs?|pack)\\b/i.test(text)) || '';
+        const availability = /out of stock|unavailable/i.test(joined) ? 'Out of stock' : '';
+
+        const row = {
+          product_id: productId,
+          title,
+          brand,
+          pack_size: packSize,
+          price,
+          mrp,
+          discount,
+          availability,
+          url: href,
+        };
+        const existing = byProductId.get(productId);
+        if (!existing || (!existing.title && row.title)) byProductId.set(productId, row);
+      }
+
+      for (const row of byProductId.values()) {
+        rows.push(row);
+        if (rows.length >= limit) break;
+      }
+
+      const bodyText = clean(document.body?.innerText || '');
+      return { rows, bodyText, href: location.href };
+    })()
+  `;
+}

package/clis/blinkit/add-to-cart.js

@@ -0,0 +1,123 @@
+import { CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+  DOMAIN,
+  ensureCartHasItems,
+  openCartPanel,
+  parseQuantity,
+  readCartState,
+  requireProductId,
+  resolveCoordinates,
+  summarizeCartResponse,
+} from './utils.js';
+
+function buildCartItemEvaluate(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 json = await resp.json().catch(() => null);
+      if (!resp.ok || !json) return { ok: false, status: resp.status };
+      const snippets = json?.response?.snippets || [];
+      const strip = snippets.find((snippet) => snippet?.widget_type === 'product_atc_strip')?.data || {};
+      const action = strip.stepper_data_v2?.increment_actions?.default?.find((item) => item?.add_to_cart)
+        || strip.rfc_actions_v2?.default?.find((item) => item?.remove_from_cart);
+      const cartItem = action?.add_to_cart?.cart_item || action?.remove_from_cart?.cart_item || null;
+      return [Boolean(cartItem), resp.status, cartItem, strip.inventory, strip.is_sold_out === true];
+    })()
+  `;
+}
+
+function buildWriteCartEvaluate(cartItem, quantity) {
+  return `
+    (() => {
+      const cartItem = ${JSON.stringify(cartItem)};
+      const quantity = ${quantity};
+      const readJson = (key, fallback) => {
+        try { return JSON.parse(localStorage.getItem(key) || 'null') || fallback; } catch { return fallback; }
+      };
+      const cart = readJson('cart', { count: 0, total: 0, chargeableDeliveryCost: 0, items: {}, promoInfo: [], paymentMode: null, step: [], version: 1, promo_id: '', CartAddressScreenVisible: false, uniqueSkuInCart: 0, cart_type: '', cart_state: 'invalid' });
+      const id = String(cartItem.product_id);
+      const current = cart.items?.[id]?.quantity || 0;
+      cart.items = cart.items || {};
+      cart.items[id] = {
+        product: {
+          product_id: cartItem.product_id,
+          price: cartItem.price,
+          image_url: cartItem.image_url,
+          unit: cartItem.unit,
+          mrp: cartItem.mrp,
+          group_id: cartItem.group_id,
+          merchant_id: cartItem.merchant_id,
+          name: cartItem.product_name || cartItem.display_name,
+          brand: cartItem.brand
+        },
+        quantity: current + quantity
+      };
+      const values = Object.values(cart.items);
+      cart.count = values.reduce((sum, item) => sum + Number(item.quantity || 0), 0);
+      cart.total = values.reduce((sum, item) => sum + Number(item.quantity || 0) * Number(item.product?.price || 0), 0);
+      cart.uniqueSkuInCart = values.length;
+      cart.version = 1;
+      localStorage.setItem('cart', JSON.stringify(cart));
+      window.__reduxStore__?.dispatch?.({ type: 'SYNC_CART', cart });
+      return [true, id, cart.items[id].quantity, cart.count, cart.total];
+    })()
+  `;
+}
+
+cli({
+  site: 'blinkit',
+  name: 'add-to-cart',
+  access: 'write',
+  description: 'Add a Blinkit product to cart',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'productId', required: true, positional: true, help: 'Blinkit product id' },
+    { name: 'quantity', type: 'int', default: 1, help: 'Quantity to add (default 1, max 12)' },
+    { name: 'lat', help: 'Delivery latitude (defaults to current Blinkit browser location)' },
+    { name: 'lon', help: 'Delivery longitude (defaults to current Blinkit browser location)' },
+  ],
+  columns: ['status', 'productId', 'quantity', 'itemCount', 'itemsTotal', 'payable', 'message'],
+  func: async (page, kwargs) => {
+    const productId = requireProductId(kwargs.productId);
+    const quantity = parseQuantity(kwargs.quantity);
+
+    await page.goto(`https://blinkit.com/prn/x/prid/${productId}`).catch((error) => {
+      throw new CommandExecutionError(`blinkit add-to-cart navigation failed: ${error?.message || error}`);
+    });
+    const { lat, lon } = await resolveCoordinates(page, kwargs);
+    const found = await page.evaluate(buildCartItemEvaluate(productId, lat, lon)).catch((error) => {
+      throw new CommandExecutionError(`blinkit add-to-cart product read failed: ${error?.message || error}`);
+    });
+    const [foundOk, , cartItem, , soldOut] = Array.isArray(found) ? found : [];
+    if (!foundOk || !cartItem) throw new EmptyResultError('blinkit add-to-cart', `No cart payload for product ${productId}`);
+    if (soldOut) throw new CommandExecutionError(`Product ${productId} is sold out`);
+
+    const updated = await page.evaluate(buildWriteCartEvaluate(cartItem, quantity)).catch((error) => {
+      throw new CommandExecutionError(`blinkit add-to-cart write failed: ${error?.message || error}`);
+    });
+    const [updatedOk, , updatedQuantity] = Array.isArray(updated) ? updated : [];
+    if (!updatedOk) throw new CommandExecutionError(`Could not add product ${productId} to cart`);
+
+    await openCartPanel(page);
+    const summary = summarizeCartResponse(await readCartState(page));
+    ensureCartHasItems(summary);
+    return [{
+      status: 'added',
+      productId,
+      quantity: updatedQuantity,
+      itemCount: summary.itemCount,
+      itemsTotal: summary.itemsTotal,
+      payable: summary.payable,
+      message: `Added ${quantity}`,
+    }];
+  },
+});
+
+export const __test__ = {
+  buildWriteCartEvaluate,
+};

package/clis/blinkit/auth.js

@@ -0,0 +1,99 @@
+import { AuthRequiredError, TimeoutError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { BASE, DOMAIN } from './utils.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 300;
+
+async function probeBlinkitIdentity(page) {
+  const probe = await page.evaluate(`
+    (() => {
+      const readJson = (key) => {
+        try { return JSON.parse(localStorage.getItem(key) || 'null'); } catch { return null; }
+      };
+      const state = window.__reduxStore__?.getState?.();
+      const auth = state?.data?.auth || readJson('auth') || {};
+      const user = state?.data?.user || readJson('user') || {};
+      const text = document.body.innerText || '';
+      if (!auth.accessToken && /^Login$/m.test(text)) return { kind: 'auth', detail: 'Blinkit login button is still visible' };
+      if (!auth.accessToken) return { kind: 'auth', detail: 'Blinkit auth access token missing' };
+      return {
+        ok: true,
+        phone: auth.phoneNumber || user.phone || user.profile?.phone || '',
+        user_id: user.id || user.user_id || user.profile?.id || ''
+      };
+    })()
+  `);
+  if (probe?.kind === 'auth') throw new AuthRequiredError(DOMAIN, probe.detail);
+  return { phone: probe?.phone || '', user_id: probe?.user_id || '' };
+}
+
+function buildOpenLoginEvaluate() {
+  return `
+    (() => {
+      const readJson = (key) => {
+        try { return JSON.parse(localStorage.getItem(key) || 'null'); } catch { return null; }
+      };
+      const state = window.__reduxStore__?.getState?.();
+      const auth = state?.data?.auth || readJson('auth') || {};
+      if (auth.accessToken) return { opened: false, detail: 'already_logged_in' };
+
+      const dialogText = document.querySelector('[role="dialog"]')?.innerText || '';
+      if (/Enter mobile number|Log in or Sign up/i.test(dialogText)) {
+        return { opened: true, detail: 'login_dialog_visible' };
+      }
+
+      const target = Array.from(document.querySelectorAll('button, [role="button"], a, div'))
+        .find((node) => (node.innerText || node.textContent || '').trim() === 'Login');
+      target?.dispatchEvent?.(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+      return { opened: Boolean(target), detail: target ? 'clicked_login' : 'login_button_missing' };
+    })()
+  `;
+}
+
+cli({
+  site: 'blinkit',
+  name: 'login',
+  access: 'write',
+  description: 'Open Blinkit login and wait until the browser session is authenticated',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  args: [
+    { name: 'timeout', type: 'int', default: DEFAULT_TIMEOUT_SECONDS, help: 'Maximum seconds to wait for the user to finish login' },
+  ],
+  columns: ['status', 'logged_in', 'phone', 'user_id'],
+  func: async (page, kwargs) => {
+    await page.goto(BASE);
+    await page.wait(1);
+    try {
+      const identity = await probeBlinkitIdentity(page);
+      return [{ status: 'already_logged_in', logged_in: true, ...identity }];
+    } catch (error) {
+      if (!(error instanceof AuthRequiredError)) throw error;
+    }
+
+    const opened = await page.evaluate(buildOpenLoginEvaluate()).catch(() => null);
+    const timeoutSeconds = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    let lastMessage = opened?.opened ? '' : opened?.detail || '';
+    while (Date.now() < deadline) {
+      await page.wait(2);
+      try {
+        const identity = await probeBlinkitIdentity(page);
+        return [{ status: 'login_complete', logged_in: true, ...identity }];
+      } catch (error) {
+        if (!(error instanceof AuthRequiredError)) throw error;
+        lastMessage = error.message;
+      }
+    }
+    throw new TimeoutError('blinkit login', timeoutSeconds, lastMessage || 'Finish OTP login in the opened Blinkit tab and retry.');
+  },
+});
+
+export const __test__ = {
+  buildOpenLoginEvaluate,
+  probeBlinkitIdentity,
+};

package/clis/blinkit/blinkit.test.js

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError } from '@agentrhq/webcmd/errors';
+import { getRegistry } from '@agentrhq/webcmd/registry';
+import { __test__ as authTest } from './auth.js';
+import { __test__ as searchTest } from './search.js';
+import { __test__ as productTest } from './product.js';
+import { __test__ as addToCartTest } from './add-to-cart.js';
+import { __test__ as placeOrderTest } from './place-order.js';
+import { normalizeLocationState, resolveCoordinates } from './utils.js';
+import './cart.js';
+import './checkout.js';
+import './location.js';
+
+describe('blinkit helpers', () => {
+  it('rejects invalid external args before browser work', () => {
+    expect(() => searchTest.parseLimit(0)).toThrow(ArgumentError);
+    expect(() => searchTest.parseLimit(49)).toThrow(ArgumentError);
+    expect(() => searchTest.parseCoordinate('91', 'lat', '28.413333')).toThrow(ArgumentError);
+    expect(() => searchTest.parseCoordinate('181', 'lon', '77.072833')).toThrow(ArgumentError);
+  });
+
+  it('normalizes product snippets from Blinkit layout search', () => {
+    const row = searchTest.normalizeSnippet({
+      widget_type: 'product_card_snippet_type_2',
+      data: {
+        identity: { id: '19512' },
+        name: { text: 'Amul Taaza Toned Milk' },
+        brand_name: { text: 'Amul' },
+        variant: { text: '500 ml' },
+        normal_price: { text: '₹30' },
+        inventory: 12,
+        merchant_id: '31719',
+        eta_tag: { title: { text: 'earliest' } },
+        image: { url: 'https://cdn.grofers.com/product.png' },
+      },
+    }, 1);
+
+    expect(row).toMatchObject({
+      rank: 1,
+      productId: '19512',
+      name: 'Amul Taaza Toned Milk',
+      brand: 'Amul',
+      variant: '500 ml',
+      price: 30,
+      currency: 'INR',
+      inventory: 12,
+      available: true,
+      url: 'https://blinkit.com/prn/x/prid/19512',
+    });
+  });
+
+  it('normalizes product detail snippets', () => {
+    const row = productTest.normalizeProduct([
+      { widget_type: 'text_right_icons_rating_snippet_type', data: { title: { text: 'Amul Taaza Toned Milk' } } },
+      {
+        widget_type: 'product_atc_strip',
+        data: {
+          identity: { id: '19512' },
+          variant: { text: '500 ml' },
+          normal_price: { text: '₹30' },
+          product_id: '19512',
+          stepper_data_v2: {
+            increment_actions: {
+              default: [{ add_to_cart: { cart_item: { product_id: 19512, product_name: 'Amul Taaza Toned Milk', price: 30, mrp: 30, unit: '500 ml' } } }],
+            },
+          },
+        },
+      },
+    ], '19512');
+    expect(row).toMatchObject({ productId: '19512', name: 'Amul Taaza Toned Milk', price: 30 });
+  });
+
+  it('keeps place-order no-op unless --confirm is passed', async () => {
+    const command = getRegistry().get('blinkit/place-order');
+    const fakePage = { goto: () => { throw new Error('should not navigate'); } };
+    await expect(command.func(fakePage, {})).resolves.toMatchObject([{ status: 'no-op', confirmed: false }]);
+  });
+
+  it('builds the cart write script from product payload', () => {
+    const script = addToCartTest.buildWriteCartEvaluate({ product_id: 19512, price: 30, mrp: 30, unit: '500 ml' }, 2);
+    expect(script).toContain('localStorage.setItem');
+    expect(script).toContain('SYNC_CART');
+  });
+
+  it('opens the Blinkit login dialog before waiting for OTP', () => {
+    const script = authTest.buildOpenLoginEvaluate();
+    expect(script).toContain('Login');
+    expect(script).toContain('click');
+    expect(script).toContain('Enter mobile number');
+  });
+
+  it('uses the current Blinkit browser location when coordinates are not explicit', async () => {
+    const page = {
+      evaluate: async () => ({ lat: 12.9110953, lon: 77.6292907 }),
+    };
+
+    await expect(resolveCoordinates(page, {})).resolves.toEqual({ lat: '12.9110953', lon: '77.6292907' });
+    await expect(resolveCoordinates(page, { lat: '1', lon: '2' })).resolves.toEqual({ lat: '1', lon: '2' });
+  });
+
+  it('normalizes selected location without leaking exact address or coordinates', () => {
+    expect(normalizeLocationState({
+      address: 'Block C-03 / 79, Private Building',
+      city: 'Bengaluru',
+      locality: 'HSR Layout',
+      pinCode: '560102',
+      coords: { lat: 12.9110953, lon: 77.6292907 },
+    })).toEqual({
+      selected: true,
+      label: '',
+      area: 'HSR Layout',
+      city: 'Bengaluru',
+      pincode: '560102',
+      hasCoordinates: true,
+      source: 'browser',
+    });
+  });
+
+  it('reports empty checkout instead of failing before items are added', async () => {
+    const command = getRegistry().get('blinkit/checkout');
+    let readCartState = false;
+    const fakePage = {
+      goto: async () => {},
+      wait: async () => {},
+      evaluate: async (script) => {
+        if (script.includes('loggedIn')) {
+          readCartState = true;
+          return {
+            ok: true,
+            loggedIn: true,
+            storedCart: { items: {}, count: 0, total: 0, cart_state: 'valid' },
+          };
+        }
+        if (script.includes('cartResponse')) return false;
+        return true;
+      },
+    };
+
+    await expect(command.func(fakePage, {})).resolves.toMatchObject([{ status: 'empty', itemCount: 0 }]);
+    expect(readCartState).toBe(true);
+  });
+});
+
+describe('blinkit registry shape', () => {
+  it('registers the buying-path commands', () => {
+    for (const name of ['login', 'location', 'search', 'product', 'add-to-cart', 'cart', 'checkout', 'place-order']) {
+      expect(getRegistry().get(`blinkit/${name}`)).toBeDefined();
+    }
+  });
+
+  it('marks only cart-changing commands as write', () => {
+    expect(getRegistry().get('blinkit/search').access).toBe('read');
+    expect(getRegistry().get('blinkit/product').access).toBe('read');
+    expect(getRegistry().get('blinkit/location').access).toBe('read');
+    expect(getRegistry().get('blinkit/cart').access).toBe('read');
+    expect(getRegistry().get('blinkit/checkout').access).toBe('read');
+    expect(getRegistry().get('blinkit/login').access).toBe('write');
+    expect(getRegistry().get('blinkit/add-to-cart').access).toBe('write');
+    expect(getRegistry().get('blinkit/place-order').access).toBe('write');
+  });
+
+  it('place-order script only targets final order/payment buttons', () => {
+    const script = placeOrderTest.buildPlaceOrderEvaluate();
+    expect(script).toContain('place order');
+    expect(script).toContain('cash on delivery');
+    expect(script).not.toContain('Proceed');
+  });
+});

package/clis/blinkit/cart.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { DOMAIN, openCartPanel, readCartState, summarizeCartResponse } from './utils.js';
+
+cli({
+  site: 'blinkit',
+  name: 'cart',
+  access: 'read',
+  description: 'Show the current Blinkit cart',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [],
+  columns: ['status', 'productId', 'name', 'variant', 'price', 'quantity', 'total', 'itemCount', 'payable', 'cartState'],
+  func: async (page) => {
+    await openCartPanel(page);
+    const summary = summarizeCartResponse(await readCartState(page));
+    if (!summary.items.length) {
+      return [{ status: 'empty', itemCount: 0, payable: summary.payable, cartState: summary.cartState }];
+    }
+    return summary.items.map((item) => ({
+      status: summary.status,
+      productId: item.productId,
+      name: item.name,
+      variant: item.variant,
+      price: item.price,
+      quantity: item.quantity,
+      total: item.total,
+      itemCount: summary.itemCount,
+      payable: summary.payable,
+      cartState: summary.cartState,
+    }));
+  },
+});

package/clis/blinkit/checkout.js

@@ -0,0 +1,32 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { DOMAIN, openCartPanel, readCartState, summarizeCartResponse } from './utils.js';
+
+cli({
+  site: 'blinkit',
+  name: 'checkout',
+  access: 'read',
+  description: 'Review Blinkit checkout totals and blockers without placing an order',
+  domain: DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  args: [],
+  columns: ['status', 'itemCount', 'itemsTotal', 'deliveryCharge', 'handlingCharge', 'payable', 'cartState', 'checkoutBlocked', 'validations'],
+  func: async (page) => {
+    await openCartPanel(page);
+    const state = await readCartState(page);
+    const summary = summarizeCartResponse(state);
+    return [{
+      status: state.loggedIn ? summary.status : 'login_required',
+      itemCount: summary.itemCount,
+      itemsTotal: summary.itemsTotal,
+      deliveryCharge: summary.deliveryCharge,
+      handlingCharge: summary.handlingCharge,
+      payable: summary.payable,
+      cartState: summary.cartState,
+      checkoutBlocked: summary.checkoutBlocked,
+      validations: summary.validations,
+    }];
+  },
+});