@cydm/pie 1.0.5 → 1.0.6

package/dist/chunks/capabilities-FENCOHVA.js

@@ -0,0 +1,9 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  createCliHostCapabilities
+} from "./chunk-JYBXCEJJ.js";
+import "./chunk-RID3574D.js";
+import "./chunk-TG2EQLX2.js";
+export {
+  createCliHostCapabilities
+};

package/dist/chunks/chunk-JYBXCEJJ.js

@@ -0,0 +1,315 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  Type
+} from "./chunk-RID3574D.js";
+
+// src/capabilities/bash/index.ts
+import { spawn } from "child_process";
+import { createWriteStream } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomBytes } from "crypto";
+
+// src/capabilities/bash/truncate.ts
+var DEFAULT_MAX_LINES = 2e3;
+var DEFAULT_MAX_BYTES = 50 * 1024;
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes}B`;
+  } else if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  } else {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+}
+function truncateTail(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  let lastLinePartial = false;
+  for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      if (outputLinesArr.length === 0) {
+        const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+        outputLinesArr.unshift(truncatedLine);
+        outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+        lastLinePartial = true;
+      }
+      break;
+    }
+    outputLinesArr.unshift(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join("\n");
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateStringToBytesFromEnd(str, maxBytes) {
+  const buf = Buffer.from(str, "utf-8");
+  if (buf.length <= maxBytes) {
+    return str;
+  }
+  let start = buf.length - maxBytes;
+  while (start < buf.length && (buf[start] & 192) === 128) {
+    start++;
+  }
+  return buf.slice(start).toString("utf-8");
+}
+
+// src/capabilities/bash/index.ts
+var bashSchema = Type.Object({
+  command: Type.String({ description: "The bash command to execute" }),
+  timeout: Type.Optional(
+    Type.Number({
+      description: "Timeout in seconds. Default: 120s (2 minutes). For longer tasks, explicitly set a higher value: { timeout: 600 } for npm install, { timeout: 600 } for cargo build, etc."
+    })
+  ),
+  cwd: Type.Optional(Type.String({ description: "Working directory for the command" }))
+});
+var DEFAULT_TIMEOUT_SECONDS = 120;
+function getTempFilePath() {
+  const id = randomBytes(8).toString("hex");
+  return join(tmpdir(), `pie-bash-${id}.log`);
+}
+function killProcessTree(pid) {
+  if (process.platform === "win32") {
+    try {
+      spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+        stdio: "ignore",
+        detached: true
+      });
+    } catch {
+    }
+  } else {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+function createBashTool(defaultCwd) {
+  return {
+    name: "bash",
+    label: "bash",
+    description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Default timeout: 120s. Use timeout parameter for longer tasks (e.g., npm install -> 600).`,
+    parameters: bashSchema,
+    execute: async (_toolCallId, { command, timeout, cwd }, signal, onUpdate) => {
+      const workingDir = cwd ?? defaultCwd ?? process.cwd();
+      const timeoutMs = (timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1e3;
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let tempFilePath;
+        let tempFileStream;
+        let totalBytes = 0;
+        const chunks = [];
+        let chunksBytes = 0;
+        const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
+        let timedOut = false;
+        const child = spawn(command, [], {
+          shell: true,
+          cwd: workingDir,
+          env: process.env,
+          detached: true
+          // Allows killing entire process tree
+        });
+        const timeoutId = setTimeout(() => {
+          timedOut = true;
+          if (child.pid) {
+            killProcessTree(child.pid);
+          }
+        }, timeoutMs);
+        const onAbort = () => {
+          clearTimeout(timeoutId);
+          if (child.pid) {
+            killProcessTree(child.pid);
+          }
+          reject(new Error("Operation aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child.stdout?.on("data", (data) => {
+          totalBytes += data.length;
+          if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+            tempFilePath = getTempFilePath();
+            tempFileStream = createWriteStream(tempFilePath);
+            for (const chunk of chunks) {
+              tempFileStream.write(chunk);
+            }
+          }
+          if (tempFileStream) {
+            tempFileStream.write(data);
+          }
+          chunks.push(data);
+          chunksBytes += data.length;
+          while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+            const removed = chunks.shift();
+            chunksBytes -= removed.length;
+          }
+          if (onUpdate) {
+            const fullBuffer = Buffer.concat(chunks);
+            const fullText = fullBuffer.toString("utf-8");
+            const truncation = truncateTail(fullText);
+            onUpdate({
+              content: [{ type: "text", text: truncation.content || "" }],
+              details: {
+                exitCode: null,
+                signal: null,
+                timedOut: false,
+                truncation: truncation.truncated ? {
+                  truncated: true,
+                  truncatedBy: truncation.truncatedBy,
+                  totalLines: truncation.totalLines,
+                  outputLines: truncation.outputLines
+                } : void 0,
+                fullOutputPath: tempFilePath
+              }
+            });
+          }
+        });
+        child.stderr?.on("data", (data) => {
+          totalBytes += data.length;
+          if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+            tempFilePath = getTempFilePath();
+            tempFileStream = createWriteStream(tempFilePath);
+            for (const chunk of chunks) {
+              tempFileStream.write(chunk);
+            }
+          }
+          if (tempFileStream) {
+            tempFileStream.write(data);
+          }
+          chunks.push(data);
+          chunksBytes += data.length;
+          while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+            const removed = chunks.shift();
+            chunksBytes -= removed.length;
+          }
+        });
+        child.on("close", (code, sig) => {
+          clearTimeout(timeoutId);
+          signal?.removeEventListener("abort", onAbort);
+          if (tempFileStream) {
+            tempFileStream.end();
+          }
+          const fullBuffer = Buffer.concat(chunks);
+          let fullOutput = fullBuffer.toString("utf-8");
+          const truncation = truncateTail(fullOutput);
+          let outputText = truncation.content || "(no output)";
+          const details = {
+            exitCode: code,
+            signal: sig?.toString() ?? null,
+            timedOut
+          };
+          if (truncation.truncated) {
+            details.truncation = {
+              truncated: true,
+              truncatedBy: truncation.truncatedBy,
+              totalLines: truncation.totalLines,
+              outputLines: truncation.outputLines
+            };
+            details.fullOutputPath = tempFilePath;
+            const startLine = truncation.totalLines - truncation.outputLines + 1;
+            const endLine = truncation.totalLines;
+            if (truncation.lastLinePartial) {
+              const lastLineSize = formatSize(
+                Buffer.byteLength(fullOutput.split("\n").pop() || "", "utf-8")
+              );
+              outputText += `
+
+[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${tempFilePath}]`;
+            } else if (truncation.truncatedBy === "lines") {
+              outputText += `
+
+[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+            } else {
+              outputText += `
+
+[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+            }
+          }
+          if (timedOut) {
+            outputText += `
+
+[Command timed out after ${timeout ?? DEFAULT_TIMEOUT_SECONDS} seconds]`;
+          }
+          const content = [{ type: "text", text: outputText }];
+          if (code !== 0 && code !== null) {
+            reject(new Error(outputText));
+          } else {
+            resolve({ content, details });
+          }
+        });
+        child.on("error", (err) => {
+          clearTimeout(timeoutId);
+          signal?.removeEventListener("abort", onAbort);
+          if (tempFileStream) {
+            tempFileStream.end();
+          }
+          reject(err);
+        });
+      });
+    }
+  };
+}
+
+// src/capabilities/index.ts
+function createCliHostCapabilities(cwd) {
+  const bashTool = createBashTool(cwd);
+  const capabilities = [
+    {
+      id: "bash",
+      description: "Node/TUI host capability for executing shell commands in the local workspace.",
+      tools: [bashTool]
+    }
+  ];
+  return {
+    capabilities,
+    tools: capabilities.flatMap((capability) => capability.tools)
+  };
+}
+
+export {
+  createCliHostCapabilities
+};