@jiggai/kitchen 0.1.11 → 0.2.0

package/src/app/teams/[teamId]/team-editor/team-editor-data.ts

@@ -0,0 +1,255 @@
+import { errorMessage } from "@/lib/errors";
+import { fetchAll, fetchJson } from "@/lib/fetch-json";
+import type { RecipeListItem, TeamAgentEntry, TeamTabSetters } from "./types";
+import { safeParseJson } from "./team-editor-utils";
+
+async function fetchRecipesAndMeta(teamId: string) {
+  const [recipesData, metaRes] = await Promise.all([
+    fetchJson<{ recipes?: RecipeListItem[] }>("/api/recipes", { cache: "no-store" }),
+    fetch(`/api/teams/meta?teamId=${encodeURIComponent(teamId)}`, { cache: "no-store" }),
+  ]);
+  return { recipesData, metaRes };
+}
+
+const TEAM_TAB_URLS = (teamId: string) => [
+  `/api/teams/files?teamId=${encodeURIComponent(teamId)}`,
+  `/api/cron/jobs?teamId=${encodeURIComponent(teamId)}`,
+  "/api/agents",
+  `/api/teams/skills?teamId=${encodeURIComponent(teamId)}`,
+  "/api/skills/available",
+];
+
+async function fetchTeamTabResponses(teamId: string) {
+  const responses = await fetchAll(TEAM_TAB_URLS(teamId));
+  const texts = await Promise.all(responses.map((r) => r.text()));
+  return { responses, texts };
+}
+
+export async function loadTeamTabData(teamId: string, setters: TeamTabSetters): Promise<void> {
+  setters.setTeamFilesLoading(true);
+  setters.setCronLoading(true);
+  setters.setTeamAgentsLoading(true);
+  setters.setSkillsLoading(true);
+  try {
+    const { responses, texts } = await fetchTeamTabResponses(teamId);
+    const [filesRes, cronRes, agentsRes, skillsRes, availableSkillsRes] = responses;
+    const [filesText, cronText, agentsText, skillsText, availableText] = texts;
+
+    const filesJson = safeParseJson<{ ok?: boolean; files?: unknown[] }>(filesText, {});
+    if (filesRes.ok && filesJson.ok && Array.isArray(filesJson.files)) {
+      setters.setTeamFiles(
+        filesJson.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,
+          };
+        }),
+      );
+    }
+
+    const cronJson = safeParseJson<{ ok?: boolean; jobs?: unknown[] }>(cronText, {});
+    if (cronRes.ok && cronJson.ok && Array.isArray(cronJson.jobs)) setters.setCronJobs(cronJson.jobs);
+
+    const agentsJson = safeParseJson<{ agents?: unknown[] }>(agentsText, {});
+    if (agentsRes.ok && Array.isArray(agentsJson.agents)) {
+      const filtered = agentsJson.agents.filter((a) => String((a as { id?: unknown }).id ?? "").startsWith(`${teamId}-`));
+      setters.setTeamAgents(
+        filtered.map((a) => {
+          const agent = a as { id?: unknown; identityName?: unknown };
+          return { id: String(agent.id ?? ""), identityName: typeof agent.identityName === "string" ? agent.identityName : undefined };
+        }),
+      );
+    }
+
+    const skillsJson = safeParseJson<{ ok?: boolean; skills?: unknown[] }>(skillsText, {});
+    if (skillsRes.ok && skillsJson.ok && Array.isArray(skillsJson.skills)) setters.setSkillsList(skillsJson.skills as string[]);
+
+    const availableJson = safeParseJson<{ ok?: boolean; skills?: unknown[] }>(availableText, {});
+    if (availableSkillsRes.ok && availableJson.ok && Array.isArray(availableJson.skills)) {
+      const list = availableJson.skills as string[];
+      setters.setAvailableSkills(list);
+      setters.setSelectedSkill((prev) => {
+        const p = String(prev ?? "").trim();
+        if (p && list.includes(p)) return p;
+        return list[0] ?? "";
+      });
+    }
+  } finally {
+    setters.setTeamFilesLoading(false);
+    setters.setCronLoading(false);
+    setters.setTeamAgentsLoading(false);
+    setters.setSkillsLoading(false);
+  }
+}
+
+export type LoadTeamEditorInitialSetters = TeamTabSetters & {
+  setRecipes: (r: RecipeListItem[]) => void;
+  setLockedFromId: (v: string | null) => void;
+  setLockedFromName: (v: string | null) => void;
+  setProvenanceMissing: (v: boolean) => void;
+  setFromId: (v: string) => void;
+  setTeamMetaRecipeHash: (v: string | null) => void;
+};
+
+export async function loadTeamEditorInitial(teamId: string, setters: LoadTeamEditorInitialSetters): Promise<void> {
+  const initialData = await fetchRecipesAndMeta(teamId);
+  setters.setRecipes((initialData.recipesData.recipes ?? []) as RecipeListItem[]);
+
+  let locked: { recipeId: string; recipeName?: string } | null = null;
+  try {
+    const metaJson = await initialData.metaRes.json();
+    const meta = metaJson.meta as { recipeId?: unknown; recipeName?: unknown; recipeHash?: unknown } | undefined;
+    if (initialData.metaRes.ok && metaJson.ok && meta?.recipeId) {
+      locked = {
+        recipeId: String(meta.recipeId),
+        recipeName: typeof meta.recipeName === "string" ? meta.recipeName : undefined,
+      };
+      setters.setTeamMetaRecipeHash(typeof meta.recipeHash === "string" ? meta.recipeHash : null);
+    } else {
+      setters.setTeamMetaRecipeHash(null);
+    }
+  } catch {
+    setters.setTeamMetaRecipeHash(null);
+  }
+
+  if (locked) {
+    setters.setLockedFromId(locked.recipeId);
+    setters.setLockedFromName(locked.recipeName ?? null);
+    setters.setProvenanceMissing(false);
+    setters.setFromId(locked.recipeId);
+  } else {
+    setters.setLockedFromId(null);
+    setters.setLockedFromName(null);
+    setters.setProvenanceMissing(true);
+    const list = (initialData.recipesData.recipes ?? []) as RecipeListItem[];
+    const preferred = list.find((r) => r.kind === "team" && r.id === teamId);
+    const fallback = list.find((r) => r.kind === "team");
+    const pick = preferred ?? fallback;
+    if (pick) setters.setFromId(pick.id);
+  }
+
+  await loadTeamTabData(teamId, {
+    setTeamFiles: setters.setTeamFiles,
+    setCronJobs: setters.setCronJobs,
+    setTeamAgents: setters.setTeamAgents,
+    setSkillsList: setters.setSkillsList,
+    setAvailableSkills: setters.setAvailableSkills,
+    setSelectedSkill: setters.setSelectedSkill,
+    setTeamFilesLoading: setters.setTeamFilesLoading,
+    setCronLoading: setters.setCronLoading,
+    setTeamAgentsLoading: setters.setTeamAgentsLoading,
+    setSkillsLoading: setters.setSkillsLoading,
+  });
+}
+
+export async function fetchTeamAgentsOnce(teamId: string): Promise<{ ok: boolean; agents: TeamAgentEntry[] }> {
+  try {
+    const agentsJson = await fetchJson<{ agents?: unknown[] }>("/api/agents", { cache: "no-store" });
+    const all = Array.isArray(agentsJson.agents) ? agentsJson.agents : [];
+    const filtered = all.filter((a) => String((a as { id?: unknown }).id ?? "").startsWith(`${teamId}-`));
+    const mapped = filtered.map((a) => {
+      const agent = a as { id?: unknown; identityName?: unknown };
+      return { id: String(agent.id ?? ""), identityName: typeof agent.identityName === "string" ? agent.identityName : undefined };
+    });
+    return { ok: true, agents: mapped };
+  } catch {
+    return { ok: false, agents: [] };
+  }
+}
+
+async function applyScaffoldAfterTeamAgentsChange(
+  teamId: string,
+  toId: string,
+  flashMessage: (msg: string, kind: "success" | "error") => void
+): Promise<void> {
+  try {
+    await fetchJson("/api/scaffold", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        kind: "team",
+        recipeId: toId.trim(),
+        teamId,
+        applyConfig: true,
+        overwrite: false,
+        allowExisting: true,
+        cronInstallChoice: "no",
+      }),
+    });
+  } catch (e: unknown) {
+    flashMessage(errorMessage(e), "error");
+  }
+}
+
+async function pollTeamAgentsUntil(
+  teamId: string,
+  expectedAgentId: string,
+  setTeamAgents: (a: TeamAgentEntry[]) => void,
+  maxMs: number
+): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < maxMs) {
+    try {
+      const r = await fetchTeamAgentsOnce(teamId);
+      if (r.ok) {
+        setTeamAgents(r.agents);
+        const hasExpected = expectedAgentId ? r.agents.some((a) => a.id === expectedAgentId) : false;
+        if (!expectedAgentId || hasExpected) return true;
+      }
+    } catch {
+      // ignore
+    }
+    await new Promise((res) => setTimeout(res, 500));
+  }
+  return false;
+}
+
+export async function handleAddAgentToTeam(opts: {
+  teamId: string;
+  toId: string;
+  newRole: string;
+  derivedRole: string;
+  newRoleName: string;
+  content: string;
+  setContent: (c: string) => void;
+  setTeamAgents: (a: TeamAgentEntry[]) => void;
+  flashMessage: (msg: string, kind: "success" | "error") => void;
+  ensureCustomRecipeExists: (args: { overwrite: boolean }) => Promise<unknown>;
+}): Promise<void> {
+  const { teamId, toId, newRole, derivedRole, newRoleName, content, setContent, setTeamAgents, flashMessage, ensureCustomRecipeExists } =
+    opts;
+  try {
+    await ensureCustomRecipeExists({ overwrite: false });
+  } catch (e: unknown) {
+    const msg = errorMessage(e);
+    if (!/Recipe id already exists:/i.test(msg)) throw e;
+  }
+  const json = await fetchJson<{ ok?: boolean; content?: string; addedAgentId?: string }>("/api/recipes/team-agents", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(
+      newRole === "__custom__"
+        ? { recipeId: toId.trim(), op: "add", role: derivedRole, name: newRoleName }
+        : { recipeId: toId.trim(), op: "addLike", baseRole: derivedRole, teamId, name: newRoleName },
+    ),
+  });
+  if (!json.ok) throw new Error("Failed updating agents list");
+  setContent(String(json.content ?? content));
+
+  await applyScaffoldAfterTeamAgentsChange(teamId, toId, flashMessage);
+
+  const expectedAgentId = typeof json.addedAgentId === "string" ? json.addedAgentId : "";
+  const appeared = await pollTeamAgentsUntil(teamId, expectedAgentId, setTeamAgents, 5000);
+  if (!appeared && expectedAgentId) {
+    try {
+      void fetch("/api/gateway/restart", { method: "POST" });
+    } catch {
+      // ignore
+    }
+    await pollTeamAgentsUntil(teamId, expectedAgentId, setTeamAgents, 10000);
+  }
+  flashMessage(`Updated agents list in ${toId}`, "success");
+}

package/src/app/teams/[teamId]/team-editor/team-editor-utils.ts

@@ -0,0 +1,78 @@
+export function safeParseJson<T>(text: string, def: T): T {
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return def;
+  }
+}
+
+function replaceOrAddIdInLines(lines: string[], id: string): string[] {
+  let found = false;
+  const next = lines.map((line) => {
+    if (/^id\s*:/i.test(line)) {
+      found = true;
+      return `id: ${id}`;
+    }
+    return line;
+  });
+  if (!found) next.unshift(`id: ${id}`);
+  return next;
+}
+
+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 nextLines = replaceOrAddIdInLines(fm.split("\n"), id);
+  return `---\n${nextLines.join("\n")}\n---\n${body}`;
+}
+
+function patchTeamIdInLines(
+  lines: string[],
+  teamId: string
+): { next: string[]; sawTeamBlock: boolean; patched: boolean } {
+  const next: string[] = [];
+  let inTeam = false;
+  let sawTeamBlock = false;
+  let patched = false;
+
+  for (const line of lines) {
+    if (/^team\s*:\s*$/i.test(line)) {
+      inTeam = true;
+      sawTeamBlock = true;
+      next.push(line);
+      continue;
+    }
+    if (inTeam && /^\S/.test(line)) inTeam = false;
+    if (inTeam && /^\s+teamId\s*:/i.test(line)) {
+      next.push(`  teamId: ${teamId}`);
+      patched = true;
+      continue;
+    }
+    next.push(line);
+  }
+  return { next, sawTeamBlock, patched };
+}
+
+export function forceFrontmatterTeamTeamId(md: string, teamId: 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");
+  const { next, sawTeamBlock, patched } = patchTeamIdInLines(lines, teamId);
+
+  if (sawTeamBlock && !patched) {
+    const out: string[] = [];
+    for (const line of next) {
+      out.push(line);
+      if (/^team\s*:\s*$/i.test(line)) out.push(`  teamId: ${teamId}`);
+    }
+    return `---\n${out.join("\n")}\n---\n${body}`;
+  }
+  return `---\n${next.join("\n")}\n---\n${body}`;
+}

package/src/app/teams/[teamId]/team-editor/types.ts

@@ -0,0 +1,34 @@
+export type RecipeListItem = {
+  id: string;
+  name: string;
+  kind: "agent" | "team";
+  source: "builtin" | "workspace";
+};
+
+export type RecipeDetail = RecipeListItem & {
+  content: string;
+  filePath: string | null;
+};
+
+export type TeamFileEntry = {
+  name: string;
+  missing: boolean;
+  required?: boolean;
+  rationale?: string;
+};
+
+export type TeamAgentEntry = { id: string; identityName?: string };
+
+/** Setters used by loadTeamTabData and passed through from loadTeamEditorInitial. */
+export type TeamTabSetters = {
+  setTeamFiles: (f: TeamFileEntry[]) => void;
+  setCronJobs: (j: unknown[]) => void;
+  setTeamAgents: (a: TeamAgentEntry[]) => void;
+  setSkillsList: (s: string[]) => void;
+  setAvailableSkills: (s: string[]) => void;
+  setSelectedSkill: (fn: (prev: string) => string) => void;
+  setTeamFilesLoading: (v: boolean) => void;
+  setCronLoading: (v: boolean) => void;
+  setTeamAgentsLoading: (v: boolean) => void;
+  setSkillsLoading: (v: boolean) => void;
+};

package/src/app/teams/[teamId]/tickets/[ticket]/page.tsx

@@ -0,0 +1,35 @@
+import { TicketDetailClient } from "@/app/tickets/TicketDetailClient";
+import { getTicketMarkdown } from "@/lib/tickets";
+
+export const dynamic = "force-dynamic";
+
+export default async function TeamTicketDetailPage({
+  params,
+}: {
+  params: Promise<{ teamId: string; ticket: string }>;
+}) {
+  const { teamId, ticket } = await params;
+  const data = await getTicketMarkdown(teamId, ticket);
+
+  if (!data) {
+    return (
+      <div className="ck-glass p-6">
+        <h1 className="text-xl font-semibold tracking-tight">Ticket not found</h1>
+        <p className="mt-3 text-sm text-[color:var(--ck-text-secondary)]">
+          Couldn’t locate “{ticket}” in backlog/in-progress/testing/done for team “{teamId}”.
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <TicketDetailClient
+      teamId={teamId}
+      ticketId={data.id}
+      file={data.file}
+      markdown={data.markdown}
+      backHref={`/teams/${encodeURIComponent(teamId)}/tickets`}
+      currentOwner={data.owner}
+    />
+  );
+}

package/src/app/teams/[teamId]/tickets/page.tsx

@@ -0,0 +1,15 @@
+import { TicketsBoardClient } from "@/app/tickets/TicketsBoardClient";
+import { listTickets } from "@/lib/tickets";
+
+export const dynamic = "force-dynamic";
+
+export default async function TeamTicketsPage({
+  params,
+}: {
+  params: Promise<{ teamId: string }>;
+}) {
+  const { teamId } = await params;
+  const tickets = await listTickets(teamId);
+
+  return <TicketsBoardClient tickets={tickets} basePath={`/teams/${encodeURIComponent(teamId)}/tickets`} />;
+}

package/src/app/teams/[teamId]/workflows/[workflowId]/WorkflowCanvas.tsx

@@ -0,0 +1,111 @@
+"use client";
+
+import { useRef, useState } from "react";
+import type { WorkflowFileV1 } from "@/lib/workflows/types";
+
+export function WorkflowCanvas({
+  wf,
+  selectedNodeId,
+  onSelectNode,
+  onWorkflowChange,
+}: {
+  wf: WorkflowFileV1 | null;
+  selectedNodeId: string;
+  onSelectNode: (id: string) => void;
+  onWorkflowChange: (next: WorkflowFileV1) => void;
+}) {
+  const canvasRef = useRef<HTMLDivElement | null>(null);
+  const [dragging, setDragging] = useState<null | {
+    nodeId: string;
+    dx: number;
+    dy: number;
+    left: number;
+    top: number;
+  }>(null);
+
+  const nodes = wf?.nodes ?? [];
+  const edges = wf?.edges ?? [];
+
+  return (
+    <div
+      ref={canvasRef}
+      className="relative h-full min-h-0 w-full flex-1 overflow-auto rounded-[var(--ck-radius-sm)] border border-white/10 bg-black/20"
+    >
+      <div className="relative h-[1200px] w-[2200px]">
+        <svg className="absolute inset-0" width={2200} height={1200}>
+          {edges.map((e) => {
+            const a = nodes.find((n) => n.id === e.from);
+            const b = nodes.find((n) => n.id === e.to);
+            if (!a || !b || !wf) return null;
+            const ax = (typeof a.x === "number" ? a.x : 80) + 90;
+            const ay = (typeof a.y === "number" ? a.y : 80) + 24;
+            const bx = (typeof b.x === "number" ? b.x : 80) + 90;
+            const by = (typeof b.y === "number" ? b.y : 80) + 24;
+            return (
+              <line
+                key={e.id}
+                x1={ax}
+                y1={ay}
+                x2={bx}
+                y2={by}
+                stroke="rgba(255,255,255,0.18)"
+                strokeWidth={2}
+              />
+            );
+          })}
+        </svg>
+
+        {nodes.map((n, idx) => {
+          const x = typeof n.x === "number" ? n.x : 80 + idx * 220;
+          const y = typeof n.y === "number" ? n.y : 80;
+          const selected = selectedNodeId === n.id;
+          return (
+            <div
+              key={n.id}
+              role="button"
+              tabIndex={0}
+              onClick={() => onSelectNode(n.id)}
+              onPointerDown={(e) => {
+                if (e.button !== 0) return;
+                const el = canvasRef.current;
+                if (!el) return;
+                const rect = el.getBoundingClientRect();
+                onSelectNode(n.id);
+                setDragging({
+                  nodeId: n.id,
+                  dx: e.clientX - rect.left - x,
+                  dy: e.clientY - rect.top - y,
+                  left: rect.left,
+                  top: rect.top,
+                });
+              }}
+              onPointerUp={() => setDragging(null)}
+              onPointerMove={(e) => {
+                if (!dragging || dragging.nodeId !== n.id || !wf) return;
+                const el = canvasRef.current;
+                if (!el) return;
+                const nextX = e.clientX - dragging.left - dragging.dx;
+                const nextY = e.clientY - dragging.top - dragging.dy;
+                const nextNodes = wf.nodes.map((node) =>
+                  node.id === n.id ? { ...node, x: nextX, y: nextY } : node
+                );
+                onWorkflowChange({ ...wf, nodes: nextNodes });
+              }}
+              className={
+                selected
+                  ? "absolute cursor-grab rounded-[var(--ck-radius-sm)] border border-white/25 bg-white/10 px-3 py-2 text-xs text-[color:var(--ck-text-primary)] shadow-[var(--ck-shadow-1)]"
+                  : "absolute cursor-grab rounded-[var(--ck-radius-sm)] border border-white/10 bg-white/5 px-3 py-2 text-xs text-[color:var(--ck-text-secondary)] hover:bg-white/10"
+              }
+              style={{ left: x, top: y, width: 180 }}
+            >
+              <div className="font-medium text-[color:var(--ck-text-primary)]">{n.name || n.id}</div>
+              <div className="mt-0.5 text-[10px] uppercase tracking-wide text-[color:var(--ck-text-tertiary)]">
+                {n.type}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

package/src/app/teams/[teamId]/workflows/[workflowId]/page.tsx

@@ -0,0 +1,27 @@
+import { unstable_noStore as noStore } from "next/cache";
+import WorkflowsEditorClient from "./workflows-editor-client";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
+export default async function WorkflowEditorPage({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ teamId: string; workflowId: string }>;
+  searchParams?: Promise<Record<string, string | string[] | undefined>>;
+}) {
+  noStore();
+
+  const { teamId, workflowId } = await params;
+  const sp = (await searchParams) ?? {};
+  const draftRaw = sp.draft;
+  const draft = Array.isArray(draftRaw) ? draftRaw[0] : draftRaw;
+
+  // Full-bleed workflows editor (no extra top row / padding / border).
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <WorkflowsEditorClient teamId={teamId} workflowId={workflowId} draft={draft === "1"} />
+    </div>
+  );
+}