opencode-swarm 7.0.2 → 7.0.3

package/dist/tools/__tests__/repo-graph-walk.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Regression coverage for the repo-graph walker (issue #704).
+ *
+ * Each test installs a fresh fixture under a tmp dir and asserts the walker
+ * cannot be tricked into:
+ *   - infinite recursion via symlink cycles,
+ *   - exceeding the wall-clock budget on a slow filesystem,
+ *   - exceeding the file cap during traversal (vs. post-truncation),
+ *   - scanning a refused top-level workspace root.
+ *
+ * Symlink-loop coverage is POSIX-only; the test bails on Windows because
+ * creating a directory symlink there requires Developer Mode. The walker's
+ * cycle defense itself is platform-agnostic — see `seenRealPaths` in
+ * src/tools/repo-graph.ts.
+ */
+export {};

package/dist/tools/repo-graph.d.ts

@@ -206,10 +206,24 @@ export declare function saveIfDirty(workspace: string): Promise<void>;
  * @returns Complete RepoGraph with nodes and edges
  * @throws Error if workspace validation fails
  */
-export declare function buildWorkspaceGraph(workspaceRoot: string, options?: {
+export interface BuildWorkspaceGraphOptions {
     maxFileSizeBytes?: number;
     maxFiles?: number;
-}): RepoGraph;
+    walkBudgetMs?: number;
+    followSymlinks?: boolean;
+}
+export declare function buildWorkspaceGraph(workspaceRoot: string, options?: BuildWorkspaceGraphOptions): RepoGraph;
+/**
+ * Async, event-loop-safe variant of `buildWorkspaceGraph`. The traversal
+ * yields between batches and uses async fs primitives, so callers can run
+ * this from plugin init without freezing the host while a large workspace
+ * is scanned. The per-file processing remains sync — it is CPU-bound symbol
+ * extraction, and the existing per-file caps already prevent runaway work.
+ *
+ * Returned shape matches `buildWorkspaceGraph`. Same homedir guard, same
+ * bounded walk behavior, same deterministic file order.
+ */
+export declare function buildWorkspaceGraphAsync(workspaceRoot: string, options?: BuildWorkspaceGraphOptions): Promise<RepoGraph>;
 /**
  * Incrementally update the graph for a set of changed files.
  * Re-scans only the specified files, updates their nodes and edges,

package/dist/utils/__tests__/bun-compat.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bun-compat shim tests (issue #704).
+ *
+ * Each public surface is exercised against the live runtime. When running
+ * under Bun the shim delegates to the native `Bun.*` primitives; when running
+ * under Node the shim's fallback path is exercised. The test only asserts the
+ * observable contract (text equality, written byte count, exit code parity)
+ * — it does not lock in implementation details that legitimately differ
+ * between the two paths.
+ */
+export {};

package/dist/utils/__tests__/timeout.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Timeout-helper tests (issue #704).
+ *
+ * The plugin init path uses `withTimeout` to bound the snapshot rehydration
+ * read so a slow filesystem cannot pin the host's `await server(...)`. The
+ * helper must:
+ *   - resolve to the racer's value when the racer wins,
+ *   - reject with the supplied error when the deadline elapses,
+ *   - clear its timer in `finally` (no leak that holds the loop open),
+ *   - never throw synchronously.
+ */
+export {};

package/dist/utils/bun-compat.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Runtime-portability shim for the small set of `Bun.*` APIs we depend on.
+ *
+ * Why this exists: the plugin entry (`src/index.ts`) is bundled with
+ * `--target node`, but the source tree calls `Bun.file`, `Bun.write`,
+ * `Bun.spawn`, `Bun.spawnSync`, and `Bun.hash` directly. OpenCode's plugin
+ * host explicitly supports running plugins under Node (its own `PluginInput`
+ * uses `$: typeof Bun === "undefined" ? undefined : Bun.$`). On the OpenCode
+ * Desktop sidecar, plugins may execute under Node — every direct `Bun.*`
+ * reference would throw `ReferenceError: Bun is not defined`.
+ *
+ * This module funnels all such calls through a small set of helpers that
+ * detect the runtime once and dispatch to either the Bun primitive or a
+ * Node fallback. The fallbacks are deliberately small — they implement
+ * exactly the surface our callers use, no more.
+ *
+ * Cross-platform notes:
+ *   - `bunWrite` performs an atomic write via temp+rename on the Node path,
+ *     mirroring Bun's atomic semantics. Includes a Windows EEXIST retry loop
+ *     because rename can race with file-handle release on Windows.
+ *   - `bunSpawn` and `bunSpawnSync` use `node:child_process` and translate
+ *     Bun's option shape into Node's. Stdout/stderr capture is wired so
+ *     callers see the same `text()`/`stdout` shape regardless of runtime.
+ *   - `bunHash` uses Node's `xxhash` via `Bun.hash`'s default algorithm when
+ *     present and falls back to a stable djb2-derived 32-bit hash on Node.
+ */
+/**
+ * Whether the current runtime is Bun. Cached at first call — every subsequent
+ * call is a single property access.
+ */
+export declare function isBun(): boolean;
+/**
+ * Bun.file / fs read shim. Returns an object exposing the subset of
+ * `BunFile` methods used in this codebase: `text()`, `arrayBuffer()`,
+ * `exists()`, and `size`.
+ *
+ * On Bun, this is a thin wrapper around `Bun.file()` so callers see
+ * identical semantics. On Node, the methods read the file lazily.
+ */
+export interface BunCompatFile {
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    exists(): Promise<boolean>;
+    readonly size: number;
+}
+export declare function bunFile(filePath: string): BunCompatFile;
+/**
+ * Atomic file write. On Bun this delegates to `Bun.write`. On Node we write
+ * to a temp file in the same directory and rename atomically — the same
+ * semantics every existing call site already expects via Bun.write.
+ */
+export declare function bunWrite(filePath: string, data: string | Uint8Array | ArrayBuffer | ArrayBufferView): Promise<number>;
+/**
+ * Stable 32-bit hash. Bun's `Bun.hash` uses xxHash64 by default; on Node we
+ * fall back to a 32-bit djb2 hash — identical hashes are NOT guaranteed
+ * across runtimes, so callers should not rely on cross-runtime hash equality
+ * (no current caller does — every `Bun.hash` use is in-process state keying
+ * or a same-runtime cache key).
+ */
+export declare function bunHash(input: string | ArrayBufferView | ArrayBuffer): bigint;
+/**
+ * Process spawn. Bun's `Bun.spawn` returns an object with `exited`, `stdout`,
+ * `stderr` etc. We expose a minimal compatible surface that callers actually
+ * use: `exited`, `exitCode`, and `stdout`/`stderr` as `ReadableStream`-like
+ * objects with `text()` and `bytes()` methods.
+ */
+export interface BunCompatSpawnOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    stdin?: 'inherit' | 'ignore' | 'pipe';
+    stdout?: 'inherit' | 'ignore' | 'pipe';
+    stderr?: 'inherit' | 'ignore' | 'pipe';
+    timeout?: number;
+}
+export interface BunCompatStream {
+    text(): Promise<string>;
+    bytes(): Promise<Uint8Array>;
+    /**
+     * Returns a Web ReadableStream reader for incremental, bounded
+     * consumption — matches the Bun runtime's `proc.stdout.getReader()`
+     * shape, used by the test-runner's `readBoundedStream` to cap memory
+     * for multi-GB test output.
+     */
+    getReader(): ReadableStreamDefaultReader<Uint8Array>;
+}
+export interface BunCompatSubprocess {
+    readonly stdout: BunCompatStream;
+    readonly stderr: BunCompatStream;
+    readonly exited: Promise<number>;
+    exitCode: number | null;
+    kill(signal?: NodeJS.Signals | number): void;
+}
+export declare function bunSpawn(cmd: string[], options?: BunCompatSpawnOptions): BunCompatSubprocess;
+export interface BunCompatSyncResult {
+    stdout: Uint8Array;
+    stderr: Uint8Array;
+    exitCode: number;
+    success: boolean;
+}
+export declare function bunSpawnSync(cmd: string[] | {
+    cmd: string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    stdin?: string | Uint8Array;
+    timeout?: number;
+}, options?: BunCompatSpawnOptions): BunCompatSyncResult;

package/dist/utils/timeout.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Timeout primitives used by the plugin init path.
+ *
+ * Hard rule: every timer scheduled here must call `unref()` so it never holds
+ * the process open, and every Promise.race must clear the timer in `finally`
+ * so it does not leak the timer reference after the racer settles.
+ */
+/**
+ * Race a promise against a timeout. The timer is cleared in `finally` so the
+ * Node event loop is not pinned open after the race resolves. The returned
+ * promise resolves to the racer's value, or rejects with the supplied
+ * `timeoutError` if the deadline elapses first.
+ *
+ * @param promise        Long-running operation to race.
+ * @param ms             Deadline in milliseconds.
+ * @param timeoutError   Error thrown when the deadline elapses.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, timeoutError: Error): Promise<T>;
+/**
+ * Yield to the macrotask queue. Works under both Node and Bun runtimes,
+ * unlike `setImmediate` which is Node-only.
+ */
+export declare function yieldToEventLoop(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.0.2",
+	"version": "7.0.3",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -45,7 +45,8 @@
 		"format": "biome format . --write",
 		"check": "biome check --write .",
 		"dev": "bun run build && opencode",
-		"prepublishOnly": "bun run build"
+		"prepublishOnly": "bun run build",
+		"repro:704": "node scripts/repro-704.mjs"
 	},
 	"dependencies": {
 		"@opencode-ai/plugin": "^1.1.53",