@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,95 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../agents/update/route";
-
-vi.mock("@/lib/gateway", () => ({
-  gatewayConfigGet: vi.fn(),
-  gatewayConfigPatch: vi.fn(),
-}));
-
-import { gatewayConfigGet, gatewayConfigPatch } from "@/lib/gateway";
-
-describe("api agents update route", () => {
-  const cfgWithAgent = {
-    agents: {
-      list: [
-        { id: "agent-1", workspace: "/ws", model: "gpt-4", identity: { name: "Old", emoji: "🧑" } },
-      ],
-    },
-  };
-
-  beforeEach(() => {
-    vi.mocked(gatewayConfigGet).mockReset();
-    vi.mocked(gatewayConfigPatch).mockReset();
-
-    vi.mocked(gatewayConfigGet).mockResolvedValue({
-      raw: JSON.stringify(cfgWithAgent),
-      hash: "abc",
-    });
-    vi.mocked(gatewayConfigPatch).mockResolvedValue(undefined);
-  });
-
-  it("throws when agentId missing", async () => {
-    await expect(
-      POST(
-        new Request("https://test", {
-          method: "POST",
-          body: JSON.stringify({ agentId: "   " }),
-        })
-      )
-    ).rejects.toThrow("agentId is required");
-  });
-
-  it("returns 404 when agent not in config", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "missing" }),
-      })
-    );
-    expect(res.status).toBe(404);
-    const json = await res.json();
-    expect(json.error).toContain("Agent not found");
-  });
-
-  it("returns ok and patches config on success", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({
-          agentId: "agent-1",
-          patch: {
-            workspace: " /new/ws ",
-            model: "gpt-4o",
-            identity: { name: "New Name", theme: "dark", emoji: "🤖", avatar: "x" },
-          },
-        }),
-      })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.agentId).toBe("agent-1");
-
-    expect(gatewayConfigPatch).toHaveBeenCalled();
-    const [patch] = vi.mocked(gatewayConfigPatch).mock.calls[0];
-    expect(patch.agents.list[0].workspace).toBe("/new/ws");
-    expect(patch.agents.list[0].model).toBe("gpt-4o");
-    expect(patch.agents.list[0].identity).toMatchObject({
-      name: "New Name",
-      theme: "dark",
-      emoji: "🤖",
-      avatar: "x",
-    });
-  });
-
-  it("finds agent case-insensitively", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ agentId: "AGENT-1", patch: {} }),
-      })
-    );
-    expect(res.status).toBe(200);
-    expect(gatewayConfigPatch).toHaveBeenCalled();
-  });
-});

package/src/app/api/__tests__/channels-bindings-route.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET, PUT, DELETE } from "../channels/bindings/route";
-
-vi.mock("@/lib/gateway", () => ({
-  gatewayConfigGet: vi.fn(),
-  gatewayConfigPatch: vi.fn(),
-}));
-
-import { gatewayConfigGet, gatewayConfigPatch } from "@/lib/gateway";
-
-describe("api channels bindings route", () => {
-  beforeEach(() => {
-    vi.mocked(gatewayConfigGet).mockReset();
-    vi.mocked(gatewayConfigPatch).mockReset();
-
-    vi.mocked(gatewayConfigGet).mockResolvedValue({
-      raw: JSON.stringify({ channels: { telegram: { botToken: "x" } } }),
-      hash: "abc",
-    });
-    vi.mocked(gatewayConfigPatch).mockResolvedValue(undefined);
-  });
-
-  describe("GET", () => {
-    it("returns channels and hash", async () => {
-      const res = await GET();
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.channels).toEqual({ telegram: { botToken: "x" } });
-      expect(json.hash).toBe("abc");
-    });
-
-    it("returns empty channels when invalid JSON", async () => {
-      vi.mocked(gatewayConfigGet).mockResolvedValue({
-        raw: "not json",
-        hash: "x",
-      });
-      const res = await GET();
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.channels).toEqual({});
-    });
-
-    it("returns 500 when gateway throws", async () => {
-      vi.mocked(gatewayConfigGet).mockRejectedValue(new Error("Gateway error"));
-      const res = await GET();
-      expect(res.status).toBe(500);
-    });
-  });
-
-  describe("PUT", () => {
-    it("returns 400 when provider or config missing", async () => {
-      const r1 = await PUT(
-        new Request("https://test", { method: "PUT", body: JSON.stringify({}) })
-      );
-      expect(r1.status).toBe(400);
-      expect((await r1.json()).error).toBe("provider is required");
-
-      const r2 = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ provider: "tg", config: "not-object" }),
-        })
-      );
-      expect(r2.status).toBe(400);
-      expect((await r2.json()).error).toBe("config must be an object");
-    });
-
-    it("returns 400 when telegram config lacks botToken", async () => {
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ provider: "telegram", config: {} }),
-        })
-      );
-      expect(res.status).toBe(400);
-      expect((await res.json()).error).toBe("telegram.botToken is required");
-    });
-
-    it("returns ok and patches on success", async () => {
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({
-            provider: "telegram",
-            config: { botToken: "secret" },
-          }),
-        })
-      );
-      expect(res.status).toBe(200);
-      expect(gatewayConfigPatch).toHaveBeenCalledWith(
-        { channels: { telegram: { botToken: "secret" } } },
-        expect.stringContaining("telegram")
-      );
-    });
-
-    it("returns 500 when gatewayConfigPatch throws", async () => {
-      vi.mocked(gatewayConfigPatch).mockRejectedValue(new Error("Gateway error"));
-      const res = await PUT(
-        new Request("https://test", {
-          method: "PUT",
-          body: JSON.stringify({ provider: "slack", config: {} }),
-        })
-      );
-      expect(res.status).toBe(500);
-      expect((await res.json()).error).toBe("Gateway error");
-    });
-  });
-
-  describe("DELETE", () => {
-    it("returns 400 when provider missing", async () => {
-      const res = await DELETE(
-        new Request("https://test", { method: "DELETE", body: JSON.stringify({}) })
-      );
-      expect(res.status).toBe(400);
-    });
-
-    it("returns ok and patches provider to null", async () => {
-      const res = await DELETE(
-        new Request("https://test", {
-          method: "DELETE",
-          body: JSON.stringify({ provider: "telegram" }),
-        })
-      );
-      expect(res.status).toBe(200);
-      expect(gatewayConfigPatch).toHaveBeenCalledWith(
-        { channels: { telegram: null } },
-        expect.stringContaining("telegram")
-      );
-    });
-
-    it("returns 500 when gatewayConfigPatch throws", async () => {
-      vi.mocked(gatewayConfigPatch).mockRejectedValue(new Error("Gateway error"));
-      const res = await DELETE(
-        new Request("https://test", {
-          method: "DELETE",
-          body: JSON.stringify({ provider: "telegram" }),
-        })
-      );
-      expect(res.status).toBe(500);
-    });
-  });
-});

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

@@ -1,93 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../cron/delete/route";
-
-vi.mock("@/lib/gateway", () => ({ toolsInvoke: vi.fn() }));
-vi.mock("node:fs/promises", () => ({
-  default: {
-    readdir: vi.fn(),
-    stat: vi.fn(),
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-  },
-}));
-
-import { toolsInvoke } from "@/lib/gateway";
-import fs from "node:fs/promises";
-
-describe("api cron delete route", () => {
-  beforeEach(() => {
-    vi.mocked(toolsInvoke).mockReset();
-    vi.mocked(fs.readdir).mockReset();
-    vi.mocked(fs.stat).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-  });
-
-  it("returns 400 when 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).toBe("id is required");
-  });
-
-  it("returns 200 and invokes cron remove", async () => {
-    vi.mocked(toolsInvoke).mockResolvedValue({ ok: true });
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "job-1" }) })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.id).toBe("job-1");
-    expect(toolsInvoke).toHaveBeenCalledWith({ tool: "cron", args: { action: "remove", jobId: "job-1" } });
-  });
-
-  it("marks orphaned entries in cron-jobs.json when mapping references job", async () => {
-    const baseHome = "/mock/base";
-    vi.mocked(toolsInvoke)
-      .mockResolvedValueOnce({ ok: true })
-      .mockResolvedValueOnce({
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              result: {
-                raw: JSON.stringify({
-                  agents: { defaults: { workspace: baseHome + "/agents" } },
-                }),
-              },
-            }),
-          },
-        ],
-      });
-    vi.mocked(fs.readdir).mockResolvedValue([
-      { name: "workspace-team1", isDirectory: () => true } as never,
-    ]);
-    vi.mocked(fs.stat).mockResolvedValue({} as never);
-    vi.mocked(fs.readFile).mockResolvedValue(
-      JSON.stringify({
-        version: 1,
-        entries: {
-          "recipe-1": { installedCronId: "job-1", orphaned: false },
-          "recipe-2": { installedCronId: "other", orphaned: false },
-        },
-      })
-    );
-    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-
-    const res = await POST(
-      new Request("https://test", { method: "POST", body: JSON.stringify({ id: "job-1" }) })
-    );
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.orphanedIn).toHaveLength(1);
-    expect(json.orphanedIn[0].teamId).toBe("team1");
-    expect(json.orphanedIn[0].keys).toContain("recipe-1");
-    expect(fs.writeFile).toHaveBeenCalled();
-    const written = JSON.parse(vi.mocked(fs.writeFile).mock.calls[0][1] as string);
-    expect(written.entries["recipe-1"].orphaned).toBe(true);
-  });
-});

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

@@ -1,78 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { POST } from "../cron/job/route";
-
-vi.mock("@/lib/gateway", () => ({ toolsInvoke: vi.fn() }));
-
-import { toolsInvoke } from "@/lib/gateway";
-
-describe("api cron job route", () => {
-  beforeEach(() => {
-    vi.mocked(toolsInvoke).mockReset();
-    vi.mocked(toolsInvoke).mockResolvedValue({ ok: true });
-  });
-
-  it("returns 400 when id or action missing", async () => {
-    const r1 = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ action: "enable" }),
-      })
-    );
-    expect(r1.status).toBe(400);
-    expect((await r1.json()).error).toBe("id is required");
-
-    const r2 = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ id: "job-1", action: "invalid" }),
-      })
-    );
-    expect(r2.status).toBe(400);
-    expect((await r2.json()).error).toBe("action must be enable|disable|run");
-  });
-
-  it("calls toolsInvoke for enable", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ id: "job-1", action: "enable" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    expect(toolsInvoke).toHaveBeenCalledWith({
-      tool: "cron",
-      args: { action: "update", jobId: "job-1", patch: { enabled: true } },
-    });
-  });
-
-  it("calls toolsInvoke for disable", async () => {
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ id: "job-1", action: "disable" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    expect(toolsInvoke).toHaveBeenCalledWith({
-      tool: "cron",
-      args: { action: "update", jobId: "job-1", patch: { enabled: false } },
-    });
-  });
-
-  it("calls toolsInvoke for run", async () => {
-    vi.mocked(toolsInvoke).mockResolvedValue({ ok: true, result: { ran: true } });
-    const res = await POST(
-      new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ id: "job-1", action: "run" }),
-      })
-    );
-    expect(res.status).toBe(200);
-    expect(toolsInvoke).toHaveBeenCalledWith({
-      tool: "cron",
-      args: { action: "run", jobId: "job-1" },
-    });
-    const json = await res.json();
-    expect(json.result).toEqual({ ok: true, result: { ran: true } });
-  });
-});

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

@@ -1,116 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../cron/jobs/route";
-
-vi.mock("@/lib/gateway", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/gateway")>();
-  return { ...actual, toolsInvoke: vi.fn() };
-});
-vi.mock("@/lib/paths", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/paths")>();
-  return {
-    ...actual,
-    getTeamWorkspaceDir: vi.fn(),
-    readOpenClawConfig: vi.fn().mockResolvedValue({ agents: { defaults: { workspace: "/home/test/.openclaw/agents" } } }),
-  };
-});
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn().mockResolvedValue({ ok: true, stdout: "[]" }) }));
-vi.mock("node:fs/promises", () => ({
-  default: {
-    readFile: vi.fn(),
-    readdir: vi.fn().mockResolvedValue([]),
-    stat: vi.fn(),
-  },
-}));
-
-import { toolsInvoke } from "@/lib/gateway";
-import { getTeamWorkspaceDir } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("api cron jobs route", () => {
-  beforeEach(() => {
-    vi.mocked(toolsInvoke).mockReset();
-    vi.mocked(getTeamWorkspaceDir).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-    vi.mocked(fs.readdir).mockReset();
-    vi.mocked(fs.readdir).mockResolvedValue([]);
-  });
-
-  it("returns empty jobs when toolsInvoke has no text", async () => {
-    vi.mocked(toolsInvoke).mockResolvedValue({ content: [] });
-
-    const res = await GET(new Request("https://test"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.jobs).toEqual([]);
-  });
-
-  it("returns jobs when no teamId", async () => {
-    const jobs = [{ id: "j1", name: "Job 1" }];
-    vi.mocked(toolsInvoke).mockResolvedValue({
-      content: [{ type: "text", text: JSON.stringify({ jobs }) }],
-    });
-
-    const res = await GET(new Request("https://test"));
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.jobs).toEqual(jobs);
-  });
-
-  it("filters by team when teamId provided", async () => {
-    const allJobs = [
-      { id: "j1" },
-      { id: "j2" },
-      { id: "j3" },
-    ];
-    vi.mocked(toolsInvoke).mockResolvedValue({
-      content: [{ type: "text", text: JSON.stringify({ jobs: allJobs }) }],
-    });
-    vi.mocked(getTeamWorkspaceDir).mockResolvedValue("/home/x/.openclaw/workspace-my-team");
-    vi.mocked(fs.readFile).mockResolvedValue(
-      JSON.stringify({
-        entries: {
-          a: { installedCronId: "j1", orphaned: false },
-          b: { installedCronId: "j3", orphaned: false },
-          c: { installedCronId: "j99", orphaned: true },
-        },
-      })
-    );
-
-    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.jobs).toHaveLength(2);
-    expect(json.jobs.map((j: { id: string }) => j.id)).toEqual(["j1", "j3"]);
-    expect(json.installedIds).toEqual(["j1", "j3"]);
-  });
-
-  it("returns empty filtered jobs when provenance file missing", async () => {
-    vi.mocked(toolsInvoke).mockResolvedValue({
-      content: [{ type: "text", text: JSON.stringify({ jobs: [{ id: "j1" }] }) }],
-    });
-    vi.mocked(getTeamWorkspaceDir).mockResolvedValue("/home/x/.openclaw/workspace-t");
-    vi.mocked(fs.readFile).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.jobs).toEqual([]);
-    expect(json.installedIds).toEqual([]);
-  });
-
-  it("returns 500 when toolsInvoke throws", async () => {
-    vi.mocked(toolsInvoke).mockRejectedValue(new Error("Gateway unavailable"));
-
-    const res = await GET(new Request("https://test"));
-    expect(res.status).toBe(500);
-    const json = await res.json();
-    expect(json.error).toBe("Gateway unavailable");
-  });
-});

package/src/app/api/__tests__/cron-recipe-installed-route.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { GET } from "../cron/recipe-installed/route";
-
-vi.mock("@/lib/gateway", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@/lib/gateway")>();
-  return { ...actual, toolsInvoke: vi.fn() };
-});
-vi.mock("node:fs/promises", () => ({ default: { readFile: vi.fn() } }));
-
-import { toolsInvoke } from "@/lib/gateway";
-import fs from "node:fs/promises";
-
-describe("api cron recipe-installed route", () => {
-  const baseWorkspace = "/home/x/.openclaw/agents";
-  const gatewayConfigResponse = {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          result: {
-            raw: JSON.stringify({
-              agents: { defaults: { workspace: baseWorkspace } },
-            }),
-          },
-        }),
-      },
-    ],
-  };
-
-  beforeEach(() => {
-    vi.mocked(toolsInvoke).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-
-    vi.mocked(toolsInvoke)
-      .mockResolvedValueOnce(gatewayConfigResponse as never)
-      .mockResolvedValueOnce({ jobs: [] } as never);
-  });
-
-  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 gateway config has no text", async () => {
-    vi.mocked(toolsInvoke).mockReset();
-    vi.mocked(toolsInvoke).mockResolvedValue({ content: [] } as never);
-
-    const res = await GET(
-      new Request("https://test?teamId=my-team")
-    );
-    expect(res.status).toBe(500);
-    expect((await res.json()).error).toBe("Failed to fetch config via gateway");
-  });
-
-  it("returns 500 when workspace not set", async () => {
-    vi.mocked(toolsInvoke).mockReset();
-    vi.mocked(toolsInvoke).mockResolvedValue({
-      content: [{ type: "text", text: JSON.stringify({ result: { raw: "{}" } }) }],
-    } as never);
-
-    const res = await GET(
-      new Request("https://test?teamId=my-team")
-    );
-    expect(res.status).toBe(500);
-    expect((await res.json()).error).toBe("agents.defaults.workspace not set");
-  });
-
-  it("returns jobs filtered by mapping", async () => {
-    vi.mocked(fs.readFile).mockResolvedValue(
-      JSON.stringify({
-        version: 1,
-        entries: {
-          r1: { installedCronId: "cron-1", orphaned: false },
-          r2: { installedCronId: "cron-2", orphaned: false },
-        },
-      })
-    );
-    vi.mocked(toolsInvoke)
-      .mockReset()
-      .mockResolvedValueOnce(gatewayConfigResponse as never)
-      .mockResolvedValueOnce({
-        jobs: [
-          { id: "cron-1", name: "J1" },
-          { id: "cron-2", name: "J2" },
-          { id: "cron-3", name: "J3" },
-        ],
-      } 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.jobCount).toBe(2);
-    expect(json.jobs).toHaveLength(2);
-    expect(json.jobs.map((j: { id: string }) => j.id)).toEqual(["cron-1", "cron-2"]);
-  });
-
-  it("returns empty jobs when mapping file missing", async () => {
-    vi.mocked(fs.readFile).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.jobs).toEqual([]);
-    expect(json.jobCount).toBe(0);
-  });
-});

package/src/app/api/__tests__/gateway-restart-route.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { POST } from "../gateway/restart/route";
-
-vi.mock("@/lib/openclaw", () => ({ runOpenClaw: vi.fn() }));
-import { runOpenClaw } from "@/lib/openclaw";
-
-describe("api gateway restart route", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.mocked(runOpenClaw).mockReset();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("returns 200 and schedules restart", async () => {
-    vi.mocked(runOpenClaw).mockResolvedValue({ ok: true, exitCode: 0, stdout: "", stderr: "" });
-
-    const res = await POST();
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.ok).toBe(true);
-    expect(json.scheduled).toBe(true);
-
-    expect(runOpenClaw).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(50);
-    expect(runOpenClaw).toHaveBeenCalledWith(["gateway", "restart"]);
-  });
-
-  it("responds immediately before restart runs", async () => {
-    const res = await POST();
-    expect(res.status).toBe(200);
-    expect(runOpenClaw).not.toHaveBeenCalled();
-  });
-});