@jiggai/kitchen 0.3.1 → 0.3.3

package/src/app/api/__tests__/goals-promote-route.test.ts

@@ -1,200 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../goals/[id]/promote/route";
-import path from "node:path";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-
-import { runOpenClaw } from "@/lib/openclaw";
-vi.mock("@/lib/goals", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/goals")>();
-  return { ...actual, readGoal: vi.fn(), writeGoal: vi.fn() };
-});
-vi.mock("@/lib/paths", () => ({
-  getTeamWorkspaceDir: vi.fn(),
-  readOpenClawConfig: vi.fn(),
-}));
-vi.mock("node:fs/promises", () => ({
-  default: { mkdir: vi.fn(), writeFile: vi.fn() },
-}));
-
-import { readGoal, writeGoal } from "@/lib/goals";
-import { getTeamWorkspaceDir, readOpenClawConfig } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("api goals promote route", () => {
-  const teamWs = "/mock-workspace/development-team";
-  const existingGoal = {
-    id: "my-goal",
-    frontmatter: { id: "my-goal", title: "My Goal", tags: [], teams: [] },
-    body: "## Existing body",
-    raw: "",
-  };
-
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(readGoal).mockReset();
-    vi.mocked(writeGoal).mockReset();
-    vi.mocked(getTeamWorkspaceDir).mockReset();
-    vi.mocked(readOpenClawConfig).mockReset();
-    vi.mocked(fs.mkdir).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-
-    vi.mocked(getTeamWorkspaceDir).mockResolvedValue(teamWs);
-    vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-  });
-
-  it("returns 404 when goal not found", async () => {
-    vi.mocked(readGoal).mockResolvedValue(null);
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "missing" }) }
-    );
-    expect(res.status).toBe(404);
-    const json = await res.json();
-    expect(json.error).toBe("Goal not found");
-  });
-
-  it("creates inbox file and updates goal on success", async () => {
-    vi.mocked(readGoal).mockResolvedValue(existingGoal);
-    vi.mocked(writeGoal).mockResolvedValue({
-      frontmatter: { ...existingGoal.frontmatter, status: "active" },
-      body: "",
-      raw: "",
-    });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({});
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "my-goal" }) }
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.goal.id).toBe("my-goal");
-    expect(json.inboxPath).toContain("inbox");
-    expect(json.inboxPath).toContain("goal");
-    expect(fs.mkdir).toHaveBeenCalledWith(path.join(teamWs, "inbox"), { recursive: true });
-    expect(fs.writeFile).toHaveBeenCalledWith(
-      expect.stringContaining("inbox"),
-      expect.stringContaining("My Goal"),
-      expect.any(Object)
-    );
-    expect(writeGoal).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: "my-goal",
-        status: "active",
-        body: expect.stringContaining("## Workflow"),
-      })
-    );
-  });
-
-  it("pingAttempted false when agentToAgent disabled", async () => {
-    vi.mocked(readGoal).mockResolvedValue(existingGoal);
-    vi.mocked(writeGoal).mockResolvedValue({
-      frontmatter: existingGoal.frontmatter,
-      body: "",
-      raw: "",
-    });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      tools: { agentToAgent: { enabled: false } },
-    });
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "my-goal" }) }
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.pingAttempted).toBe(false);
-    expect(runOpenClaw).not.toHaveBeenCalled();
-  });
-
-  it("pingAttempted true and pingOk true when agentToAgent enabled", async () => {
-    vi.mocked(readGoal).mockResolvedValue(existingGoal);
-    vi.mocked(writeGoal).mockResolvedValue({
-      frontmatter: existingGoal.frontmatter,
-      body: "",
-      raw: "",
-    });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      tools: { agentToAgent: { enabled: true, allow: ["*"] } },
-    });
-    vi.mocked(runOpenClaw).mockResolvedValue({ ok: true, exitCode: 0, stdout: "", stderr: "" });
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "my-goal" }) }
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.pingAttempted).toBe(true);
-    expect(json.pingOk).toBe(true);
-    expect(runOpenClaw).toHaveBeenCalledWith(
-      expect.arrayContaining(["agent", "--agent", "development-team-lead"])
-    );
-  });
-
-  it("pingOk false when exec fails", async () => {
-    vi.mocked(readGoal).mockResolvedValue(existingGoal);
-    vi.mocked(writeGoal).mockResolvedValue({
-      frontmatter: existingGoal.frontmatter,
-      body: "",
-      raw: "",
-    });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      tools: { agentToAgent: { enabled: true, allow: ["*"] } },
-    });
-    vi.mocked(runOpenClaw).mockRejectedValue(new Error("Command failed"));
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "my-goal" }) }
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.pingAttempted).toBe(true);
-    expect(json.pingOk).toBe(false);
-    expect(json.pingReason).toBe("Command failed");
-  });
-
-  it("uses alternate filename when EEXIST", async () => {
-    vi.mocked(readGoal).mockResolvedValue(existingGoal);
-    vi.mocked(writeGoal).mockResolvedValue({
-      frontmatter: existingGoal.frontmatter,
-      body: "",
-      raw: "",
-    });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({});
-
-    const eexist = new Error("EEXIST") as Error & { code?: string };
-    eexist.code = "EEXIST";
-
-    vi.mocked(fs.writeFile)
-      .mockRejectedValueOnce(eexist)
-      .mockResolvedValueOnce(undefined);
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "my-goal" }) }
-    );
-    expect(res.status).toBe(200);
-    expect(fs.writeFile).toHaveBeenCalledTimes(2);
-    const secondPath = (fs.writeFile as ReturnType<typeof vi.fn>).mock.calls[1][0];
-    expect(secondPath).toContain("-goal-");
-    expect(secondPath).toContain(".md");
-  });
-
-  it("returns 500 when readGoal throws", async () => {
-    vi.mocked(readGoal).mockRejectedValue(new Error("File system error"));
-
-    const res = await POST(
-      new Request("https://test"),
-      { params: Promise.resolve({ id: "my-goal" }) }
-    );
-    expect(res.status).toBe(500);
-    const json = (await res.json()) as { error?: string };
-    expect(json.error).toBe("File system error");
-  });
-});

package/src/app/api/__tests__/goals-route.test.ts

@@ -1,184 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET, POST } from "../goals/route";
-import { GET as GET_ID, PUT, DELETE } from "../goals/[id]/route";
-
-vi.mock("@/lib/goals", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/goals")>();
-  return {
-    ...actual,
-    listGoals: vi.fn(),
-    readGoal: vi.fn(),
-    writeGoal: vi.fn(),
-    deleteGoal: vi.fn(),
-  };
-});
-
-import { listGoals, readGoal, writeGoal, deleteGoal } from "@/lib/goals";
-
-describe("api goals route", () => {
-  beforeEach(() => {
-    vi.mocked(listGoals).mockReset();
-    vi.mocked(readGoal).mockReset();
-    vi.mocked(writeGoal).mockReset();
-    vi.mocked(deleteGoal).mockReset();
-  });
-
-  describe("GET /api/goals", () => {
-    it("returns goals when listGoals succeeds", async () => {
-      vi.mocked(listGoals).mockResolvedValue([
-        { id: "g1", frontmatter: { id: "g1", title: "Goal 1" }, body: "", raw: "" },
-      ]);
-      const res = await GET();
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.goals).toHaveLength(1);
-      expect(json.goals[0].id).toBe("g1");
-    });
-
-    it("returns 500 when listGoals throws", async () => {
-      vi.mocked(listGoals).mockRejectedValue(new Error("fs error"));
-      const res = await GET();
-      expect(res.status).toBe(500);
-      const json = await res.json();
-      expect(json.error).toBe("fs error");
-    });
-  });
-
-  describe("POST /api/goals", () => {
-    it("returns 400 when id or title missing", async () => {
-      const res = await POST(new Request("https://test", { method: "POST", body: JSON.stringify({}) }));
-      expect(res.status).toBe(400);
-      const json = await res.json();
-      expect(json.error).toBe("id and title are required");
-    });
-
-    it("returns goal when writeGoal succeeds", async () => {
-      vi.mocked(writeGoal).mockResolvedValue({
-        frontmatter: { id: "g1", title: "G1" },
-        body: "",
-        raw: "",
-      });
-      const res = await POST(
-        new Request("https://test", {
-          method: "POST",
-          body: JSON.stringify({ id: "g1", title: "G1" }),
-        })
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.goal.id).toBe("g1");
-    });
-  });
-
-  describe("GET /api/goals/[id]", () => {
-    it("returns goal when found", async () => {
-      vi.mocked(readGoal).mockResolvedValue({
-        id: "g1",
-        frontmatter: { id: "g1", title: "G1" },
-        body: "body",
-        raw: "raw",
-      });
-      const res = await GET_ID(new Request("https://test"), { params: Promise.resolve({ id: "g1" }) });
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.goal.id).toBe("g1");
-      expect(json.body).toBe("body");
-    });
-
-    it("returns 404 when not found", async () => {
-      vi.mocked(readGoal).mockResolvedValue(null);
-      const res = await GET_ID(new Request("https://test"), { params: Promise.resolve({ id: "g1" }) });
-      expect(res.status).toBe(404);
-    });
-
-    it("returns 400 when readGoal throws Invalid goal id or Path traversal", async () => {
-      vi.mocked(readGoal).mockRejectedValue(new Error("Invalid goal id"));
-      const r1 = await GET_ID(new Request("https://test"), { params: Promise.resolve({ id: "bad" }) });
-      expect(r1.status).toBe(400);
-
-      vi.mocked(readGoal).mockRejectedValue(new Error("Path traversal"));
-      const r2 = await GET_ID(new Request("https://test"), { params: Promise.resolve({ id: "../x" }) });
-      expect(r2.status).toBe(400);
-    });
-
-    it("returns 500 when readGoal throws other error", async () => {
-      vi.mocked(readGoal).mockRejectedValue(new Error("fs error"));
-      const res = await GET_ID(new Request("https://test"), { params: Promise.resolve({ id: "g1" }) });
-      expect(res.status).toBe(500);
-    });
-  });
-
-  describe("PUT /api/goals/[id]", () => {
-    it("returns 400 when title missing", async () => {
-      const res = await PUT(
-        new Request("https://test", { method: "PUT", body: JSON.stringify({}) }),
-        { params: Promise.resolve({ id: "g1" }) }
-      );
-      expect(res.status).toBe(400);
-    });
-
-    it("returns goal when writeGoal succeeds", async () => {
-      vi.mocked(writeGoal).mockResolvedValue({
-        frontmatter: { id: "g1", title: "Updated" },
-        body: "",
-        raw: "",
-      });
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ title: "Updated" }),
-        }),
-        { params: Promise.resolve({ id: "g1" }) }
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.goal.title).toBe("Updated");
-    });
-
-    it("returns 400 when writeGoal throws Invalid goal id", async () => {
-      vi.mocked(writeGoal).mockRejectedValue(new Error("Invalid goal id"));
-      const res = await PUT(
-        new Request("https://test", { method: "PUT", body: JSON.stringify({ title: "T" }) }),
-        { params: Promise.resolve({ id: "bad" }) }
-      );
-      expect(res.status).toBe(400);
-    });
-
-    it("returns 500 when writeGoal throws other error", async () => {
-      vi.mocked(writeGoal).mockRejectedValue(new Error("fs error"));
-      const res = await PUT(
-        new Request("https://test", { method: "PUT", body: JSON.stringify({ title: "T" }) }),
-        { params: Promise.resolve({ id: "g1" }) }
-      );
-      expect(res.status).toBe(500);
-    });
-  });
-
-  describe("DELETE /api/goals/[id]", () => {
-    it("returns 200 when delete succeeds", async () => {
-      vi.mocked(deleteGoal).mockResolvedValue({ ok: true });
-      const res = await DELETE(new Request("https://test"), { params: Promise.resolve({ id: "g1" }) });
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-    });
-
-    it("returns 404 when delete returns ok false", async () => {
-      vi.mocked(deleteGoal).mockResolvedValue({ ok: false });
-      const res = await DELETE(new Request("https://test"), { params: Promise.resolve({ id: "g1" }) });
-      expect(res.status).toBe(404);
-    });
-
-    it("returns 400 when deleteGoal throws Invalid goal id", async () => {
-      vi.mocked(deleteGoal).mockRejectedValue(new Error("Invalid goal id"));
-      const res = await DELETE(new Request("https://test"), { params: Promise.resolve({ id: "bad" }) });
-      expect(res.status).toBe(400);
-    });
-
-    it("returns 500 when deleteGoal throws other error", async () => {
-      vi.mocked(deleteGoal).mockRejectedValue(new Error("fs error"));
-      const res = await DELETE(new Request("https://test"), { params: Promise.resolve({ id: "g1" }) });
-      expect(res.status).toBe(500);
-    });
-  });
-});

package/src/app/api/__tests__/ids-check-route.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("@/lib/paths", () => ({ readOpenClawConfig: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: { stat: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { readOpenClawConfig } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("api ids check route", () => {
-  let GET: (req: Request) => Promise<Response>;
-
-  beforeEach(async () => {
-    vi.resetModules();
-    vi.useFakeTimers();
-    vi.advanceTimersByTime(15_000);
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(readOpenClawConfig).mockReset();
-    vi.mocked(fs.stat).mockReset();
-    const mod = await import("../ids/check/route");
-    GET = mod.GET;
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("returns 400 when kind invalid", async () => {
-    const res = await GET(new Request("https://test/api/ids/check?kind=invalid&id=foo"));
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("kind must be team|agent");
-  });
-
-  it("returns available:false reason:empty when id empty", async () => {
-    const res = await GET(new Request("https://test/api/ids/check?kind=agent&id="));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.available).toBe(false);
-    expect(json.reason).toBe("empty");
-  });
-
-  it("returns available:false reason:recipe-id-collision when id collides with recipe", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "foo" }]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      });
-
-    const res = await GET(new Request("https://test/api/ids/check?kind=agent&id=foo"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.available).toBe(false);
-    expect(json.reason).toBe("recipe-id-collision");
-  });
-
-  it("returns available:false reason:agent-exists for agent id", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "my-agent" }]),
-        stderr: "",
-      });
-
-    const res = await GET(new Request("https://test/api/ids/check?kind=agent&id=my-agent"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.available).toBe(false);
-    expect(json.reason).toBe("agent-exists");
-  });
-
-  it("returns available:true for new agent id", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      });
-
-    const res = await GET(new Request("https://test/api/ids/check?kind=agent&id=new-agent"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.available).toBe(true);
-  });
-
-  it("returns available:false reason:team-workspace-exists when team dir exists", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      agents: { defaults: { workspace: "/home/user/agents" } },
-    } as never);
-    vi.mocked(fs.stat).mockResolvedValue({} as never);
-
-    const res = await GET(new Request("https://test/api/ids/check?kind=team&id=my-team"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.available).toBe(false);
-    expect(json.reason).toBe("team-workspace-exists");
-  });
-
-  it("returns available:false reason:team-agents-exist when agents with prefix exist", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "my-team-lead" }]),
-        stderr: "",
-      });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      agents: { defaults: { workspace: "/home/user/agents" } },
-    } as never);
-    vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-
-    const res = await GET(new Request("https://test/api/ids/check?kind=team&id=my-team"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.available).toBe(false);
-    expect(json.reason).toBe("team-agents-exist");
-  });
-
-  it("returns available:true for new team id", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([]),
-        stderr: "",
-      });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      agents: { defaults: { workspace: "/home/user/agents" } },
-    } as never);
-    vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-
-    const res = await GET(new Request("https://test/api/ids/check?kind=team&id=new-team"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.available).toBe(true);
-  });
-});

package/src/app/api/__tests__/marketplace-recipes-route.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../marketplace/recipes/route";
-import { GET as GET_SLUG } from "../marketplace/recipes/[slug]/route";
-
-vi.mock("@/lib/marketplace", () => ({
-  loadRegistry: vi.fn(),
-  search: vi.fn(),
-  getBySlug: vi.fn(),
-}));
-
-import { loadRegistry, search, getBySlug } from "@/lib/marketplace";
-
-const sampleRecipe = {
-  slug: "my-agent",
-  kind: "agent" as const,
-  name: "My Agent",
-  description: "Does stuff",
-  version: "1.0.0",
-  tags: ["agent"],
-  sourceUrl: "https://example.com",
-};
-
-describe("api marketplace recipes route", () => {
-  beforeEach(() => {
-    vi.mocked(loadRegistry).mockReset();
-    vi.mocked(search).mockReset();
-    vi.mocked(getBySlug).mockReset();
-  });
-
-  describe("GET /api/marketplace/recipes", () => {
-    it("returns recipes on success without query", async () => {
-      vi.mocked(loadRegistry).mockResolvedValue({
-        version: 1,
-        generatedAt: "2025-01-01",
-        recipes: [sampleRecipe],
-      });
-      vi.mocked(search).mockImplementation((recipes) => recipes);
-
-      const res = await GET(new Request("https://test/api/marketplace/recipes"));
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.recipes).toHaveLength(1);
-      expect(json.recipes[0].slug).toBe("my-agent");
-      expect(search).toHaveBeenCalledWith([sampleRecipe], null);
-    });
-
-    it("returns filtered recipes when query provided", async () => {
-      vi.mocked(loadRegistry).mockResolvedValue({
-        version: 1,
-        generatedAt: "2025-01-01",
-        recipes: [sampleRecipe],
-      });
-      vi.mocked(search).mockReturnValue([sampleRecipe]);
-
-      const res = await GET(new Request("https://test/api/marketplace/recipes?q=agent"));
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(search).toHaveBeenCalledWith([sampleRecipe], "agent");
-    });
-
-    it("returns 500 when loadRegistry throws", async () => {
-      vi.mocked(loadRegistry).mockRejectedValue(new Error("Registry error"));
-
-      const res = await GET(new Request("https://test/api/marketplace/recipes"));
-      expect(res.status).toBe(500);
-      const json = await res.json();
-      expect(json.ok).toBe(false);
-      expect(json.error).toBe("Registry error");
-    });
-  });
-
-  describe("GET /api/marketplace/recipes/[slug]", () => {
-    it("returns recipe when found", async () => {
-      vi.mocked(loadRegistry).mockResolvedValue({
-        version: 1,
-        generatedAt: "2025-01-01",
-        recipes: [sampleRecipe],
-      });
-      vi.mocked(getBySlug).mockReturnValue(sampleRecipe);
-
-      const res = await GET_SLUG(
-        new Request("https://test"),
-        { params: Promise.resolve({ slug: "my-agent" }) }
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.recipe.slug).toBe("my-agent");
-    });
-
-    it("returns 404 when not found", async () => {
-      vi.mocked(loadRegistry).mockResolvedValue({
-        version: 1,
-        generatedAt: "2025-01-01",
-        recipes: [],
-      });
-      vi.mocked(getBySlug).mockReturnValue(null);
-
-      const res = await GET_SLUG(
-        new Request("https://test"),
-        { params: Promise.resolve({ slug: "missing" }) }
-      );
-      expect(res.status).toBe(404);
-      const json = await res.json();
-      expect(json.ok).toBe(false);
-      expect(json.error).toBe("Not found");
-    });
-
-    it("returns 500 when loadRegistry throws", async () => {
-      vi.mocked(loadRegistry).mockRejectedValue(new Error("Load failed"));
-
-      const res = await GET_SLUG(
-        new Request("https://test"),
-        { params: Promise.resolve({ slug: "any" }) }
-      );
-      expect(res.status).toBe(500);
-      const json = await res.json();
-      expect(json.error).toBe("Load failed");
-    });
-  });
-});