whale-code 6.5.10 → 6.6.0

package/dist/cli/services/tools/__tests__/web-tools.test.js

@@ -1,285 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// Mocks
-// ============================================================================
-
-vi.mock("node:dns/promises", () => ({
-  lookup: vi.fn(async hostname => {
-    const map = {
-      "example.com": "93.184.216.34",
-      "internal.local": "192.168.1.1",
-      "evil-redirect.com": "10.0.0.1",
-      "safe-site.org": "151.101.1.140"
-    };
-    if (map[hostname]) return {
-      address: map[hostname],
-      family: 4
-    };
-    throw new Error(`DNS lookup failed for ${hostname}`);
-  })
-}));
-vi.mock("../../auth-service.js", () => ({
-  getValidToken: vi.fn(async () => null),
-  createAuthenticatedClient: vi.fn()
-}));
-vi.mock("../../config-store.js", () => ({
-  resolveConfig: vi.fn(() => ({}))
-}));
-
-// We mock global fetch
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-import { isBlockedUrl, webFetch } from "../web-tools.js";
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-// ============================================================================
-// isBlockedUrl — SSRF protection
-// ============================================================================
-
-describe("isBlockedUrl", () => {
-  it("blocks localhost", () => {
-    expect(isBlockedUrl("http://localhost/admin")).toBe(true);
-    expect(isBlockedUrl("http://127.0.0.1/admin")).toBe(true);
-    expect(isBlockedUrl("http://[::1]/admin")).toBe(true);
-    expect(isBlockedUrl("http://0.0.0.0/admin")).toBe(true);
-  });
-  it("blocks private IPv4 ranges (10.x.x.x)", () => {
-    expect(isBlockedUrl("http://10.0.0.1/api")).toBe(true);
-    expect(isBlockedUrl("http://10.255.255.255/api")).toBe(true);
-  });
-  it("blocks private IPv4 ranges (172.16-31.x.x)", () => {
-    expect(isBlockedUrl("http://172.16.0.1/api")).toBe(true);
-    expect(isBlockedUrl("http://172.31.255.255/api")).toBe(true);
-  });
-  it("does not block 172.15.x.x (public)", () => {
-    expect(isBlockedUrl("http://172.15.0.1/api")).toBe(false);
-  });
-  it("blocks private IPv4 ranges (192.168.x.x)", () => {
-    expect(isBlockedUrl("http://192.168.1.1/api")).toBe(true);
-    expect(isBlockedUrl("http://192.168.0.100/api")).toBe(true);
-  });
-  it("blocks cloud metadata endpoint", () => {
-    expect(isBlockedUrl("http://169.254.169.254/latest/meta-data")).toBe(true);
-    expect(isBlockedUrl("http://169.254.1.1/")).toBe(true);
-  });
-  it("blocks IPv6-mapped IPv4", () => {
-    expect(isBlockedUrl("http://[::ffff:127.0.0.1]/api")).toBe(true);
-  });
-  it("blocks decimal IP representations", () => {
-    expect(isBlockedUrl("http://2130706433/api")).toBe(true); // 127.0.0.1
-  });
-  it("blocks hex IP representations", () => {
-    expect(isBlockedUrl("http://0x7f000001/api")).toBe(true);
-  });
-  it("blocks octal IPs", () => {
-    expect(isBlockedUrl("http://0177.0.0.1/api")).toBe(true);
-  });
-  it("blocks short zero addresses", () => {
-    expect(isBlockedUrl("http://0/")).toBe(true);
-    expect(isBlockedUrl("http://0.0/")).toBe(true);
-    expect(isBlockedUrl("http://0.0.0/")).toBe(true);
-  });
-  it("blocks .internal and .local TLDs", () => {
-    expect(isBlockedUrl("http://something.internal/api")).toBe(true);
-    expect(isBlockedUrl("http://printer.local/status")).toBe(true);
-  });
-  it("blocks non-HTTP protocols", () => {
-    expect(isBlockedUrl("ftp://example.com/file")).toBe(true);
-    expect(isBlockedUrl("file:///etc/passwd")).toBe(true);
-    expect(isBlockedUrl("gopher://example.com")).toBe(true);
-  });
-  it("allows public HTTP URLs", () => {
-    expect(isBlockedUrl("http://example.com")).toBe(false);
-    expect(isBlockedUrl("https://google.com")).toBe(false);
-    expect(isBlockedUrl("https://github.com/user/repo")).toBe(false);
-  });
-  it("blocks IPv6 private addresses", () => {
-    expect(isBlockedUrl("http://[fe80::1]/api")).toBe(true);
-    expect(isBlockedUrl("http://[fc00::1]/api")).toBe(true);
-    expect(isBlockedUrl("http://[fd12::1]/api")).toBe(true);
-  });
-  it("returns true for malformed URLs", () => {
-    expect(isBlockedUrl("not-a-url")).toBe(true);
-    expect(isBlockedUrl("")).toBe(true);
-  });
-});
-
-// ============================================================================
-// webFetch
-// ============================================================================
-
-describe("webFetch", () => {
-  it("requires url parameter", async () => {
-    const result = await webFetch({});
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("url is required");
-  });
-  it("blocks fetch to localhost", async () => {
-    const result = await webFetch({
-      url: "http://127.0.0.1/admin"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("URL blocked");
-  });
-  it("blocks fetch to private IPs", async () => {
-    const result = await webFetch({
-      url: "http://192.168.1.1/admin"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("URL blocked");
-  });
-  it("fetches and returns HTML as text", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({
-        "content-type": "text/html"
-      }),
-      text: async () => "<html><body><h1>Hello</h1><p>World</p></body></html>"
-    });
-    const result = await webFetch({
-      url: "https://example.com"
-    });
-    expect(result.success).toBe(true);
-    expect(result.output).toContain("Hello");
-    expect(result.output).toContain("World");
-  });
-  it("returns JSON pretty-printed", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({
-        "content-type": "application/json"
-      }),
-      text: async () => '{"key":"value","nested":{"a":1}}'
-    });
-    const result = await webFetch({
-      url: "https://api.example.com/data"
-    });
-    expect(result.success).toBe(true);
-    expect(result.output).toContain('"key": "value"');
-  });
-  it("returns plain text as-is", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({
-        "content-type": "text/plain"
-      }),
-      text: async () => "plain text content here"
-    });
-    const result = await webFetch({
-      url: "https://example.com/file.txt"
-    });
-    expect(result.success).toBe(true);
-    expect(result.output).toBe("plain text content here");
-  });
-  it("handles HTTP errors", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      statusText: "Not Found",
-      headers: new Headers()
-    });
-    const result = await webFetch({
-      url: "https://example.com/missing"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("404");
-  });
-  it("handles redirect to blocked address", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 302,
-      headers: new Headers({
-        location: "http://192.168.1.1/admin"
-      })
-    });
-    const result = await webFetch({
-      url: "https://example.com/redirect"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("Redirect target is a blocked address");
-  });
-  it("handles redirect without Location header", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 301,
-      headers: new Headers()
-    });
-    const result = await webFetch({
-      url: "https://example.com/redirect"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("no Location header");
-  });
-  it("handles too many redirects", async () => {
-    // First fetch -> 302 redirect to safe URL
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 302,
-      headers: new Headers({
-        location: "https://example.com/step2"
-      })
-    });
-    // Second fetch -> still redirecting
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 302,
-      headers: new Headers({
-        location: "https://example.com/step3"
-      })
-    });
-    const result = await webFetch({
-      url: "https://example.com/chain"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("Too many redirects");
-  });
-  it("handles fetch errors (network failures)", async () => {
-    mockFetch.mockRejectedValueOnce(new Error("Network error"));
-    const result = await webFetch({
-      url: "https://example.com"
-    });
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("Fetch error");
-    expect(result.output).toContain("Network error");
-  });
-  it("truncates very long HTML content", async () => {
-    const longHtml = `<html><body><p>${"x".repeat(600_000)}</p></body></html>`;
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({
-        "content-type": "text/html"
-      }),
-      text: async () => longHtml
-    });
-    const result = await webFetch({
-      url: "https://example.com/huge"
-    });
-    expect(result.success).toBe(true);
-    expect(result.output).toContain("safety truncated");
-  });
-  it("truncates JSON at 80k chars", async () => {
-    const bigJson = JSON.stringify({
-      data: "x".repeat(100_000)
-    });
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({
-        "content-type": "application/json"
-      }),
-      text: async () => bigJson
-    });
-    const result = await webFetch({
-      url: "https://api.example.com/big"
-    });
-    expect(result.success).toBe(true);
-    expect(result.output.length).toBeLessThanOrEqual(80_000);
-  });
-});

package/dist/cli/services/tools/shell-exec.test.js

@@ -1,148 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-// Mock child_process.spawn so commands are NOT actually executed.
-// We only need to test the safety filter (blocked vs allowed), not run real commands.
-vi.mock("child_process", async () => {
-  const actual = await vi.importActual("child_process");
-  return {
-    ...actual,
-    spawn: vi.fn(() => {
-      // Return a fake child process that immediately exits with code 0
-      const {
-        EventEmitter
-      } = require("events");
-      const {
-        Readable
-      } = require("stream");
-      const child = new EventEmitter();
-      child.stdout = new Readable({
-        read() {
-          this.push(null);
-        }
-      });
-      child.stderr = new Readable({
-        read() {
-          this.push(null);
-        }
-      });
-      child.stdin = {
-        write: vi.fn(),
-        end: vi.fn()
-      };
-      child.pid = 99999;
-      child.kill = vi.fn();
-      // Emit close on next tick so the promise resolves
-      setTimeout(() => child.emit("exit", 0), 5);
-      return child;
-    })
-  };
-});
-vi.mock("../sandbox.js", () => ({
-  sandboxCommand: vi.fn(cmd => ({
-    wrapped: cmd,
-    profilePath: null
-  })),
-  cleanupSandbox: vi.fn()
-}));
-vi.mock("../background-processes.js", () => ({
-  spawnBackground: vi.fn(async () => ({
-    status: "running",
-    message: "ok"
-  })),
-  readProcessOutput: vi.fn(() => ({
-    status: "completed",
-    exitCode: 0,
-    newOutput: "ok",
-    newErrors: ""
-  })),
-  killProcess: vi.fn(() => ({
-    success: true,
-    message: "killed"
-  })),
-  listProcesses: vi.fn(() => [])
-}));
-vi.mock("../agent-events.js", () => ({
-  getGlobalEmitter: vi.fn(() => ({
-    emitToolOutput: vi.fn()
-  }))
-}));
-vi.mock("../debug-log.js", () => ({
-  debugLog: vi.fn()
-}));
-import { runCommand } from "./shell-exec.js";
-async function allowed(cmd) {
-  const r = await runCommand({
-    command: cmd,
-    timeout: 2000
-  });
-  return !r.output.includes("blocked for safety");
-}
-async function blocked(cmd) {
-  const r = await runCommand({
-    command: cmd,
-    timeout: 2000
-  });
-  return r.output.includes("blocked for safety");
-}
-describe("BLOCKED — catastrophic", () => {
-  it("rm -rf /", async () => expect(await blocked("rm -rf /")).toBe(true));
-  it("rm -rf /*", async () => expect(await blocked("rm -rf /*")).toBe(true));
-  it("rm -fr /", async () => expect(await blocked("rm -fr /")).toBe(true));
-  it("rm -r -f /", async () => expect(await blocked("rm -r -f /")).toBe(true));
-  it("rm -rf / chained", async () => expect(await blocked("rm -rf / && echo done")).toBe(true));
-  it("rm -rf / ; cmd", async () => expect(await blocked("rm -rf / ; echo hi")).toBe(true));
-  it("rm -rf ~", async () => expect(await blocked("rm -rf ~")).toBe(true));
-  it("rm -rf ~/", async () => expect(await blocked("rm -rf ~/")).toBe(true));
-  it("rm -rf ~/*", async () => expect(await blocked("rm -rf ~/*")).toBe(true));
-  it("rm -rf ~ chained", async () => expect(await blocked("rm -rf ~ && echo done")).toBe(true));
-  it("mkfs", async () => expect(await blocked("mkfs /dev/sda1")).toBe(true));
-  it("mkfs.ext4", async () => expect(await blocked("mkfs.ext4 /dev/sda1")).toBe(true));
-  it("dd to /dev/sda", async () => expect(await blocked("dd if=/dev/zero of=/dev/sda")).toBe(true));
-  it("dd to /dev/disk0", async () => expect(await blocked("dd if=x of=/dev/disk0")).toBe(true));
-  it("dd to /dev/nvme0n1", async () => expect(await blocked("dd if=/dev/zero of=/dev/nvme0n1")).toBe(true));
-  it("> /dev/sda", async () => expect(await blocked("echo x > /dev/sda")).toBe(true));
-  it("> /dev/disk0", async () => expect(await blocked("echo x > /dev/disk0")).toBe(true));
-  it("fork bomb", async () => expect(await blocked(":(){ :|:& };:")).toBe(true));
-});
-describe("ALLOWED — full developer access", () => {
-  // rm on specific paths
-  it("rm -rf node_modules", async () => expect(await allowed("rm -rf node_modules")).toBe(true));
-  it("rm -rf /tmp/build", async () => expect(await allowed("rm -rf /tmp/build")).toBe(true));
-  it("rm -rf /Users/whale/project/nm", async () => expect(await allowed("rm -rf /Users/whale/project/node_modules")).toBe(true));
-  it("rm -rf ~/project/dist", async () => expect(await allowed("rm -rf ~/project/dist")).toBe(true));
-  it("rm -rf ~/Downloads/old", async () => expect(await allowed("rm -rf ~/Downloads/old-stuff")).toBe(true));
-  it("rm -rf ~/.npm-cache", async () => expect(await allowed("rm -rf ~/.npm-cache")).toBe(true));
-  it("rm -rf /var/tmp/cache", async () => expect(await allowed("rm -rf /var/tmp/cache")).toBe(true));
-  it("rm file.txt", async () => expect(await allowed("rm file.txt")).toBe(true));
-  // chmod / chown
-  it("chmod 777 /tmp/test", async () => expect(await allowed("chmod 777 /tmp/test")).toBe(true));
-  it("chmod -R 777 /tmp/test", async () => expect(await allowed("chmod -R 777 /tmp/test")).toBe(true));
-  it("chown -R user ~/.npm", async () => expect(await allowed("chown -R whale ~/.npm")).toBe(true));
-  it("chown -R user /Users/.npm-cache", async () => expect(await allowed("chown -R whale /Users/whale/.npm-cache")).toBe(true));
-  it("sudo chown -R $(whoami) ~/.npm", async () => expect(await allowed("sudo chown -R $(whoami) ~/.npm")).toBe(true));
-  // npm / node
-  it("npm install", async () => expect(await allowed("npm install")).toBe(true));
-  it("npm run build", async () => expect(await allowed("npm run build")).toBe(true));
-  it("npm run dev", async () => expect(await allowed("npm run dev")).toBe(true));
-  it("npm test", async () => expect(await allowed("npm test")).toBe(true));
-  it("npm cache clean --force", async () => expect(await allowed("npm cache clean --force")).toBe(true));
-  it("node -e with require+exec", async () => expect(await allowed("node -e 'require(\"child_process\").execSync(\"ls\")'")).toBe(true));
-  // curl/wget including pipe to bash
-  it("curl | bash install", async () => expect(await allowed("curl -fsSL https://bun.sh/install | bash")).toBe(true));
-  it("wget | bash", async () => expect(await allowed("wget -qO- https://example.com/install.sh | bash")).toBe(true));
-  // python
-  it("python -e with os.system", async () => expect(await allowed("python -e 'import os; os.system(\"ls\")'")).toBe(true));
-  // git
-  it("git push", async () => expect(await allowed("git push")).toBe(true));
-  it("git push --force", async () => expect(await allowed("git push --force")).toBe(true));
-  it("git reset --hard", async () => expect(await allowed("git reset --hard HEAD~1")).toBe(true));
-  // dd on regular files
-  it("dd to regular file", async () => expect(await allowed("dd if=/dev/urandom of=./random.bin bs=1024 count=1")).toBe(true));
-  it("dd to /dev/null", async () => expect(await allowed("dd if=./bigfile of=/dev/null bs=1M")).toBe(true));
-  it("dd to /tmp", async () => expect(await allowed("dd if=/dev/zero of=/tmp/testfile bs=1M count=10")).toBe(true));
-  // base64
-  it("base64 -d | bash", async () => expect(await allowed("base64 -d | bash")).toBe(true));
-  // system tools
-  it("brew install", async () => expect(await allowed("brew install postgresql")).toBe(true));
-  it("terraform apply", async () => expect(await allowed("terraform apply -auto-approve")).toBe(true));
-  it("docker system prune -af", async () => expect(await allowed("docker system prune -af")).toBe(true));
-});

package/dist/cli/shared/SharedTick.d.ts

@@ -1,10 +0,0 @@
-/**
- * SharedTick — single 120ms interval powering all periodic UI updates
- *
- * Spinner listeners notified every tick (120ms).
- * Elapsed listeners notified every 8th tick (~960ms).
- * Auto-start/stop based on listener count.
- */
-export declare function useSpinner(): string;
-export declare function useSharedElapsed(): number;
-export declare function useSharedElapsedSince(startTime: number): number;

package/dist/cli/shared/__tests__/markdown.test.js

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ============================================================================
-// Mocks — Theme and external dependencies
-// ============================================================================
-
-// Mock the Theme module to avoid filesystem reads for theme.json
-vi.mock("../Theme.js", () => ({
-  colors: {
-    brand: "#0A84FF",
-    brandDim: "#0071E3",
-    success: "#30D158",
-    error: "#FF453A",
-    warning: "#FF9F0A",
-    info: "#64D2FF",
-    pink: "#FF375F",
-    purple: "#BF5AF2",
-    indigo: "#5E5CE6",
-    mint: "#66D4CF",
-    teal: "#6AC4DC",
-    lavender: "#D4BBFF",
-    roseGold: "#FFB5C2",
-    text: "#F5F5F7",
-    secondary: "#A1A1A6",
-    tertiary: "#6E6E73",
-    quaternary: "#48484A",
-    separator: "#38383A",
-    diffAddedBg: "#0d2818",
-    diffRemovedBg: "#2d0f14",
-    diffWordAdded: "#1a4d2e",
-    diffWordRemoved: "#4d1a24"
-  }
-}));
-import { renderMarkdown, closeIncompleteFences, contentWidth, toolContentWidth } from "../markdown.js";
-
-// ============================================================================
-// Setup / Teardown
-// ============================================================================
-
-let origColumns;
-beforeEach(() => {
-  origColumns = process.stdout.columns;
-});
-afterEach(() => {
-  if (origColumns !== undefined) {
-    Object.defineProperty(process.stdout, "columns", {
-      value: origColumns,
-      writable: true
-    });
-  }
-});
-
-// ============================================================================
-// contentWidth / toolContentWidth
-// ============================================================================
-
-describe("contentWidth", () => {
-  it("returns terminal width minus 2", () => {
-    Object.defineProperty(process.stdout, "columns", {
-      value: 100,
-      writable: true
-    });
-    expect(contentWidth()).toBe(98);
-  });
-  it("defaults to 80 when columns is undefined", () => {
-    Object.defineProperty(process.stdout, "columns", {
-      value: undefined,
-      writable: true
-    });
-    expect(contentWidth()).toBe(78);
-  });
-});
-describe("toolContentWidth", () => {
-  it("returns terminal width minus 6", () => {
-    Object.defineProperty(process.stdout, "columns", {
-      value: 100,
-      writable: true
-    });
-    expect(toolContentWidth()).toBe(94);
-  });
-});
-
-// ============================================================================
-// closeIncompleteFences
-// ============================================================================
-
-describe("closeIncompleteFences", () => {
-  it("closes an open code fence", () => {
-    const input = "Some text\n```typescript\nconst x = 1;";
-    const result = closeIncompleteFences(input);
-    expect(result).toContain("```typescript");
-    expect(result.endsWith("```")).toBe(true);
-  });
-  it("does not modify already closed code fence", () => {
-    const input = "```typescript\nconst x = 1;\n```";
-    const result = closeIncompleteFences(input);
-    // Should not add extra closing fence
-    const fenceCount = (result.match(/```/g) || []).length;
-    expect(fenceCount).toBe(2);
-  });
-  it("closes unmatched inline backtick", () => {
-    const input = "Here is some `inline code";
-    const result = closeIncompleteFences(input);
-    expect(result.endsWith("`")).toBe(true);
-  });
-  it("does not modify matched inline backticks", () => {
-    const input = "Here is `code` done.";
-    const result = closeIncompleteFences(input);
-    expect(result).toBe(input);
-  });
-  it("closes unmatched bold markers", () => {
-    const input = "Some **bold text";
-    const result = closeIncompleteFences(input);
-    expect(result).toContain("**");
-    // Should have closing **
-    const boldCount = (result.match(/\*\*/g) || []).length;
-    expect(boldCount % 2).toBe(0);
-  });
-  it("closes unmatched italic markers", () => {
-    const input = "Some *italic text";
-    const result = closeIncompleteFences(input);
-    const starCount = (result.replace(/\*\*/g, "").match(/\*/g) || []).length;
-    expect(starCount % 2).toBe(0);
-  });
-  it("handles empty input", () => {
-    expect(closeIncompleteFences("")).toBe("");
-  });
-  it("handles multiple open fences correctly (only last remains open)", () => {
-    const input = "```\nblock1\n```\n```\nblock2";
-    const result = closeIncompleteFences(input);
-    expect(result.endsWith("```")).toBe(true);
-  });
-});
-
-// ============================================================================
-// renderMarkdown — basic rendering
-// ============================================================================
-
-describe("renderMarkdown", () => {
-  it("renders plain text without errors", () => {
-    const result = renderMarkdown("Hello, world!");
-    expect(result).toContain("Hello, world!");
-  });
-  it("renders headings", () => {
-    const result = renderMarkdown("# My Heading");
-    // Should contain the heading text (with possible ANSI codes)
-    expect(result).toContain("My Heading");
-  });
-  it("renders bold text", () => {
-    const result = renderMarkdown("This is **bold** text.");
-    expect(result).toContain("bold");
-  });
-  it("renders inline code", () => {
-    const result = renderMarkdown("Use `console.log` here.");
-    expect(result).toContain("console.log");
-  });
-  it("renders links", () => {
-    const result = renderMarkdown("[Google](https://google.com)");
-    expect(result).toContain("Google");
-  });
-  it("renders unordered list items", () => {
-    const result = renderMarkdown("- Item 1\n- Item 2\n- Item 3");
-    expect(result).toContain("Item 1");
-    expect(result).toContain("Item 2");
-    expect(result).toContain("Item 3");
-  });
-  it("renders code blocks with language", () => {
-    const result = renderMarkdown("```javascript\nconst x = 1;\n```");
-    expect(result).toContain("const");
-    expect(result).toContain("x");
-  });
-  it("handles streaming mode with fence closure", () => {
-    // Streaming mode should close incomplete fences
-    const result = renderMarkdown("```typescript\nconst x = 1;", true);
-    // Should render without throwing
-    expect(result).toContain("const");
-  });
-  it("handles non-streaming mode without fence closure", () => {
-    // Non-streaming with complete markdown
-    const result = renderMarkdown("Hello\n\nWorld", false);
-    expect(result).toContain("Hello");
-    expect(result).toContain("World");
-  });
-  it("strips trailing newlines from output", () => {
-    const result = renderMarkdown("Test");
-    expect(result.endsWith("\n\n")).toBe(false);
-  });
-});