@petercjl/tuda 0.0.0-stage → 0.1.1

package/dist/main.js

@@ -0,0 +1,1067 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3, stat } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path6 from "node:path";
+import os3 from "node:os";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// src/management.ts
+import { access as access2, cp, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/paths.ts
+import { access } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function defaultUserDataPath() {
+  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "Tuda");
+  if (process.platform === "win32") return path.join(process.env.APPDATA || os.homedir(), "Tuda");
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "Tuda");
+}
+function candidateTudaAppRoots() {
+  if (process.platform === "darwin") return ["/Applications/Tuda.app", path.join(os.homedir(), "Applications/Tuda.app")];
+  if (process.platform === "win32") return [path.join(process.env.LOCALAPPDATA || os.homedir(), "Programs/Tuda"), "C:\\Program Files\\Tuda"];
+  return ["/opt/Tuda", "/usr/lib/tuda"];
+}
+async function resolveTudaApp(explicitRoot) {
+  for (const root2 of explicitRoot ? [explicitRoot] : candidateTudaAppRoots()) {
+    const commandPath = process.platform === "darwin" ? path.join(root2, "Contents/MacOS/Tuda") : path.join(root2, process.platform === "win32" ? "Tuda.exe" : "Tuda");
+    try {
+      await access(commandPath);
+      return { root: root2, commandPath };
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/management.ts
+var root = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..");
+var skillName = "using-tuda";
+var owner = "@petercjl/tuda";
+var receiptName = ".tuda-skill.json";
+var exists = (p) => access2(p).then(() => true, () => false);
+var readJson = async (p) => JSON.parse(await readFile(p, "utf8"));
+var json = (value) => process.stdout.write(JSON.stringify({ schemaVersion: 1, ok: true, ...value }, null, 2) + "\n");
+var source = path2.join(root, "skills", skillName);
+async function digest(directory) {
+  const hash = createHash("sha256");
+  async function visit(dir, prefix = "") {
+    for (const entry of (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+      if ([receiptName, ".runtime", "agents"].includes(entry.name)) continue;
+      if (entry.isSymbolicLink()) throw new Error("UNSAFE_SKILL_LINK");
+      const name = path2.posix.join(prefix, entry.name);
+      if (entry.isDirectory()) await visit(path2.join(dir, entry.name), name);
+      else if (entry.isFile()) hash.update(name + "\0").update(await readFile(path2.join(dir, entry.name)));
+    }
+  }
+  await visit(directory);
+  return hash.digest("hex");
+}
+function selectedTarget(args) {
+  const at = args.indexOf("--target");
+  const raw = at >= 0 ? args[at + 1] : void 0;
+  if (!raw || raw.startsWith("--") || !path2.isAbsolute(raw)) throw new Error("TARGET_REQUIRED: --target must be the current Agent's absolute, exact Skill directory.");
+  const target = path2.resolve(raw);
+  if (path2.basename(target) !== skillName || target === path2.parse(target).root || target === source) throw new Error("UNSAFE_TARGET: select a separate using-tuda directory.");
+  return target;
+}
+async function installSkill(target, activation = {}) {
+  const renameDirectory = activation.rename ?? rename;
+  const pkg = await readJson(path2.join(root, "package.json"));
+  const expected = await digest(source);
+  let backup;
+  if (await exists(target)) {
+    if ((await lstat(target)).isSymbolicLink()) throw new Error("UNMANAGED_TARGET: links require an explicit migration.");
+    const receipt = await readJson(path2.join(target, receiptName)).catch(() => null);
+    if (receipt?.package !== owner) throw new Error("UNMANAGED_TARGET: existing directory was preserved.");
+    if (await digest(target) !== receipt.digest) throw new Error("LOCAL_EDITS: existing Skill was preserved.");
+    const installedRuntime = await readFile(path2.join(target, ".runtime", "dist", "main.js")).catch(() => null);
+    const installedHash = installedRuntime ? createHash("sha256").update(installedRuntime).digest("hex") : null;
+    const currentHash = createHash("sha256").update(await readFile(path2.join(root, "dist", "main.js"))).digest("hex");
+    if (installedHash && installedHash !== receipt.runtimeSha256) throw new Error("LOCAL_EDITS: target-owned runtime was preserved.");
+    if (receipt.version === pkg.version && receipt.digest === expected && installedHash === currentHash) {
+      return { target, installed: true, managed: true, current: true, version: pkg.version, digest: expected, changed: false, hostDiscovery: "pending" };
+    }
+    backup = `${target}.backup-${randomUUID()}`;
+  }
+  await mkdir(path2.dirname(target), { recursive: true });
+  const staging = `${target}.install-${randomUUID()}`;
+  try {
+    await cp(source, staging, { recursive: true, errorOnExist: true });
+    await mkdir(path2.join(staging, ".runtime"));
+    for (const name of ["dist", "guard", "skills", "package.json", "capabilities.json", "release-manifest.json", "INSTALL.md", "UPDATE.md", "LICENSE", "THIRD_PARTY_NOTICES.md"]) {
+      if (await exists(path2.join(root, name))) await cp(path2.join(root, name), path2.join(staging, ".runtime", name), { recursive: true });
+    }
+    if (backup && await exists(path2.join(target, "agents"))) await cp(path2.join(target, "agents"), path2.join(staging, "agents"), { recursive: true, force: true });
+    await writeFile(path2.join(staging, receiptName), JSON.stringify({ schemaVersion: 1, package: owner, version: pkg.version, digest: expected, runtimeSha256: createHash("sha256").update(await readFile(path2.join(staging, ".runtime", "dist", "main.js"))).digest("hex") }, null, 2), { flag: "wx" });
+    let inPlace = false;
+    let oldFiles = [];
+    const files = async (at, prefix = "") => {
+      const result = [];
+      for (const entry of await readdir(at, { withFileTypes: true })) {
+        if (entry.isSymbolicLink()) throw new Error("UNSAFE_SKILL_LINK");
+        const relative = path2.join(prefix, entry.name);
+        if (entry.isDirectory()) result.push(...await files(path2.join(at, entry.name), relative));
+        else result.push(relative);
+      }
+      return result;
+    };
+    if (backup) {
+      try {
+        await renameDirectory(target, backup);
+      } catch (error) {
+        if (!["EBUSY", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
+        oldFiles = await files(target);
+        await cp(target, backup, { recursive: true, errorOnExist: true });
+        inPlace = true;
+      }
+    }
+    const stagedFiles = await files(staging);
+    try {
+      if (inPlace) {
+        await cp(staging, target, { recursive: true, force: true });
+        for (const name of oldFiles) if (!stagedFiles.includes(name)) await rm(path2.join(target, name), { force: true });
+        if (await digest(target) !== expected) throw new Error("ACTIVATION_INTEGRITY_FAILED");
+      } else await renameDirectory(staging, target);
+    } catch (error) {
+      if (backup) {
+        if (inPlace) {
+          await cp(backup, target, { recursive: true, force: true });
+          for (const name of stagedFiles) if (!oldFiles.includes(name)) await rm(path2.join(target, name), { force: true });
+        } else await rename(backup, target);
+      }
+      throw error;
+    }
+    return { target, installed: true, managed: true, current: true, version: pkg.version, digest: expected, changed: true, backup, hostDiscovery: "pending" };
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+}
+async function registry(tag, timeout = 4e3) {
+  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(owner)}/${encodeURIComponent(tag)}`, { signal: AbortSignal.timeout(timeout) });
+  if (response.status === 404) return null;
+  if (!response.ok) throw new Error(`REGISTRY_ERROR: ${response.status}`);
+  return response.json();
+}
+async function automaticUpdateCheck() {
+  if (process.env.TUDA_NO_UPDATE_CHECK === "1" || await exists(path2.join(root, "..", ".git"))) return;
+  const cache = path2.join(defaultUserDataPath(), "cli-update-check.json");
+  try {
+    const previous = await readJson(cache).catch(() => null);
+    if (previous && Date.now() - previous.checkedAt < 864e5) return;
+    const own = await readJson(path2.join(root, "package.json"));
+    const latest = await registry("latest", 600);
+    await mkdir(path2.dirname(cache), { recursive: true });
+    const temporary = `${cache}.${randomUUID()}`;
+    await writeFile(temporary, JSON.stringify({ checkedAt: Date.now(), latest: latest?.version ?? null }), { flag: "wx" });
+    await rename(temporary, cache);
+    if (latest && latest.version !== own.version) process.stderr.write(`Tuda ${latest.version} is available; use tuda update check --json.
+`);
+  } catch {
+  }
+}
+async function handleManagement(args) {
+  const [group, action] = args;
+  if (args.includes("--help") && args.includes("--json")) {
+    const manifest = await readJson(path2.join(root, "capabilities.json"));
+    json({ ...manifest, options: manifest.commandContracts[`${group} ${action}`]?.options ?? {} });
+    return true;
+  }
+  if (!["version", "--version", "capabilities", "skill", "update", "doctor"].includes(group)) return false;
+  const allowed = /* @__PURE__ */ new Set(["--json", "--version", "--target", "--agent", "--name", "--channel", "--user-data-path", "--no-launch", "--app-path"]);
+  for (const arg of args.filter((arg2) => arg2.startsWith("--"))) if (!allowed.has(arg)) throw new Error(`UNKNOWN_OPTION: ${arg}`);
+  const option = (name) => {
+    const i = args.indexOf(name);
+    return i < 0 ? void 0 : args[i + 1];
+  };
+  const agent = option("--agent");
+  if (agent && !/^[a-z][a-z0-9-]{0,63}$/.test(agent)) throw new Error("INVALID_AGENT");
+  const pkg = await readJson(path2.join(root, "package.json"));
+  if (group === "version" || group === "--version") {
+    if (args.includes("--json")) json({ package: pkg.name, version: pkg.version });
+    else process.stdout.write(pkg.version + "\n");
+  } else if (group === "capabilities") json(await readJson(path2.join(root, "capabilities.json")));
+  else if (group === "doctor") {
+    const checks = { node: Number(process.versions.node.split(".")[0]) >= 22, skill: await exists(path2.join(source, "SKILL.md")), runtime: await exists(path2.join(root, "dist", "main.js")) };
+    json({ package: pkg.name, version: pkg.version, checks, runtimeReady: Object.values(checks).every(Boolean), desktopRequiredForCanvas: true, platforms: { darwin: "development", win32: "customer" } });
+    if (!Object.values(checks).every(Boolean)) process.exitCode = 1;
+  } else if (group === "skill") {
+    if (option("--name") && option("--name") !== skillName) throw new Error("UNKNOWN_SKILL");
+    if (action === "source") {
+      json({ ...await readJson(path2.join(root, "capabilities.json")), package: pkg.name, version: pkg.version, name: skillName, sourcePath: source, skills: [{ ok: true, name: skillName, package: pkg.name, version: pkg.version, sourcePath: source }], complete: true });
+    } else if (action === "status") {
+      const target = selectedTarget(args);
+      const receipt = await readJson(path2.join(target, receiptName)).catch(() => null);
+      const installed = await exists(path2.join(target, "SKILL.md"));
+      const actual = installed ? await digest(target) : void 0;
+      const runtime = await readFile(path2.join(target, ".runtime", "dist", "main.js")).catch(() => null);
+      const runtimeCurrent = Boolean(runtime && receipt?.runtimeSha256 === createHash("sha256").update(runtime).digest("hex") && receipt.runtimeSha256 === createHash("sha256").update(await readFile(path2.join(root, "dist", "main.js"))).digest("hex"));
+      json({ name: skillName, package: pkg.name, edited: Boolean(installed && receipt && actual !== receipt.digest), verification: { verified: Boolean(actual && actual === receipt?.digest && runtimeCurrent), algorithm: "sha256" }, recovery: { required: false }, target, installed, managed: receipt?.package === owner, current: receipt?.package === owner && receipt.version === pkg.version && actual === receipt.digest && actual === await digest(source) && runtimeCurrent, version: receipt?.version ?? pkg.version, digest: actual, hostDiscovery: "pending" });
+    } else if (["install", "update"].includes(action)) json(await installSkill(selectedTarget(args)));
+    else throw new Error("UNKNOWN_SKILL_COMMAND");
+  } else if (group === "update") {
+    const tag = option("--channel") ?? "latest";
+    if (!["latest", "next"].includes(tag)) throw new Error("INVALID_CHANNEL");
+    const target = action === "install" ? selectedTarget(args) : void 0;
+    if (action === "install" && await exists(path2.join(root, "..", ".git"))) throw new Error("GIT_OWNED_INSTALL: update the checkout through Git.");
+    const latest = await registry(tag);
+    if (action === "check") json({ package: pkg.name, currentVersion: pkg.version, latestVersion: latest?.version ?? null, available: Boolean(latest && latest.version !== pkg.version), channel: tag, automaticInstall: false });
+    else if (action === "install") {
+      if (!latest || !/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(latest.version)) throw new Error("RELEASE_UNAVAILABLE");
+      const stage = path2.join(path2.dirname(target), `.tuda-update-${randomUUID()}`);
+      await mkdir(stage);
+      const npmEntry = process.platform === "win32" ? path2.join(path2.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js") : void 0;
+      if (npmEntry && !await exists(npmEntry)) throw new Error("NPM_RUNTIME_REQUIRED: run this management operation with the installed Node.js runtime.");
+      await promisify(execFile)(npmEntry ? process.execPath : "npm", [...npmEntry ? [npmEntry] : [], "install", "--prefix", stage, "--ignore-scripts", "--no-audit", "--no-fund", `${owner}@${latest.version}`], { timeout: 18e4, windowsHide: true });
+      const entry = path2.join(stage, "node_modules", "@petercjl", "tuda", "dist", "main.js");
+      const result = await promisify(execFile)(process.execPath, [entry, "skill", "update", "--target", target, "--json"], { timeout: 6e4 });
+      const receipt = JSON.parse(result.stdout);
+      if (!receipt.ok || receipt.version !== latest.version || !receipt.current) throw new Error("SKILL_SYNC_INCOMPLETE");
+      await rm(stage, { recursive: true, force: true });
+      json({ ...receipt, package: owner, runtimeEntry: path2.join(target, ".runtime", "dist", "main.js"), bootstrapReplaced: false });
+    } else throw new Error("UNKNOWN_UPDATE_COMMAND");
+  }
+  return true;
+}
+
+// ../electron/agent-integration.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { access as access3, cp as cp2, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import os2 from "node:os";
+var MANAGED_SKILL_FILE = ".tuda-managed.json";
+var SKILL_AUTO_INSTALL_POLICY_FILE = "mcp-skill-policy.json";
+async function getAgentIntegrationStatus(homeDir) {
+  return { clients: await Promise.all(SUPPORTED_AGENT_IDS.map((client) => agentStatus(client, homeDir))) };
+}
+var AGENT_SKILL_NAMES = ["using-tuda"];
+async function bundledAgentSkills(bundledSkillPath) {
+  const bundles = AGENT_SKILL_NAMES.map((name) => ({
+    name,
+    source: bundledSkillPath
+  }));
+  for (const { source: source2 } of bundles) {
+    try {
+      await access3(path3.join(source2, "SKILL.md"));
+    } catch {
+      throw new Error("Tuda \u5185\u7F6E Skill \u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5 App \u540E\u91CD\u8BD5\u3002");
+    }
+  }
+  return Promise.all(bundles.map(async (bundle) => ({ ...bundle, snapshot: await snapshotSkill(bundle.source) })));
+}
+async function installAgentSkill(client, homeDir, bundledSkillPath) {
+  const bundles = await bundledAgentSkills(bundledSkillPath);
+  for (const { name } of bundles) {
+    const target = getSkillPath(client, homeDir, name);
+    if (await pathExists(target) && !await readManagedSkillDigest(target)) {
+      throw new Error(`\u5DF2\u6709\u81EA\u884C\u7EF4\u62A4\u7684\u540C\u540D Skill\uFF08${name}\uFF09\uFF0C\u8BF7\u5148\u5904\u7406\u8BE5\u76EE\u5F55\u518D\u5B89\u88C5\u3002`);
+    }
+  }
+  for (const { name, source: source2, snapshot } of bundles) {
+    const target = getSkillPath(client, homeDir, name);
+    if (target !== source2) await replaceManagedSkill(target, source2, snapshot.digest);
+  }
+  await removeManagedWorkspaceSkill(client, homeDir);
+  return getAgentIntegrationStatus(homeDir);
+}
+async function detectCodingAgents(homeDir) {
+  const status = await getAgentIntegrationStatus(homeDir);
+  return status.clients.filter((client) => client.detected).map((client) => client.id);
+}
+function skillAutoInstallPolicyPath(userDataPath) {
+  return path3.join(userDataPath, SKILL_AUTO_INSTALL_POLICY_FILE);
+}
+async function readSkillAutoInstallPolicy(userDataPath) {
+  try {
+    const parsed = JSON.parse(await readOptional(skillAutoInstallPolicyPath(userDataPath)));
+    if (isRecord(parsed) && isRecord(parsed.declined)) {
+      const declined = {};
+      for (const id of SUPPORTED_AGENT_IDS) if (parsed.declined[id] === true) declined[id] = true;
+      return { schemaVersion: 1, declined };
+    }
+  } catch {
+  }
+  return { schemaVersion: 1, declined: {} };
+}
+async function setSkillAutoInstallDeclined(userDataPath, client, declined) {
+  const policy = await readSkillAutoInstallPolicy(userDataPath);
+  if (declined) policy.declined[client] = true;
+  else delete policy.declined[client];
+  await writeWithParent(skillAutoInstallPolicyPath(userDataPath), `${JSON.stringify(policy, null, 2)}
+`);
+}
+async function uninstallAgentSkill(client, homeDir) {
+  const targets = AGENT_SKILL_NAMES.map((name) => getSkillPath(client, homeDir, name));
+  for (const target of targets) {
+    if (await pathExists(target) && !await readManagedSkillDigest(target) && !await readOptional(path3.join(target, ".tuda-skill.json")).then((text) => {
+      try {
+        return JSON.parse(text).package === "@petercjl/tuda";
+      } catch {
+        return false;
+      }
+    })) throw new Error("\u6B64 Skill \u672A\u7531 Tuda \u7BA1\u7406\uFF0C\u672A\u79FB\u9664\u3002");
+  }
+  for (const target of targets) await rm2(target, { recursive: true, force: true });
+  await removeManagedWorkspaceSkill(client, homeDir);
+  return getAgentIntegrationStatus(homeDir);
+}
+async function removeManagedWorkspaceSkill(client, homeDir) {
+  const legacyPath = path3.join(path3.dirname(getSkillPath(client, homeDir)), "tuda-workspace");
+  if (await readManagedSkillDigest(legacyPath)) await rm2(legacyPath, { recursive: true, force: true });
+}
+async function removeLegacyIntegration(client, homeDir) {
+  if (client !== "codex" && client !== "claude-code") return;
+  const configPath = path3.join(homeDir, client === "codex" ? ".codex/config.toml" : ".claude.json");
+  const current = await readOptional(configPath);
+  if (!current.trim()) return;
+  let next = current;
+  if (client === "codex") {
+    next = removeTomlTable(current, "mcp_servers.tuda");
+  } else {
+    let config;
+    try {
+      config = JSON.parse(current);
+    } catch {
+      throw new Error("Claude Code \u914D\u7F6E\u4E0D\u662F\u6709\u6548 JSON\uFF0C\u672A\u4FEE\u6539\u8BE5\u6587\u4EF6\u3002");
+    }
+    if (!isRecord(config)) throw new Error("Claude Code \u914D\u7F6E\u683C\u5F0F\u65E0\u6548\uFF0C\u672A\u4FEE\u6539\u8BE5\u6587\u4EF6\u3002");
+    if (!isRecord(config.mcpServers) || !("tuda" in config.mcpServers)) return;
+    delete config.mcpServers.tuda;
+    next = JSON.stringify(config, null, 2) + "\n";
+  }
+  if (next !== current) await writeWithParent(configPath, next);
+}
+async function agentStatus(client, homeDir) {
+  const executable = AGENT_EXECUTABLES[client];
+  const directories = [...(process.env.PATH ?? "").split(path3.delimiter), path3.join(homeDir, ".local/bin"), path3.join(homeDir, ".npm-global/bin"), ...homeDir === os2.homedir() ? ["/opt/homebrew/bin", "/usr/local/bin"] : []];
+  let executablePath;
+  for (const directory of directories.filter(Boolean)) {
+    const candidate = path3.join(directory, executable + (process.platform === "win32" ? ".cmd" : ""));
+    try {
+      await access3(candidate, 1);
+      executablePath = candidate;
+      break;
+    } catch {
+    }
+  }
+  const desktop = client === "codex" && process.platform === "darwin" && (await pathExists("/Applications/Codex.app") || await pathExists(path3.join(homeDir, "Applications/Codex.app")));
+  const configPath = path3.join(homeDir, client === "codex" ? ".codex/config.toml" : client === "claude-code" ? ".claude.json" : AGENT_CONFIG_PATHS[client]);
+  const content = await readOptional(configPath);
+  let legacyConfigured = false;
+  if (client === "codex") legacyConfigured = /\[mcp_servers\.tuda\]/u.test(content);
+  else {
+    try {
+      legacyConfigured = Boolean(JSON.parse(content).mcpServers?.tuda);
+    } catch {
+    }
+  }
+  const skillPath = getSkillPath(client, homeDir);
+  const skillPaths = AGENT_SKILL_NAMES.map((name) => getSkillPath(client, homeDir, name));
+  const skillInstalled = (await Promise.all(skillPaths.map((target, index) => isSkillInstalled(target, AGENT_SKILL_NAMES[index])))).every(Boolean);
+  const skillManaged = (await Promise.all(skillPaths.map(async (target) => await readManagedSkillDigest(target) || await readOptional(path3.join(target, ".tuda-skill.json")).then((text) => {
+    try {
+      return JSON.parse(text).package === "@petercjl/tuda";
+    } catch {
+      return false;
+    }
+  })))).every(Boolean);
+  const detected = Boolean(executablePath || desktop);
+  return { id: client, detected, detection: detected ? "installed" : content.trim() ? "config-only" : "not-found", executablePath, skillInstalled, skillManaged, skillPath, legacyConfigured };
+}
+var SUPPORTED_AGENT_IDS = ["codex", "claude-code", "workbuddy", "cursor", "windsurf", "cline", "roo-cline", "gemini-cli", "opencode"];
+var AGENT_EXECUTABLES = { codex: "codex", "claude-code": "claude", workbuddy: "workbuddy", cursor: "cursor", windsurf: "windsurf", cline: "cline", "roo-cline": "roo", "gemini-cli": "gemini", opencode: "opencode" };
+var AGENT_SKILL_DIRS = { codex: ".codex/skills", "claude-code": ".claude/skills", workbuddy: ".workbuddy/skills", cursor: ".cursor/skills", windsurf: ".codeium/windsurf/skills", cline: ".cline/skills", "roo-cline": ".roo/skills", "gemini-cli": ".gemini/skills", opencode: ".config/opencode/skills" };
+var AGENT_CONFIG_PATHS = { workbuddy: ".workbuddy/config.json", cursor: ".cursor/config.json", windsurf: ".codeium/windsurf/config.json", cline: ".cline/config.json", "roo-cline": ".roo/config.json", "gemini-cli": ".gemini/settings.json", opencode: ".config/opencode/config.json" };
+function getSkillPath(client, homeDir, name = "using-tuda") {
+  return path3.join(homeDir, AGENT_SKILL_DIRS[client], name);
+}
+async function isSkillInstalled(skillPath, name = "using-tuda") {
+  try {
+    const content = await readFile2(path3.join(skillPath, "SKILL.md"), "utf8");
+    return new RegExp(`^name:\\s*${name}\\s*$`, "mu").test(content);
+  } catch {
+    return false;
+  }
+}
+async function replaceManagedSkill(skillPath, bundledSkillPath, bundleDigest) {
+  const temporaryPath = `${skillPath}.update-${process.pid}-${randomUUID2()}`;
+  const backupPath = `${skillPath}.backup-${process.pid}-${randomUUID2()}`;
+  let movedExisting = false;
+  let installedNew = false;
+  await mkdir2(path3.dirname(skillPath), { recursive: true });
+  try {
+    await cp2(bundledSkillPath, temporaryPath, { recursive: true, force: true });
+    await writeFile2(path3.join(temporaryPath, MANAGED_SKILL_FILE), `${JSON.stringify({ schemaVersion: 1, bundleDigest }, null, 2)}
+`, "utf8");
+    try {
+      await rename2(skillPath, backupPath);
+      movedExisting = true;
+    } catch (error) {
+      if (!isNodeError(error, "ENOENT")) throw error;
+    }
+    try {
+      await rename2(temporaryPath, skillPath);
+      installedNew = true;
+    } catch (error) {
+      if (movedExisting) await rename2(backupPath, skillPath);
+      throw error;
+    }
+  } finally {
+    await rm2(temporaryPath, { recursive: true, force: true });
+    if (installedNew) await rm2(backupPath, { recursive: true, force: true });
+  }
+}
+async function readManagedSkillDigest(skillPath) {
+  try {
+    const value = JSON.parse(await readFile2(path3.join(skillPath, MANAGED_SKILL_FILE), "utf8"));
+    return typeof value.bundleDigest === "string" ? value.bundleDigest : null;
+  } catch {
+    return null;
+  }
+}
+async function snapshotSkill(directory) {
+  const files = /* @__PURE__ */ new Map();
+  await collectSkillFiles(directory, "", files);
+  const hash = createHash2("sha256");
+  for (const [relativePath, fileDigest] of files) {
+    hash.update(relativePath).update("\0").update(fileDigest).update("\0");
+  }
+  return { digest: hash.digest("hex"), files };
+}
+async function collectSkillFiles(directory, relativeDirectory, files) {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (entry.name === MANAGED_SKILL_FILE) continue;
+    const relativePath = path3.posix.join(relativeDirectory, entry.name);
+    const sourcePath = path3.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await collectSkillFiles(sourcePath, relativePath, files);
+    } else if (entry.isFile()) {
+      files.set(relativePath, createHash2("sha256").update(await readFile2(sourcePath)).digest("hex"));
+    }
+  }
+}
+function removeTomlTable(content, table) {
+  return content.replace(tomlTablePattern(table), "$1");
+}
+function tomlTablePattern(table) {
+  const escapedTable = table.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`(^|\\n)(?:#.*\\n)*\\[${escapedTable}\\][\\s\\S]*?(?=\\n(?:#.*\\n)*\\[(?!${escapedTable}\\.env\\])[^\\]]+\\]|$)`, "u");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function readOptional(filePath) {
+  try {
+    return await readFile2(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return "";
+    throw error;
+  }
+}
+async function pathExists(targetPath) {
+  try {
+    await access3(targetPath);
+    return true;
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return false;
+    throw error;
+  }
+}
+async function writeWithParent(filePath, content) {
+  const { mkdir: mkdir4 } = await import("node:fs/promises");
+  await mkdir4(path3.dirname(filePath), { recursive: true });
+  await writeFile2(filePath, content, "utf8");
+}
+function isNodeError(error, code) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === code;
+}
+
+// src/commands.ts
+var CliError = class extends Error {
+};
+async function runAdd(options) {
+  const targets = options.agents ?? await detectCodingAgents(options.homeDir);
+  if (!targets.length) throw new CliError("\u672A\u68C0\u6D4B\u5230 Coding Agent\u3002\u4F7F\u7528 --agent workbuddy \u7B49\u6307\u5B9A\u76EE\u6807\u3002");
+  const results = [];
+  for (const client of targets) {
+    await installAgentSkill(client, options.homeDir, options.bundledSkillPath);
+    await removeLegacyIntegration(client, options.homeDir);
+    await setSkillAutoInstallDeclined(options.userDataPath, client, false);
+    results.push({ client, skill: "installed" });
+  }
+  return { results };
+}
+async function runRemove(options) {
+  const targets = options.agents ?? await detectCodingAgents(options.homeDir);
+  for (const client of targets) {
+    await uninstallAgentSkill(client, options.homeDir);
+    await removeLegacyIntegration(client, options.homeDir);
+    await setSkillAutoInstallDeclined(options.userDataPath, client, true);
+  }
+  return { results: targets.map((client) => ({ client, skill: "removed" })) };
+}
+
+// src/runtime.ts
+import { spawn } from "node:child_process";
+import { readFile as readFile4 } from "node:fs/promises";
+import { createHash as createHash3 } from "node:crypto";
+import path5 from "node:path";
+
+// ../electron/local-api-client.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import path4 from "node:path";
+var BRIDGE_FILE = "local-api.json";
+async function callLocalApi(userDataPath, method, args) {
+  const bridgePath = path4.join(userDataPath, BRIDGE_FILE);
+  const info = JSON.parse(await readFile3(bridgePath, "utf8"));
+  if (!Number.isInteger(info.port) || info.port < 1 || info.port > 65535 || typeof info.token !== "string" || !/^[A-Za-z0-9_-]{20,100}$/u.test(info.token)) throw new Error("Tuda \u672C\u5730\u670D\u52A1\u53D1\u73B0\u4FE1\u606F\u65E0\u6548\u3002");
+  const response = await fetch(`http://127.0.0.1:${info.port}/call`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${info.token}`, "content-type": "application/json" },
+    signal: AbortSignal.timeout(3e4),
+    body: JSON.stringify({ method, args })
+  });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error || "Tuda \u672A\u80FD\u5B8C\u6210 CLI \u8BF7\u6C42\u3002");
+  return body.result;
+}
+
+// ../electron/background-session.ts
+var CLI_BACKGROUND_FLAG = "--tuda-background";
+
+// src/runtime.ts
+async function desktopInstance(userDataPath) {
+  let info;
+  try {
+    info = JSON.parse(await readFile4(path5.join(userDataPath, "local-api.json"), "utf8"));
+  } catch {
+    throw new Error("INVALID_LOCAL_BRIDGE");
+  }
+  if (!Number.isInteger(info.port) || info.port < 1 || info.port > 65535 || typeof info.token !== "string" || !/^[A-Za-z0-9_-]{20,100}$/.test(info.token)) throw new Error("INVALID_LOCAL_BRIDGE");
+  return createHash3("sha256").update(`${info.port}\0${info.token}`).digest("hex");
+}
+async function prepareDesktop(options) {
+  const call = await connect(options);
+  const state = await call("status");
+  return { ready: true, instanceId: await desktopInstance(options.userDataPath), protocolVersion: state.protocolVersion, desktopVersion: state.desktopVersion, boardPlugin: state.boardPlugin };
+}
+async function connect(options) {
+  const startupTimeoutMs = options.startupTimeoutMs ?? Number(process.env.TUDA_STARTUP_TIMEOUT_MS ?? 3e4);
+  if (!Number.isInteger(startupTimeoutMs) || startupTimeoutMs < 1e3 || startupTimeoutMs > 18e4) throw new Error("INVALID_STARTUP_TIMEOUT: expected 1000..180000 milliseconds");
+  const call = (method, args = {}) => callLocalApi(options.userDataPath, method, args);
+  try {
+    await call("status");
+    return call;
+  } catch (error) {
+    if (options.noLaunch) throw error;
+  }
+  const app = await resolveTudaApp(options.appRoot);
+  if (!app) throw new Error("\u672A\u627E\u5230 Tuda App\uFF0C\u8BF7\u5148\u5B89\u88C5\u5E76\u6253\u5F00 App\uFF0C\u6216\u6307\u5B9A --app-path\u3002");
+  const child = spawn(app.commandPath, [CLI_BACKGROUND_FLAG], { detached: true, stdio: "ignore", windowsHide: true, env: Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== "ELECTRON_RUN_AS_NODE")) });
+  await new Promise((resolve, reject) => {
+    child.once("spawn", resolve);
+    child.once("error", reject);
+  });
+  child.unref();
+  const startupDeadline = Date.now() + startupTimeoutMs;
+  while (Date.now() < startupDeadline) {
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    try {
+      await call("status");
+      return call;
+    } catch {
+    }
+  }
+  throw new Error("Tuda \u540E\u53F0\u670D\u52A1\u5C1A\u672A\u5C31\u7EEA\uFF0C\u8BF7\u68C0\u67E5\u8FD0\u884C\u65E5\u5FD7\uFF0C\u6216\u624B\u52A8\u6253\u5F00 App \u540E\u91CD\u8BD5\u3002");
+}
+
+// ../shared/media-import.ts
+var MAX_INLINE_MEDIA_BYTES = 20 * 1024 * 1024;
+var MAX_INLINE_MEDIA_DATA_URL_LENGTH = Math.ceil(MAX_INLINE_MEDIA_BYTES / 3) * 4 + 128;
+function assertInlineMediaByteLength(bytes, label = "\u7D20\u6750") {
+  if (bytes === 0) throw new Error(`${label}\u4E3A\u7A7A\uFF0C\u8BF7\u9009\u62E9\u975E\u7A7A\u7D20\u6750\u6587\u4EF6\u3002`);
+  if (bytes > MAX_INLINE_MEDIA_BYTES) {
+    throw new Error(`${label}\u539F\u59CB\u6587\u4EF6\u5927\u5C0F\u8D85\u8FC7 20 MiB\uFF08${MAX_INLINE_MEDIA_BYTES} \u5B57\u8282\uFF09\uFF0C\u5F53\u524D ${bytes} \u5B57\u8282\u3002\u8BF7\u538B\u7F29\u540E\u91CD\u8BD5\uFF0C\u6216\u901A\u8FC7 App \u5BFC\u5165\u3002`);
+  }
+}
+
+// ../electron/workspace-tools.ts
+var MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+function listWorkspaceTools() {
+  return [
+    tool("status", "Read workspace status and protocol version."),
+    tool("get_space", "Read selected personal/enterprise space, authenticated member, collaboration and pending-save state. No tokens returned."),
+    tool("select_space", "Switch the desktop selected space after flushing changes. Enterprise requires DingTalk login.", { target: { type: "string", enum: ["personal", "enterprise"] } }, ["target"]),
+    tool("list_providers", "List saved providers without credentials.", { kind: { type: "string", enum: ["image", "video", "text", "audio"] } }),
+    tool("get_provider", "Read saved Provider configuration without credentials.", { providerId: stringField("Provider ID") }, ["providerId"]),
+    tool("configure_provider", "Atomically configure a video or TTS provider. Does not submit generation. Omitted fields and credentials are preserved; empty apiKey clears it.", {
+      kind: { type: "string", enum: ["video", "audio"] },
+      action: { type: "string", enum: ["upsert", "default", "remove"] },
+      providerId: stringField("Existing ID or optional new ID"),
+      name: stringField("Display name"),
+      type: { type: "string", enum: ["ark", "fal", "openrouter", "minimax", "openai-compatible"] },
+      baseUrl: stringField("HTTP(S) service URL"),
+      model: stringField("Default model"),
+      models: stringArrayField("Saved models", 0),
+      voice: stringField("TTS voice ID"),
+      speechEndpoint: stringField("TTS relative endpoint; defaults to /v1/audio/speech"),
+      connectionProviderId: stringField("Video image connection ID; empty detaches"),
+      apiKey: stringField("Credential to encrypt; empty clears; never returned"),
+      setDefault: { type: "boolean" }
+    }, ["kind"]),
+    tool("list_models", "Read saved models for a provider.", { providerId: stringField("Provider ID") }, ["providerId"]),
+    tool("list_tasks", "Read generation history."),
+    tool("cancel_generation", "Cancel a locally queued image task before provider submission. Running requests are not cancelled and remote billing cannot be stopped or confirmed. Ctrl+C in the CLI only stops waiting.", { generationId: stringField("Image client task/generation ID") }, ["generationId"]),
+    tool("list_modification_requests", "Read saved annotation/mask edit briefs. No generation is submitted. Only ready requests may be claimed.", { boardId: stringField("Optional board ID") }),
+    tool("get_modification_request", "Read a brief with immutable sourcePath/sourceVersionId, relative regions, annotationPath/maskPath and required clarification. Use read_asset to inspect its managed images.", { requestId: stringField("Request ID") }, ["requestId"]),
+    tool("claim_modification_request", "Atomically claim a ready brief. Other agents cannot claim it. Retain the returned claim.token; use the fixed sourcePath when editing. No model call is submitted.", { requestId: stringField("Request ID"), owner: stringField("Agent session identifier") }, ["requestId", "owner"]),
+    tool("clarify_modification_request", "Supply explicit user clarification to a needs-input/failed brief. Never invent missing instructions. Does not generate images.", { requestId: stringField("Request ID"), instruction: stringField("Clarified user instruction") }, ["requestId", "instruction"]),
+    tool("finish_modification_request", "Link a claimed brief to a succeeded edit task and its managed outputs, or record an error. Requires claim token. Results are appended to the original node once.", { requestId: stringField("Request ID"), claimToken: stringField("Claim token"), resultJobId: stringField("Succeeded edit generation job ID"), resultPaths: stringArrayField("Managed output paths", 1), error: stringField("Failure description") }, ["requestId", "claimToken"]),
+    tool("create_canvas", "Create a persistent HTML/React/Vue code Canvas on the current board. Code is stored, not executed; user clicks Run in its isolated preview. React accepts JSX with default export or App; Vue accepts SFC script setup/template/style. Only built-in react, react-dom/client, vue imports are supported; no npm installation or network requests. Read get_board before editing existing nodes.", { boardId: stringField("Current board ID"), framework: { type: "string", enum: ["html", "react", "vue"] }, code: { type: "string", maxLength: 1e5 }, title: stringField("Canvas title") }, ["boardId", "framework", "code"]),
+    tool("update_canvas", "Update a Canvas node after reading get_board. Send full replacement code and expectedCode equal to the last read code to avoid overwriting manual edits. Does not execute code.", { boardId: stringField("Current board ID"), nodeId: stringField("Canvas node ID"), framework: { type: "string", enum: ["html", "react", "vue"] }, code: { type: "string", maxLength: 1e5 }, expectedCode: stringField("Exact previous code read from get_board"), title: stringField("Optional title") }, ["boardId", "nodeId", "framework", "code", "expectedCode"]),
+    tool("list_templates", "List reusable custom templates shared with the App. Legacy local templates migrate when the App workspace opens."),
+    tool("get_template", "Read a saved reusable template.", { templateId: stringField("Template ID") }, ["templateId"]),
+    ...["create_template", "update_template"].map((name) => tool(name, "Save reusable rules in the App template library. No generation or model call. Updates preserve omitted fields.", {
+      templateId: stringField("Existing template ID for update"),
+      name: stringField("Template name"),
+      description: stringField("Description"),
+      prompt: stringField("Fixed reusable rules"),
+      category: stringField("marketing/product/social/illustration/portrait/brand/concept/editing/other"),
+      mode: { type: "string", enum: ["generate", "edit"] },
+      useCase: stringField("Image use case; defaults to other"),
+      expectedPrompt: stringField("Optional previous prompt for optimistic concurrency"),
+      extractionScenario: { type: "string", enum: ["design-language", "layout-skeleton", "series-template", "replica"] },
+      fields: { type: "array", items: { type: "object", required: ["id", "label", "value"], properties: { id: stringField("Field ID"), label: stringField("Label"), value: stringField("Rule") } } }
+    }, name === "create_template" ? ["name", "prompt"] : ["templateId"])),
+    tool("get_board_library", "Read shared folder tree, board locations and directory revision in the selected space."),
+    tool("manage_board_library", "Create/rename folders, copy or move boards or folder trees, or delete an empty folder. Requires the latest expectedRevision from get_board_library. Null parentId means root; moves retain contents and asset paths.", {
+      expectedRevision: { type: "integer", minimum: 0 },
+      action: { type: "object", properties: {
+        type: { type: "string", enum: ["createFolder", "renameFolder", "move", "copy", "deleteEmptyFolder"] },
+        name: stringField("Folder name"),
+        id: stringField("Existing folder ID"),
+        parentId: { type: ["string", "null"] },
+        items: { type: "array", minItems: 1, maxItems: 1e3, items: { type: "object", properties: { kind: { type: "string", enum: ["board", "folder"] }, id: stringField("Item ID") }, required: ["kind", "id"] } }
+      }, required: ["type"], additionalProperties: false }
+    }, ["expectedRevision", "action"]),
+    tool("list_boards", "List Tuda boards."),
+    tool("resolve_generation_board", "Resolve the configured CLI default board, or reuse/create CLI \u521B\u4F5C when unset. An explicit boardId takes priority. Missing configured boards fail before generation.", { boardId: stringField("Optional target board ID") }),
+    tool("get_active_board", "Read the board currently active in the Tuda workspace, if any."),
+    tool("get_board", "Read a board including its nodes and image URLs.", { boardId: stringField("Board ID") }, ["boardId"]),
+    tool("get_board_layout", "Inspect a board's rendered bounds and report overlapping image nodes.", { boardId: stringField("Board ID") }, ["boardId"]),
+    tool("open_board", "Open a board in Tuda without changing its viewport.", { boardId: stringField("Board ID") }, ["boardId"]),
+    tool("fit_board_view", "Open a board in Tuda and fit all of its image nodes into the visible canvas.", { boardId: stringField("Board ID") }, ["boardId"]),
+    tool("focus_nodes", "Open a board and focus selected nodes in the visible canvas.", { boardId: stringField("Board ID"), nodeIds: stringArrayField("Board node IDs", 1) }, ["boardId", "nodeIds"]),
+    tool("move_image", "Move an image node to absolute canvas coordinates.", { boardId: stringField("Board ID"), nodeId: stringField("Image node ID"), x: numberField("Absolute canvas X coordinate"), y: numberField("Absolute canvas Y coordinate") }, ["boardId", "nodeId", "x", "y"]),
+    tool("resize_image", "Resize an image node by display width while preserving its image aspect ratio.", { boardId: stringField("Board ID"), nodeId: stringField("Image node ID"), displayWidth: { type: "number", minimum: 120, maximum: 600, description: "Display width in canvas units" } }, ["boardId", "nodeId", "displayWidth"]),
+    tool("arrange_images", "Arrange image nodes around their current center.", { boardId: stringField("Board ID"), nodeIds: stringArrayField("Image node IDs", 2), mode: { type: "string", enum: ["horizontal", "vertical", "grid"] }, gap: { type: "number", minimum: 0, maximum: 1e3, description: "Gap between images; defaults to 40" } }, ["boardId", "nodeIds", "mode"]),
+    tool("duplicate_images", "Duplicate image nodes, including their version history.", { boardId: stringField("Board ID"), nodeIds: stringArrayField("Image node IDs", 1), offset: { type: "number", minimum: -1e4, maximum: 1e4, description: "X and Y offset; defaults to 24" } }, ["boardId", "nodeIds"]),
+    tool("trash_images", "Move image nodes to Tuda's recoverable image trash.", { boardId: stringField("Board ID"), nodeIds: stringArrayField("Image node IDs", 1) }, ["boardId", "nodeIds"]),
+    tool("restore_image", "Restore an image from Tuda's recoverable image trash.", { trashId: stringField("Trashed image record ID returned by trash_images") }, ["trashId"]),
+    tool("set_image_version", "Switch an image node to a zero-based version index.", { boardId: stringField("Board ID"), nodeId: stringField("Image node ID"), versionIndex: { type: "integer", minimum: 0, description: "Zero-based image version index" } }, ["boardId", "nodeId", "versionIndex"]),
+    tool("create_board", "Create a new Tuda board.", { name: stringField("Board name") }),
+    tool("list_assets", "List searchable image assets.", { limit: { type: "number", minimum: 1, maximum: 100 } }),
+    tool("read_asset", "Read a managed image as a data URL. Use the CLI assets export command to save a source, annotation or mask locally for visual inspection.", { path: stringField("Managed Tuda image path") }, ["path"]),
+    tool("get_generation_status", "Read an image generation or edit task. Poll this after generate_image or edit_image returns a generationId.", { generationId: stringField("Generation ID") }, ["generationId"]),
+    tool("generate_image", "Start image generation using Tuda's configured provider. Reference paths are managed Tuda asset paths and remain visible on the board. Set background to transparent for a transparent PNG. Check the Provider capabilities with list_providers first; unsupported transparency requests fail instead of falling back to an opaque image. Returns immediately with a generationId; poll get_generation_status until terminal. Successful images are added to the board. Omit boardId to use the configured CLI default board.", { boardId: stringField("Target board ID"), prompt: stringField("Image prompt"), templateId: stringField("Optional saved template; prompt supplies this run content"), providerId: stringField("Provider ID"), quality: { type: "string", enum: ["auto", "low", "medium", "high"] }, style: stringField("Style"), referencePaths: { type: "array", items: { type: "string" }, description: "Managed Tuda reference image paths" }, n: { type: "number", minimum: 1, maximum: 4 }, model: stringField("Optional model"), size: stringField("Optional size"), background: { type: "string", enum: ["auto", "opaque", "transparent"], description: "Requested output background; support depends on the active Provider" } }, ["prompt"]),
+    tool("edit_image", "Edit a managed image. For a claimed annotation brief, supply modificationRequestId and claimToken: the app validates its fixed source, uses its mask/references and binds one execution key. Finish the request to append results once. Set background to transparent for a transparent PNG; check Provider capabilities with list_providers first. Unsupported transparency requests fail. This operation may incur provider charges.", { boardId: stringField("Target board ID"), sourcePath: stringField("Managed source image path"), prompt: stringField("Reviewed edit instruction"), templateId: stringField("Optional saved edit template"), providerId: stringField("Provider ID"), model: stringField("Model ID"), background: { type: "string", enum: ["auto", "opaque", "transparent"], description: "Requested output background; transparent produces PNG and requires Provider support" }, modificationRequestId: stringField("Optional claimed modification request ID"), claimToken: stringField("Token returned only by claim_modification_request"), referencePaths: stringArrayField("Additional managed references when no modification request", 0) }, ["boardId", "sourcePath", "prompt"]),
+    tool("import_image", "Import a data URL image into Tuda managed assets and optionally append it to a board. Maximum original file size: 20 MiB; independent of text limits.", { dataUrl: { ...stringField("Base64 image data URL; decoded file must be non-empty and at most 20 MiB"), maxLength: MAX_INLINE_MEDIA_DATA_URL_LENGTH }, boardId: stringField("Optional target board ID") }, ["dataUrl"]),
+    tool("generate_video", "Start an asynchronous video generation task. Returns a videoGenerationId immediately; poll get_video_generation_status until terminal. Final results are managed local files, never remote provider URLs.", {
+      boardId: stringField("Target board ID"),
+      prompt: stringField("Video prompt"),
+      mode: { type: "string", enum: ["generate", "remix", "extend"] },
+      model: stringField("Optional video model"),
+      aspectRatio: stringField("Optional aspect ratio, for example 16:9"),
+      resolution: stringField("Optional resolution, for example 720p"),
+      durationSeconds: { type: "number", minimum: 1, maximum: 60 },
+      referenceImagePaths: { type: "array", items: { type: "string" }, description: "Managed reference image paths. Empty or omitted uses the requested board image or latest board image; set textOnly=true for text-only." },
+      textOnly: { type: "boolean", description: "Explicitly generate without board image references" },
+      referenceNodeIds: stringArrayField("Board image node IDs to animate; used when referenceImagePaths is omitted", 0),
+      firstFramePath: stringField("Optional managed first-frame image path"),
+      lastFramePath: stringField("Optional managed last-frame image path"),
+      sourceVideoPath: stringField("Managed source video path for remix or extend"),
+      referenceVideoPaths: { type: "array", items: { type: "string" }, description: "Managed reference video paths" },
+      referenceAudioPaths: { type: "array", items: { type: "string" }, description: "Managed reference audio paths" },
+      generationNodeId: stringField("Video generation node ID for a board workflow"),
+      targetVideoNodeId: stringField("Target video node ID for remix or extend"),
+      generateAudio: { type: "boolean" },
+      watermark: { type: "boolean" },
+      providerId: stringField("Optional provider ID")
+    }, ["prompt"]),
+    tool("get_video_generation_status", "Read a persisted video task. Poll until completed, failed, or cancelled. Completed results expose managed local paths only.", { videoGenerationId: stringField("Video generation ID") }, ["videoGenerationId"]),
+    tool("stop_video_polling", "Stop this App session's local polling for a video task. This does not cancel the remote provider task.", { videoGenerationId: stringField("Video generation ID") }, ["videoGenerationId"]),
+    tool("import_video", "Import a video data URL into Tuda managed storage and optionally append it to a board. Maximum original file size: 20 MiB; independent of text limits. Remote URLs are not accepted as final results.", { dataUrl: { ...stringField("Base64 MP4/MOV/WebM data URL; decoded file must be non-empty and at most 20 MiB"), maxLength: MAX_INLINE_MEDIA_DATA_URL_LENGTH }, boardId: stringField("Optional target board ID") }, ["dataUrl"]),
+    tool("slice_image", "Locally slice a managed image into PNG assets and append to a board. No model call. Specify crops OR rows/columns (1-8); margin/gap are source pixels. Preserves the original. Returns images, crops and nodeIds in reading order.", {
+      boardId: stringField("Target board ID"),
+      nodeId: stringField("Source image node ID; alternatively sourcePath"),
+      sourcePath: stringField("Managed source image path"),
+      rows: { type: "integer", minimum: 1, maximum: 8 },
+      columns: { type: "integer", minimum: 1, maximum: 8 },
+      margin: { type: "integer", minimum: 0 },
+      gap: { type: "integer", minimum: 0 },
+      crops: { type: "array", minItems: 1, maxItems: 64, items: { type: "object", required: ["x", "y", "width", "height"], additionalProperties: false, properties: { x: { type: "integer", minimum: 0 }, y: { type: "integer", minimum: 0 }, width: { type: "integer", minimum: 1 }, height: { type: "integer", minimum: 1 } } } }
+    }, ["boardId"]),
+    tool("export_assets", "Export selected managed image paths as a ZIP to Tuda's download directory.", { paths: { type: "array", items: { type: "string" } } }, ["paths"]),
+    tool("open_tuda", "Open Tuda visibly for the user.")
+  ];
+}
+function tool(name, description, properties = {}, required = []) {
+  return { name, description, inputSchema: { type: "object", properties: { space: { type: "string", enum: ["personal", "enterprise"], description: "Pin this operation to a space; omitted uses the selected desktop space at task start." }, ...properties }, ...required.length ? { required } : {} } };
+}
+function stringField(description) {
+  return { type: "string", description };
+}
+function numberField(description) {
+  return { type: "number", description };
+}
+function stringArrayField(description, minItems) {
+  return { type: "array", items: { type: "string" }, minItems, uniqueItems: true, description };
+}
+
+// src/main.ts
+var HELP = `Tuda CLI \u2014 \u4F7F\u7528 App \u4FDD\u5B58\u7684\u6A21\u578B\u521B\u4F5C
+
+tuda status                         \u5DE5\u4F5C\u533A\u72B6\u6001
+tuda desktop prepare                \u51C6\u5907\u684C\u9762\u540E\u53F0\u5E76\u8FD4\u56DE\u4E0D\u542B\u51ED\u8BC1\u7684\u5B9E\u4F8B\u8EAB\u4EFD
+tuda providers list [--kind image]   \u5DF2\u4FDD\u5B58\u7684\u6A21\u578B\u670D\u52A1\uFF08\u4E0D\u5305\u542B\u5BC6\u94A5\uFF09
+tuda providers show <id>             \u67E5\u770B\u914D\u7F6E\uFF08\u4E0D\u5305\u542B\u5BC6\u94A5\uFF09
+tuda providers set --kind video|audio --provider <id> --model <id> [\u914D\u7F6E\u9009\u9879]
+tuda providers default|remove <id> --kind video|audio
+tuda models list --provider <id>     \u670D\u52A1\u5DF2\u4FDD\u5B58\u7684\u6A21\u578B
+tuda models set --kind video|audio --provider <id> --model <id> [--saved-model <id>]
+\u914D\u7F6E\uFF1A--type --name --base-url --voice --speech-endpoint --connection-provider
+      --saved-model <id>\uFF08\u53EF\u91CD\u590D\uFF09 --default --api-key-env <\u53D8\u91CF\u540D> | --api-key-stdin
+      --clear-api-key \u6E05\u9664\u5BC6\u94A5\uFF1B\u7701\u7565\u5BC6\u94A5\u53C2\u6570\u5219\u4FDD\u7559\u539F\u51ED\u8BC1\u3002audio \u4E3A\u72EC\u7ACB TTS \u914D\u7F6E\u3002
+tuda image generate --prompt <text> [--reference <file>] [--out <file>]
+tuda image slice --path <managed-path> --rows 3 --columns 4 [--out <directory>]
+tuda image edit --input <file> --prompt <text> [--out <file>]
+tuda video generate --prompt <text> [--board <id>]
+tuda tasks list|get|wait|cancel [task-id] [--kind video] [--out <file>]
+tuda boards list|create|show|open [id] [--name <name>]
+tuda assets list|import|export [--input <file>] [--path <managed-path>] [--out <file>]
+tuda templates list|show [id]       \u67E5\u8BE2\u53EF\u590D\u7528\u6A21\u677F
+tuda templates create --name <name> --prompt <rules>
+tuda templates update <id> --prompt <rules>
+\u6A21\u677F\u5B57\u6BB5\uFF1A--description --category --mode --use-case\uFF1B--input <JSON\u6587\u4EF6>
+\u56FE\u7247\u751F\u6210/\u7F16\u8F91\uFF1A--template <id> --prompt <\u672C\u6B21\u5185\u5BB9>
+tuda tools list                      \u5B8C\u6574\u64CD\u4F5C\u76EE\u5F55\u53CA JSON schema
+tuda guard descriptor                \u79BB\u7EBF\u8F93\u51FA Guard \u547D\u4EE4\u63CF\u8FF0\uFF08\u4E0D\u4F1A\u5B89\u88C5\u6216\u542F\u7528 Guard\uFF09
+tuda call <operation> --input '<JSON>'  \u8C03\u7528\u4EFB\u610F\u5DE5\u4F5C\u53F0\u64CD\u4F5C
+tuda add [--agent <id>]              \u5B89\u88C5 CLI Skill\uFF0C\u8FC1\u79FB\u65E7\u96C6\u6210
+tuda remove --agent <id>             \u79FB\u9664 Skill
+
+\u901A\u7528\u9009\u9879\uFF1A--json --async --provider <id> --model <id> --board <id>
+--user-data-path <path> --app-path <path> --no-launch --timeout <seconds> --startup-timeout <seconds>
+\u9ED8\u8BA4\u81EA\u52A8\u542F\u52A8\u9690\u85CF\u540E\u53F0\u670D\u52A1\uFF0C\u4E0D\u663E\u793A App \u7A97\u53E3\uFF1B--no-launch \u4EC5\u8FDE\u63A5\u5DF2\u6709\u670D\u52A1\u3002
+\u751F\u6210\uFF1A--size auto --n 1 --quality high --background transparent
+\u672A\u6307\u5B9A --board \u65F6\u4F7F\u7528\u8BBE\u7F6E\u4E2D\u7684 CLI \u9ED8\u8BA4\u753B\u677F\uFF1B\u672A\u914D\u7F6E\u65F6\u4F7F\u7528\u300CCLI \u521B\u4F5C\u300D\u3002
+\u9ED8\u8BA4\u7B49\u5F85\u4EFB\u52A1\u5B8C\u6210\uFF1BCtrl+C \u53EA\u7ED3\u675F\u7B49\u5F85\u3002\u5DF2\u6709\u8F93\u51FA\u6587\u4EF6\u4E0D\u4F1A\u8986\u76D6\uFF0C\u9664\u975E --overwrite\u3002`;
+function parse(argv) {
+  const words = [], flags = {};
+  const bools = /* @__PURE__ */ new Set(["json", "async", "no-launch", "overwrite", "help", "version", "default", "api-key-stdin", "clear-api-key"]);
+  const values = /* @__PURE__ */ new Set(["template", "description", "category", "mode", "use-case", "expected-prompt", "agent", "home", "kind", "provider", "model", "prompt", "input", "out", "path", "board", "name", "size", "quality", "style", "background", "n", "reference", "ratio", "duration", "resolution", "timeout", "startup-timeout", "request-id", "app-path", "user-data-path", "type", "base-url", "voice", "speech-endpoint", "connection-provider", "saved-model", "api-key-env", "rows", "columns", "margin", "gap", "crops", "node"]);
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      words.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    if (bools.has(key)) {
+      flags[key] = ["true"];
+      continue;
+    }
+    if (!values.has(key)) throw new Error(`\u672A\u77E5\u53C2\u6570 --${key}\u3002`);
+    const value = argv[++i];
+    if (!value || value.startsWith("--")) throw new Error(`\u53C2\u6570 --${key} \u7F3A\u5C11\u503C\u3002`);
+    (flags[key] ??= []).push(value);
+  }
+  return { words, flags };
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+var moduleDir = path6.dirname(fileURLToPath2(import.meta.url));
+async function importFile(call, file, boardId) {
+  const mime = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif", ".mp4": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm" };
+  const mimeType = mime[path6.extname(file).toLowerCase()];
+  if (!mimeType) throw new Error("\u4E0D\u652F\u6301\u7684\u7D20\u6750\u6587\u4EF6\u683C\u5F0F\u3002");
+  const label = `\u7D20\u6750\u300C${path6.basename(file)}\u300D`;
+  const info = await stat(file);
+  if (!info.isFile()) throw new Error(`${label}\u4E0D\u662F\u666E\u901A\u6587\u4EF6\u3002`);
+  assertInlineMediaByteLength(info.size, label);
+  const bytes = await readFile5(file);
+  assertInlineMediaByteLength(bytes.length, label);
+  const result = await call(mimeType.startsWith("video/") ? "import_video" : "import_image", { dataUrl: `data:${mimeType};base64,${bytes.toString("base64")}`, ...boardId ? { boardId } : {} });
+  if (typeof result === "string") return result;
+  const r = record(result);
+  const managed = r.path ?? r.videoPath ?? r.imagePath;
+  if (typeof managed !== "string") throw new Error("\u7D20\u6750\u5BFC\u5165\u672A\u8FD4\u56DE\u53D7\u7BA1\u8DEF\u5F84\u3002");
+  return managed;
+}
+async function exportFiles(call, paths, destination, overwrite) {
+  if (!paths.length) throw new Error("\u6CA1\u6709\u53EF\u5BFC\u51FA\u7684\u7D20\u6750\u3002");
+  const directory = paths.length > 1 || destination.endsWith(path6.sep) || (await stat(destination).catch(() => null))?.isDirectory();
+  const outputs = [];
+  for (let i = 0; i < paths.length; i++) {
+    const target = path6.resolve(directory ? path6.join(destination, `${i + 1}-${path6.basename(paths[i])}`) : destination);
+    const data = record(await call("read_asset", { path: paths[i] })).dataUrl;
+    if (typeof data !== "string" || !/^data:[^;]+;base64,/u.test(data)) throw new Error("\u7D20\u6750\u6570\u636E\u683C\u5F0F\u65E0\u6548\u3002");
+    await mkdir3(path6.dirname(target), { recursive: true });
+    await writeFile3(target, Buffer.from(data.slice(data.indexOf(",") + 1), "base64"), { flag: overwrite ? "w" : "wx" });
+    outputs.push(target);
+  }
+  return outputs;
+}
+async function main() {
+  if (await handleManagement(process.argv.slice(2))) return;
+  const { words, flags } = parse(process.argv.slice(2));
+  if (!(words[0] === "desktop" && words[1] === "prepare")) await automaticUpdateCheck();
+  const get = (key) => flags[key]?.at(-1);
+  if (flags.help || words[0] === "help" || !words.length && !flags.version) {
+    process.stdout.write(HELP + "\n");
+    return;
+  }
+  if (flags.version || words[0] === "version") {
+    const pkg = JSON.parse(await readFile5(path6.resolve(moduleDir, "../package.json"), "utf8"));
+    process.stdout.write(pkg.version + "\n");
+    return;
+  }
+  const timeout = Number(get("timeout") ?? "600");
+  if (!Number.isFinite(timeout) || timeout <= 0) throw new Error("--timeout \u5FC5\u987B\u662F\u6B63\u6570\u3002");
+  const userDataPath = get("user-data-path") ?? process.env.TUDA_USER_DATA_PATH ?? defaultUserDataPath();
+  const [group, action, id] = words;
+  const output = (data) => process.stdout.write(JSON.stringify(flags.json ? { schemaVersion: 1, ok: true, data } : data, (key, value) => key === "previewImageDataUrls" ? void 0 : value, 2) + "\n");
+  if (group === "desktop" && action === "prepare") {
+    output(await prepareDesktop({
+      userDataPath,
+      appRoot: get("app-path"),
+      noLaunch: Boolean(flags["no-launch"]),
+      startupTimeoutMs: get("startup-timeout") === void 0 ? Number(process.env.TUDA_STARTUP_TIMEOUT_MS ?? 12e4) : Number(get("startup-timeout")) * 1e3
+    }));
+    return;
+  }
+  if (group === "guard" && action === "descriptor") {
+    output(JSON.parse(await readFile5(path6.resolve(moduleDir, "../guard/command.tuda.json"), "utf8")));
+    return;
+  }
+  if (group === "add" || group === "remove") {
+    const agents = flags.agent;
+    const supported = /* @__PURE__ */ new Set(["codex", "claude-code", "workbuddy", "cursor", "windsurf", "cline", "roo-cline", "gemini-cli", "opencode"]);
+    if (agents?.some((a) => !supported.has(a))) throw new Error("\u672A\u77E5\u7684 Coding Agent\u3002");
+    const options = { homeDir: get("home") ?? os3.homedir(), userDataPath, agents: agents ?? null, bundledSkillPath: path6.resolve(moduleDir, "../skills/using-tuda") };
+    output(await (group === "add" ? runAdd(options) : runRemove(options)));
+    return;
+  }
+  if (group === "tools" && action === "list") {
+    output(listWorkspaceTools());
+    return;
+  }
+  const call = await connect({ ...get("startup-timeout") === void 0 ? {} : { startupTimeoutMs: Number(get("startup-timeout")) * 1e3 }, userDataPath, appRoot: get("app-path"), noLaunch: Boolean(flags["no-launch"]) || Boolean(process.env.TUDA_USER_DATA_PATH) || Boolean(get("user-data-path")) });
+  if (group === "status" || group === "doctor") {
+    output(await call("status"));
+    return;
+  }
+  if (group === "providers" && action === "list") {
+    output(await call("list_providers", get("kind") ? { kind: get("kind") } : {}));
+    return;
+  }
+  if (group === "providers" && action === "show") {
+    output(await call("get_provider", { providerId: id ?? get("provider") }));
+    return;
+  }
+  if (group === "providers" && ["set", "default", "remove"].includes(action) || group === "models" && action === "set") {
+    if (!["video", "audio"].includes(get("kind") ?? "")) throw new Error("\u914D\u7F6E\u5FC5\u987B\u6307\u5B9A --kind video \u6216 audio\u3002");
+    const input = { kind: get("kind"), action: action === "set" ? "upsert" : action, providerId: id ?? get("provider") };
+    if (action !== "set" && !input.providerId) throw new Error("\u7F3A\u5C11 Provider ID\u3002");
+    const fields = { name: "name", type: "type", "base-url": "baseUrl", model: "model", voice: "voice", "speech-endpoint": "speechEndpoint", "connection-provider": "connectionProviderId" };
+    for (const [flag, field] of Object.entries(fields)) if (get(flag) !== void 0) input[field] = get(flag) === "none" && flag === "connection-provider" ? "" : get(flag);
+    if (flags["saved-model"]) input.models = flags["saved-model"];
+    if (flags.default) input.setDefault = true;
+    const keySources = [Boolean(get("api-key-env")), Boolean(flags["api-key-stdin"]), Boolean(flags["clear-api-key"])].filter(Boolean).length;
+    if (keySources > 1) throw new Error("\u5BC6\u94A5\u53C2\u6570\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528\u3002");
+    if (action !== "set" && (keySources || Object.keys(input).some((key) => !["kind", "action", "providerId"].includes(key)))) throw new Error("\u9ED8\u8BA4/\u5220\u9664\u64CD\u4F5C\u4E0D\u63A5\u53D7\u5176\u5B83\u914D\u7F6E\u5B57\u6BB5\u3002");
+    if (get("api-key-env")) {
+      const key = process.env[get("api-key-env")];
+      if (!key?.trim()) throw new Error("\u6307\u5B9A\u7684 API Key \u73AF\u5883\u53D8\u91CF\u4E3A\u7A7A\u6216\u4E0D\u5B58\u5728\u3002");
+      input.apiKey = key.trim();
+    }
+    if (flags["api-key-stdin"]) {
+      if (process.stdin.isTTY) throw new Error("\u8BF7\u901A\u8FC7\u7BA1\u9053\u5411 stdin \u63D0\u4F9B\u5BC6\u94A5\u3002");
+      const chunks = [];
+      let bytes = 0;
+      for await (const chunk of process.stdin) {
+        const buffer = Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > 1e5) throw new Error("API Key \u8F93\u5165\u8FC7\u957F\u3002");
+        chunks.push(buffer);
+      }
+      const key = Buffer.concat(chunks).toString("utf8").trim();
+      if (!key) throw new Error("API Key \u8F93\u5165\u4E3A\u7A7A\uFF1B\u6E05\u9664\u8BF7\u4F7F\u7528 --clear-api-key\u3002");
+      input.apiKey = key;
+    }
+    if (flags["clear-api-key"]) input.apiKey = "";
+    output(await call("configure_provider", input));
+    return;
+  }
+  if (group === "models" && action === "list") {
+    output(await call("list_models", { providerId: get("provider") }));
+    return;
+  }
+  if (group === "call") {
+    if (!action || !listWorkspaceTools().some((tool2) => tool2.name === action)) throw new Error("\u672A\u77E5\u7684\u5DE5\u4F5C\u53F0\u64CD\u4F5C\uFF0C\u8BF7\u8FD0\u884C tuda tools list\u3002");
+    const args = JSON.parse(get("input") ?? "{}");
+    if (!args || typeof args !== "object" || Array.isArray(args)) throw new Error("--input \u5FC5\u987B\u662F JSON \u5BF9\u8C61\u3002");
+    output(await call(action, args));
+    return;
+  }
+  let result;
+  const video = group === "video" || get("kind") === "video";
+  if (group === "templates") {
+    const methods = { list: "list_templates", show: "get_template", create: "create_template", update: "update_template" };
+    if (!methods[action]) throw new Error("\u672A\u77E5\u6A21\u677F\u64CD\u4F5C\u3002");
+    if (["show", "update"].includes(action) && !id) throw new Error("\u7F3A\u5C11\u6A21\u677F ID\u3002");
+    let input = {};
+    if (get("input")) {
+      const parsed = JSON.parse(await readFile5(get("input"), "utf8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("\u6A21\u677F\u6587\u4EF6\u5FC5\u987B\u662F JSON \u5BF9\u8C61\u3002");
+      input = parsed;
+    }
+    for (const [flag, field] of Object.entries({ name: "name", prompt: "prompt", description: "description", category: "category", mode: "mode", "use-case": "useCase", "expected-prompt": "expectedPrompt" })) {
+      if (get(flag) !== void 0) input[field] = get(flag);
+    }
+    if (id) input.templateId = id;
+    output(await call(methods[action], input));
+    return;
+  }
+  if (group === "boards") {
+    const methods = { list: "list_boards", create: "create_board", show: "get_board", open: "open_board", active: "get_active_board" };
+    if (!methods[action]) throw new Error("\u672A\u77E5\u753B\u677F\u64CD\u4F5C\u3002");
+    output(await call(methods[action], { boardId: id, name: get("name") }));
+    return;
+  }
+  if (group === "assets") {
+    if (action === "list") {
+      output(await call("list_assets"));
+      return;
+    }
+    if (action === "import" && get("input")) {
+      output({ path: await importFile(call, get("input"), get("board")) });
+      return;
+    }
+    if (action === "export" && get("path") && get("out")) {
+      output({ paths: await exportFiles(call, [get("path")], get("out"), Boolean(flags.overwrite)) });
+      return;
+    }
+    throw new Error("\u7D20\u6750\u64CD\u4F5C\u7F3A\u5C11\u53C2\u6570\u3002\u8FD0\u884C tuda help \u67E5\u770B\u7528\u6CD5\u3002");
+  }
+  if (group === "image" && action === "slice") {
+    if ([get("input"), get("path"), get("node")].filter(Boolean).length !== 1) throw new Error("\u5207\u56FE\u987B\u6307\u5B9A\u4E14\u4EC5\u6307\u5B9A --input\u3001--path \u6216 --node\u3002");
+    const args = {};
+    for (const key of ["rows", "columns", "margin", "gap"]) if (get(key) !== void 0) args[key] = Number(get(key));
+    if (get("crops")) args.crops = JSON.parse(get("crops"));
+    if (args.crops === void 0 && (!get("rows") || !get("columns"))) throw new Error("\u8BF7\u6307\u5B9A --rows \u548C --columns\uFF0C\u6216 --crops JSON\u3002");
+    const boardId = get("board") ?? String(record(await call("resolve_generation_board")).boardId);
+    args.boardId = boardId;
+    if (get("node")) args.nodeId = get("node");
+    else args.sourcePath = get("path") ?? await importFile(call, get("input"), boardId);
+    const sliced = record(await call("slice_image", args));
+    if (get("out")) {
+      try {
+        sliced.exportedPaths = await exportFiles(call, sliced.images.map((image) => image.path), path6.resolve(get("out")) + path6.sep, Boolean(flags.overwrite));
+      } catch (error) {
+        throw new Error(`\u5207\u56FE\u5DF2\u4FDD\u5B58\u5230\u753B\u677F ${boardId}\uFF1B\u5BFC\u51FA\u5931\u8D25\uFF0C\u53EF\u7528 assets export \u91CD\u8BD5\uFF1A${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    output(sliced);
+    return;
+  }
+  if (group === "tasks" && action === "list") {
+    output(await call("list_tasks"));
+    return;
+  }
+  if (group === "tasks" && action === "cancel") {
+    if (!id) throw new Error("\u7F3A\u5C11\u4EFB\u52A1 ID\u3002");
+    if (video) throw new Error("\u89C6\u9891\u8FDC\u7AEF\u53D6\u6D88\u4E0D\u5728\u6B64\u64CD\u4F5C\u8303\u56F4\uFF1B\u4EC5\u505C\u6B62\u7B49\u5F85\u4E0D\u4F1A\u505C\u6B62\u8FDC\u7AEF\u4EFB\u52A1\u3002");
+    output(await call("cancel_generation", { generationId: id }));
+    return;
+  }
+  if (group === "tasks" && (action === "get" || action === "wait")) {
+    if (!id) throw new Error("\u7F3A\u5C11\u4EFB\u52A1 ID\u3002");
+    result = await call(video ? "get_video_generation_status" : "get_generation_status", video ? { videoGenerationId: id } : { generationId: id });
+    if (action === "get") {
+      const r = record(result);
+      delete r.previewImageDataUrls;
+      output(r);
+      return;
+    }
+  } else if (group === "image" && (action === "generate" || action === "edit") || group === "video" && action === "generate") {
+    if (video && get("template")) throw new Error("--template \u76EE\u524D\u53EA\u652F\u6301\u56FE\u7247\u751F\u6210\u548C\u7F16\u8F91\u3002");
+    if (!get("prompt")?.trim()) throw new Error("\u7F3A\u5C11 --prompt\u3002");
+    if (action === "edit" && !get("input")) throw new Error("\u7F3A\u5C11 --input\u3002");
+    let boardId = get("board");
+    if (!boardId) {
+      boardId = String(record(await call("resolve_generation_board")).boardId);
+    }
+    const args = { templateId: get("template"), boardId, prompt: get("prompt"), providerId: get("provider"), model: get("model"), size: get("size"), quality: get("quality"), background: get("background"), style: get("style"), n: get("n") ? Number(get("n")) : 1 };
+    if (flags.reference) args[video ? "referenceImagePaths" : "referencePaths"] = await Promise.all(flags.reference.map((file) => importFile(call, file, boardId)));
+    if (action === "edit") {
+      if (!get("input")) throw new Error("\u7F3A\u5C11 --input\u3002");
+      args.sourcePath = await importFile(call, get("input"), boardId);
+    }
+    if (video) {
+      args.aspectRatio = get("ratio");
+      args.durationSeconds = get("duration") ? Number(get("duration")) : void 0;
+      args.resolution = get("resolution");
+    }
+    args.requestId = get("request-id") ?? randomUUID3();
+    if (!video) process.stderr.write(`\u63D0\u4EA4\u8BF7\u6C42 ${String(args.requestId)}
+`);
+    try {
+      result = await call(video ? "generate_video" : action === "edit" ? "edit_image" : "generate_image", args);
+    } catch (error) {
+      throw new Error(`${error instanceof Error ? error.message : String(error)}${video ? "" : `\uFF1B\u8BF7\u6C42 ID ${String(args.requestId)}\uFF0C\u8BF7\u5148\u67E5\u8BE2\u4EFB\u52A1\u72B6\u6001\u518D\u51B3\u5B9A\u662F\u5426\u91CD\u65B0\u751F\u6210\u3002`}`);
+    }
+    if (flags.async) {
+      output(result);
+      return;
+    }
+  } else throw new Error("\u672A\u77E5\u547D\u4EE4\u3002\u8FD0\u884C tuda help \u67E5\u770B\u7528\u6CD5\u3002");
+  let task = record(result);
+  const taskId = task.generationId ?? task.videoGenerationId;
+  if (typeof taskId !== "string") throw new Error("\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u672A\u8FD4\u56DE\u4EFB\u52A1 ID\u3002");
+  process.stderr.write(`\u4EFB\u52A1 ${taskId}\uFF1BCtrl+C \u7ED3\u675F\u7B49\u5F85\uFF0C\u53EF\u7528 tasks wait ${taskId}${video ? " --kind video" : ""} \u7EE7\u7EED\u3002
+`);
+  const deadline = Date.now() + timeout * 1e3;
+  while (!["succeeded", "completed", "failed", "cancelled", "interrupted", "unknown"].includes(String(task.status))) {
+    if (Date.now() >= deadline) throw new Error(`\u7B49\u5F85\u8D85\u65F6\uFF0C\u4EFB\u52A1\u4ECD\u53EF\u67E5\u8BE2\uFF1A${taskId}`);
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    task = record(await call(video ? "get_video_generation_status" : "get_generation_status", video ? { videoGenerationId: taskId } : { generationId: taskId }));
+  }
+  delete task.previewImageDataUrls;
+  if (["failed", "cancelled", "interrupted", "unknown"].includes(String(task.status))) throw new Error(`\u4EFB\u52A1 ${taskId}\uFF1A${String(task.error ?? task.status)}`);
+  if (get("out")) {
+    const paths = video ? [String(record(task.video).path)] : (task.images ?? []).map((image) => image.path);
+    try {
+      task.exportedPaths = await exportFiles(call, paths, get("out"), Boolean(flags.overwrite));
+    } catch (error) {
+      throw new Error(`\u751F\u6210\u5DF2\u5B8C\u6210\uFF0C\u4EFB\u52A1 ${taskId}\uFF1B\u5BFC\u51FA\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\u3002\u53EF\u518D\u6B21 tasks wait \u5BFC\u51FA\u3002`);
+    }
+  }
+  output(task);
+}
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  if (process.argv.includes("--json")) process.stdout.write(JSON.stringify({ schemaVersion: 1, ok: false, error: { code: /^([A-Z][A-Z0-9_]+):/.exec(message)?.[1] ?? "TUDA_ERROR", message } }) + "\n");
+  else process.stderr.write(`tuda\uFF1A${message}
+`);
+  process.exitCode = 1;
+});