@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,117 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET, PUT } from "../agents/file/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: { readFile: vi.fn(), mkdir: vi.fn(), writeFile: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import fs from "node:fs/promises";
-
-describe("api agents file route", () => {
-  const ws = "/mock-workspace/agent-1";
-
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-    vi.mocked(fs.mkdir).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "agent-1", workspace: ws }]),
-      stderr: "",
-    });
-  });
-
-  describe("GET", () => {
-    it("returns 400 when agentId or name missing", async () => {
-      const r1 = await GET(new Request("https://test?name=IDENTITY.md"));
-      expect(r1.status).toBe(400);
-      expect((await r1.json()).error).toBe("agentId is required");
-
-      const r2 = await GET(new Request("https://test?agentId=agent-1"));
-      expect(r2.status).toBe(400);
-      expect((await r2.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?agentId=agent-1&name=IDENTITY.md")
-      );
-      expect(res.status).toBe(404);
-    });
-
-    it("returns content on success", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue("# Identity\n\nContent");
-      const res = await GET(
-        new Request("https://test?agentId=agent-1&name=IDENTITY.md")
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.content).toBe("# Identity\n\nContent");
-    });
-
-    it("throws on path traversal", async () => {
-      await expect(
-        GET(new Request("https://test?agentId=agent-1&name=../etc/passwd"))
-      ).rejects.toThrow("Invalid file name");
-    });
-  });
-
-  describe("PUT", () => {
-    it("returns 400 when agentId, 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({ agentId: "a", content: "c" }),
-        })
-      );
-      expect(r2.status).toBe(400);
-
-      const r3 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ agentId: "a", name: "X" }),
-        })
-      );
-      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({
-            agentId: "agent-1",
-            name: "IDENTITY.md",
-            content: "# New",
-          }),
-        })
-      );
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(fs.writeFile).toHaveBeenCalledWith(
-        expect.stringContaining("IDENTITY.md"),
-        "# New",
-        "utf8"
-      );
-    });
-  });
-});

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

@@ -1,61 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../agents/files/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: { stat: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import fs from "node:fs/promises";
-
-describe("api agents files route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(fs.stat).mockReset();
-  });
-
-  it("returns 400 when agentId missing", async () => {
-    const res = await GET(new Request("https://test/api/agents/files"));
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("agentId is required");
-  });
-
-  it("returns ok with files", async () => {
-    const ws = "/mock-workspace/agent-1";
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "agent-1", workspace: ws }]),
-      stderr: "",
-    });
-    vi.mocked(fs.stat)
-      .mockResolvedValueOnce({ size: 100, mtimeMs: 123 } as never)
-      .mockRejectedValueOnce(new Error("ENOENT"));
-
-    const res = await GET(new Request("https://test/api/agents/files?agentId=agent-1"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.agentId).toBe("agent-1");
-    expect(json.workspace).toBe(ws);
-    expect(json.files).toBeDefined();
-    expect(json.files.some((f: { name: string }) => f.name === "IDENTITY.md")).toBe(true);
-  });
-
-  it("returns 404 when agent workspace not found", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "other" }]),
-      stderr: "",
-    });
-
-    const res = await GET(new Request("https://test/api/agents/files?agentId=missing"));
-    expect(res.status).toBe(404);
-    const json = await res.json();
-    expect(json.ok).toBe(false);
-    expect(json.error).toContain("workspace not found");
-  });
-});

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

@@ -1,104 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { DELETE } from "../agents/[id]/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: { mkdir: vi.fn(), rename: vi.fn(), rm: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-
-describe("api agents [id] route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-  });
-
-  it("returns 400 when id missing", async () => {
-    const res = await DELETE(
-      new Request("https://test", { method: "DELETE" }),
-      { params: Promise.resolve({ id: "" }) }
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("agent id is required");
-  });
-
-  it("returns 500 when runOpenClaw fails", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: false,
-      exitCode: 1,
-      stdout: "",
-      stderr: "Agent not found",
-    });
-
-    const res = await DELETE(
-      new Request("https://test", { method: "DELETE" }),
-      { params: Promise.resolve({ id: "my-agent" }) }
-    );
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("Failed to delete agent: my-agent");
-    expect(json.stderr).toBe("Agent not found");
-  });
-
-  it("returns ok on success", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify({ deleted: true }),
-      stderr: "",
-    });
-
-    const res = await DELETE(
-      new Request("https://test", { method: "DELETE" }),
-      { params: Promise.resolve({ id: "my-agent" }) }
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.result).toEqual({ deleted: true });
-  });
-
-  it("returns ok with raw stdout when JSON parse fails", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "plain text",
-      stderr: "",
-    });
-
-    const res = await DELETE(
-      new Request("https://test", { method: "DELETE" }),
-      { params: Promise.resolve({ id: "my-agent" }) }
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.result).toBe("plain text");
-  });
-
-  it("moves team role to trash when agent has workspace", async () => {
-    vi.mocked(runOpenClaw)
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([
-          { id: "team1-role1", workspace: "/var/workspace/workspace-team1/roles/role1" },
-        ]),
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify({ deleted: true }),
-        stderr: "",
-      });
-
-    const res = await DELETE(
-      new Request("https://test", { method: "DELETE" }),
-      { params: Promise.resolve({ id: "team1-role1" }) }
-    );
-    expect(res.status).toBe(200);
-    expect(res.ok).toBe(true);
-  });
-});

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

@@ -1,92 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../agents/identity/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-
-import { runOpenClaw } from "@/lib/openclaw";
-
-describe("api agents identity route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-  });
-
-  it("returns 400 when agentId 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("agentId is required");
-  });
-
-  it("returns ok with stdout/stderr on success", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "Updated identity",
-      stderr: "",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "my-agent" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.stdout).toBe("Updated identity");
-    expect(runOpenClaw).toHaveBeenCalledWith(["agents", "set-identity", "my-agent"]);
-  });
-
-  it("passes optional name, emoji, theme, avatar", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "",
-      stderr: "",
-    });
-
-    await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          agentId: "a",
-          name: "Bob",
-          emoji: "🤖",
-          theme: "dark",
-          avatar: "url",
-        }),
-      })
-    );
-    expect(runOpenClaw).toHaveBeenCalledWith([
-      "agents",
-      "set-identity",
-      "a",
-      "--name",
-      "Bob",
-      "--emoji",
-      "🤖",
-      "--theme",
-      "dark",
-      "--avatar",
-      "url",
-    ]);
-  });
-
-  it("returns 500 when runOpenClaw throws", async () => {
-    vi.mocked(runOpenClaw).mockRejectedValue(new Error("CLI failed"));
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "a" }),
-      })
-    );
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("Failed to set agent identity");
-    expect(json.message).toBe("CLI failed");
-  });
-});

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

@@ -1,54 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../agents/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-
-import { runOpenClaw } from "@/lib/openclaw";
-
-describe("api agents route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-  });
-
-  it("returns agents on success", async () => {
-    const agents = [
-      { id: "agent-1", identityName: "Agent 1", workspace: "/ws/1" },
-    ];
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify(agents),
-      stderr: "",
-    });
-
-    const res = await GET();
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.agents).toHaveLength(1);
-    expect(json.agents[0].id).toBe("agent-1");
-  });
-
-  it("returns 500 when runOpenClaw throws", async () => {
-    vi.mocked(runOpenClaw).mockRejectedValue(new Error("Command failed"));
-
-    const res = await GET();
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("Failed to list agents");
-    expect(json.message).toBe("Command failed");
-  });
-
-  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 list agents");
-  });
-});

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

@@ -1,131 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../agents/skills/install/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("@/lib/agent-workspace", () => ({ parseTeamRoleWorkspace: vi.fn() }));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { parseTeamRoleWorkspace } from "@/lib/agent-workspace";
-
-describe("api agents skills install route", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(parseTeamRoleWorkspace).mockReturnValue({ kind: "agent" as const });
-  });
-
-  it("returns 400 when agentId missing", async () => {
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ skill: "foo" }) })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("agentId is required");
-  });
-
-  it("returns 400 when skill missing", async () => {
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ agentId: "a1" }) })
-    );
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("skill is required");
-  });
-
-  it("returns 200 and installs at agent scope when not team role", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "installed",
-      stderr: "",
-    });
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "a1", workspace: "/ws/a1" }]),
-      stderr: "",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "a1", skill: "my-skill" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.agentId).toBe("a1");
-    expect(json.skill).toBe("my-skill");
-    expect(json.scopeArgs).toEqual([
-      "recipes",
-      "install-skill",
-      "my-skill",
-      "--agent-id",
-      "a1",
-      "--yes",
-    ]);
-  });
-
-  it("installs at team scope when agent has teamRole workspace", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: "installed",
-      stderr: "",
-    });
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "a1", workspace: "workspace-team1/roles/lead" }]),
-      stderr: "",
-    });
-    vi.mocked(parseTeamRoleWorkspace).mockReturnValue({
-      kind: "teamRole" as const,
-      teamId: "team1",
-      role: "lead",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "a1", skill: "my-skill" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.scopeArgs).toEqual([
-      "recipes",
-      "install-skill",
-      "my-skill",
-      "--team-id",
-      "team1",
-      "--yes",
-    ]);
-  });
-
-  it("returns 500 when runOpenClaw fails", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "a1" }]),
-      stderr: "",
-    });
-    vi.mocked(runOpenClaw).mockResolvedValueOnce({
-      ok: false,
-      exitCode: 1,
-      stdout: "stdout msg",
-      stderr: "stderr msg",
-    });
-
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "a1", skill: "bad-skill" }),
-      })
-    );
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.ok).toBe(false);
-    expect(json.error).toBe("stderr msg");
-  });
-});

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

@@ -1,64 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../agents/skills/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: { readdir: vi.fn() },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import fs from "node:fs/promises";
-
-describe("api agents skills route", () => {
-  const ws = "/mock-workspace/agent-1";
-
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(fs.readdir).mockReset();
-
-    vi.mocked(runOpenClaw).mockResolvedValue({
-      ok: true,
-      exitCode: 0,
-      stdout: JSON.stringify([{ id: "agent-1", workspace: ws }]),
-      stderr: "",
-    });
-  });
-
-  it("returns 400 when agentId missing", async () => {
-    const res = await GET(new Request("https://test"));
-    expect(res.status).toBe(400);
-    const json = await res.json();
-    expect(json.error).toBe("agentId is required");
-  });
-
-  it("returns sorted skills on success", async () => {
-    vi.mocked(fs.readdir).mockResolvedValue([
-      { name: "b-skill", isDirectory: () => true } as never,
-      { name: "a-skill", isDirectory: () => true } as never,
-      { name: "file.md", isDirectory: () => false } as never,
-    ]);
-
-    const res = await GET(
-      new Request("https://test?agentId=agent-1")
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.skills).toEqual(["a-skill", "b-skill"]);
-    expect(json.skillsDirs).toBeDefined();
-    expect(json.skillsDirs[0]).toContain("skills");
-  });
-
-  it("returns empty skills with note when readdir fails", async () => {
-    vi.mocked(fs.readdir).mockRejectedValue(new Error("ENOENT"));
-
-    const res = await GET(
-      new Request("https://test?agentId=agent-1")
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.skills).toEqual([]);
-    expect(json.note).toContain("ENOENT");
-  });
-});