tuya-platform-cli 0.1.0

package/src/lib/schema-builder.js

@@ -0,0 +1,431 @@
+const START_NODE_ID = "100001";
+
+export function validateDefinition(definition) {
+  const errors = [];
+
+  if (!definition.name) {
+    errors.push("Missing required field: name");
+  }
+  if (!Array.isArray(definition.startOutputs) || definition.startOutputs.length === 0) {
+    errors.push("startOutputs must be a non-empty array");
+  }
+  if (!Array.isArray(definition.nodes) || definition.nodes.length === 0) {
+    errors.push("nodes must be a non-empty array");
+  }
+  if (!Array.isArray(definition.edges) || definition.edges.length === 0) {
+    errors.push("edges must be a non-empty array");
+  }
+  if (!Array.isArray(definition.ends) || definition.ends.length === 0) {
+    errors.push("ends must be a non-empty array");
+  }
+
+  const allIds = new Set(["start"]);
+  const nodeIds = (definition.nodes ?? []).map((n) => n.id);
+  const endIds = (definition.ends ?? []).map((e) => e.id);
+
+  for (const id of [...nodeIds, ...endIds]) {
+    if (allIds.has(id)) {
+      errors.push(`Duplicate node id: ${id}`);
+    }
+    allIds.add(id);
+  }
+
+  const validNodeIds = new Set(allIds);
+
+  for (const edge of definition.edges ?? []) {
+    const [source, target] = edge;
+    if (!validNodeIds.has(source)) {
+      errors.push(`Edge source "${source}" not found`);
+    }
+    if (!validNodeIds.has(target)) {
+      errors.push(`Edge target "${target}" not found`);
+    }
+  }
+
+  const outputMap = new Map();
+  for (const output of definition.startOutputs ?? []) {
+    outputMap.set(`start.${output.id}`, output);
+  }
+  for (const node of definition.nodes ?? []) {
+    for (const output of node.outputs ?? []) {
+      outputMap.set(`${node.id}.${output.id}`, output);
+    }
+  }
+
+  for (const node of definition.nodes ?? []) {
+    for (const input of node.inputs ?? []) {
+      if (input.ref && !outputMap.has(input.ref)) {
+        errors.push(`Input ref "${input.ref}" in node "${node.id}" not found`);
+      }
+    }
+  }
+
+  for (const end of definition.ends ?? []) {
+    if (end.input?.ref && !outputMap.has(end.input.ref)) {
+      errors.push(`Input ref "${end.input.ref}" in end "${end.id}" not found`);
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Definition validation failed:\n${errors.join("\n")}`);
+  }
+}
+
+function resolveNodeId(id) {
+  return id === "start" ? START_NODE_ID : id;
+}
+
+function resolveRef(ref, outputMap) {
+  const dotIndex = ref.indexOf(".");
+  const nodeId = ref.slice(0, dotIndex);
+  const outputId = ref.slice(dotIndex + 1);
+  const resolvedNodeId = resolveNodeId(nodeId);
+  const output = outputMap.get(ref);
+
+  return {
+    isRef: 1,
+    refNode: resolvedNodeId,
+    refId: outputId,
+    refName: output?.name ?? outputId,
+  };
+}
+
+function computeLayout(definition) {
+  const allIds = ["start", ...(definition.nodes ?? []).map((n) => n.id), ...(definition.ends ?? []).map((e) => e.id)];
+  const adjacency = new Map();
+  const inDegree = new Map();
+
+  for (const id of allIds) {
+    adjacency.set(id, []);
+    inDegree.set(id, 0);
+  }
+
+  for (const [source, target] of definition.edges) {
+    adjacency.get(source).push(target);
+    inDegree.set(target, (inDegree.get(target) ?? 0) + 1);
+  }
+
+  const column = new Map();
+  const tempInDegree = new Map(inDegree);
+  const queue = [];
+
+  for (const id of allIds) {
+    if (tempInDegree.get(id) === 0) {
+      queue.push(id);
+      column.set(id, 0);
+    }
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+
+    for (const neighbor of adjacency.get(current)) {
+      const newCol = (column.get(current) ?? 0) + 1;
+      column.set(neighbor, Math.max(column.get(neighbor) ?? 0, newCol));
+      tempInDegree.set(neighbor, tempInDegree.get(neighbor) - 1);
+      if (tempInDegree.get(neighbor) === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+
+  const columnGroups = new Map();
+  for (const [id, col] of column) {
+    if (!columnGroups.has(col)) {
+      columnGroups.set(col, []);
+    }
+    columnGroups.get(col).push(id);
+  }
+
+  const positions = new Map();
+  const centerY = 320;
+  const xStart = 100;
+  const xStep = 360;
+  const yStep = 280;
+
+  for (const [col, ids] of columnGroups) {
+    const x = xStart + col * xStep;
+    const totalHeight = (ids.length - 1) * yStep;
+    const startY = centerY - totalHeight / 2;
+
+    ids.forEach((id, index) => {
+      positions.set(id, { x, y: startY + index * yStep });
+    });
+  }
+
+  return positions;
+}
+
+function buildStartNode(definition, position) {
+  return {
+    id: START_NODE_ID,
+    type: "Start",
+    meta: { position },
+    data: {
+      title: "Start",
+      nodeMeta: {
+        title: "开始",
+        description: "支持中间过程的消息输出，支持流式和非流式两种方式",
+      },
+      outputs: definition.startOutputs.map((output) => ({
+        disableEdit: false,
+        id: output.id,
+        name: output.id,
+        required: output.required ?? false,
+        type: output.type ?? "string",
+      })),
+      version: 1,
+    },
+  };
+}
+
+function buildLLMNode(nodeDef, position, outputMap) {
+  const inputs = (nodeDef.inputs ?? []).map((input) => {
+    const refResult = input.ref ? resolveRef(input.ref, outputMap) : {};
+    return {
+      constantValue: "",
+      disableEdit: false,
+      id: input.id,
+      ...refResult,
+      name: input.name ?? "input",
+      type: input.type ?? "string",
+    };
+  });
+
+  const outputs = (nodeDef.outputs ?? []).map((output) => ({
+    disableEdit: false,
+    id: output.id,
+    name: output.name ?? "output",
+    type: output.type ?? "string",
+  }));
+
+  const params = nodeDef.params ?? {};
+
+  return {
+    id: nodeDef.id,
+    type: "LLM",
+    meta: { position },
+    data: {
+      title: nodeDef.title ?? "大模型",
+      nodeMeta: {
+        description: "调用大语言模型,使用变量和提示词生成回复",
+        title: "大模型",
+      },
+      exceptionSetting: {
+        timeout: 60,
+        retryTimes: 0,
+        strategy: 0,
+        portId: "",
+      },
+      inputs,
+      nodeParam: {
+        model: params.model ?? "160",
+        outputType: params.outputType ?? 1,
+        skills: params.skills ?? [],
+        systemPrompt: params.systemPrompt ?? "",
+        useHistory: params.useHistory ?? 0,
+        userPrompt: params.userPrompt ?? "",
+      },
+      outputs,
+      version: 1,
+      visionInputs: [],
+    },
+  };
+}
+
+function buildSelectNode(nodeDef, position) {
+  const conditions = nodeDef.conditions ?? [];
+  const selectConditions = {};
+
+  conditions.forEach((cond, index) => {
+    selectConditions[index] = {
+      portId: cond.portId,
+      conditionList: (cond.rules ?? []).map((rule) => ({
+        conditionId: rule.conditionId,
+        prerequisites: {
+          id: rule.prerequisitesId ?? `pre_${rule.conditionId}`,
+          name: rule.ref ? rule.ref.split(".")[1] : "",
+          type: rule.type ?? "string",
+          isRef: rule.ref ? 1 : 0,
+          constantValue: "",
+        },
+        postcondition: {
+          id: rule.postconditionId ?? `post_${rule.conditionId}`,
+          name: "",
+          type: rule.type ?? "string",
+          isRef: 0,
+          constantValue: rule.value ?? "",
+        },
+        judge: rule.judge ?? "=",
+      })),
+      conditionRelation: cond.conditionRelation ?? "&&",
+    };
+  });
+
+  selectConditions["-1"] = {
+    portId: nodeDef.elsePortId ?? "condition_else_port",
+  };
+
+  return {
+    id: nodeDef.id,
+    type: "Select",
+    meta: { position },
+    data: {
+      title: nodeDef.title ?? "选择器",
+      nodeMeta: {
+        title: "选择器",
+        description: "连接多个下游分支，若设定的条件成立则仅运行对应的分支，若均不成立则只运行\u201C否则\u201D分支",
+      },
+      exceptionSetting: {
+        timeout: 60,
+        retryTimes: 0,
+        strategy: 0,
+        portId: "",
+      },
+      inputs: [],
+      outputs: [],
+      nodeParam: {
+        selectConditions,
+      },
+    },
+  };
+}
+
+function buildSearchKnowledgeNode(nodeDef, position, outputMap) {
+  const inputs = (nodeDef.inputs ?? []).map((input) => {
+    const refResult = input.ref ? resolveRef(input.ref, outputMap) : {};
+    return {
+      constantValue: "",
+      disableEdit: false,
+      id: input.id,
+      ...refResult,
+      name: input.name ?? "query",
+      type: input.type ?? "string",
+    };
+  });
+
+  const outputs = (nodeDef.outputs ?? []).map((output) => ({
+    disableEdit: false,
+    id: output.id,
+    name: output.name ?? "data",
+    type: output.type ?? "string",
+  }));
+
+  const params = nodeDef.params ?? {};
+
+  return {
+    id: nodeDef.id,
+    type: "SearchKnowledge",
+    meta: { position },
+    data: {
+      title: nodeDef.title ?? "知识库检索",
+      nodeMeta: {
+        title: "知识库检索",
+        description: "在选定的知识中,根据输入变量召回最匹配的信息,并以列表形式返回",
+      },
+      inputs,
+      nodeParam: {
+        libResource: params.libResource ?? [],
+        maxRecallNum: params.maxRecallNum ?? 5,
+        searchStrategy: params.searchStrategy ?? 1,
+        similarity: params.similarity ?? 0.7,
+      },
+      outputs,
+      version: 1,
+    },
+  };
+}
+
+function buildEndNode(endDef, position, outputMap) {
+  const inputs = [];
+  if (endDef.input) {
+    const refResult = endDef.input.ref ? resolveRef(endDef.input.ref, outputMap) : {};
+    inputs.push({
+      constantValue: "",
+      disableEdit: false,
+      id: endDef.input.id,
+      ...refResult,
+      name: endDef.input.name ?? refResult.refName ?? "output",
+      type: endDef.input.type ?? "string",
+    });
+  }
+
+  return {
+    id: endDef.id,
+    type: "End",
+    meta: { position },
+    data: {
+      title: endDef.title ?? "输出",
+      nodeMeta: {
+        description: "支持中间过程的消息输出，支持流式和非流式两种方式",
+        title: "输出",
+      },
+      nodeParam: {
+        isStream: 0,
+        outputContent: "",
+        saveRecord: true,
+        tts: true,
+      },
+      inputs,
+      visionInputs: [],
+      audioInputs: [],
+      outputs: [],
+      version: 1,
+    },
+  };
+}
+
+export function buildSchemaFromDefinition(definition) {
+  const outputMap = new Map();
+  for (const output of definition.startOutputs) {
+    outputMap.set(`start.${output.id}`, { name: output.id, type: output.type ?? "string" });
+  }
+  for (const node of definition.nodes) {
+    for (const output of node.outputs ?? []) {
+      outputMap.set(`${node.id}.${output.id}`, { name: output.name ?? "output", type: output.type ?? "string" });
+    }
+  }
+
+  const positions = computeLayout(definition);
+
+  const nodes = [];
+
+  nodes.push(buildStartNode(definition, positions.get("start") ?? { x: 100, y: 320 }));
+
+  for (const nodeDef of definition.nodes) {
+    const position = positions.get(nodeDef.id) ?? { x: 460, y: 320 };
+
+    switch (nodeDef.type) {
+      case "LLM":
+        nodes.push(buildLLMNode(nodeDef, position, outputMap));
+        break;
+      case "Select":
+        nodes.push(buildSelectNode(nodeDef, position));
+        break;
+      case "SearchKnowledge":
+        nodes.push(buildSearchKnowledgeNode(nodeDef, position, outputMap));
+        break;
+      default:
+        throw new Error(`Unsupported node type: ${nodeDef.type}`);
+    }
+  }
+
+  for (const endDef of definition.ends) {
+    const position = positions.get(endDef.id) ?? { x: 820, y: 320 };
+    nodes.push(buildEndNode(endDef, position, outputMap));
+  }
+
+  const edges = definition.edges.map(([source, target]) => ({
+    sourceNodeID: resolveNodeId(source),
+    targetNodeID: resolveNodeId(target),
+  }));
+
+  return {
+    editVersionNo: 1,
+    nodes,
+    edges,
+    workflow: {
+      region: definition.region ?? "AZ",
+    },
+  };
+}

package/src/lib/selectors.js

@@ -0,0 +1,12 @@
+// Centralized CSS selectors for Tuya workflow platform UI elements.
+// These class names are build artifacts and may change with platform updates.
+
+export const SELECTORS = {
+  NODE_PANEL_ITEM: ".node-panel_nodeItem__1AnsQ",
+  FLOW_ACTIVITY_NODE: ".gedit-flow-activity-node",
+  CODE_MIRROR_EDITOR: '.cm-content[contenteditable="true"]',
+  MODAL_WRAP: ".ant-modal-wrap",
+  SELECT_SELECTOR: ".ant-select-selector",
+  SELECT_DROPDOWN_OPTION: ".ant-select-dropdown .ant-select-item-option-content",
+  MORE_ICON: ".icon-gengduo",
+};

package/src/lib/steps.js

@@ -0,0 +1,50 @@
+export const STEPS = [
+  {
+    id: "step-01-list-load",
+    title: "工作流列表加载",
+    instruction:
+      "在浏览器中打开工作流列表页，等待列表、筛选栏和表格加载完成，不要额外点击。",
+  },
+  {
+    id: "step-02-create-workflow",
+    title: "创建工作流",
+    instruction:
+      '点击“创建工作流”，填写名称“测试工作流”、描述“test”，如弹窗有数据中心字段则选择“美西”，然后确认创建。',
+  },
+  {
+    id: "step-03-detail-load",
+    title: "工作流详情加载",
+    instruction:
+      "进入新建工作流的编辑页，等待编辑器初始化完成，不要立即拖动画布。",
+  },
+  {
+    id: "step-04-add-intent-node",
+    title: "添加节点 - 意图识别节点",
+    instruction:
+      '点击“添加节点”，选择“意图识别”，模式选择“极速”，至少添加一个意图条目并保存该节点配置。',
+  },
+  {
+    id: "step-05-add-llm-node",
+    title: "添加节点 - 大模型节点",
+    instruction:
+      '点击“添加节点”，选择“大模型”，选第一个可用模型，填写系统提示词和用户提示词并确认。',
+  },
+  {
+    id: "step-06-save-workflow",
+    title: "保存工作流",
+    instruction:
+      "执行画布保存，等待保存完成。本步骤是最关键抓取点，保存完成前不要进行其他操作。",
+  },
+  {
+    id: "step-07-trial-run",
+    title: "试运行",
+    instruction:
+      '点击“试运行”，数据中心选“美西”，输入 `USER_TEXT=你好`，执行并等待结果流完全结束。',
+  },
+  {
+    id: "step-08-delete-workflow",
+    title: "删除工作流",
+    instruction:
+      '返回工作流列表页，通过 hover 打开操作菜单，删除刚创建的“测试工作流”并确认。',
+  },
+];

package/src/lib/util.js

@@ -0,0 +1,93 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+export function expandHome(inputPath) {
+  if (inputPath == null) {
+    throw new TypeError("expandHome: path must not be null or undefined");
+  }
+
+  if (inputPath === "~") {
+    return os.homedir();
+  }
+
+  if (inputPath.startsWith("~/")) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+
+  return inputPath;
+}
+
+export async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+  return dirPath;
+}
+
+export async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export async function writeText(filePath, text) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, text, "utf8");
+}
+
+export function slugify(value) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64);
+}
+
+export function timestampForFile(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+
+export function safeJsonParse(text) {
+  if (typeof text !== "string" || text.length === 0) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+export async function prompt(message) {
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    return await rl.question(message);
+  } finally {
+    rl.close();
+  }
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function trimBody(body, limit = 200_000) {
+  if (body == null) {
+    return body;
+  }
+
+  const stringBody = typeof body === "string" ? body : JSON.stringify(body);
+  if (Buffer.byteLength(stringBody, "utf8") <= limit) {
+    return stringBody;
+  }
+
+  const buf = Buffer.from(stringBody, "utf8");
+  let end = limit;
+  // Avoid truncating in the middle of a multi-byte UTF-8 character
+  while (end > 0 && (buf[end] & 0xc0) === 0x80) {
+    end -= 1;
+  }
+  return `${buf.toString("utf8", 0, end)}\n...<truncated>`;
+}