tuya-platform-cli 0.1.0

package/src/lib/cdp-client.js

@@ -0,0 +1,115 @@
+import WebSocket from "ws";
+
+export class BrowserCdpClient {
+  constructor(websocketUrl) {
+    this.websocketUrl = websocketUrl;
+    this.socket = null;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.eventListeners = new Map();
+  }
+
+  async connect() {
+    this.socket = new WebSocket(this.websocketUrl);
+
+    await new Promise((resolve, reject) => {
+      this.socket.once("open", resolve);
+      this.socket.once("error", reject);
+    });
+
+    this.socket.on("message", (rawData) => {
+      const message = JSON.parse(rawData.toString());
+
+      if (typeof message.id === "number") {
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+          return;
+        }
+
+        this.pending.delete(message.id);
+
+        if (message.error) {
+          pending.reject(new Error(message.error.message));
+          return;
+        }
+
+        pending.resolve(message.result);
+        return;
+      }
+
+      if (message.method) {
+        const listeners = this.eventListeners.get(message.method) ?? [];
+        for (const listener of listeners) {
+          listener(message.params ?? {}, message.sessionId ?? null);
+        }
+      }
+    });
+
+    this.socket.on("close", () => {
+      for (const pending of this.pending.values()) {
+        pending.reject(new Error("CDP socket closed"));
+      }
+      this.pending.clear();
+    });
+  }
+
+  async send(method, params = {}, sessionId = null, timeoutMs = 30_000) {
+    const id = this.nextId;
+    this.nextId += 1;
+
+    const payload = { id, method, params };
+    if (sessionId) {
+      payload.sessionId = sessionId;
+    }
+
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+
+    this.socket.send(JSON.stringify(payload));
+
+    if (timeoutMs <= 0) {
+      return promise;
+    }
+
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`CDP timeout: ${method} (${timeoutMs}ms)`));
+      }, timeoutMs);
+    });
+
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+  }
+
+  on(method, listener) {
+    const listeners = this.eventListeners.get(method) ?? [];
+    listeners.push(listener);
+    this.eventListeners.set(method, listeners);
+  }
+
+  async close() {
+    if (!this.socket) {
+      return;
+    }
+
+    await new Promise((resolve) => {
+      this.socket.once("close", resolve);
+      this.socket.close();
+    });
+  }
+}
+
+export async function getBrowserWebSocketUrl(remoteDebuggingPort) {
+  const response = await fetch(
+    `http://127.0.0.1:${remoteDebuggingPort}/json/version`,
+  );
+
+  if (!response.ok) {
+    throw new Error(`CDP version endpoint failed: ${response.status}`);
+  }
+
+  const payload = await response.json();
+  return payload.webSocketDebuggerUrl;
+}

package/src/lib/chrome.js

@@ -0,0 +1,115 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { ensureDir, sleep } from "./util.js";
+
+async function copyRecursive(sourcePath, targetPath) {
+  const stats = await fs.stat(sourcePath);
+
+  if (stats.isDirectory()) {
+    await fs.mkdir(targetPath, { recursive: true });
+    const entries = await fs.readdir(sourcePath);
+    for (const entry of entries) {
+      await copyRecursive(
+        path.join(sourcePath, entry),
+        path.join(targetPath, entry),
+      );
+    }
+    return;
+  }
+
+  await fs.copyFile(sourcePath, targetPath);
+}
+
+export async function prepareProfileSnapshot({
+  chromeProfileRoot,
+  chromeProfileName,
+}) {
+  const tempRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "tuya-workflow-profile-"),
+  );
+  const tempProfileRoot = path.join(tempRoot, "ChromeUserData");
+  const tempProfileDir = path.join(tempProfileRoot, chromeProfileName);
+  const sourceProfileDir = path.join(chromeProfileRoot, chromeProfileName);
+  const sourceLocalState = path.join(chromeProfileRoot, "Local State");
+
+  await ensureDir(tempProfileRoot);
+  await copyRecursive(sourceProfileDir, tempProfileDir);
+
+  try {
+    await fs.copyFile(sourceLocalState, path.join(tempProfileRoot, "Local State"));
+  } catch {
+    // `Local State` is optional for some profile states.
+  }
+
+  return {
+    tempRoot,
+    tempProfileRoot,
+    tempProfileDir,
+  };
+}
+
+export async function launchChrome({
+  chromePath,
+  baseUrl,
+  remoteDebuggingPort,
+  tempProfileRoot,
+  chromeProfileName,
+  outputDir,
+  headless,
+}) {
+  const netLogPath = path.join(outputDir, "chrome-netlog.json");
+  const args = [
+    `--remote-debugging-port=${remoteDebuggingPort}`,
+    `--user-data-dir=${tempProfileRoot}`,
+    `--profile-directory=${chromeProfileName}`,
+    `--log-net-log=${netLogPath}`,
+    "--net-log-capture-mode=IncludeSensitive",
+    "--disable-background-networking",
+    "--disable-renderer-backgrounding",
+    "--disable-background-timer-throttling",
+    "--window-size=1600,1200",
+  ];
+
+  if (headless) {
+    args.push("--headless=new");
+  }
+
+  args.push(baseUrl);
+
+  const chromeProcess = spawn(chromePath, args, {
+    stdio: "ignore",
+    detached: false,
+  });
+
+  chromeProcess.on("error", (error) => {
+    console.error(`Failed to launch Chrome: ${error.message}`);
+  });
+
+  await sleep(2_500);
+
+  return {
+    chromeProcess,
+    netLogPath,
+  };
+}
+
+export async function cleanupProfileSnapshot(tempRoot) {
+  if (!tempRoot) {
+    return;
+  }
+
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await fs.rm(tempRoot, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        throw error;
+      }
+
+      await sleep(500 * (attempt + 1));
+    }
+  }
+}

package/src/lib/commands/auto-basic.js

@@ -0,0 +1,482 @@
+import path from "node:path";
+import { chromium } from "playwright";
+import { STEPS } from "../steps.js";
+import { ensureDir, sleep, slugify, writeJson, writeText } from "../util.js";
+import { writeReport } from "../report.js";
+import { writeStaticAnalysis } from "../analyze.js";
+import { SELECTORS } from "../selectors.js";
+
+const DEFAULT_PAGE_URL_INCLUDES = "platform.tuya.com/ai/workflow";
+
+class PlaywrightStepRecorder {
+  constructor({ context, page, outputDir }) {
+    this.context = context;
+    this.page = page;
+    this.outputDir = outputDir;
+    this.activeStep = null;
+    this.requestMap = new Map();
+    this.requests = [];
+    this.counter = 1;
+
+    this.onRequest = this.onRequest.bind(this);
+    this.onResponse = this.onResponse.bind(this);
+    this.onRequestFailed = this.onRequestFailed.bind(this);
+
+    this.context.on("request", this.onRequest);
+    this.context.on("response", this.onResponse);
+    this.context.on("requestfailed", this.onRequestFailed);
+  }
+
+  onRequest(request) {
+    if (!this.activeStep) {
+      return;
+    }
+
+    const headers = request.headers();
+    const entry = {
+      id: this.counter,
+      stepId: this.activeStep.id,
+      requestKey: String(this.counter),
+      method: request.method(),
+      url: request.url(),
+      resourceType: request.resourceType(),
+      requestHeaders: headers,
+      authHeaders: Object.fromEntries(
+        Object.entries(headers).filter(([key]) =>
+          ["authorization", "cookie", "x-auth-token", "x-csrf-token", "x-requested-with"].includes(
+            key.toLowerCase(),
+          ),
+        ),
+      ),
+      requestBody: request.postData() ?? null,
+      startedAt: new Date().toISOString(),
+    };
+
+    this.counter += 1;
+    this.requestMap.set(request, entry);
+    this.requests.push(entry);
+  }
+
+  async onResponse(response) {
+    if (!this.activeStep) {
+      return;
+    }
+
+    const request = response.request();
+    const entry = this.requestMap.get(request);
+    if (!entry) {
+      return;
+    }
+
+    entry.responseStatus = response.status();
+    entry.responseHeaders = await response.allHeaders().catch(() => ({}));
+    entry.finishedAt = new Date().toISOString();
+
+    try {
+      entry.responseBody = await response.text();
+    } catch {
+      entry.responseBody = null;
+    }
+  }
+
+  onRequestFailed(request) {
+    if (!this.activeStep) {
+      return;
+    }
+
+    const entry = this.requestMap.get(request);
+    if (!entry) {
+      return;
+    }
+
+    entry.failure = request.failure()?.errorText ?? "requestfailed";
+  }
+
+  async startStep(step) {
+    this.activeStep = step;
+    this.requestMap.clear();
+    this.requests = [];
+  }
+
+  async finishStep(step) {
+    await ensureDir(path.join(this.outputDir, step.id, "requests"));
+    const network = this.requests.map((entry) => ({ ...entry }));
+    const stepDir = path.join(this.outputDir, step.id);
+    const requestsDir = path.join(stepDir, "requests");
+    const bundlesDir = path.join(this.outputDir, "bundles");
+    await ensureDir(bundlesDir);
+
+    for (const [index, request] of network.entries()) {
+      const name = `${String(index + 1).padStart(3, "0")}-${slugify(request.method)}-${slugify(
+        request.url,
+      )}.json`;
+      await writeJson(path.join(requestsDir, name), request);
+
+      const contentType = String(request.responseHeaders?.["content-type"] ?? "");
+      if (
+        request.responseBody &&
+        (contentType.includes("javascript") || /\.js(\?|$)/i.test(request.url))
+      ) {
+        await writeText(
+          path.join(bundlesDir, `${slugify(request.url)}.js`),
+          request.responseBody,
+        );
+      }
+    }
+
+    await writeJson(path.join(stepDir, "network.json"), network);
+    await this.page.screenshot({
+      path: path.join(stepDir, "screenshot.png"),
+      fullPage: true,
+    }).catch(() => {});
+
+    this.activeStep = null;
+    return network;
+  }
+
+  async dispose() {
+    this.context.off("request", this.onRequest);
+    this.context.off("response", this.onResponse);
+    this.context.off("requestfailed", this.onRequestFailed);
+  }
+}
+
+async function getBrowserContext(remoteDebuggingPort, pageUrlIncludes = DEFAULT_PAGE_URL_INCLUDES) {
+  const browser = await chromium.connectOverCDP(`http://127.0.0.1:${remoteDebuggingPort}`);
+  const context = browser.contexts()[0] ?? (await browser.newContext());
+  const page =
+    context.pages().find((candidate) => candidate.url().includes(pageUrlIncludes)) ??
+    context.pages().find((candidate) => candidate.url().startsWith("http")) ??
+    (await context.newPage());
+
+  return { browser, context, page };
+}
+
+async function dismissKnownModals(page) {
+  const modal = page.locator(SELECTORS.MODAL_WRAP).last();
+  if (!(await modal.isVisible().catch(() => false))) {
+    return;
+  }
+
+  const text = await modal.innerText().catch(() => "");
+
+  if (text.includes("你确定要删除该工作流吗")) {
+    const buttons = modal.locator("button");
+    const count = await buttons.count().catch(() => 0);
+    if (count > 0) {
+      await buttons.nth(count - 1).click({ force: true }).catch(() => {});
+      await page.waitForTimeout(3_000);
+      return;
+    }
+  }
+
+  if (text.includes("当前不是最新版本")) {
+    const cancel = modal.getByRole("button", { name: /取消/ }).first();
+    if (await cancel.isVisible().catch(() => false)) {
+      await cancel.click();
+      await page.waitForTimeout(1_000);
+      return;
+    }
+  }
+
+  const closeButton = modal.getByRole("button", { name: /取消|关闭/ }).first();
+  if (await closeButton.isVisible().catch(() => false)) {
+    await closeButton.click().catch(() => {});
+    await page.waitForTimeout(1_000);
+  }
+}
+
+async function cleanupExistingWorkflow(page, baseUrl, workflowName = "测试工作流") {
+  await page.goto(baseUrl, { waitUntil: "domcontentloaded" }).catch(() => {});
+  await page.waitForTimeout(5_000);
+  await dismissKnownModals(page);
+
+  const MAX_CLEANUP_ITERATIONS = 20;
+  for (let iteration = 0; iteration < MAX_CLEANUP_ITERATIONS; iteration += 1) {
+    const row = page.locator("tr", { hasText: workflowName }).first();
+    if (!(await row.isVisible().catch(() => false))) {
+      break;
+    }
+
+    await row.hover();
+    await row.locator(SELECTORS.MORE_ICON).click();
+    await page.getByText("删除").last().click();
+    const confirm = page.getByRole("button", { name: /确认|确定/ }).last();
+    if (await confirm.isVisible().catch(() => false)) {
+      await confirm.click();
+    }
+    await page.waitForTimeout(4_000);
+
+    if (iteration === MAX_CLEANUP_ITERATIONS - 1) {
+      throw new Error(`cleanupExistingWorkflow: exceeded ${MAX_CLEANUP_ITERATIONS} iterations`);
+    }
+  }
+}
+
+async function createWorkflow(page, workflowName = "测试工作流") {
+  await page.getByRole("button", { name: "创建工作流" }).click();
+  await page.waitForTimeout(1_000);
+  const modal = page.locator(SELECTORS.MODAL_WRAP).last();
+  await modal.locator('input[placeholder*="工作流名称"]').fill(workflowName);
+  await modal.locator('textarea[placeholder*="工作流描述"]').fill("test");
+  await modal.locator(SELECTORS.SELECT_SELECTOR).first().click();
+  await page
+    .locator(SELECTORS.SELECT_DROPDOWN_OPTION)
+    .filter({ hasText: /美西/ })
+    .last()
+    .click();
+  await modal.getByRole("button", { name: /确定|确认/ }).click();
+  await page.waitForTimeout(5_000);
+}
+
+async function openWorkflowEditor(page, workflowName = "测试工作流") {
+  const row = page.locator("tr", { hasText: workflowName }).first();
+  await row.hover();
+  await row.getByText("编辑").click({ force: true });
+  await page.waitForTimeout(8_000);
+  await dismissKnownModals(page);
+  await page.waitForTimeout(1_000);
+}
+
+async function addIntentNode(page) {
+  await dismissKnownModals(page);
+  await page.getByRole("button", { name: "添加节点" }).click();
+  await page.waitForTimeout(1_000);
+  await page.locator(SELECTORS.NODE_PANEL_ITEM).filter({ hasText: "意图识别" }).click();
+  await page.waitForTimeout(2_000);
+  const node = page.locator(SELECTORS.FLOW_ACTIVITY_NODE).last();
+  await node.click({ force: true });
+  await page.waitForTimeout(1_000);
+  const speedMode = page.getByText("极速模式", { exact: true }).first();
+  if (await speedMode.isVisible().catch(() => false)) {
+    await speedMode.click();
+  }
+  const intentInput = page.locator('input[placeholder*="请输入用户意图的描述"]').first();
+  if (await intentInput.isVisible().catch(() => false)) {
+    await intentInput.fill("问候");
+  }
+  await page.waitForTimeout(8_000);
+}
+
+async function selectAllShortcut(page) {
+  const modifier = process.platform === "darwin" ? "Meta+A" : "Control+A";
+  await page.keyboard.press(modifier);
+}
+
+async function fillCodeMirror(editor, text, page) {
+  await editor.click();
+  await selectAllShortcut(page);
+  await page.keyboard.press("Backspace");
+  await page.keyboard.type(text, { delay: 20 });
+}
+
+async function addLlmNode(page) {
+  await dismissKnownModals(page);
+  await page.getByRole("button", { name: "添加节点" }).click();
+  await page.waitForTimeout(1_000);
+  await page.locator(SELECTORS.NODE_PANEL_ITEM).filter({ hasText: "大模型" }).click();
+  await page.waitForTimeout(2_500);
+  const node = page.locator(SELECTORS.FLOW_ACTIVITY_NODE).last();
+  await node.click({ force: true });
+  await page.waitForTimeout(1_000);
+
+  const editors = page.locator(SELECTORS.CODE_MIRROR_EDITOR);
+  if ((await editors.count()) >= 2) {
+    await fillCodeMirror(editors.nth(0), "你是一个友好的助手。", page);
+    await fillCodeMirror(editors.nth(1), "请回答用户的问题。", page);
+  }
+  await page.waitForTimeout(8_000);
+}
+
+async function triggerAutosave(page) {
+  const editors = page.locator(SELECTORS.CODE_MIRROR_EDITOR);
+  if ((await editors.count()) >= 2) {
+    await fillCodeMirror(editors.nth(1), "请回答用户的问题，并简洁回复。", page);
+  }
+  await page.waitForTimeout(8_000);
+}
+
+async function trialRun(page) {
+  await dismissKnownModals(page);
+  await page.getByRole("button", { name: "试运行" }).click();
+  await page.waitForTimeout(2_000);
+
+  const inputs = page.locator("input, textarea, [contenteditable='true']");
+  const count = await inputs.count();
+  for (let index = 0; index < count; index += 1) {
+    const input = inputs.nth(index);
+    const placeholder = (await input.getAttribute("placeholder").catch(() => "")) ?? "";
+    const text = (await input.innerText().catch(() => "")) ?? "";
+    if (placeholder.includes("USER_TEXT") || text.includes("USER_TEXT")) {
+      await input.click();
+      await selectAllShortcut(page);
+      await page.keyboard.type("你好");
+      break;
+    }
+  }
+
+  const dcSelector = page.locator(SELECTORS.SELECT_SELECTOR).filter({ hasText: /数据中心|美西|请选择/ }).first();
+  if (await dcSelector.isVisible().catch(() => false)) {
+    await dcSelector.click().catch(() => {});
+    await page
+      .locator(SELECTORS.SELECT_DROPDOWN_OPTION)
+      .filter({ hasText: /美西/ })
+      .last()
+      .click()
+      .catch(() => {});
+  }
+
+  const runButton = page.getByRole("button", { name: /^运行$/ }).last();
+  if (await runButton.isVisible().catch(() => false)) {
+    await runButton.click();
+  }
+  await page.waitForTimeout(20_000);
+}
+
+async function deleteWorkflow(page, baseUrl, workflowName = "测试工作流") {
+  await page.goto(baseUrl, { waitUntil: "domcontentloaded" }).catch(() => {});
+  await page.waitForTimeout(5_000);
+  const row = page.locator("tr", { hasText: workflowName }).first();
+  await row.hover();
+  await row.locator(SELECTORS.MORE_ICON).click();
+  await page.getByText("删除").last().click();
+  const confirm = page.getByRole("button", { name: /确认|确定/ }).last();
+  if (await confirm.isVisible().catch(() => false)) {
+    await confirm.click();
+  }
+  await page.waitForTimeout(5_000);
+}
+
+async function runStep(recorder, step, action, idleMs = 5_000) {
+  await recorder.startStep(step);
+  await action();
+  await sleep(idleMs);
+  return recorder.finishStep(step);
+}
+
+function requireStepRequests(stepId, network, urlMatchers) {
+  const matched = network.some((request) =>
+    urlMatchers.some((matcher) => matcher.test(String(request.url ?? ""))),
+  );
+
+  if (!matched) {
+    throw new Error(
+      `${stepId} failed: expected one of ${urlMatchers.map((item) => item.source).join(", ")}`,
+    );
+  }
+}
+
+export async function runAutoBasicCapture(config) {
+  await ensureDir(config.outputDir);
+
+  const { browser, context, page } = await getBrowserContext(config.remoteDebuggingPort);
+  const recorder = new PlaywrightStepRecorder({ context, page, outputDir: config.outputDir });
+  const workflowName = config.workflowName ?? "测试工作流";
+
+  try {
+    await page.bringToFront();
+    await cleanupExistingWorkflow(page, config.baseUrl, workflowName);
+
+    const stepNetworks = [];
+
+    stepNetworks.push({
+      step: STEPS[0],
+      network: await runStep(
+        recorder,
+        STEPS[0],
+        async () => {
+          await page.goto(config.baseUrl, { waitUntil: "domcontentloaded" }).catch(() => {});
+          await page.waitForTimeout(8_000);
+        },
+        1_000,
+      ),
+    });
+    requireStepRequests(STEPS[0].id, stepNetworks[0].network, [/workflow\/list/i]);
+
+    stepNetworks.push({
+      step: STEPS[1],
+      network: await runStep(recorder, STEPS[1], async () => {
+        await createWorkflow(page, workflowName);
+      }),
+    });
+    requireStepRequests(STEPS[1].id, stepNetworks[1].network, [/addBasic/i]);
+
+    stepNetworks.push({
+      step: STEPS[2],
+      network: await runStep(recorder, STEPS[2], async () => {
+        await openWorkflowEditor(page, workflowName);
+      }, 2_000),
+    });
+    requireStepRequests(STEPS[2].id, stepNetworks[2].network, [/workflow\/get/i]);
+
+    stepNetworks.push({
+      step: STEPS[3],
+      network: await runStep(recorder, STEPS[3], async () => {
+        await addIntentNode(page);
+      }),
+    });
+    requireStepRequests(STEPS[3].id, stepNetworks[3].network, [/workflow\/update/i]);
+
+    stepNetworks.push({
+      step: STEPS[4],
+      network: await runStep(recorder, STEPS[4], async () => {
+        await addLlmNode(page);
+      }),
+    });
+    requireStepRequests(STEPS[4].id, stepNetworks[4].network, [/workflow\/update/i]);
+
+    stepNetworks.push({
+      step: STEPS[5],
+      network: await runStep(recorder, STEPS[5], async () => {
+        await triggerAutosave(page);
+      }),
+    });
+    requireStepRequests(STEPS[5].id, stepNetworks[5].network, [/workflow\/update/i]);
+
+    stepNetworks.push({
+      step: STEPS[6],
+      network: await runStep(recorder, STEPS[6], async () => {
+        await trialRun(page);
+      }, 2_000),
+    });
+    requireStepRequests(STEPS[6].id, stepNetworks[6].network, [
+      /run-pre-check/i,
+      /workflow\/test\/config/i,
+      /workflow\/test\/execute/i,
+      /workflow\/test\/progress/i,
+    ]);
+
+    stepNetworks.push({
+      step: STEPS[7],
+      network: await runStep(recorder, STEPS[7], async () => {
+        await deleteWorkflow(page, config.baseUrl, workflowName);
+      }),
+    });
+    requireStepRequests(STEPS[7].id, stepNetworks[7].network, [/workflow\/delete/i]);
+
+    const workflowId =
+      page.url().match(/workflowId=([^&]+)/)?.[1] ??
+      page.url().match(/[?&]id=([^&]+)/)?.[1] ??
+      null;
+
+    await writeJson(path.join(config.outputDir, "summary.json"), {
+      generatedAt: new Date().toISOString(),
+      command: "auto-basic",
+      outputDir: config.outputDir,
+      workflowId,
+      steps: stepNetworks.map(({ step, network }) => ({
+        id: step.id,
+        title: step.title,
+        requestCount: network.length,
+      })),
+    });
+
+    await writeReport(config.outputDir, stepNetworks);
+    await writeStaticAnalysis(config.outputDir, stepNetworks);
+
+    console.log(JSON.stringify({ outputDir: config.outputDir, workflowId }, null, 2));
+  } finally {
+    await recorder.dispose();
+    await browser.close();
+  }
+}