@jiggai/kitchen 0.1.11 → 0.2.0

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

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,57 @@
+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([]);
+  });
+});

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

@@ -0,0 +1,135 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { POST } from "../recipes/team-agents/route";
+import path from "node:path";
+
+vi.mock("@/lib/paths", () => ({ getWorkspaceRecipesDir: vi.fn() }));
+vi.mock("node:fs/promises", () => ({
+  default: { readFile: vi.fn(), writeFile: vi.fn() },
+}));
+
+import { getWorkspaceRecipesDir } from "@/lib/paths";
+import fs from "node:fs/promises";
+
+const teamRecipeMd = `---
+kind: team
+agents:
+  - role: lead
+    name: Lead
+---
+# Team body`;
+
+describe("api recipes team-agents route", () => {
+  const dir = "/mock-workspace/recipes";
+
+  beforeEach(() => {
+    vi.mocked(getWorkspaceRecipesDir).mockReset();
+    vi.mocked(fs.readFile).mockReset();
+    vi.mocked(fs.writeFile).mockReset();
+
+    vi.mocked(getWorkspaceRecipesDir).mockResolvedValue(dir);
+    vi.mocked(fs.readFile).mockResolvedValue(teamRecipeMd);
+    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+  });
+
+  it("returns 400 when recipeId missing", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ op: "add", role: "qa" }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("recipeId is required");
+  });
+
+  it("returns 400 when op invalid", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ recipeId: "my-team", op: "invalid", role: "qa" }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("op must be add|remove|addLike");
+  });
+
+  it("throws when role invalid", async () => {
+    await expect(
+      POST(
+        new Request("https://test", {
+          method: "POST",
+          body: JSON.stringify({ recipeId: "my-team", op: "add", role: "" }),
+        })
+      )
+    ).rejects.toThrow("role is required");
+  });
+
+  it("returns 400 when kind is not team", async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(`---
+kind: agent
+---
+# Body`);
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ recipeId: "agent-recipe", op: "add", role: "qa" }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toContain("kind must be team");
+  });
+
+  it("adds agent and returns ok", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({
+          recipeId: "my-team",
+          op: "add",
+          role: "qa",
+          name: "QA",
+        }),
+      })
+    );
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.recipeId).toBe("my-team");
+    expect(json.agents).toContainEqual(expect.objectContaining({ role: "qa", name: "QA" }));
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.join(dir, "my-team.md"),
+      expect.stringContaining("role: qa"),
+      "utf8"
+    );
+  });
+
+  it("removes agent", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ recipeId: "my-team", op: "remove", role: "lead" }),
+      })
+    );
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.agents).not.toContainEqual(expect.objectContaining({ role: "lead" }));
+  });
+
+  it("throws when fs.readFile fails", async () => {
+    vi.mocked(fs.readFile).mockRejectedValue(new Error("ENOENT"));
+
+    await expect(
+      POST(
+        new Request("https://test", {
+          method: "POST",
+          body: JSON.stringify({ recipeId: "missing", op: "add", role: "qa" }),
+        })
+      )
+    ).rejects.toThrow();
+  });
+});