@jiggai/kitchen 0.1.12 → 0.2.0

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

@@ -0,0 +1,143 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { POST } from "../agents/add/route";
+import path from "node:path";
+
+const mockRunCommand = vi.hoisted(() => vi.fn());
+
+vi.mock("@/lib/kitchen-api", () => ({
+  getKitchenApi: () => ({
+    runtime: {
+      system: {
+        runCommandWithTimeout: mockRunCommand,
+      },
+    },
+  }),
+}));
+vi.mock("node:fs/promises", () => ({
+  default: {
+    readFile: vi.fn(),
+    mkdir: vi.fn(),
+    writeFile: vi.fn(),
+    copyFile: vi.fn(),
+    rename: vi.fn(),
+  },
+}));
+
+import fs from "node:fs/promises";
+
+const baseWorkspace = "/mock-workspace";
+const existingConfig = {
+  agents: {
+    defaults: { workspace: baseWorkspace },
+    list: [{ id: "existing", workspace: "/ws/existing" }],
+  },
+};
+
+describe("api agents add route", () => {
+  beforeEach(() => {
+    mockRunCommand.mockReset();
+    vi.mocked(fs.readFile).mockReset();
+    vi.mocked(fs.mkdir).mockReset();
+    vi.mocked(fs.writeFile).mockReset();
+    vi.mocked(fs.copyFile).mockReset();
+    vi.mocked(fs.rename).mockReset();
+
+    vi.stubEnv("HOME", "/mock-home");
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(existingConfig));
+    vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+    vi.mocked(fs.copyFile).mockResolvedValue(undefined);
+    vi.mocked(fs.rename).mockResolvedValue(undefined);
+    mockRunCommand.mockResolvedValue({ stdout: "", stderr: "" });
+  });
+
+  it("returns 400 when agent 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).toContain("agent id is required");
+  });
+
+  it("returns 400 when agent id invalid format", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ newAgentId: "bad id!" }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toContain("match");
+  });
+
+  it("returns 500 when HOME not set", async () => {
+    vi.stubEnv("HOME", "");
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ newAgentId: "my-agent" }),
+      })
+    );
+    expect(res.status).toBe(500);
+    const json = await res.json();
+    expect(json.error).toBe("HOME is not set");
+  });
+
+  it("returns 500 when workspace not set in config", async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      JSON.stringify({ agents: {} })
+    );
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ newAgentId: "my-agent" }),
+      })
+    );
+    expect(res.status).toBe(500);
+    const json = await res.json();
+    expect(json.error).toBe("agents.defaults.workspace not set");
+  });
+
+  it("returns 409 when agent exists and overwrite false", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ newAgentId: "existing" }),
+      })
+    );
+    expect(res.status).toBe(409);
+    const json = await res.json();
+    expect(json.error).toBe("Agent already exists: existing");
+  });
+
+  it("returns ok and restarts gateway on success", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({
+          newAgentId: "my-agent",
+          name: "My Agent",
+        }),
+      })
+    );
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.agentId).toBe("my-agent");
+    expect(json.restarted).toBe(true);
+    expect(json.workspace).toBe(
+      path.resolve(baseWorkspace, "..", "workspace-my-agent")
+    );
+    expect(mockRunCommand).toHaveBeenCalledWith(
+      ["openclaw", "gateway", "restart"],
+      expect.objectContaining({ timeoutMs: 120000 })
+    );
+  });
+});

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

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

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

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

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

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

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