opencode-swarm 7.82.2 → 7.84.0

package/README.md

@@ -1080,7 +1080,9 @@ Control how tool outputs are summarized for LLM context.
 | `/swarm agents` | Registered agents with models and permissions |
 | `/swarm history` | Completed phases with status |
 | `/swarm config` | Current resolved configuration |
-| `/swarm diagnose` | Health check for `.swarm/` files and config |
+| `/swarm diagnose` | Health check for `.swarm/` files, config, and sandbox executor status |
+| `/swarm guardrail explain [--agent <role>] [--scope <path>] [--write <path>...] [--] <command>` | Dry-run guardrail decisions — report what would be allowed/blocked without executing anything |
+| `/swarm guardrail-log [--blocks-only]` | Read and print the guardrail decision log most-recent-first; `--blocks-only` shows only block decisions |
 | `/swarm export` | Export plan and context as portable JSON |
 | `/swarm evidence [task]` | Evidence bundles for a task or all tasks |
 | `/swarm archive [--dry-run]` | Archive old evidence with retention policy |

package/dist/cli/capability-probe-jevmgwmf.js

@@ -0,0 +1,18 @@
+// @bun
+import {
+  SandboxCapabilityProbe,
+  init_capability_probe,
+  isBubblewrapAvailable,
+  isSandboxExecAvailable,
+  isWindowsSandboxAvailable
+} from "./index-hz59hg4h.js";
+import"./index-yx44zd0p.js";
+import"./index-a76rekgs.js";
+init_capability_probe();
+
+export {
+  isWindowsSandboxAvailable,
+  isSandboxExecAvailable,
+  isBubblewrapAvailable,
+  SandboxCapabilityProbe
+};

package/dist/cli/config-doctor-4tcdd9vt.js

@@ -0,0 +1,35 @@
+// @bun
+import {
+  applySafeAutoFixes,
+  createConfigBackup,
+  detectStraySwarmDirs,
+  getConfigPaths,
+  readDoctorArtifact,
+  removeStraySwarmDir,
+  restoreFromBackup,
+  runConfigDoctor,
+  runConfigDoctorWithFixes,
+  shouldRunOnStartup,
+  writeBackupArtifact,
+  writeDoctorArtifact
+} from "./index-a82d6d87.js";
+import"./index-wg3r6acj.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-293f68mj.js";
+import"./index-a76rekgs.js";
+export {
+  writeDoctorArtifact,
+  writeBackupArtifact,
+  shouldRunOnStartup,
+  runConfigDoctorWithFixes,
+  runConfigDoctor,
+  restoreFromBackup,
+  removeStraySwarmDir,
+  readDoctorArtifact,
+  getConfigPaths,
+  detectStraySwarmDirs,
+  createConfigBackup,
+  applySafeAutoFixes
+};

package/dist/cli/dispatch-k86d928w.js

@@ -0,0 +1,477 @@
+// @bun
+import {
+  LANGUAGE_REGISTRY,
+  buildGoBackend,
+  buildPythonBackend,
+  defaultBackendFor,
+  defaultBuildTestCommand,
+  defaultParseTestOutput,
+  defaultSelectBuildCommand,
+  defaultSelectTestFramework,
+  defaultTestFilesFor,
+  detectProjectLanguages,
+  tokenizeCommand
+} from "./index-f8r50m3h.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-b9v501fr.js";
+import"./index-a76rekgs.js";
+
+// src/lang/dispatch.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/lang/registry-backend.ts
+class LanguageBackendRegistry {
+  backends = new Map;
+  register(backend) {
+    const existing = this.backends.get(backend.id);
+    if (existing && existing !== backend) {
+      throw new Error(`LanguageBackendRegistry: backend id "${backend.id}" registered twice. ` + `Each LanguageBackend.id must be unique.`);
+    }
+    this.backends.set(backend.id, backend);
+  }
+  get(id) {
+    return this.backends.get(id);
+  }
+  getOrDefault(id) {
+    const registered = this.backends.get(id);
+    if (registered)
+      return registered;
+    const profile = LANGUAGE_REGISTRY.get(id);
+    if (!profile)
+      return;
+    return defaultBackendFor(profile);
+  }
+  unregister(id) {
+    this.backends.delete(id);
+  }
+}
+var LANGUAGE_BACKEND_REGISTRY = new LanguageBackendRegistry;
+
+// src/lang/framework-detector.ts
+import * as fs from "fs";
+import * as path from "path";
+function detectLaravelProject(directory) {
+  const signals = getLaravelSignals(directory);
+  const signalCount = [
+    signals.hasArtisanFile,
+    signals.hasLaravelFrameworkDep,
+    signals.hasConfigApp
+  ].filter(Boolean).length;
+  return signalCount >= 2;
+}
+function getLaravelSignals(directory) {
+  const hasArtisanFile = checkArtisanFile(directory);
+  const hasLaravelFrameworkDep = checkLaravelFrameworkDep(directory);
+  const hasConfigApp = checkConfigApp(directory);
+  return { hasArtisanFile, hasLaravelFrameworkDep, hasConfigApp };
+}
+function checkArtisanFile(directory) {
+  const artisanPath = path.join(directory, "artisan");
+  if (!fs.existsSync(artisanPath))
+    return false;
+  try {
+    return fs.statSync(artisanPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function checkLaravelFrameworkDep(directory) {
+  const composerPath = path.join(directory, "composer.json");
+  if (!fs.existsSync(composerPath))
+    return false;
+  try {
+    const content = fs.readFileSync(composerPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const require2 = parsed?.require ?? {};
+    return typeof require2["laravel/framework"] === "string";
+  } catch {
+    return false;
+  }
+}
+function checkConfigApp(directory) {
+  return fs.existsSync(path.join(directory, "config", "app.php"));
+}
+
+// src/lang/backends/php.ts
+var PROFILE_ID = "php";
+async function selectFramework(dir) {
+  if (detectLaravelProject(dir)) {
+    return {
+      name: "laravel",
+      detectedVia: "Laravel signals (artisan / composer.json / config/app.php)"
+    };
+  }
+  return null;
+}
+function buildPhpBackend() {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID);
+  if (!profile) {
+    throw new Error("buildPhpBackend: php profile not in LANGUAGE_REGISTRY. " + "profiles.ts must be imported before this backend.");
+  }
+  return {
+    ...defaultBackendFor(profile),
+    selectFramework
+  };
+}
+
+// src/lang/backends/typescript.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var PROFILE_ID2 = "typescript";
+var IMPORT_REGEX_ES = /import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g;
+var IMPORT_REGEX_BARE = /import\s+['"]([^'"]+)['"]/g;
+var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var IMPORT_REGEX_DYNAMIC = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
+function readPackageJsonRaw(dir) {
+  try {
+    const content = fs2.readFileSync(path2.join(dir, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function readPackageJson(dir) {
+  return _internals.readPackageJsonRaw(dir);
+}
+function readPackageJsonTestScript(dir) {
+  return readPackageJson(dir)?.scripts?.test ?? null;
+}
+function frameworkFromScriptsTest(script) {
+  if (script.includes("vitest"))
+    return "vitest";
+  if (script.includes("jest"))
+    return "jest";
+  if (script.includes("mocha"))
+    return "mocha";
+  if (script.includes("bun test"))
+    return "bun:test";
+  return null;
+}
+function frameworkFromDevDeps(devDeps) {
+  if (!devDeps)
+    return null;
+  if (devDeps.vitest || devDeps["@vitest/ui"])
+    return "vitest";
+  if (devDeps.jest || devDeps["@types/jest"])
+    return "jest";
+  if (devDeps.mocha || devDeps["@types/mocha"])
+    return "mocha";
+  return null;
+}
+function selectionFromFramework(profile, fwName, dir, detectedVia) {
+  const fw = profile.test.frameworks.find((f) => f.name === fwName);
+  if (!fw)
+    return null;
+  const argv = tokenizeCommand(fw.cmd);
+  if (argv.length === 0)
+    return null;
+  return {
+    name: fw.name,
+    cmd: argv,
+    cwd: dir,
+    detectedVia,
+    filesIgnored: false
+  };
+}
+async function selectTestFramework(dir) {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID2);
+  if (!profile)
+    return null;
+  const pkg = readPackageJson(dir);
+  const script = pkg?.scripts?.test;
+  if (script) {
+    const fwName = frameworkFromScriptsTest(script);
+    if (fwName) {
+      const sel = selectionFromFramework(profile, fwName, dir, "package.json#scripts.test");
+      if (sel)
+        return sel;
+    }
+  }
+  const devDepsFw = frameworkFromDevDeps(pkg?.devDependencies);
+  if (devDepsFw) {
+    const sel = selectionFromFramework(profile, devDepsFw, dir, "package.json#devDependencies");
+    if (sel)
+      return sel;
+  }
+  return defaultSelectTestFramework(profile, dir);
+}
+function buildTestCommand(framework, files, dir, opts) {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID2);
+  if (!profile)
+    return null;
+  return defaultBuildTestCommand(profile, framework, files, dir, opts);
+}
+function parseTestOutput(framework, stdout, stderr, exitCode) {
+  return defaultParseTestOutput(framework, stdout, stderr, exitCode);
+}
+async function selectFramework2(dir) {
+  const pkg = readPackageJson(dir);
+  if (!pkg)
+    return null;
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const order = [
+    ["next", "next"],
+    ["nuxt", "nuxt"],
+    ["@angular/core", "angular"],
+    ["svelte", "svelte"],
+    ["react", "react"],
+    ["vue", "vue"],
+    ["express", "express"],
+    ["fastify", "fastify"],
+    ["@nestjs/core", "nestjs"]
+  ];
+  for (const [pkgName, displayName] of order) {
+    if (deps[pkgName]) {
+      return {
+        name: displayName,
+        detectedVia: `package.json#dependencies.${pkgName}`
+      };
+    }
+  }
+  return null;
+}
+async function selectEntryPoints(dir) {
+  const pkg = readPackageJson(dir);
+  if (!pkg)
+    return [];
+  const points = [];
+  const obj = pkg;
+  if (obj.bin) {
+    if (typeof obj.bin === "string")
+      points.push(obj.bin);
+    else
+      for (const v of Object.values(obj.bin))
+        points.push(v);
+  }
+  if (obj.main)
+    points.push(obj.main);
+  if (obj.module && obj.module !== obj.main)
+    points.push(obj.module);
+  if (obj.exports && typeof obj.exports === "object") {
+    const root = obj.exports["."];
+    if (typeof root === "string" && !points.includes(root))
+      points.push(root);
+  }
+  return [...new Set(points.filter((p) => p.length > 0))];
+}
+function extractImports(_sourceFile, source) {
+  const out = new Set;
+  for (const re of [
+    IMPORT_REGEX_ES,
+    IMPORT_REGEX_BARE,
+    IMPORT_REGEX_REQUIRE,
+    IMPORT_REGEX_DYNAMIC,
+    IMPORT_REGEX_REEXPORT
+  ]) {
+    re.lastIndex = 0;
+    let m = re.exec(source);
+    while (m !== null) {
+      out.add(m[1]);
+      m = re.exec(source);
+    }
+  }
+  return [...out];
+}
+async function selectBuildCommand(dir) {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID2);
+  if (!profile)
+    return null;
+  return defaultSelectBuildCommand(profile, dir);
+}
+async function testFilesFor(sourceFile, dir) {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID2);
+  if (!profile)
+    return [];
+  return defaultTestFilesFor(profile, sourceFile, dir);
+}
+function buildTypescriptBackend() {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID2);
+  if (!profile) {
+    throw new Error("buildTypescriptBackend: typescript profile not in LANGUAGE_REGISTRY. " + "profiles.ts must be imported before this backend.");
+  }
+  return {
+    ...profile,
+    selectTestFramework,
+    buildTestCommand,
+    parseTestOutput,
+    extractImports,
+    selectBuildCommand,
+    testFilesFor,
+    selectFramework: selectFramework2,
+    selectEntryPoints
+  };
+}
+var _internals = {
+  readPackageJsonRaw,
+  readPackageJsonTestScript,
+  frameworkFromScriptsTest
+};
+
+// src/lang/backends/index.ts
+var registered = false;
+function registerAllBackends() {
+  if (registered)
+    return;
+  LANGUAGE_BACKEND_REGISTRY.register(buildTypescriptBackend());
+  LANGUAGE_BACKEND_REGISTRY.register(buildPythonBackend());
+  LANGUAGE_BACKEND_REGISTRY.register(buildGoBackend());
+  LANGUAGE_BACKEND_REGISTRY.register(buildPhpBackend());
+  registered = true;
+}
+registerAllBackends();
+
+// src/lang/dispatch.ts
+var _internals2 = {
+  detectProjectLanguages,
+  cacheCapacity: 64
+};
+var cache = new Map;
+var insertCounter = 0;
+var MANIFEST_FILES = [
+  "package.json",
+  "tsconfig.json",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  "Pipfile",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "build.zig",
+  "CMakeLists.txt",
+  "Makefile",
+  "meson.build",
+  "Package.swift",
+  "pubspec.yaml",
+  "Gemfile",
+  "composer.json"
+];
+var _MANIFEST_SET = new Set(MANIFEST_FILES);
+function safeReaddirSet(dir) {
+  try {
+    return new Set(fs3.readdirSync(dir));
+  } catch {
+    return new Set;
+  }
+}
+function manifestHash(dir) {
+  const entries = safeReaddirSet(dir);
+  if (entries.size === 0)
+    return "";
+  const parts = [];
+  for (const name of MANIFEST_FILES) {
+    if (!entries.has(name))
+      continue;
+    try {
+      const stat = fs3.statSync(path3.join(dir, name));
+      parts.push(`${name}:${stat.size}:${stat.mtimeMs}:${stat.ino}`);
+    } catch {}
+  }
+  return parts.join("|");
+}
+var manifestRootCache = new Map;
+function findManifestRoot(start) {
+  const resolved = path3.resolve(start);
+  const cached = manifestRootCache.get(resolved);
+  if (cached !== undefined)
+    return cached;
+  let cur = resolved;
+  for (let i = 0;i < 32; i++) {
+    const entries = safeReaddirSet(cur);
+    if (entries.size > 0) {
+      for (const name of MANIFEST_FILES) {
+        if (entries.has(name)) {
+          manifestRootCache.set(resolved, cur);
+          return cur;
+        }
+      }
+      if (entries.has(".git")) {
+        manifestRootCache.set(resolved, cur);
+        return cur;
+      }
+    }
+    const parent = path3.dirname(cur);
+    if (parent === cur)
+      break;
+    cur = parent;
+  }
+  manifestRootCache.set(resolved, start);
+  return start;
+}
+function evictIfNeeded() {
+  if (cache.size <= _internals2.cacheCapacity)
+    return;
+  let oldestKey;
+  let oldestOrder = Infinity;
+  for (const [k, v] of cache.entries()) {
+    if (v.insertOrder < oldestOrder) {
+      oldestOrder = v.insertOrder;
+      oldestKey = k;
+    }
+  }
+  if (oldestKey !== undefined)
+    cache.delete(oldestKey);
+}
+async function pickBackend(dir) {
+  const root = findManifestRoot(dir);
+  const hash = manifestHash(root);
+  const cacheKey = root;
+  const cached = cache.get(cacheKey);
+  if (cached && cached.hash === hash) {
+    return cached.backend;
+  }
+  if (hash === "") {
+    cache.set(cacheKey, {
+      hash,
+      backend: null,
+      profiles: [],
+      insertOrder: insertCounter++
+    });
+    evictIfNeeded();
+    return null;
+  }
+  const profiles = await _internals2.detectProjectLanguages(root);
+  if (profiles.length === 0) {
+    cache.set(cacheKey, {
+      hash,
+      backend: null,
+      profiles: [],
+      insertOrder: insertCounter++
+    });
+    evictIfNeeded();
+    return null;
+  }
+  const winner = profiles[0];
+  const backend = LANGUAGE_BACKEND_REGISTRY.getOrDefault(winner.id) ?? null;
+  cache.set(cacheKey, {
+    hash,
+    backend,
+    profiles: profiles.map((p) => ({ id: p.id })),
+    insertOrder: insertCounter++
+  });
+  evictIfNeeded();
+  return backend;
+}
+function pickedProfiles(dir) {
+  const root = findManifestRoot(dir);
+  const cached = cache.get(root);
+  return cached?.profiles ?? [];
+}
+function clearDispatchCache() {
+  cache.clear();
+  manifestRootCache.clear();
+  insertCounter = 0;
+}
+export {
+  pickedProfiles,
+  pickBackend,
+  clearDispatchCache,
+  _internals2 as _internals
+};