@vellumai/assistant 0.4.11 → 0.4.13

package/src/config/bundled-skills/doordash/doordash-cli.ts

@@ -0,0 +1,1193 @@
+/**
+ * CLI command group: `vellum doordash`
+ *
+ * Order food from DoorDash via the command line.
+ * All commands output JSON to stdout. Use --json for machine-readable output.
+ */
+
+import * as net from "node:net";
+
+import { Command } from "commander";
+
+import {
+  addToCart,
+  getDropoffOptions,
+  getItemDetails,
+  getPaymentMethods,
+  getStoreMenu,
+  listCarts,
+  placeOrder,
+  removeFromCart,
+  retailSearch,
+  search,
+  searchItems,
+  SessionExpiredError,
+  viewCart,
+} from "./lib/client.js";
+import { extractQueries, saveQueries } from "./lib/query-extractor.js";
+import {
+  clearSession,
+  importFromRecording,
+  loadSession,
+} from "./lib/session.js";
+import { createMessageParser, serialize } from "./lib/shared/ipc.js";
+import { NetworkRecorder } from "./lib/shared/network-recorder.js";
+import { getSocketPath, readSessionToken } from "./lib/shared/platform.js";
+import { loadRecording, saveRecording } from "./lib/shared/recording-store.js";
+import type { SessionRecording } from "./lib/shared/recording-types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function output(data: unknown, json: boolean): void {
+  process.stdout.write(
+    json ? JSON.stringify(data) + "\n" : JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function outputError(message: string, code = 1): void {
+  output({ ok: false, error: message }, true);
+  process.exitCode = code;
+}
+
+function getJson(cmd: Command): boolean {
+  let c: Command | null = cmd;
+  while (c) {
+    if ((c.opts() as { json?: boolean }).json) return true;
+    c = c.parent;
+  }
+  return false;
+}
+
+const SESSION_EXPIRED_MSG =
+  "Your DoorDash session has expired. Please sign in to DoorDash in Chrome — " +
+  "the assistant will use Ride Shotgun to capture your session automatically.";
+
+async function run(cmd: Command, fn: () => Promise<unknown>): Promise<void> {
+  try {
+    const result = await fn();
+    output({ ok: true, ...(result as Record<string, unknown>) }, getJson(cmd));
+  } catch (err) {
+    if (err instanceof SessionExpiredError) {
+      output(
+        { ok: false, error: "session_expired", message: SESSION_EXPIRED_MSG },
+        getJson(cmd),
+      );
+      process.exitCode = 1;
+      return;
+    }
+    outputError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+export function registerDoordashCommand(program: Command): void {
+  const dd = program
+    .command("doordash")
+    .description(
+      "Order food from DoorDash. Requires a session imported from a Ride Shotgun recording.",
+    )
+    .option("--json", "Machine-readable JSON output");
+
+  // =========================================================================
+  // login — import session from a recording
+  // =========================================================================
+  dd.command("login")
+    .description("Import a DoorDash session from a Ride Shotgun recording")
+    .requiredOption("--recording <path>", "Path to the recording JSON file")
+    .action(async (opts: { recording: string }, cmd: Command) => {
+      await run(cmd, async () => {
+        const session = importFromRecording(opts.recording);
+        return {
+          message: "Session imported successfully",
+          cookieCount: session.cookies.length,
+          recordingId: session.recordingId,
+        };
+      });
+    });
+
+  // =========================================================================
+  // logout — clear saved session
+  // =========================================================================
+  dd.command("logout")
+    .description("Clear the saved DoorDash session")
+    .action((_opts: unknown, cmd: Command) => {
+      clearSession();
+      output({ ok: true, message: "Session cleared" }, getJson(cmd));
+    });
+
+  // =========================================================================
+  // refresh — start Ride Shotgun learn to capture fresh cookies
+  // =========================================================================
+  dd.command("refresh")
+    .description(
+      "Start a Ride Shotgun learn session to capture fresh DoorDash cookies. " +
+        "Opens doordash.com in a separate Chrome window — sign in when prompted. " +
+        "Your existing Chrome and tabs are not affected.",
+    )
+    .option("--duration <seconds>", "Recording duration in seconds", "180")
+    .action(async (opts: { duration: string }, cmd: Command) => {
+      const json = getJson(cmd);
+      const duration = parseInt(opts.duration, 10);
+
+      try {
+        // Restore minimized Chrome window so user can see the login page
+        try {
+          await restoreChromeWindow();
+        } catch {
+          /* best-effort */
+        }
+
+        const result = await startLearnSession(duration);
+        if (result.recordingPath) {
+          const session = importFromRecording(result.recordingPath);
+
+          // Also extract and save captured queries for self-healing
+          let queriesCaptured = 0;
+          try {
+            const recording = loadRecording(result.recordingId ?? "");
+            if (recording) {
+              const queries = extractQueries(recording);
+              if (queries.length > 0) {
+                saveQueries(queries);
+                queriesCaptured = queries.length;
+              }
+            }
+          } catch {
+            // Non-fatal: query extraction is best-effort
+          }
+
+          // Best-effort: minimize Chrome window after capturing session
+          try {
+            await minimizeChromeWindow();
+            process.stderr.write("[doordash] Chrome window minimized\n");
+          } catch {
+            // Non-fatal: minimizing is best-effort
+          }
+
+          output(
+            {
+              ok: true,
+              message: "Session refreshed successfully",
+              cookieCount: session.cookies.length,
+              recordingId: result.recordingId,
+              queriesCaptured,
+            },
+            json,
+          );
+        } else {
+          output(
+            {
+              ok: false,
+              error: "Recording completed but no recording path returned",
+              recordingId: result.recordingId,
+            },
+            json,
+          );
+          process.exitCode = 1;
+        }
+      } catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+      }
+    });
+
+  // =========================================================================
+  // record — standalone CDP network recording
+  // =========================================================================
+  dd.command("record")
+    .description(
+      "Record DoorDash network traffic via CDP. " +
+        "Opens Chrome with CDP debugging, captures GraphQL operations, " +
+        "and saves captured queries for self-healing API support.",
+    )
+    .option("--duration <seconds>", "Max recording duration in seconds", "120")
+    .option(
+      "--stop-on <operationName>",
+      "Auto-stop when this GraphQL operation is captured (e.g. addCartItem)",
+    )
+    .action(
+      async (opts: { duration: string; stopOn?: string }, cmd: Command) => {
+        const json = getJson(cmd);
+        const duration = parseInt(opts.duration, 10);
+
+        try {
+          await ensureChromeWithCDP();
+
+          const startTime = Date.now() / 1000;
+          const recorder = new NetworkRecorder("doordash.com");
+          await recorder.startDirect("http://localhost:9222");
+
+          process.stderr.write("Recording DoorDash network traffic...\n");
+          if (opts.stopOn) {
+            process.stderr.write(
+              `Will auto-stop when "${opts.stopOn}" operation is detected.\n`,
+            );
+          }
+          process.stderr.write(
+            `Timeout: ${duration}s. Press Ctrl+C to stop early.\n`,
+          );
+
+          const finishRecording = async () => {
+            process.stderr.write("\nStopping recording...\n");
+            const cookies = await recorder.extractCookies("doordash.com");
+            const entries = await recorder.stop();
+
+            const recording: SessionRecording = {
+              id: crypto.randomUUID(),
+              startedAt: startTime,
+              endedAt: Date.now() / 1000,
+              targetDomain: "doordash.com",
+              networkEntries: entries,
+              cookies,
+              observations: [],
+            };
+
+            const recordingPath = saveRecording(recording);
+
+            // Extract and save queries
+            const queries = extractQueries(recording);
+            let queriesPath: string | undefined;
+            if (queries.length > 0) {
+              queriesPath = saveQueries(queries);
+            }
+
+            process.stderr.write(`\nRecording saved: ${recordingPath}\n`);
+            process.stderr.write(`Network entries: ${entries.length}\n`);
+            process.stderr.write(
+              `GraphQL operations captured: ${queries.length}\n`,
+            );
+            if (queries.length > 0) {
+              process.stderr.write("Operations:\n");
+              for (const q of queries) {
+                const varsKeys =
+                  q.exampleVariables && typeof q.exampleVariables === "object"
+                    ? Object.keys(
+                        q.exampleVariables as Record<string, unknown>,
+                      ).join(", ")
+                    : "(none)";
+                process.stderr.write(
+                  `  - ${q.operationName} [vars: ${varsKeys}]\n`,
+                );
+              }
+              process.stderr.write(`Queries saved: ${queriesPath}\n`);
+            }
+
+            output(
+              {
+                ok: true,
+                recordingId: recording.id,
+                recordingPath,
+                networkEntries: entries.length,
+                queriesCaptured: queries.length,
+                operations: queries.map((q) => q.operationName),
+                queriesPath,
+              },
+              json,
+            );
+          };
+
+          await new Promise<void>((resolve) => {
+            let poll: ReturnType<typeof setInterval> | undefined;
+
+            // Timeout
+            const timer = setTimeout(() => {
+              if (poll) clearInterval(poll);
+              process.stderr.write(`\nTimeout reached (${duration}s).\n`);
+              resolve();
+            }, duration * 1000);
+
+            // Ctrl+C
+            process.on("SIGINT", () => {
+              if (poll) clearInterval(poll);
+              clearTimeout(timer);
+              resolve();
+            });
+
+            // --stop-on: poll entries for the target operation
+            if (opts.stopOn) {
+              const target = opts.stopOn;
+              poll = setInterval(() => {
+                const entries = recorder.getEntries();
+                const found = entries.some((e) => {
+                  if (!e.request.postData) return false;
+                  try {
+                    const body = JSON.parse(e.request.postData) as {
+                      operationName?: string;
+                    };
+                    return body.operationName === target;
+                  } catch {
+                    return false;
+                  }
+                });
+                if (found) {
+                  clearInterval(poll);
+                  clearTimeout(timer);
+                  process.stderr.write(`\nDetected "${target}" operation.\n`);
+                  // Small delay to let the response come back
+                  setTimeout(() => resolve(), 3000);
+                }
+              }, 500);
+            }
+          });
+
+          await finishRecording();
+        } catch (err) {
+          outputError(err instanceof Error ? err.message : String(err));
+        }
+      },
+    );
+
+  // =========================================================================
+  // inspect — inspect a recording's GraphQL operations
+  // =========================================================================
+  dd.command("inspect")
+    .description("Inspect GraphQL operations in a recording")
+    .argument("<recordingId>", "Recording ID or path to recording JSON file")
+    .option("--op <operationName>", "Filter to a specific operation name")
+    .option(
+      "--extract-options",
+      "Extract item customization options from updateCartItem operations",
+    )
+    .action(
+      async (
+        recordingIdOrPath: string,
+        opts: { op?: string; extractOptions?: boolean },
+        cmd: Command,
+      ) => {
+        const json = getJson(cmd);
+
+        try {
+          let recording: SessionRecording | null = null;
+
+          // Try as path first, then as recording ID
+          if (
+            recordingIdOrPath.includes("/") ||
+            recordingIdOrPath.endsWith(".json")
+          ) {
+            try {
+              const { readFileSync } = await import("node:fs");
+              recording = JSON.parse(
+                readFileSync(recordingIdOrPath, "utf-8"),
+              ) as SessionRecording;
+            } catch {
+              // Fall through to try as ID
+            }
+          }
+          if (!recording) {
+            recording = loadRecording(recordingIdOrPath);
+          }
+
+          if (!recording) {
+            outputError(`Recording not found: ${recordingIdOrPath}`);
+            return;
+          }
+
+          const queries = extractQueries(recording);
+
+          if (opts.extractOptions) {
+            const cartOps = queries.filter(
+              (q) => q.operationName === "updateCartItem",
+            );
+            if (cartOps.length === 0) {
+              outputError(
+                "No updateCartItem operations found in this recording",
+              );
+              return;
+            }
+
+            const extracted = cartOps.map((q) => {
+              const vars = (q.exampleVariables ?? {}) as Record<
+                string,
+                unknown
+              >;
+              const params = (vars.updateCartItemApiParams ?? {}) as Record<
+                string,
+                unknown
+              >;
+              return {
+                itemId: params.itemId as string | undefined,
+                itemName: params.itemName as string | undefined,
+                nestedOptions: params.nestedOptions as string | undefined,
+                specialInstructions: params.specialInstructions as
+                  | string
+                  | undefined,
+                unitPrice: params.unitPrice as number | undefined,
+                menuId: params.menuId as string | undefined,
+                storeId: params.storeId as string | undefined,
+              };
+            });
+
+            if (json) {
+              output(
+                { ok: true, items: extracted, count: extracted.length },
+                true,
+              );
+            } else {
+              for (const item of extracted) {
+                process.stderr.write(
+                  `\nItem: ${item.itemName ?? "unknown"} (${item.itemId ?? "?"})\n`,
+                );
+                process.stderr.write(
+                  `  Store: ${item.storeId ?? "?"}, Menu: ${item.menuId ?? "?"}\n`,
+                );
+                process.stderr.write(
+                  `  Unit Price: ${item.unitPrice ?? "?"}\n`,
+                );
+                if (item.specialInstructions) {
+                  process.stderr.write(
+                    `  Special Instructions: ${item.specialInstructions}\n`,
+                  );
+                }
+                process.stderr.write(
+                  `  Options: ${item.nestedOptions ?? "[]"}\n`,
+                );
+              }
+            }
+            return;
+          }
+
+          if (opts.op) {
+            const match = queries.find((q) => q.operationName === opts.op);
+            if (!match) {
+              outputError(
+                `Operation "${opts.op}" not found. Available: ${queries.map((q) => q.operationName).join(", ")}`,
+              );
+              return;
+            }
+
+            if (json) {
+              output({ ok: true, operation: match }, true);
+            } else {
+              process.stderr.write(`Operation: ${match.operationName}\n`);
+              process.stderr.write(
+                `Captured at: ${new Date(match.capturedAt * 1000).toISOString()}\n\n`,
+              );
+              process.stderr.write("--- Query ---\n");
+              process.stderr.write(match.query + "\n\n");
+              process.stderr.write("--- Variables ---\n");
+              process.stderr.write(
+                JSON.stringify(match.exampleVariables, null, 2) + "\n",
+              );
+            }
+          } else {
+            if (json) {
+              output(
+                { ok: true, operations: queries, count: queries.length },
+                true,
+              );
+            } else {
+              process.stderr.write(`Recording: ${recording.id}\n`);
+              process.stderr.write(
+                `Total network entries: ${recording.networkEntries.length}\n`,
+              );
+              process.stderr.write(`GraphQL operations: ${queries.length}\n\n`);
+
+              for (const q of queries) {
+                const varsKeys =
+                  q.exampleVariables && typeof q.exampleVariables === "object"
+                    ? Object.keys(
+                        q.exampleVariables as Record<string, unknown>,
+                      ).join(", ")
+                    : "(none)";
+                process.stderr.write(`  ${q.operationName}\n`);
+                process.stderr.write(`    Variables: ${varsKeys}\n`);
+                process.stderr.write(
+                  `    Captured: ${new Date(q.capturedAt * 1000).toISOString()}\n`,
+                );
+              }
+            }
+          }
+        } catch (err) {
+          outputError(err instanceof Error ? err.message : String(err));
+        }
+      },
+    );
+
+  // =========================================================================
+  // status — check session status
+  // =========================================================================
+  dd.command("status")
+    .description("Check if a DoorDash session is active")
+    .action((_opts: unknown, cmd: Command) => {
+      const session = loadSession();
+      if (session) {
+        output(
+          {
+            ok: true,
+            loggedIn: true,
+            cookieCount: session.cookies.length,
+            importedAt: session.importedAt,
+            recordingId: session.recordingId,
+          },
+          getJson(cmd),
+        );
+      } else {
+        output({ ok: true, loggedIn: false }, getJson(cmd));
+      }
+    });
+
+  // =========================================================================
+  // search — search for restaurants/stores
+  // =========================================================================
+  dd.command("search")
+    .description("Search for restaurants on DoorDash")
+    .argument("<query>", 'Search query (e.g. "pizza", "thai food")')
+    .action(async (query: string, _opts: unknown, cmd: Command) => {
+      await run(cmd, async () => {
+        const results = await search(query);
+        return { results, count: results.length };
+      });
+    });
+
+  // =========================================================================
+  // store-search — search for items within a specific retail/convenience store
+  // =========================================================================
+  dd.command("store-search")
+    .description(
+      "Search for items within a specific store (best for convenience/pharmacy stores)",
+    )
+    .argument("<storeId>", "DoorDash store ID")
+    .argument("<query>", 'Search query (e.g. "tylenol", "advil")')
+    .option("--limit <n>", "Max results", "30")
+    .action(
+      async (
+        storeId: string,
+        query: string,
+        opts: { limit: string },
+        cmd: Command,
+      ) => {
+        await run(cmd, async () => {
+          const result = await retailSearch(storeId, query, {
+            limit: parseInt(opts.limit, 10),
+          });
+          return result;
+        });
+      },
+    );
+
+  // =========================================================================
+  // search-items — search for items across all stores (works for convenience/retail)
+  // =========================================================================
+  dd.command("search-items")
+    .description(
+      "Search for items across all stores (works for convenience/retail stores)",
+    )
+    .argument("<query>", 'Search query (e.g. "tylenol", "advil")')
+    .option("--debug", "Print raw response to stderr")
+    .action(async (query: string, opts: { debug?: boolean }, cmd: Command) => {
+      await run(cmd, async () => {
+        const results = await searchItems(query, { debug: opts.debug });
+        return { results, count: results.length };
+      });
+    });
+
+  // =========================================================================
+  // menu — get a store's menu
+  // =========================================================================
+  dd.command("menu")
+    .description("Get a restaurant's menu by store ID")
+    .argument("<storeId>", "DoorDash store ID")
+    .option("--menu-id <menuId>", "Specific menu ID (optional)")
+    .option("--debug", "Print raw response structure to stderr")
+    .action(
+      async (
+        storeId: string,
+        opts: { menuId?: string; debug?: boolean },
+        cmd: Command,
+      ) => {
+        await run(cmd, async () => {
+          const store = await getStoreMenu(storeId, opts.menuId, {
+            debug: opts.debug,
+          });
+          return { store };
+        });
+      },
+    );
+
+  // =========================================================================
+  // item — get item details
+  // =========================================================================
+  dd.command("item")
+    .description("Get details for a specific menu item")
+    .argument("<storeId>", "DoorDash store ID")
+    .argument("<itemId>", "Menu item ID")
+    .action(
+      async (storeId: string, itemId: string, _opts: unknown, cmd: Command) => {
+        await run(cmd, async () => {
+          const item = await getItemDetails(storeId, itemId);
+          return { item };
+        });
+      },
+    );
+
+  // =========================================================================
+  // cart — cart operations (subcommand group)
+  // =========================================================================
+  const cart = dd.command("cart").description("Cart operations");
+
+  // cart add
+  cart
+    .command("add")
+    .description("Add an item to your cart")
+    .requiredOption("--store-id <storeId>", "Store ID")
+    .requiredOption("--menu-id <menuId>", "Menu ID")
+    .requiredOption("--item-id <itemId>", "Item ID")
+    .requiredOption("--item-name <name>", "Item name")
+    .requiredOption("--unit-price <cents>", "Unit price in cents")
+    .option("--quantity <n>", "Quantity", "1")
+    .option("--cart-id <cartId>", "Existing cart ID (creates new if omitted)")
+    .option("--special-instructions <text>", "Special instructions")
+    .option(
+      "--options <json>",
+      "Item customization options as JSON array (from item details or recording)",
+    )
+    .action(
+      async (
+        opts: {
+          storeId: string;
+          menuId: string;
+          itemId: string;
+          itemName: string;
+          unitPrice: string;
+          quantity: string;
+          cartId?: string;
+          specialInstructions?: string;
+          options?: string;
+        },
+        cmd: Command,
+      ) => {
+        await run(cmd, async () => {
+          const result = await addToCart({
+            storeId: opts.storeId,
+            menuId: opts.menuId,
+            itemId: opts.itemId,
+            itemName: opts.itemName,
+            unitPrice: parseInt(opts.unitPrice, 10),
+            quantity: parseInt(opts.quantity, 10),
+            cartId: opts.cartId,
+            specialInstructions: opts.specialInstructions,
+            nestedOptions: opts.options,
+          });
+          return { cart: result };
+        });
+      },
+    );
+
+  // cart remove
+  cart
+    .command("remove")
+    .description("Remove an item from your cart")
+    .requiredOption("--cart-id <cartId>", "Cart ID")
+    .requiredOption("--item-id <itemId>", "Order item ID (from cart view)")
+    .action(async (opts: { cartId: string; itemId: string }, cmd: Command) => {
+      await run(cmd, async () => {
+        const result = await removeFromCart(opts.cartId, opts.itemId);
+        return { cart: result };
+      });
+    });
+
+  // cart view
+  cart
+    .command("view")
+    .description("View cart contents")
+    .argument("<cartId>", "Cart ID")
+    .action(async (cartId: string, _opts: unknown, cmd: Command) => {
+      await run(cmd, async () => {
+        const result = await viewCart(cartId);
+        return { cart: result };
+      });
+    });
+
+  // cart list
+  cart
+    .command("list")
+    .description("List all active carts")
+    .option("--store-id <storeId>", "Filter by store ID")
+    .action(async (opts: { storeId?: string }, cmd: Command) => {
+      await run(cmd, async () => {
+        const carts = await listCarts(opts.storeId);
+        return { carts, count: carts.length };
+      });
+    });
+
+  // cart learn — capture customization options via CDP recording
+  cart
+    .command("learn")
+    .description(
+      "Learn item customization options by recording a browser interaction. " +
+        "Opens Chrome and watches you customize an item — when you add it to cart, " +
+        "the nestedOptions and specialInstructions are extracted and output.",
+    )
+    .option("--duration <seconds>", "Max recording duration in seconds", "120")
+    .action(async (opts: { duration: string }, cmd: Command) => {
+      const json = getJson(cmd);
+      const duration = parseInt(opts.duration, 10);
+
+      try {
+        await ensureChromeWithCDP();
+
+        const startTime = Date.now() / 1000;
+        const recorder = new NetworkRecorder("doordash.com");
+        await recorder.startDirect("http://localhost:9222");
+
+        process.stderr.write(
+          "Recording... Navigate to an item, customize it, and add it to cart.\n",
+        );
+        process.stderr.write(
+          `Will auto-stop when "updateCartItem" is detected. Timeout: ${duration}s.\n`,
+        );
+
+        await new Promise<void>((resolve) => {
+          const timer = setTimeout(() => {
+            if (poll) clearInterval(poll);
+            process.stderr.write(`\nTimeout reached (${duration}s).\n`);
+            resolve();
+          }, duration * 1000);
+
+          process.on("SIGINT", () => {
+            if (poll) clearInterval(poll);
+            clearTimeout(timer);
+            resolve();
+          });
+
+          const poll = setInterval(() => {
+            const entries = recorder.getEntries();
+            const found = entries.some((e) => {
+              if (!e.request.postData) return false;
+              try {
+                const body = JSON.parse(e.request.postData) as {
+                  operationName?: string;
+                };
+                return body.operationName === "updateCartItem";
+              } catch {
+                return false;
+              }
+            });
+            if (found) {
+              clearInterval(poll);
+              clearTimeout(timer);
+              process.stderr.write('\nDetected "updateCartItem" operation.\n');
+              setTimeout(() => resolve(), 3000);
+            }
+          }, 500);
+        });
+
+        process.stderr.write("Stopping recording...\n");
+        const cookies = await recorder.extractCookies("doordash.com");
+        const entries = await recorder.stop();
+
+        const recording: SessionRecording = {
+          id: crypto.randomUUID(),
+          startedAt: startTime,
+          endedAt: Date.now() / 1000,
+          targetDomain: "doordash.com",
+          networkEntries: entries,
+          cookies,
+          observations: [],
+        };
+
+        // Extract updateCartItem operations
+        const queries = extractQueries(recording);
+        const cartOps = queries.filter(
+          (q) => q.operationName === "updateCartItem",
+        );
+
+        if (cartOps.length === 0) {
+          outputError(
+            "No updateCartItem operations captured. Did you add an item to cart?",
+          );
+          return;
+        }
+
+        const extracted = cartOps.map((q) => {
+          const vars = (q.exampleVariables ?? {}) as Record<string, unknown>;
+          const params = (vars.updateCartItemApiParams ?? {}) as Record<
+            string,
+            unknown
+          >;
+          return {
+            itemId: params.itemId as string | undefined,
+            itemName: params.itemName as string | undefined,
+            nestedOptions: params.nestedOptions as string | undefined,
+            specialInstructions: params.specialInstructions as
+              | string
+              | undefined,
+            unitPrice: params.unitPrice as number | undefined,
+            menuId: params.menuId as string | undefined,
+            storeId: params.storeId as string | undefined,
+          };
+        });
+
+        // Also save the recording for future reference
+        const recordingPath = saveRecording(recording);
+
+        output(
+          {
+            ok: true,
+            items: extracted,
+            count: extracted.length,
+            recordingId: recording.id,
+            recordingPath,
+          },
+          json,
+        );
+      } catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+      }
+    });
+
+  // =========================================================================
+  // checkout — get checkout / dropoff options
+  // =========================================================================
+  dd.command("checkout")
+    .description("Get delivery/dropoff options for a cart")
+    .argument("<cartId>", "Cart ID")
+    .option("--address-id <addressId>", "Delivery address ID")
+    .action(
+      async (cartId: string, opts: { addressId?: string }, cmd: Command) => {
+        await run(cmd, async () => {
+          const options = await getDropoffOptions(cartId, opts.addressId);
+          return { dropoffOptions: options };
+        });
+      },
+    );
+
+  // =========================================================================
+  // order — order operations (subcommand group)
+  // =========================================================================
+  const order = dd.command("order").description("Order operations");
+
+  // order place
+  order
+    .command("place")
+    .description("Place an order from a cart")
+    .requiredOption("--cart-id <cartId>", "Cart ID")
+    .requiredOption("--store-id <storeId>", "Store ID")
+    .requiredOption("--total <cents>", "Order total in cents")
+    .option("--tip <cents>", "Tip amount in cents", "0")
+    .option("--delivery-option <type>", "Delivery option type", "STANDARD")
+    .option(
+      "--dropoff-option <id>",
+      "Dropoff option ID (from checkout command)",
+    )
+    .option(
+      "--payment-uuid <uuid>",
+      "Payment method UUID (uses default if omitted)",
+    )
+    .option("--payment-type <type>", "Payment method type", "Card")
+    .action(
+      async (
+        opts: {
+          cartId: string;
+          storeId: string;
+          total: string;
+          tip: string;
+          deliveryOption: string;
+          dropoffOption?: string;
+          paymentUuid?: string;
+          paymentType: string;
+        },
+        cmd: Command,
+      ) => {
+        await run(cmd, async () => {
+          const result = await placeOrder({
+            cartId: opts.cartId,
+            storeId: opts.storeId,
+            total: parseInt(opts.total, 10),
+            tipAmount: parseInt(opts.tip, 10),
+            deliveryOptionType: opts.deliveryOption,
+            dropoffOptionId: opts.dropoffOption,
+            paymentMethodUuid: opts.paymentUuid,
+            paymentMethodType: opts.paymentType,
+          });
+          return { order: result };
+        });
+      },
+    );
+
+  // =========================================================================
+  // payment-methods — list saved payment methods
+  // =========================================================================
+  dd.command("payment-methods")
+    .description("List saved payment methods")
+    .action(async (_opts: unknown, cmd: Command) => {
+      await run(cmd, async () => {
+        const methods = await getPaymentMethods();
+        return { methods, count: methods.length };
+      });
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Chrome CDP restart helper
+// ---------------------------------------------------------------------------
+
+import { spawn as spawnChild } from "node:child_process";
+import { homedir } from "node:os";
+import { join as pathJoin } from "node:path";
+
+const CDP_BASE = "http://localhost:9222";
+const CHROME_DATA_DIR = pathJoin(
+  homedir(),
+  "Library/Application Support/Google/Chrome-CDP",
+);
+
+async function isCdpReady(): Promise<boolean> {
+  try {
+    const res = await fetch(`${CDP_BASE}/json/version`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureChromeWithCDP(): Promise<void> {
+  // Already running with CDP?
+  if (await isCdpReady()) return;
+
+  // Launch a separate Chrome instance with CDP flags alongside any existing Chrome.
+  // Using a dedicated --user-data-dir allows coexistence without killing the user's browser.
+  const chromeApp =
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+  spawnChild(
+    chromeApp,
+    [
+      `--remote-debugging-port=9222`,
+      `--force-renderer-accessibility`,
+      `--user-data-dir=${CHROME_DATA_DIR}`,
+      `https://www.doordash.com/consumer/login/`,
+    ],
+    {
+      detached: true,
+      stdio: "ignore",
+    },
+  ).unref();
+
+  // Wait for CDP to be ready
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (await isCdpReady()) return;
+  }
+  throw new Error("Chrome started but CDP endpoint not responding after 15s");
+}
+
+async function minimizeChromeWindow(): Promise<void> {
+  const res = await fetch(`${CDP_BASE}/json/list`);
+  const targets = (await res.json()) as Array<{
+    type: string;
+    webSocketDebuggerUrl: string;
+  }>;
+  const pageTarget = targets.find((t) => t.type === "page");
+  if (!pageTarget) return;
+
+  const ws = new WebSocket(pageTarget.webSocketDebuggerUrl);
+
+  await new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error("CDP minimize timed out"));
+    }, 5000);
+
+    ws.addEventListener("open", () => {
+      ws.send(JSON.stringify({ id: 1, method: "Browser.getWindowForTarget" }));
+    });
+
+    ws.addEventListener("message", (event) => {
+      const msg = JSON.parse(String(event.data)) as {
+        id: number;
+        result?: { windowId: number };
+      };
+      if (msg.id === 1 && msg.result) {
+        ws.send(
+          JSON.stringify({
+            id: 2,
+            method: "Browser.setWindowBounds",
+            params: {
+              windowId: msg.result.windowId,
+              bounds: { windowState: "minimized" },
+            },
+          }),
+        );
+      } else if (msg.id === 1) {
+        clearTimeout(timeout);
+        ws.close();
+        reject(new Error("Browser.getWindowForTarget failed"));
+      } else if (msg.id === 2) {
+        clearTimeout(timeout);
+        ws.close();
+        resolve();
+      }
+    });
+
+    ws.addEventListener("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+async function restoreChromeWindow(): Promise<void> {
+  const res = await fetch(`${CDP_BASE}/json/list`);
+  const targets = (await res.json()) as Array<{
+    type: string;
+    webSocketDebuggerUrl: string;
+  }>;
+  const pageTarget = targets.find((t) => t.type === "page");
+  if (!pageTarget) return;
+
+  const ws = new WebSocket(pageTarget.webSocketDebuggerUrl);
+
+  await new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error("CDP restore timed out"));
+    }, 5000);
+
+    ws.addEventListener("open", () => {
+      ws.send(JSON.stringify({ id: 1, method: "Browser.getWindowForTarget" }));
+    });
+
+    ws.addEventListener("message", (event) => {
+      const msg = JSON.parse(String(event.data)) as {
+        id: number;
+        result?: { windowId: number };
+      };
+      if (msg.id === 1 && msg.result) {
+        ws.send(
+          JSON.stringify({
+            id: 2,
+            method: "Browser.setWindowBounds",
+            params: {
+              windowId: msg.result.windowId,
+              bounds: { windowState: "normal" },
+            },
+          }),
+        );
+      } else if (msg.id === 1) {
+        clearTimeout(timeout);
+        ws.close();
+        reject(new Error("Browser.getWindowForTarget failed"));
+      } else if (msg.id === 2) {
+        clearTimeout(timeout);
+        ws.close();
+        resolve();
+      }
+    });
+
+    ws.addEventListener("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Ride Shotgun learn session helper
+// ---------------------------------------------------------------------------
+
+interface LearnResult {
+  recordingId?: string;
+  recordingPath?: string;
+}
+
+async function startLearnSession(
+  durationSeconds: number,
+): Promise<LearnResult> {
+  // Step 1: Ensure Chrome is running with CDP
+  await ensureChromeWithCDP();
+
+  // Step 2: Connect to daemon and start recording
+  return new Promise((resolve, reject) => {
+    const socketPath = getSocketPath();
+    const sessionToken = readSessionToken();
+    const socket = net.createConnection(socketPath);
+    const parser = createMessageParser();
+
+    socket.on("error", (err) => {
+      reject(
+        new Error(
+          `Cannot connect to daemon: ${err.message}. Is the daemon running?`,
+        ),
+      );
+    });
+
+    // Timeout safety — unref so it doesn't keep process alive
+    const timeoutHandle = setTimeout(
+      () => {
+        socket.destroy();
+        reject(
+          new Error(`Learn session timed out after ${durationSeconds + 30}s`),
+        );
+      },
+      (durationSeconds + 30) * 1000,
+    );
+    timeoutHandle.unref();
+
+    let authenticated = !sessionToken; // If no token needed, consider already authenticated
+
+    const sendStartCommand = () => {
+      socket.write(
+        serialize({
+          type: "ride_shotgun_start",
+          durationSeconds,
+          intervalSeconds: 5,
+          mode: "learn",
+          targetDomain: "doordash.com",
+        } as Record<string, unknown>),
+      );
+    };
+
+    socket.on("data", (chunk) => {
+      const messages = parser.feed(chunk.toString("utf-8"));
+      for (const msg of messages) {
+        const m = msg as unknown as Record<string, unknown>;
+
+        // Handle auth handshake
+        if (!authenticated && m.type === "auth_result") {
+          if ((m as { success: boolean }).success) {
+            authenticated = true;
+            sendStartCommand();
+          } else {
+            clearTimeout(timeoutHandle);
+            socket.destroy();
+            reject(new Error("Daemon authentication failed"));
+          }
+          continue;
+        }
+
+        // Skip duplicate auth_result after already authenticated
+        if (m.type === "auth_result") {
+          continue;
+        }
+
+        if (m.type === "ride_shotgun_result") {
+          clearTimeout(timeoutHandle);
+          socket.destroy();
+          resolve({
+            recordingId: m.recordingId as string | undefined,
+            recordingPath: m.recordingPath as string | undefined,
+          });
+        }
+      }
+    });
+
+    socket.on("connect", () => {
+      if (sessionToken) {
+        // Send auth and wait for auth_result before sending the command
+        socket.write(
+          serialize({
+            type: "auth",
+            token: sessionToken,
+          } as Record<string, unknown>),
+        );
+      } else {
+        // No auth needed, send command immediately
+        sendStartCommand();
+      }
+    });
+  });
+}