Update src/app/api/action/route.ts

src/app/api/action/route.ts

@@ -1,76 +1,127 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getPage, navigateTo } from "@/lib/browser";
 
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type ActionPayload = {
+  type?:
+    | "click"
+    | "type"
+    | "scroll"
+    | "navigate"
+    | "keypress"
+    | "hover"
+    | "answer"
+    | "wait";
+  description?: string;
+  x?: number;
+  y?: number;
+  text?: string;
+  key?: string;
+  url?: string;
+  scrollX?: number;
+  scrollY?: number;
+  ms?: number;
+};
+
+function normalizeUrl(input: string): string {
+  const value = (input || "").trim();
+  if (!value) throw new Error("URL is required");
+  if (/^https?:\/\//i.test(value)) return value;
+  return `https://${value}`;
+}
+
 export async function POST(req: NextRequest) {
   try {
-    const action = await req.json();
+    const action = (await req.json()) as ActionPayload;
     const page = getPage();
 
     if (!page) {
       return NextResponse.json(
-        { error: "No active browser session. Click Launch first." },
+        { error: "No active browser session. Launch the browser first." },
         { status: 400 }
       );
     }
 
     switch (action.type) {
       case "click": {
+        if (typeof action.x !== "number" || typeof action.y !== "number") {
+          throw new Error("Click action requires numeric x and y");
+        }
+
         await page.mouse.click(action.x, action.y);
-        await page
-          .waitForLoadState("domcontentloaded", { timeout: 8_000 })
-          .catch(() => {});
+        await page.waitForLoadState("domcontentloaded", { timeout: 5000 }).catch(() => {});
+        await page.waitForTimeout(500);
         break;
       }
 
       case "type": {
-        if (action.x !== undefined && action.y !== undefined) {
+        if (typeof action.x === "number" && typeof action.y === "number") {
           await page.mouse.click(action.x, action.y);
-          await new Promise((r) => setTimeout(r, 150));
+          await page.waitForTimeout(150);
         }
+
         await page.keyboard.type(action.text || "", { delay: 25 });
+        await page.waitForTimeout(300);
         break;
       }
 
       case "keypress": {
         await page.keyboard.press(action.key || "Enter");
-        await page
-          .waitForLoadState("domcontentloaded", { timeout: 8_000 })
-          .catch(() => {});
+        await page.waitForLoadState("domcontentloaded", { timeout: 5000 }).catch(() => {});
+        await page.waitForTimeout(400);
         break;
       }
 
       case "scroll": {
         await page.mouse.wheel(action.scrollX || 0, action.scrollY || 300);
-        await new Promise((r) => setTimeout(r, 300));
+        await page.waitForTimeout(400);
         break;
       }
 
       case "navigate": {
-        // Use the layered navigateTo helper instead of bare page.goto
-        await navigateTo(action.url);
+        const targetUrl = normalizeUrl(action.url || "");
+        await navigateTo(targetUrl);
         break;
       }
 
       case "hover": {
-        await page.mouse.move(action.x || 0, action.y || 0);
+        if (typeof action.x !== "number" || typeof action.y !== "number") {
+          throw new Error("Hover action requires numeric x and y");
+        }
+
+        await page.mouse.move(action.x, action.y);
+        await page.waitForTimeout(250);
         break;
       }
 
       case "wait": {
-        await new Promise((r) =>
-          setTimeout(r, Math.min(action.ms || 1000, 5000))
-        );
+        const ms = Math.min(Math.max(action.ms || 1000, 100), 10000);
+        await page.waitForTimeout(ms);
         break;
       }
 
-      default:
+      case "answer": {
+        // No browser action needed; handled client-side
         break;
+      }
+
+      default:
+        return NextResponse.json(
+          { error: "Unsupported action type" },
+          { status: 400 }
+        );
     }
 
-    return NextResponse.json({ success: true });
+    return NextResponse.json({
+      success: true,
+      action: action.type,
+    });
   } catch (e: unknown) {
-    const msg = e instanceof Error ? e.message : "Unknown error";
-    console.error("[/api/action]", msg);
-    return NextResponse.json({ error: msg }, { status: 500 });
+    const message = e instanceof Error ? e.message : "Unknown error";
+    console.error("[/api/action]", message);
+
+    return NextResponse.json({ error: message }, { status: 500 });
   }
 }