@shulex/cxclawctl 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 
 // src/auth.ts
 import open from "open";
@@ -9,7 +9,7 @@ import open from "open";
 // package.json
 var package_default = {
   name: "@shulex/cxclawctl",
-  version: "0.1.4",
+  version: "0.1.6",
   description: "Solvea CXClaw CLI and Codex plugin runtime",
   type: "module",
   bin: {
@@ -38,6 +38,7 @@ var package_default = {
   },
   dependencies: {
     "@alicloud/log": "^1.2.6",
+    "@aws-sdk/client-s3": "^3.1156.0",
     "@napi-rs/keyring": "^2.1.2",
     "compare-versions": "^6.1.1",
     exceljs: "^4.4.0",
@@ -189,13 +190,32 @@ function positionals(args) {
 }
 
 // src/business.ts
-import { dirname, resolve } from "path";
+import { dirname as dirname2, resolve } from "path";
 import { fileURLToPath } from "url";
 
 // src/solvea/commands.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 
 // src/solvea/client.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { basename, dirname, extname } from "path";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+var KNOWLEDGE_TYPES = /* @__PURE__ */ new Set(["QA", "LEARN_SELF", "FILE", "WEBSITE", "PRODUCT"]);
+var asObject = (value, message) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
+  return value;
+};
+var asPositiveInt = (value, message) => {
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error(message);
+  return number;
+};
+var knowledgeType = (value) => {
+  const normalized = String(value ?? "").toUpperCase();
+  if (!KNOWLEDGE_TYPES.has(normalized)) throw new Error("knowledge type must be QA, LEARN_SELF, FILE, WEBSITE, or PRODUCT");
+  return normalized;
+};
+var isolationKnowledgeType = (value) => ({ QA: "QA", LEARN_SELF: "QA", FILE: "DOCUMENT", WEBSITE: "DOCUMENT", PRODUCT: "PRODUCT" })[knowledgeType(value)];
 var SolveaClient = class {
   constructor(session) {
     this.session = session;
@@ -304,14 +324,25 @@ var SolveaClient = class {
     return this.post("/api_v2/gpt/ap/createAgent", { projectId: Number(await this.projectId()), ...data3 });
   }
   async updateAgent(data3) {
-    return this.post("/api_v2/gpt/ap/updateAgent", data3);
+    const payload = { ...data3, projectId: Number(await this.projectId()) };
+    if (payload.agentId === void 0 && payload.id !== void 0) payload.agentId = payload.id;
+    return this.post("/api_v2/gpt/ap/updateAgent", payload);
   }
   async updateChatflow(agentId, graph, publish = false) {
     const current = await this.getAgent(agentId);
     const agent = Array.isArray(current) ? current[0] : current;
     if (!agent || agent.type !== "CHAT_FLOW") throw new Error(`Agent ${agentId} is not CHAT_FLOW`);
+    if (!graph || !Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) throw new Error("chatFlowGraph must be an object with nodes and edges");
     const payload = { ...agent, agentId: agent.id ?? Number(agentId), meta: { ...agent.meta ?? {}, chatFlowGraph: graph } };
-    return this.updateAgent({ ...payload, ...publish ? { publish: true } : {} });
+    if (publish) {
+      delete payload.backupType;
+      delete payload.meta.backupType;
+      delete payload.meta.draft_flow_updatetime;
+    } else {
+      payload.backupType = "DRAFT";
+      payload.meta.draft_flow_updatetime = Date.now();
+    }
+    return this.updateAgent(payload);
   }
   async listPlugins() {
     return this.post("/api_v2/gpt/ap/queryPlugin", { projectId: Number(await this.projectId()), needRelation: false });
@@ -323,7 +354,9 @@ var SolveaClient = class {
     return this.post("/api_v2/gpt/ap/createPlugin", { projectId: Number(await this.projectId()), ...data3 });
   }
   async updatePlugin(data3) {
-    return this.post("/api_v2/gpt/ap/updatePlugin", { projectId: Number(await this.projectId()), ...data3 });
+    const payload = { projectId: Number(await this.projectId()), ...data3 };
+    if (payload.pluginId === void 0 && payload.id !== void 0) payload.pluginId = payload.id;
+    return this.post("/api_v2/gpt/ap/updatePlugin", payload);
   }
   async deletePlugin(id) {
     return this.post("/api_v2/gpt/ap/deletePlugin", { projectId: Number(await this.projectId()), pluginId: Number(id) });
@@ -375,11 +408,48 @@ var SolveaClient = class {
   }
   async chat(data3) {
     const bot = String(data3.botId ?? await this.botId());
-    return this.post(`/api_v2/gpt/bot/${bot}/chat`, { botId: Number(bot), projectId: Number(await this.projectId()), option: { debug: true }, ...data3 });
+    return this.post(`/api_v2/gpt/bot/${bot}/chat`, { ...data3, botId: Number(bot), projectId: Number(await this.projectId()), option: data3.option ?? { debug: true } });
+  }
+  async chatStream(data3) {
+    const bot = String(data3.botId ?? await this.botId());
+    const body = { ...data3, botId: Number(bot), projectId: Number(await this.projectId()), option: data3.option ?? { debug: true } };
+    const cookie = this.env === "prod" ? "_token" : "_token_staging";
+    const response = await fetch(`${this.baseUrl}/api_v2/gpt/bot/${encodeURIComponent(bot)}/chat/stream`, {
+      method: "POST",
+      headers: {
+        accept: "text/event-stream",
+        "content-type": "application/json",
+        origin: this.baseUrl,
+        referer: `${this.baseUrl}/chatbot`,
+        cookie: `${cookie}=${this.session.tenant.businessToken}`,
+        "x-cxclaw-client-version": process.env.CXCLAW_PLUGIN_VERSION ?? "unknown"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await response.text();
+    if (!response.ok) throw new Error(`HTTP ${response.status} POST /api_v2/gpt/bot/${bot}/chat/stream: ${text}`);
+    let finalAction;
+    const content = [];
+    for (const line of text.split(/\r?\n/)) {
+      if (!line.startsWith("data:")) continue;
+      const raw = line.slice(5).trim();
+      if (!raw) continue;
+      let event;
+      try {
+        event = asObject(JSON.parse(raw), "stream event must be an object");
+      } catch {
+        continue;
+      }
+      if (event.errno !== void 0 && ![0, "0"].includes(event.errno)) throw new Error(`API error POST /api_v2/gpt/bot/${bot}/chat/stream: ${String(event.errmsg ?? event.message ?? event.errno)}`);
+      if (event.content) content.push(String(event.content));
+      if (event.isEnd) finalAction = event.data && typeof event.data === "object" && !Array.isArray(event.data) ? event.data : event;
+    }
+    return finalAction ?? { content: content.join(""), isEnd: true };
   }
   async chatAsync(data3) {
     const bot = String(data3.botId ?? await this.botId());
-    return this.post(`/api_v2/gpt/bot/${bot}/chat/async`, { botId: Number(bot), projectId: Number(await this.projectId()), option: { debug: true }, ...data3 });
+    return this.post(`/api_v2/gpt/bot/${bot}/chat/async`, { ...data3, botId: Number(bot), projectId: Number(await this.projectId()), option: data3.option ?? { debug: true } });
   }
   async asyncResult(receipt, botId) {
     const bot = botId ?? await this.botId();
@@ -410,10 +480,10 @@ var SolveaClient = class {
     return this.post(`/api_v2/gpt/project/${await this.projectId()}/strategy?v4=true`, data3);
   }
   async updateStrategy(id, data3) {
-    return this.request("PUT", `/api_v2/gpt/project/${await this.projectId()}/strategy/${encodeURIComponent(id)}`, data3);
+    return this.request("PUT", `/api_v2/gpt/project/${await this.projectId()}/strategy/${encodeURIComponent(id)}`, data3, { v4: "true" });
   }
   async toggleStrategy(id, enabled2) {
-    return this.request("PUT", `/api_v2/gpt/project/${await this.projectId()}/strategy/${encodeURIComponent(id)}/status`, { status: enabled2 ? "ENABLED" : "DISABLED" });
+    return this.request("PUT", `/api_v2/gpt/project/${await this.projectId()}/strategy/${encodeURIComponent(id)}`, { status: enabled2 ? "ENABLED" : "DISABLED" }, { v4: "true" });
   }
   async qualityStatus() {
     return this.get("/api_v2/intelli/inspection/ticket/status");
@@ -494,11 +564,212 @@ var SolveaClient = class {
   async getKnowledge(id) {
     return this.get(`${this.qamPrefix}/project/${await this.projectId()}/ku/${encodeURIComponent(id)}`);
   }
+  async getDocument(id) {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/document/${encodeURIComponent(id)}`);
+  }
+  async getProductKnowledge(id) {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/ku_product/${encodeURIComponent(id)}`);
+  }
+  async getKnowledgeByType(id, type) {
+    const normalized = knowledgeType(type);
+    if (normalized === "FILE" || normalized === "WEBSITE") return this.getDocument(id);
+    if (normalized === "PRODUCT") return this.getProductKnowledge(id);
+    return this.getKnowledge(id);
+  }
   async updateKnowledge(id, data3) {
-    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/ku`, { ...data3, kuId: Number(id) });
+    const payload = { ...data3 };
+    if (payload.directoryId === void 0) {
+      const current = asObject(await this.getKnowledge(id), `could not read knowledge ${id} before update`);
+      if (current.directoryId !== void 0) payload.directoryId = current.directoryId;
+    }
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/ku`, { ...payload, kuId: asPositiveInt(id, "knowledge id must be a positive integer") });
   }
   async uploadQa(items) {
-    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/kus`, items);
+    if (!Array.isArray(items) || !items.length) throw new Error("QA items must be a non-empty array");
+    const payload = items.map((value, index) => {
+      const item = asObject(value, `QA item #${index + 1} must be an object`);
+      const title = String(item.title ?? "").trim();
+      const content = String(item.content ?? "").trim();
+      if (!title) throw new Error(`QA item #${index + 1} requires title`);
+      if (!content) throw new Error(`QA item #${index + 1} requires content`);
+      return {
+        title,
+        content,
+        forceIndex: item.forceIndex ?? true,
+        type: "QA",
+        published: item.published ?? true,
+        taskType: item.taskType ?? "MANUAL",
+        metadata: item.metadata ?? { tags: [] },
+        directoryId: item.directoryId ?? "",
+        isVisible: item.isVisible ?? true
+      };
+    });
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/kus`, payload);
+  }
+  async createDocuments(documents, directoryId, taskType) {
+    if (!documents.length) throw new Error("documents must be a non-empty array");
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/documents`, {
+      documents,
+      published: true,
+      taskType,
+      taskUrl: "MANUAL",
+      isFullSiteCrawl: false,
+      metadata: { tags: [] },
+      directoryId,
+      isVisible: true
+    });
+  }
+  async uploadTempFile(filePath, forKnowledge = false) {
+    const credentialPath = forKnowledge ? `${this.qamPrefix}/project/${await this.projectId()}/sts_credentials` : `/api_v2/gpt/project/${await this.projectId()}/sts_credentials`;
+    const credentials = asObject(
+      await this.get(credentialPath),
+      "STS credentials must be an object"
+    );
+    const required = ["accessKeyId", "secretAccessKey", "sessionToken", "region", "bucketName", "path"];
+    const missing = required.filter((key2) => !credentials[key2]);
+    if (missing.length) throw new Error(`knowledge STS credentials missing fields: ${missing.join(", ")}`);
+    const key = `${String(credentials.path)}${basename(filePath)}`;
+    const client = new S3Client({
+      region: String(credentials.region),
+      credentials: {
+        accessKeyId: String(credentials.accessKeyId),
+        secretAccessKey: String(credentials.secretAccessKey),
+        sessionToken: String(credentials.sessionToken)
+      }
+    });
+    const contentTypes = {
+      ".doc": "application/msword",
+      ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".pdf": "application/pdf"
+    };
+    await client.send(new PutObjectCommand({
+      Bucket: String(credentials.bucketName),
+      Key: key,
+      Body: await readFile(filePath),
+      ContentType: contentTypes[extname(filePath).toLowerCase()] ?? "application/octet-stream"
+    }));
+    return key;
+  }
+  async uploadKnowledgeFile(filePath) {
+    return this.uploadTempFile(filePath, true);
+  }
+  async downloadFile(path, target, query2) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query2 ?? {})) url.searchParams.set(key, String(value));
+    const cookie = this.env === "prod" ? "_token" : "_token_staging";
+    const response = await fetch(url, {
+      headers: { accept: "*/*", origin: this.baseUrl, referer: `${this.baseUrl}/chatbot`, cookie: `${cookie}=${this.session.tenant.businessToken}` },
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status} GET ${path}: ${await response.text()}`);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, new Uint8Array(await response.arrayBuffer()));
+    return target;
+  }
+  async downloadLabelTemplate(templateType, target) {
+    if (!["VOC_LABEL", "VOC_LABEL_INIT"].includes(templateType)) throw new Error("template type must be VOC_LABEL or VOC_LABEL_INIT");
+    return this.downloadFile(`/api_v2/gpt/label/project/${await this.projectId()}/downloadLabelTemplate`, target, { type: templateType });
+  }
+  async downloadLabels(treeId, target) {
+    return this.downloadFile(`/api_v2/gpt/label/project/${await this.projectId()}/downloadLabel`, target, { treeId: asPositiveInt(treeId, "tree id must be a positive integer") });
+  }
+  async uploadLabelFile(treeId, filePath, init = false) {
+    const fileKey = await this.uploadTempFile(filePath);
+    const result = await this.post(`/api_v2/gpt/label/project/${await this.projectId()}/uploadLabel`, {
+      treeId: asPositiveInt(treeId, "tree id must be a positive integer"),
+      file: fileKey,
+      ...init ? { uploadWay: "INIT" } : {}
+    });
+    return { fileKey, result };
+  }
+  async updateKus(value) {
+    const source = Array.isArray(value) ? value : asObject(value, "batch knowledge update must be an array or object with list").list;
+    if (!Array.isArray(source) || !source.length) throw new Error("batch knowledge update requires a non-empty array");
+    const list = [];
+    for (const [index, value2] of source.entries()) {
+      const row = { ...asObject(value2, `batch knowledge item #${index + 1} must be an object`) };
+      row.kuId = asPositiveInt(row.kuId ?? row.id, `batch knowledge item #${index + 1} requires kuId or id`);
+      delete row.id;
+      if (row.directoryId === void 0) {
+        const current = asObject(await this.getKnowledge(String(row.kuId)), `could not read knowledge ${row.kuId} before update`);
+        if (current.directoryId !== void 0) row.directoryId = current.directoryId;
+      }
+      list.push(row);
+    }
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/kus`, { list });
+  }
+  async updateDocumentContent(id, type, changes) {
+    const normalized = knowledgeType(type);
+    if (normalized !== "FILE" && normalized !== "WEBSITE") throw new Error("document type must be FILE or WEBSITE");
+    const unknown = Object.keys(changes).filter((key) => !["fileText", "filePath", "title"].includes(key));
+    if (unknown.length) throw new Error(`unsupported document content fields: ${unknown.sort().join(", ")}`);
+    if (changes.fileText === void 0 && changes.filePath === void 0) throw new Error("document update requires fileText or filePath");
+    const documentId = asPositiveInt(id, "document id must be a positive integer");
+    const current = asObject(await this.getDocument(id), `could not read document ${id} before update`);
+    const payload = {
+      type: normalized,
+      directoryId: current.directoryId,
+      fileName: current.fileName ?? current.name ?? current.title,
+      title: current.title ?? current.fileName ?? current.name,
+      metadata: current.metadata && typeof current.metadata === "object" && !Array.isArray(current.metadata) ? current.metadata : {},
+      ...changes,
+      knowledgeIds: [documentId]
+    };
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/document/${documentId}/contentV2`, payload);
+  }
+  async createProductKnowledge(data3) {
+    if (!data3.title || !data3.spuUrl) throw new Error("product knowledge requires title and spuUrl");
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/ku_product`, {
+      source: "MANUAL",
+      published: true,
+      isVisible: true,
+      metadata: { tags: [] },
+      ...data3
+    });
+  }
+  async updateProductKnowledge(id, changes) {
+    const allowed = /* @__PURE__ */ new Set(["productId", "tags", "documentId", "title", "handle", "vendor", "category", "brand", "productStatus", "country", "spuUrl", "image", "platform", "currency", "price", "compareAtPrice", "describe", "source", "skuList", "directoryId", "published", "metadata", "specialTagMap", "isVisible", "optionName"]);
+    const unknown = Object.keys(changes).filter((key) => !allowed.has(key) && key !== "id" && key !== "kuProductId");
+    if (unknown.length) throw new Error(`unsupported product fields: ${unknown.sort().join(", ")}`);
+    const current = asObject(await this.getProductKnowledge(id), `could not read product knowledge ${id} before update`);
+    const payload = {};
+    for (const key of allowed) if (current[key] !== void 0) payload[key] = current[key];
+    for (const key of allowed) if (changes[key] !== void 0) payload[key] = changes[key];
+    const missing = ["title", "describe", "spuUrl", "image", "source", "published", "isVisible"].filter((key) => payload[key] === void 0 || payload[key] === "");
+    if (missing.length) throw new Error(`product detail is incomplete: ${missing.join(", ")}`);
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/ku_product`, { ...payload, kuProductId: asPositiveInt(id, "product id must be a positive integer") });
+  }
+  async updateKuProducts(value) {
+    const source = Array.isArray(value) ? value : asObject(value, "batch product update must be an array or object with list").list;
+    if (!Array.isArray(source) || !source.length) throw new Error("batch product update requires a non-empty array");
+    const list = source.map((value2, index) => {
+      const row = asObject(value2, `batch product item #${index + 1} must be an object`);
+      const entry2 = { id: asPositiveInt(row.id ?? row.kuProductId, `batch product item #${index + 1} requires id or kuProductId`) };
+      if (row.mainPush !== void 0) entry2.mainPush = Boolean(row.mainPush);
+      if (row.enable !== void 0) entry2.enable = Boolean(row.enable);
+      else if (row.published !== void 0) entry2.enable = Boolean(row.published);
+      return entry2;
+    });
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/ku_products`, { list });
+  }
+  async operateKnowledge(value, confirmDelete = false) {
+    const source = Array.isArray(value) ? value : asObject(value, "knowledge operation must be an array or object with requestList").requestList;
+    if (!Array.isArray(source) || !source.length) throw new Error("knowledge operation requires a non-empty array");
+    const supportedOperations = /* @__PURE__ */ new Set(["DELETE", "MOVE", "PUBLISH", "UNPUBLISH", "VISIBLE", "INVISIBLE"]);
+    const requestList = [];
+    for (const [index, value2] of source.entries()) {
+      const row = asObject(value2, `knowledge operation #${index + 1} must be an object`);
+      const type = knowledgeType(row.knowledgeType);
+      const operateType = String(row.operateType ?? "").toUpperCase();
+      if (!supportedOperations.has(operateType)) throw new Error(`unsupported knowledge operation: ${operateType}`);
+      const knowledgeId = asPositiveInt(row.knowledgeId, `knowledge operation #${index + 1} requires knowledgeId`);
+      await this.getKnowledgeByType(String(knowledgeId), type);
+      const normalized = { knowledgeType: type, knowledgeId, operateType };
+      if (operateType === "MOVE") normalized.directoryId = asPositiveInt(row.directoryId, "MOVE requires directoryId");
+      requestList.push(normalized);
+    }
+    if (requestList.some((item) => item.operateType === "DELETE") && !confirmDelete) throw new Error("DELETE requires --confirm-delete after explicit user acknowledgement");
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/updateKnowledge`, { requestList });
   }
   async listDirectories() {
     return this.get(`${this.qamPrefix}/project/${await this.projectId()}/directories`, { keyword: "", kuPublished: "" });
@@ -515,12 +786,111 @@ var SolveaClient = class {
   async knowledgeTags(keyword = "") {
     return this.get(`${this.qamPrefix}/project/${await this.projectId()}/searchKeywordAndIntents`, { keyword });
   }
+  async moveDirectory(id, parentId) {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/directory/move`, { currentId: asPositiveInt(id, "directory id must be a positive integer"), parentId: Number(parentId) });
+  }
+  async getKnowledgeIsolationKeywords(id, type) {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/knowledge/isolation_keywords`, { knowledgeType: isolationKnowledgeType(type), knowledgeId: asPositiveInt(id, "knowledge id must be a positive integer") });
+  }
+  async batchUpdateIsolationKeywordBindings(data3) {
+    const items = data3.items ?? [], directoryIds = data3.directoryIds ?? [], keywordIds = data3.keywordIds ?? [];
+    if (!Array.isArray(items) || !Array.isArray(directoryIds) || !Array.isArray(keywordIds)) throw new Error("items, directoryIds and keywordIds must be arrays");
+    if (!items.length && !directoryIds.length && !keywordIds.length) throw new Error("isolation keyword binding update has no targets or keyword IDs");
+    if (items.length && directoryIds.length) throw new Error("submit knowledge items and directory IDs in separate binding updates");
+    const normalizedItems = items.map((value, index) => {
+      const row = asObject(value, `isolation binding item #${index + 1} must be an object`);
+      if (!Array.isArray(row.keywordIds)) throw new Error("items[].keywordIds must be an array");
+      return {
+        knowledgeType: isolationKnowledgeType(row.knowledgeType ?? "QA"),
+        knowledgeId: asPositiveInt(row.knowledgeId, "items[].knowledgeId must be a positive integer"),
+        keywordIds: [...new Set(row.keywordIds.map((value2) => asPositiveInt(value2, "items[].keywordIds must contain positive integer IDs")))]
+      };
+    });
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/knowledge/isolation_keywords/batch`, {
+      items: normalizedItems,
+      directoryIds: [...new Set(directoryIds.map((value) => asPositiveInt(value, "directoryIds must contain positive integer IDs")))],
+      keywordIds: [...new Set(keywordIds.map((value) => asPositiveInt(value, "keywordIds must contain positive integer IDs")))]
+    });
+  }
+  async applyIsolationKeywordBindings(data3) {
+    const operation = String(data3.operation ?? "append").toLowerCase();
+    if (!["append", "remove", "replace"].includes(operation)) throw new Error("operation must be append, remove, or replace");
+    const items = data3.items ?? [], directoryIds = data3.directoryIds ?? [];
+    if (!Array.isArray(items) || !Array.isArray(directoryIds) || !items.length && !directoryIds.length) throw new Error("binding update requires knowledge items or directory IDs");
+    if (items.length && directoryIds.length) throw new Error("submit knowledge items and directory IDs in separate binding updates");
+    if (directoryIds.length && operation !== "replace") throw new Error("directory bindings require operation=replace");
+    if ((directoryIds.length || operation === "replace") && data3.confirmReplace !== true) throw new Error("binding replacement requires confirmReplace=true after explicit user confirmation");
+    const resolvedItems = [];
+    for (const [index, value] of items.entries()) {
+      const row = asObject(value, `isolation binding item #${index + 1} must be an object`);
+      const id = asPositiveInt(row.knowledgeId, "items[].knowledgeId must be a positive integer");
+      const type = knowledgeType(row.knowledgeType);
+      if (!Array.isArray(row.keywordIds)) throw new Error("items[].keywordIds must be an array");
+      const requestedIds = row.keywordIds.map((value2) => asPositiveInt(value2, "items[].keywordIds must contain positive integer IDs"));
+      await this.getKnowledgeByType(String(id), type);
+      const existingResponse = await this.getKnowledgeIsolationKeywords(String(id), type);
+      const existingRows = Array.isArray(existingResponse) ? existingResponse : existingResponse && typeof existingResponse === "object" && Array.isArray(existingResponse.list) ? existingResponse.list : [];
+      const existingIds = existingRows.map((value2) => asPositiveInt(asObject(value2, "existing isolation keyword binding must be an object").id, "existing isolation keyword binding has an invalid ID"));
+      const finalIds = operation === "append" ? [.../* @__PURE__ */ new Set([...existingIds, ...requestedIds])] : operation === "remove" ? existingIds.filter((id2) => !requestedIds.includes(id2)) : [...new Set(requestedIds)];
+      resolvedItems.push({ knowledgeType: type, knowledgeId: id, keywordIds: finalIds });
+    }
+    for (const value of directoryIds) await this.listKnowledge({ directoryId: asPositiveInt(value, "directoryIds must contain positive integer IDs"), pageIndex: 1, pageSize: 1 });
+    return this.batchUpdateIsolationKeywordBindings({ items: resolvedItems, directoryIds, keywordIds: data3.keywordIds ?? [] });
+  }
+  async editKnowledgeTags(data3) {
+    const knowledgeIds = data3.knowledgeIds, requestedTags = data3.tagList;
+    if (!Array.isArray(knowledgeIds) || !knowledgeIds.length) throw new Error("edit knowledge tags requires non-empty knowledgeIds");
+    if (!Array.isArray(requestedTags) || requestedTags.some((value) => typeof value !== "string" || !value.trim())) throw new Error("tagList must contain non-empty strings");
+    const operation = String(data3.operation ?? "append");
+    if (!["append", "replace", "remove"].includes(operation)) throw new Error("tag operation must be append, replace, or remove");
+    const type = knowledgeType(data3.type ?? "QA");
+    const results = [];
+    for (const value of knowledgeIds) {
+      const id = asPositiveInt(value, "knowledgeIds must contain positive integer IDs");
+      const current = asObject(await this.getKnowledgeByType(String(id), type), `could not read knowledge ${id} before tag update`);
+      const metadata = current.metadata && typeof current.metadata === "object" && !Array.isArray(current.metadata) ? current.metadata : {};
+      const existing = Array.isArray(current.tags) ? current.tags : Array.isArray(metadata.tags) ? metadata.tags : [];
+      const requested = requestedTags.map(String);
+      const tagList = operation === "append" ? [.../* @__PURE__ */ new Set([...existing.map(String), ...requested])] : operation === "remove" ? existing.map(String).filter((tag) => !requested.includes(tag)) : [...new Set(requested)];
+      results.push(await this.post(`${this.qamPrefix}/project/${await this.projectId()}/editTags`, { type, knowledgeIds: [id], tagList }));
+    }
+    return { success: true, results };
+  }
   async transcript(chatId) {
     return this.get(`/api_v2/gpt/project/${await this.projectId()}/transcript/${encodeURIComponent(chatId)}`, { isCompare: true });
   }
   async listTranscripts(data3) {
     return this.post(`/api_v2/gpt/project/${await this.projectId()}/transcripts/filter`, data3);
   }
+  async getConversationsByIntent(intent, limit = 50) {
+    const intentResponse = await this.listIntents("");
+    const intents = Array.isArray(intentResponse) ? intentResponse : intentResponse && typeof intentResponse === "object" && Array.isArray(intentResponse.data) ? intentResponse.data : intentResponse && typeof intentResponse === "object" && Array.isArray(intentResponse.list) ? intentResponse.list : [];
+    const matched = intents.find((value) => value && typeof value === "object" && String(value.name ?? "") === intent);
+    if (!matched?.id) return [];
+    const response = await this.listTranscripts({ pageSize: limit, pageIndex: 1, intentId: Number(matched.id) });
+    const rows = Array.isArray(response) ? response : response && typeof response === "object" && Array.isArray(response.list) ? response.list : [];
+    const result = [];
+    for (const value of rows) {
+      if (!value || typeof value !== "object") continue;
+      const row = value, chatId = row.chatId ?? row.id;
+      if (!chatId) continue;
+      try {
+        const detail = asObject(await this.transcript(String(chatId)), `transcript ${chatId} must be an object`);
+        const turns = Array.isArray(detail.turns) ? detail.turns : Array.isArray(detail.messages) ? detail.messages : [];
+        const messages = [];
+        let metadata = {};
+        for (const turnValue of turns) {
+          if (!turnValue || typeof turnValue !== "object") continue;
+          const turn = turnValue, role = turn.role ?? turn.type, content = turn.content ?? turn.message;
+          if (role === "USER" && content) messages.push(content);
+          if (!Object.keys(metadata).length && turn.metadata && typeof turn.metadata === "object" && !Array.isArray(turn.metadata)) metadata = turn.metadata;
+        }
+        if (messages.length) result.push({ source_chat_id: chatId, intent, messages, metadata });
+      } catch {
+      }
+    }
+    return result;
+  }
   async resolveTranscriptChatId(externalId, pageSize2 = 10) {
     const result = await this.listTranscripts({ pageSize: pageSize2, pageIndex: 1, debug: false, keyword: externalId });
     const rows = Array.isArray(result) ? result : result?.list;
@@ -535,10 +905,10 @@ var SolveaClient = class {
 };
 
 // src/solvea/input.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 async function jsonData(args, required = true) {
   const file = option(args, "--data-file");
-  const raw = file ? await readFile(file, "utf8") : option(args, "--data");
+  const raw = file ? await readFile2(file, "utf8") : option(args, "--data");
   if (!raw) {
     if (required) throw new Error("--data or --data-file is required");
     return {};
@@ -549,7 +919,7 @@ async function jsonData(args, required = true) {
 }
 async function jsonValue(args) {
   const file = option(args, "--data-file");
-  const raw = file ? await readFile(file, "utf8") : option(args, "--data", true);
+  const raw = file ? await readFile2(file, "utf8") : option(args, "--data", true);
   return JSON.parse(raw);
 }
 function requireFlag(args, name, command) {
@@ -649,9 +1019,9 @@ var reportBody = async (args) => ({
   ...await data(args)
 });
 var handlers2 = {
-  "chat-stream": async (c, a) => c.rawCall("POST", `/api_v2/gpt/bot/${await c.botId()}/chat`, { message: option(a, "--message", true), botId: Number(option(a, "--bot-id") ?? await c.botId()), projectId: Number(await project(c)), option: { debug: true }, stream: true }),
+  "chat-stream": async (c, a) => c.chatStream({ message: option(a, "--message", true), botId: Number(option(a, "--bot-id") ?? await c.botId()), touchPoint: option(a, "--touch-point") ?? "LIVE_CHAT", ...await data(a) }),
   "update-chatflow": async (c, a) => c.updateChatflow(option(a, "--agent-id", true), await jsonData(a), flag(a, "--publish")),
-  "get-conversations-by-intent": async (c, a) => c.listTranscripts({ pageSize: Number(option(a, "--limit") ?? 50), pageIndex: 1, intent: option(a, "--intent", true) }),
+  "get-conversations-by-intent": (c, a) => c.getConversationsByIntent(option(a, "--intent", true), Number(option(a, "--limit") ?? 50)),
   "resolve-transcript-chat-id": async (c, a) => c.resolveTranscriptChatId(option(a, "--external-id", true), Number(option(a, "--page-size") ?? 10)),
   "list-isolation-keywords": async (c, a) => c.rawCall("GET", `${c.qamPath}/project/${await project(c)}/isolation_keywords`, void 0, { keyword: option(a, "--keyword") ?? "", pageIndex: page(a), pageSize: pageSize(a) }),
   "create-isolation-keyword": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/isolation_keyword`, { keyword: option(a, "--keyword", true) }),
@@ -660,16 +1030,16 @@ var handlers2 = {
     requireFlag(a, "--confirm-delete", "delete-isolation-keyword");
     return c.rawCall("DELETE", `${c.qamPath}/project/${await project(c)}/isolation_keyword/${requireId(a)}`);
   },
-  "get-knowledge-isolation-keywords": async (c, a) => c.rawCall("GET", `${c.qamPath}/project/${await project(c)}/knowledge/isolation_keywords`, void 0, { knowledgeType: option(a, "--type", true), knowledgeId: requireId(a) }),
-  "batch-update-isolation-keyword-bindings": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/knowledge/isolation_keywords/batch`, await jsonValue(a)),
-  "edit-knowledge-tags": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/editTags`, await jsonValue(a)),
-  "move-directory": async (c, a) => c.rawCall("GET", `${c.qamPath}/project/${await project(c)}/directory/move`, void 0, { currentId: requireId(a), parentId: option(a, "--parent-id", true) }),
-  "operate-knowledge": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/updateKnowledge`, await jsonValue(a)),
-  "batch-update-knowledge": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/kus`, await jsonValue(a)),
-  "update-document-content": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/document`, { id: requireId(a), ...await data(a) }),
-  "create-product-knowledge": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/ku_product`, await jsonValue(a)),
-  "update-product-knowledge": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/ku_product`, { kuProductId: Number(requireId(a)), ...await data(a) }),
-  "batch-update-products": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/ku_products`, { list: await jsonValue(a) }),
+  "get-knowledge-isolation-keywords": (c, a) => c.getKnowledgeIsolationKeywords(requireId(a), option(a, "--type", true)),
+  "batch-update-isolation-keyword-bindings": async (c, a) => c.applyIsolationKeywordBindings(await data(a)),
+  "edit-knowledge-tags": async (c, a) => c.editKnowledgeTags(await data(a)),
+  "move-directory": (c, a) => c.moveDirectory(requireId(a), option(a, "--parent-id", true)),
+  "operate-knowledge": async (c, a) => c.operateKnowledge(await jsonValue(a), flag(a, "--confirm-delete")),
+  "batch-update-knowledge": async (c, a) => c.updateKus(await jsonValue(a)),
+  "update-document-content": async (c, a) => c.updateDocumentContent(requireId(a), option(a, "--type", true), await data(a)),
+  "create-product-knowledge": async (c, a) => c.createProductKnowledge(await data(a)),
+  "update-product-knowledge": async (c, a) => c.updateProductKnowledge(requireId(a), await data(a)),
+  "batch-update-products": async (c, a) => c.updateKuProducts(await jsonValue(a)),
   "upload-web": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/documents`, { documents: optionList(a, "--url").map((filePath) => ({ filePath, docType: "TC", fileType: "website" })), taskType: "WEB", published: true, isVisible: true, metadata: { tags: [] }, directoryId: option(a, "--directory-id") ?? "" }),
   "list-label-groups": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/getTreeInfo`, void 0, option(a, "--name") ? { treeName: option(a, "--name") } : void 0),
   "create-label-group": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateTreeInfo`, { ...await data(a), treeName: option(a, "--name", true), operateType: "CREATE" }),
@@ -686,12 +1056,12 @@ var handlers2 = {
     requireFlag(a, "--confirm-delete", "delete-label-node");
     return c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateNode`, { treeId: Number(option(a, "--tree-id", true)), operateType: "DELETE", nodes: [{ id: Number(requireId(a)) }] });
   },
-  "download-label-template": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/downloadLabelTemplate`, void 0, { type: option(a, "--template-type") ?? "VOC_LABEL" }),
-  "download-labels": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/downloadLabel`, void 0, { treeId: option(a, "--tree-id", true) }),
-  "upload-labels": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/uploadLabel`, { treeId: Number(option(a, "--tree-id", true)), file: option(a, "--file", true), ...option(a, "--init") ? { uploadWay: "INIT" } : {} }),
+  "download-label-template": async (c, a) => ({ file: await c.downloadLabelTemplate(option(a, "--template-type") === "init" ? "VOC_LABEL_INIT" : "VOC_LABEL", option(a, "--output") ?? `${option(a, "--template-type") ?? "label"}_template.xlsx`) }),
+  "download-labels": async (c, a) => ({ file: await c.downloadLabels(option(a, "--tree-id", true), option(a, "--output") ?? `labels_${option(a, "--tree-id", true)}.xlsx`) }),
+  "upload-labels": (c, a) => c.uploadLabelFile(option(a, "--tree-id", true), option(a, "--file", true), flag(a, "--init")),
   "export-transcripts": async (c, a) => c.rawCall("POST", `/api_v2/gpt/project/${await project(c)}/transcripts/export/async`, { pageSize: pageSize(a), pageIndex: page(a), timeOffset: Number(option(a, "--time-offset") ?? 8), ...await data(a) }),
   "get-export-tasks": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/getLabelTask`, { page: page(a), pageSize: pageSize(a) }),
-  "upload-batch-test-file": async (c, a) => c.rawCall("GET", `/api_v2/gpt/project/${await project(c)}/sts_credentials`),
+  "upload-batch-test-file": async (c, a) => ({ file: await c.uploadTempFile(option(a, "--file", true)) }),
   "submit-batch-test": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/uploadMessage`, { file: option(a, "--file", true), type: option(a, "--type", true), ...option(a, "--bot-id") ? { botId: Number(option(a, "--bot-id")) } : {}, ...await data(a) }),
   "get-batch-test-tasks": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/getLabelTask`, { page: page(a), pageSize: pageSize(a), ...option(a, "--type") ? { taskType: option(a, "--type") } : {} }),
   "list-voice-agents": (c) => c.listAgents("voice"),
@@ -732,7 +1102,7 @@ function enabled(args, command) {
 }
 async function data2(args) {
   const file = option(args, "--data-file");
-  const raw = file ? await readFile2(file, "utf8") : option(args, "--data");
+  const raw = file ? await readFile3(file, "utf8") : option(args, "--data");
   if (!raw) throw new Error("--data or --data-file is required");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("request data must be a JSON object");
@@ -761,6 +1131,26 @@ async function transcriptFilters(args) {
   }
   return filters;
 }
+async function knowledgeFilters(args) {
+  const filters = {
+    type: "ALL",
+    pageIndex: 1,
+    pageSize: 50,
+    keyword: "",
+    ...await optionalData(args)
+  };
+  const optional = [
+    ["type", "--type", String],
+    ["pageIndex", "--page", Number],
+    ["pageSize", "--page-size", Number],
+    ["keyword", "--keyword", String]
+  ];
+  for (const [field, name, convert] of optional) {
+    const value = option(args, name);
+    if (value !== void 0) filters[field] = convert(value);
+  }
+  return filters;
+}
 async function runSolveaCommand(session, command, args) {
   const client = new SolveaClient(session);
   if (EXTENDED_COMMANDS.has(command)) return runExtendedCommand(client, command, args);
@@ -836,9 +1226,9 @@ async function runSolveaCommand(session, command, args) {
     case "delete-custom-quality-rule":
       return client.deleteCustomQualityRule(option(args, "--inspection-key", true));
     case "list-knowledge":
-      return client.listKnowledge(await optionalData(args));
+      return client.listKnowledge(await knowledgeFilters(args));
     case "get-knowledge":
-      return client.getKnowledge(id());
+      return client.getKnowledgeByType(id(), option(args, "--type", true));
     case "update-knowledge":
       return client.updateKnowledge(id(), await data2(args));
     case "upload-qa":
@@ -919,7 +1309,7 @@ function isNativeSolveaCommand(command) {
 }
 
 // src/business.ts
-var packageRoot = () => resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var packageRoot = () => resolve(dirname2(fileURLToPath(import.meta.url)), "..");
 async function runApi(session, command, args) {
   if (isNativeSolveaCommand(command)) {
     console.log(JSON.stringify(await runSolveaCommand(session, command, args), null, 2));
@@ -979,8 +1369,8 @@ var resources = {
     delete: action("delete-templates", "Delete reply templates", "--ids <id> [id...] --confirm-delete")
   },
   knowledge: {
-    list: action("list-knowledge", "List knowledge", "[--data <json> | --data-file <path>]"),
-    get: action("get-knowledge", "Get one knowledge item", "--id <knowledge-id>"),
+    list: action("list-knowledge", "List knowledge", "[--type <type>] [--page <number>] [--page-size <number>] [--keyword <text>] [--data <json> | --data-file <path>]"),
+    get: action("get-knowledge", "Get one knowledge item", "--id <knowledge-id> --type <QA|LEARN_SELF|FILE|WEBSITE|PRODUCT>"),
     update: action("update-knowledge", "Update a knowledge item", "--id <knowledge-id> (--data <json> | --data-file <path>)"),
     "upload-qa": action("upload-qa", "Upload QA items", "--data <json> | --data-file <path>"),
     tags: action("list-knowledge-tags", "List knowledge tags", "[--keyword <keyword>]")
@@ -1115,7 +1505,7 @@ function publicTenant(t) {
 
 // src/update.ts
 import { spawn } from "child_process";
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { homedir, platform } from "os";
 import { isAbsolute, join as join2 } from "path";
 var exec = (command, args, options3 = {}) => new Promise((resolve5, reject) => {
@@ -1193,8 +1583,8 @@ async function installScheduler() {
     const dir = join2(homedir(), "Library/LaunchAgents");
     const path = join2(dir, "com.solvea.cxclaw.update.plist");
     const programArguments = [invocation.command, ...invocation.args].map((value) => `<string>${xml(value)}</string>`).join("");
-    await mkdir(dir, { recursive: true });
-    await writeFile(
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(
       path,
       `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -1208,15 +1598,15 @@ async function installScheduler() {
   if (platform() === "linux") {
     const dir = join2(homedir(), ".config/systemd/user");
     const command = [invocation.command, ...invocation.args].map(systemdArg).join(" ");
-    await mkdir(dir, { recursive: true });
-    await writeFile(
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(
       join2(dir, "cxclaw-update.service"),
       `[Service]
 Type=oneshot
 ExecStart=${command}
 `
     );
-    await writeFile(
+    await writeFile2(
       join2(dir, "cxclaw-update.timer"),
       "[Timer]\nOnBootSec=5m\nOnUnitActiveSec=6h\nPersistent=true\n[Install]\nWantedBy=timers.target\n"
     );
@@ -1367,14 +1757,14 @@ async function runRuntime(action2, args) {
 // src/workflows/solvea-kit.ts
 import ExcelJS from "exceljs";
 import { promises as fs2 } from "fs";
-import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 var workspace2 = () => resolve3(process.env.WORKSPACE_DIR ?? join4(process.cwd(), "workspace"));
 var outputDir = (owner) => join4(workspace2(), "outputs", owner);
 var stateDir = (owner) => join4(workspace2(), "state", owner);
 var now = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 15);
 var readJson2 = async (path) => JSON.parse(await fs2.readFile(path, "utf8"));
 var writeJson2 = async (path, value) => {
-  await fs2.mkdir(dirname2(path), { recursive: true });
+  await fs2.mkdir(dirname3(path), { recursive: true });
   await fs2.writeFile(path, JSON.stringify(value, null, 2));
 };
 var INIT_NOTICE = `The information of this row cannot be deleted! Tips:
@@ -1428,7 +1818,7 @@ async function generateLabelImport(args) {
   sheet.columns.forEach((column) => {
     column.width = 18;
   });
-  await fs2.mkdir(dirname2(output), { recursive: true });
+  await fs2.mkdir(dirname3(output), { recursive: true });
   await workbook.xlsx.writeFile(output);
   return { file: output, format: init ? "init" : "update", rows: labels.length };
 }
@@ -1452,8 +1842,8 @@ async function runSolveaKitWorkflow(action2, args) {
 }
 
 // src/workflows/support.ts
-import { readFile as readFile3 } from "fs/promises";
-import { basename as basename2 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename3 } from "path";
 var safe = (value) => encodeURIComponent(value);
 var docsMcpUrl = process.env.CXCLAW_DOCS_MCP_URL ?? "https://solvea-39f11a36.mintlify.app/mcp";
 var publicDocsPrefix = "https://www.voc.ai/cn/docs/";
@@ -1527,7 +1917,7 @@ async function runSupport(session, action2, args) {
     const attachments = [];
     for (const file of options2(args, "--attachment")) {
       const form = new FormData();
-      form.append("file", new Blob([await readFile3(file)]), basename2(file));
+      form.append("file", new Blob([await readFile4(file)]), basename3(file));
       const tenant = session.tenant;
       const base = tenant?.businessUrl?.replace(/\/$/, "");
       if (!tenant || !base || !tenant.businessToken) throw new Error("no tenant selected");
@@ -1558,24 +1948,24 @@ async function runSupport(session, action2, args) {
 }
 
 // src/workflows/common.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname3, join as join5, resolve as resolve4 } from "path";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4, join as join5, resolve as resolve4 } from "path";
 import { homedir as homedir2 } from "os";
 var workspaceRoot = () => resolve4(process.env.CXCLAW_WORKSPACE ?? join5(homedir2(), ".cxclaw", "workspace"));
 var stateRoot = (domain) => resolve4(process.env.CXCLAW_STATE_DIR ?? join5(workspaceRoot(), "state"), domain);
 var outputRoot = (domain) => resolve4(process.env.CXCLAW_OUTPUT_DIR ?? join5(workspaceRoot(), "outputs"), domain);
 async function ensureParent(file) {
-  await mkdir2(dirname3(file), { recursive: true });
+  await mkdir3(dirname4(file), { recursive: true });
 }
 async function ensureDir(directory) {
-  await mkdir2(directory, { recursive: true });
+  await mkdir3(directory, { recursive: true });
 }
 async function readJson3(file) {
-  return JSON.parse(await readFile4(file, "utf8"));
+  return JSON.parse(await readFile5(file, "utf8"));
 }
 async function writeJson3(file, value) {
   await ensureParent(file);
-  await writeFile2(file, `${JSON.stringify(value, null, 2)}
+  await writeFile3(file, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function intOption(args, name, fallback) {
@@ -1593,7 +1983,7 @@ function htmlEscape(value) {
 }
 async function writeHtml(file, title, body) {
   await ensureParent(file);
-  await writeFile2(file, `<!doctype html><html><head><meta charset="utf-8"><title>${htmlEscape(title)}</title><style>body{font-family:system-ui,sans-serif;margin:2rem;line-height:1.5}pre{white-space:pre-wrap;background:#f6f8fa;padding:1rem;border-radius:8px}.card{border:1px solid #ddd;border-radius:8px;padding:1rem;margin:1rem 0}</style></head><body><h1>${htmlEscape(title)}</h1>${body}</body></html>`, "utf8");
+  await writeFile3(file, `<!doctype html><html><head><meta charset="utf-8"><title>${htmlEscape(title)}</title><style>body{font-family:system-ui,sans-serif;margin:2rem;line-height:1.5}pre{white-space:pre-wrap;background:#f6f8fa;padding:1rem;border-radius:8px}.card{border:1px solid #ddd;border-radius:8px;padding:1rem;margin:1rem 0}</style></head><body><h1>${htmlEscape(title)}</h1>${body}</body></html>`, "utf8");
 }
 function asRows(value) {
   if (Array.isArray(value)) return value.filter((item) => item && typeof item === "object");
@@ -1800,8 +2190,8 @@ async function runLocalAgentWorkflow(action2, args) {
 }
 async function writeFileText(file, content) {
   await ensureParent(file);
-  const { writeFile: writeFile3 } = await import("fs/promises");
-  await writeFile3(file, `${content}
+  const { writeFile: writeFile4 } = await import("fs/promises");
+  await writeFile4(file, `${content}
 `, "utf8");
 }
 
@@ -1839,9 +2229,9 @@ async function createSheet(args) {
   return { output, count: cases.length, mode: option(args, "--mode") };
 }
 async function submit(client, args) {
-  const file = option(args, "--file", true);
+  const file = await client.uploadTempFile(option(args, "--file", true));
   const result = await client.rawCall("POST", `/api_v2/gpt/label/project/${await client.projectId()}/uploadMessage`, { file, type: option(args, "--mode", true), ...option(args, "--agent-id") ? { agentId: Number(option(args, "--agent-id")) } : {}, ...option(args, "--flow-version") ? { flowVersion: Number(option(args, "--flow-version")) } : {} });
-  return result;
+  return { fileKey: file, result };
 }
 async function runAgentTester(session, action2, args) {
   if (!action2) throw new Error("agent-tester action is required");
@@ -2124,6 +2514,56 @@ async function extractWebQa(args) {
   }
   return { outputDir: outputDir2, files, count: files.length };
 }
+var flattenDirectories = (nodes, result = []) => {
+  for (const node of nodes) {
+    result.push(node);
+    if (Array.isArray(node.children)) flattenDirectories(node.children.filter((child) => child && typeof child === "object"), result);
+  }
+  return result;
+};
+function validateQaItems(values, maxDepth) {
+  if (!values.length) throw new Error("QA plan must contain at least one item");
+  return values.map((value, index) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`QA item #${index + 1} must be an object`);
+    const item = value;
+    if (!Array.isArray(item.dir_path) || !item.dir_path.length) throw new Error(`QA item #${index + 1} dir_path must be a non-empty array`);
+    if (item.dir_path.length > maxDepth) throw new Error(`QA item #${index + 1} dir_path exceeds maximum depth ${maxDepth}`);
+    const dirPath = item.dir_path.map((name, depth) => {
+      if (typeof name !== "string" || !name.trim() || /[\\/]/.test(name)) throw new Error(`QA item #${index + 1} dir_path[${depth}] must be a folder name`);
+      return name.trim();
+    });
+    const title = typeof item.question === "string" ? item.question.trim() : "";
+    const content = typeof item.answer === "string" ? item.answer.trim() : "";
+    if (!title) throw new Error(`QA item #${index + 1} question must be a non-empty string`);
+    if (!content) throw new Error(`QA item #${index + 1} answer must be a non-empty markdown string`);
+    return { dirPath, title, content };
+  });
+}
+async function resolveDirectory(client, path, directories, cache) {
+  let parentId = 0;
+  const prefix = [];
+  for (const name of path) {
+    prefix.push(name);
+    const key = prefix.join("/");
+    const cached = cache.get(key);
+    if (cached !== void 0) {
+      parentId = cached;
+      continue;
+    }
+    const match = directories.find((directory) => String(directory.name ?? "") === name && Number(directory.parentId ?? 0) === parentId);
+    if (match) parentId = Number(match.id ?? match.directoryId);
+    else {
+      const createdParentId = parentId;
+      const created = await client.createFolder(name, parentId);
+      const id = Number(created?.id ?? created?.directoryId);
+      if (!Number.isSafeInteger(id) || id <= 0) throw new Error(`could not create directory ${key}: response has no directory id`);
+      parentId = id;
+      directories.push({ id, name, parentId: Number(created?.parentId ?? createdParentId) });
+    }
+    cache.set(key, parentId);
+  }
+  return parentId;
+}
 async function importQa(client, args) {
   const qaFile = option(args, "--qa-file");
   const fromDir = option(args, "--from-dir");
@@ -2135,23 +2575,67 @@ async function importQa(client, args) {
   }
   if (fromDir) {
     const { readdir } = await import("fs/promises");
-    for (const file of (await readdir(fromDir)).filter((name) => name.endsWith(".json"))) {
+    for (const file of (await readdir(fromDir)).filter((name) => name.endsWith(".json")).sort()) {
       const value = await readJson3(join8(fromDir, file));
       items.push(...Array.isArray(value) ? value : value.items && Array.isArray(value.items) ? value.items : [value]);
     }
   }
+  const maxDepth = intOption(args, "--max-depth", 3);
+  if (!Number.isSafeInteger(maxDepth) || maxDepth <= 0) throw new Error("--max-depth must be a positive integer");
+  const normalized = validateQaItems(items, maxDepth);
   const plan2 = { items, count: items.length, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
   const planFile = join8(outputRoot("kb-builder"), `qa_import_plan_${Date.now()}.json`);
   await writeJson3(planFile, plan2);
   if (flag(args, "--dry-run")) return { dryRun: true, planFile, count: items.length };
-  return { planFile, count: items.length, result: await client.uploadQa(items) };
+  const directories = flattenDirectories(asRows(await client.listDirectories()));
+  const cache = /* @__PURE__ */ new Map();
+  const payload = [];
+  for (const item of normalized) payload.push({ title: item.title, content: item.content, directoryId: await resolveDirectory(client, item.dirPath, directories, cache) });
+  return { planFile, count: payload.length, result: await client.uploadQa(payload) };
 }
 async function importSources(client, args) {
-  const plan2 = await readJson3(option(args, "--plan-file", true));
-  const documents = Array.isArray(plan2.documents) ? plan2.documents : Array.isArray(plan2.items) ? plan2.items : [];
-  const payload = { documents, taskType: "WEB", published: true, isVisible: true, metadata: { tags: [] }, directoryId: String(plan2.directoryId ?? "") };
-  if (!flag(args, "--execute")) return { dryRun: true, payload };
-  return client.rawCall("POST", `${client.qamPath}/project/${await client.projectId()}/documents`, payload);
+  const value = await readJson3(option(args, "--plan-file", true));
+  const source = Array.isArray(value) ? value : value && typeof value === "object" && Array.isArray(value.items) ? value.items : [];
+  if (!source.length) throw new Error("source document plan must be a non-empty array");
+  const maxDepth = intOption(args, "--max-depth", 3);
+  if (!Number.isSafeInteger(maxDepth) || maxDepth <= 0) throw new Error("--max-depth must be a positive integer");
+  const { stat } = await import("fs/promises");
+  const normalized = [];
+  const seenUrls = /* @__PURE__ */ new Set();
+  for (const [index, raw] of source.entries()) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`source document #${index + 1} must be an object`);
+    const item = raw;
+    const itemSource = typeof item.source === "string" ? item.source.trim() : "";
+    if (!itemSource) throw new Error(`source document #${index + 1} needs a non-empty source`);
+    const path = item.dir_path ?? [];
+    if (!Array.isArray(path) || path.some((name) => typeof name !== "string" || !name.trim() || /[\\/]/.test(name))) throw new Error(`source document #${index + 1} dir_path must contain folder names`);
+    if (path.length > maxDepth) throw new Error(`source document #${index + 1} dir_path exceeds maximum depth ${maxDepth}`);
+    const isUrl = /^https?:\/\//i.test(itemSource);
+    if (!isUrl) {
+      if (![".doc", ".docx", ".pdf"].some((extension) => itemSource.toLowerCase().endsWith(extension))) throw new Error(`source document #${index + 1} supports .doc, .docx, or .pdf`);
+      const info = await stat(itemSource).catch(() => void 0);
+      if (!info?.isFile()) throw new Error(`source document #${index + 1} file not found: ${itemSource}`);
+    }
+    const skippedDuplicate = isUrl && seenUrls.has(itemSource);
+    if (isUrl) seenUrls.add(itemSource);
+    normalized.push({ source: itemSource, dirPath: path.map(String).map((name) => name.trim()), isUrl, skippedDuplicate });
+  }
+  if (!flag(args, "--execute")) return { dryRun: true, count: normalized.length, items: normalized.map((item) => ({ source: item.source, dir_path: item.dirPath, status: item.skippedDuplicate ? "skipped_duplicate" : "pending" })) };
+  const directories = flattenDirectories(asRows(await client.listDirectories()));
+  const cache = /* @__PURE__ */ new Map();
+  const results = [];
+  for (const item of normalized) {
+    if (item.skippedDuplicate) {
+      results.push({ source: item.source, status: "skipped_duplicate" });
+      continue;
+    }
+    const directoryId = await resolveDirectory(client, item.dirPath, directories, cache);
+    const filePath = item.isUrl ? item.source : await client.uploadKnowledgeFile(item.source);
+    const documents = [{ filePath, docType: "TC", ...item.isUrl ? { fileType: "website" } : {} }];
+    const result = await client.createDocuments(documents, directoryId, item.isUrl ? "WEB" : "FILE");
+    results.push({ source: item.source, directoryId, status: "submitted", result });
+  }
+  return { count: normalized.length, results };
 }
 async function importTemplates(client, args) {
   const source = option(args, "--plan-file") ?? option(args, "--xlsx");
@@ -2429,7 +2913,7 @@ async function main(args = process.argv.slice(2)) {
     if (flag(args, "--scheduled")) await new Promise((resolve5) => setTimeout(resolve5, Math.random() * 18e5));
     return print(await update());
   }
-  if (command === "commands" || command === "capabilities") console.log(await readFile5(new URL("../capabilities.lock.json", import.meta.url), "utf8"));
+  if (command === "commands" || command === "capabilities") console.log(await readFile6(new URL("../capabilities.lock.json", import.meta.url), "utf8"));
   else throw new Error(`unknown command: ${command}`);
 }
 main().catch((error) => {