oc-browser-relay 1.0.3 → 1.0.5

package/bundled-relay/index.js

@@ -4976,8 +4976,8 @@ var require_raw_body = __commonJS({
           type: "entity.too.large"
         }));
       }
-      var state2 = stream._readableState;
-      if (stream._decoder || state2 && (state2.encoding || state2.decoder)) {
+      var state = stream._readableState;
+      if (stream._decoder || state && (state.encoding || state.decoder)) {
         return done(createError(500, "stream encoding should not be set", {
           type: "stream.encoding.set"
         }));
@@ -22629,6 +22629,7 @@ var ERROR_CODES = {
   // 步骤类
   ERR_INVALID_STEP: "ERR_INVALID_STEP",
   ERR_STEP_EXECUTION_FAILED: "ERR_STEP_EXECUTION_FAILED",
+  ERR_STEP_TIMEOUT: "ERR_STEP_TIMEOUT",
   // Runtime 类
   ERR_RUNTIME_NOT_AVAILABLE: "ERR_RUNTIME_NOT_AVAILABLE",
   ERR_RUNTIME_BUSY: "ERR_RUNTIME_BUSY",
@@ -22726,46 +22727,6 @@ var FileService = class {
   }
 };
 
-// relay/src/cdp-bridge/index.ts
-import { chromium } from "playwright-core";
-var state = null;
-async function connectToChrome(port = 9222) {
-  const cdpUrl = `http://127.0.0.1:${port}`;
-  console.log(`[CDP] Connecting to Chrome via CDP at ${cdpUrl}`);
-  const browser = await chromium.connectOverCDP(cdpUrl);
-  const contexts = browser.contexts();
-  const context = contexts[0] ?? await browser.newContext();
-  state = { browser, context };
-  console.log("[CDP] Connected to Chrome via CDP \u2713");
-  return state;
-}
-async function getActivePage(context) {
-  const pages = context.pages();
-  if (pages.length === 0) {
-    return await context.newPage();
-  }
-  return pages[pages.length - 1];
-}
-var CDPController = class {
-  constructor(cdpPort = 9222) {
-    this.cdpPort = cdpPort;
-  }
-  async ensureConnected() {
-    if (!state || !state.browser.isConnected()) {
-      return await connectToChrome(this.cdpPort);
-    }
-    return state;
-  }
-  async snapshot() {
-    const { context } = await this.ensureConnected();
-    const page = await getActivePage(context);
-    return await page.content();
-  }
-  isConnected() {
-    return state !== null && state.browser.isConnected();
-  }
-};
-
 // relay/src/workspace-service/index.ts
 import * as crypto2 from "crypto";
 import * as fs2 from "fs";
@@ -23275,6 +23236,7 @@ function mapTaskStatusToCurrentNodeStatus(status) {
 function mapToolNameToTaskOperation(tool) {
   switch (tool) {
     case "open_tab":
+    case "close_tab":
     case "ensure_publish_ready":
       return "navigate";
     case "fill_field":
@@ -23285,6 +23247,10 @@ function mapToolNameToTaskOperation(tool) {
     case "switch_tab":
     case "apply_search_filters":
       return "click";
+    case "present_page_activity":
+      return "unknown";
+    case "invoke_page_request":
+      return "extract_api_payload";
     case "collect_search_list":
     case "collect_search_item_details":
     case "collect_structured_data":
@@ -23339,6 +23305,8 @@ function buildTaskStatusView(input) {
     capability: input.capability,
     currentOperation: input.currentOperation,
     progress,
+    lastProgressAt: input.lastProgressAt,
+    lastProgress: input.lastProgress ?? null,
     currentNode,
     browsingContext: input.browsingContext,
     captureWindow: input.captureWindow,
@@ -23520,6 +23488,8 @@ function applyTaskStatusView(task, overrides) {
     } : void 0,
     captureWindow,
     lastArtifact: overrides?.lastArtifact ?? task.statusView?.lastArtifact,
+    lastProgressAt: overrides?.lastProgressAt ?? task.statusView?.lastProgressAt,
+    lastProgress: overrides?.lastProgress ?? task.statusView?.lastProgress,
     progressHint: overrides?.progressHint
   });
 }
@@ -23613,6 +23583,107 @@ function applyArtifactCreatedToTask(task, payload) {
     lastArtifact: payload.artifact
   });
 }
+function applyStepProgressToTask(task, payload) {
+  task.currentNodeId = payload.stepId;
+  task.updatedAt = payload.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
+  applyTaskStatusView(task, {
+    currentNodeId: payload.stepId,
+    currentNodeTool: payload.tool,
+    currentOperation: mapToolNameToTaskOperation(payload.tool),
+    lastProgressAt: payload.updatedAt,
+    lastProgress: payload.details ?? null,
+    progressHint: payload.details?.progressHint ?? payload.details?.message
+  });
+}
+
+// relay/src/step-watchdog.ts
+var StepWatchdogRegistry = class {
+  constructor(onExpired) {
+    this.onExpired = onExpired;
+    this.pending = /* @__PURE__ */ new Map();
+  }
+  start(input) {
+    const existing = this.pending.get(input.taskId);
+    const preservedStartedAt = existing && existing.stepId === input.stepId ? existing.startedAt : void 0;
+    this.clear(input.taskId);
+    const startedAt = preservedStartedAt || input.startedAt || (/* @__PURE__ */ new Date()).toISOString();
+    const lastProgressAt = input.lastProgressAt || startedAt;
+    const deadlineAt = new Date(new Date(lastProgressAt).getTime() + input.timeoutMs).toISOString();
+    const entry = {
+      taskId: input.taskId,
+      stepId: input.stepId,
+      tool: input.tool,
+      timeoutMs: input.timeoutMs,
+      startedAt,
+      lastProgressAt,
+      deadlineAt,
+      lastProgress: input.lastProgress,
+      timer: null
+    };
+    entry.timer = this.createTimer(entry);
+    this.pending.set(input.taskId, entry);
+  }
+  progress(input) {
+    const existing = this.pending.get(input.taskId);
+    if (!existing || existing.stepId !== input.stepId) {
+      return;
+    }
+    clearTimeout(existing.timer);
+    existing.tool = input.tool ?? existing.tool;
+    existing.lastProgressAt = input.updatedAt;
+    existing.deadlineAt = new Date(new Date(input.updatedAt).getTime() + existing.timeoutMs).toISOString();
+    existing.lastProgress = input.details;
+    existing.timer = this.createTimer(existing);
+  }
+  clear(taskId, stepId) {
+    const existing = this.pending.get(taskId);
+    if (!existing) {
+      return;
+    }
+    if (stepId && existing.stepId !== stepId) {
+      return;
+    }
+    clearTimeout(existing.timer);
+    this.pending.delete(taskId);
+  }
+  get(taskId) {
+    const entry = this.pending.get(taskId);
+    if (!entry) {
+      return null;
+    }
+    return {
+      taskId: entry.taskId,
+      stepId: entry.stepId,
+      tool: entry.tool,
+      timeoutMs: entry.timeoutMs,
+      startedAt: entry.startedAt,
+      lastProgressAt: entry.lastProgressAt,
+      deadlineAt: entry.deadlineAt,
+      lastProgress: entry.lastProgress
+    };
+  }
+  createTimer(entry) {
+    const timer = setTimeout(() => {
+      const current = this.pending.get(entry.taskId);
+      if (!current || current !== entry) {
+        return;
+      }
+      this.pending.delete(entry.taskId);
+      this.onExpired({
+        taskId: current.taskId,
+        stepId: current.stepId,
+        tool: current.tool,
+        timeoutMs: current.timeoutMs,
+        startedAt: current.startedAt,
+        lastProgressAt: current.lastProgressAt,
+        deadlineAt: current.deadlineAt,
+        lastProgress: current.lastProgress
+      });
+    }, entry.timeoutMs);
+    timer.unref?.();
+    return timer;
+  }
+};
 
 // relay/src/task-ready-registry.ts
 var TaskReadyRegistry = class {
@@ -23826,7 +23897,10 @@ function resolveFallbackStepIndex(task, currentStepIndex, result) {
 }
 
 // relay/src/task-node-result.ts
-function mapNodeResultToExecutionStatus(result) {
+function resolveNodeExecutionStatusFromResult(result) {
+  if (result.ok && result?.observation?.skipped === true) {
+    return "skipped";
+  }
   return result.ok ? "success" : "failed";
 }
 function normalizeNodeResult(result, normalizedError) {
@@ -23841,7 +23915,7 @@ function persistNodeResultOnTask(task, result) {
   if (!matchedNode) {
     return false;
   }
-  updateNodeExecutionStatus(task, result.nodeId, mapNodeResultToExecutionStatus(result), {
+  updateNodeExecutionStatus(task, result.nodeId, resolveNodeExecutionStatusFromResult(result), {
     result,
     error: result.error
   });
@@ -24002,13 +24076,14 @@ function applyTaskExecutionResult(task, orchestrator, result) {
   } : null);
   const persistedNodeResult = normalizeNodeResult(result, normalizedNodeError);
   persistNodeResultOnTask(task, persistedNodeResult);
+  const executionStatus = resolveNodeExecutionStatusFromResult(persistedNodeResult);
   const fallbackStepIndex = resolveFallbackStepIndex(
     task,
     orchestrator.currentStepIndex,
     persistedNodeResult
   );
   task.status = result.ok || fallbackStepIndex != null ? "running" : "failed";
-  task.currentNodeId = result.nodeId;
+  task.currentNodeId = executionStatus === "skipped" ? void 0 : result.nodeId;
   task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   task.lastError = result.ok || fallbackStepIndex != null ? null : normalizedNodeError;
   return {
@@ -24024,7 +24099,6 @@ var app = (0, import_express.default)();
 var server = createServer(app);
 var PORT = process.env.PORT || DEFAULT_RELAY_PORT;
 var fileService = new FileService();
-var cdpController = new CDPController();
 var workspaceService = new WorkspaceService();
 var templateExecutor = new TemplateExecutor();
 var CLIENT_RECONNECT_GRACE_MS = 3e3;
@@ -24033,6 +24107,12 @@ var STEP_DISPATCH_INTERVAL_MS = Number(process.env.STEP_DISPATCH_INTERVAL_MS) ||
 var RUNTIME_ONLINE_GRACE_MS = 1e4;
 var RUNTIME_PRESENCE_TTL_MS = 5 * 60 * 1e3;
 var COMPLETED_TASK_TTL_MS = Number(process.env.COMPLETED_TASK_TTL_MS) || 60 * 60 * 1e3;
+var STEP_WATCHDOG_FALLBACK_TIMEOUT_MS = 6e4;
+var STEP_WATCHDOG_DEFAULT_TIMEOUTS = {
+  upload_assets: 18e4,
+  fill_field: 12e4,
+  collect_structured_data: 18e4
+};
 var runtimeConnections = /* @__PURE__ */ new Map();
 var runtimePresence = /* @__PURE__ */ new Map();
 var tasks = /* @__PURE__ */ new Map();
@@ -24046,6 +24126,9 @@ var taskReadyRegistry = new TaskReadyRegistry(
 );
 var taskTemplateCache = /* @__PURE__ */ new Map();
 var taskTemplateIndexCache = null;
+var stepWatchdogs = new StepWatchdogRegistry((entry) => {
+  handleStepTimeout(entry);
+});
 var RELAY_PROJECT_ROOT = process.env.CHROMEAGENT_RELAY_PROJECT_ROOT ? path3.resolve(process.env.CHROMEAGENT_RELAY_PROJECT_ROOT) : path3.resolve(path3.dirname(fileURLToPath(import.meta.url)), "..", "..");
 app.use((req, res, next) => {
   res.header("Access-Control-Allow-Origin", "*");
@@ -24070,6 +24153,17 @@ function createRelayError(message, code = ERROR_CODES.ERR_INVALID_TASK, status =
   error.status = status;
   return error;
 }
+function resolveStepWatchdogTimeoutMs(step) {
+  const explicitTimeoutMs = Number(step?.args?.timeoutMs);
+  if (Number.isFinite(explicitTimeoutMs) && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  const defaultTimeoutMs = step.tool ? STEP_WATCHDOG_DEFAULT_TIMEOUTS[step.tool] : void 0;
+  if (typeof defaultTimeoutMs === "number" && defaultTimeoutMs > 0) {
+    return defaultTimeoutMs;
+  }
+  return STEP_WATCHDOG_FALLBACK_TIMEOUT_MS;
+}
 function registerRuntimeConnection(clientId, res) {
   const existing = runtimeConnections.get(clientId);
   if (existing && existing.res !== res) {
@@ -24587,7 +24681,8 @@ async function startNextBatchItem(batchJobId) {
       message: error?.message || "Runtime not available"
     };
     updateTaskStatusView(task);
-    throw error;
+    console.error(`Batch task ${task.taskId} failed:`, error);
+    await handleBatchTaskTerminal(task.taskId, "failed", task.lastError);
   }
 }
 async function handleBatchTaskTerminal(taskId, status, lastError) {
@@ -24659,7 +24754,7 @@ async function registerAndDispatchTask(task) {
       message: error?.message || "Runtime not available"
     };
     updateTaskStatusView(task);
-    throw error;
+    console.error(`Task ${task.taskId} failed:`, error);
   }
   return task;
 }
@@ -24687,6 +24782,9 @@ async function handleRuntimeMessage(msg) {
     case "node.status":
       handleNodeStatus(msg);
       break;
+    case "step.progress":
+      handleStepProgress(msg);
+      break;
     case "capture.started":
       handleCaptureStarted(msg);
       break;
@@ -24739,6 +24837,24 @@ function handleNodeStarted(msg) {
   if (!task) {
     return;
   }
+  const existingWatchdog = stepWatchdogs.get(payload.taskId);
+  if (!existingWatchdog || existingWatchdog.stepId !== payload.nodeId) {
+    const orchestrator = orchestrators.get(payload.taskId);
+    const step = orchestrator ? resolveCurrentTaskExecutionStep(task, orchestrator) : null;
+    if (step && step.nodeId === payload.nodeId) {
+      const timeoutMs = resolveStepWatchdogTimeoutMs(step);
+      if (typeof timeoutMs === "number") {
+        stepWatchdogs.start({
+          taskId: payload.taskId,
+          stepId: payload.nodeId,
+          tool: payload.tool,
+          timeoutMs,
+          startedAt: payload.updatedAt,
+          lastProgressAt: payload.updatedAt
+        });
+      }
+    }
+  }
   task.currentNodeId = payload.nodeId;
   task.updatedAt = payload.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
   updateTaskNodeProcessView(task, {
@@ -24771,6 +24887,23 @@ function handleNodeStatus(msg) {
     message: payload.message
   });
 }
+function handleStepProgress(msg) {
+  const payload = msg.payload;
+  const task = tasks.get(payload.taskId);
+  if (!task) {
+    return;
+  }
+  stepWatchdogs.progress(payload);
+  task.currentNodeId = payload.stepId;
+  task.updatedAt = payload.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
+  if (typeof payload.details?.tabId === "number") {
+    task.currentTabId = payload.details.tabId;
+  }
+  if (typeof payload.details?.pageState === "string" && payload.details.pageState.length > 0) {
+    task.currentPageId = payload.details.pageState;
+  }
+  applyStepProgressToTask(task, payload);
+}
 function handleNodeResult(msg) {
   const rawResult = msg.payload;
   logRelayFlow("Received node result", {
@@ -24800,10 +24933,12 @@ function handleNodeResult(msg) {
   }
   const resolvedTask = task;
   const resolvedOrchestrator = orchestrator;
+  stepWatchdogs.clear(rawResult.taskId, rawResult.nodeId);
   const appliedResult = applyTaskExecutionResult(resolvedTask, resolvedOrchestrator, rawResult);
+  const executionStatus = resolvedTask.payload?.nodeResults?.[rawResult.nodeId]?.status;
   updateTaskStatusView(resolvedTask, {
-    currentNodeId: rawResult.nodeId,
-    currentNodeStatus: appliedResult.persistedNodeResult.ok ? "succeeded" : "failed"
+    currentNodeId: executionStatus === "skipped" ? void 0 : rawResult.nodeId,
+    currentNodeStatus: executionStatus === "skipped" ? "skipped" : appliedResult.persistedNodeResult.ok ? "succeeded" : "failed"
   });
   if (appliedResult.shouldContinue) {
     continueOrchestrator(rawResult.taskId, rawResult.nodeId, appliedResult.nextStepIndex ?? void 0);
@@ -24836,7 +24971,11 @@ function handleTaskStatus(msg) {
   task.lastTriggeredNavigation = status.lastTriggeredNavigation ?? task.lastTriggeredNavigation;
   task.browsingContexts = Array.isArray(status.browsingContexts) ? status.browsingContexts : task.browsingContexts;
   task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  task.statusView = status.statusView ?? task.statusView;
+  task.statusView = status.statusView ? {
+    ...status.statusView,
+    lastProgressAt: status.statusView.lastProgressAt ?? task.statusView?.lastProgressAt,
+    lastProgress: status.statusView.lastProgress ?? task.statusView?.lastProgress ?? null
+  } : task.statusView;
   if (!task.statusView) {
     updateTaskStatusView(task, {
       currentNodeId: status.currentNodeId
@@ -24845,15 +24984,18 @@ function handleTaskStatus(msg) {
   if (status.status === "queued") {
     resolveTaskReady(status.taskId);
   } else if (status.status === "failed") {
+    stepWatchdogs.clear(status.taskId);
     rejectTaskReady(status.taskId, task.lastError || createRelayError("Task failed before ready", ERROR_CODES.ERR_RUNTIME_NOT_AVAILABLE, 503));
     orchestrators.delete(status.taskId);
     notifyRuntimeTaskFinalized(task, "failed");
     void handleBatchTaskTerminal(status.taskId, "failed", task.lastError);
   } else if (status.status === "completed") {
+    stepWatchdogs.clear(status.taskId);
     rejectTaskReady(status.taskId, createRelayError("Task completed before orchestrator start", ERROR_CODES.ERR_TASK_TIMEOUT, 500));
     notifyRuntimeTaskFinalized(task, "completed");
     void handleBatchTaskTerminal(status.taskId, "completed", null);
   } else if (status.status === "cancelled") {
+    stepWatchdogs.clear(status.taskId);
     rejectTaskReady(status.taskId, createRelayError("Task cancelled before completion", ERROR_CODES.ERR_TASK_TIMEOUT, 499));
     orchestrators.delete(status.taskId);
     notifyRuntimeTaskFinalized(task, "cancelled");
@@ -25481,16 +25623,6 @@ app.get("/api/file/content/:fileId", async (req, res) => {
     res.status(500).json({ ok: false, error: { code: ERROR_CODES.ERR_FILE_PREPARE_FAILED, message: err.message } });
   }
 });
-app.post("/api/debug/snapshot", async (req, res) => {
-  try {
-    const { taskId } = req.body;
-    const task = tasks.get(taskId);
-    const snapshot = await cdpController.snapshot();
-    res.json({ ok: true, task, snapshot });
-  } catch (err) {
-    res.status(500).json({ ok: false, error: { code: ERROR_CODES.ERR_RUNTIME_NOT_AVAILABLE, message: err.message } });
-  }
-});
 app.get("/health", (req, res) => {
   res.json({ status: "ok", runtimes: runtimeConnections.size, tasks: tasks.size });
 });
@@ -25511,6 +25643,60 @@ function startOrchestrator(taskId) {
   orchestrators.set(taskId, orchestrator);
   void sendNextStep(taskId);
 }
+function handleStepTimeout(entry) {
+  const task = tasks.get(entry.taskId);
+  const orchestrator = orchestrators.get(entry.taskId);
+  if (!task || !orchestrator) {
+    return;
+  }
+  const currentStep = resolveCurrentTaskExecutionStep(task, orchestrator);
+  if (!currentStep || currentStep.nodeId !== entry.stepId) {
+    return;
+  }
+  const diagnosticReason = entry.lastProgress ? entry.lastProgress.phase === "wait_for_login" ? "waiting_login_stalled" : "progress_stalled" : "no_progress_reported";
+  const timeoutResult = {
+    type: "node.result",
+    taskId: entry.taskId,
+    nodeId: entry.stepId,
+    tool: entry.tool || currentStep.tool,
+    ok: false,
+    status: "failed",
+    observation: {
+      error: `Step timed out after ${entry.timeoutMs}ms without progress`,
+      code: ERROR_CODES.ERR_STEP_TIMEOUT,
+      executor: "relay_watchdog"
+    },
+    error: {
+      code: ERROR_CODES.ERR_STEP_TIMEOUT,
+      message: `Step timed out after ${entry.timeoutMs}ms without progress`,
+      details: {
+        timeoutAt: entry.deadlineAt,
+        startedAt: entry.startedAt,
+        lastProgressAt: entry.lastProgressAt,
+        timeoutMs: entry.timeoutMs,
+        tool: entry.tool || currentStep.tool,
+        stepId: entry.stepId,
+        currentTabId: task.currentTabId ?? null,
+        currentPageState: task.statusView?.lastProgress?.pageState ?? task.currentPageId ?? null,
+        diagnosticReason,
+        lastProgress: entry.lastProgress ?? null
+      }
+    },
+    timestamp: Date.now()
+  };
+  logRelayFlow("Step watchdog timed out", {
+    taskId: entry.taskId,
+    stepId: entry.stepId,
+    timeoutMs: entry.timeoutMs,
+    diagnosticReason
+  });
+  handleNodeResult({
+    type: "node.result",
+    requestId: null,
+    timestamp: Date.now(),
+    payload: timeoutResult
+  });
+}
 async function sendNextStep(taskId) {
   console.log(`[Relay] sendNextStep \u88AB\u8C03\u7528: ${taskId}`);
   const task = tasks.get(taskId);
@@ -25530,6 +25716,7 @@ async function sendNextStep(taskId) {
   }
   console.log(`[Relay] \u5F53\u524D\u8282\u70B9\u7D22\u5F15: ${orch.currentStepIndex}, \u603B\u8282\u70B9\u6570: ${executionLength}`);
   if (orch.currentStepIndex >= executionLength) {
+    stepWatchdogs.clear(taskId);
     task.status = "completed";
     task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     updateTaskStatusView(task, {
@@ -25543,6 +25730,7 @@ async function sendNextStep(taskId) {
   }
   const step = markTaskExecutionDispatch(task, orch);
   if (!step) {
+    stepWatchdogs.clear(taskId);
     task.status = "failed";
     task.lastError = {
       code: ERROR_CODES.ERR_INVALID_TASK,
@@ -25570,6 +25758,7 @@ async function sendNextStep(taskId) {
   try {
     targetRuntimeId = requireTaskRuntimeId(task);
   } catch (error) {
+    stepWatchdogs.clear(taskId);
     task.status = "failed";
     task.lastError = {
       code: error?.code || ERROR_CODES.ERR_RUNTIME_NOT_AVAILABLE,
@@ -25585,6 +25774,7 @@ async function sendNextStep(taskId) {
   }
   const sent = await sendToClientWithGracePeriod(targetRuntimeId, stepMessage);
   if (!sent) {
+    stepWatchdogs.clear(taskId);
     task.status = "failed";
     task.lastError = {
       code: ERROR_CODES.ERR_RUNTIME_NOT_AVAILABLE,
@@ -25598,6 +25788,18 @@ async function sendNextStep(taskId) {
     void handleBatchTaskTerminal(taskId, "failed", task.lastError);
     return;
   }
+  const watchdogTimeoutMs = resolveStepWatchdogTimeoutMs(step);
+  if (typeof watchdogTimeoutMs === "number") {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    stepWatchdogs.start({
+      taskId,
+      stepId: step.nodeId,
+      tool: step.tool,
+      timeoutMs: watchdogTimeoutMs,
+      startedAt,
+      lastProgressAt: startedAt
+    });
+  }
   console.log(`[Relay] Sent node ${orch.currentStepIndex + 1}/${executionLength} for task ${taskId}`);
 }
 function continueOrchestrator(taskId, completedNodeId, nextStepIndex) {

package/bundled-relay/package.json

@@ -3,8 +3,5 @@
   "private": true,
   "type": "module",
   "version": "1.0.0",
-  "description": "Bundled runtime dependencies for the oc-browser-relay OpenClaw plugin.",
-  "dependencies": {
-    "playwright-core": "^1.58.2"
-  }
+  "description": "Bundled runtime dependencies for the oc-browser-relay OpenClaw plugin."
 }

package/bundled-relay/public/configs/pages/sycm-taobao-home.json

@@ -95,6 +95,59 @@
       ]
     }
   },
+  "apiSources": {
+    "live_metrics_overview": {
+      "method": "GET",
+      "urlVariants": [
+        {
+          "whenPath": "payload.dateType",
+          "equals": "today",
+          "url": "https://sycm.taobao.com/portal/live/new/index/overview/v3.json"
+        },
+        {
+          "default": true,
+          "url": "https://sycm.taobao.com/portal/coreIndex/new/overview/v3.json"
+        }
+      ],
+      "query": {
+        "needCycleCrc": "true",
+        "dateType": "{{payload.dateType}}",
+        "dateRange": "{{payload.dateRange}}",
+        "_": "{{runtime.timestamp}}",
+        "token": "{{session.token}}"
+      },
+      "headers": {
+        "sycm-referer": "/portal/home.htm"
+      },
+      "responsePath": "content.data.data",
+      "metaPath": "content.data"
+    },
+    "live_metrics_trend": {
+      "method": "GET",
+      "urlVariants": [
+        {
+          "whenPath": "payload.dateType",
+          "equals": "today",
+          "url": "https://sycm.taobao.com/portal/live/new/index/trend/v3.json"
+        },
+        {
+          "default": true,
+          "url": "https://sycm.taobao.com/portal/coreIndex/new/trend/v3.json"
+        }
+      ],
+      "query": {
+        "dateType": "{{payload.dateType}}",
+        "dateRange": "{{payload.dateRange}}",
+        "_": "{{runtime.timestamp}}",
+        "token": "{{session.token}}"
+      },
+      "headers": {
+        "sycm-referer": "/portal/home.htm"
+      },
+      "responsePath": "content.data.data",
+      "metaPath": "content.data"
+    }
+  },
   "crawlerHints": {
     "structuredDataExtractors": {
       "live_metrics": {
@@ -118,6 +171,38 @@
             "meta": "sources.live_metrics.meta"
           }
         }
+      },
+      "live_metrics_direct": {
+        "observationSources": [
+          {
+            "sourceId": "live_overview",
+            "nodeIdArg": "overviewNodeId",
+            "sourceType": "step_observation",
+            "observationPath": "$self"
+          },
+          {
+            "sourceId": "live_trend",
+            "nodeIdArg": "trendNodeId",
+            "sourceType": "step_observation",
+            "observationPath": "$self"
+          }
+        ],
+        "outputSchema": {
+          "root": {
+            "overview": "sources.live_overview.response.data",
+            "trend": "sources.live_trend.response.data",
+            "capturedAt": "sources.live_overview.invokedAt",
+            "meta": {
+              "overviewUrl": "sources.live_overview.response.url",
+              "trendUrl": "sources.live_trend.response.url",
+              "overviewStatus": "sources.live_overview.response.status",
+              "trendStatus": "sources.live_trend.response.status",
+              "interval": "sources.live_overview.response.meta.interval",
+              "timestamp": "sources.live_overview.response.meta.timestamp",
+              "updateTime": "sources.live_overview.response.meta.updateTime"
+            }
+          }
+        }
       }
     }
   }

package/bundled-relay/public/configs/pages/taobao-item-detail.json

@@ -35,20 +35,20 @@
       "scrollIntoView": true,
       "requireVisible": true,
       "preHover": true,
-      "hoverDurationMsRange": [100, 220],
-      "preClickPauseMsRange": [60, 160]
+      "hoverDurationMsRange": [70, 180],
+      "preClickPauseMsRange": [40, 120]
     },
     "humanBehavior": {
-      "cursorMoveSpeedRange": [78, 128],
-      "cursorStepDelayMsRange": [4, 10],
-      "cursorVisibleDurationMsRange": [180, 320],
-      "minCursorStepCount": 12,
-      "mouseDownUpDelayMsRange": [40, 120],
-      "postClickPauseMsRange": [60, 180]
+      "cursorMoveSpeedRange": [110, 180],
+      "cursorStepDelayMsRange": [3, 7],
+      "cursorVisibleDurationMsRange": [120, 220],
+      "minCursorStepCount": 9,
+      "mouseDownUpDelayMsRange": [30, 80],
+      "postClickPauseMsRange": [40, 120]
     },
     "actionPausePolicy": {
-      "minPauseMs": 160,
-      "maxPauseMs": 900
+      "minPauseMs": 120,
+      "maxPauseMs": 560
     }
   },
   "actions": {