tuya-platform-cli 0.1.0

package/src/lib/commands/sample-trial-inputs.js

@@ -0,0 +1,173 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, writeJson, writeText } from "../util.js";
+import {
+  buildNetworkCapture,
+  debugOriginForRegion,
+  executeTrialRun,
+  getBrowserContext,
+  pageFetchJson,
+  requireApiSuccess,
+  uploadImageForTrialRun,
+} from "./shared.js";
+
+function buildSummaryMarkdown(artifact) {
+  return [
+    "# Trial Run Inputs Sample",
+    "",
+    `- Workflow ID: \`${artifact.workflowId}\``,
+    `- Region: \`${artifact.region}\``,
+    `- Endpoint: \`${artifact.config.endpointType}:${artifact.config.endpointId}\``,
+    `- Text run status: \`${artifact.textRun.latestProgress?.json?.result?.executeStatus ?? artifact.textRun.latestProgress?.json?.errorCode ?? "unknown"}\``,
+    `- Image run status: \`${artifact.imageRun?.latestProgress?.json?.result?.executeStatus ?? artifact.imageRun?.latestProgress?.json?.errorCode ?? "skipped"}\``,
+    "",
+  ].join("\n");
+}
+
+export async function runSampleTrialInputs(config) {
+  if (!config.workflowId) {
+    throw new Error("sample-trial-inputs requires --workflow-id");
+  }
+
+  await ensureDir(config.outputDir);
+
+  const { browser, context, page } = await getBrowserContext(config.remoteDebuggingPort);
+  const baseOrigin = debugOriginForRegion(config.region, config.baseUrl);
+  const capture = buildNetworkCapture(
+    context,
+    /run-pre-check|workflow\/test\/config|workflow\/test\/execute|workflow\/test\/progress|uploadSignV3|checkFileStatus|file\/signature/i,
+  );
+
+  try {
+    await page.bringToFront();
+    await page.goto(`${baseOrigin}/ai/workflow/debug?workflowId=${config.workflowId}&region=${config.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: config.workflowId,
+          region: config.region,
+        },
+      },
+      baseOrigin,
+    });
+    requireApiSuccess("run-pre-check", preCheck);
+
+    const configResponse = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/test/config", {
+      body: {
+        workflowId: config.workflowId,
+      },
+      baseOrigin,
+    });
+    requireApiSuccess("test/config", configResponse);
+
+    const endpointType = configResponse.json?.result?.endpointType;
+    const endpointId = configResponse.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: config.workflowId,
+          endpointType,
+          endpointId,
+        },
+      },
+      baseOrigin,
+    });
+    requireApiSuccess("test/config/save", configSave);
+
+    const textOnly = await executeTrialRun(page, {
+      baseOrigin,
+      workflowId: config.workflowId,
+      endpointType,
+      endpointId,
+      inputArgs: {
+        USER_TEXT: "你好",
+      },
+    });
+
+    const textLatestProgress = textOnly.progress[textOnly.progress.length - 1] ?? null;
+
+    let imageRun = null;
+    if (config.imagePath) {
+      const upload = await uploadImageForTrialRun(page, config.imagePath, {
+        baseOrigin,
+        readFile: fs.readFile,
+        basename: path.basename,
+      });
+
+      const run = await executeTrialRun(page, {
+        baseOrigin,
+        workflowId: config.workflowId,
+        endpointType,
+        endpointId,
+        inputArgs: {
+          USER_TEXT: "请描述这张图片",
+          USER_IMAGE: [upload.bizUrl],
+        },
+      });
+
+      imageRun = {
+        upload,
+        ...run,
+        latestProgress: run.progress[run.progress.length - 1] ?? null,
+      };
+    }
+
+    const artifact = {
+      generatedAt: new Date().toISOString(),
+      workflowId: config.workflowId,
+      region: config.region,
+      config: {
+        endpointType,
+        endpointId,
+      },
+      preCheck,
+      configResponse,
+      configSave,
+      textRun: {
+        ...textOnly,
+        latestProgress: textLatestProgress,
+      },
+      imageRun,
+      events: capture.events,
+    };
+
+    await writeJson(
+      path.join(config.outputDir, `trial-run-inputs-${config.workflowId}.json`),
+      artifact,
+    );
+    await writeText(
+      path.join(config.outputDir, "trial-run-inputs.md"),
+      buildSummaryMarkdown(artifact),
+    );
+
+    console.log(
+      JSON.stringify(
+        {
+          outputDir: config.outputDir,
+          workflowId: config.workflowId,
+          textRunStatus:
+            textLatestProgress?.json?.result?.executeStatus ??
+            textLatestProgress?.json?.errorCode ??
+            null,
+          imageRunStatus:
+            imageRun?.latestProgress?.json?.result?.executeStatus ??
+            imageRun?.latestProgress?.json?.errorCode ??
+            null,
+        },
+        null,
+        2,
+      ),
+    );
+  } finally {
+    capture.dispose();
+    await browser.close();
+  }
+}

package/src/lib/commands/shared.js

@@ -0,0 +1,457 @@
+import { chromium } from "playwright";
+import { safeJsonParse } from "../util.js";
+
+export function requireApiSuccess(label, response) {
+  if (!response) {
+    throw new Error(`${label} failed: empty response`);
+  }
+
+  if (response.error) {
+    throw new Error(`${label} failed: ${response.error}`);
+  }
+
+  if (response.status >= 400) {
+    throw new Error(`${label} failed: HTTP ${response.status}`);
+  }
+
+  if (response.json && response.json.success === false) {
+    throw new Error(
+      `${label} failed: ${response.json.errorCode ?? response.json.status ?? "business_error"} ${
+        response.json.errorMsg ?? ""
+      }`.trim(),
+    );
+  }
+
+  return response;
+}
+
+export async function getBrowserContext(
+  remoteDebuggingPort,
+  pageUrlIncludes = "platform.tuya.com/ai/workflow",
+) {
+  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 };
+}
+
+export function buildNetworkCapture(
+  context,
+  urlPattern = /workflow\/update|workflow\/get|workflow\/list|addBasic/i,
+) {
+  const events = [];
+
+  const onRequest = (request) => {
+    if (!urlPattern.test(request.url())) {
+      return;
+    }
+
+    events.push({
+      ts: new Date().toISOString(),
+      type: "request",
+      method: request.method(),
+      url: request.url(),
+      headers: request.headers(),
+      body: request.postData() ?? null,
+    });
+  };
+
+  const onResponse = async (response) => {
+    if (!urlPattern.test(response.url())) {
+      return;
+    }
+
+    let body = null;
+    try {
+      body = await response.text();
+    } catch {
+      body = null;
+    }
+
+    events.push({
+      ts: new Date().toISOString(),
+      type: "response",
+      status: response.status(),
+      url: response.url(),
+      headers: await response.allHeaders().catch(() => ({})),
+      body,
+    });
+  };
+
+  context.on("request", onRequest);
+  context.on("response", onResponse);
+
+  return {
+    events,
+    dispose() {
+      context.off("request", onRequest);
+      context.off("response", onResponse);
+    },
+  };
+}
+
+export async function pageFetchJson(
+  page,
+  pathOrUrl,
+  {
+    method = "POST",
+    body = null,
+    headers = {},
+    baseOrigin,
+  } = {},
+) {
+  const response = await page.evaluate(
+    async ({ pathOrUrl, method, body, headers, baseOrigin }) => {
+      const targetUrl = /^https?:\/\//i.test(pathOrUrl)
+        ? pathOrUrl
+        : new URL(pathOrUrl, baseOrigin ?? window.location.origin).toString();
+      const csrf =
+        globalThis.csrf ??
+        decodeURIComponent(
+          document.cookie.match(/(?:^|;\s*)csrf-token=([^;]+)/)?.[1] ?? "",
+        );
+
+      if (!csrf) {
+        return {
+          status: 0,
+          url: targetUrl,
+          headers: {},
+          text: "",
+          error: "Missing csrf-token in page context",
+        };
+      }
+
+      const finalHeaders = {
+        "content-type": "application/json; charset=UTF-8",
+        "x-requested-with": "XMLHttpRequest",
+        ...headers,
+      };
+
+      if (!Object.keys(finalHeaders).some((key) => key.toLowerCase() === "csrf-token")) {
+        finalHeaders["csrf-token"] = csrf;
+      }
+
+      const fetchResponse = await fetch(targetUrl, {
+        method,
+        headers: finalHeaders,
+        credentials: "include",
+        body: body === null ? undefined : JSON.stringify(body),
+      });
+
+      const responseHeaders = {};
+      fetchResponse.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+
+      return {
+        status: fetchResponse.status,
+        url: fetchResponse.url,
+        headers: responseHeaders,
+        text: await fetchResponse.text(),
+      };
+    },
+    { pathOrUrl, method, body, headers, baseOrigin },
+  );
+
+  return {
+    ...response,
+    json: safeJsonParse(response.text),
+  };
+}
+
+export async function createWorkflowViaPage(
+  page,
+  { workflowName, workflowDesc, workflowRegion, workflowType = 1 },
+  { baseOrigin } = {},
+) {
+  const response = await pageFetchJson(
+    page,
+    "/micro-app/exp/api/v2/aigc/workflow/addBasic",
+    {
+      body: {
+        params: {
+          workflowName,
+          workflowDesc,
+          workflowRegion,
+          workflowType,
+        },
+      },
+      baseOrigin,
+    },
+  );
+
+  requireApiSuccess("create workflow", response);
+
+  const workflowId = response.json?.result?.workflowId ?? null;
+  if (!workflowId) {
+    throw new Error("create workflow failed: missing workflowId");
+  }
+
+  return {
+    ...response,
+    workflowId,
+  };
+}
+
+export async function getWorkflowViaPage(page, workflowId, { baseOrigin } = {}) {
+  const response = await pageFetchJson(page, "/micro-app/ai/api/v2/aigc/workflow/get", {
+    body: {
+      params: {
+        workflowId,
+      },
+    },
+    baseOrigin,
+  });
+
+  requireApiSuccess("get workflow", response);
+  return response;
+}
+
+export async function updateWorkflowViaPage(
+  page,
+  { workflowId, editVersionNo = 1, schemaJson },
+  { baseOrigin } = {},
+) {
+  const response = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/update", {
+    body: {
+      params: {
+        workflowId,
+        editVersionNo,
+        schemaJson: JSON.stringify(schemaJson),
+      },
+    },
+    baseOrigin,
+  });
+
+  requireApiSuccess("update workflow", response);
+  return response;
+}
+
+export function readWorkflowSchema(detailResponse) {
+  const schemaText = detailResponse?.json?.result?.schemaJson;
+  const schemaJson = safeJsonParse(schemaText);
+  if (!schemaJson) {
+    throw new Error("get workflow failed: schemaJson missing or invalid");
+  }
+  return schemaJson;
+}
+
+export function pickLatestUpdateRequest(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event.type === "request" && /workflow\/update/.test(event.url) && event.body) {
+      return event;
+    }
+  }
+  return null;
+}
+
+export function extractSchemaNode(events, nodeType) {
+  const updateRequest = pickLatestUpdateRequest(events);
+  if (!updateRequest) {
+    return null;
+  }
+
+  const requestBody = safeJsonParse(updateRequest.body);
+  const schemaJson = safeJsonParse(requestBody?.params?.schemaJson);
+  const node = schemaJson?.nodes?.find((item) => item.type === nodeType) ?? null;
+
+  return {
+    updateRequest,
+    schemaJson,
+    node,
+  };
+}
+
+export function assertNodePresent(snapshot, nodeType) {
+  if (!snapshot?.node) {
+    throw new Error(`Expected node type ${nodeType} in workflow/update payload`);
+  }
+  return snapshot.node;
+}
+
+export async function discoverReleasedProjectCode(page, { baseOrigin } = {}) {
+  const response = await pageFetchJson(page, "/global/iotcommon/api/content/aigc/agent/list", {
+    body: {},
+    baseOrigin,
+  });
+
+  requireApiSuccess("list agents", response);
+
+  const projects = Array.isArray(response.json?.result) ? response.json.result : [];
+  const candidate = projects.find((item) => item.projectCode) ?? null;
+  if (!candidate) {
+    throw new Error("list agents failed: no projectCode available");
+  }
+
+  return {
+    response,
+    projectCode: candidate.projectCode,
+    projectName: candidate.projectName ?? null,
+  };
+}
+
+export async function publishAgentViaPage(page, { projectCode, region }, { baseOrigin } = {}) {
+  const response = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/publish/agent", {
+    body: {
+      params: {
+        projectCode,
+        region,
+      },
+    },
+    baseOrigin,
+  });
+
+  requireApiSuccess("publish agent", response);
+  return response;
+}
+
+export async function listKnowledgeLibrariesViaPage(page, { baseOrigin } = {}) {
+  const response = await pageFetchJson(page, "/micro-app/exp/api/aigc/model/library/list", {
+    body: {},
+    baseOrigin,
+  });
+
+  requireApiSuccess("list knowledge libraries", response);
+  return response;
+}
+
+export function debugOriginForRegion(region, fallbackBaseUrl) {
+  if (String(region).toUpperCase() === "AZ") {
+    return "https://us.platform.tuya.com";
+  }
+  return new URL(fallbackBaseUrl).origin;
+}
+
+export async function pollProgress(page, { baseOrigin, workflowId, executeId, retries = 8, intervalMs = 1_500 }) {
+  const attempts = [];
+
+  for (let index = 0; index < retries; index += 1) {
+    const progress = await pageFetchJson(page, "/micro-app/ai/api/aigc/workflow/test/progress", {
+      body: {
+        workflowId,
+        executeId,
+      },
+      baseOrigin,
+    });
+
+    attempts.push(progress);
+
+    if (progress.json?.success === false) {
+      break;
+    }
+
+    const status = progress.json?.result?.executeStatus;
+    if (status === 2 || status === 3) {
+      break;
+    }
+
+    await page.waitForTimeout(intervalMs);
+  }
+
+  return attempts;
+}
+
+export async function executeTrialRun(page, { baseOrigin, workflowId, endpointType, endpointId, inputArgs }) {
+  const execute = await pageFetchJson(page, "/micro-app/ai/api/v2/aigc/workflow/test/execute", {
+    body: {
+      params: {
+        workflowId,
+        inputArgs,
+        endpointType,
+        endpointId,
+      },
+    },
+    baseOrigin,
+  });
+  requireApiSuccess("test/execute", execute);
+
+  const executeId = execute.json?.result?.executeId ?? execute.json?.result;
+  if (!executeId) {
+    throw new Error("test/execute failed: missing executeId");
+  }
+
+  const progress = await pollProgress(page, {
+    baseOrigin,
+    workflowId,
+    executeId,
+  });
+
+  return {
+    execute,
+    executeId,
+    progress,
+  };
+}
+
+export async function uploadImageForTrialRun(page, imagePath, { baseOrigin, readFile, basename }) {
+  const fileBuffer = await readFile(imagePath);
+  const fileName = basename(imagePath);
+
+  const uploadSign = await pageFetchJson(page, "/global/api/assets/uploadSignV3", {
+    body: {
+      biz: "AI_PRIVATE",
+      uploadFileName: fileName,
+      isIE: false,
+    },
+    baseOrigin,
+  });
+  requireApiSuccess("uploadSignV3", uploadSign);
+
+  const action = uploadSign.json?.result?.action;
+  const uploadHeaders = uploadSign.json?.result?.headers ?? {};
+  const uploadToken = uploadSign.json?.result?.token;
+  if (!action || !uploadToken) {
+    throw new Error("uploadSignV3 failed: missing action or token");
+  }
+
+  const putResponse = await fetch(action, {
+    method: "PUT",
+    headers: uploadHeaders,
+    body: fileBuffer,
+  });
+  if (!putResponse.ok) {
+    throw new Error(`signed upload failed: HTTP ${putResponse.status}`);
+  }
+
+  const checkFileStatus = await pageFetchJson(page, "/global/api/assets/checkFileStatus", {
+    body: {
+      uploadToken,
+    },
+    baseOrigin,
+  });
+  requireApiSuccess("checkFileStatus", checkFileStatus);
+
+  const bizUrl = checkFileStatus.json?.result?.bizUrl;
+  if (!bizUrl) {
+    throw new Error("checkFileStatus failed: missing bizUrl");
+  }
+
+  const signature = await pageFetchJson(
+    page,
+    "/micro-app/ai/global/iotcommon/api/file/signature",
+    {
+      body: {
+        biz: "AI_PRIVATE",
+        files: [{ path: bizUrl }],
+      },
+      baseOrigin,
+    },
+  );
+  requireApiSuccess("file/signature", signature);
+
+  return {
+    uploadSign,
+    put: {
+      status: putResponse.status,
+      url: action,
+    },
+    checkFileStatus,
+    signature,
+    bizUrl,
+  };
+}