zidane 4.0.2 → 4.1.3

package/dist/chunk-UD25QF3H.js

@@ -1,304 +0,0 @@
-// src/contexts/docker.ts
-var SINGLE_QUOTE_RE = /'/g;
-function createDockerContext(config) {
-  let counter = 0;
-  const containers = /* @__PURE__ */ new Map();
-  const defaultImage = config?.image ?? "oven/bun:latest";
-  const defaultCwd = config?.cwd ?? "/workspace";
-  const defaultEnv = config?.env;
-  const defaultLimits = config?.limits;
-  async function getDockerode() {
-    try {
-      const Dockerode = (await import("dockerode")).default;
-      return new Dockerode();
-    } catch {
-      throw new Error("dockerode is required for Docker execution context. Install it with: bun add dockerode");
-    }
-  }
-  const ctx = {
-    type: "docker",
-    capabilities: {
-      shell: true,
-      filesystem: true,
-      network: true,
-      gpu: false
-    },
-    async spawn(overrides) {
-      const docker = await getDockerode();
-      const id = `docker-${++counter}`;
-      const image = overrides?.image ?? defaultImage;
-      const cwd = overrides?.cwd ?? defaultCwd;
-      try {
-        await docker.getImage(image).inspect();
-      } catch {
-        await new Promise((resolve2, reject) => {
-          docker.pull(image, (err, stream) => {
-            if (err)
-              return reject(err);
-            docker.modem.followProgress(stream, (err2) => {
-              err2 ? reject(err2) : resolve2();
-            });
-          });
-        });
-      }
-      const limits = { ...defaultLimits, ...overrides?.limits };
-      const hostConfig = {};
-      if (limits?.memory) {
-        hostConfig.Memory = limits.memory * 1024 * 1024;
-      }
-      if (limits?.cpu) {
-        hostConfig.NanoCpus = Number.parseFloat(limits.cpu) * 1e9;
-      }
-      const env = { ...defaultEnv, ...overrides?.env };
-      const container = await docker.createContainer({
-        Image: image,
-        Cmd: ["sleep", "infinity"],
-        WorkingDir: cwd,
-        Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
-        HostConfig: hostConfig
-      });
-      await container.start();
-      const handle = { id, type: "docker", cwd };
-      containers.set(id, { handle, container, docker });
-      return handle;
-    },
-    async exec(handle, command, options) {
-      const ref = containers.get(handle.id);
-      if (!ref)
-        throw new Error(`Container ${handle.id} not found`);
-      const execCwd = options?.cwd ?? handle.cwd;
-      const env = options?.env ? Object.entries(options.env).map(([k, v]) => `${k}=${v}`) : [];
-      const exec = await ref.container.exec({
-        Cmd: ["sh", "-c", command],
-        WorkingDir: execCwd,
-        Env: env,
-        AttachStdout: true,
-        AttachStderr: true
-      });
-      const stream = await exec.start({ Detach: false });
-      return new Promise((resolve2) => {
-        let stdout = "";
-        let stderr = "";
-        let resolved = false;
-        const stdoutSink = {
-          write(chunk) {
-            stdout += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-            return true;
-          },
-          end() {
-          },
-          on() {
-          },
-          once() {
-          },
-          emit() {
-            return true;
-          }
-        };
-        const stderrSink = {
-          write(chunk) {
-            stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-            return true;
-          },
-          end() {
-          },
-          on() {
-          },
-          once() {
-          },
-          emit() {
-            return true;
-          }
-        };
-        try {
-          ref.docker.modem.demuxStream(stream, stdoutSink, stderrSink);
-        } catch {
-          stream.on("data", (chunk) => {
-            stdout += chunk.toString("utf-8");
-          });
-        }
-        const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30;
-        const timer = setTimeout(() => {
-          if (resolved)
-            return;
-          resolved = true;
-          try {
-            stream.destroy?.();
-          } catch {
-          }
-          resolve2({ stdout, stderr: stderr ? `${stderr}
-[timeout]` : "[timeout]", exitCode: 124 });
-        }, timeout * 1e3);
-        stream.on("end", async () => {
-          if (resolved)
-            return;
-          resolved = true;
-          clearTimeout(timer);
-          let exitCode = 0;
-          try {
-            const inspect = await exec.inspect();
-            exitCode = inspect.ExitCode ?? 0;
-          } catch {
-          }
-          resolve2({ stdout, stderr, exitCode });
-        });
-        stream.on("error", (err) => {
-          if (resolved)
-            return;
-          resolved = true;
-          clearTimeout(timer);
-          resolve2({ stdout, stderr: stderr ? `${stderr}
-${err.message}` : err.message, exitCode: 1 });
-        });
-      });
-    },
-    async readFile(handle, path) {
-      const result = await ctx.exec(handle, `cat ${JSON.stringify(path)}`);
-      if (result.exitCode !== 0)
-        throw new Error(`Failed to read file: ${result.stderr}`);
-      return result.stdout;
-    },
-    async writeFile(handle, path, content) {
-      const escaped = content.replace(SINGLE_QUOTE_RE, String.raw`'\''`);
-      const result = await ctx.exec(handle, `mkdir -p "$(dirname ${JSON.stringify(path)})" && printf '%s' '${escaped}' > ${JSON.stringify(path)}`);
-      if (result.exitCode !== 0)
-        throw new Error(`Failed to write file: ${result.stderr}`);
-    },
-    async listFiles(handle, path) {
-      const result = await ctx.exec(handle, `ls -1 ${JSON.stringify(path)}`);
-      if (result.exitCode !== 0)
-        return [];
-      return result.stdout.trim().split("\n").filter(Boolean);
-    },
-    async destroy(handle) {
-      const ref = containers.get(handle.id);
-      if (!ref)
-        return;
-      try {
-        await ref.container.stop({ t: 5 });
-        await ref.container.remove({ force: true });
-      } catch {
-      }
-      containers.delete(handle.id);
-    }
-  };
-  return ctx;
-}
-
-// src/contexts/process.ts
-import { exec as execCb } from "child_process";
-import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
-import { promisify } from "util";
-var execAsync = promisify(execCb);
-function createProcessContext(config) {
-  let counter = 0;
-  const handles = /* @__PURE__ */ new Map();
-  const defaultCwd = config?.cwd ?? process.cwd();
-  const defaultEnv = config?.env;
-  return {
-    type: "process",
-    capabilities: {
-      shell: true,
-      filesystem: true,
-      network: true,
-      gpu: false
-    },
-    async spawn(overrides) {
-      const id = `process-${++counter}`;
-      const cwd = overrides?.cwd ?? defaultCwd;
-      await mkdir(cwd, { recursive: true });
-      const handle = { id, type: "process", cwd };
-      handles.set(id, handle);
-      return handle;
-    },
-    async exec(handle, command, options) {
-      const cwd = options?.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd;
-      try {
-        const { stdout, stderr } = await execAsync(command, {
-          cwd,
-          env: { ...process.env, ...defaultEnv, ...options?.env },
-          timeout: (options?.timeout ?? config?.limits?.timeout ?? 30) * 1e3,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        return { stdout, stderr, exitCode: 0 };
-      } catch (err) {
-        const e = err;
-        return {
-          stdout: typeof e.stdout === "string" ? e.stdout : "",
-          stderr: typeof e.stderr === "string" ? e.stderr : typeof e.message === "string" ? e.message : String(err),
-          exitCode: typeof e.code === "number" ? e.code : 1
-        };
-      }
-    },
-    async readFile(handle, path) {
-      return readFile(resolve(handle.cwd, path), "utf-8");
-    },
-    async readFileBinary(handle, path) {
-      const buf = await readFile(resolve(handle.cwd, path));
-      return new Uint8Array(buf);
-    },
-    async writeFile(handle, path, content) {
-      const fullPath = resolve(handle.cwd, path);
-      await mkdir(dirname(fullPath), { recursive: true });
-      await writeFile(fullPath, content, "utf-8");
-    },
-    async listFiles(handle, path) {
-      return readdir(resolve(handle.cwd, path));
-    },
-    async destroy(handle) {
-      handles.delete(handle.id);
-    }
-  };
-}
-
-// src/contexts/sandbox.ts
-function createSandboxContext(provider) {
-  const sandboxes = /* @__PURE__ */ new Map();
-  function getSandboxId(handle) {
-    const id = sandboxes.get(handle.id);
-    if (!id)
-      throw new Error(`Sandbox ${handle.id} not found`);
-    return id;
-  }
-  return {
-    type: "sandbox",
-    capabilities: {
-      shell: true,
-      filesystem: true,
-      network: true,
-      gpu: false
-    },
-    async spawn(config) {
-      const result = await provider.spawn(config ?? {});
-      const handle = { id: result.id, type: "sandbox", cwd: result.cwd };
-      sandboxes.set(handle.id, result.id);
-      return handle;
-    },
-    async exec(handle, command, options) {
-      return provider.exec(getSandboxId(handle), command, options);
-    },
-    async readFile(handle, path) {
-      return provider.readFile(getSandboxId(handle), path);
-    },
-    async writeFile(handle, path, content) {
-      return provider.writeFile(getSandboxId(handle), path, content);
-    },
-    async listFiles(handle, path) {
-      return provider.listFiles(getSandboxId(handle), path);
-    },
-    async destroy(handle) {
-      const id = sandboxes.get(handle.id);
-      if (!id)
-        return;
-      await provider.destroy(id);
-      sandboxes.delete(handle.id);
-    }
-  };
-}
-
-export {
-  createDockerContext,
-  createProcessContext,
-  createSandboxContext
-};