@jiggai/kitchen 0.1.11 → 0.2.0

package/src/lib/agents.ts

@@ -0,0 +1,17 @@
+import { runOpenClaw } from "./openclaw";
+
+export type AgentListItem = {
+  id: string;
+  identityName?: string;
+  workspace?: string;
+  model?: string;
+  isDefault?: boolean;
+};
+
+export async function resolveAgentWorkspace(agentId: string): Promise<string> {
+  const { stdout } = await runOpenClaw(["agents", "list", "--json"]);
+  const list = JSON.parse(stdout) as AgentListItem[];
+  const agent = list.find((a) => a.id === agentId);
+  if (!agent?.workspace) throw new Error(`Agent workspace not found for ${agentId}`);
+  return agent.workspace;
+}

package/src/lib/api-route-helpers.ts

@@ -0,0 +1,157 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+
+/** Parses JSON body; returns 400 on parse error. */
+export async function parseJsonBody(req: Request): Promise<{ body: Record<string, unknown> } | NextResponse> {
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "Invalid JSON" }, { status: 400 });
+  }
+  const o = body && typeof body === "object" ? (body as Record<string, unknown>) : {};
+  return { body: o };
+}
+
+/** Returns NextResponse.json({ ok: true, ...rest }) from a storage result with ok field. */
+export function jsonOkRest<T extends { ok: boolean }>(r: T): NextResponse {
+  const rest = Object.fromEntries(Object.entries(r as Record<string, unknown>).filter(([k]) => k !== "ok"));
+  return NextResponse.json({ ok: true, ...rest });
+}
+
+import { resolveAgentWorkspace } from "@/lib/agents";
+import { errorMessage } from "@/lib/errors";
+
+/** Runs async storage fn and returns jsonOkRest on success, or 500 on error. */
+export async function withStorageError<T extends { ok: boolean }>(
+  fn: () => Promise<T>
+): Promise<NextResponse> {
+  try {
+    return jsonOkRest(await fn());
+  } catch (err: unknown) {
+    return NextResponse.json({ ok: false, error: errorMessage(err) }, { status: 500 });
+  }
+}
+import { readOpenClawConfig, teamDirFromBaseWorkspace } from "@/lib/paths";
+
+export type TeamContext = { teamId: string; teamDir: string };
+
+/** Error response for install-skill openclaw failures. Use when runOpenClaw returns !ok. */
+export function installSkillErrorResponse(
+  args: string[],
+  res: { stdout?: string; stderr?: string; exitCode?: number },
+  extra?: Record<string, unknown>
+): NextResponse {
+  const stdout = res.stdout?.trim();
+  const stderr = res.stderr?.trim();
+  return NextResponse.json(
+    {
+      ok: false,
+      error: stderr || stdout || `openclaw ${args.join(" ")} failed (exit=${res.exitCode})`,
+      stdout: res.stdout,
+      stderr: res.stderr,
+      ...extra,
+    },
+    { status: 500 }
+  );
+}
+
+async function resolveTeamContext(teamId: string): Promise<TeamContext | NextResponse> {
+  if (!teamId) return NextResponse.json({ ok: false, error: "teamId is required" }, { status: 400 });
+
+  const cfg = await readOpenClawConfig();
+  const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
+  if (!baseWorkspace) {
+    return NextResponse.json({ ok: false, error: "agents.defaults.workspace not set" }, { status: 500 });
+  }
+
+  const teamDir = teamDirFromBaseWorkspace(baseWorkspace, teamId);
+  return { teamId, teamDir };
+}
+
+/** Resolves teamId and teamDir from URL search params. Returns error response if invalid. */
+export async function getTeamContextFromQuery(req: Request): Promise<TeamContext | NextResponse> {
+  const { searchParams } = new URL(req.url);
+  const teamId = String(searchParams.get("teamId") ?? "").trim();
+  return resolveTeamContext(teamId);
+}
+
+/** Runs handler with team context from query; returns error response if context invalid. */
+export async function withTeamContextFromQuery(
+  req: Request,
+  handler: (ctx: TeamContext) => Promise<NextResponse>
+): Promise<NextResponse> {
+  const ctx = await getTeamContextFromQuery(req);
+  if (ctx instanceof NextResponse) return ctx;
+  return handler(ctx);
+}
+
+/** Resolves teamId and teamDir from parsed body. Caller must parse req.json() first. */
+export async function getTeamContextFromBody(body: { teamId?: string }): Promise<TeamContext | NextResponse> {
+  const teamId = String(body.teamId ?? "").trim();
+  return resolveTeamContext(teamId);
+}
+
+export type AgentContext = { agentId: string; ws: string };
+
+/** Resolves agentId and workspace from URL search params. Returns error response if invalid. */
+export async function getAgentContextFromQuery(req: Request): Promise<AgentContext | NextResponse> {
+  const { searchParams } = new URL(req.url);
+  const agentId = String(searchParams.get("agentId") ?? "").trim();
+  return resolveAgentContext(agentId);
+}
+
+/** Resolves agentId and workspace from parsed body. Caller must parse req.json() first. */
+export async function getAgentContextFromBody(body: { agentId?: string }): Promise<AgentContext | NextResponse> {
+  const agentId = String(body.agentId ?? "").trim();
+  return resolveAgentContext(agentId);
+}
+
+async function resolveAgentContext(agentId: string): Promise<AgentContext | NextResponse> {
+  if (!agentId) return NextResponse.json({ ok: false, error: "agentId is required" }, { status: 400 });
+  try {
+    const ws = await resolveAgentWorkspace(agentId);
+    return { agentId, ws };
+  } catch (e: unknown) {
+    return NextResponse.json({ ok: false, error: errorMessage(e) }, { status: 404 });
+  }
+}
+
+export type FileCandidate = { name: string; required: boolean; rationale: string };
+
+/** Lists workspace files with presence/size info. */
+export async function listWorkspaceFiles(
+  baseDir: string,
+  candidates: FileCandidate[]
+): Promise<
+  Array<{
+    name: string;
+    required: boolean;
+    rationale: string;
+    path: string;
+    missing: boolean;
+    size?: number;
+    updatedAtMs?: number;
+  }>
+> {
+  return Promise.all(
+    candidates.map(async (c) => {
+      const p = path.join(baseDir, c.name);
+      try {
+        const st = await fs.stat(p);
+        return {
+          name: c.name,
+          required: c.required,
+          rationale: c.rationale,
+          path: p,
+          missing: false,
+          size: st.size,
+          updatedAtMs: st.mtimeMs,
+        };
+      } catch {
+        return { name: c.name, required: c.required, rationale: c.rationale, path: p, missing: true };
+      }
+    })
+  );
+}

package/src/lib/cron.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared shape for cron job objects returned by the gateway cron tool.
+ * Different callers may receive slightly different structures; these helpers normalize access.
+ */
+export type CronJobShape = {
+  id?: unknown;
+  jobId?: unknown;
+  name?: unknown;
+  enabled?: unknown;
+  state?: { enabled?: unknown };
+};
+
+/** Typed cron job for UI display. API returns jobs that match this structure. */
+export type CronJob = {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  schedule?: { kind?: string; expr?: string; everyMs?: number };
+  state?: { nextRunAtMs?: number };
+  agentId?: string;
+  sessionTarget?: string;
+};
+
+export function cronJobId(j: CronJobShape): string {
+  return String(j.id ?? j.jobId ?? "").trim();
+}
+
+export function cronJobLabel(j: CronJobShape): string {
+  return String(j.name ?? j.id ?? j.jobId ?? "(unnamed)");
+}
+
+export function fmtCronSchedule(s?: CronJob["schedule"]): string {
+  if (!s) return "";
+  if (s.kind === "cron" && s.expr) return s.expr;
+  if (s.kind === "every" && s.everyMs) {
+    const mins = Math.round(s.everyMs / 60000);
+    return mins >= 60 ? `every ${Math.round(mins / 60)}h` : `every ${mins}m`;
+  }
+  return s.kind ?? "";
+}

package/src/lib/editor-utils.ts

@@ -0,0 +1,18 @@
+export type FileListEntry = {
+  name: string;
+  missing: boolean;
+  required: boolean;
+  rationale?: string;
+};
+
+export function normalizeFileListEntries(files: unknown[]): FileListEntry[] {
+  return files.map((f) => {
+    const entry = f as { name?: unknown; missing?: unknown; required?: unknown; rationale?: unknown };
+    return {
+      name: String(entry.name ?? ""),
+      missing: Boolean(entry.missing),
+      required: Boolean(entry.required),
+      rationale: typeof entry.rationale === "string" ? entry.rationale : undefined,
+    };
+  });
+}

package/src/lib/errors.ts

@@ -0,0 +1,7 @@
+/**
+ * Extracts a string message from an unknown error value.
+ * Used consistently across API routes and client components.
+ */
+export function errorMessage(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}

package/src/lib/exec.ts

@@ -0,0 +1,4 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+export const execFileAsync = promisify(execFile);

package/src/lib/fetch-json.ts

@@ -0,0 +1,29 @@
+/** Fetches multiple URLs in parallel with cache: "no-store". */
+export async function fetchAll(urls: string[]): Promise<Response[]> {
+  return Promise.all(urls.map((url) => fetch(url, { cache: "no-store" })));
+}
+
+/**
+ * Fetches JSON and throws on !res.ok.
+ * Use errorMessage(e) in catch blocks.
+ */
+export async function fetchJson<T = unknown>(url: string, opts?: RequestInit): Promise<T> {
+  const res = await fetch(url, opts);
+  const json = (await res.json()) as { error?: string };
+  if (!res.ok) throw new Error(json.error ?? "Request failed");
+  return json as T;
+}
+
+/**
+ * Fetches JSON and returns result with status. Use when you need to handle specific
+ * HTTP status codes (e.g. 409) differently from generic errors.
+ */
+export async function fetchJsonWithStatus<T = unknown>(
+  url: string,
+  opts?: RequestInit
+): Promise<{ ok: true; data: T } | { ok: false; status: number; error: string }> {
+  const res = await fetch(url, opts);
+  const json = (await res.json()) as { error?: string };
+  if (res.ok) return { ok: true, data: json as T };
+  return { ok: false, status: res.status, error: json.error ?? "Request failed" };
+}

package/src/lib/gateway.ts

@@ -62,13 +62,17 @@ export async function toolsInvoke<T = unknown>(req: ToolsInvokeRequest): Promise
   return json.result as T;
 }
 
+export function getContentText(content: Array<{ type: string; text?: string }> | undefined): string | undefined {
+  return content?.find((c) => c.type === "text")?.text;
+}
+
 export async function gatewayConfigGet(): Promise<{ raw: string; hash: string }> {
   const toolResult = await toolsInvoke<{ content: Array<{ type: string; text?: string }> }>({
     tool: "gateway",
     args: { action: "config.get", raw: "{}" },
   });
 
-  const text = toolResult?.content?.find((c) => c.type === "text")?.text;
+  const text = getContentText(toolResult?.content);
   if (!text) throw new Error("gateway config.get: missing text payload");
 
   const parsed = JSON.parse(text) as ToolTextEnvelope;

package/src/lib/goal-promote.ts

@@ -0,0 +1,27 @@
+import { slugifyId } from "./slugify";
+
+/** Slugify for file path parts (max 80 chars). */
+export function slugifyFilePart(input: string): string {
+  return slugifyId(input, 80);
+}
+
+const WORKFLOW_MARKER = "<!-- goal-workflow -->";
+
+export function ensureWorkflowInstructions(body: string): string {
+  if (body.includes(WORKFLOW_MARKER)) return body;
+  const snippet = [
+    "",
+    "## Workflow",
+    WORKFLOW_MARKER,
+    "- Use **Promote to inbox** to send this goal to the development-team inbox for scoping.",
+    "- When promoted, set goal status to **active**.",
+    "- Track implementation work via tickets (add links/IDs under a **Tickets** section in this goal).",
+    "- When development is complete (all associated tickets marked done), set goal status to **done**.",
+    "",
+    "## Tickets",
+    "- (add ticket links/ids)",
+    "",
+  ].join("\n");
+
+  return (body ?? "").trim() + snippet;
+}

package/src/lib/goals-client.ts

@@ -0,0 +1,69 @@
+"use client";
+
+import { useMemo, useState } from "react";
+
+/** Client-safe goal types and utils (no node deps). */
+
+export type GoalStatus = "planned" | "active" | "done";
+
+export type GoalFrontmatter = {
+  id: string;
+  title: string;
+  status: GoalStatus;
+  tags: string[];
+  teams: string[];
+  updatedAt: string;
+};
+
+/** Form state shape for GoalFormFields. */
+export type GoalFormState = {
+  title: string;
+  setTitle: (v: string) => void;
+  status: GoalStatus;
+  setStatus: (v: GoalStatus) => void;
+  tagsRaw: string;
+  setTagsRaw: (v: string) => void;
+  teamsRaw: string;
+  setTeamsRaw: (v: string) => void;
+  body: string;
+  setBody: (v: string) => void;
+};
+
+/** Parses comma-separated string into trimmed non-empty array. */
+export function parseCommaList(raw: string): string[] {
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+/** Shared form state for goal create/edit. Returns formState for GoalFormFields and parsed tags/teams. */
+export function useGoalFormState(initial?: Partial<GoalFormState>): {
+  formState: GoalFormState;
+  tags: string[];
+  teams: string[];
+} {
+  const [title, setTitle] = useState(initial?.title ?? "");
+  const [status, setStatus] = useState<GoalStatus>(initial?.status ?? "planned");
+  const [tagsRaw, setTagsRaw] = useState(initial?.tagsRaw ?? "");
+  const [teamsRaw, setTeamsRaw] = useState(initial?.teamsRaw ?? "");
+  const [body, setBody] = useState(initial?.body ?? "");
+
+  const formState: GoalFormState = useMemo(
+    () => ({
+      title,
+      setTitle,
+      status,
+      setStatus,
+      tagsRaw,
+      setTagsRaw,
+      teamsRaw,
+      setTeamsRaw,
+      body,
+      setBody,
+    }),
+    [title, status, tagsRaw, teamsRaw, body]
+  );
+
+  const tags = useMemo(() => parseCommaList(tagsRaw), [tagsRaw]);
+  const teams = useMemo(() => parseCommaList(teamsRaw), [teamsRaw]);
+
+  return { formState, tags, teams };
+}

package/src/lib/goals.ts

@@ -1,10 +1,17 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { NextResponse } from "next/server";
 import YAML from "yaml";
+import { errorMessage } from "@/lib/errors";
 import { getWorkspaceGoalsDir } from "@/lib/paths";
 
 export type GoalStatus = "planned" | "active" | "done";
 
+/** Parses comma-separated string into trimmed non-empty array. */
+export function parseCommaList(raw: string): string[] {
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
 export type GoalFrontmatter = {
   id: string;
   title: string;
@@ -20,7 +27,7 @@ export type GoalSummary = GoalFrontmatter & {
 
 const ID_RE = /^[a-z0-9][a-z0-9-]{1,63}$/;
 
-function assertSafeGoalId(id: string) {
+export function assertSafeGoalId(id: string) {
   if (!ID_RE.test(id)) {
     throw new Error(
       `Invalid goal id "${id}". Use 2-64 chars: lowercase letters, numbers, hyphens. Example: "increase-trial-activation".`
@@ -28,7 +35,19 @@ function assertSafeGoalId(id: string) {
   }
 }
 
-function splitFrontmatter(md: string): { fm: unknown; body: string } {
+/** Maps goal-related errors to HTTP status: 400 for validation, 500 for other. */
+export function goalErrorStatus(msg: string): 400 | 500 {
+  return /Invalid goal id|Path traversal/.test(msg) ? 400 : 500;
+}
+
+/** Returns NextResponse for goal API errors. Use in catch blocks. */
+export function goalErrorResponse(e: unknown): NextResponse {
+  const msg = errorMessage(e);
+  const status = goalErrorStatus(msg);
+  return NextResponse.json({ error: msg }, { status });
+}
+
+export function splitFrontmatter(md: string): { fm: unknown; body: string } {
   if (md.startsWith("---\n")) {
     const end = md.indexOf("\n---\n", 4);
     if (end !== -1) {
@@ -41,7 +60,7 @@ function splitFrontmatter(md: string): { fm: unknown; body: string } {
   return { fm: {}, body: md };
 }
 
-function normalizeFrontmatter(input: unknown, fallbackId: string, fallbackTitle: string): GoalFrontmatter {
+export function normalizeFrontmatter(input: unknown, fallbackId: string, fallbackTitle: string): GoalFrontmatter {
   const now = new Date().toISOString();
   const obj = (input && typeof input === "object") ? (input as Record<string, unknown>) : {};
   const id = String(obj.id ?? fallbackId).trim();

package/src/lib/json.ts

@@ -0,0 +1,10 @@
+/**
+ * Safely parse JSON. Returns null on parse error.
+ */
+export function safeJsonParse(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}

package/src/lib/openclaw.ts

@@ -7,11 +7,32 @@ export type OpenClawExecResult = {
   stderr: string;
 };
 
+function extractStdout(err: { stdout?: unknown }): string {
+  if (typeof err.stdout === "string") return err.stdout;
+  if (err.stdout && typeof err.stdout === "object" && "toString" in err.stdout) {
+    return String((err.stdout as { toString: () => string }).toString());
+  }
+  return "";
+}
+
+function resolveExitCode(res: { exitCode?: unknown; code?: unknown; status?: unknown }): number {
+  if (typeof res.exitCode === "number") return res.exitCode;
+  if (typeof res.code === "number") return res.code;
+  if (typeof res.status === "number") return res.status;
+  return 0;
+}
+
+function extractStderr(err: { stderr?: unknown; message?: unknown }, fallback: unknown): string {
+  if (typeof err.stderr === "string") return err.stderr;
+  if (err.stderr && typeof err.stderr === "object" && "toString" in err.stderr) {
+    return String((err.stderr as { toString: () => string }).toString());
+  }
+  if (typeof err.message === "string") return err.message;
+  return String(fallback);
+}
+
 export async function runOpenClaw(args: string[]): Promise<OpenClawExecResult> {
-  // Avoid child_process usage in plugin code (triggers OpenClaw install-time safety warnings).
-  // Delegate to the OpenClaw runtime helper instead.
   const api = getKitchenApi();
-
   try {
     const res = (await api.runtime.system.runCommandWithTimeout(["openclaw", ...args], { timeoutMs: 120000 })) as {
       stdout?: unknown;
@@ -23,22 +44,16 @@ export async function runOpenClaw(args: string[]): Promise<OpenClawExecResult> {
 
     const stdout = String(res.stdout ?? "");
     const stderr = String(res.stderr ?? "");
-    const exitCode =
-      typeof res.exitCode === "number"
-        ? res.exitCode
-        : typeof res.code === "number"
-          ? res.code
-          : typeof res.status === "number"
-            ? res.status
-            : 0;
+    const exitCode = resolveExitCode(res);
+
 
     if (exitCode !== 0) return { ok: false, exitCode, stdout, stderr };
     return { ok: true, exitCode: 0, stdout, stderr };
   } catch (e: unknown) {
     const err = e as { code?: unknown; stdout?: unknown; stderr?: unknown; message?: unknown };
     const exitCode = typeof err.code === "number" ? err.code : 1;
-    const stdout = typeof err.stdout === "string" ? err.stdout : "";
-    const stderr = typeof err.stderr === "string" ? err.stderr : typeof err.message === "string" ? err.message : String(e);
+    const stdout = extractStdout(err);
+    const stderr = extractStderr(err, e);
     return { ok: false, exitCode, stdout, stderr };
   }
 }

package/src/lib/paths.ts

@@ -46,6 +46,18 @@ export async function getTeamWorkspaceDir(teamId: string) {
   return path.join(home, ".openclaw", `workspace-${teamId}`);
 }
 
+/** Team workspace dir derived from agents.defaults.workspace (sibling: .. / workspace-{teamId}) */
+export function teamDirFromBaseWorkspace(baseWorkspace: string, teamId: string) {
+  return path.resolve(baseWorkspace, "..", `workspace-${teamId}`);
+}
+
+/** Rejects path traversal and empty names; returns normalized name. */
+export function assertSafeRelativeFileName(name: string): string {
+  const n = name.replace(/\\/g, "/");
+  if (!n || n.startsWith("/") || n.includes("..")) throw new Error("Invalid file name");
+  return n;
+}
+
 export async function getBuiltinRecipesDir() {
   const cfg = await readOpenClawConfig();
   const p =

package/src/lib/poll.ts

@@ -0,0 +1,18 @@
+/**
+ * Polls until check returns a non-null value or timeout. Returns the value or null on timeout.
+ */
+export async function pollUntil<T>(
+  check: () => Promise<T | null>,
+  opts: { timeoutMs: number; intervalMs?: number }
+): Promise<T | null> {
+  const intervalMs = opts.intervalMs ?? 500;
+  const started = Date.now();
+
+  while (Date.now() - started < opts.timeoutMs) {
+    const result = await check();
+    if (result !== null) return result;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+
+  return null;
+}

package/src/lib/recipe-clone.ts

@@ -0,0 +1,42 @@
+import YAML from "yaml";
+
+export function suggestIds(baseId: string): string[] {
+  const b = String(baseId || "recipe").trim();
+  return [`custom-${b}`, `my-${b}`, `${b}-2`, `${b}-alt`];
+}
+
+export function scaffoldCmdForKind(kind: string, toId: string): string[] | null {
+  if (kind === "team") {
+    return ["recipes", "scaffold-team", toId, "--team-id", toId, "--overwrite", "--overwrite-recipe"];
+  }
+  if (kind === "agent") {
+    return ["recipes", "scaffold", toId, "--agent-id", toId, "--overwrite", "--overwrite-recipe"];
+  }
+  return null;
+}
+
+export function patchFrontmatter(
+  original: string,
+  toId: string,
+  toName: string | undefined
+): { next: string; kind: string } {
+  const end = original.indexOf("\n---\n", 4);
+  if (end === -1) throw new Error("Recipe frontmatter not terminated (---)");
+  const yamlText = original.slice(4, end + 1);
+  const fm = (YAML.parse(yamlText) ?? {}) as Record<string, unknown>;
+  const kind = String(fm.kind ?? "").trim().toLowerCase();
+
+  const teamPatch =
+    kind === "team"
+      ? {
+          team: {
+            ...(typeof fm.team === "object" && fm.team ? (fm.team as Record<string, unknown>) : {}),
+            teamId: toId,
+          },
+        }
+      : {};
+  const patched: Record<string, unknown> = { ...fm, id: toId, ...(toName ? { name: toName } : {}), ...teamPatch };
+  const nextYaml = YAML.stringify(patched).trimEnd();
+  const next = `---\n${nextYaml}\n---\n${original.slice(end + 5)}`;
+  return { next, kind };
+}

package/src/lib/recipe-team-agents.ts

@@ -0,0 +1,30 @@
+export function splitRecipeFrontmatter(md: string): { yamlText: string; rest: string } {
+  if (!md.startsWith("---\n")) throw new Error("Recipe markdown must start with YAML frontmatter (---)");
+  const end = md.indexOf("\n---\n", 4);
+  if (end === -1) throw new Error("Recipe frontmatter not terminated (---)");
+  const yamlText = md.slice(4, end + 1);
+  const rest = md.slice(end + 5);
+  return { yamlText, rest };
+}
+
+export function normalizeRole(role: string): string {
+  const r = role.trim();
+  if (!r) throw new Error("role is required");
+  if (!/^[a-z][a-z0-9-]{0,62}$/i.test(r)) throw new Error("role must be alphanumeric/dash");
+  return r;
+}
+
+/** Validates create-team or create-agent id. Returns error message or null. */
+export function validateCreateId(
+  recipe: { id: string } | null,
+  id: string,
+  entityLabel: "team" | "agent"
+): string | null {
+  if (!recipe) return null;
+  const t = id.trim();
+  const label = entityLabel === "team" ? "Team id" : "Agent id";
+  if (!t) return `${label} is required.`;
+  if (t === recipe.id)
+    return `${label} cannot be the same as the recipe id (${recipe.id}). Choose a new ${entityLabel} id.`;
+  return null;
+}