@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,221 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../recipes/clone/route";
-import path from "node:path";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("@/lib/paths", () => ({ getWorkspaceRecipesDir: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: { stat: vi.fn(), mkdir: vi.fn(), writeFile: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { getWorkspaceRecipesDir } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-const sampleRecipe = `---
-id: source-agent
-kind: agent
-name: Source Agent
----
-# Content`;
-
-describe("api recipes clone route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(getWorkspaceRecipesDir).mockReset();
-    vi.mocked(fs.stat).mockReset();
-    vi.mocked(fs.mkdir).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-  });
-
-  it("returns 400 when fromId missing", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ toId: "target" }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("Missing fromId");
-  });
-
-  it("returns 400 when toId missing", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ fromId: "source" }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("Missing toId");
-  });
-
-  it("returns 400 when recipes show fails", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: false,
-      exitCode: 1,
-      stdout: "",
-      stderr: "Not found",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ fromId: "source", toId: "target" }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("Not found");
-  });
-
-  it("clones and returns ok for agent", async () => {
-    const dir = "/mock-workspace/recipes";
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: sampleRecipe,
-      stderr: "",
-    });
-    vi.mocked(getWorkspaceRecipesDir).mockResolvedValue(dir);
-    vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-    vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ fromId: "source-agent", toId: "my-agent" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.recipeId).toBe("my-agent");
-    expect(json.filePath).toBe(path.join(dir, "my-agent.md"));
-    expect(fs.writeFile).toHaveBeenCalledWith(
-      path.join(dir, "my-agent.md"),
-      expect.stringContaining("id: my-agent"),
-      "utf8"
-    );
-  });
-
-  it("returns 409 when target exists and overwrite false", async () => {
-    const dir = "/mock-workspace/recipes";
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: sampleRecipe,
-      stderr: "",
-    });
-    vi.mocked(getWorkspaceRecipesDir).mockResolvedValue(dir);
-    vi.mocked(fs.stat).mockResolvedValue({} as never);
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ fromId: "source-agent", toId: "existing" }),
-      })
-    );
-    expect(res.status).toBe(409);
-    const json = await res.json();
-    expect(json.error).toContain("already exists");
-    expect(json.code).toBe("RECIPE_ID_TAKEN");
-    expect(json.suggestions).toContain("custom-existing");
-  });
-
-  it("scaffolds when scaffold true for agent", async () => {
-    const dir = "/mock-workspace/recipes";
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: sampleRecipe,
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: "",
-        stderr: "",
-      });
-    vi.mocked(getWorkspaceRecipesDir).mockResolvedValue(dir);
-    vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-    vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          fromId: "source-agent",
-          toId: "my-agent",
-          scaffold: true,
-        }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.scaffold?.ok).toBe(true);
-    expect(runOpenClaw).toHaveBeenCalledTimes(2);
-    expect(runOpenClaw).toHaveBeenNthCalledWith(2, [
-      "recipes",
-      "scaffold",
-      "my-agent",
-      "--agent-id",
-      "my-agent",
-      "--overwrite",
-      "--overwrite-recipe",
-    ]);
-  });
-
-  it("scaffolds team when kind is team", async () => {
-    const teamRecipe = `---
-id: source-team
-kind: team
-name: Source Team
----
-# Team body`;
-    const dir = "/mock-workspace/recipes";
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: teamRecipe,
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: "",
-        stderr: "",
-      });
-    vi.mocked(getWorkspaceRecipesDir).mockResolvedValue(dir);
-    vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-    vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          fromId: "source-team",
-          toId: "my-team",
-          scaffold: true,
-        }),
-      })
-    );
-    expect(res.status).toBe(200);
-    expect(runOpenClaw).toHaveBeenNthCalledWith(2, [
-      "recipes",
-      "scaffold-team",
-      "my-team",
-      "--team-id",
-      "my-team",
-      "--overwrite",
-      "--overwrite-recipe",
-    ]);
-  });
-});

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

@@ -1,248 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../recipes/delete/route";
-import path from "node:path";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("@/lib/recipes", () => ({
-  findRecipeById: vi.fn(),
-  resolveRecipePath: vi.fn(),
-}));
-vi.mock("node:fs/promises", () => ({
-  default: { stat: vi.fn(), rm: vi.fn(), readdir: vi.fn(), readFile: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { findRecipeById, resolveRecipePath } from "@/lib/recipes";
-import fs from "node:fs/promises";
-
-const workspaceItem = {
-  id: "my-agent",
-  name: "My Agent",
-  kind: "agent" as const,
-  source: "workspace" as const,
-};
-
-const teamWorkspaceItem = {
-  id: "my-team",
-  name: "My Team",
-  kind: "team" as const,
-  source: "workspace" as const,
-};
-
-const builtinItem = {
-  id: "builtin-recipe",
-  name: "Builtin",
-  kind: "agent" as const,
-  source: "builtin" as const,
-};
-
-describe("api recipes delete route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(findRecipeById).mockReset();
-    vi.mocked(resolveRecipePath).mockReset();
-    vi.mocked(fs.stat).mockReset();
-    vi.mocked(fs.rm).mockReset();
-    vi.mocked(fs.readdir).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-  });
-
-  it("returns 400 when id 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 is required");
-  });
-
-  it("returns 404 when list fails or recipe not found", async () => {
-    vi.mocked(findRecipeById).mockResolvedValue(null);
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "x" }) })
-    );
-    expect(res.status).toBe(404);
-    const json = await res.json();
-    expect(json.error).toBe("Recipe not found: x");
-  });
-
-  it("returns 404 when recipe not found", async () => {
-    vi.mocked(findRecipeById).mockResolvedValue(null);
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "missing" }) })
-    );
-    expect(res.status).toBe(404);
-    const json = await res.json();
-    expect(json.error).toBe("Recipe not found: missing");
-  });
-
-  it("returns 403 when builtin", async () => {
-    vi.mocked(findRecipeById).mockResolvedValue(builtinItem);
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ id: "builtin-recipe" }),
-      })
-    );
-    expect(res.status).toBe(403);
-    const json = await res.json();
-    expect(json.error).toContain("builtin and cannot be deleted");
-  });
-
-  it("returns 500 when workspace not set", async () => {
-    vi.mocked(findRecipeById).mockResolvedValue(workspaceItem);
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: "",
-      stderr: "",
-    });
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "my-agent" }) })
-    );
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("agents.defaults.workspace not set");
-  });
-
-  it("returns 403 when path outside workspace", async () => {
-    const wsRoot = "/mock-workspace";
-    vi.mocked(findRecipeById).mockResolvedValue(workspaceItem);
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: wsRoot,
-      stderr: "",
-    });
-    vi.mocked(resolveRecipePath).mockResolvedValue("/outside/path/recipe.md");
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "my-agent" }) })
-    );
-    expect(res.status).toBe(403);
-    const json = await res.json();
-    expect(json.error).toContain("Refusing to delete non-workspace recipe path");
-  });
-
-  it("returns 409 when team has workspace", async () => {
-    const wsRoot = "/mock-workspace";
-    vi.mocked(findRecipeById).mockResolvedValue(teamWorkspaceItem);
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: wsRoot,
-      stderr: "",
-    });
-    vi.mocked(resolveRecipePath).mockResolvedValue(
-      path.join(wsRoot, "recipes", "my-team.md")
-    );
-    vi.mocked(fs.readdir).mockResolvedValue([
-      { name: "workspace-my-team", isDirectory: () => true } as never,
-    ]);
-    vi.mocked(fs.readFile).mockResolvedValue(
-      JSON.stringify({ recipeId: "my-team", teamId: "my-team" })
-    );
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "my-team" }) })
-    );
-    expect(res.status).toBe(409);
-    const json = await res.json();
-    expect(json.error).toContain("in use by installed team");
-    expect(json.details.attachedTeams).toContain("my-team");
-  });
-
-  it("returns 200 when team has agents in config but no attached workspace", async () => {
-    const wsRoot = "/mock-workspace";
-    vi.mocked(findRecipeById).mockResolvedValue(teamWorkspaceItem);
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: wsRoot,
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "my-team-lead" }]),
-        stderr: "",
-      });
-    vi.mocked(resolveRecipePath).mockResolvedValue(
-      path.join(wsRoot, "recipes", "my-team.md")
-    );
-    vi.mocked(fs.readdir).mockResolvedValue([]);
-    vi.mocked(fs.rm).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "my-team" }) })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-  });
-
-  it("deletes and returns ok for agent recipe", async () => {
-    const wsRoot = "/mock-workspace";
-    const filePath = path.join(wsRoot, "recipes", "my-agent.md");
-    vi.mocked(findRecipeById).mockResolvedValue(workspaceItem);
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: wsRoot,
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "other-agent" }]),
-        stderr: "",
-      });
-    vi.mocked(resolveRecipePath).mockResolvedValue(filePath);
-    vi.mocked(fs.readFile).mockRejectedValue(new Error("ENOENT"));
-    vi.mocked(fs.rm).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "my-agent" }) })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.deleted).toBe(path.resolve(filePath));
-    expect(fs.rm).toHaveBeenCalledWith(path.resolve(filePath), { force: true });
-  });
-
-  it("deletes team recipe when not installed", async () => {
-    const wsRoot = "/mock-workspace";
-    const filePath = path.join(wsRoot, "recipes", "my-team.md");
-    vi.mocked(findRecipeById).mockResolvedValue(teamWorkspaceItem);
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: wsRoot,
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "other-agent" }]),
-        stderr: "",
-      });
-    vi.mocked(resolveRecipePath).mockResolvedValue(filePath);
-    vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-    vi.mocked(fs.rm).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "my-team" }) })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-  });
-});

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

@@ -1,166 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET, PUT } from "../recipes/[id]/route";
-import path from "node:path";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("@/lib/recipes", () => ({
-  findRecipeById: vi.fn(),
-  parseFrontmatterId: vi.fn(),
-  resolveRecipePath: vi.fn(),
-  writeRecipeFile: vi.fn(),
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { findRecipeById, parseFrontmatterId, resolveRecipePath, writeRecipeFile } from "@/lib/recipes";
-
-const workspaceItem = {
-  id: "my-recipe",
-  name: "My Recipe",
-  kind: "agent" as const,
-  source: "workspace" as const,
-};
-
-const builtinItem = {
-  id: "builtin-recipe",
-  name: "Builtin",
-  kind: "agent" as const,
-  source: "builtin" as const,
-};
-
-describe("api recipes [id] route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(findRecipeById).mockReset();
-    vi.mocked(resolveRecipePath).mockReset();
-    vi.mocked(writeRecipeFile).mockReset();
-    vi.mocked(parseFrontmatterId).mockReset();
-  });
-
-  describe("GET /api/recipes/[id]", () => {
-    it("returns 404 when recipe not in list", async () => {
-      vi.mocked(findRecipeById).mockResolvedValue(null);
-
-      const res = await GET(new Request("https://test"), {
-        params: Promise.resolve({ id: "missing" }),
-      });
-      expect(res.status).toBe(404);
-      const json = await res.json();
-      expect(json.error).toBe("Recipe not found: missing");
-    });
-
-    it("returns recipe with content on success", async () => {
-      vi.mocked(findRecipeById).mockResolvedValue(workspaceItem);
-      vi.mocked(runOpenClaw).mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: "# Recipe content",
-        stderr: "",
-      });
-      vi.mocked(resolveRecipePath).mockResolvedValue("/mock/recipes/my-recipe.md");
-
-      const res = await GET(new Request("https://test"), {
-        params: Promise.resolve({ id: "my-recipe" }),
-      });
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.recipe.id).toBe("my-recipe");
-      expect(json.recipe.content).toBe("# Recipe content");
-      expect(json.recipe.filePath).toBe("/mock/recipes/my-recipe.md");
-    });
-
-    it("returns filePath null when resolveRecipePath rejects", async () => {
-      vi.mocked(findRecipeById).mockResolvedValue(workspaceItem);
-      vi.mocked(runOpenClaw).mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: "# Content",
-        stderr: "",
-      });
-      vi.mocked(resolveRecipePath).mockRejectedValue(new Error("no path"));
-
-      const res = await GET(new Request("https://test"), {
-        params: Promise.resolve({ id: "my-recipe" }),
-      });
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.recipe.filePath).toBeNull();
-    });
-  });
-
-  describe("PUT /api/recipes/[id]", () => {
-    it("returns 400 when content missing", async () => {
-      const res = await PUT(
-        new Request("https://test", { method: "PUT", body: JSON.stringify({}) }),
-        { params: Promise.resolve({ id: "my-recipe" }) }
-      );
-      expect(res.status).toBe(400);
-      const json = await res.json();
-      expect(json.error).toBe("Missing content");
-    });
-
-    it("returns 400 when frontmatter id mismatch", async () => {
-      vi.mocked(parseFrontmatterId).mockReturnValue("other-id");
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ content: "---\nid: other-id\n---\nbody" }),
-        }),
-        { params: Promise.resolve({ id: "my-recipe" }) }
-      );
-      expect(res.status).toBe(400);
-      const json = await res.json();
-      expect(json.error).toContain("Frontmatter id (other-id) must match URL id (my-recipe)");
-    });
-
-    it("returns 404 when recipe not found", async () => {
-      vi.mocked(parseFrontmatterId).mockReturnValue("my-recipe");
-      vi.mocked(findRecipeById).mockResolvedValue(null);
-
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ content: "---\nid: my-recipe\n---\nbody" }),
-        }),
-        { params: Promise.resolve({ id: "my-recipe" }) }
-      );
-      expect(res.status).toBe(404);
-    });
-
-    it("returns 403 when builtin recipe", async () => {
-      vi.mocked(parseFrontmatterId).mockReturnValue("builtin-recipe");
-      vi.mocked(findRecipeById).mockResolvedValue(builtinItem);
-
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ content: "---\nid: builtin-recipe\n---\nbody" }),
-        }),
-        { params: Promise.resolve({ id: "builtin-recipe" }) }
-      );
-      expect(res.status).toBe(403);
-      const json = await res.json();
-      expect(json.error).toContain("builtin and cannot be modified");
-    });
-
-    it("writes and returns ok on success", async () => {
-      const content = "---\nid: my-recipe\n---\nBody text";
-      vi.mocked(parseFrontmatterId).mockReturnValue("my-recipe");
-      vi.mocked(findRecipeById).mockResolvedValue(workspaceItem);
-      vi.mocked(resolveRecipePath).mockResolvedValue(path.join("/mock", "my-recipe.md"));
-      vi.mocked(writeRecipeFile).mockResolvedValue(undefined);
-
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ content }),
-        }),
-        { params: Promise.resolve({ id: "my-recipe" }) }
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.filePath).toBe(path.join("/mock", "my-recipe.md"));
-      expect(writeRecipeFile).toHaveBeenCalledWith(path.join("/mock", "my-recipe.md"), content);
-    });
-  });
-});

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

@@ -1,57 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../recipes/route";
-
-vi.mock("@/lib/openclaw", () => ({
-  runOpenClaw: vi.fn(),
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-
-describe("api recipes route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-  });
-
-  it("returns recipes when openclaw outputs valid JSON array", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "r1", name: "Recipe 1" }]),
-      stderr: "",
-    });
-
-    const res = await GET();
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.recipes).toHaveLength(1);
-    expect(json.recipes[0].id).toBe("r1");
-  });
-
-  it("returns 500 when stdout is invalid JSON", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "not json",
-      stderr: "",
-    });
-
-    const res = await GET();
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("Failed to parse openclaw recipes list output");
-  });
-
-  it("returns empty array when data is not array", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify({ not: "array" }),
-      stderr: "",
-    });
-
-    const res = await GET();
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.recipes).toEqual([]);
-  });
-});