@polderlabs/bizar-plugin 0.5.4 → 0.6.0

package/index.ts

@@ -109,6 +109,7 @@ import {
 } from "./src/options.js";
 
 import { ServeLifecycle } from "./src/serve.js";
+import { writeServeInfo, clearServeInfo } from "./src/serve-info.js";
 import { HttpClient } from "./src/http-client.js";
 import { EventStream } from "./src/event-stream.js";
 import { BackgroundStateStore, type BackgroundState } from "./src/background-state.js";
@@ -216,6 +217,7 @@ let instanceManagerHandle: InstanceManager | null = null;
 let serveHandle: ServeLifecycle | null = null;
 let streamHandle: EventStream | null = null;
 let loggerHandle: Logger | null = null;
+const signalHandlerRefs = new Map<"SIGTERM" | "SIGINT", () => void>();
 
 // --- Plugin entry point ---------------------------------------------------
 
@@ -359,6 +361,20 @@ async function init(
       });
       serveHandle = serve;
       const serveInfo = await serve.start();
+      // v3.5.7 — Persist serve-info so the dashboard can talk to us
+      try {
+        writeServeInfo(options.stateDir, {
+          baseUrl: serveInfo.baseUrl,
+          port: serveInfo.port,
+          password: serveInfo.password,
+          worktree: serveInfo.worktree,
+          pid: serveInfo.pid,
+          startedAt: serveInfo.startedAt,
+        }, logger);
+        logger.info(`[bizar] wrote serve-info to ${options.stateDir}/serve.json`);
+      } catch (err) {
+        logger.warn(`[bizar] failed to write serve-info: ${err instanceof Error ? err.message : String(err)}`);
+      }
       const http = new HttpClient({
         baseUrl: `http://127.0.0.1:${serveInfo.port}`,
         password: serveInfo.password,
@@ -437,7 +453,7 @@ async function init(
 
   // --- Signal traps (spec §5.3) ------------------------------------------
 
-  installSignalHandlers(logger, instanceManager, serve, stream);
+  installSignalHandlers(logger, instanceManager, serve, stream, options.stateDir);
 
   const ctx: RuntimeContext = {
     logger,
@@ -462,6 +478,7 @@ function installSignalHandlers(
   instanceManager: InstanceManager | null,
   serve: ServeLifecycle | null,
   stream: EventStream | null,
+  stateDir: string,
 ): void {
   const onSignal = async (sig: "SIGTERM" | "SIGINT") => {
     if (shuttingDown) return;
@@ -503,7 +520,10 @@ function installSignalHandlers(
       }
     }
 
-    // 4. Exit. (Note: the host may keep the process alive if other work
+    // 4. Clear serve-info so the dashboard doesn't try to talk to a dead serve.
+    clearServeInfo(stateDir, logger);
+
+    // 5. Exit. (Note: the host may keep the process alive if other work
     //    is pending, but for the plugin process this is the end.)
     try {
       process.exit(0);
@@ -516,14 +536,19 @@ function installSignalHandlers(
   // duplicate handlers. Use `process.once` so each handler runs at most
   // once per signal; the `shuttingDown` guard catches reentry.
   for (const sig of ["SIGTERM", "SIGINT"] as const) {
-    try {
-      process.removeAllListeners(sig);
-    } catch {
-      // ignore
+    const previous = signalHandlerRefs.get(sig);
+    if (previous) {
+      try {
+        process.removeListener(sig, previous);
+      } catch {
+        // ignore
+      }
     }
-    process.on(sig, () => {
+    const handler = () => {
       void onSignal(sig);
-    });
+    };
+    signalHandlerRefs.set(sig, handler);
+    process.once(sig, handler);
   }
 }
 
@@ -1070,6 +1095,7 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
           );
         }
       }
+      clearServeInfo(ctx.options.stateDir, ctx.logger);
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-plugin",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Bizar opencode plugin — loop detection, status reporting, handoff signal, background agents, and slash commands + visual plan flow for subagent activity",
   "type": "module",
   "main": "./index.ts",

package/src/background-state.ts

@@ -389,11 +389,22 @@ export class BackgroundStateStore {
    */
   async save(state: BackgroundState): Promise<void> {
     if (!this.ensureDir()) return;
+    return withLock(this.locks, state.instanceId, () => this.saveUnlocked(state));
+  }
+
+  /**
+   * Persist a `BackgroundState` without acquiring the per-instance mutex.
+   *
+   * Callers must already hold the lock for `state.instanceId`. This exists
+   * for internal code paths such as `InstanceManager.update()` that need to
+   * mutate in-memory state while holding the same lock; calling `save()`
+   * there would re-enter the mutex and deadlock the promise chain.
+   */
+  saveUnlocked(state: BackgroundState): Promise<void> {
+    if (!this.ensureDir()) return Promise.resolve();
     const filePath = backgroundStateFilePath(this.stateDir, state.instanceId);
-    return withLock(this.locks, state.instanceId, () => {
-      writeStateAtomic(filePath, state, this.logger);
-      return Promise.resolve();
-    });
+    writeStateAtomic(filePath, state, this.logger);
+    return Promise.resolve();
   }
 
   /**

package/src/background.ts

@@ -139,6 +139,7 @@ const STALL_CHECK_INTERVAL_MS = 15_000;
  */
 export class InstanceManager {
   private instances = new Map<string, BackgroundState>();
+  private eventUnsubscribers = new Map<string, () => void>();
   private addLock: Promise<unknown> = Promise.resolve();
   private stateStore: BackgroundStateStore;
   private maxConcurrent: number;
@@ -193,6 +194,7 @@ export class InstanceManager {
       () => void this.runStallAndLoopChecks(),
       STALL_CHECK_INTERVAL_MS,
     );
+    this.stallCheckerTimer.unref?.();
   }
 
   // --- Getters ------------------------------------------------------------
@@ -376,8 +378,11 @@ export class InstanceManager {
       if (TERMINAL_STATUSES.has(patch.status ?? current.status) && !current.completedAt) {
         current.completedAt = Date.now();
       }
+      if (TERMINAL_STATUSES.has(current.status)) {
+        this.detachEventHandler(instanceId);
+      }
       try {
-        await this.stateStore.save(current);
+        await this.stateStore.saveUnlocked(current);
       } catch (err: unknown) {
         this.logger.warn(
           `bizar: failed to persist update for ${instanceId}: ${
@@ -704,13 +709,26 @@ export class InstanceManager {
   // --- Internal: per-session event handler -------------------------------
 
   public attachEventHandler(inst: BackgroundState): () => void {
+    this.detachEventHandler(inst.instanceId);
     const handler: SessionEventHandler = (ev: StreamEvent) => {
       void this.handleInstanceEvent(inst.instanceId, ev);
     };
     const unsubscribe = this.stream.onSessionEvent(inst.sessionId, handler);
+    this.eventUnsubscribers.set(inst.instanceId, unsubscribe);
     return unsubscribe;
   }
 
+  private detachEventHandler(instanceId: string): void {
+    const unsubscribe = this.eventUnsubscribers.get(instanceId);
+    if (!unsubscribe) return;
+    try {
+      unsubscribe();
+    } catch {
+      // ignore
+    }
+    this.eventUnsubscribers.delete(instanceId);
+  }
+
   private async handleInstanceEvent(
     instanceId: string,
     ev: StreamEvent,

package/src/commands-impl.ts

@@ -112,6 +112,9 @@ export interface ExecuteResult {
  *                    list so we can include status + lastEdited).
  * `open_plan_url` — just returns the parser's response (the parser
  *                    already built the URL). No I/O.
+ * `launch_dashboard` — spawns `bizar dashboard start` as a detached
+ *                    child process. Reads the port file back and
+ *                    appends the URL to the parser's response.
  * `tool_invocation` — delegates to `executeToolInvocation`.
  *
  * Never throws. All failures become `responseOverride` strings.
@@ -131,6 +134,8 @@ export async function executeSideEffect(
         // No I/O — the parser already built the URL. The chat hook
         // uses the parser's response unchanged.
         return {};
+      case "launch_dashboard":
+        return await executeLaunchDashboard(sideEffect.defaultPort, ctx);
       case "tool_invocation":
         return await executeToolInvocation(sideEffect, ctx, opts);
       default: {
@@ -188,6 +193,96 @@ async function executeListPlans(
   };
 }
 
+/**
+ * Launch the Bizar dashboard as a detached child process.
+ *
+ * We spawn `bizar dashboard start` with `detached: true` and `unref()`
+ * so the child's lifetime is independent of the plugin host. We then
+ * poll the port file (written by the child) for up to ~3s and append
+ * the URL to the parser's response. If anything goes wrong we surface
+ * a clear error so the user knows where to look.
+ *
+ * Never throws — all failures become responseSuffix/Override.
+ */
+async function executeLaunchDashboard(
+  defaultPort: number,
+  ctx: ExecutorContext,
+): Promise<ExecuteResult> {
+  const { spawn } = await import("node:child_process");
+  const { existsSync, readFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { homedir } = await import("node:os");
+
+  const portFile = join(homedir(), ".config", "bizar", "dashboard.port");
+
+  // If a dashboard is already running, just report its URL.
+  if (existsSync(portFile)) {
+    try {
+      const port = readFileSync(portFile, "utf8").trim();
+      if (port && Number.isFinite(Number(port))) {
+        return {
+          responseSuffix:
+            `\n✓ Dashboard already running at http://localhost:${port}/`,
+        };
+      }
+    } catch {
+      /* fall through to spawn */
+    }
+  }
+
+  try {
+    // `bizar` is on $PATH for global installs; for npx / local installs
+    // we'd want to resolve to the package's bin. Spawn `bizar` directly
+    // for now — the user's $PATH is the source of truth.
+    const child = spawn("bizar", ["dashboard", "start"], {
+      detached: true,
+      stdio: "ignore",
+      cwd: ctx.worktree,
+    });
+    child.on("error", (err) => {
+      ctx.logger.warn(`bizar: dashboard spawn error: ${err.message}`);
+    });
+    child.unref();
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      responseOverride:
+        `Could not launch the Bizar dashboard: ${msg}\n` +
+        `Try running \`bizar dashboard start\` in your terminal.`,
+    };
+  }
+
+  // Poll the port file briefly so the response carries the live URL.
+  const deadline = Date.now() + 3000;
+  let resolvedPort: number | null = null;
+  while (Date.now() < deadline) {
+    if (existsSync(portFile)) {
+      try {
+        const port = Number(readFileSync(portFile, "utf8").trim());
+        if (Number.isFinite(port) && port > 0) {
+          resolvedPort = port;
+          break;
+        }
+      } catch {
+        /* ignore — keep polling */
+      }
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+
+  if (resolvedPort === null) {
+    return {
+      responseSuffix:
+        `\n✓ Dashboard launching… (preferred port ${defaultPort}, ` +
+        `fallback to a free port). The browser will open shortly.`,
+    };
+  }
+
+  return {
+    responseSuffix: `\n✓ Dashboard running at http://localhost:${resolvedPort}/`,
+  };
+}
+
 // --- executeToolInvocation -----------------------------------------------
 
 /**

package/src/commands.ts

@@ -60,6 +60,10 @@ export type SideEffect =
   | {
       kind: "list_plans";
     }
+  | {
+      kind: "launch_dashboard";
+      defaultPort: number;
+    }
   | {
       kind: "tool_invocation";
       toolName: string;
@@ -264,6 +268,8 @@ export function parseSlashCommand(
       return handleVisualPlan(rest, ctx);
     case "plan":
       return handlePlan(rest, ctx);
+    case "bizar":
+      return handleBizar(rest, ctx);
     case "help":
     case "commands":
       return helpResult();
@@ -845,6 +851,53 @@ function handlePlanWait(args: string[]): SlashCommandResult {
   };
 }
 
+// --- /bizar --------------------------------------------------------------
+
+/**
+ * v2.5.0 — `/bizar [args]` launches the dashboard or routes a sub-request.
+ *
+ * Behavior:
+ *   - `/bizar` (no args) — emits a `launch_dashboard` side-effect. The
+ *     executor spawns `bizar dashboard start` as a detached child
+ *     process, then the host surfaces the URL in the response.
+ *   - `/bizar <args>` — passes the args to the menu command file. Today
+ *     the menu routes intent (`/explain`, `/plan`, `/audit`, etc.); the
+ *     response is the menu's natural-language routing advice.
+ *
+ * Note: the menu text lives in `config/commands/bizar.md` and is shipped
+ * via the CLI package. The plugin only handles the no-arg case for the
+ * side-effect; with args we return a short pointer so the user knows
+ * where the routing table lives.
+ */
+function handleBizar(arg: string, ctx: ParseContext): SlashCommandResult {
+  const trimmed = arg.trim();
+
+  if (trimmed === "") {
+    const port = ctx.defaultPort ?? 4321;
+    return {
+      handled: true,
+      response:
+        `🪩 Bizar dashboard launching in the background.\n` +
+        `Visit http://localhost:${port}/ once the server is ready.\n` +
+        `(If the browser did not open automatically, click the URL above.)`,
+      sideEffect: {
+        kind: "launch_dashboard",
+        defaultPort: port,
+      },
+    };
+  }
+
+  // With args, defer to the menu command file shipped with the CLI.
+  return {
+    handled: true,
+    response:
+      `🪩 Bizar routing your request: "${trimmed}"\n` +
+      `The menu command file (config/commands/bizar.md) maps intents like\n` +
+      `"explain X", "plan Y", "review PR", "audit", "learn", and "init"\n` +
+      `to the right Bizar action. For the dashboard, use \`/bizar\` with no args.`,
+  };
+}
+
 // --- /help ----------------------------------------------------------------
 
 function helpResult(): SlashCommandResult {

package/src/plan-fs.ts

@@ -43,7 +43,7 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import type { Logger } from "./logger.js";
 
@@ -146,7 +146,7 @@ function writeJsonAtomic(
 ): { ok: true } | { ok: false; error: string } {
   const tmp = `${filePath}.tmp`;
   try {
-    mkdirSync(join(filePath, ".."), { recursive: true });
+    mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
     renameSync(tmp, filePath);
     return { ok: true };

package/src/serve-info.ts

@@ -0,0 +1,228 @@
+/**
+ * serve-info.ts
+ *
+ * v0.5.4 (bug #3) — Publish the opencode-serve connection details to a
+ * small on-disk file so out-of-process consumers (the Bizar dashboard
+ * server, the TUI, hooks, etc.) can talk to the same opencode serve child
+ * the plugin owns.
+ *
+ * Why this exists:
+ *   The plugin owns the `opencode serve` child process. It picks a
+ *   random port (or the operator's `BIZAR_SERVE_PORT`) and generates
+ *   a 32-byte `OPENCODE_SERVER_PASSWORD` on every start. Until now the
+ *   only consumer of that child was the plugin itself (via
+ *   {@link HttpClient} / {@link EventStream}). The dashboard, which
+ *   lives in a separate process, had no way to reach the child — its
+ *   `DELETE /background/:id` could only kill a tmux attach, never the
+ *   underlying opencode session.
+ *
+ * What this writes:
+ *   `<stateDir>/serve.json` containing:
+ *     {
+ *       baseUrl: "http://127.0.0.1:4097",
+ *       port: 4097,
+ *       password: "<32-byte secret base64>",
+ *       worktree: "/path/to/cwd",
+ *       pid: 12345,
+ *       startedAt: 1700000000000
+ *     }
+ *
+ * The dashboard's `serve-info.mjs` looks for this file in the same
+ * multi-path pattern as `BG_DIRS` and uses it to issue
+ * `POST /api/session/{id}/abort` against the same opencode child the
+ * plugin is using.
+ *
+ * Lifecycle:
+ *   - `write(info)` — called once after `ServeLifecycle.start()`
+ *     succeeds. Atomic write via tmp+rename.
+ *   - `clear()` — called from the plugin's signal handlers and from
+ *     `shutdownAll` paths so a stale file from a dead serve does not
+ *     confuse the dashboard.
+ *   - `read()` — synchronous helper used by tests and by the dashboard's
+ *     process (out-of-process via `serve-info.mjs`).
+ *
+ * Security note:
+ *   The file contains the serve password. `stateDir` defaults to
+ *   `~/.cache/bizar`, which is mode 0700 on most Linux systems but
+ *   not enforced. We refuse to write to a path inside any of the
+ *   `~/.ssh`, `~/.gnupg`, `~/.aws`, `~/.kube` directories (same refusal
+ *   as `options.ts`).
+ */
+
+import { writeFileSync, renameSync, unlinkSync, existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { expandHome, findSecretDirMatch } from "./options.js";
+
+// --- Public types ---------------------------------------------------------
+
+/**
+ * Connection info for one running `opencode serve` child. See the
+ * module header for the wire format.
+ */
+export interface ServeInfo {
+  baseUrl: string;
+  port: number;
+  password: string;
+  worktree: string;
+  pid: number;
+  startedAt: number;
+}
+
+// --- Logger interface -----------------------------------------------------
+
+/**
+ * Minimal Logger interface — matches the shape in `state.ts` / `logger.ts`.
+ */
+export interface Logger {
+  debug(message: string): void;
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+}
+
+// --- File-path helpers ----------------------------------------------------
+
+function infoFilePath(stateDir: string): string {
+  return path.join(expandHome(stateDir), "serve.json");
+}
+
+// --- Read -----------------------------------------------------------------
+
+/**
+ * Synchronous read of the serve-info file. Returns `null` if the file is
+ * missing, unreadable, malformed, or fails the schema check. Never throws.
+ *
+ * Intended for callers in the same process as the plugin. Out-of-process
+ * consumers (the dashboard server) should use `serve-info.mjs`, which has
+ * the same logic but lives in `.mjs`.
+ */
+export function readServeInfo(stateDir: string, _logger?: Logger): ServeInfo | null {
+  const file = infoFilePath(stateDir);
+  if (!existsSync(file)) return null;
+  try {
+    const raw = readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    if (
+      typeof parsed.baseUrl !== "string" ||
+      typeof parsed.port !== "number" ||
+      typeof parsed.password !== "string" ||
+      typeof parsed.worktree !== "string" ||
+      typeof parsed.pid !== "number" ||
+      typeof parsed.startedAt !== "number"
+    ) {
+      return null;
+    }
+    return {
+      baseUrl: parsed.baseUrl,
+      port: parsed.port,
+      password: parsed.password,
+      worktree: parsed.worktree,
+      pid: parsed.pid,
+      startedAt: parsed.startedAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// --- Write / clear --------------------------------------------------------
+
+/**
+ * Atomically write the serve-info file. The temp file is renamed into
+ * place so a concurrent reader never sees a half-written JSON. Returns
+ * silently on success and logs a warning on failure.
+ *
+ * Refuses to write if `stateDir` resolves inside a secret directory
+ * (`~/.ssh`, `~/.gnupg`, `~/.aws`, `~/.kube`).
+ */
+export function writeServeInfo(
+  stateDir: string,
+  info: ServeInfo,
+  logger: Logger,
+): boolean {
+  // §6.4 — refuse to write if stateDir is inside a secret dir. Mirrors
+  // the same refusal logic in `options.ts` so a misconfigured stateDir
+  // cannot cause the password to leak into an unsafe location.
+  const secretMatch = findSecretDirMatch(stateDir);
+  if (secretMatch !== null) {
+    logger.error(
+      `bizar: refusing to write serve-info file — stateDir is inside secret dir ${secretMatch}`,
+    );
+    return false;
+  }
+  const finalPath = infoFilePath(stateDir);
+  const tmpPath = `${finalPath}.tmp`;
+  try {
+    writeFileSync(tmpPath, JSON.stringify(info, null, 2), "utf8");
+    renameSync(tmpPath, finalPath);
+    logger.debug(
+      `bizar: wrote serve-info to ${finalPath} (port=${info.port}, pid=${info.pid})`,
+    );
+    return true;
+  } catch (err: unknown) {
+    logger.warn(
+      `bizar: failed to write serve-info at ${finalPath}: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+    try {
+      if (existsSync(tmpPath)) unlinkSync(tmpPath);
+    } catch {
+      // ignore
+    }
+    return false;
+  }
+}
+
+/**
+ * Best-effort delete of the serve-info file. Idempotent — missing files
+ * are not an error. Used by signal handlers and the shutdown path so the
+ * dashboard does not try to talk to a dead serve.
+ */
+export function clearServeInfo(stateDir: string, logger: Logger): void {
+  const file = infoFilePath(stateDir);
+  try {
+    if (existsSync(file)) {
+      unlinkSync(file);
+      logger.debug(`bizar: cleared serve-info at ${file}`);
+    }
+  } catch (err: unknown) {
+    logger.warn(
+      `bizar: failed to clear serve-info at ${file}: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+  }
+}
+
+/**
+ * Convenience: resolve the path where the file would be written, without
+ * writing. Exposed for diagnostics and for tests that want to clean up.
+ */
+export function serveInfoFilePath(stateDir: string): string {
+  return infoFilePath(stateDir);
+}
+
+// Re-export for callers that want the raw `expandHome` from this module.
+export { expandHome };
+
+// --- Helpers --------------------------------------------------------------
+
+/**
+ * Defensive helper: validate that the resolved stateDir is writable in
+ * the current process. Returns true on success. Used by `writeServeInfo`'s
+ * call sites that want to log a single summary line before touching disk.
+ */
+export function canWriteStateDir(stateDir: string): boolean {
+  try {
+    const expanded = expandHome(stateDir);
+    if (expanded === os.homedir()) return true;
+    // We don't actually touch the disk here — the caller wants to know
+    // whether `mkdirSync` is likely to succeed. Just check the path is
+    // absolute after expansion.
+    return path.isAbsolute(expanded);
+  } catch {
+    return false;
+  }
+}

package/src/serve.ts

@@ -56,6 +56,9 @@ export interface ServeInfo {
   pid: number;
   port: number;
   password: string;
+  baseUrl: string;
+  worktree: string;
+  startedAt: number;
 }
 
 /**
@@ -207,11 +210,19 @@ export class ServeLifecycle {
     }
 
     this.attachExitHandler();
+    const startedAt = Date.now();
     this._logger.info(
       `bizar: opencode serve ready on http://127.0.0.1:${boundPort} (pid=${proc.pid})`,
     );
 
-    return { pid: proc.pid, port: boundPort, password };
+    return {
+      pid: proc.pid,
+      port: boundPort,
+      password,
+      baseUrl: `http://127.0.0.1:${boundPort}`,
+      worktree: this._worktree,
+      startedAt,
+    };
   }
 
   // --- Stop ---------------------------------------------------------------

package/tests/attach-handler-bug.test.ts

@@ -76,8 +76,8 @@ class InMemoryStateStore {
 
 // We import the real InstanceManager after the stubs are defined so the
 // test file fails fast if the real signature changes.
-import { InstanceManager } from "../src/background.ts";
-import type { BackgroundState } from "../src/background-state.ts";
+import { InstanceManager } from "../src/background.js";
+import type { BackgroundState } from "../src/background-state.js";
 
 function makeDraft(overrides: Partial<BackgroundState> = {}): BackgroundState {
   return {

package/tests/event-stream.test.ts

@@ -65,7 +65,7 @@ type Event = EventSessionIdle | EventSessionError | EventMessagePartUpdated;
 class FakeEventStream {
   private handlers = new Map<string, Array<(event: Event) => void>>();
   private sessions = new Map<string, string>(); // instanceId → sessionId
-  private instances = new Map<string, BackgroundState>();
+  public instances = new Map<string, BackgroundState>();
   private closed = false;
 
   /** Register an instance's sessionId for event routing */
@@ -406,4 +406,4 @@ describe("EventStream interface contract", () => {
     expect(typeof stream.onSessionEvent).toBe("function");
     expect(typeof stream.close).toBe("function");
   });
-});
+});