@jiggai/kitchen 0.1.11 → 0.2.0

package/src/lib/__tests__/gateway.test.ts

@@ -0,0 +1,234 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { toolsInvoke, gatewayConfigGet, gatewayConfigPatch, getContentText } from "../gateway";
+
+vi.mock("@/lib/paths", () => ({
+  readOpenClawConfig: vi.fn(),
+}));
+
+import { readOpenClawConfig } from "@/lib/paths";
+
+const mockFetch = vi.hoisted(() => vi.fn());
+
+describe("gateway", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", mockFetch);
+    vi.mocked(readOpenClawConfig).mockReset();
+    mockFetch.mockReset();
+    vi.stubEnv("OPENCLAW_GATEWAY_HTTP_URL", "");
+    vi.stubEnv("OPENCLAW_GATEWAY_URL", "");
+    vi.stubEnv("OPENCLAW_GATEWAY_TOKEN", "");
+  });
+
+  describe("toolsInvoke", () => {
+    it("returns result when ok", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { port: 18789, auth: { token: "test-token" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: true, result: { foo: "bar" } }),
+      });
+
+      const r = await toolsInvoke({ tool: "test", action: "run" });
+      expect(r).toEqual({ foo: "bar" });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "http://127.0.0.1:18789/tools/invoke",
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({ authorization: "Bearer test-token" }),
+          body: JSON.stringify({ tool: "test", action: "run" }),
+        })
+      );
+    });
+
+    it("throws when res.ok false", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        json: async () => ({ ok: false, error: "Server error" }),
+      });
+
+      await expect(toolsInvoke({ tool: "x" })).rejects.toThrow("Server error");
+    });
+
+    it("throws when json.ok false", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: false, error: { message: "Tool failed" } }),
+      });
+
+      await expect(toolsInvoke({ tool: "x" })).rejects.toThrow("Tool failed");
+    });
+
+    it("throws when token missing", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({});
+
+      await expect(toolsInvoke({ tool: "x" })).rejects.toThrow("Missing gateway token");
+    });
+
+    it("uses config token when env and config both set", async () => {
+      vi.stubEnv("OPENCLAW_GATEWAY_TOKEN", "env-token");
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "config-token" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: true, result: {} }),
+      });
+
+      await toolsInvoke({ tool: "x" });
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({ authorization: "Bearer config-token" }),
+        })
+      );
+    });
+  });
+
+  describe("getContentText", () => {
+    it("returns text from content item with type text", () => {
+      expect(getContentText([{ type: "text", text: "hello" }])).toBe("hello");
+    });
+    it("returns undefined when no text item", () => {
+      expect(getContentText([{ type: "other" }])).toBeUndefined();
+      expect(getContentText([])).toBeUndefined();
+      expect(getContentText(undefined)).toBeUndefined();
+    });
+  });
+
+  describe("gatewayConfigGet", () => {
+    it("returns raw and hash from tool result", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      const payload = {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              ok: true,
+              result: { raw: '{"key":"val"}', hash: "abc123" },
+            }),
+          },
+        ],
+      };
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: true, result: payload }),
+      });
+
+      const r = await gatewayConfigGet();
+      expect(r).toEqual({ raw: '{"key":"val"}', hash: "abc123" });
+    });
+
+    it("throws when text payload missing", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          ok: true,
+          result: { content: [{ type: "other" }] },
+        }),
+      });
+
+      await expect(gatewayConfigGet()).rejects.toThrow("gateway config.get: missing text payload");
+    });
+
+    it("throws when result.raw missing", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          ok: true,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ ok: true, result: { hash: "x" } }),
+              },
+            ],
+          },
+        }),
+      });
+
+      await expect(gatewayConfigGet()).rejects.toThrow("gateway config.get: missing result.raw");
+    });
+
+    it("throws when result.hash missing", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          ok: true,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ ok: true, result: { raw: "{}" } }),
+              },
+            ],
+          },
+        }),
+      });
+
+      await expect(gatewayConfigGet()).rejects.toThrow("gateway config.get: missing result.hash");
+    });
+  });
+
+  describe("gatewayConfigPatch", () => {
+    it("calls toolsInvoke with patch and baseHash", async () => {
+      vi.mocked(readOpenClawConfig).mockResolvedValue({
+        gateway: { auth: { token: "t" } },
+      });
+      let callCount = 0;
+      mockFetch.mockImplementation(async () => {
+        callCount++;
+        if (callCount === 1) {
+          return {
+            ok: true,
+            json: async () => ({
+              ok: true,
+              result: {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      ok: true,
+                      result: { raw: "{}", hash: "h1" },
+                    }),
+                  },
+                ],
+              },
+            }),
+          };
+        }
+        return {
+          ok: true,
+          json: async () => ({ ok: true, result: {} }),
+        };
+      });
+
+      await gatewayConfigPatch({ newKey: "val" }, "Custom note");
+
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      const patchCall = mockFetch.mock.calls[1];
+      const body = JSON.parse(patchCall[1].body as string);
+      expect(body.args?.action).toBe("config.patch");
+      expect(body.args?.baseHash).toBe("h1");
+      expect(body.args?.note).toBe("Custom note");
+    });
+  });
+});

package/src/lib/__tests__/goal-promote.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { slugifyFilePart, ensureWorkflowInstructions } from "../goal-promote";
+
+describe("goal-promote", () => {
+  describe("slugifyFilePart", () => {
+    it("lowercases and hyphenates", () => {
+      expect(slugifyFilePart("My Goal Title")).toBe("my-goal-title");
+    });
+
+    it("strips leading and trailing hyphens", () => {
+      expect(slugifyFilePart("  --foo--  ")).toBe("foo");
+    });
+
+    it("truncates to 80 chars", () => {
+      const long = "a".repeat(100);
+      expect(slugifyFilePart(long).length).toBe(80);
+    });
+
+    it("handles empty input", () => {
+      expect(slugifyFilePart("")).toBe("");
+    });
+  });
+
+  describe("ensureWorkflowInstructions", () => {
+    it("returns body unchanged when marker present", () => {
+      const body = "Content\n<!-- goal-workflow -->\nMore";
+      expect(ensureWorkflowInstructions(body)).toBe(body);
+    });
+
+    it("appends workflow snippet when marker missing", () => {
+      const body = "## Existing";
+      const result = ensureWorkflowInstructions(body);
+      expect(result).toContain("## Existing");
+      expect(result).toContain("## Workflow");
+      expect(result).toContain("<!-- goal-workflow -->");
+      expect(result).toContain("Promote to inbox");
+    });
+  });
+});

package/src/lib/__tests__/goals-client.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { parseCommaList } from "../goals-client";
+
+describe("goals-client", () => {
+  describe("parseCommaList", () => {
+    it("parses comma-separated string into trimmed array", () => {
+      expect(parseCommaList("a, b, c")).toEqual(["a", "b", "c"]);
+    });
+
+    it("filters empty strings", () => {
+      expect(parseCommaList("a,,b,  ,c")).toEqual(["a", "b", "c"]);
+    });
+
+    it("returns empty array for empty string", () => {
+      expect(parseCommaList("")).toEqual([]);
+    });
+
+    it("trims whitespace", () => {
+      expect(parseCommaList("  x  ,  y  ")).toEqual(["x", "y"]);
+    });
+
+    it("handles single item", () => {
+      expect(parseCommaList("only")).toEqual(["only"]);
+    });
+  });
+});

package/src/lib/__tests__/goals.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import * as path from "node:path";
+import fs from "node:fs/promises";
+import {
+  assertSafeGoalId,
+  splitFrontmatter,
+  normalizeFrontmatter,
+  listGoals,
+  readGoal,
+  writeGoal,
+  deleteGoal,
+  goalErrorStatus,
+  parseCommaList,
+} from "../goals";
+import { getWorkspaceGoalsDir } from "@/lib/paths";
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    mkdir: vi.fn(),
+    readdir: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    unlink: vi.fn(),
+  },
+}));
+
+vi.mock("@/lib/paths", () => ({
+  getWorkspaceGoalsDir: vi.fn(),
+}));
+
+describe("goals", () => {
+  describe("assertSafeGoalId", () => {
+    it("accepts valid ids", () => {
+      expect(() => assertSafeGoalId("ab")).not.toThrow();
+      expect(() => assertSafeGoalId("my-goal-123")).not.toThrow();
+      expect(() => assertSafeGoalId("increase-trial-activation")).not.toThrow();
+    });
+
+    it("rejects invalid ids", () => {
+      expect(() => assertSafeGoalId("")).toThrow("Invalid goal id");
+      expect(() => assertSafeGoalId("A")).toThrow("Invalid goal id");
+      expect(() => assertSafeGoalId("invalid_id")).toThrow("Invalid goal id");
+      expect(() => assertSafeGoalId("no spaces")).toThrow("Invalid goal id");
+      expect(() => assertSafeGoalId("-leading")).toThrow("Invalid goal id");
+      expect(() => assertSafeGoalId("a".repeat(65))).toThrow("Invalid goal id");
+    });
+  });
+
+  describe("parseCommaList", () => {
+    it("parses comma-separated values", () => {
+      expect(parseCommaList("a, b, c")).toEqual(["a", "b", "c"]);
+      expect(parseCommaList("development-team, marketing-team")).toEqual(["development-team", "marketing-team"]);
+    });
+    it("trims and filters empty", () => {
+      expect(parseCommaList("  a , , b  ")).toEqual(["a", "b"]);
+      expect(parseCommaList("")).toEqual([]);
+    });
+  });
+
+  describe("goalErrorStatus", () => {
+    it("returns 400 for validation errors", () => {
+      expect(goalErrorStatus("Invalid goal id")).toBe(400);
+      expect(goalErrorStatus("Path traversal rejected")).toBe(400);
+    });
+    it("returns 500 for other errors", () => {
+      expect(goalErrorStatus("fs error")).toBe(500);
+    });
+  });
+
+  describe("splitFrontmatter", () => {
+    it("parses valid frontmatter", () => {
+      const md = `---
+id: foo
+title: My Goal
+status: active
+---
+Body here`;
+      const { fm, body } = splitFrontmatter(md);
+      expect(fm).toEqual({ id: "foo", title: "My Goal", status: "active" });
+      expect(body.trim()).toBe("Body here");
+    });
+
+    it("returns empty fm and full body when no frontmatter", () => {
+      const md = "# Just markdown\n\nNo frontmatter";
+      const { fm, body } = splitFrontmatter(md);
+      expect(fm).toEqual({});
+      expect(body).toBe("# Just markdown\n\nNo frontmatter");
+    });
+
+    it("handles empty frontmatter", () => {
+      const md = `---
+---
+Body`;
+      const { fm, body } = splitFrontmatter(md);
+      expect(fm).toEqual({});
+      // Implementation returns full md when closing --- not found from position 4
+      expect(body).toContain("Body");
+    });
+  });
+
+  describe("normalizeFrontmatter", () => {
+    it("normalizes full input", () => {
+      const input = {
+        id: "my-goal",
+        title: "My Goal",
+        status: "active",
+        tags: ["a", "b"],
+        teams: ["team1"],
+        updatedAt: "2026-01-01T00:00:00Z",
+      };
+      const result = normalizeFrontmatter(input, "fallback-id", "Fallback Title");
+      expect(result).toEqual({
+        id: "my-goal",
+        title: "My Goal",
+        status: "active",
+        tags: ["a", "b"],
+        teams: ["team1"],
+        updatedAt: "2026-01-01T00:00:00Z",
+      });
+    });
+
+    it("uses fallbacks for missing fields", () => {
+      const result = normalizeFrontmatter({}, "fb-id", "Fallback");
+      expect(result.id).toBe("fb-id");
+      expect(result.title).toBe("Fallback");
+      expect(result.status).toBe("planned");
+      expect(result.tags).toEqual([]);
+      expect(result.teams).toEqual([]);
+      expect(result.updatedAt).toBeDefined();
+    });
+
+    it("normalizes status to planned when invalid", () => {
+      const result = normalizeFrontmatter({ status: "invalid" }, "id", "Title");
+      expect(result.status).toBe("planned");
+    });
+
+    it("accepts active and done status", () => {
+      expect(normalizeFrontmatter({ status: "active" }, "id", "").status).toBe("active");
+      expect(normalizeFrontmatter({ status: "done" }, "id", "").status).toBe("done");
+    });
+
+    it("handles non-object input", () => {
+      const result = normalizeFrontmatter(null, "id", "t");
+      expect(result.id).toBe("id");
+      expect(result.title).toBe("t");
+    });
+  });
+
+  describe("listGoals", () => {
+    beforeEach(() => {
+      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+    });
+
+    it("returns sorted goals", async () => {
+      vi.mocked(fs.readdir).mockResolvedValue(["goal-b.md", "goal-a.md"]);
+      vi.mocked(fs.readFile)
+        .mockResolvedValueOnce(`---
+id: goal-b
+title: B
+status: done
+tags: []
+teams: []
+updatedAt: 2026-01-02T00:00:00Z
+---
+Body B`)
+        .mockResolvedValueOnce(`---
+id: goal-a
+title: A
+status: active
+tags: []
+teams: []
+updatedAt: 2026-01-01T00:00:00Z
+---
+Body A`);
+
+      const result = await listGoals();
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe("goal-a");
+      expect(result[0].status).toBe("active");
+      expect(result[1].id).toBe("goal-b");
+      expect(result[1].status).toBe("done");
+    });
+
+    it("returns empty array when no files", async () => {
+      vi.mocked(fs.readdir).mockResolvedValue([]);
+      const result = await listGoals();
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("readGoal", () => {
+    beforeEach(() => {
+      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+    });
+
+    it("returns goal when exists", async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(`---
+id: my-goal
+title: My Goal
+status: active
+---
+Body text`);
+
+      const result = await readGoal("my-goal");
+      expect(result).not.toBeNull();
+      expect(result!.frontmatter.id).toBe("my-goal");
+      expect(result!.frontmatter.title).toBe("My Goal");
+      expect(result!.body.trim()).toBe("Body text");
+    });
+
+    it("returns null when file not found", async () => {
+      vi.mocked(fs.readFile).mockRejectedValue({ code: "ENOENT" });
+      const result = await readGoal("missing-goal");
+      expect(result).toBeNull();
+    });
+
+    it("throws on invalid id", async () => {
+      await expect(readGoal("")).rejects.toThrow("Invalid goal id");
+    });
+  });
+
+  describe("writeGoal", () => {
+    beforeEach(() => {
+      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+    });
+
+    it("writes goal and returns frontmatter", async () => {
+      const result = await writeGoal({
+        id: "new-goal",
+        title: "New Goal",
+        body: "Content",
+      });
+      expect(result.frontmatter.id).toBe("new-goal");
+      expect(result.frontmatter.title).toBe("New Goal");
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.join("/mock-workspace/goals", "new-goal.md"),
+        expect.stringContaining("New Goal"),
+        "utf8"
+      );
+    });
+
+    it("throws on invalid id", async () => {
+      await expect(writeGoal({ id: "bad id", title: "X", body: "" })).rejects.toThrow("Invalid goal id");
+    });
+  });
+
+  describe("deleteGoal", () => {
+    beforeEach(() => {
+      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+    });
+
+    it("returns ok when deleted", async () => {
+      const result = await deleteGoal("my-goal");
+      expect(result).toEqual({ ok: true });
+      expect(fs.unlink).toHaveBeenCalledWith(path.join("/mock-workspace/goals", "my-goal.md"));
+    });
+
+    it("returns not_found when file missing", async () => {
+      vi.mocked(fs.unlink).mockRejectedValue({ code: "ENOENT" });
+      const result = await deleteGoal("missing");
+      expect(result).toEqual({ ok: false, reason: "not_found" });
+    });
+
+    it("throws on other errors", async () => {
+      vi.mocked(fs.unlink).mockRejectedValue(new Error("Permission denied"));
+      await expect(deleteGoal("my-goal")).rejects.toThrow("Permission denied");
+    });
+  });
+});

package/src/lib/__tests__/json.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { safeJsonParse } from "../json";
+
+describe("safeJsonParse", () => {
+  it("parses valid JSON", () => {
+    expect(safeJsonParse('{"a":1}')).toEqual({ a: 1 });
+    expect(safeJsonParse("[1,2]")).toEqual([1, 2]);
+    expect(safeJsonParse('"hi"')).toBe("hi");
+  });
+
+  it("returns null for invalid JSON", () => {
+    expect(safeJsonParse("not json")).toBeNull();
+    expect(safeJsonParse("{")).toBeNull();
+  });
+});

package/src/lib/__tests__/kitchen-api.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { getKitchenApi } from "../kitchen-api";
+
+describe("kitchen-api", () => {
+  beforeEach(() => {
+    delete (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api;
+  });
+
+  afterEach(() => {
+    delete (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api;
+  });
+
+  it("throws when __clawkitchen_api is missing", () => {
+    expect(() => getKitchenApi()).toThrow(
+      "ClawKitchen: OpenClaw plugin API not available"
+    );
+  });
+
+  it("returns api when __clawkitchen_api is set", () => {
+    const mockApi = {
+      config: {},
+      runtime: {
+        system: {
+          runCommandWithTimeout: async () => ({ stdout: "", stderr: "" }),
+        },
+      },
+    };
+    (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api = mockApi;
+
+    expect(getKitchenApi()).toBe(mockApi);
+  });
+});