opencode-swarm 7.83.0 → 7.85.0

package/dist/cli/index-5cb86007.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  redactPath,
+  redactShellCommand
+} from "./index-vq2321gg.js";
+
+// src/services/guardrail-log-service.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var BLOCK_TYPES = new Set([
+  "file_write",
+  "scope_violation",
+  "destructive_block"
+]);
+function isBlockEntry(entry) {
+  if (entry.type === null || entry.type === undefined)
+    return false;
+  return BLOCK_TYPES.has(entry.type);
+}
+function redactSummary(entry) {
+  if (entry.type === "file_write" || entry.type === "scope_violation") {
+    const raw = entry.path ?? "";
+    return redactPath(raw);
+  }
+  if (entry.type === "destructive_block" || entry.type === "sandbox_wrap" || entry.type === "sandbox_skip" || entry.type === "shell" || entry.type === null || entry.type === undefined) {
+    const raw = entry.command ?? "";
+    return redactShellCommand(raw);
+  }
+  return "";
+}
+function formatEntry(entry) {
+  const decisionType = entry.type ?? "shell";
+  const summary = redactSummary(entry);
+  return `- [${entry.ts}] ${decisionType} | agent: ${entry.agent} | ${summary}`;
+}
+async function handleGuardrailLog(directory, args) {
+  const auditPath = path.join(directory, ".swarm", "session", "shell-audit.jsonl");
+  let raw;
+  try {
+    raw = await fs.readFile(auditPath, "utf-8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return "No guardrail decisions recorded yet.";
+    }
+    throw error;
+  }
+  const lines = raw.split(/\r?\n/);
+  const entries = [];
+  for (const line of lines) {
+    if (line.trim().length === 0)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isPlainObject(parsed))
+      continue;
+    if (typeof parsed.ts !== "string")
+      continue;
+    if (typeof parsed.sessionID !== "string")
+      continue;
+    if (typeof parsed.agent !== "string")
+      continue;
+    if (typeof parsed.tool !== "string")
+      continue;
+    const entry = {
+      ts: parsed.ts,
+      sessionID: parsed.sessionID,
+      agent: parsed.agent,
+      tool: parsed.tool
+    };
+    if (typeof parsed.type === "string") {
+      entry.type = parsed.type;
+    }
+    if (typeof parsed.command === "string") {
+      entry.command = parsed.command;
+    }
+    if (typeof parsed.path === "string") {
+      entry.path = parsed.path;
+    }
+    entries.push(entry);
+  }
+  if (entries.length === 0) {
+    return "No guardrail decisions recorded yet.";
+  }
+  const blocksOnly = args.includes("--blocks-only");
+  const filtered = blocksOnly ? entries.filter(isBlockEntry) : entries;
+  if (filtered.length === 0) {
+    if (blocksOnly) {
+      return "No guardrail block decisions recorded yet.";
+    }
+    return "No guardrail decisions recorded yet.";
+  }
+  filtered.sort((a, b) => {
+    const diff = b.ts.localeCompare(a.ts);
+    return diff === 0 ? 0 : diff;
+  });
+  const header = blocksOnly ? "# Guardrail Block Log (most-recent-first)" : "# Guardrail Decision Log (most-recent-first)";
+  const body = filtered.map(formatEntry).join(`
+`);
+  return `${header}
+
+${body}`;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && (value.constructor === Object || Object.getPrototypeOf(value) === null);
+}
+export { handleGuardrailLog };

package/dist/cli/index-a76rekgs.js

@@ -0,0 +1,67 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+export { __toESM, __toCommonJS, __commonJS, __export, __esm, __require };

package/dist/cli/index-b9v501fr.js

@@ -0,0 +1,371 @@
+// @bun
+// src/utils/bun-compat.ts
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "child_process";
+import * as fsSync from "fs";
+import * as fsPromises from "fs/promises";
+import * as path from "path";
+var WINDOWS_RENAME_MAX_RETRIES = 3;
+var WINDOWS_RENAME_RETRY_DELAY_MS = 50;
+var tempCounter = 0;
+function getBun() {
+  const g = globalThis;
+  return g.Bun;
+}
+function bunFile(filePath) {
+  const bun = getBun();
+  if (bun?.file) {
+    return bun.file(filePath);
+  }
+  let cachedSize;
+  return {
+    async text() {
+      return fsPromises.readFile(filePath, "utf-8");
+    },
+    async arrayBuffer() {
+      const buf = await fsPromises.readFile(filePath);
+      const ab = new ArrayBuffer(buf.byteLength);
+      new Uint8Array(ab).set(buf);
+      return ab;
+    },
+    async exists() {
+      try {
+        await fsPromises.access(filePath, fsSync.constants.F_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    get size() {
+      if (cachedSize !== undefined)
+        return cachedSize;
+      try {
+        cachedSize = fsSync.statSync(filePath).size;
+      } catch {
+        cachedSize = 0;
+      }
+      return cachedSize;
+    }
+  };
+}
+async function bunWrite(filePath, data) {
+  const bun = getBun();
+  if (bun?.write) {
+    return bun.write(filePath, data);
+  }
+  const dir = path.dirname(filePath);
+  const tempName = `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${tempCounter++}.${Math.random().toString(36).slice(2, 10)}.tmp`;
+  const tempPath = path.join(dir, tempName);
+  let buffer;
+  if (typeof data === "string") {
+    buffer = data;
+  } else if (data instanceof ArrayBuffer) {
+    buffer = new Uint8Array(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    buffer = new Uint8Array(0);
+  }
+  try {
+    await fsPromises.mkdir(dir, { recursive: true });
+  } catch {}
+  await fsPromises.writeFile(tempPath, buffer);
+  let lastError;
+  for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+    try {
+      await fsPromises.rename(tempPath, filePath);
+      lastError = undefined;
+      break;
+    } catch (err) {
+      lastError = err;
+      const code = err.code;
+      if (code !== "EEXIST" && code !== "EBUSY" && code !== "EPERM") {
+        break;
+      }
+      await new Promise((r) => setTimeout(r, WINDOWS_RENAME_RETRY_DELAY_MS));
+    }
+  }
+  if (lastError) {
+    try {
+      await fsPromises.unlink(tempPath);
+    } catch {}
+    throw lastError;
+  }
+  try {
+    const dirFd = await fsPromises.open(dir, "r");
+    try {
+      await dirFd.sync();
+    } finally {
+      await dirFd.close();
+    }
+  } catch {}
+  const stats = await fsPromises.stat(filePath);
+  return stats.size;
+}
+function bunHash(input) {
+  const bun = getBun();
+  if (bun?.hash) {
+    const r = bun.hash(input);
+    return typeof r === "bigint" ? r : BigInt(r);
+  }
+  let bytes;
+  if (typeof input === "string") {
+    bytes = new TextEncoder().encode(input);
+  } else if (input instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input);
+  } else {
+    bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  let hash = 5381n;
+  for (const b of bytes) {
+    hash = hash * 33n + BigInt(b) & 0xffffffffffffffffn;
+  }
+  return hash;
+}
+function killProcessTreeImpl(pid, signal, directKill, wasDetached) {
+  if (typeof pid !== "number" || pid <= 0) {
+    directKill();
+    return;
+  }
+  if (process.platform === "win32") {
+    try {
+      nodeSpawnSync("taskkill", ["/PID", String(pid), "/T", "/F"]);
+    } catch {
+      directKill();
+    }
+    return;
+  }
+  if (wasDetached) {
+    try {
+      process.kill(-pid, signal ?? "SIGKILL");
+      return;
+    } catch {}
+  }
+  directKill();
+}
+function streamFromNode(pipe) {
+  const collected = new Promise((resolve) => {
+    if (!pipe) {
+      resolve(Buffer.alloc(0));
+      return;
+    }
+    const chunks = [];
+    pipe.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    pipe.on("end", () => resolve(Buffer.concat(chunks)));
+    pipe.on("error", () => resolve(Buffer.concat(chunks)));
+  });
+  const toWebReadable = () => {
+    if (!pipe) {
+      return new ReadableStream({
+        start(controller) {
+          controller.close();
+        }
+      });
+    }
+    const r = pipe;
+    if (typeof r.toWeb === "function") {
+      return r.toWeb();
+    }
+    return new ReadableStream({
+      start(controller) {
+        pipe.on("data", (chunk) => {
+          controller.enqueue(typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        });
+        pipe.on("end", () => controller.close());
+        pipe.on("error", (err) => controller.error(err));
+      },
+      cancel() {
+        const destroyable = pipe;
+        if (typeof destroyable.destroy === "function") {
+          try {
+            destroyable.destroy();
+          } catch {}
+        }
+      }
+    });
+  };
+  return {
+    async text() {
+      return (await collected).toString("utf-8");
+    },
+    async bytes() {
+      const b = await collected;
+      return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+    },
+    getReader() {
+      return toWebReadable().getReader();
+    }
+  };
+}
+function mapStdio(v) {
+  return v ?? "pipe";
+}
+function streamFromBun(stream) {
+  if (!stream || typeof stream !== "object") {
+    const empty = {
+      async text() {
+        return "";
+      },
+      async bytes() {
+        return new Uint8Array(0);
+      },
+      getReader() {
+        return new ReadableStream({
+          start(controller) {
+            controller.close();
+          }
+        }).getReader();
+      }
+    };
+    return empty;
+  }
+  const candidate = stream;
+  const collect = async () => {
+    if (typeof candidate.getReader !== "function") {
+      return new Uint8Array(0);
+    }
+    const reader = candidate.getReader();
+    const chunks = [];
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value)
+        chunks.push(value);
+    }
+    const total = chunks.reduce((acc, c) => acc + c.byteLength, 0);
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+      out.set(c, off);
+      off += c.byteLength;
+    }
+    return out;
+  };
+  const text = typeof candidate.text === "function" ? () => candidate.text() : async () => new TextDecoder().decode(await collect());
+  const bytes = typeof candidate.bytes === "function" ? () => candidate.bytes() : collect;
+  const getReader = typeof candidate.getReader === "function" ? () => candidate.getReader() : () => new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  }).getReader();
+  return { text, bytes, getReader };
+}
+function bunSpawn(cmd, options) {
+  const bun = getBun();
+  if (bun?.spawn) {
+    const proc2 = bun.spawn(cmd, options);
+    return {
+      stdout: streamFromBun(proc2.stdout),
+      stderr: streamFromBun(proc2.stderr),
+      exited: proc2.exited,
+      get exitCode() {
+        return proc2.exitCode;
+      },
+      kill(sig) {
+        if (options?.killProcessTree) {
+          killProcessTreeImpl(proc2.pid, sig, () => proc2.kill(sig), false);
+        } else {
+          proc2.kill(sig);
+        }
+      }
+    };
+  }
+  const [file, ...args] = cmd;
+  const detached = options?.killProcessTree === true;
+  const proc = nodeSpawn(file, args, {
+    cwd: options?.cwd,
+    env: options?.env,
+    detached,
+    windowsHide: true,
+    stdio: [
+      mapStdio(options?.stdin),
+      mapStdio(options?.stdout),
+      mapStdio(options?.stderr)
+    ]
+  });
+  const killChild = (signal) => {
+    if (detached) {
+      killProcessTreeImpl(proc.pid, signal, () => proc.kill(signal), true);
+    } else {
+      proc.kill(signal);
+    }
+  };
+  let timeoutHandle;
+  const exited = new Promise((resolve) => {
+    proc.on("exit", (code) => resolve(code ?? 0));
+    proc.on("error", () => resolve(1));
+    if (options?.timeout && options.timeout > 0) {
+      timeoutHandle = setTimeout(() => {
+        try {
+          killChild("SIGKILL");
+        } catch {}
+      }, options.timeout);
+      if (typeof timeoutHandle.unref === "function") {
+        timeoutHandle.unref();
+      }
+    }
+  }).finally(() => {
+    if (timeoutHandle !== undefined)
+      clearTimeout(timeoutHandle);
+  });
+  return {
+    stdout: streamFromNode(proc.stdout),
+    stderr: streamFromNode(proc.stderr),
+    exited,
+    get exitCode() {
+      return proc.exitCode;
+    },
+    kill(signal) {
+      killChild(signal);
+    }
+  };
+}
+function bunSpawnSync(cmd, options) {
+  const bun = getBun();
+  if (bun?.spawnSync) {
+    const result2 = bun.spawnSync(cmd, options);
+    return result2;
+  }
+  let argv;
+  let mergedOptions;
+  if (Array.isArray(cmd)) {
+    argv = cmd;
+    mergedOptions = { ...options ?? {} };
+  } else {
+    argv = cmd.cmd;
+    mergedOptions = {
+      cwd: cmd.cwd,
+      env: cmd.env,
+      stdin: "pipe",
+      timeout: cmd.timeout,
+      ...options ?? {}
+    };
+    if (cmd.stdin !== undefined) {
+      mergedOptions.stdin = cmd.stdin;
+    }
+  }
+  const [file, ...args] = argv;
+  const result = nodeSpawnSync(file, args, {
+    cwd: mergedOptions.cwd,
+    env: mergedOptions.env,
+    input: mergedOptions.stdin instanceof Uint8Array || typeof mergedOptions.stdin === "string" ? mergedOptions.stdin : undefined,
+    timeout: mergedOptions.timeout,
+    windowsHide: true
+  });
+  const stdout = result.stdout instanceof Buffer ? new Uint8Array(result.stdout.buffer, result.stdout.byteOffset, result.stdout.byteLength) : typeof result.stdout === "string" ? new TextEncoder().encode(result.stdout) : new Uint8Array(0);
+  const stderr = result.stderr instanceof Buffer ? new Uint8Array(result.stderr.buffer, result.stderr.byteOffset, result.stderr.byteLength) : typeof result.stderr === "string" ? new TextEncoder().encode(result.stderr) : new Uint8Array(0);
+  const exitCode = result.status ?? (result.signal ? 128 : 1);
+  return {
+    stdout,
+    stderr,
+    exitCode,
+    success: exitCode === 0 && !result.error
+  };
+}
+
+export { bunFile, bunWrite, bunHash, bunSpawn, bunSpawnSync };