tuya-platform-cli 0.1.0

package/src/lib/commands/configure.js

@@ -0,0 +1,158 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, writeJson } from "../util.js";
+import {
+  createWorkflowViaPage,
+  debugOriginForRegion,
+  executeTrialRun,
+  getBrowserContext,
+  getWorkflowViaPage,
+  pageFetchJson,
+  readWorkflowSchema,
+  requireApiSuccess,
+  updateWorkflowViaPage,
+} from "./shared.js";
+import { validateDefinition, buildSchemaFromDefinition } from "../schema-builder.js";
+
+export async function runConfigure(config) {
+  if (!config.definitionFile) {
+    throw new Error("configure requires --definition-file");
+  }
+
+  const definitionText = await fs.readFile(config.definitionFile, "utf-8");
+  const definition = JSON.parse(definitionText);
+
+  validateDefinition(definition);
+
+  const schemaJson = buildSchemaFromDefinition(definition);
+
+  await ensureDir(config.outputDir);
+
+  const { browser, page } = await getBrowserContext(config.remoteDebuggingPort);
+  const region = definition.region ?? config.region;
+  const baseOrigin = debugOriginForRegion(region, config.baseUrl);
+
+  try {
+    await page.bringToFront();
+    await page.goto(`${baseOrigin}/ai/workflow`, { waitUntil: "domcontentloaded" }).catch(() => {});
+    await page.waitForTimeout(4_000);
+
+    let workflowId = config.workflowId;
+
+    if (!workflowId) {
+      const created = await createWorkflowViaPage(
+        page,
+        {
+          workflowName: definition.name,
+          workflowDesc: definition.description ?? "",
+          workflowRegion: region,
+          workflowType: definition.type ?? 1,
+        },
+        { baseOrigin },
+      );
+      workflowId = created.workflowId;
+    }
+
+    const detailBefore = await getWorkflowViaPage(page, workflowId, { baseOrigin });
+    const editVersionNo = detailBefore.json?.result?.editVersionNo ?? 1;
+
+    await updateWorkflowViaPage(
+      page,
+      {
+        workflowId,
+        editVersionNo,
+        schemaJson,
+      },
+      { baseOrigin },
+    );
+
+    const detailAfter = await getWorkflowViaPage(page, workflowId, { baseOrigin });
+    const savedSchema = readWorkflowSchema(detailAfter);
+
+    const expectedNodeCount = 1 + definition.nodes.length + definition.ends.length;
+    const verified =
+      (savedSchema.nodes ?? []).length >= expectedNodeCount &&
+      (savedSchema.edges ?? []).length >= definition.edges.length;
+
+    const result = {
+      workflowId,
+      verified,
+      nodeCount: (savedSchema.nodes ?? []).length,
+      edgeCount: (savedSchema.edges ?? []).length,
+    };
+
+    if (definition.trialRun) {
+      await page
+        .goto(`${baseOrigin}/ai/workflow/debug?workflowId=${workflowId}&region=${region}`, {
+          waitUntil: "domcontentloaded",
+        })
+        .catch(() => {});
+      await page.waitForTimeout(4_000);
+
+      const preCheck = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/run-pre-check", {
+        body: {
+          params: {
+            workflowId,
+            region,
+          },
+        },
+        baseOrigin,
+      });
+      requireApiSuccess("run-pre-check", preCheck);
+
+      const testConfig = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/test/config", {
+        body: { workflowId },
+        baseOrigin,
+      });
+      requireApiSuccess("test/config", testConfig);
+
+      const endpointType = testConfig.json?.result?.endpointType;
+      const endpointId = testConfig.json?.result?.endpointId;
+      if (!endpointType || !endpointId) {
+        throw new Error("test/config failed: missing endpointType or endpointId");
+      }
+
+      const configSave = await pageFetchJson(
+        page,
+        "/micro-app/ai/api/aigc/workflow/test/config/save",
+        {
+          body: {
+            params: {
+              workflowId,
+              endpointType,
+              endpointId,
+            },
+          },
+          baseOrigin,
+        },
+      );
+      requireApiSuccess("test/config/save", configSave);
+
+      const trialResult = await executeTrialRun(page, {
+        baseOrigin,
+        workflowId,
+        endpointType,
+        endpointId,
+        inputArgs: definition.trialRun.inputs,
+      });
+
+      const latestProgress = trialResult.progress[trialResult.progress.length - 1] ?? null;
+      result.trialRun = {
+        executeId: trialResult.executeId,
+        status: latestProgress?.json?.result?.executeStatus ?? null,
+      };
+    }
+
+    await writeJson(path.join(config.outputDir, `configure-${workflowId}.json`), {
+      generatedAt: new Date().toISOString(),
+      definition,
+      schemaJson,
+      savedSchema,
+      result,
+    });
+
+    console.log(JSON.stringify(result, null, 2));
+  } finally {
+    await browser.close();
+  }
+}

package/src/lib/commands/doctor.js

@@ -0,0 +1,184 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, writeJson, writeText } from "../util.js";
+import {
+  debugOriginForRegion,
+  getBrowserContext,
+  getWorkflowViaPage,
+  pageFetchJson,
+  requireApiSuccess,
+} from "./shared.js";
+
+function recordCheck(checks, name, ok, detail) {
+  checks.push({
+    name,
+    ok,
+    detail,
+  });
+}
+
+function buildDoctorMarkdown(report) {
+  return [
+    "# CLI Doctor",
+    "",
+    `- Generated at: \`${report.generatedAt}\``,
+    `- Remote debugging port: \`${report.remoteDebuggingPort}\``,
+    `- Base URL: \`${report.baseUrl}\``,
+    `- Region: \`${report.region}\``,
+    `- Healthy: \`${report.ok}\``,
+    "",
+    "## Checks",
+    ...report.checks.map((check) => `- [${check.ok ? "x" : " "}] ${check.name}: ${check.detail}`),
+    "",
+  ].join("\n");
+}
+
+export async function runDoctor(config) {
+  await ensureDir(config.outputDir);
+
+  const checks = [];
+  let browser = null;
+
+  try {
+    if (config.imagePath) {
+      await fs.access(config.imagePath);
+      const stat = await fs.stat(config.imagePath);
+      recordCheck(checks, "image-path", stat.size > 0, `${config.imagePath} (${stat.size} bytes)`);
+      if (stat.size <= 0) {
+        throw new Error("image-path check failed");
+      }
+    } else {
+      recordCheck(checks, "image-path", true, "not provided");
+    }
+
+    const browserContext = await getBrowserContext(config.remoteDebuggingPort);
+    browser = browserContext.browser;
+    const { page } = browserContext;
+
+    recordCheck(checks, "cdp-connect", true, `connected to 127.0.0.1:${config.remoteDebuggingPort}`);
+
+    await page.bringToFront();
+    await page.goto(config.baseUrl, { waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(2_000);
+
+    const currentUrl = page.url();
+    recordCheck(checks, "base-url-open", /platform\.tuya\.com\/ai\/workflow/.test(currentUrl), currentUrl);
+    if (!/platform\.tuya\.com\/ai\/workflow/.test(currentUrl)) {
+      throw new Error(`base-url-open failed: landed on ${currentUrl}`);
+    }
+
+    const listResponse = await pageFetchJson(page, "/micro-app/exp/api/aigc/workflow/list", {
+      body: {
+        params: {
+          pageNo: 1,
+          pageSize: 20,
+        },
+      },
+    });
+    requireApiSuccess("workflow/list", listResponse);
+    const totalCount = listResponse.json?.result?.totalCount ?? null;
+    recordCheck(checks, "workflow-list", true, `workflow/list ok, totalCount=${totalCount ?? "unknown"}`);
+
+    const pageText = (await page.locator("body").innerText().catch(() => "")).slice(0, 4_000);
+    const loginIndicators = ["创建工作流", "工作流名称", "流程类型"];
+    const matchedIndicators = loginIndicators.filter((item) => pageText.includes(item));
+    const loginOk = matchedIndicators.length > 0;
+    recordCheck(
+      checks,
+      "workflow-page-content",
+      loginOk,
+      loginOk ? `matched ${matchedIndicators.join(", ")}` : "expected workflow page text not found",
+    );
+    if (!loginOk) {
+      throw new Error("workflow-page-content failed");
+    }
+
+    if (config.workflowId) {
+      const detail = await getWorkflowViaPage(page, config.workflowId);
+      const workflowName = detail.json?.result?.workflowName ?? "unknown";
+      recordCheck(checks, "workflow-get", true, `workflowId=${config.workflowId}, name=${workflowName}`);
+
+      const preCheck = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/run-pre-check", {
+        body: {
+          params: {
+            workflowId: config.workflowId,
+            region: config.region,
+          },
+        },
+      });
+      requireApiSuccess("run-pre-check", preCheck);
+      const preCheckOk = preCheck.json?.result?.isSuccess === 1;
+      recordCheck(
+        checks,
+        "run-pre-check",
+        preCheckOk,
+        preCheckOk
+          ? `workflowId=${config.workflowId} passed`
+          : JSON.stringify(preCheck.json?.result?.errors ?? []),
+      );
+      if (!preCheckOk) {
+        throw new Error("run-pre-check failed");
+      }
+
+      const debugOrigin = debugOriginForRegion(config.region, config.baseUrl);
+      const testConfig = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/test/config", {
+        body: {
+          workflowId: config.workflowId,
+        },
+        baseOrigin: debugOrigin,
+      });
+      requireApiSuccess("test/config", testConfig);
+      const endpointType = testConfig.json?.result?.endpointType ?? null;
+      const endpointId = testConfig.json?.result?.endpointId ?? null;
+      const configOk = Boolean(endpointType && endpointId);
+      recordCheck(
+        checks,
+        "test-config",
+        configOk,
+        configOk
+          ? `endpointType=${endpointType}, endpointId=${endpointId}`
+          : "missing endpointType or endpointId",
+      );
+      if (!configOk) {
+        throw new Error("test-config failed");
+      }
+    } else {
+      recordCheck(checks, "workflow-get", true, "skipped: no --workflow-id");
+      recordCheck(checks, "run-pre-check", true, "skipped: no --workflow-id");
+      recordCheck(checks, "test-config", true, "skipped: no --workflow-id");
+    }
+
+    const report = {
+      generatedAt: new Date().toISOString(),
+      ok: true,
+      remoteDebuggingPort: config.remoteDebuggingPort,
+      baseUrl: config.baseUrl,
+      region: config.region,
+      workflowId: config.workflowId ?? null,
+      imagePath: config.imagePath ?? null,
+      checks,
+    };
+
+    await writeJson(path.join(config.outputDir, "doctor.json"), report);
+    await writeText(path.join(config.outputDir, "doctor.md"), buildDoctorMarkdown(report));
+    console.log(JSON.stringify(report, null, 2));
+  } catch (error) {
+    const report = {
+      generatedAt: new Date().toISOString(),
+      ok: false,
+      remoteDebuggingPort: config.remoteDebuggingPort,
+      baseUrl: config.baseUrl,
+      region: config.region,
+      workflowId: config.workflowId ?? null,
+      imagePath: config.imagePath ?? null,
+      checks,
+      error: error.message,
+    };
+
+    await writeJson(path.join(config.outputDir, "doctor.json"), report);
+    await writeText(path.join(config.outputDir, "doctor.md"), buildDoctorMarkdown(report));
+    throw error;
+  } finally {
+    await browser?.close().catch(() => {});
+  }
+}

package/src/lib/commands/list-libraries.js

@@ -0,0 +1,33 @@
+import {
+  debugOriginForRegion,
+  getBrowserContext,
+  listKnowledgeLibrariesViaPage,
+} from "./shared.js";
+
+export async function runListLibraries(config) {
+  const { browser, page } = await getBrowserContext(config.remoteDebuggingPort);
+  const baseOrigin = debugOriginForRegion(config.region, config.baseUrl);
+
+  try {
+    await page.bringToFront();
+    await page.goto(`${baseOrigin}/ai/workflow`, { waitUntil: "domcontentloaded" }).catch(() => {});
+    await page.waitForTimeout(4_000);
+
+    const response = await listKnowledgeLibrariesViaPage(page, { baseOrigin });
+
+    const libraries = Array.isArray(response.json?.result)
+      ? response.json.result.map((lib) => ({
+          libCode: lib.libCode,
+          libName: lib.libName,
+          supportCategory: lib.supportCategory,
+          libCategories: lib.libCategories ?? [],
+        }))
+      : [];
+
+    const result = { libraries };
+
+    console.log(JSON.stringify(result, null, 2));
+  } finally {
+    await browser.close();
+  }
+}

package/src/lib/commands/manual-record.js

@@ -0,0 +1,82 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { prepareProfileSnapshot, launchChrome, cleanupProfileSnapshot } from "../chrome.js";
+import { StepRecorder } from "../recorder.js";
+import { STEPS } from "../steps.js";
+import { ensureDir, prompt, sleep, writeJson } from "../util.js";
+import { writeReport } from "../report.js";
+import { writeStaticAnalysis } from "../analyze.js";
+
+async function validatePaths(config) {
+  await fs.access(config.chromePath);
+  await fs.access(path.join(config.chromeProfileRoot, config.chromeProfileName));
+}
+
+export async function runManualRecord(config) {
+  await validatePaths(config);
+  await ensureDir(config.outputDir);
+
+  console.log(`Output directory: ${config.outputDir}`);
+  console.log("Preparing Chrome profile snapshot...");
+
+  const profile = await prepareProfileSnapshot(config);
+  let chromeProcess = null;
+  const stepNetworks = [];
+
+  try {
+    const chrome = await launchChrome({
+      ...config,
+      tempProfileRoot: profile.tempProfileRoot,
+      chromeProfileName: config.chromeProfileName,
+      outputDir: config.outputDir,
+    });
+    chromeProcess = chrome.chromeProcess;
+
+    console.log("Connecting to Chrome CDP...");
+    const recorder = new StepRecorder(config);
+    await recorder.initialize();
+    await sleep(2_000);
+
+    console.log(
+      "Chrome is ready. Complete each step in the browser window, then return here and press Enter.",
+    );
+
+    for (const step of STEPS) {
+      console.log(`\n=== ${step.title} ===`);
+      console.log(step.instruction);
+      await prompt("Press Enter to start recording this step...");
+      await recorder.startStep(step);
+      await prompt("Perform the action in Chrome, then press Enter to finish this step...");
+      const network = await recorder.finishStep(step);
+      stepNetworks.push({ step, network });
+      console.log(`Captured ${network.length} requests for ${step.title}`);
+    }
+
+    await recorder.close();
+
+    await writeJson(path.join(config.outputDir, "summary.json"), {
+      generatedAt: new Date().toISOString(),
+      command: "manual",
+      stepCount: stepNetworks.length,
+      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(`\nReport written to ${path.join(config.outputDir, "report.md")}`);
+    console.log(
+      `Static analysis written to ${path.join(config.outputDir, "static-analysis.md")}`,
+    );
+  } finally {
+    if (chromeProcess) {
+      chromeProcess.kill("SIGTERM");
+    }
+
+    await cleanupProfileSnapshot(profile?.tempRoot);
+  }
+}

package/src/lib/commands/publish.js

@@ -0,0 +1,63 @@
+import path from "node:path";
+import { ensureDir, writeJson } from "../util.js";
+import {
+  debugOriginForRegion,
+  getBrowserContext,
+  getWorkflowViaPage,
+  publishAgentViaPage,
+} from "./shared.js";
+
+export async function runPublish(config) {
+  if (!config.workflowId) {
+    throw new Error("publish requires --workflow-id");
+  }
+
+  await ensureDir(config.outputDir);
+
+  const { browser, page } = await getBrowserContext(config.remoteDebuggingPort);
+  const baseOrigin = debugOriginForRegion(config.region, config.baseUrl);
+
+  try {
+    await page.bringToFront();
+    await page.goto(`${baseOrigin}/ai/workflow`, { waitUntil: "domcontentloaded" }).catch(() => {});
+    await page.waitForTimeout(4_000);
+
+    const detailResponse = await getWorkflowViaPage(page, config.workflowId, { baseOrigin });
+    const projectCode =
+      config.projectCode ??
+      detailResponse.json?.result?.projectCode ??
+      (() => {
+        const schemaText = detailResponse.json?.result?.schemaJson;
+        if (typeof schemaText === "string") {
+          try {
+            return JSON.parse(schemaText)?.workflow?.projectCode ?? null;
+          } catch {
+            return null;
+          }
+        }
+        return null;
+      })();
+
+    if (!projectCode) {
+      throw new Error("publish failed: unable to determine projectCode. Use --project-code to specify.");
+    }
+
+    await publishAgentViaPage(page, { projectCode, region: config.region }, { baseOrigin });
+
+    const result = {
+      workflowId: config.workflowId,
+      projectCode,
+      region: config.region,
+      published: true,
+    };
+
+    await writeJson(path.join(config.outputDir, `publish-${config.workflowId}.json`), {
+      generatedAt: new Date().toISOString(),
+      result,
+    });
+
+    console.log(JSON.stringify(result, null, 2));
+  } finally {
+    await browser.close();
+  }
+}