@jiggai/kitchen 0.1.11 → 0.2.0

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

@@ -0,0 +1,113 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { GET, POST } from "../teams/meta/route";
+import path from "node:path";
+
+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 meta 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 } },
+    });
+  });
+
+  describe("GET", () => {
+    it("returns 400 when teamId missing", async () => {
+      const res = await GET(new Request("https://test/api/teams/meta"));
+      expect(res.status).toBe(400);
+      expect((await res.json()).error).toBe("teamId is required");
+    });
+
+    it("returns 500 when workspace not set", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({});
+      const res = await GET(new Request("https://test/api/teams/meta?teamId=my-team"));
+      expect(res.status).toBe(500);
+      expect((await res.json()).error).toBe("agents.defaults.workspace not set");
+    });
+
+    it("returns meta when file exists", async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify({ teamId: "my-team", recipeId: "r1" })
+      );
+      const res = await GET(new Request("https://test/api/teams/meta?teamId=my-team"));
+      expect(res.status).toBe(200);
+      const json = await res.json();
+      expect(json.ok).toBe(true);
+      expect(json.meta).toEqual({ teamId: "my-team", recipeId: "r1" });
+    });
+
+    it("returns missing true when file not found", async () => {
+      vi.mocked(fs.readFile).mockRejectedValue(new Error("ENOENT"));
+      const res = await GET(new Request("https://test/api/teams/meta?teamId=my-team"));
+      expect(res.status).toBe(200);
+      const json = await res.json();
+      expect(json.ok).toBe(true);
+      expect(json.meta).toBeNull();
+      expect(json.missing).toBe(true);
+    });
+  });
+
+  describe("POST", () => {
+    it("returns 400 when teamId or recipeId missing", async () => {
+      const res1 = await POST(
+        new Request("https://test", {
+          method: "POST",
+          body: JSON.stringify({ recipeId: "r1" }),
+        })
+      );
+      expect(res1.status).toBe(400);
+      expect((await res1.json()).error).toBe("teamId is required");
+
+      const res2 = await POST(
+        new Request("https://test", {
+          method: "POST",
+          body: JSON.stringify({ teamId: "t1" }),
+        })
+      );
+      expect(res2.status).toBe(400);
+      expect((await res2.json()).error).toBe("recipeId is required");
+    });
+
+    it("writes meta and returns ok", async () => {
+      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({
+            teamId: "my-team",
+            recipeId: "my-recipe",
+            recipeName: "My Recipe",
+          }),
+        })
+      );
+      expect(res.status).toBe(200);
+      const json = await res.json();
+      expect(json.ok).toBe(true);
+      expect(json.meta.teamId).toBe("my-team");
+      expect(json.meta.recipeId).toBe("my-recipe");
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.join(path.resolve(baseWorkspace, "..", "workspace-my-team"), "team.json"),
+        expect.stringContaining("my-team"),
+        "utf8"
+      );
+    });
+  });
+});

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

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { POST } from "../teams/orchestrator/install/route";
+
+vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
+vi.mock("node:fs/promises", () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    readdir: vi.fn(),
+    chmod: vi.fn(),
+  },
+}));
+
+import { runOpenClaw } from "@/lib/openclaw";
+
+describe("api teams orchestrator install route", () => {
+  beforeEach(() => {
+    vi.mocked(runOpenClaw).mockReset();
+  });
+
+  it("returns 400 when teamId missing", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({
+          orchestratorAgentId: "team1-swarm-orchestrator",
+          repoDir: "/home/test/repo",
+        }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toMatch(/teamId.*required/i);
+  });
+
+  it("returns 400 when orchestratorAgentId missing", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({
+          teamId: "team1",
+          repoDir: "/home/test/repo",
+        }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toMatch(/orchestratorAgentId.*required/i);
+  });
+
+  it("returns 400 when repoDir missing", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({
+          teamId: "team1",
+          orchestratorAgentId: "team1-swarm-orchestrator",
+        }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toMatch(/repoDir.*required/i);
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { GET } from "../teams/orchestrator/route";
+
+vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
+vi.mock("@/lib/kitchen-api", () => ({
+  getKitchenApi: vi.fn(() => ({
+    runtime: {
+      system: {
+        runCommandWithTimeout: vi.fn().mockResolvedValue({ stdout: "", stderr: "" }),
+      },
+    },
+  })),
+}));
+
+import { runOpenClaw } from "@/lib/openclaw";
+
+describe("api teams orchestrator route", () => {
+  beforeEach(() => {
+    vi.mocked(runOpenClaw).mockReset();
+  });
+
+  it("returns 400 when teamId missing", async () => {
+    const res = await GET(new Request("https://test"));
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("teamId is required");
+  });
+
+  it("returns 200 with present:false when no orchestrator agent found", async () => {
+    vi.mocked(runOpenClaw).mockResolvedValue({
+      ok: true,
+      stdout: JSON.stringify([{ id: "other-agent", workspace: "/home" }]),
+      stderr: "",
+      exitCode: 0,
+    });
+    const res = await GET(new Request("https://test?teamId=team1"));
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.present).toBe(false);
+  });
+
+  it("returns 200 with present:true when orchestrator agent found", async () => {
+    vi.mocked(runOpenClaw).mockResolvedValue({
+      ok: true,
+      stdout: JSON.stringify([
+        { id: "team1-swarm-orchestrator", workspace: "/home/workspace-team1" },
+      ]),
+      stderr: "",
+      exitCode: 0,
+    });
+    const res = await GET(new Request("https://test?teamId=team1"));
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.present).toBe(true);
+    expect(json.agent.id).toBe("team1-swarm-orchestrator");
+  });
+});

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

@@ -0,0 +1,122 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { POST } from "../teams/remove-team/route";
+
+vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
+
+import { runOpenClaw } from "@/lib/openclaw";
+
+describe("api teams remove-team route", () => {
+  beforeEach(() => {
+    vi.mocked(runOpenClaw).mockReset();
+  });
+
+  it("returns 400 when teamId 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("teamId is required");
+  });
+
+  it("returns 403 when team is builtin", async () => {
+    vi.mocked(runOpenClaw).mockResolvedValue({
+      ok: true,
+      exitCode: 0,
+      stdout: JSON.stringify([
+        { id: "builtin-team", kind: "team", source: "builtin" },
+      ]),
+      stderr: "",
+    });
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "builtin-team" }),
+      })
+    );
+    expect(res.status).toBe(403);
+    const json = await res.json();
+    expect(json.error).toContain("Refusing to delete builtin team");
+  });
+
+  it("returns 500 when runOpenClaw fails", async () => {
+    vi.mocked(runOpenClaw)
+      .mockResolvedValueOnce({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify([{ id: "my-team", kind: "team", source: "workspace" }]),
+        stderr: "",
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        exitCode: 1,
+        stdout: "",
+        stderr: "Team in use",
+      });
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "my-team" }),
+      })
+    );
+    expect(res.status).toBe(500);
+    const json = await res.json();
+    expect(json.error).toContain("Team in use");
+  });
+
+  it("returns ok on success", async () => {
+    vi.mocked(runOpenClaw)
+      .mockResolvedValueOnce({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify([{ id: "my-team", kind: "team", source: "workspace" }]),
+        stderr: "",
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify({ removed: true }),
+        stderr: "",
+      });
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "my-team" }),
+      })
+    );
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.result).toEqual({ removed: true });
+  });
+
+  it("includes includeAmbiguous when specified", async () => {
+    vi.mocked(runOpenClaw)
+      .mockResolvedValueOnce({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify([{ id: "t", kind: "team", source: "workspace" }]),
+        stderr: "",
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        exitCode: 0,
+        stdout: "{}",
+        stderr: "",
+      });
+
+    await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "t", includeAmbiguous: true }),
+      })
+    );
+    expect(runOpenClaw).toHaveBeenNthCalledWith(
+      2,
+      expect.arrayContaining(["--include-ambiguous"])
+    );
+  });
+});

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

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { POST } from "../teams/skills/install/route";
+
+vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
+import { runOpenClaw } from "@/lib/openclaw";
+
+describe("api teams skills install route", () => {
+  beforeEach(() => {
+    vi.mocked(runOpenClaw).mockReset();
+  });
+
+  it("returns 400 when teamId 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("teamId is required");
+  });
+
+  it("returns 400 when skill missing", async () => {
+    const res = await POST(
+      new Request("https://test", { method: "POST", body: JSON.stringify({ teamId: "t1" }) })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("skill is required");
+  });
+
+  it("returns 200 and installs skill for team", async () => {
+    vi.mocked(runOpenClaw).mockResolvedValue({
+      ok: true,
+      exitCode: 0,
+      stdout: "installed",
+      stderr: "",
+    });
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "t1", skill: "my-skill" }),
+      })
+    );
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.teamId).toBe("t1");
+    expect(json.skill).toBe("my-skill");
+    expect(runOpenClaw).toHaveBeenCalledWith([
+      "recipes",
+      "install-skill",
+      "my-skill",
+      "--team-id",
+      "t1",
+      "--yes",
+    ]);
+  });
+
+  it("returns 500 when runOpenClaw fails", async () => {
+    vi.mocked(runOpenClaw).mockResolvedValue({
+      ok: false,
+      exitCode: 1,
+      stdout: "stdout msg",
+      stderr: "stderr msg",
+    });
+
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "t1", 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__/teams-skills-route.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { GET } from "../teams/skills/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: { readdir: vi.fn() },
+}));
+
+import { readOpenClawConfig } from "@/lib/paths";
+import fs from "node:fs/promises";
+
+describe("api teams skills route", () => {
+  const baseWorkspace = "/mock-workspace";
+
+  beforeEach(() => {
+    vi.mocked(readOpenClawConfig).mockReset();
+    vi.mocked(fs.readdir).mockReset();
+
+    vi.mocked(readOpenClawConfig).mockResolvedValue({
+      agents: { defaults: { workspace: baseWorkspace } },
+    });
+  });
+
+  it("returns 400 when teamId missing", async () => {
+    const res = await GET(new Request("https://test"));
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("teamId is required");
+  });
+
+  it("returns 500 when workspace not set", async () => {
+    vi.mocked(readOpenClawConfig).mockResolvedValue({});
+
+    const res = await GET(
+      new Request("https://test?teamId=my-team")
+    );
+    expect(res.status).toBe(500);
+    const json = await res.json();
+    expect(json.error).toBe("agents.defaults.workspace not set");
+  });
+
+  it("returns sorted skills on success", async () => {
+    vi.mocked(fs.readdir).mockResolvedValue([
+      { name: "skill-b", isDirectory: () => true } as never,
+      { name: "skill-a", isDirectory: () => true } as never,
+      { name: "README.md", isDirectory: () => false } as never,
+    ]);
+
+    const res = await GET(
+      new Request("https://test?teamId=my-team")
+    );
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.skills).toEqual(["skill-a", "skill-b"]);
+  });
+
+  it("returns empty skills with note when skills dir missing", async () => {
+    vi.mocked(fs.readdir).mockRejectedValue(new Error("ENOENT"));
+
+    const res = await GET(
+      new Request("https://test?teamId=my-team")
+    );
+    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__/teams-workflow-runs-route.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { GET, POST } from "../teams/workflow-runs/route";
+
+vi.mock("@/lib/workflows/runs-storage", () => ({
+  listWorkflowRuns: vi.fn(),
+  readWorkflowRun: vi.fn(),
+  writeWorkflowRun: vi.fn(),
+}));
+vi.mock("@/lib/workflows/storage", () => ({
+  readWorkflow: vi.fn(),
+}));
+
+import { listWorkflowRuns, readWorkflowRun } from "@/lib/workflows/runs-storage";
+
+describe("api teams workflow-runs route", () => {
+  beforeEach(() => {
+    vi.mocked(listWorkflowRuns).mockReset();
+    vi.mocked(readWorkflowRun).mockReset();
+  });
+
+  it("GET returns 400 when teamId missing", async () => {
+    const res = await GET(new Request("https://test"));
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("teamId is required");
+  });
+
+  it("GET returns 400 when workflowId missing", async () => {
+    const res = await GET(new Request("https://test?teamId=team1"));
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("workflowId is required");
+  });
+
+  it("GET returns 200 with list when no runId", async () => {
+    vi.mocked(listWorkflowRuns).mockResolvedValue({
+      ok: true,
+      dir: "/home/test",
+      files: ["run-1.run.json"],
+    });
+    const res = await GET(new Request("https://test?teamId=team1&workflowId=wf1"));
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.files).toEqual(["run-1.run.json"]);
+  });
+
+  it("GET returns 200 with run when runId provided", async () => {
+    const run = { id: "run-1", status: "running", nodes: [] };
+    vi.mocked(readWorkflowRun).mockResolvedValue({
+      ok: true,
+      path: "/home/test/run-1.run.json",
+      run,
+    });
+    const res = await GET(new Request("https://test?teamId=team1&workflowId=wf1&runId=run-1"));
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.run).toEqual(run);
+  });
+
+  it("POST returns 400 when teamId missing", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ workflowId: "wf1", mode: "create" }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("teamId is required");
+  });
+
+  it("POST returns 400 when workflowId missing", async () => {
+    const res = await POST(
+      new Request("https://test", {
+        method: "POST",
+        body: JSON.stringify({ teamId: "team1", mode: "create" }),
+      })
+    );
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.error).toBe("workflowId is required");
+  });
+});