@jiggai/kitchen 0.3.1 → 0.3.3

package/src/app/api/recipes/team-agents/route.ts

@@ -1,80 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { NextResponse } from "next/server";
-import { getWorkspaceRecipesDir } from "@/lib/paths";
-import {
-  splitFrontmatter,
-  normalizeRole,
-  parseRecipeFrontmatter,
-  buildNextMarkdown,
-  handleRemove,
-  handleAdd,
-  handleAddLike,
-} from "./helpers";
-
-export async function POST(req: Request) {
-  const body = (await req.json()) as {
-    recipeId?: string;
-    op?: "add" | "remove" | "addLike";
-    role?: string;
-    baseRole?: string;
-    teamId?: string;
-    name?: string;
-  };
-
-  const recipeId = String(body.recipeId ?? "").trim();
-  const op = body.op;
-  if (!recipeId) return NextResponse.json({ ok: false, error: "recipeId is required" }, { status: 400 });
-  if (op !== "add" && op !== "remove" && op !== "addLike") {
-    return NextResponse.json({ ok: false, error: "op must be add|remove|addLike" }, { status: 400 });
-  }
-
-  const name = typeof body.name === "string" ? body.name.trim() : "";
-
-  const dir = await getWorkspaceRecipesDir();
-  const filePath = path.join(dir, `${recipeId}.md`);
-
-  const md = await fs.readFile(filePath, "utf8");
-  const { yamlText, rest } = splitFrontmatter(md);
-  const { fm, agents, templates } = parseRecipeFrontmatter(yamlText);
-
-  const kind = String(fm.kind ?? "");
-  if (kind && kind !== "team") {
-    return NextResponse.json({ ok: false, error: `recipe kind must be team (got ${kind})` }, { status: 400 });
-  }
-
-  let result: { nextAgents: Array<Record<string, unknown>>; nextTemplates: Record<string, unknown>; addedRole: string | null } | NextResponse;
-
-  if (op === "remove") {
-    const role = normalizeRole(String(body.role ?? ""));
-    result = handleRemove(agents, templates, role);
-  } else if (op === "add") {
-    const role = normalizeRole(String(body.role ?? ""));
-    result = handleAdd(agents, templates, role, name);
-  } else {
-    const baseRole = normalizeRole(String(body.baseRole ?? ""));
-    const teamId = String(body.teamId ?? "").trim();
-    result = await handleAddLike(agents, templates, baseRole, name, teamId);
-  }
-
-  if (result instanceof NextResponse) return result;
-
-  const { nextAgents, nextTemplates, addedRole } = result;
-  nextAgents.sort((a, b) => String(a.role ?? "").localeCompare(String(b.role ?? "")));
-
-  const nextMd = buildNextMarkdown(fm, nextAgents, nextTemplates, rest);
-  await fs.writeFile(filePath, nextMd, "utf8");
-
-  const teamId = typeof body.teamId === "string" ? body.teamId.trim() : "";
-  const addedAgentId = teamId && addedRole ? `${teamId}-${addedRole}` : null;
-
-  return NextResponse.json({
-    ok: true,
-    recipeId,
-    filePath,
-    agents: nextAgents,
-    content: nextMd,
-    addedRole,
-    addedAgentId,
-  });
-}

package/src/app/api/scaffold/__tests__/helpers.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import {
-  validateAgentId,
-  validateTeamId,
-  withCronOverride,
-  persistTeamProvenance,
-  persistAgentProvenance,
-} from "../helpers";
-
-vi.mock("@/lib/openclaw", () => ({
-  runOpenClaw: vi.fn(),
-}));
-vi.mock("@/lib/paths", () => ({
-  readOpenClawConfig: vi.fn(),
-  getWorkspaceRecipesDir: vi.fn(),
-}));
-vi.mock("node:fs/promises", () => ({
-  default: {
-    stat: vi.fn(),
-    mkdir: vi.fn(),
-    writeFile: vi.fn(),
-    readFile: vi.fn(),
-  },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import { readOpenClawConfig, getWorkspaceRecipesDir } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-describe("scaffold helpers", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(readOpenClawConfig).mockReset();
-    vi.mocked(getWorkspaceRecipesDir).mockReset();
-    vi.mocked(fs.stat).mockReset();
-    vi.mocked(fs.mkdir).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-  });
-
-  describe("validateAgentId", () => {
-    it("returns null when agentId empty", async () => {
-      const result = await validateAgentId("", new Set(["recipe1"]));
-      expect(result).toBeNull();
-    });
-
-    it("returns 409 when agentId matches recipe id", async () => {
-      const result = await validateAgentId("my-recipe", new Set(["my-recipe"]));
-      expect(result).not.toBeNull();
-      expect((result as Response).status).toBe(409);
-      const json = await (result as Response).json();
-      expect(json.error).toContain("cannot match an existing recipe id");
-    });
-
-    it("returns null when agent does not exist", async () => {
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        stdout: JSON.stringify([{ id: "other-agent" }]),
-        stderr: "",
-        exitCode: 0,
-      });
-      const result = await validateAgentId("new-agent", new Set());
-      expect(result).toBeNull();
-    });
-
-    it("returns 409 when agent already exists", async () => {
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        stdout: JSON.stringify([{ id: "existing-agent" }]),
-        stderr: "",
-        exitCode: 0,
-      });
-      const result = await validateAgentId("existing-agent", new Set());
-      expect(result).not.toBeNull();
-      expect((result as Response).status).toBe(409);
-      const json = await (result as Response).json();
-      expect(json.error).toContain("Agent already exists");
-    });
-  });
-
-  describe("validateTeamId", () => {
-    it("returns null when teamId empty", async () => {
-      const result = await validateTeamId("", new Set());
-      expect(result).toBeNull();
-    });
-
-    it("returns 409 when teamId matches recipe id", async () => {
-      const result = await validateTeamId("my-recipe", new Set(["my-recipe"]));
-      expect(result).not.toBeNull();
-      expect((result as Response).status).toBe(409);
-      const json = await (result as Response).json();
-      expect(json.error).toContain("cannot match an existing recipe id");
-    });
-
-    it("returns 409 when team workspace exists", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        agents: { defaults: { workspace: "/home/.openclaw/workspace" } },
-      } as never);
-      vi.mocked(fs.stat).mockResolvedValue({} as never);
-      const result = await validateTeamId("team1", new Set());
-      expect(result).not.toBeNull();
-      expect((result as Response).status).toBe(409);
-      const json = await (result as Response).json();
-      expect(json.error).toContain("Team workspace already exists");
-    });
-
-    it("returns null when team workspace does not exist and no agents", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        agents: { defaults: { workspace: "/home/.openclaw/workspace" } },
-      } as never);
-      vi.mocked(fs.stat).mockRejectedValue(new Error("not found"));
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        stdout: JSON.stringify([]),
-        stderr: "",
-        exitCode: 0,
-      });
-      const result = await validateTeamId("team1", new Set());
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("withCronOverride", () => {
-    it("runs fn without override when override undefined", async () => {
-      const fn = vi.fn().mockResolvedValue(42);
-      const result = await withCronOverride(undefined, fn);
-      expect(result).toBe(42);
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(runOpenClaw).not.toHaveBeenCalled();
-    });
-
-    it("runs fn and restores config when override yes", async () => {
-      vi.mocked(runOpenClaw)
-        .mockResolvedValueOnce({ ok: true, stdout: "off", stderr: "", exitCode: 0 })
-        .mockResolvedValueOnce({ ok: true, stdout: "", stderr: "", exitCode: 0 })
-        .mockResolvedValueOnce({ ok: true, stdout: "", stderr: "", exitCode: 0 });
-      const fn = vi.fn().mockResolvedValue("done");
-      const result = await withCronOverride("yes", fn);
-      expect(result).toBe("done");
-      expect(runOpenClaw).toHaveBeenCalledTimes(3); // get, set on, set restore
-    });
-  });
-
-  describe("persistTeamProvenance", () => {
-    it("writes team.json when workspace configured", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        agents: { defaults: { workspace: "/home/.openclaw/workspace" } },
-      } as never);
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        stdout: JSON.stringify([{ id: "r1", name: "Recipe 1" }]),
-        stderr: "",
-        exitCode: 0,
-      });
-      vi.mocked(getWorkspaceRecipesDir).mockResolvedValue("/workspace/recipes");
-      vi.mocked(fs.readFile).mockResolvedValue("---\nkind: team\n---\nbody");
-      await persistTeamProvenance("team1", "recipe1", "abc123");
-      expect(fs.mkdir).toHaveBeenCalled();
-      expect(fs.writeFile).toHaveBeenCalled();
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      expect(writeCall[0]).toContain("team.json");
-      expect(writeCall[1]).toContain("team1");
-      expect(writeCall[1]).toContain("recipe1");
-    });
-  });
-
-  describe("persistAgentProvenance", () => {
-    it("writes agent.json when workspace configured", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        agents: { defaults: { workspace: "/home/.openclaw/workspace" } },
-      } as never);
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        stdout: JSON.stringify([{ id: "r1", name: "Recipe 1" }]),
-        stderr: "",
-        exitCode: 0,
-      });
-      await persistAgentProvenance("agent1", "recipe1", null);
-      expect(fs.mkdir).toHaveBeenCalled();
-      expect(fs.writeFile).toHaveBeenCalled();
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      expect(writeCall[0]).toContain("agent.json");
-      expect(writeCall[1]).toContain("agent1");
-    });
-  });
-});

package/src/app/api/scaffold/helpers.ts

@@ -1,214 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import YAML from "yaml";
-import { runOpenClaw } from "@/lib/openclaw";
-import { readOpenClawConfig, getWorkspaceRecipesDir } from "@/lib/paths";
-import { NextResponse } from "next/server";
-
-const TEAM_META_FILE = "team.json";
-const AGENT_META_FILE = "agent.json";
-
-function teamDirFromTeamId(baseWorkspace: string, teamId: string) {
-  return path.resolve(baseWorkspace, "..", `workspace-${teamId}`);
-}
-
-export async function validateAgentId(
-  agentId: string,
-  recipeIds: Set<string>
-): Promise<NextResponse | null> {
-  if (!agentId) return null;
-  if (recipeIds.has(agentId)) {
-    return NextResponse.json(
-      { ok: false, error: `Agent id cannot match an existing recipe id: ${agentId}. Choose a new agent id.` },
-      { status: 409 }
-    );
-  }
-  const agentsRes = await runOpenClaw(["agents", "list", "--json"]);
-  if (!agentsRes.ok) return null;
-  try {
-    const agents = JSON.parse(agentsRes.stdout) as Array<{ id?: unknown }>;
-    const exists = agents.some((a) => String(a.id ?? "").trim() === agentId);
-    if (exists) {
-      return NextResponse.json(
-        { ok: false, error: `Agent already exists: ${agentId}. Choose a new id or enable overwrite.` },
-        { status: 409 }
-      );
-    }
-  } catch {
-    // ignore parse errors
-  }
-  return null;
-}
-
-export async function validateTeamId(
-  teamId: string,
-  recipeIds: Set<string>
-): Promise<NextResponse | null> {
-  if (!teamId) return null;
-  if (recipeIds.has(teamId)) {
-    return NextResponse.json(
-      { ok: false, error: `Team id cannot match an existing recipe id: ${teamId}. Choose a new team id.` },
-      { status: 409 }
-    );
-  }
-  try {
-    const cfg = await readOpenClawConfig();
-    const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
-    if (baseWorkspace) {
-      const teamDir = teamDirFromTeamId(baseWorkspace, teamId);
-      const hasWorkspace = await fs.stat(teamDir).then(() => true).catch(() => false);
-      if (hasWorkspace) {
-        return NextResponse.json(
-          { ok: false, error: `Team workspace already exists: ${teamId}. Choose a new id or enable overwrite.` },
-          { status: 409 }
-        );
-      }
-    }
-  } catch {
-    // ignore
-  }
-  const agentsRes = await runOpenClaw(["agents", "list", "--json"]);
-  if (!agentsRes.ok) return null;
-  try {
-    const agents = JSON.parse(agentsRes.stdout) as Array<{ id?: unknown }>;
-    const hasAgents = agents.some((a) => String(a.id ?? "").startsWith(`${teamId}-`));
-    if (hasAgents) {
-      return NextResponse.json(
-        { ok: false, error: `Team agents already exist for team: ${teamId}. Choose a new id or enable overwrite.` },
-        { status: 409 }
-      );
-    }
-  } catch {
-    // ignore
-  }
-  return null;
-}
-
-export async function withCronOverride<T>(
-  override: "yes" | "no" | undefined,
-  fn: () => Promise<T>
-): Promise<T> {
-  let prevCronInstallation: string | null = null;
-  if (override === "yes" || override === "no") {
-    const cfgPath = "plugins.entries.recipes.config.cronInstallation";
-    const prev = await runOpenClaw(["config", "get", cfgPath]);
-    prevCronInstallation = prev.stdout.trim() || null;
-    const next = override === "yes" ? "on" : "off";
-    await runOpenClaw(["config", "set", cfgPath, next]);
-  }
-  try {
-    return await fn();
-  } finally {
-    if (prevCronInstallation !== null) {
-      try {
-        await runOpenClaw(["config", "set", "plugins.entries.recipes.config.cronInstallation", prevCronInstallation]);
-      } catch {
-        // best-effort restore
-      }
-    }
-  }
-}
-
-async function getRecipeName(recipeId: string): Promise<string | undefined> {
-  try {
-    const list = await runOpenClaw(["recipes", "list"]);
-    if (!list.ok) return undefined;
-    const items = JSON.parse(list.stdout) as Array<{ id?: string; name?: string }>;
-    const hit = items.find((r) => String(r.id ?? "").trim() === recipeId);
-    return String(hit?.name ?? "").trim() || undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-async function persistProvenance(opts: {
-  id: string;
-  idKey: "teamId" | "agentId";
-  recipeId: string;
-  recipeHash: string | null;
-  dirResolver: (baseWorkspace: string) => string;
-  metaFileName: string;
-}): Promise<void> {
-  try {
-    const cfg = await readOpenClawConfig();
-    const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
-    if (!baseWorkspace) return;
-
-    const dir = opts.dirResolver(baseWorkspace);
-    const recipeName = await getRecipeName(opts.recipeId);
-    const now = new Date().toISOString();
-    const meta = {
-      [opts.idKey]: opts.id,
-      recipeId: opts.recipeId,
-      ...(recipeName ? { recipeName } : {}),
-      ...(opts.recipeHash ? { recipeHash: opts.recipeHash } : {}),
-      scaffoldedAt: now,
-      attachedAt: now,
-    };
-
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path.join(dir, opts.metaFileName), JSON.stringify(meta, null, 2) + "\n", "utf8");
-  } catch {
-    // best-effort only
-  }
-}
-
-export async function persistTeamProvenance(
-  teamId: string,
-  recipeId: string,
-  recipeHash: string | null
-): Promise<void> {
-  await persistProvenance({
-    id: teamId,
-    idKey: "teamId",
-    recipeId,
-    recipeHash,
-    dirResolver: (base) => teamDirFromTeamId(base, teamId),
-    metaFileName: TEAM_META_FILE,
-  });
-
-  // Best-effort: ensure team.teamId matches in generated recipe
-  try {
-    const cfg = await readOpenClawConfig();
-    const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
-    if (!baseWorkspace) return;
-    const recipesDir = await getWorkspaceRecipesDir();
-    const recipePath = path.join(recipesDir, `${teamId}.md`);
-    const md = await fs.readFile(recipePath, "utf8");
-    if (md.startsWith("---\n")) {
-      const end = md.indexOf("\n---\n", 4);
-      if (end !== -1) {
-        const yamlText = md.slice(4, end + 1);
-        const rest = md.slice(end + 5);
-        const fm = (YAML.parse(yamlText) ?? {}) as Record<string, unknown>;
-        const nextFm: Record<string, unknown> = {
-          ...fm,
-          team: {
-            ...(typeof fm.team === "object" && fm.team ? (fm.team as Record<string, unknown>) : {}),
-            teamId,
-          },
-        };
-        const nextYaml = YAML.stringify(nextFm).trimEnd();
-        const nextMd = `---\n${nextYaml}\n---\n${rest}`;
-        if (nextMd !== md) await fs.writeFile(recipePath, nextMd, "utf8");
-      }
-    }
-  } catch {
-    // ignore
-  }
-}
-
-export async function persistAgentProvenance(
-  agentId: string,
-  recipeId: string,
-  recipeHash: string | null
-): Promise<void> {
-  await persistProvenance({
-    id: agentId,
-    idKey: "agentId",
-    recipeId,
-    recipeHash,
-    dirResolver: (base) => path.resolve(base, "agents", agentId),
-    metaFileName: AGENT_META_FILE,
-  });
-}

package/src/app/api/scaffold/route.ts

@@ -1,95 +0,0 @@
-import crypto from "node:crypto";
-import { NextResponse } from "next/server";
-import { runOpenClaw } from "@/lib/openclaw";
-import { buildScaffoldArgs } from "@/lib/scaffold";
-import {
-  validateAgentId,
-  validateTeamId,
-  withCronOverride,
-  persistTeamProvenance,
-  persistAgentProvenance,
-} from "./helpers";
-
-type ReqBody = Parameters<typeof buildScaffoldArgs>[0] & {
-  cronInstallChoice?: "yes" | "no";
-  allowExisting?: boolean;
-};
-
-const asString = (v: unknown) => {
-  if (typeof v === "string") return v;
-  if (v instanceof Uint8Array) return new TextDecoder().decode(v);
-  if (v && typeof (v as { toString?: unknown }).toString === "function") return String(v);
-  return "";
-};
-
-function sha256(text: string) {
-  return crypto.createHash("sha256").update(text, "utf8").digest("hex");
-}
-
-async function getRecipeIds(): Promise<Set<string>> {
-  const recipesRes = await runOpenClaw(["recipes", "list"]);
-  if (!recipesRes.ok) return new Set();
-  try {
-    const recipes = JSON.parse(recipesRes.stdout) as Array<{ id?: unknown }>;
-    return new Set(recipes.map((r) => String(r.id ?? "").trim()).filter(Boolean));
-  } catch {
-    return new Set();
-  }
-}
-
-export async function POST(req: Request) {
-  const body = (await req.json()) as ReqBody;
-
-  let recipeHash: string | null = null;
-  try {
-    const shown = await runOpenClaw(["recipes", "show", body.recipeId]);
-    if (shown.ok) recipeHash = sha256(shown.stdout);
-  } catch {
-    // ignore
-  }
-
-  const args = buildScaffoldArgs(body, { allowExisting: body.allowExisting });
-
-  try {
-    if (!body.overwrite && !body.allowExisting) {
-      const recipeIds = await getRecipeIds();
-      if (body.kind === "agent") {
-        const agentId = String(body.agentId ?? "").trim();
-        const err = await validateAgentId(agentId, recipeIds);
-        if (err) return err;
-      } else {
-        const teamId = String(body.teamId ?? "").trim();
-        const err = await validateTeamId(teamId, recipeIds);
-        if (err) return err;
-      }
-    }
-
-    return await withCronOverride(body.cronInstallChoice, async () => {
-      const { stdout, stderr } = await runOpenClaw(args);
-
-      if (body.kind === "team") {
-        const teamId = String(body.teamId ?? "").trim();
-        if (teamId) await persistTeamProvenance(teamId, body.recipeId, recipeHash);
-      }
-
-      if (body.kind === "agent") {
-        const agentId = String(body.agentId ?? "").trim();
-        if (agentId) await persistAgentProvenance(agentId, body.recipeId, recipeHash);
-      }
-
-      return NextResponse.json({ ok: true, args, stdout, stderr });
-    });
-  } catch (e: unknown) {
-    const err = e as { message?: string; stdout?: unknown; stderr?: unknown };
-    return NextResponse.json(
-      {
-        ok: false,
-        args,
-        error: err?.message ?? String(e),
-        stdout: asString(err?.stdout),
-        stderr: asString(err?.stderr),
-      },
-      { status: 500 }
-    );
-  }
-}

package/src/app/api/settings/cron-installation/route.ts

@@ -1,58 +0,0 @@
-import { NextResponse } from "next/server";
-import { errorMessage } from "@/lib/errors";
-import { gatewayConfigGet, gatewayConfigPatch } from "@/lib/gateway";
-
-const CFG_PATH = "plugins.entries.recipes.config.cronInstallation";
-
-function getPath(obj: unknown, p: string): unknown {
-  return p.split(".").reduce<unknown>((acc, k) => {
-    if (!acc || typeof acc !== "object") return undefined;
-    return (acc as Record<string, unknown>)[k];
-  }, obj);
-}
-
-export async function GET() {
-  try {
-    const { raw } = await gatewayConfigGet();
-    const cfg = JSON.parse(raw);
-    const value = String(getPath(cfg, CFG_PATH) ?? "").trim();
-    return NextResponse.json({ ok: true, path: CFG_PATH, value });
-  } catch (e: unknown) {
-    return NextResponse.json(
-      { ok: false, error: errorMessage(e) },
-      { status: 500 },
-    );
-  }
-}
-
-export async function PUT(req: Request) {
-  try {
-    const body = (await req.json()) as { value?: string };
-    const value = String(body.value ?? "").trim();
-    if (!value || !["off", "prompt", "on"].includes(value)) {
-      return NextResponse.json({ ok: false, error: "value must be one of: off|prompt|on" }, { status: 400 });
-    }
-
-    await gatewayConfigPatch(
-      {
-        plugins: {
-          entries: {
-            recipes: {
-              config: {
-                cronInstallation: value,
-              },
-            },
-          },
-        },
-      },
-      `ClawKitchen: set ${CFG_PATH}=${value}`
-    );
-
-    return NextResponse.json({ ok: true, path: CFG_PATH, value, note: "Gateway will restart to apply config." });
-  } catch (e: unknown) {
-    return NextResponse.json(
-      { ok: false, error: errorMessage(e) },
-      { status: 500 },
-    );
-  }
-}

package/src/app/api/skills/available/route.ts

@@ -1,23 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { NextResponse } from "next/server";
-import { errorMessage } from "@/lib/errors";
-
-export async function GET() {
-  const home = os.homedir();
-  const globalSkillsDir = path.join(home, ".openclaw", "skills");
-
-  try {
-    const entries = await fs.readdir(globalSkillsDir, { withFileTypes: true });
-    const skills = entries
-      .filter((e) => e.isDirectory())
-      .map((e) => e.name)
-      .sort((a, b) => a.localeCompare(b));
-
-    return NextResponse.json({ ok: true, skillsDir: globalSkillsDir, skills });
-  } catch (e: unknown) {
-    // If missing, treat as empty.
-    return NextResponse.json({ ok: true, skillsDir: globalSkillsDir, skills: [], note: errorMessage(e) });
-  }
-}