akm-cli 0.6.1 → 0.7.0

package/dist/tests/commands/show.test.js

@@ -0,0 +1,294 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { akmShowUnified as akmShow } from "../../src/commands/show";
+import { saveConfig } from "../../src/core/config";
+// Trigger source-provider self-registration
+import "../../src/sources/providers/index";
+const createdTmpDirs = [];
+function createTmpDir(prefix = "akm-show-") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+function writeFile(filePath, content = "") {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+afterAll(() => {
+    for (const dir of createdTmpDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
+const originalStashDir = process.env.AKM_STASH_DIR;
+let testCacheDir = "";
+let testConfigDir = "";
+let stashDir = "";
+beforeEach(() => {
+    testCacheDir = createTmpDir("akm-show-cache-");
+    testConfigDir = createTmpDir("akm-show-config-");
+    stashDir = createTmpDir("akm-show-stash-");
+    for (const sub of ["scripts", "skills", "commands", "agents", "knowledge"]) {
+        fs.mkdirSync(path.join(stashDir, sub), { recursive: true });
+    }
+    process.env.XDG_CACHE_HOME = testCacheDir;
+    process.env.XDG_CONFIG_HOME = testConfigDir;
+    process.env.AKM_STASH_DIR = stashDir;
+});
+afterEach(() => {
+    if (originalXdgCacheHome === undefined) {
+        delete process.env.XDG_CACHE_HOME;
+    }
+    else {
+        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
+    }
+    if (originalXdgConfigHome === undefined) {
+        delete process.env.XDG_CONFIG_HOME;
+    }
+    else {
+        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
+    }
+    if (originalStashDir === undefined) {
+        delete process.env.AKM_STASH_DIR;
+    }
+    else {
+        process.env.AKM_STASH_DIR = originalStashDir;
+    }
+    if (testCacheDir) {
+        fs.rmSync(testCacheDir, { recursive: true, force: true });
+        testCacheDir = "";
+    }
+    if (testConfigDir) {
+        fs.rmSync(testConfigDir, { recursive: true, force: true });
+        testConfigDir = "";
+    }
+});
+// ── Installed ref with missing asset ─────────────────────────────────────────
+describe("akmShow installed ref", () => {
+    test("throws with add guidance when origin is not installed", async () => {
+        const installedStashRoot = createTmpDir("akm-show-installed-root-");
+        // Create the type subdirectory so it is a valid stash root, but do NOT
+        // create the actual asset file.
+        fs.mkdirSync(path.join(installedStashRoot, "scripts"), { recursive: true });
+        saveConfig({
+            semanticSearchMode: "off",
+            installed: [
+                {
+                    id: "test-pkg",
+                    source: "npm",
+                    ref: "test-pkg",
+                    artifactUrl: "https://example.com/test-pkg.tgz",
+                    stashRoot: installedStashRoot,
+                    cacheDir: installedStashRoot,
+                    installedAt: new Date().toISOString(),
+                },
+            ],
+        });
+        // Use an origin that is NOT installed so resolveSourcesForOrigin returns
+        // empty, triggering the add-guidance error path.
+        await expect(akmShow({ ref: "npm:@other/missing-pkg//script:missing.sh" })).rejects.toThrow(/akm add/);
+    });
+    test("resolves installed-stash style nested agent refs", async () => {
+        const installedStashRoot = createTmpDir("akm-show-installed-agent-");
+        writeFile(path.join(installedStashRoot, "tools", "agents", "svelte-file-editor.md"), ["---", "name: svelte-file-editor", "description: Svelte editor", "---", "Use Svelte tools."].join("\n"));
+        saveConfig({
+            semanticSearchMode: "off",
+            installed: [
+                {
+                    id: "github:sveltejs/ai-tools",
+                    source: "github",
+                    ref: "github:sveltejs/ai-tools",
+                    artifactUrl: "https://example.com/svelte-tools.tgz",
+                    stashRoot: installedStashRoot,
+                    cacheDir: installedStashRoot,
+                    installedAt: new Date().toISOString(),
+                },
+            ],
+        });
+        const result = await akmShow({ ref: "github:sveltejs/ai-tools//agent:tools/agents/svelte-file-editor" });
+        expect(result.type).toBe("agent");
+        expect(result.origin).toBe("github:sveltejs/ai-tools");
+        expect(result.path).toContain(path.join("tools", "agents", "svelte-file-editor.md"));
+        expect(result.prompt).toContain("Use Svelte tools.");
+    });
+    test("resolves installed-stash style nested skill refs", async () => {
+        const installedStashRoot = createTmpDir("akm-show-installed-skill-");
+        writeFile(path.join(installedStashRoot, "tools", "skills", "svelte-code-writer", "SKILL.md"), ["---", "name: svelte-code-writer", "description: Svelte writer", "---", "# Svelte writer"].join("\n"));
+        saveConfig({
+            semanticSearchMode: "off",
+            installed: [
+                {
+                    id: "github:sveltejs/ai-tools",
+                    source: "github",
+                    ref: "github:sveltejs/ai-tools",
+                    artifactUrl: "https://example.com/svelte-tools.tgz",
+                    stashRoot: installedStashRoot,
+                    cacheDir: installedStashRoot,
+                    installedAt: new Date().toISOString(),
+                },
+            ],
+        });
+        const result = await akmShow({ ref: "github:sveltejs/ai-tools//skill:tools/skills/svelte-code-writer" });
+        expect(result.type).toBe("skill");
+        expect(result.origin).toBe("github:sveltejs/ai-tools");
+        expect(result.path).toContain(path.join("tools", "skills", "svelte-code-writer", "SKILL.md"));
+        expect(result.content).toContain("# Svelte writer");
+    });
+});
+// ── Search path resolution ───────────────────────────────────────────────────
+describe("akmShow search path", () => {
+    test("resolves from search path directories", async () => {
+        const searchPathDir = createTmpDir("akm-show-searchpath-");
+        writeFile(path.join(searchPathDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
+        saveConfig({ semanticSearchMode: "off", sources: [{ type: "filesystem", path: searchPathDir }] });
+        const result = await akmShow({ ref: "script:deploy.sh" });
+        expect(result.type).toBe("script");
+        expect(result.name).toBe("deploy.sh");
+        expect(result.path).toContain(searchPathDir);
+    });
+});
+// ── editability flags ────────────────────────────────────────────────────────
+describe("akmShow editability", () => {
+    test("working stash asset has editable true", async () => {
+        writeFile(path.join(stashDir, "scripts", "local.sh"), "#!/usr/bin/env bash\necho local\n");
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "script:local.sh" });
+        expect(result.type).toBe("script");
+        expect(result.origin).toBeNull();
+        expect(result.action).toContain("Execute the run command");
+        expect(result.editable).toBe(true);
+        expect(result.editHint).toBeUndefined();
+    });
+    test("search path asset has editable true", async () => {
+        const searchPathDir = createTmpDir("akm-show-searchpath-editable-");
+        writeFile(path.join(searchPathDir, "scripts", "remote.sh"), "#!/usr/bin/env bash\necho remote\n");
+        saveConfig({ semanticSearchMode: "off", sources: [{ type: "filesystem", path: searchPathDir }] });
+        const result = await akmShow({ ref: "script:remote.sh" });
+        expect(result.type).toBe("script");
+        expect(result.origin).toBeNull();
+        expect(result.editable).toBe(true);
+        expect(result.editHint).toBeUndefined();
+    });
+    test("installed (cache-managed) asset has editable false with editHint", async () => {
+        const installedStashRoot = createTmpDir("akm-show-installed-resolve-");
+        writeFile(path.join(installedStashRoot, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
+        saveConfig({
+            semanticSearchMode: "off",
+            installed: [
+                {
+                    id: "installed-pkg",
+                    source: "npm",
+                    ref: "npm:installed-pkg",
+                    artifactUrl: "https://example.com/installed-pkg.tgz",
+                    stashRoot: installedStashRoot,
+                    cacheDir: installedStashRoot,
+                    installedAt: new Date().toISOString(),
+                },
+            ],
+        });
+        const result = await akmShow({ ref: "script:deploy.sh" });
+        expect(result.type).toBe("script");
+        expect(result.origin).toBe("installed-pkg");
+        expect(result.editable).toBe(false);
+        expect(result.editHint).toContain("akm clone");
+        expect(result.editHint).toContain("script:deploy.sh");
+    });
+});
+// ── Content-based classification via new renderer pipeline ─────────────────
+describe("akmShow content-based classification", () => {
+    test("model alone in commands/ stays a command (directory wins over weak agent signal)", async () => {
+        // model is shared frontmatter (OpenCode convention). In commands/,
+        // the directory matcher (specificity 10) beats the model-only agent
+        // signal (specificity 8), so this stays a command.
+        writeFile(path.join(stashDir, "commands", "deploy.md"), ["---", "model: gpt-4", "description: Deploy command", "---", "Deploy $ARGUMENTS."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "command:deploy.md" });
+        expect(result.type).toBe("command");
+        expect(result.template).toBe("Deploy $ARGUMENTS.");
+        expect(result.modelHint).toBe("gpt-4");
+        expect(result.parameters).toEqual(["ARGUMENTS"]);
+    });
+    test("tools frontmatter in commands/ overrides to agent (strong signal)", async () => {
+        // tools/toolPolicy are agent-exclusive signals at specificity 20,
+        // which beats the commands/ directory matcher at 10.
+        writeFile(path.join(stashDir, "commands", "hybrid.md"), ["---", "tools:", "  read: allow", "model: gpt-4", "---", "You are a hybrid agent."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "command:hybrid.md" });
+        expect(result.type).toBe("agent");
+        expect(result.action).toContain("verbatim");
+        expect(result.prompt).toContain("You are a hybrid agent.");
+    });
+    test("command in commands/ directory extracts OpenCode-style frontmatter", async () => {
+        writeFile(path.join(stashDir, "commands", "deploy.md"), [
+            "---",
+            "description: Deploy to production",
+            "model: claude-sonnet-4-20250514",
+            "agent: build",
+            "---",
+            "Deploy $ARGUMENTS to production.",
+        ].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "command:deploy.md" });
+        expect(result.type).toBe("command");
+        expect(result.template).toBe("Deploy $ARGUMENTS to production.");
+        expect(result.description).toBe("Deploy to production");
+        expect(result.modelHint).toBe("claude-sonnet-4-20250514");
+        expect(result.agent).toBe("build");
+        expect(result.parameters).toEqual(["ARGUMENTS"]);
+    });
+    test("command parameter extraction includes positional placeholders", async () => {
+        writeFile(path.join(stashDir, "commands", "positional.md"), ["---", "description: Positional args", "---", "Run release $1 with notes from $2 and flag $9."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "command:positional.md" });
+        expect(result.type).toBe("command");
+        expect(result.parameters).toEqual(["$1", "$2", "$9"]);
+    });
+    test("command parameter extraction includes named placeholders", async () => {
+        writeFile(path.join(stashDir, "commands", "named.md"), ["---", "description: Named args", "---", "Deploy {{env}} with {{version}} using {{env}} again."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "command:named.md" });
+        expect(result.type).toBe("command");
+        expect(result.parameters).toEqual(["env", "version"]);
+    });
+    test("script in scripts/ directory uses new renderer pipeline", async () => {
+        writeFile(path.join(stashDir, "scripts", "build.sh"), "#!/usr/bin/env bash\necho build\n");
+        saveConfig({ semanticSearchMode: "off" });
+        const result = await akmShow({ ref: "script:build.sh" });
+        expect(result.type).toBe("script");
+        expect(result.run).toBeDefined();
+        expect(result.run).toContain("bash");
+    });
+    test("$ARGUMENTS in body classifies .md as command even outside commands/", async () => {
+        writeFile(path.join(stashDir, "knowledge", "deploy-cmd.md"), ["---", "description: Deploy helper", "---", "Deploy $ARGUMENTS to staging."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        // $ARGUMENTS placeholder (specificity 18) beats knowledge/ directory hint (10)
+        const result = await akmShow({ ref: "knowledge:deploy-cmd.md" });
+        expect(result.type).toBe("command");
+        expect(result.template).toBe("Deploy $ARGUMENTS to staging.");
+        expect(result.description).toBe("Deploy helper");
+    });
+    test("agent frontmatter classifies .md as command even outside commands/", async () => {
+        writeFile(path.join(stashDir, "agents", "build-cmd.md"), ["---", "agent: build", "description: Build dispatch", "---", "Build the project."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        // agent frontmatter (specificity 18) beats agents/ directory hint (15)
+        const result = await akmShow({ ref: "agent:build-cmd.md" });
+        expect(result.type).toBe("command");
+        expect(result.template).toBe("Build the project.");
+        expect(result.agent).toBe("build");
+    });
+    test("knowledge view modes work through new renderer pipeline", async () => {
+        writeFile(path.join(stashDir, "knowledge", "guide.md"), ["# Intro", "Welcome.", "", "## Setup", "Install things.", "", "## Usage", "Use things."].join("\n"));
+        saveConfig({ semanticSearchMode: "off" });
+        const tocResult = await akmShow({ ref: "knowledge:guide.md", view: { mode: "toc" } });
+        expect(tocResult.content).toContain("Intro");
+        expect(tocResult.content).toContain("Setup");
+        const sectionResult = await akmShow({
+            ref: "knowledge:guide.md",
+            view: { mode: "section", heading: "Setup" },
+        });
+        expect(sectionResult.content).toContain("Install things.");
+    });
+});

package/dist/tests/common.test.js

@@ -0,0 +1,266 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { hasErrnoCode, isAssetType, isWithin, jsonWithByteCap, ResponseTooLargeError, readBodyWithByteCap, resolveStashDir, toPosix, } from "../src/core/common";
+// ── resolveStashDir ──────────────────────────────────────────────────────────
+describe("resolveStashDir", () => {
+    const origEnv = process.env.AKM_STASH_DIR;
+    const origXdgConfigHome = process.env.XDG_CONFIG_HOME;
+    const origHome = process.env.HOME;
+    let testConfigHome;
+    beforeEach(() => {
+        testConfigHome = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-config-"));
+        process.env.XDG_CONFIG_HOME = testConfigHome;
+    });
+    afterEach(() => {
+        if (origEnv === undefined) {
+            delete process.env.AKM_STASH_DIR;
+        }
+        else {
+            process.env.AKM_STASH_DIR = origEnv;
+        }
+        if (origXdgConfigHome === undefined) {
+            delete process.env.XDG_CONFIG_HOME;
+        }
+        else {
+            process.env.XDG_CONFIG_HOME = origXdgConfigHome;
+        }
+        if (origHome === undefined) {
+            delete process.env.HOME;
+        }
+        else {
+            process.env.HOME = origHome;
+        }
+        if (testConfigHome) {
+            fs.rmSync(testConfigHome, { recursive: true, force: true });
+        }
+    });
+    test("throws when no stash dir is configured and default does not exist", () => {
+        delete process.env.AKM_STASH_DIR;
+        // Point HOME to a tmp dir without an akm subdirectory
+        const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-home-"));
+        process.env.HOME = tmpHome;
+        try {
+            expect(() => resolveStashDir()).toThrow("No stash directory found");
+        }
+        finally {
+            fs.rmSync(tmpHome, { recursive: true, force: true });
+        }
+    });
+    test("throws when AKM_STASH_DIR points to nonexistent path", () => {
+        process.env.AKM_STASH_DIR = "/nonexistent/path/that/does/not/exist";
+        expect(() => resolveStashDir()).toThrow("Unable to read");
+    });
+    test("throws when AKM_STASH_DIR path is a file, not a directory", () => {
+        const tmpFile = path.join(os.tmpdir(), `akm-common-test-file-${Date.now()}`);
+        fs.writeFileSync(tmpFile, "not a directory");
+        try {
+            process.env.AKM_STASH_DIR = tmpFile;
+            expect(() => resolveStashDir()).toThrow("must point to a directory");
+        }
+        finally {
+            fs.unlinkSync(tmpFile);
+        }
+    });
+    test("returns resolved path for valid AKM_STASH_DIR", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-"));
+        try {
+            process.env.AKM_STASH_DIR = tmpDir;
+            const result = resolveStashDir();
+            expect(result).toBe(path.resolve(tmpDir));
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    test("reads stashDir from config.json when env var is not set", () => {
+        delete process.env.AKM_STASH_DIR;
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-stash-"));
+        try {
+            const configDir = path.join(testConfigHome, "akm");
+            fs.mkdirSync(configDir, { recursive: true });
+            fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ stashDir: tmpDir }));
+            const result = resolveStashDir();
+            expect(result).toBe(path.resolve(tmpDir));
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    test("uses default stash dir when it exists", () => {
+        delete process.env.AKM_STASH_DIR;
+        const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-home-"));
+        const defaultStash = path.join(tmpHome, "akm");
+        fs.mkdirSync(defaultStash, { recursive: true });
+        process.env.HOME = tmpHome;
+        try {
+            const result = resolveStashDir();
+            expect(result).toBe(defaultStash);
+        }
+        finally {
+            fs.rmSync(tmpHome, { recursive: true, force: true });
+        }
+    });
+    test("env var takes precedence over config.json stashDir", () => {
+        const envDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-env-"));
+        const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-cfg-"));
+        try {
+            process.env.AKM_STASH_DIR = envDir;
+            const configRoot = path.join(testConfigHome, "akm");
+            fs.mkdirSync(configRoot, { recursive: true });
+            fs.writeFileSync(path.join(configRoot, "config.json"), JSON.stringify({ stashDir: configDir }));
+            const result = resolveStashDir();
+            expect(result).toBe(path.resolve(envDir));
+        }
+        finally {
+            fs.rmSync(envDir, { recursive: true, force: true });
+            fs.rmSync(configDir, { recursive: true, force: true });
+        }
+    });
+});
+// ── toPosix ──────────────────────────────────────────────────────────────────
+describe("toPosix", () => {
+    test("already-posix paths are unchanged", () => {
+        expect(toPosix("foo/bar/baz")).toBe("foo/bar/baz");
+    });
+    test("backslash paths are converted to forward slashes", () => {
+        expect(toPosix("foo\\bar\\baz")).toBe("foo/bar/baz");
+    });
+    test("mixed separators are normalized", () => {
+        expect(toPosix("foo\\bar/baz")).toBe("foo/bar/baz");
+    });
+    test("empty string returns empty string", () => {
+        expect(toPosix("")).toBe("");
+    });
+});
+// ── hasErrnoCode ─────────────────────────────────────────────────────────────
+describe("hasErrnoCode", () => {
+    test("returns true for error with matching code", () => {
+        const err = Object.assign(new Error("fail"), { code: "ENOENT" });
+        expect(hasErrnoCode(err, "ENOENT")).toBe(true);
+    });
+    test("returns false for error with non-matching code", () => {
+        const err = Object.assign(new Error("fail"), { code: "EACCES" });
+        expect(hasErrnoCode(err, "ENOENT")).toBe(false);
+    });
+    test("returns false for string error", () => {
+        expect(hasErrnoCode("some string error", "ENOENT")).toBe(false);
+    });
+    test("returns false for null", () => {
+        expect(hasErrnoCode(null, "ENOENT")).toBe(false);
+    });
+    test("returns false for object without code property", () => {
+        expect(hasErrnoCode({ message: "fail" }, "ENOENT")).toBe(false);
+    });
+    test("returns false for undefined", () => {
+        expect(hasErrnoCode(undefined, "ENOENT")).toBe(false);
+    });
+});
+// ── isAssetType ──────────────────────────────────────────────────────────────
+describe("isAssetType", () => {
+    test("returns true for all valid types", () => {
+        expect(isAssetType("skill")).toBe(true);
+        expect(isAssetType("command")).toBe(true);
+        expect(isAssetType("agent")).toBe(true);
+        expect(isAssetType("knowledge")).toBe(true);
+        expect(isAssetType("script")).toBe(true);
+    });
+    test("returns false for invalid strings", () => {
+        expect(isAssetType("widget")).toBe(false);
+        expect(isAssetType("")).toBe(false);
+        expect(isAssetType("tool")).toBe(false);
+        expect(isAssetType("plugin")).toBe(false);
+    });
+});
+// ── isWithin ────────────────────────────────────────────────────────────────
+describe("isWithin", () => {
+    test("returns true for path inside root", () => {
+        expect(isWithin("/root/sub/file.txt", "/root")).toBe(true);
+    });
+    test("returns true for path equal to root", () => {
+        expect(isWithin("/root", "/root")).toBe(true);
+    });
+    test("returns false for path outside root", () => {
+        expect(isWithin("/other/file.txt", "/root")).toBe(false);
+    });
+    test("returns false for parent traversal", () => {
+        expect(isWithin("/root/../etc/passwd", "/root")).toBe(false);
+    });
+    test("returns true for nested subdirectory", () => {
+        expect(isWithin("/root/a/b/c/d.txt", "/root")).toBe(true);
+    });
+    test("returns false for sibling directory with similar prefix", () => {
+        expect(isWithin("/root-other/file.txt", "/root")).toBe(false);
+    });
+});
+// ── readBodyWithByteCap / jsonWithByteCap ────────────────────────────────────
+describe("readBodyWithByteCap", () => {
+    function makeResponse(body, init) {
+        const res = new Response(body, { headers: init?.headers });
+        if (init?.url)
+            Object.defineProperty(res, "url", { value: init.url });
+        return res;
+    }
+    test("reads small bodies verbatim", async () => {
+        const text = await readBodyWithByteCap(makeResponse("hello world"), 1024);
+        expect(text).toBe("hello world");
+    });
+    test("handles empty bodies", async () => {
+        const text = await readBodyWithByteCap(makeResponse(""), 1024);
+        expect(text).toBe("");
+    });
+    test("refuses before reading if Content-Length exceeds cap", async () => {
+        const body = "x".repeat(1000);
+        const response = makeResponse(body, {
+            headers: { "content-length": "1000" },
+            url: "http://example.invalid/too-big",
+        });
+        await expect(readBodyWithByteCap(response, 100)).rejects.toBeInstanceOf(ResponseTooLargeError);
+    });
+    test("aborts mid-stream when Content-Length is absent but body exceeds cap", async () => {
+        const stream = new ReadableStream({
+            start(controller) {
+                // 5 chunks of 1000 bytes each = 5000 bytes; cap at 2500.
+                for (let i = 0; i < 5; i++) {
+                    controller.enqueue(new TextEncoder().encode("x".repeat(1000)));
+                }
+                controller.close();
+            },
+        });
+        const response = new Response(stream);
+        await expect(readBodyWithByteCap(response, 2500)).rejects.toBeInstanceOf(ResponseTooLargeError);
+    });
+    test("accepts body right at the cap", async () => {
+        const body = "x".repeat(100);
+        const text = await readBodyWithByteCap(makeResponse(body), 100);
+        expect(text.length).toBe(100);
+    });
+    test("decodes multi-chunk UTF-8 bodies correctly", async () => {
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new TextEncoder().encode("hello "));
+                controller.enqueue(new TextEncoder().encode("world"));
+                controller.close();
+            },
+        });
+        const response = new Response(stream);
+        const text = await readBodyWithByteCap(response, 1024);
+        expect(text).toBe("hello world");
+    });
+});
+describe("jsonWithByteCap", () => {
+    test("parses small JSON bodies", async () => {
+        const data = await jsonWithByteCap(new Response(JSON.stringify({ hello: "world" })), 1024);
+        expect(data.hello).toBe("world");
+    });
+    test("rejects oversized JSON before parse", async () => {
+        const big = JSON.stringify({ data: "x".repeat(2000) });
+        const response = new Response(big, { headers: { "content-length": String(big.length) } });
+        await expect(jsonWithByteCap(response, 500)).rejects.toBeInstanceOf(ResponseTooLargeError);
+    });
+    test("propagates JSON.parse errors for malformed input", async () => {
+        const response = new Response("{not json");
+        await expect(jsonWithByteCap(response, 1024)).rejects.toThrow();
+    });
+});