@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,57 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../teams/files/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: { stat: vi.fn() },
-}));
-
-import { readOpenClawConfig } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("api teams files route", () => {
-  const baseWorkspace = "/mock-workspace";
-
-  beforeEach(() => {
-    vi.mocked(readOpenClawConfig).mockReset();
-    vi.mocked(fs.stat).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/files"));
-    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/api/teams/files?teamId=my-team"));
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("agents.defaults.workspace not set");
-  });
-
-  it("returns files with missing flags", async () => {
-    vi.mocked(fs.stat)
-      .mockResolvedValueOnce({ size: 100, mtimeMs: 123456 } as never)
-      .mockRejectedValueOnce(new Error("ENOENT"));
-
-    const res = await GET(new Request("https://test/api/teams/files?teamId=my-team"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.teamId).toBe("my-team");
-    expect(json.files).toBeDefined();
-    expect(json.files.some((f: { name: string }) => f.name === "TEAM.md")).toBe(true);
-    expect(json.files.some((f: { missing: boolean }) => f.missing === true)).toBe(true);
-  });
-});

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

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

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

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

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

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

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

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