@jiggai/kitchen 0.3.1 → 0.3.3

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

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

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

@@ -1,173 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../scaffold/route";
-import path from "node:path";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("@/lib/paths", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/paths")>();
-  return { ...actual, readOpenClawConfig: vi.fn() };
-});
-vi.mock("node:fs/promises", () => ({
-  default: { mkdir: vi.fn(), writeFile: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { readOpenClawConfig } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("api scaffold route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(readOpenClawConfig).mockReset();
-    vi.mocked(fs.mkdir).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-  });
-
-  it("returns ok on agent scaffold success", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "Done",
-      stderr: "",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ kind: "agent", recipeId: "my-agent" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.args).toEqual(["recipes", "scaffold", "my-agent"]);
-    expect(runOpenClaw).toHaveBeenCalledWith(["recipes", "scaffold", "my-agent"]);
-  });
-
-  it("returns ok on team scaffold success", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "Done",
-      stderr: "",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          kind: "team",
-          recipeId: "my-team",
-          teamId: "my-team",
-        }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.args).toContain("scaffold-team");
-    expect(json.args).toContain("--team-id");
-  });
-
-  it("returns 500 when runOpenClaw throws", async () => {
-    vi.mocked(runOpenClaw).mockRejectedValue(new Error("Command failed"));
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ kind: "agent", recipeId: "my-agent" }),
-      })
-    );
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.ok).toBe(false);
-    expect(json.error).toBe("Command failed");
-  });
-
-  it("applies cron override when cronInstallChoice yes", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "hash", stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: JSON.stringify([]), stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "off", stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "", stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "Done", stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "", stderr: "" });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          kind: "agent",
-          recipeId: "my-agent",
-          cronInstallChoice: "yes",
-        }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const calls = vi.mocked(runOpenClaw).mock.calls;
-    const configGetCalls = calls.filter((c) => c[0]?.[0] === "config" && c[0]?.[1] === "get");
-    const configSetCalls = calls.filter((c) => c[0]?.[0] === "config" && c[0]?.[1] === "set");
-    expect(configGetCalls.length).toBeGreaterThanOrEqual(1);
-    expect(configSetCalls.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it("persists team provenance on team scaffold", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "Done",
-      stderr: "",
-    });
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      agents: { defaults: { workspace: "/mock-workspace" } },
-    });
-    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({
-          kind: "team",
-          recipeId: "my-team",
-          teamId: "my-team",
-        }),
-      })
-    );
-    expect(res.status).toBe(200);
-    expect(fs.mkdir).toHaveBeenCalledWith(
-      path.resolve("/mock-workspace", "..", "workspace-my-team"),
-      { recursive: true }
-    );
-    expect(fs.writeFile).toHaveBeenCalledWith(
-      path.join(path.resolve("/mock-workspace", "..", "workspace-my-team"), "team.json"),
-      expect.stringContaining("my-team"),
-      "utf8"
-    );
-  });
-
-  it("attempts cron restore in finally when scaffold throws after override", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "hash", stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: JSON.stringify([]), stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "off", stderr: "" })
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "", stderr: "" })
-      .mockRejectedValueOnce(new Error("Scaffold failed"))
-      .mockResolvedValueOnce({ ok: true, exitCode: 0, stdout: "", stderr: "" });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          kind: "agent",
-          recipeId: "my-agent",
-          cronInstallChoice: "yes",
-        }),
-      })
-    );
-    expect(res.status).toBe(500);
-    const calls = vi.mocked(runOpenClaw).mock.calls;
-    const configSetCalls = calls.filter((c) => c[0]?.[0] === "config" && c[0]?.[1] === "set");
-    expect(configSetCalls.length).toBeGreaterThanOrEqual(2);
-  });
-});

package/src/app/api/__tests__/settings-cron-installation-route.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET, PUT } from "../settings/cron-installation/route";
-
-vi.mock("@/lib/gateway", () => ({
-  gatewayConfigGet: vi.fn(),
-  gatewayConfigPatch: vi.fn(),
-}));
-
-import { gatewayConfigGet, gatewayConfigPatch } from "@/lib/gateway";
-
-describe("api settings cron-installation route", () => {
-  beforeEach(() => {
-    vi.mocked(gatewayConfigGet).mockReset();
-    vi.mocked(gatewayConfigPatch).mockReset();
-
-    vi.mocked(gatewayConfigGet).mockResolvedValue({
-      raw: JSON.stringify({
-        plugins: {
-          entries: { recipes: { config: { cronInstallation: "prompt" } } },
-        },
-      }),
-      hash: "abc",
-    });
-    vi.mocked(gatewayConfigPatch).mockResolvedValue(undefined);
-  });
-
-  describe("GET", () => {
-    it("returns path and value", async () => {
-      const res = await GET();
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.path).toBe("plugins.entries.recipes.config.cronInstallation");
-      expect(json.value).toBe("prompt");
-    });
-  });
-
-  describe("PUT", () => {
-    it("returns 400 when value invalid", async () => {
-      const r1 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ value: "invalid" }),
-        })
-      );
-      expect(r1.status).toBe(400);
-      expect((await r1.json()).error).toContain("off|prompt|on");
-
-      const r2 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({}),
-        })
-      );
-      expect(r2.status).toBe(400);
-    });
-
-    it("returns ok and patches on valid value", async () => {
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ value: "on" }),
-        })
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.value).toBe("on");
-      expect(gatewayConfigPatch).toHaveBeenCalledWith(
-        expect.objectContaining({
-          plugins: {
-            entries: {
-              recipes: {
-                config: { cronInstallation: "on" },
-              },
-            },
-          },
-        }),
-        expect.any(String)
-      );
-    });
-  });
-});

package/src/app/api/__tests__/skills-available-route.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../skills/available/route";
-
-vi.mock("node:fs/promises", () => ({
-  default: { readdir: vi.fn() },
-}));
-vi.mock("node:os", () => ({
-  default: { homedir: () => "/home/user" },
-}));
-
-import fs from "node:fs/promises";
-
-describe("api skills available route", () => {
-  beforeEach(() => {
-    vi.mocked(fs.readdir).mockReset();
-  });
-
-  it("returns skills from ~/.openclaw/skills", async () => {
-    vi.mocked(fs.readdir).mockResolvedValue([
-      { name: "skill-a", isDirectory: () => true } as never,
-      { name: "skill-b", isDirectory: () => true } as never,
-      { name: "file.txt", isDirectory: () => false } as never,
-    ] as never[]);
-
-    const res = await GET();
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.skillsDir).toContain(".openclaw/skills");
-    expect(json.skills).toEqual(["skill-a", "skill-b"]);
-    expect(fs.readdir).toHaveBeenCalledWith(
-      expect.stringContaining(".openclaw/skills"),
-      { withFileTypes: true }
-    );
-  });
-
-  it("returns empty skills when dir missing", async () => {
-    vi.mocked(fs.readdir).mockRejectedValue(new Error("ENOENT"));
-
-    const res = await GET();
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.skills).toEqual([]);
-    expect(json.note).toBe("ENOENT");
-  });
-});

package/src/app/api/__tests__/swarms-start-route.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../swarms/start/route";
-
-vi.mock("@/lib/kitchen-api", () => ({
-  getKitchenApi: vi.fn(() => ({
-    runtime: {
-      system: {
-        runCommandWithTimeout: vi.fn().mockResolvedValue({ stdout: "", stderr: "" }),
-      },
-    },
-  })),
-}));
-
-vi.mock("node:fs/promises", () => ({
-  default: {
-    access: vi.fn().mockResolvedValue(undefined),
-    writeFile: vi.fn().mockResolvedValue(undefined),
-    unlink: vi.fn().mockResolvedValue(undefined),
-  },
-}));
-
-describe("api swarms start route", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("returns 400 when orchestratorAgentId missing", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ taskId: "t1", spec: "do something" }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toMatch(/orchestratorAgentId.*required/i);
-  });
-
-  it("returns 400 when taskId missing", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ orchestratorAgentId: "team1-swarm-orchestrator", spec: "do something" }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toMatch(/taskId.*required/i);
-  });
-
-  it("returns 400 when neither spec nor specFile provided", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ orchestratorAgentId: "team1-swarm-orchestrator", taskId: "t1" }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toMatch(/spec|specFile/i);
-  });
-
-  it("returns 400 when both spec and specFile provided", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          orchestratorAgentId: "team1-swarm-orchestrator",
-          taskId: "t1",
-          spec: "x",
-          specFile: "/home/test/x.md",
-        }),
-      })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toMatch(/exactly one/i);
-  });
-});

package/src/app/api/__tests__/swarms-status-route.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../swarms/status/route";
-
-vi.mock("@/lib/kitchen-api", () => ({
-  getKitchenApi: vi.fn(() => ({
-    runtime: {
-      system: {
-        runCommandWithTimeout: vi.fn().mockResolvedValue({ stdout: "", stderr: "" }),
-      },
-    },
-  })),
-}));
-
-vi.mock("node:fs/promises", () => ({
-  default: {
-    readFile: vi.fn().mockResolvedValue(JSON.stringify({ agents: { defaults: { workspace: "/home" } } })),
-    access: vi.fn().mockResolvedValue(undefined),
-  },
-}));
-
-describe("api swarms status route", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("returns 400 when orchestratorAgentId missing", async () => {
-    const res = await GET(new Request("https://test"));
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toMatch(/orchestratorAgentId.*required/i);
-  });
-
-  it("returns 200 when orchestratorAgentId provided", async () => {
-    const res = await GET(
-      new Request("https://test?orchestratorAgentId=team1-swarm-orchestrator")
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.orchestratorWorkspace).toBeDefined();
-  });
-});

package/src/app/api/__tests__/teams-file-route.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET, PUT } from "../teams/file/route";
-
-vi.mock("@/lib/paths", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/paths")>();
-  return { ...actual, readOpenClawConfig: vi.fn() };
-});
-vi.mock("node:fs/promises", () => ({
-  default: {
-    readFile: vi.fn(),
-    mkdir: vi.fn(),
-    writeFile: vi.fn(),
-  },
-}));
-
-import { readOpenClawConfig } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("api teams file route", () => {
-  const baseWorkspace = "/mock-workspace";
-
-  beforeEach(() => {
-    vi.mocked(readOpenClawConfig).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-    vi.mocked(fs.mkdir).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-
-    vi.mocked(readOpenClawConfig).mockResolvedValue({
-      agents: { defaults: { workspace: baseWorkspace } },
-    });
-  });
-
-  it("returns 400 when teamId missing", async () => {
-    const res = await GET(new Request("https://test/api/teams/file?name=TEAM.md"));
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("teamId is required");
-  });
-
-  it("returns 400 when name missing", async () => {
-    const res = await GET(new Request("https://test/api/teams/file?teamId=my-team"));
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("name is required");
-  });
-
-  it("returns 404 when file missing", async () => {
-    vi.mocked(fs.readFile).mockRejectedValue(new Error("ENOENT"));
-
-    const res = await GET(
-      new Request("https://test/api/teams/file?teamId=my-team&name=TEAM.md")
-    );
-    expect(res.status).toBe(404);
-    const json = await res.json();
-    expect(json.ok).toBe(false);
-  });
-
-  it("returns content on success", async () => {
-    vi.mocked(fs.readFile).mockResolvedValue("# Team\n\nContent");
-
-    const res = await GET(
-      new Request("https://test/api/teams/file?teamId=my-team&name=TEAM.md")
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.content).toBe("# Team\n\nContent");
-    expect(json.name).toBe("TEAM.md");
-  });
-
-  it("throws on path traversal in name", async () => {
-    await expect(
-      GET(new Request("https://test/api/teams/file?teamId=my-team&name=../etc/passwd"))
-    ).rejects.toThrow("Invalid file name");
-  });
-
-  describe("PUT", () => {
-    it("returns 400 when teamId, name, or content missing", async () => {
-      const r1 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ name: "X", content: "c" }),
-        })
-      );
-      expect(r1.status).toBe(400);
-
-      const r2 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ teamId: "my-team", content: "c" }),
-        })
-      );
-      expect(r2.status).toBe(400);
-
-      const r3 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ teamId: "my-team", name: "TEAM.md" }),
-        })
-      );
-      expect(r3.status).toBe(400);
-    });
-
-    it("writes file and returns ok", async () => {
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({
-            teamId: "my-team",
-            name: "TEAM.md",
-            content: "# Team\n\nNew content",
-          }),
-        })
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.name).toBe("TEAM.md");
-      expect(fs.writeFile).toHaveBeenCalledWith(
-        expect.stringContaining("TEAM.md"),
-        "# Team\n\nNew content",
-        "utf8"
-      );
-    });
-  });
-});