chainlesschain 0.162.176 → 0.162.178

package/src/commands/init.js

@@ -561,6 +561,7 @@ parameters:
     description: 输出文件路径（.mp3 或 .wav）
     default: "output.mp3"
 execution-mode: direct
+capabilities: [shell-exec]
 ---
 
 # AI 音频生成
@@ -608,24 +609,38 @@ chainlesschain cli-anything register <tool-name>
  * Auto-detects which backend is available and uses the best one.
  */
 
-const { execSync, spawn, spawnSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const https = require("https");
 
-function commandExists(cmd) {
+function requireProcessBroker(context) {
+  const broker = context && context.processBroker;
+  if (!broker || typeof broker.run !== "function" ||
+      typeof broker.runSync !== "function" || typeof broker.runFileSync !== "function") {
+    throw new Error("Process Broker unavailable for audio-gen skill");
+  }
+  return broker;
+}
+
+function commandExists(processBroker, cmd) {
   try {
-    execSync(\`\${cmd} --version\`, { stdio: "ignore", encoding: "utf-8" });
+    processBroker.runFileSync(cmd, ["--version"], {
+      stdio: "ignore",
+      encoding: "utf-8",
+      timeout: 5000,
+    });
     return true;
   } catch {
     return false;
   }
 }
 
-function runEdgeTTS(text, voice, outputPath) {
+function runEdgeTTS(processBroker, text, voice, outputPath) {
   return new Promise((resolve, reject) => {
     const args = ["edge-tts", "--voice", voice || "zh-CN-XiaoxiaoNeural", "--text", text, "--write-media", outputPath];
-    const proc = spawn("python", ["-m", ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const proc = processBroker.run("python", ["-m", ...args], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
     let stderr = "";
     proc.stderr.on("data", (d) => (stderr += d.toString("utf8")));
     proc.on("close", (code) => {
@@ -699,7 +714,7 @@ function callOpenAITTS(text, voice, outputPath, apiKey) {
   });
 }
 
-async function audioGenHandler(params) {
+async function audioGenHandler(params, processBroker) {
   const { text, voice, type, output } = params;
 
   if (!text) {
@@ -717,9 +732,9 @@ async function audioGenHandler(params) {
   const openaiKey = process.env.OPENAI_API_KEY;
 
   // 1. edge-tts (free, no API key needed)
-  if (commandExists("edge-tts") || await checkPythonModule("edge_tts")) {
+  if (commandExists(processBroker, "edge-tts") || await checkPythonModule(processBroker, "edge_tts")) {
     try {
-      await runEdgeTTS(text, voice, outputPath);
+      await runEdgeTTS(processBroker, text, voice, outputPath);
       return {
         success: true,
         backend: "edge-tts",
@@ -732,11 +747,11 @@ async function audioGenHandler(params) {
   }
 
   // 2. piper-tts (offline, free)
-  if (commandExists("piper")) {
+  if (commandExists(processBroker, "piper")) {
     try {
       // Pass the text via stdin with NO shell — an echo-pipe only escaped
       // double-quotes, so backticks / \$(...) in \`text\` would still execute.
-      const r = spawnSync("piper", ["--output_file", outputPath], {
+      const r = processBroker.runSync("piper", ["--output_file", outputPath], {
         input: text,
         encoding: "utf-8",
       });
@@ -796,21 +811,26 @@ async function audioGenHandler(params) {
   };
 };
 
-async function checkPythonModule(moduleName) {
+async function checkPythonModule(processBroker, moduleName) {
   try {
-    execSync(\`python -c "import \${moduleName}"\`, { stdio: "ignore", encoding: "utf-8" });
+    processBroker.runFileSync("python", ["-c", \`import \${moduleName}\`], {
+      stdio: "ignore",
+      encoding: "utf-8",
+      timeout: 10000,
+    });
     return true;
   } catch {
     return false;
   }
 }
 
-audioGenHandler.execute = async (task, _ctx, _skill) => {
+audioGenHandler.execute = async (task, context, _skill) => {
+  const processBroker = requireProcessBroker(context);
   const input = typeof task === "string" ? task : (task.input || task.params?.input || "");
   let p = {};
   try { p = input.trim().startsWith("{") ? JSON.parse(input) : { text: input }; }
   catch { p = { text: input }; }
-  return audioGenHandler(p);
+  return audioGenHandler(p, processBroker);
 };
 module.exports = audioGenHandler;
 `,
@@ -899,6 +919,7 @@ parameters:
     required: false
     description: 输出文件名（不含扩展名，默认为主题名）
 execution-mode: direct
+capabilities: [shell-exec]
 ---
 
 # AI 文档生成
@@ -969,27 +990,39 @@ chainlesschain skill run cli-anything-soffice "convert report.md to pdf"
  *   - pdf:     LibreOffice soffice --headless
  */
 
-const { spawnSync, execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 
 // ─── Tool detection ───────────────────────────────────────────────
 
-function commandExists(cmd) {
+function requireProcessBroker(context) {
+  const broker = context && context.processBroker;
+  if (!broker || typeof broker.runSync !== "function" ||
+      typeof broker.runFileSync !== "function") {
+    throw new Error("Process Broker unavailable for doc-generate skill");
+  }
+  return broker;
+}
+
+function commandExists(processBroker, cmd) {
   try {
-    execSync(\`\${cmd} --version\`, { stdio: "ignore", encoding: "utf-8" });
+    processBroker.runFileSync(cmd, ["--version"], {
+      stdio: "ignore",
+      encoding: "utf-8",
+      timeout: 5000,
+    });
     return true;
   } catch {
     return false;
   }
 }
 
-function detectSoffice() {
-  if (commandExists("soffice")) return "soffice";
-  if (commandExists("libreoffice")) return "libreoffice";
+function detectSoffice(processBroker) {
+  if (commandExists(processBroker, "soffice")) return "soffice";
+  if (commandExists(processBroker, "libreoffice")) return "libreoffice";
   // Windows default install path
   const winPath = "C:\\\\Program Files\\\\LibreOffice\\\\program\\\\soffice.exe";
-  if (process.platform === "win32" && fs.existsSync(winPath)) return \`"\${winPath}"\`;
+  if (process.platform === "win32" && fs.existsSync(winPath)) return winPath;
   return null;
 }
 
@@ -1042,11 +1075,11 @@ function mdToHtml(md, title) {
 
 // ─── Conversion helpers ───────────────────────────────────────────
 
-function convertWithPandoc(mdFile, outputFile, format) {
-  const result = spawnSync(
+function convertWithPandoc(processBroker, mdFile, outputFile, format) {
+  const result = processBroker.runSync(
     "pandoc",
     [mdFile, "-o", outputFile, "--standalone"],
-    { encoding: "utf-8", timeout: 60000 },
+    { encoding: "utf-8", timeout: 60000, shell: false },
   );
   if (result.status !== 0) {
     throw new Error(\`pandoc failed: \${result.stderr || result.error?.message}\`);
@@ -1054,11 +1087,11 @@ function convertWithPandoc(mdFile, outputFile, format) {
   return outputFile;
 }
 
-function convertWithSoffice(sofficeCmd, inputFile, format, outDir) {
-  const result = spawnSync(
+function convertWithSoffice(processBroker, sofficeCmd, inputFile, format, outDir) {
+  const result = processBroker.runSync(
     sofficeCmd,
     ["--headless", "--convert-to", format, inputFile, "--outdir", outDir],
-    { encoding: "utf-8", timeout: 120000, shell: process.platform === "win32" },
+    { encoding: "utf-8", timeout: 120000, shell: false },
   );
   if (result.status !== 0) {
     throw new Error(\`soffice failed: \${result.stderr || result.error?.message}\`);
@@ -1070,7 +1103,7 @@ function convertWithSoffice(sofficeCmd, inputFile, format, outDir) {
 
 // ─── LLM content generation ───────────────────────────────────────
 
-function generateContent(topic, style, outline) {
+function generateContent(processBroker, topic, style, outline) {
   const styleDesc = STYLE_PROMPTS[style] || STYLE_PROMPTS.report;
   const outlineSection = outline
     ? \`\\n\\n大纲要求（请按以下结构组织内容）：\\n\${outline}\`
@@ -1080,7 +1113,7 @@ function generateContent(topic, style, outline) {
     \`请为以下主题生成\${styleDesc}。\\n\\n主题：\${topic}\${outlineSection}\\n\\n要求：\\n- 使用标准 Markdown 格式（H1/H2/H3 标题、列表、表格等）\\n- 内容详实具体，不少于 800 字\\n- 使用中文撰写\\n- 直接输出 Markdown 内容，不需要额外说明\`;
 
   // Try chainlesschain ask first
-  const askResult = spawnSync(
+  const askResult = processBroker.runSync(
     process.execPath,
     [process.argv[1], "ask", prompt],
     {
@@ -1088,6 +1121,7 @@ function generateContent(topic, style, outline) {
       timeout: 120000,
       cwd: process.cwd(),
       env: process.env,
+      shell: false,
     },
   );
 
@@ -1130,7 +1164,7 @@ function generateContent(topic, style, outline) {
 
 // ─── Main handler ─────────────────────────────────────────────────
 
-async function docGenerateHandler(params) {
+async function docGenerateHandler(params, processBroker) {
   const { topic, format, outline, style, output } = params;
 
   if (!topic) {
@@ -1144,7 +1178,7 @@ async function docGenerateHandler(params) {
 
   // Generate content via LLM
   console.log(\`[doc-generate] Generating \${docStyle} document for: \${topic}\`);
-  const mdContent = generateContent(topic, docStyle, outline);
+  const mdContent = generateContent(processBroker, topic, docStyle, outline);
 
   // Always write markdown first
   const mdFile = path.join(outputDir, \`\${safeTitle}.md\`);
@@ -1174,13 +1208,13 @@ async function docGenerateHandler(params) {
   }
 
   // DOCX / PDF: try pandoc then soffice
-  const sofficeCmd = detectSoffice();
+  const sofficeCmd = detectSoffice(processBroker);
 
   if (fmt === "docx") {
-    if (commandExists("pandoc")) {
+    if (commandExists(processBroker, "pandoc")) {
       try {
         const docxFile = path.join(outputDir, \`\${safeTitle}.docx\`);
-        convertWithPandoc(mdFile, docxFile, "docx");
+        convertWithPandoc(processBroker, mdFile, docxFile, "docx");
         return { success: true, format: "docx", output: docxFile, mdOutput: mdFile, message: \`DOCX saved to: \${docxFile} (via pandoc)\` };
       } catch (err) {
         console.warn("[doc-generate] pandoc failed:", err.message);
@@ -1191,7 +1225,7 @@ async function docGenerateHandler(params) {
         // soffice needs HTML or ODT as input for md→docx (md not natively supported)
         const htmlFile = path.join(outputDir, \`\${safeTitle}.html\`);
         fs.writeFileSync(htmlFile, mdToHtml(mdContent, topic), "utf-8");
-        const docxFile = convertWithSoffice(sofficeCmd, htmlFile, "docx", outputDir);
+        const docxFile = convertWithSoffice(processBroker, sofficeCmd, htmlFile, "docx", outputDir);
         // Clean up temp HTML
         try { fs.unlinkSync(htmlFile); } catch { /* ignore */ }
         return { success: true, format: "docx", output: docxFile, mdOutput: mdFile, message: \`DOCX saved to: \${docxFile} (via LibreOffice)\` };
@@ -1213,17 +1247,17 @@ async function docGenerateHandler(params) {
       try {
         const htmlFile = path.join(outputDir, \`\${safeTitle}.html\`);
         fs.writeFileSync(htmlFile, mdToHtml(mdContent, topic), "utf-8");
-        const pdfFile = convertWithSoffice(sofficeCmd, htmlFile, "pdf", outputDir);
+        const pdfFile = convertWithSoffice(processBroker, sofficeCmd, htmlFile, "pdf", outputDir);
         try { fs.unlinkSync(htmlFile); } catch { /* ignore */ }
         return { success: true, format: "pdf", output: pdfFile, mdOutput: mdFile, message: \`PDF saved to: \${pdfFile} (via LibreOffice)\` };
       } catch (err) {
         console.warn("[doc-generate] soffice pdf failed:", err.message);
       }
     }
-    if (commandExists("pandoc") && commandExists("wkhtmltopdf")) {
+    if (commandExists(processBroker, "pandoc") && commandExists(processBroker, "wkhtmltopdf")) {
       try {
         const pdfFile = path.join(outputDir, \`\${safeTitle}.pdf\`);
-        convertWithPandoc(mdFile, pdfFile, "pdf");
+        convertWithPandoc(processBroker, mdFile, pdfFile, "pdf");
         return { success: true, format: "pdf", output: pdfFile, mdOutput: mdFile, message: \`PDF saved to: \${pdfFile} (via pandoc+wkhtmltopdf)\` };
       } catch (err) {
         console.warn("[doc-generate] pandoc pdf failed:", err.message);
@@ -1241,12 +1275,13 @@ async function docGenerateHandler(params) {
   return { error: \`Unsupported format: \${fmt}\`, hint: "Supported formats: md, html, docx, pdf" };
 }
 
-docGenerateHandler.execute = async (task, _ctx, _skill) => {
+docGenerateHandler.execute = async (task, context, _skill) => {
+  const processBroker = requireProcessBroker(context);
   const input = typeof task === "string" ? task : (task.input || task.params?.input || "");
   let p = {};
   try { p = input.trim().startsWith("{") ? JSON.parse(input) : { topic: input }; }
   catch { p = { topic: input }; }
-  return docGenerateHandler(p);
+  return docGenerateHandler(p, processBroker);
 };
 module.exports = docGenerateHandler;
 `,
@@ -1275,6 +1310,7 @@ parameters:
     required: false
     description: 输出目录（默认与源文件相同目录）
 execution-mode: direct
+capabilities: [shell-exec]
 ---
 
 # LibreOffice 文档格式转换
@@ -1352,17 +1388,29 @@ soffice --version
  *     chainlesschain cli-anything register soffice
  */
 
-const { spawnSync, execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 
 const SUPPORTED_FORMATS = new Set(["pdf", "docx", "html", "odt", "pptx", "xlsx", "csv", "txt", "png"]);
 
-function findSoffice() {
+function requireProcessBroker(context) {
+  const broker = context && context.processBroker;
+  if (!broker || typeof broker.runSync !== "function" ||
+      typeof broker.runFileSync !== "function") {
+    throw new Error("Process Broker unavailable for libre-convert skill");
+  }
+  return broker;
+}
+
+function findSoffice(processBroker) {
   const candidates = ["soffice", "libreoffice"];
   for (const cmd of candidates) {
     try {
-      execSync(\`\${cmd} --version\`, { stdio: "ignore", encoding: "utf-8" });
+      processBroker.runFileSync(cmd, ["--version"], {
+        stdio: "ignore",
+        encoding: "utf-8",
+        timeout: 5000,
+      });
       return cmd;
     } catch { /* try next */ }
   }
@@ -1373,13 +1421,13 @@ function findSoffice() {
       "C:\\\\Program Files (x86)\\\\LibreOffice\\\\program\\\\soffice.exe",
     ];
     for (const p of paths) {
-      if (fs.existsSync(p)) return \`"\${p}"\`;
+      if (fs.existsSync(p)) return p;
     }
   }
   return null;
 }
 
-async function libreConvertHandler(params) {
+async function libreConvertHandler(params, processBroker) {
   const { input_file, format, outdir } = params;
 
   if (!input_file) {
@@ -1404,7 +1452,7 @@ async function libreConvertHandler(params) {
   }
 
   // Find LibreOffice
-  const sofficeCmd = findSoffice();
+  const sofficeCmd = findSoffice(processBroker);
   if (!sofficeCmd) {
     return {
       error: "LibreOffice not found",
@@ -1432,13 +1480,13 @@ async function libreConvertHandler(params) {
   console.log(\`[libre-convert] Converting \${path.basename(inputPath)} → \${targetFormat}\`);
 
   // Run soffice
-  const result = spawnSync(
+  const result = processBroker.runSync(
     sofficeCmd,
     ["--headless", "--convert-to", targetFormat, inputPath, "--outdir", outputDir],
     {
       encoding: "utf-8",
       timeout: 120000,
-      shell: process.platform === "win32",
+      shell: false,
     },
   );
 
@@ -1486,12 +1534,13 @@ async function libreConvertHandler(params) {
   };
 }
 
-libreConvertHandler.execute = async (task, _ctx, _skill) => {
+libreConvertHandler.execute = async (task, context, _skill) => {
+  const processBroker = requireProcessBroker(context);
   const input = typeof task === "string" ? task : (task.input || task.params?.input || "");
   let p = {};
   try { p = input.trim().startsWith("{") ? JSON.parse(input) : { input_file: input }; }
   catch { p = { input_file: input }; }
-  return libreConvertHandler(p);
+  return libreConvertHandler(p, processBroker);
 };
 module.exports = libreConvertHandler;
 `,
@@ -1530,6 +1579,7 @@ input_schema:
       description: 输出目录（默认与输入文件同目录）
   required: [input_file, instruction]
 execution-mode: direct
+capabilities: [shell-exec]
 ---
 
 # AI 文档修改 (doc-edit)
@@ -1601,23 +1651,38 @@ chainlesschain cli-anything register soffice
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
-const { execSync, spawnSync } = require("child_process");
+
+function requireProcessBroker(context) {
+  const broker = context && context.processBroker;
+  if (!broker || typeof broker.runSync !== "function" ||
+      typeof broker.runFileSync !== "function") {
+    throw new Error("Process Broker unavailable for doc-edit skill");
+  }
+  return broker;
+}
 
 // ── Python detection (mirrors cli-anything-bridge pattern) ───────────────────
-function detectPython() {
+function detectPython(processBroker) {
   const candidates = ["python", "python3", "py"];
   for (const cmd of candidates) {
     try {
-      const r = spawnSync(cmd, ["--version"], { encoding: "utf-8", timeout: 5000 });
+      const r = processBroker.runSync(cmd, ["--version"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        shell: false,
+      });
       if (r.status === 0) return { found: true, command: cmd };
     } catch (_e) { /* try next */ }
   }
   return { found: false, command: null };
 }
 
-function checkPythonModule(pyCmd, moduleName) {
+function checkPythonModule(processBroker, pyCmd, moduleName) {
   try {
-    execSync(\`\${pyCmd} -c "import \${moduleName}"\`, { stdio: "ignore", timeout: 10000 });
+    processBroker.runFileSync(pyCmd, ["-c", \`import \${moduleName}\`], {
+      stdio: "ignore",
+      timeout: 10000,
+    });
     return true;
   } catch {
     return false;
@@ -1625,11 +1690,11 @@ function checkPythonModule(pyCmd, moduleName) {
 }
 
 // ── LLM call via CLI sub-process ─────────────────────────────────────────────
-function callLLM(prompt) {
-  const r = spawnSync(
+function callLLM(processBroker, prompt) {
+  const r = processBroker.runSync(
     process.execPath,
     [process.argv[1], "ask", prompt],
-    { encoding: "utf-8", timeout: 120000, cwd: process.cwd(), env: process.env },
+    { encoding: "utf-8", timeout: 120000, cwd: process.cwd(), env: process.env, shell: false },
   );
   if (r.status === 0 && r.stdout && r.stdout.trim().length > 10) return r.stdout.trim();
   return null;
@@ -1706,10 +1771,10 @@ function buildTextPrompt(content, instruction, action, section) {
 }
 
 // ── md / txt / html handler ───────────────────────────────────────────────────
-function editText(inputFile, instruction, action, section, outputDir) {
+function editText(processBroker, inputFile, instruction, action, section, outputDir) {
   const content = fs.readFileSync(inputFile, "utf-8");
   const prompt = buildTextPrompt(content, instruction, action, section);
-  const llmResult = callLLM(prompt);
+  const llmResult = callLLM(processBroker, prompt);
 
   let newContent;
   if (llmResult) {
@@ -1745,22 +1810,34 @@ function editText(inputFile, instruction, action, section, outputDir) {
 }
 
 // ── docx handler ──────────────────────────────────────────────────────────────
-function editDocx(inputFile, instruction, action, section, outputDir) {
+function editDocx(processBroker, inputFile, instruction, action, section, outputDir) {
   // Try pandoc: docx → markdown → LLM → markdown → docx
   try {
-    const r = spawnSync("pandoc", ["--version"], { encoding: "utf-8", timeout: 5000 });
+    const r = processBroker.runSync("pandoc", ["--version"], {
+      encoding: "utf-8",
+      timeout: 5000,
+      shell: false,
+    });
     if (r.status === 0) {
       const tmpMd = path.join(os.tmpdir(), \`doc_edit_\${Date.now()}.md\`);
-      spawnSync("pandoc", [inputFile, "-o", tmpMd], { encoding: "utf-8", timeout: 60000 });
+      processBroker.runSync("pandoc", [inputFile, "-o", tmpMd], {
+        encoding: "utf-8",
+        timeout: 60000,
+        shell: false,
+      });
       if (fs.existsSync(tmpMd)) {
         const content = fs.readFileSync(tmpMd, "utf-8");
         const prompt = buildTextPrompt(content, instruction, action, section);
-        const llmResult = callLLM(prompt);
+        const llmResult = callLLM(processBroker, prompt);
         if (llmResult) {
           let newContent = action === "append" ? content + "\\n\\n" + llmResult : llmResult;
           fs.writeFileSync(tmpMd, newContent, "utf-8");
           const outputFile = buildOutputPath(inputFile, outputDir);
-          spawnSync("pandoc", [tmpMd, "-o", outputFile], { encoding: "utf-8", timeout: 60000 });
+          processBroker.runSync("pandoc", [tmpMd, "-o", outputFile], {
+            encoding: "utf-8",
+            timeout: 60000,
+            shell: false,
+          });
           try { fs.unlinkSync(tmpMd); } catch (_e) { /* ignore */ }
           if (fs.existsSync(outputFile)) {
             return { success: true, input: inputFile, output: outputFile, action, message: \`DOCX edited via pandoc: \${outputFile}\` };
@@ -1784,23 +1861,27 @@ function editDocx(inputFile, instruction, action, section, outputDir) {
   }
   for (const soffice of sofficeCandidates) {
     try {
-      const rv = spawnSync(soffice, ["--version"], { encoding: "utf-8", timeout: 5000, shell: process.platform === "win32" });
+      const rv = processBroker.runSync(soffice, ["--version"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        shell: false,
+      });
       if (rv.status === 0) {
         const tmpDir2 = os.tmpdir();
-        spawnSync(soffice, ["--headless", "--convert-to", "html", inputFile, "--outdir", tmpDir2], {
-          encoding: "utf-8", timeout: 60000, shell: process.platform === "win32",
+        processBroker.runSync(soffice, ["--headless", "--convert-to", "html", inputFile, "--outdir", tmpDir2], {
+          encoding: "utf-8", timeout: 60000, shell: false,
         });
         const baseName = path.basename(inputFile, ".docx");
         const htmlFile = path.join(tmpDir2, \`\${baseName}.html\`);
         if (fs.existsSync(htmlFile)) {
           const content = fs.readFileSync(htmlFile, "utf-8");
           const prompt = buildTextPrompt(content, instruction, action, section);
-          const llmResult = callLLM(prompt);
+          const llmResult = callLLM(processBroker, prompt);
           if (llmResult) {
             fs.writeFileSync(htmlFile, llmResult, "utf-8");
             const outputFile = buildOutputPath(inputFile, outputDir);
-            spawnSync(soffice, ["--headless", "--convert-to", "docx", htmlFile, "--outdir", path.dirname(outputFile)], {
-              encoding: "utf-8", timeout: 60000, shell: process.platform === "win32",
+            processBroker.runSync(soffice, ["--headless", "--convert-to", "docx", htmlFile, "--outdir", path.dirname(outputFile)], {
+              encoding: "utf-8", timeout: 60000, shell: false,
             });
             try { fs.unlinkSync(htmlFile); } catch (_e) { /* ignore */ }
             if (fs.existsSync(outputFile)) {
@@ -1822,12 +1903,12 @@ function editDocx(inputFile, instruction, action, section, outputDir) {
 }
 
 // ── xlsx handler (Python + openpyxl) ─────────────────────────────────────────
-function editXlsx(inputFile, instruction, action, outputDir) {
-  const py = detectPython();
+function editXlsx(processBroker, inputFile, instruction, action, outputDir) {
+  const py = detectPython(processBroker);
   if (!py.found) {
     return { success: false, error: "未找到 Python，请安装 Python 3.x", hint: "https://python.org" };
   }
-  if (!checkPythonModule(py.command, "openpyxl")) {
+  if (!checkPythonModule(processBroker, py.command, "openpyxl")) {
     return {
       success: false,
       error: "需要安装 openpyxl 才能修改 XLSX 文件",
@@ -1842,19 +1923,24 @@ function editXlsx(inputFile, instruction, action, outputDir) {
   try {
     // Step 1: extract text cells (non-formula string cells)
     const extractScript = \`
-import json, openpyxl
-wb = openpyxl.load_workbook(r"""\${inputFile}""", data_only=False)
+import json, openpyxl, sys
+input_file, output_json = sys.argv[1], sys.argv[2]
+wb = openpyxl.load_workbook(input_file, data_only=False)
 cells = []
 for ws in wb.worksheets:
     for row in ws.iter_rows():
         for cell in row:
             if cell.data_type == 's' and cell.value is not None:
                 cells.append({"sheet": ws.title, "row": cell.row, "col": cell.column, "value": cell.value})
-with open(r"""\${tmpJson}""", "w", encoding="utf-8") as f:
+with open(output_json, "w", encoding="utf-8") as f:
     json.dump(cells, f, ensure_ascii=False)
 \`;
     fs.writeFileSync(tmpExtract, extractScript, "utf-8");
-    const er = spawnSync(py.command, [tmpExtract], { encoding: "utf-8", timeout: 30000 });
+    const er = processBroker.runSync(py.command, [tmpExtract, inputFile, tmpJson], {
+      encoding: "utf-8",
+      timeout: 30000,
+      shell: false,
+    });
     if (er.status !== 0) throw new Error(er.stderr || "extract failed");
 
     const cells = JSON.parse(fs.readFileSync(tmpJson, "utf-8"));
@@ -1873,7 +1959,7 @@ with open(r"""\${tmpJson}""", "w", encoding="utf-8") as f:
 \${textList}
 
 直接返回 JSON 数组，不要其他说明。\`;
-    const llmResult = callLLM(prompt);
+    const llmResult = callLLM(processBroker, prompt);
     if (!llmResult) {
       return { success: false, error: "LLM 调用失败", hint: "运行 chainlesschain llm test 检查连接" };
     }
@@ -1890,21 +1976,26 @@ with open(r"""\${tmpJson}""", "w", encoding="utf-8") as f:
     // Step 3: apply changes
     const outputFile = buildOutputPath(inputFile, outputDir);
     const applyScript = \`
-import json, openpyxl, shutil
-shutil.copy2(r"""\${inputFile}""", r"""\${outputFile}""")
-wb = openpyxl.load_workbook(r"""\${outputFile}""", data_only=False)
-updated = json.loads('''
-\${JSON.stringify(updatedCells).replace(/'/g, "\\\\'")}
-''')
+import json, openpyxl, shutil, sys
+input_file, output_file, updated_json = sys.argv[1], sys.argv[2], sys.argv[3]
+shutil.copy2(input_file, output_file)
+wb = openpyxl.load_workbook(output_file, data_only=False)
+with open(updated_json, "r", encoding="utf-8") as f:
+    updated = json.load(f)
 for item in updated:
     ws = wb[item["sheet"]]
     cell = ws.cell(row=item["row"], column=item["col"])
     if cell.data_type == 's':
         cell.value = item["value"]
-wb.save(r"""\${outputFile}""")
+wb.save(output_file)
 \`;
     fs.writeFileSync(tmpApply, applyScript, "utf-8");
-    const ar = spawnSync(py.command, [tmpApply], { encoding: "utf-8", timeout: 30000 });
+    fs.writeFileSync(tmpJson, JSON.stringify(updatedCells), "utf-8");
+    const ar = processBroker.runSync(py.command, [tmpApply, inputFile, outputFile, tmpJson], {
+      encoding: "utf-8",
+      timeout: 30000,
+      shell: false,
+    });
     if (ar.status !== 0) throw new Error(ar.stderr || "apply failed");
 
     return {
@@ -1925,12 +2016,12 @@ wb.save(r"""\${outputFile}""")
 }
 
 // ── pptx handler (Python + python-pptx) ──────────────────────────────────────
-function editPptx(inputFile, instruction, action, outputDir) {
-  const py = detectPython();
+function editPptx(processBroker, inputFile, instruction, action, outputDir) {
+  const py = detectPython(processBroker);
   if (!py.found) {
     return { success: false, error: "未找到 Python，请安装 Python 3.x", hint: "https://python.org" };
   }
-  if (!checkPythonModule(py.command, "pptx")) {
+  if (!checkPythonModule(processBroker, py.command, "pptx")) {
     return {
       success: false,
       error: "需要安装 python-pptx 才能修改 PPTX 文件",
@@ -1945,9 +2036,10 @@ function editPptx(inputFile, instruction, action, outputDir) {
   try {
     // Step 1: extract text runs (skip chart shapes)
     const extractScript = \`
-import json
+import json, sys
 from pptx import Presentation
-prs = Presentation(r"""\${inputFile}""")
+input_file, output_json = sys.argv[1], sys.argv[2]
+prs = Presentation(input_file)
 runs = []
 for si, slide in enumerate(prs.slides):
     for shi, shape in enumerate(slide.shapes):
@@ -1957,11 +2049,15 @@ for si, slide in enumerate(prs.slides):
             for ri, run in enumerate(para.runs):
                 if run.text.strip():
                     runs.append({"slide": si, "shape": shi, "para": pi, "run": ri, "text": run.text})
-with open(r"""\${tmpJson}""", "w", encoding="utf-8") as f:
+with open(output_json, "w", encoding="utf-8") as f:
     json.dump(runs, f, ensure_ascii=False)
 \`;
     fs.writeFileSync(tmpExtract, extractScript, "utf-8");
-    const er = spawnSync(py.command, [tmpExtract], { encoding: "utf-8", timeout: 30000 });
+    const er = processBroker.runSync(py.command, [tmpExtract, inputFile, tmpJson], {
+      encoding: "utf-8",
+      timeout: 30000,
+      shell: false,
+    });
     if (er.status !== 0) throw new Error(er.stderr || "extract failed");
 
     const runs = JSON.parse(fs.readFileSync(tmpJson, "utf-8"));
@@ -1980,7 +2076,7 @@ with open(r"""\${tmpJson}""", "w", encoding="utf-8") as f:
 \${textList}
 
 直接返回 JSON 数组，不要其他说明。\`;
-    const llmResult = callLLM(prompt);
+    const llmResult = callLLM(processBroker, prompt);
     if (!llmResult) {
       return { success: false, error: "LLM 调用失败", hint: "运行 chainlesschain llm test 检查连接" };
     }
@@ -1996,23 +2092,28 @@ with open(r"""\${tmpJson}""", "w", encoding="utf-8") as f:
     // Step 3: apply changes (only .text, preserve all font/style)
     const outputFile = buildOutputPath(inputFile, outputDir);
     const applyScript = \`
-import json, shutil
+import json, shutil, sys
 from pptx import Presentation
-shutil.copy2(r"""\${inputFile}""", r"""\${outputFile}""")
-prs = Presentation(r"""\${outputFile}""")
-updated = json.loads('''
-\${JSON.stringify(updatedRuns).replace(/'/g, "\\\\'")}
-''')
+input_file, output_file, updated_json = sys.argv[1], sys.argv[2], sys.argv[3]
+shutil.copy2(input_file, output_file)
+prs = Presentation(output_file)
+with open(updated_json, "r", encoding="utf-8") as f:
+    updated = json.load(f)
 for item in updated:
     slide = prs.slides[item["slide"]]
     shape = slide.shapes[item["shape"]]
     if shape.has_text_frame:
         run = shape.text_frame.paragraphs[item["para"]].runs[item["run"]]
         run.text = item["text"]
-prs.save(r"""\${outputFile}""")
+prs.save(output_file)
 \`;
     fs.writeFileSync(tmpApply, applyScript, "utf-8");
-    const ar = spawnSync(py.command, [tmpApply], { encoding: "utf-8", timeout: 30000 });
+    fs.writeFileSync(tmpJson, JSON.stringify(updatedRuns), "utf-8");
+    const ar = processBroker.runSync(py.command, [tmpApply, inputFile, outputFile, tmpJson], {
+      encoding: "utf-8",
+      timeout: 30000,
+      shell: false,
+    });
     if (ar.status !== 0) throw new Error(ar.stderr || "apply failed");
 
     return {
@@ -2033,7 +2134,7 @@ prs.save(r"""\${outputFile}""")
 }
 
 // ── Main export ───────────────────────────────────────────────────────────────
-async function docEdit(params) {
+async function docEdit(params, processBroker) {
   const { input_file, instruction, action = "edit", section, output_dir } = params || {};
 
   if (!input_file) {
@@ -2054,16 +2155,16 @@ async function docEdit(params) {
   const ext = path.extname(input_file).toLowerCase();
 
   if ([".md", ".txt", ".html", ".htm"].includes(ext)) {
-    return editText(input_file, instruction, action, section, output_dir);
+    return editText(processBroker, input_file, instruction, action, section, output_dir);
   }
   if (ext === ".docx") {
-    return editDocx(input_file, instruction, action, section, output_dir);
+    return editDocx(processBroker, input_file, instruction, action, section, output_dir);
   }
   if (ext === ".xlsx") {
-    return editXlsx(input_file, instruction, action, output_dir);
+    return editXlsx(processBroker, input_file, instruction, action, output_dir);
   }
   if (ext === ".pptx") {
-    return editPptx(input_file, instruction, action, output_dir);
+    return editPptx(processBroker, input_file, instruction, action, output_dir);
   }
 
   return {
@@ -2073,12 +2174,13 @@ async function docEdit(params) {
   };
 }
 
-docEdit.execute = async (task, _ctx, _skill) => {
+docEdit.execute = async (task, context, _skill) => {
+  const processBroker = requireProcessBroker(context);
   const input = typeof task === "string" ? task : (task.input || task.params?.input || "");
   let p = {};
   try { p = input.trim().startsWith("{") ? JSON.parse(input) : { input_file: input }; }
   catch { p = { input_file: input }; }
-  return docEdit(p);
+  return docEdit(p, processBroker);
 };
 module.exports = docEdit;
 `,