@jiggai/kitchen 0.1.11 → 0.2.0

package/src/lib/recipes.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
+import { runOpenClaw } from "./openclaw";
 import { getBuiltinRecipesDir, getWorkspaceRecipesDir } from "./paths";
 
 export type RecipeListItem = {
@@ -25,6 +26,52 @@ export function parseFrontmatterId(md: string): string {
   return fm.id;
 }
 
+/** Ensures the frontmatter id field matches the given id. Preserves body. Returns md unchanged if no valid frontmatter. */
+export function forceFrontmatterId(md: string, id: string): string {
+  if (!md.startsWith("---\n")) return md;
+  const end = md.indexOf("\n---\n", 4);
+  if (end === -1) return md;
+  const fm = md.slice(4, end);
+  const body = md.slice(end + 5);
+
+  const lines = fm.split("\n");
+  let found = false;
+  const nextLines = lines.map((line) => {
+    if (/^id\s*:/i.test(line)) {
+      found = true;
+      return `id: ${id}`;
+    }
+    return line;
+  });
+  if (!found) nextLines.unshift(`id: ${id}`);
+
+  return `---\n${nextLines.join("\n")}\n---\n${body}`;
+}
+
+/** Returns display name for a team from recipe list, or null if not found. */
+export async function getTeamDisplayName(teamId: string): Promise<string | null> {
+  const recipes = await listRecipes();
+  const match = recipes.find((r) => r.kind === "team" && r.id === teamId);
+  return match?.name ?? null;
+}
+
+/** Fetches recipe list from openclaw. Returns empty array on failure. */
+export async function listRecipes(): Promise<RecipeListItem[]> {
+  const list = await runOpenClaw(["recipes", "list"]);
+  if (!list.ok) return [];
+  try {
+    return JSON.parse(list.stdout) as RecipeListItem[];
+  } catch {
+    return [];
+  }
+}
+
+/** Fetches recipe list and returns the item with the given id, or null. */
+export async function findRecipeById(id: string): Promise<RecipeListItem | null> {
+  const recipes = await listRecipes();
+  return recipes.find((r) => r.id === id) ?? null;
+}
+
 export async function resolveRecipePath(item: RecipeListItem): Promise<string> {
   const dir = item.source === "builtin" ? await getBuiltinRecipesDir() : await getWorkspaceRecipesDir();
   // Current convention: <id>.md in the directory.

package/src/lib/scaffold-client.ts

@@ -0,0 +1,31 @@
+/** Client-side scaffold API. Shared by RecipeEditor and recipes-client. */
+
+export type ScaffoldTeamBody = {
+  kind: "team";
+  recipeId: string;
+  teamId: string;
+  cronInstallChoice?: "yes" | "no";
+};
+
+export type ScaffoldAgentBody = {
+  kind: "agent";
+  recipeId: string;
+  agentId: string;
+  name?: string;
+};
+
+export async function fetchScaffold(
+  body: ScaffoldTeamBody | ScaffoldAgentBody
+): Promise<{ res: Response; json: unknown }> {
+  const res = await fetch("/api/scaffold", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      ...body,
+      applyConfig: true,
+      overwrite: false,
+    }),
+  });
+  const json = await res.json();
+  return { res, json };
+}

package/src/lib/scaffold.ts

@@ -0,0 +1,37 @@
+export type ScaffoldReqBody =
+  | {
+      kind: "agent";
+      recipeId: string;
+      agentId?: string;
+      name?: string;
+      applyConfig?: boolean;
+      overwrite?: boolean;
+    }
+  | {
+      kind: "team";
+      recipeId: string;
+      teamId?: string;
+      applyConfig?: boolean;
+      overwrite?: boolean;
+    };
+
+export type BuildScaffoldArgsOptions = {
+  allowExisting?: boolean;
+};
+
+export function buildScaffoldArgs(
+  body: ScaffoldReqBody,
+  options?: BuildScaffoldArgsOptions
+): string[] {
+  const args: string[] = ["recipes", body.kind === "team" ? "scaffold-team" : "scaffold", body.recipeId];
+  if (body.overwrite) args.push("--overwrite");
+  if (body.applyConfig) args.push("--apply-config");
+  if (options?.allowExisting || body.overwrite) args.push("--overwrite-recipe");
+  if (body.kind === "agent") {
+    if (body.agentId) args.push("--agent-id", body.agentId);
+    if (body.name) args.push("--name", body.name);
+  } else if (body.teamId) {
+    args.push("--team-id", body.teamId);
+  }
+  return args;
+}

package/src/lib/slugify.ts

@@ -0,0 +1,25 @@
+/**
+ * Slugify a string for use in ids, file names, or URLs.
+ * Normalizes to lowercase, replaces non-alphanumeric sequences with hyphens, trims edges.
+ * Uses character-by-character processing to avoid regex ReDoS.
+ * @param maxLength - optional max length (default 80). Use 64 for goal ids.
+ */
+export function slugifyId(input: string, maxLength = 80): string {
+  const s = String(input ?? "").toLowerCase().trim();
+  const cap = Math.min(s.length, maxLength * 2);
+  let result = "";
+  let prevHyphen = false;
+  for (let i = 0; i < cap; i++) {
+    const c = s[i];
+    if ((c >= "a" && c <= "z") || (c >= "0" && c <= "9")) {
+      result += c;
+      prevHyphen = false;
+    } else if ((c === " " || c === "-" || c === "_") && !prevHyphen) {
+      result += "-";
+      prevHyphen = true;
+    }
+  }
+  while (result.startsWith("-")) result = result.slice(1);
+  while (result.endsWith("-")) result = result.slice(0, -1);
+  return result.slice(0, maxLength);
+}

package/src/lib/swarms.ts

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+/** Validates and returns trimmed id; throws if empty or invalid format. */
+export function normalizeId(kind: string, id: string): string {
+  const s = String(id ?? "").trim();
+  if (!s) throw new Error(`${kind} is required`);
+  if (!/^[a-z0-9][a-z0-9-]{0,62}$/i.test(s)) {
+    throw new Error(`${kind} must match /^[a-z0-9][a-z0-9-]{0,62}$/i`);
+  }
+  return s;
+}
+
+/** Resolves workspace path for an agent/orchestrator by id (convention: workspace-<id>). */
+export async function resolveAgentWorkspace(agentId: string): Promise<string> {
+  const cfgPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+  const raw = await fs.readFile(cfgPath, "utf8");
+  const cfg = JSON.parse(raw) as { agents?: { defaults?: { workspace?: string } } };
+
+  const baseWorkspace = String(cfg?.agents?.defaults?.workspace ?? "").trim();
+  if (!baseWorkspace) throw new Error("agents.defaults.workspace not set");
+
+  return path.resolve(baseWorkspace, "..", `workspace-${agentId}`);
+}

package/src/lib/tickets.ts

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 
 export type TicketStage = "backlog" | "in-progress" | "testing" | "done";
@@ -14,27 +15,53 @@ export interface TicketSummary {
   ageHours: number;
 }
 
-const TEAM_WORKSPACE = "/home/control/.openclaw/workspace-development-team";
+function assertSafeTeamId(teamId: string) {
+  // Conservative: matches OpenClaw team ids like "development-team".
+  if (!/^[a-z0-9][a-z0-9-]{1,63}$/.test(teamId)) {
+    throw new Error(`Invalid teamId "${teamId}"`);
+  }
+}
+
+function isPathLike(s: string) {
+  return s.includes("/") || s.includes("\\");
+}
+
+export function teamWorkspace(teamId: string) {
+  assertSafeTeamId(teamId);
+  return path.join(os.homedir(), ".openclaw", `workspace-${teamId}`);
+}
+
+/**
+ * Back-compat for older non-team-scoped routes.
+ * Prefer passing explicit teamId into APIs instead.
+ */
+export function getTeamWorkspaceDir(): string {
+  return process.env.CK_TEAM_WORKSPACE_DIR ?? teamWorkspace("development-team");
+}
 
-function stageDir(stage: TicketStage) {
+export function stageDir(stage: TicketStage, teamOrDir: string = "development-team") {
   const map: Record<TicketStage, string> = {
     backlog: "work/backlog",
     "in-progress": "work/in-progress",
     testing: "work/testing",
     done: "work/done",
   };
-  return path.join(TEAM_WORKSPACE, map[stage]);
+
+  const base = isPathLike(teamOrDir) ? teamOrDir : teamWorkspace(teamOrDir);
+  return path.join(base, map[stage]);
 }
 
-function parseTitle(md: string) {
-  // Ticket markdown files typically start with:
-  //   # 0033-some-slug
-  // (no human title after the id). Prefer extracting a readable title from the slug.
-  const header = md.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "";
+export function parseTitle(md: string) {
+  // Ticket markdown files typically start with: # 0033-some-slug
+  const firstLine = md.split("\n")[0] ?? "";
+  const header = firstLine.startsWith("# ") ? firstLine.slice(2).trim() : "";
 
   // If header is like: "<id> <title...>" keep the explicit title portion.
-  const withExplicit = header.match(/^\S+\s+(.+)$/);
-  if (withExplicit?.[1]?.trim()) return withExplicit[1].trim();
+  const firstSpace = header.indexOf(" ");
+  if (firstSpace > 0) {
+    const afterSpace = header.slice(firstSpace + 1).trim();
+    if (afterSpace) return afterSpace;
+  }
 
   // Otherwise derive from the slug: strip leading number + hyphen, then de-kebab.
   const derivedRaw = header
@@ -43,14 +70,16 @@ function parseTitle(md: string) {
     .replace(/\s+/g, " ")
     .trim();
 
+  const ACRONYMS = new Set(["api", "cli", "ui", "ux", "gpu", "cpu", "npm", "pr", "ci", "cd", "json", "yaml", "md"]);
   const titleCase = (s: string) =>
     s
       .split(" ")
       .filter(Boolean)
       .map((w) => {
-        // Keep common acronyms and versions readable.
-        if (/^(v\d+(?:\.\d+)*|api|cli|ui|ux|gpu|cpu|npm|pr|ci|cd|json|yaml|md)$/i.test(w)) return w.toUpperCase();
-        if (/^\d+(?:\.\d+)*$/.test(w)) return w;
+        const lower = w.toLowerCase();
+        if (ACRONYMS.has(lower)) return w.toUpperCase();
+        if (lower.startsWith("v") && /^\d/.test(lower.slice(1))) return w; // version-like
+        if (/^[\d.]+$/.test(w)) return w; // numbers/semver
         return w.slice(0, 1).toUpperCase() + w.slice(1);
       })
       .join(" ");
@@ -62,25 +91,30 @@ function parseTitle(md: string) {
 }
 
 function parseField(md: string, field: string): string | null {
-  const re = new RegExp(`^${field}:\s*(.*)$`, "mi");
+  const re = new RegExp(`^${field}:\\s*(.*)$`, "mi");
   const m = md.match(re);
   return m?.[1]?.trim() || null;
 }
 
-function parseNumberFromFilename(filename: string): number | null {
+export function parseNumberFromFilename(filename: string): number | null {
   const m = filename.match(/^(\d{4})-/);
   if (!m) return null;
   return Number(m[1]);
 }
 
-export async function listTickets(): Promise<TicketSummary[]> {
+/**
+ * List tickets.
+ * - Preferred: listTickets("development-team")
+ * - Back-compat: listTickets(getTeamWorkspaceDir())
+ */
+export async function listTickets(teamIdOrDir: string = "development-team"): Promise<TicketSummary[]> {
   const stages: TicketStage[] = ["backlog", "in-progress", "testing", "done"];
   const all: TicketSummary[] = [];
 
   for (const stage of stages) {
     let files: string[] = [];
     try {
-      files = await fs.readdir(stageDir(stage));
+      files = await fs.readdir(stageDir(stage, teamIdOrDir));
     } catch {
       files = [];
     }
@@ -90,7 +124,7 @@ export async function listTickets(): Promise<TicketSummary[]> {
       const number = parseNumberFromFilename(f);
       if (number == null) continue;
 
-      const file = path.join(stageDir(stage), f);
+      const file = path.join(stageDir(stage, teamIdOrDir), f);
       const [md, stat] = await Promise.all([fs.readFile(file, "utf8"), fs.stat(file)]);
 
       const title = parseTitle(md);
@@ -115,22 +149,44 @@ export async function listTickets(): Promise<TicketSummary[]> {
   return all;
 }
 
-export async function getTicketMarkdown(ticketIdOrNumber: string): Promise<{ id: string; file: string; markdown: string } | null> {
-  const tickets = await listTickets();
+/**
+ * Back-compat helper used by some API routes.
+ */
+export async function getTicketByIdOrNumber(
+  ticketIdOrNumber: string,
+  teamIdOrDir: string = "development-team",
+): Promise<TicketSummary | null> {
+  const tickets = await listTickets(teamIdOrDir);
   const normalized = ticketIdOrNumber.trim();
 
-  const byNumber = normalized.match(/^\d+$/)
-    ? tickets.find((t) => t.number === Number(normalized))
-    : null;
-
+  const byNumber = normalized.match(/^\d+$/) ? tickets.find((t) => t.number === Number(normalized)) : null;
   const byId = tickets.find((t) => t.id === normalized);
+  return byId ?? byNumber ?? null;
+}
+
+export async function resolveTicket(teamId: string, ticketIdOrNumber: string): Promise<TicketSummary | null> {
+  return getTicketByIdOrNumber(ticketIdOrNumber, teamId);
+}
 
-  const hit = byId ?? byNumber;
+/**
+ * getTicketMarkdown(teamId, ticketIdOrNumber) OR getTicketMarkdown(ticketIdOrNumber, teamDir)
+ */
+export async function getTicketMarkdown(
+  a: string,
+  b: string,
+): Promise<{ id: string; file: string; markdown: string; owner: string | null; stage: TicketStage } | null> {
+  // Detect call signature.
+  const ticketIdOrNumber = isPathLike(b) ? a : b;
+  const teamIdOrDir = isPathLike(b) ? b : a;
+
+  const hit = await getTicketByIdOrNumber(ticketIdOrNumber, teamIdOrDir);
   if (!hit) return null;
 
   return {
     id: hit.id,
     file: hit.file,
     markdown: await fs.readFile(hit.file, "utf8"),
+    owner: hit.owner,
+    stage: hit.stage,
   };
 }

package/src/lib/type-guards.ts

@@ -0,0 +1,3 @@
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return Boolean(v) && typeof v === "object" && !Array.isArray(v);
+}

package/src/lib/use-slugified-id.ts

@@ -0,0 +1,35 @@
+"use client";
+
+import { useEffect, useMemo } from "react";
+import { slugifyId } from "@/lib/slugify";
+
+/** Manages name -> slugified id with touch tracking. Resets on modal close. */
+export function useSlugifiedId(opts: {
+  open: boolean;
+  name: string;
+  setName: (v: string) => void;
+  id: string;
+  setId: (v: string) => void;
+  idTouched: boolean;
+  setIdTouched: (v: boolean) => void;
+  slugify?: (s: string, maxLen?: number) => string;
+}): { derivedId: string; effectiveId: string } {
+  const { open, name, setName, id, setId, idTouched, setIdTouched, slugify = slugifyId } = opts;
+
+  const derivedId = useMemo(() => slugify(name), [name, slugify]);
+  const effectiveId = idTouched ? id : derivedId;
+
+  useEffect(() => {
+    if (!open) return;
+    if (!idTouched) setId(derivedId);
+  }, [derivedId, open, idTouched, setId]);
+
+  useEffect(() => {
+    if (open) return;
+    setIdTouched(false);
+    setName("");
+    setId("");
+  }, [open, setIdTouched, setName, setId]);
+
+  return { derivedId, effectiveId };
+}

package/src/lib/workflows/README.md

@@ -0,0 +1,11 @@
+This folder contains the (early) file-first workflow model for ClawKitchen's Visual Workflows MVP.
+
+Source of truth lives in each team workspace:
+
+- shared-context/workflows/<id>.workflow.json
+
+API (temporary):
+
+- GET /api/teams/workflows?teamId=... (list)
+- GET /api/teams/workflows?teamId=...&id=... (read)
+- POST /api/teams/workflows { teamId, workflow } (write)

package/src/lib/workflows/__tests__/storage.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import {
+  workflowFileName,
+  assertSafeWorkflowId,
+  listWorkflows,
+  readWorkflow,
+  writeWorkflow,
+  deleteWorkflow,
+} from "../storage";
+
+vi.mock("@/lib/paths", () => ({
+  getTeamWorkspaceDir: vi.fn().mockResolvedValue("/home/test/workspace/team1"),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    readdir: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    unlink: vi.fn(),
+  },
+}));
+
+import fs from "node:fs/promises";
+
+describe("lib/workflows storage", () => {
+  beforeEach(() => {
+    vi.mocked(fs.readdir).mockReset();
+    vi.mocked(fs.readFile).mockReset();
+    vi.mocked(fs.writeFile).mockReset();
+    vi.mocked(fs.mkdir).mockReset();
+    vi.mocked(fs.unlink).mockReset();
+  });
+
+  describe("workflowFileName", () => {
+    it("returns id.workflow.json", () => {
+      expect(workflowFileName("my-workflow")).toBe("my-workflow.workflow.json");
+    });
+  });
+
+  describe("assertSafeWorkflowId", () => {
+    it("returns trimmed id when valid", () => {
+      expect(assertSafeWorkflowId("  abc-123  ")).toBe("abc-123");
+    });
+
+    it("throws when empty", () => {
+      expect(() => assertSafeWorkflowId("")).toThrow(/workflow id is required/i);
+      expect(() => assertSafeWorkflowId("   ")).toThrow(/workflow id is required/i);
+    });
+
+    it("throws when invalid chars", () => {
+      expect(() => assertSafeWorkflowId("UPPERCASE")).toThrow(/Invalid workflow id/i);
+      expect(() => assertSafeWorkflowId("has_underscore")).toThrow(/Invalid workflow id/i);
+      expect(() => assertSafeWorkflowId("has space")).toThrow(/Invalid workflow id/i);
+    });
+
+    it("accepts valid ids", () => {
+      expect(assertSafeWorkflowId("a")).toBe("a");
+      expect(assertSafeWorkflowId("abc-123")).toBe("abc-123");
+      expect(assertSafeWorkflowId("a1b2c3")).toBe("a1b2c3");
+    });
+  });
+
+  describe("listWorkflows", () => {
+    it("returns empty list when dir does not exist", async () => {
+      vi.mocked(fs.readdir).mockRejectedValue({ code: "ENOENT" });
+      const r = await listWorkflows("team1");
+      expect(r.ok).toBe(true);
+      expect(r.files).toEqual([]);
+    });
+
+    it("returns sorted workflow files", async () => {
+      vi.mocked(fs.readdir).mockResolvedValue([
+        { name: "b.workflow.json", isFile: () => true },
+        { name: "a.workflow.json", isFile: () => true },
+        { name: "other.txt", isFile: () => true },
+      ] as unknown as Awaited<ReturnType<typeof fs.readdir>>);
+      const r = await listWorkflows("team1");
+      expect(r.ok).toBe(true);
+      expect(r.files).toEqual(["a.workflow.json", "b.workflow.json"]);
+    });
+  });
+
+  describe("readWorkflow", () => {
+    it("returns parsed workflow", async () => {
+      const wf = { schema: "clawkitchen.workflow.v1", id: "wf1", name: "Test", nodes: [], edges: [] };
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(wf));
+      const r = await readWorkflow("team1", "wf1");
+      expect(r.ok).toBe(true);
+      expect(r.workflow).toEqual(wf);
+    });
+
+    it("throws when id invalid", async () => {
+      await expect(readWorkflow("team1", "")).rejects.toThrow(/workflow id is required/i);
+    });
+  });
+
+  describe("writeWorkflow", () => {
+    it("writes workflow with schema", async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      const wf = { schema: "clawkitchen.workflow.v1", id: "wf1", name: "Test", nodes: [], edges: [] };
+      const r = await writeWorkflow("team1", wf);
+      expect(r.ok).toBe(true);
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining("wf1.workflow.json"),
+        expect.stringContaining('"schema": "clawkitchen.workflow.v1"'),
+        "utf8"
+      );
+    });
+  });
+
+  describe("deleteWorkflow", () => {
+    it("returns existed:true when file deleted", async () => {
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+      const r = await deleteWorkflow("team1", "wf1");
+      expect(r.ok).toBe(true);
+      expect((r as { existed?: boolean }).existed).toBe(true);
+    });
+
+    it("returns existed:false when file not found", async () => {
+      vi.mocked(fs.unlink).mockRejectedValue({ code: "ENOENT" });
+      const r = await deleteWorkflow("team1", "wf1");
+      expect(r.ok).toBe(true);
+      expect((r as { existed?: boolean }).existed).toBe(false);
+    });
+  });
+});

package/src/lib/workflows/__tests__/validate.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { validateWorkflowFileV1 } from "../validate";
+
+describe("lib/workflows validate", () => {
+  const validWorkflow = {
+    schema: "clawkitchen.workflow.v1",
+    id: "test-wf",
+    name: "Test workflow",
+    nodes: [
+      { id: "start", type: "start" as const, x: 80, y: 80 },
+      { id: "end", type: "end" as const, x: 320, y: 80 },
+    ],
+    edges: [{ id: "e1", from: "start", to: "end" }],
+  };
+
+  it("returns no errors for valid workflow", () => {
+    const r = validateWorkflowFileV1(validWorkflow);
+    expect(r.errors).toEqual([]);
+    expect(r.warnings).toEqual([]);
+  });
+
+  it("errors when schema wrong", () => {
+    const r = validateWorkflowFileV1({ ...validWorkflow, schema: "wrong" as "clawkitchen.workflow.v1" });
+    expect(r.errors.some((e) => e.includes("schema"))).toBe(true);
+  });
+
+  it("errors when id missing", () => {
+    const r = validateWorkflowFileV1({ ...validWorkflow, id: "" });
+    expect(r.errors.some((e) => e.includes("id is required"))).toBe(true);
+  });
+
+  it("errors when name missing", () => {
+    const r = validateWorkflowFileV1({ ...validWorkflow, name: "" });
+    expect(r.errors.some((e) => e.includes("name is required"))).toBe(true);
+  });
+
+  it("errors when node ids not unique", () => {
+    const r = validateWorkflowFileV1({
+      ...validWorkflow,
+      nodes: [
+        { id: "dup", type: "start" as const },
+        { id: "dup", type: "end" as const },
+      ],
+      edges: [],
+    });
+    expect(r.errors.some((e) => e.includes("unique"))).toBe(true);
+  });
+
+  it("errors when edge references missing node", () => {
+    const r = validateWorkflowFileV1({
+      ...validWorkflow,
+      edges: [{ id: "e1", from: "start", to: "nonexistent" }],
+    });
+    expect(r.errors.some((e) => e.includes("missing to node"))).toBe(true);
+  });
+
+  it("warns when no start node", () => {
+    const r = validateWorkflowFileV1({
+      ...validWorkflow,
+      nodes: [{ id: "end", type: "end" as const }],
+      edges: [],
+    });
+    expect(r.warnings.some((w) => w.includes("no start node"))).toBe(true);
+  });
+
+  it("warns when no end node", () => {
+    const r = validateWorkflowFileV1({
+      ...validWorkflow,
+      nodes: [{ id: "start", type: "start" as const }],
+      edges: [],
+    });
+    expect(r.warnings.some((w) => w.includes("no end node"))).toBe(true);
+  });
+
+  it("validates cron triggers", () => {
+    const r = validateWorkflowFileV1({
+      ...validWorkflow,
+      triggers: [
+        { kind: "cron" as const, id: "t1", expr: "0 9 * * 1-5", enabled: true },
+      ],
+    });
+    expect(r.errors).toEqual([]);
+  });
+
+  it("errors when cron trigger missing expr", () => {
+    const r = validateWorkflowFileV1({
+      ...validWorkflow,
+      triggers: [{ kind: "cron" as const, id: "t1", expr: "", enabled: true }],
+    });
+    expect(r.errors.some((e) => e.includes("missing expr"))).toBe(true);
+  });
+});

package/src/lib/workflows/api-handlers.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from "next/server";
+import { withStorageError } from "@/lib/api-route-helpers";
+
+function params(req: Request) {
+  const { searchParams } = new URL(req.url);
+  return {
+    teamId: String(searchParams.get("teamId") ?? "").trim(),
+    id: String(searchParams.get("id") ?? "").trim(),
+    workflowId: String(searchParams.get("workflowId") ?? "").trim(),
+    runId: String(searchParams.get("runId") ?? "").trim(),
+  };
+}
+
+/** GET handler for /api/teams/workflows. */
+export async function handleWorkflowsGet(
+  req: Request,
+  readOne: (teamId: string, id: string) => Promise<{ ok: boolean }>,
+  listAll: (teamId: string) => Promise<{ ok: boolean }>
+): Promise<NextResponse> {
+  const { teamId, id } = params(req);
+  if (!teamId) return NextResponse.json({ ok: false, error: "teamId is required" }, { status: 400 });
+  return withStorageError(() => (id ? readOne(teamId, id) : listAll(teamId)));
+}
+
+/** GET handler for /api/teams/workflow-runs. */
+export async function handleWorkflowRunsGet(
+  req: Request,
+  readOne: (teamId: string, workflowId: string, runId: string) => Promise<{ ok: boolean }>,
+  listAll: (teamId: string, workflowId: string) => Promise<{ ok: boolean }>
+): Promise<NextResponse> {
+  const { teamId, workflowId, runId } = params(req);
+  if (!teamId) return NextResponse.json({ ok: false, error: "teamId is required" }, { status: 400 });
+  if (!workflowId) return NextResponse.json({ ok: false, error: "workflowId is required" }, { status: 400 });
+  return withStorageError(() => (runId ? readOne(teamId, workflowId, runId) : listAll(teamId, workflowId)));
+}