@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/chunk-VNQBHPCT.js

@@ -0,0 +1,398 @@
+// src/host/local.ts
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import process from "process";
+function getShell() {
+  if (process.platform === "win32") {
+    return { shell: "cmd.exe", args: ["/c"] };
+  }
+  const userShell = process.env.SHELL ?? "/bin/bash";
+  return { shell: userShell, args: ["-c"] };
+}
+async function killProcessTree(pid) {
+  try {
+    if (process.platform !== "win32") {
+      process.kill(-pid, "SIGKILL");
+    } else {
+      const { exec: execCb } = await import("child_process");
+      execCb(`taskkill /pid ${pid} /t /f`, () => {
+      });
+    }
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+function localHost(defaultCwd) {
+  const cwd = defaultCwd ?? process.cwd();
+  return {
+    name: "local",
+    // --------------------------------------------------------------------------
+    // File system
+    // --------------------------------------------------------------------------
+    async readFile(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      return fs.readFile(abs, "utf-8");
+    },
+    async readBytes(filePath, offset, length) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      const fh = await fs.open(abs, "r");
+      try {
+        const buf = Buffer.alloc(length);
+        await fh.read(buf, 0, length, offset);
+        return buf;
+      } finally {
+        await fh.close();
+      }
+    },
+    async writeFile(filePath, content) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      await fs.mkdir(path.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, content, "utf-8");
+    },
+    async exists(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      return existsSync(abs);
+    },
+    async stat(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      const s = await fs.stat(abs);
+      return {
+        size: s.size,
+        mtime: s.mtime,
+        isDirectory: s.isDirectory(),
+        isFile: s.isFile()
+      };
+    },
+    async readdir(dirPath) {
+      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+      const entries = await fs.readdir(abs, { withFileTypes: true });
+      return entries.map((e) => ({
+        name: e.name,
+        isDirectory: e.isDirectory(),
+        isFile: e.isFile()
+      }));
+    },
+    async mkdir(dirPath) {
+      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+      await fs.mkdir(abs, { recursive: true });
+    },
+    // --------------------------------------------------------------------------
+    // Process execution
+    // --------------------------------------------------------------------------
+    exec(command, options) {
+      const { shell, args } = getShell();
+      const execCwd = options?.cwd ?? cwd;
+      const env = {
+        ...process.env,
+        ...options?.env,
+        // Disable pagers — tools collect output, not interactive
+        PAGER: "cat",
+        GIT_PAGER: "cat"
+      };
+      return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let settled = false;
+        const child = spawn(shell, [...args, command], {
+          cwd: execCwd,
+          detached: process.platform !== "win32",
+          env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        child.stdout?.on("data", (data) => {
+          stdout += data.toString();
+          options?.onStdout?.(data);
+        });
+        child.stderr?.on("data", (data) => {
+          stderr += data.toString();
+          options?.onStderr?.(data);
+        });
+        let timer;
+        if (options?.timeout && options.timeout > 0) {
+          timer = setTimeout(() => {
+            timedOut = true;
+            if (child.pid) killProcessTree(child.pid);
+          }, options.timeout);
+        }
+        const onAbort = () => {
+          if (child.pid) killProcessTree(child.pid);
+        };
+        options?.signal?.addEventListener("abort", onAbort, { once: true });
+        child.on("close", (code) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          options?.signal?.removeEventListener("abort", onAbort);
+          resolve({ stdout, stderr, exitCode: code, timedOut });
+        });
+        child.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          options?.signal?.removeEventListener("abort", onAbort);
+          reject(err);
+        });
+      });
+    }
+  };
+}
+
+// src/host/docker/exec.ts
+async function loadDockerode() {
+  try {
+    const module = await import("dockerode");
+    return module.default ?? module;
+  } catch {
+    throw new Error(
+      "dockerHost requires the 'dockerode' package. Install it with: npm install dockerode"
+    );
+  }
+}
+async function resolveDockerRuntime(options) {
+  const Dockerode = await loadDockerode();
+  if (typeof options.container === "string") {
+    const docker = new Dockerode(options.dockerOptions);
+    const container2 = docker.getContainer(options.container);
+    return {
+      docker,
+      container: container2,
+      label: options.container
+    };
+  }
+  const container = options.container;
+  return {
+    docker: { modem: container.modem },
+    container,
+    label: container.id?.slice(0, 12) ?? "unknown"
+  };
+}
+async function containerExec(runtime, command, options = {}) {
+  const envEntries = options.env ? Object.entries(options.env).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${value}`) : void 0;
+  const exec = await runtime.container.exec({
+    Cmd: ["sh", "-c", command],
+    ...options.user ? { User: options.user } : {},
+    ...options.workdir ? { WorkingDir: options.workdir } : {},
+    ...envEntries && envEntries.length > 0 ? { Env: envEntries } : {},
+    AttachStdout: true,
+    AttachStderr: true
+  });
+  const stream = await exec.start({});
+  let timedOut = false;
+  let aborted = false;
+  return await new Promise((resolve, reject) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    runtime.docker.modem.demuxStream(
+      stream,
+      {
+        write: (chunk) => {
+          stdoutChunks.push(chunk);
+          options.onStdout?.(chunk);
+          return true;
+        },
+        end: function() {
+          return this;
+        }
+      },
+      {
+        write: (chunk) => {
+          stderrChunks.push(chunk);
+          options.onStderr?.(chunk);
+          return true;
+        },
+        end: function() {
+          return this;
+        }
+      }
+    );
+    let timer;
+    if (options.timeout && options.timeout > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        stream.destroy?.();
+      }, options.timeout);
+    }
+    const onAbort = () => {
+      aborted = true;
+      stream.destroy?.();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    stream.on("end", async () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      options.signal?.removeEventListener("abort", onAbort);
+      try {
+        const info = await exec.inspect();
+        resolve({
+          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+          exitCode: timedOut || aborted ? null : info.ExitCode ?? 0,
+          timedOut
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+    stream.on("error", (error) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      options.signal?.removeEventListener("abort", onAbort);
+      if (timedOut || aborted) {
+        resolve({
+          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+          exitCode: null,
+          timedOut
+        });
+        return;
+      }
+      reject(error);
+    });
+  });
+}
+async function runDockerCommand(options) {
+  const { runtime, command, defaultUser, defaultWorkdir, execOptions } = options;
+  return await containerExec(runtime, command, {
+    user: defaultUser,
+    workdir: execOptions?.workdir ?? execOptions?.cwd ?? defaultWorkdir,
+    env: execOptions?.env,
+    timeout: execOptions?.timeout,
+    signal: execOptions?.signal,
+    onStdout: execOptions?.onStdout,
+    onStderr: execOptions?.onStderr
+  });
+}
+
+// src/host/docker/shell.ts
+function sq(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveDockerPath(path2, defaultWorkdir) {
+  if (path2.startsWith("/")) {
+    return path2;
+  }
+  const base = defaultWorkdir.endsWith("/") ? defaultWorkdir : `${defaultWorkdir}/`;
+  return `${base}${path2}`;
+}
+
+// src/host/docker/host.ts
+async function dockerHost(options) {
+  const runtime = await resolveDockerRuntime(options);
+  const defaultUser = options.user;
+  const defaultWorkdir = options.workdir ?? "/";
+  async function run(command, execOptions) {
+    return await runDockerCommand({
+      runtime,
+      command,
+      defaultUser,
+      defaultWorkdir,
+      execOptions
+    });
+  }
+  return {
+    name: `docker:${runtime.label}`,
+    async readFile(filePath) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(`cat ${sq(absPath)}`);
+      if (result.exitCode !== 0) {
+        throw new Error(`readFile failed (${absPath}): ${result.stderr.trim()}`);
+      }
+      return result.stdout;
+    },
+    async readBytes(filePath, offset, length) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(
+        `dd if=${sq(absPath)} bs=1 skip=${offset} count=${length} 2>/dev/null`
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `readBytes failed (${absPath}): ${result.stderr.trim()}`
+        );
+      }
+      return Buffer.from(result.stdout, "binary");
+    },
+    async writeFile(filePath, content) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const dir = absPath.substring(0, absPath.lastIndexOf("/")) || "/";
+      await run(`mkdir -p ${sq(dir)}`);
+      const encoded = Buffer.from(content, "utf-8").toString("base64");
+      const result = await run(`echo ${sq(encoded)} | base64 -d > ${sq(absPath)}`);
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `writeFile failed (${absPath}): ${result.stderr.trim()}`
+        );
+      }
+    },
+    async exists(filePath) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(`test -e ${sq(absPath)}`);
+      return result.exitCode === 0;
+    },
+    async stat(filePath) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(
+        `stat -c '%s %Y %F' ${sq(absPath)} 2>/dev/null || stat -f '%z %m %HT' ${sq(absPath)}`
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(`stat failed (${absPath}): ${result.stderr.trim()}`);
+      }
+      const parts = result.stdout.trim().split(/\s+/);
+      if (parts.length < 3) {
+        throw new Error(
+          `stat: unexpected output format for ${absPath}: ${result.stdout}`
+        );
+      }
+      const size = parseInt(parts[0], 10);
+      const mtimeSec = parseInt(parts[1], 10);
+      const typeStr = parts.slice(2).join(" ").toLowerCase();
+      return {
+        size,
+        mtime: new Date(mtimeSec * 1e3),
+        isDirectory: typeStr.includes("directory"),
+        isFile: typeStr.includes("regular") || typeStr.includes("file")
+      };
+    },
+    async readdir(dirPath) {
+      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
+      const result = await run(
+        `find ${sq(absPath)} -maxdepth 1 -mindepth 1 -printf '%f\\t%y\\n' 2>/dev/null || for f in ${sq(absPath)}/*; do [ -e "$f" ] || continue; n=$(basename "$f"); if [ -d "$f" ]; then printf '%s\\td\\n' "$n"; else printf '%s\\tf\\n' "$n"; fi; done`
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `readdir failed (${absPath}): ${result.stderr.trim()}`
+        );
+      }
+      return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
+        const [name, type] = line.split("	");
+        return {
+          name,
+          isDirectory: type === "d",
+          isFile: type === "f"
+        };
+      });
+    },
+    async mkdir(dirPath) {
+      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
+      const result = await run(`mkdir -p ${sq(absPath)}`);
+      if (result.exitCode !== 0) {
+        throw new Error(`mkdir failed (${absPath}): ${result.stderr.trim()}`);
+      }
+    },
+    async exec(command, execOptions) {
+      return await run(command, execOptions);
+    }
+  };
+}
+
+export {
+  localHost,
+  dockerHost
+};

package/dist/{chunk-QAQADS4X.js → chunk-WWYYNWEW.js}

@@ -30,7 +30,7 @@ function estimateConversationTokens(messages) {
   return total;
 }
 
-// src/types/agent/compaction.ts
+// src/agent/types/compaction.ts
 var PRUNE_PROTECTED_TOOLS = ["skill"];
 
 // src/context/pruning.ts
@@ -247,6 +247,7 @@ export {
   estimateTokens,
   estimateMessageTokens,
   estimateConversationTokens,
+  PRUNE_PROTECTED_TOOLS,
   DEFAULT_CONTEXT_LIMITS,
   isContextOverflowing,
   shouldPruneContext,