@jiggai/kitchen 0.1.12 → 0.2.0

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

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

@@ -0,0 +1,123 @@
+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");
+    });
+  });
+});

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

@@ -0,0 +1,221 @@
+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",
+    ]);
+  });
+});