@agentrhq/webcmd 0.2.2 → 0.2.4

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

package/clis/practo/contact.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { normalizePracticeDoctorId, practoJson } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'contact',
+  access: 'read',
+  description: 'Get Practo virtual contact number for a practice_doctor_id',
+  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 from search results' }],
+  columns: ['practice_doctor_id', 'phone', 'raw'],
+  func: async (page, kwargs) => {
+    const id = normalizePracticeDoctorId(kwargs.practice_doctor_id);
+    const data = await practoJson(page, `/health/api/vn/vnpractice?practice_doctor_id=${id}`);
+    const phone = data?.phone_number || data?.phone || data?.number || data?.data?.phone_number || '';
+    return [{ practice_doctor_id: id, phone, raw: phone ? '' : JSON.stringify(data).slice(0, 500) }];
+  },
+});

package/clis/practo/login.js

@@ -0,0 +1,48 @@
+import { AuthRequiredError, TimeoutError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { PRACTO, probeIdentity } from './utils.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 300;
+
+function isAuthRequired(error) {
+  return error instanceof AuthRequiredError;
+}
+
+cli({
+  site: 'practo',
+  name: 'login',
+  access: 'write',
+  description: 'Open Practo login and wait until the browser session is authenticated',
+  domain: 'www.practo.com',
+  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', 'site', 'name'],
+  func: async (page, kwargs) => {
+    try {
+      const rows = await probeIdentity(page);
+      return [{ status: 'already_logged_in', ...rows[0] }];
+    } catch (error) {
+      if (!isAuthRequired(error)) throw error;
+    }
+
+    await page.goto(`${PRACTO}/login`, { waitUntil: 'none', settleMs: 1500 });
+    const timeout = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
+    const deadline = Date.now() + timeout * 1000;
+    while (Date.now() < deadline) {
+      await page.wait(2);
+      try {
+        const rows = await probeIdentity(page);
+        return [{ status: 'login_complete', ...rows[0] }];
+      } catch (error) {
+        if (!isAuthRequired(error)) throw error;
+      }
+    }
+    throw new TimeoutError('practo login', timeout, 'Complete Practo login in the browser, then retry.');
+  },
+});

package/clis/practo/practo.test.js

@@ -0,0 +1,154 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@agentrhq/webcmd/errors';
+import { getRegistry } from '@agentrhq/webcmd/registry';
+import './appointment.js';
+import './appointments.js';
+import './book-confirm.js';
+import './book-preview.js';
+import './booking-link.js';
+import './cancel.js';
+import './contact.js';
+import './login.js';
+import './profile.js';
+import './search.js';
+import './slots.js';
+import './whoami.js';
+import { __test__ } from './utils.js';
+
+const {
+  buildSearchUrl,
+  buildBookingUrl,
+  normalizeConfirm,
+  normalizeLimit,
+  normalizePracticeDoctorId,
+  normalizeSlotTime,
+  rowsFromSearchState,
+  rowsFromSlotsPayload,
+} = __test__;
+
+describe('practo helpers', () => {
+  it('builds city/specialty search URLs', () => {
+    expect(buildSearchUrl({ city: 'Bangalore', specialty: 'Orthopedist' })).toBe('https://www.practo.com/bangalore/orthopedist');
+    expect(buildSearchUrl({ city: 'New Delhi', specialty: 'Dentist', locality: 'South Extension' })).toBe('https://www.practo.com/new-delhi/dentist/south-extension');
+  });
+
+  it('validates identity, limits, slot times, and confirmations', () => {
+    expect(normalizePracticeDoctorId('859054')).toBe('859054');
+    expect(normalizeLimit('3')).toBe(3);
+    expect(normalizeSlotTime('2026-07-10 10:30:00')).toBe('2026-07-10 10:30:00');
+    expect(normalizeConfirm(true)).toBe(true);
+    expect(normalizeConfirm('true')).toBe(true);
+    expect(() => normalizePracticeDoctorId('abc')).toThrow(ArgumentError);
+    expect(() => normalizeLimit(0)).toThrow(ArgumentError);
+    expect(() => normalizeSlotTime('tomorrow')).toThrow(ArgumentError);
+  });
+
+  it('maps listing redux doctors into stable search rows', () => {
+    const rows = rowsFromSearchState({
+      listingV2: {
+        doctors: {
+          entities: {
+            1: {
+              id: 859054,
+              doctor_id: 1056089,
+              practice_id: 776696,
+              doctor_name: 'Dr. Nithin Patel',
+              specialization: 'Orthopedist',
+              experience_years: 12,
+              locality: 'Koramangala',
+              city: 'Bangalore',
+              practice: { name: 'Practo Clinic' },
+              consultation_fees: 1000,
+              profile_url: '/bangalore/doctor/dr-nithin-patel-orthopedist',
+              next_available_timestamp: '2026-07-10T10:30:00+05:30',
+            },
+          },
+        },
+      },
+    }, 1);
+    expect(rows).toEqual([{
+      rank: 1,
+      practice_doctor_id: '859054',
+      doctor_id: '1056089',
+      practice_id: '776696',
+      name: 'Dr. Nithin Patel',
+      specialty: 'Orthopedist',
+      experience_years: 12,
+      locality: 'Koramangala',
+      city: 'Bangalore',
+      clinic: 'Practo Clinic',
+      fee: 1000,
+      next_available: '2026-07-10T10:30:00+05:30',
+      profile_url: 'https://www.practo.com/bangalore/doctor/dr-nithin-patel-orthopedist',
+    }]);
+  });
+
+  it('maps slot payloads into rows and booking URLs', () => {
+    const rows = rowsFromSlotsPayload({
+      practice_doctor_id: 859054,
+      amount: 1000,
+      prepaid: false,
+      appointment_token: 'abc',
+      slots: [{
+        datestamp: '2026-07-10',
+        slots: [{ time: '10:00', timeslots: [{ ts: '2026-07-10 10:30:00', available: true }] }],
+      }],
+    });
+    expect(rows).toEqual([{
+      practice_doctor_id: '859054',
+      time: '2026-07-10 10:30:00',
+      available: true,
+      amount: 1000,
+      prepaid: false,
+      appointment_token: 'abc',
+    }]);
+    expect(buildBookingUrl({ practiceDoctorId: '859054', slotTime: rows[0].time, appointmentToken: 'abc', amount: 1000, prepaid: false }))
+      .toContain('/appointment/doctor/859054/book?');
+  });
+});
+
+describe('practo command registry', () => {
+  it('registers the approved command surface', () => {
+    for (const name of ['whoami', 'login', 'search', 'profile', 'slots', 'contact', 'booking-link', 'appointments', 'appointment', 'book-preview', 'book-confirm', 'cancel']) {
+      expect(getRegistry().get(`practo/${name}`)).toBeDefined();
+    }
+    expect(getRegistry().get('practo/auth-status')).toBe(getRegistry().get('practo/whoami'));
+  });
+
+  it('marks writes as explicit confirm commands', () => {
+    const book = getRegistry().get('practo/book-confirm');
+    const cancel = getRegistry().get('practo/cancel');
+    expect(book.access).toBe('write');
+    expect(cancel.access).toBe('write');
+    expect(book.args.find((arg) => arg.name === 'confirm')?.type).toBe('boolean');
+    expect(cancel.args.find((arg) => arg.name === 'confirm')?.type).toBe('boolean');
+  });
+
+  it('waits for manual login to complete', async () => {
+    const login = getRegistry().get('practo/login');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ __error: 'HTTP 401', status: 401 })
+        .mockResolvedValueOnce({ name: 'Ada' }),
+    };
+
+    await expect(login.func(page, { timeout: 1 })).resolves.toEqual([{
+      status: 'login_complete',
+      logged_in: true,
+      site: 'practo',
+      name: 'Ada',
+    }]);
+  });
+
+  it('refuses real booking without --confirm true', async () => {
+    const book = getRegistry().get('practo/book-confirm');
+    await expect(book.func({}, { practice_doctor_id: '859054', time: '2026-07-10 10:30:00' })).rejects.toThrow(ArgumentError);
+  });
+
+  it('refuses cancellation without --confirm true', async () => {
+    const cancel = getRegistry().get('practo/cancel');
+    await expect(cancel.func({}, { appointment_id: 'abc' })).rejects.toThrow(ArgumentError);
+  });
+});

package/clis/practo/profile.js

@@ -0,0 +1,31 @@
+import { EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { PRACTO, unwrapBrowserResult } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'profile',
+  access: 'read',
+  description: 'Read public details from a Practo doctor profile URL',
+  domain: 'www.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [{ name: 'url', positional: true, required: true, help: 'Practo doctor profile URL' }],
+  columns: ['name', 'specialty', 'experience', 'fee', 'profile_url'],
+  func: async (page, kwargs) => {
+    const url = new URL(String(kwargs.url), PRACTO).toString();
+    await page.goto(url);
+    await page.wait(2);
+    const row = unwrapBrowserResult(await page.evaluate(`(() => {
+      const text = document.body?.innerText || '';
+      const title = document.querySelector('h1')?.textContent?.trim() || document.title.replace(/ - Practo.*/, '').trim();
+      const specialty = (text.match(/(Orthopedist|Dentist|Dermatologist|Gynecologist|Pediatrician|General Physician|Cardiologist)/i) || [,''])[1];
+      const experience = (text.match(/(\\d+\\s+Years? Experience)/i) || [,''])[1];
+      const fee = (text.match(/(?:₹|Rs\\.?\\s*)([0-9,]+)/i) || [,''])[1];
+      return { name: title, specialty, experience, fee: fee ? Number(fee.replace(/,/g, '')) : '', profile_url: location.href };
+    })()`));
+    if (!row?.name) throw new EmptyResultError('practo profile');
+    return [row];
+  },
+});

package/clis/practo/search.js

@@ -0,0 +1,30 @@
+import { EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { buildSearchUrl, normalizeLimit, rowsFromSearchState, unwrapBrowserResult } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'search',
+  access: 'read',
+  description: 'Search Practo doctors by specialty, city, and optional locality',
+  domain: 'www.practo.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'specialty', positional: true, required: true, help: 'Doctor specialty, e.g. orthopedist or dermatologist' },
+    { name: 'city', default: 'bangalore', help: 'City, e.g. bangalore' },
+    { name: 'locality', help: 'Optional locality, e.g. indiranagar' },
+    { name: 'limit', type: 'int', default: 10, help: 'Max doctors to return (1-25)' },
+  ],
+  columns: ['rank', 'practice_doctor_id', 'doctor_id', 'practice_id', 'name', 'specialty', 'experience_years', 'locality', 'clinic', 'fee', 'next_available', 'profile_url'],
+  func: async (page, kwargs) => {
+    const limit = normalizeLimit(kwargs.limit);
+    await page.goto(buildSearchUrl(kwargs));
+    await page.wait(2);
+    const state = unwrapBrowserResult(await page.evaluate(`(() => window.__REDUX_STATE__ || window.__PRELOADED_STATE__ || null)()`));
+    const rows = rowsFromSearchState(state, limit);
+    if (rows.length === 0) throw new EmptyResultError('practo search', 'No doctor cards were found in Practo page state.');
+    return rows;
+  },
+});

package/clis/practo/slots.js

@@ -0,0 +1,19 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { normalizeLimit, rowsForSlots } from './utils.js';
+
+cli({
+  site: 'practo',
+  name: 'slots',
+  access: 'read',
+  description: 'List available Practo appointment slots for a practice_doctor_id',
+  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 from search results' },
+    { name: 'limit', type: 'int', default: 20, help: 'Max slots to return (1-25)' },
+  ],
+  columns: ['practice_doctor_id', 'time', 'available', 'amount', 'prepaid', 'appointment_token'],
+  func: async (page, kwargs) => (await rowsForSlots(page, kwargs.practice_doctor_id)).filter((row) => row.available).slice(0, normalizeLimit(kwargs.limit, 20)),
+});