@jiggai/kitchen 0.1.12 → 0.2.0

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

@@ -1,27 +1,19 @@
-import fs from "node:fs/promises";
-import path from "node:path";
 import crypto from "node:crypto";
 import { NextResponse } from "next/server";
-import YAML from "yaml";
 import { runOpenClaw } from "@/lib/openclaw";
-import { readOpenClawConfig, getWorkspaceRecipesDir } from "@/lib/paths";
-
-type ReqBody =
-  | {
-      kind: "agent";
-      recipeId: string;
-      agentId?: string;
-      name?: string;
-      applyConfig?: boolean;
-      overwrite?: boolean;
-    }
-  | {
-      kind: "team";
-      recipeId: string;
-      teamId?: string;
-      applyConfig?: boolean;
-      overwrite?: boolean;
-    };
+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;
@@ -34,20 +26,20 @@ function sha256(text: string) {
   return crypto.createHash("sha256").update(text, "utf8").digest("hex");
 }
 
-function teamDirFromTeamId(baseWorkspace: string, teamId: string) {
-  return path.resolve(baseWorkspace, "..", `workspace-${teamId}`);
+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();
+  }
 }
 
-const TEAM_META_FILE = "team.json";
-const AGENT_META_FILE = "agent.json";
-
 export async function POST(req: Request) {
-  const body = (await req.json()) as ReqBody & { cronInstallChoice?: "yes" | "no"; allowExisting?: boolean };
-
-  const args: string[] = ["recipes", body.kind === "team" ? "scaffold-team" : "scaffold", body.recipeId];
+  const body = (await req.json()) as ReqBody;
 
-  // Used for "Publish changes" detection in the UI.
-  // Best-effort only (we don't want to block scaffolding on hashing).
   let recipeHash: string | null = null;
   try {
     const shown = await runOpenClaw(["recipes", "show", body.recipeId]);
@@ -56,254 +48,37 @@ export async function POST(req: Request) {
     // ignore
   }
 
-  if (body.overwrite) args.push("--overwrite");
-  if (body.applyConfig) args.push("--apply-config");
-
-  // scaffold/scaffold-team also writes a workspace recipe file; allow re-runs against existing teams.
-  if (body.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);
-  }
-
-  // Kitchen runs scaffold non-interactively, so the recipes plugin cannot prompt.
-  // To emulate prompt semantics, we optionally override cronInstallation for this one scaffold run.
-  let prevCronInstallation: string | null = null;
-  const override = body.cronInstallChoice;
+  const args = buildScaffoldArgs(body, { allowExisting: body.allowExisting });
 
   try {
-    // Collision guards: site-wide rules.
-    // 1) Do not allow creating a team/agent with an id that collides with ANY recipe id.
-    //    (BUT allow when overwrite=true, which is used for re-scaffolding/publish flows.)
-    // 2) Do not allow creating a team/agent that already exists unless overwrite was explicitly set.
-    if (!body.overwrite && !body.allowExisting) {
-      const recipesRes = await runOpenClaw(["recipes", "list"]);
-      if (recipesRes.ok) {
-        try {
-          const recipes = JSON.parse(recipesRes.stdout) as Array<{ id?: unknown }>;
-          const recipeIds = new Set(recipes.map((r) => String(r.id ?? "").trim()).filter(Boolean));
-
-          if (body.kind === "agent") {
-            const agentId = String(body.agentId ?? "").trim();
-            if (agentId && 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 },
-              );
-            }
-          }
-
-          if (body.kind === "team") {
-            const teamId = String(body.teamId ?? "").trim();
-            if (teamId && 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 },
-              );
-            }
-          }
-        } catch {
-          // ignore parse errors
-        }
-      }
-    }
-
     if (!body.overwrite && !body.allowExisting) {
+      const recipeIds = await getRecipeIds();
       if (body.kind === "agent") {
         const agentId = String(body.agentId ?? "").trim();
-        if (agentId) {
-          const agentsRes = await runOpenClaw(["agents", "list", "--json"]);
-          if (agentsRes.ok) {
-            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; fall through to scaffold
-            }
-          }
-        }
-      }
-
-      if (body.kind === "team") {
+        const err = await validateAgentId(agentId, recipeIds);
+        if (err) return err;
+      } else {
         const teamId = String(body.teamId ?? "").trim();
-        if (teamId) {
-          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 and fall through
-          }
-
-          // Also check if team agents already exist in config.
-          const agentsRes = await runOpenClaw(["agents", "list", "--json"]);
-          if (agentsRes.ok) {
-            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 parse errors
-            }
-          }
-        }
+        const err = await validateTeamId(teamId, recipeIds);
+        if (err) return err;
       }
     }
 
-    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]);
-    }
-
-    const { stdout, stderr } = await runOpenClaw(args);
-
-    // Persist provenance so editors can show what recipe created what.
-    if (body.kind === "team") {
-      const teamId = String(body.teamId ?? "").trim();
-      if (teamId) {
-        try {
-          const cfg = await readOpenClawConfig();
-          const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
-          if (baseWorkspace) {
-            const teamDir = teamDirFromTeamId(baseWorkspace, teamId);
-
-            // Best-effort recipe name snapshot.
-            let recipeName: string | undefined;
-            try {
-              const list = await runOpenClaw(["recipes", "list"]);
-              if (list.ok) {
-                const items = JSON.parse(list.stdout) as Array<{ id?: string; name?: string }>;
-                const hit = items.find((r) => String(r.id ?? "").trim() === body.recipeId);
-                const n = String(hit?.name ?? "").trim();
-                if (n) recipeName = n;
-              }
-            } catch {
-              // ignore
-            }
+    return await withCronOverride(body.cronInstallChoice, async () => {
+      const { stdout, stderr } = await runOpenClaw(args);
 
-            const now = new Date().toISOString();
-            const meta = {
-              teamId,
-              recipeId: body.recipeId,
-              ...(recipeName ? { recipeName } : {}),
-              ...(recipeHash ? { recipeHash } : {}),
-              scaffoldedAt: now,
-              attachedAt: now,
-            };
-
-            await fs.mkdir(teamDir, { recursive: true });
-            await fs.writeFile(path.join(teamDir, TEAM_META_FILE), JSON.stringify(meta, null, 2) + "\n", "utf8");
-          }
-
-          // Best-effort: ensure the generated workspace recipe's `team.teamId` matches the new team id.
-          // Some template recipes carry a `team.teamId` that should not leak into cloned/scaffolded copies.
-          try {
-            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
-          }
-        } catch {
-          // best-effort only; scaffold should still succeed
-        }
+      if (body.kind === "team") {
+        const teamId = String(body.teamId ?? "").trim();
+        if (teamId) await persistTeamProvenance(teamId, body.recipeId, recipeHash);
       }
-    }
 
-    // Persist agent provenance so we can block recipe deletion while in use.
-    if (body.kind === "agent") {
-      const agentId = String(body.agentId ?? "").trim();
-      if (agentId) {
-        try {
-          const cfg = await readOpenClawConfig();
-          const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
-          if (baseWorkspace) {
-            const agentDir = path.resolve(baseWorkspace, "agents", agentId);
-
-            // Best-effort recipe name snapshot.
-            let recipeName: string | undefined;
-            try {
-              const list = await runOpenClaw(["recipes", "list"]);
-              if (list.ok) {
-                const items = JSON.parse(list.stdout) as Array<{ id?: string; name?: string }>;
-                const hit = items.find((r) => String(r.id ?? "").trim() === body.recipeId);
-                const n = String(hit?.name ?? "").trim();
-                if (n) recipeName = n;
-              }
-            } catch {
-              // ignore
-            }
-
-            const now = new Date().toISOString();
-            const meta = {
-              agentId,
-              recipeId: body.recipeId,
-              ...(recipeName ? { recipeName } : {}),
-              ...(recipeHash ? { recipeHash } : {}),
-              scaffoldedAt: now,
-              attachedAt: now,
-            };
-
-            await fs.mkdir(agentDir, { recursive: true });
-            await fs.writeFile(path.join(agentDir, AGENT_META_FILE), JSON.stringify(meta, null, 2) + "\n", "utf8");
-          }
-        } catch {
-          // best-effort only
-        }
+      if (body.kind === "agent") {
+        const agentId = String(body.agentId ?? "").trim();
+        if (agentId) await persistAgentProvenance(agentId, body.recipeId, recipeHash);
       }
-    }
-
-    // Note: do NOT restart the gateway here. Some flows (like Add agent) will
-    // poll for updated state and only restart if necessary to avoid global slowness.
 
-    return NextResponse.json({ ok: true, args, stdout, stderr });
+      return NextResponse.json({ ok: true, args, stdout, stderr });
+    });
   } catch (e: unknown) {
     const err = e as { message?: string; stdout?: unknown; stderr?: unknown };
     return NextResponse.json(
@@ -316,14 +91,5 @@ export async function POST(req: Request) {
       },
       { status: 500 }
     );
-  } finally {
-    if (prevCronInstallation !== null) {
-      try {
-        await runOpenClaw(["config", "set", "plugins.entries.recipes.config.cronInstallation", prevCronInstallation]);
-      } catch {
-        // best-effort restore
-      }
-    }
   }
 }
-

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

@@ -1,4 +1,5 @@
 import { NextResponse } from "next/server";
+import { errorMessage } from "@/lib/errors";
 import { gatewayConfigGet, gatewayConfigPatch } from "@/lib/gateway";
 
 const CFG_PATH = "plugins.entries.recipes.config.cronInstallation";
@@ -18,7 +19,7 @@ export async function GET() {
     return NextResponse.json({ ok: true, path: CFG_PATH, value });
   } catch (e: unknown) {
     return NextResponse.json(
-      { ok: false, error: e instanceof Error ? e.message : String(e) },
+      { ok: false, error: errorMessage(e) },
       { status: 500 },
     );
   }
@@ -50,7 +51,7 @@ export async function PUT(req: Request) {
     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: e instanceof Error ? e.message : String(e) },
+      { ok: false, error: errorMessage(e) },
       { status: 500 },
     );
   }

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

@@ -2,6 +2,7 @@ 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();
@@ -17,6 +18,6 @@ export async function GET() {
     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: e instanceof Error ? e.message : String(e) });
+    return NextResponse.json({ ok: true, skillsDir: globalSkillsDir, skills: [], note: errorMessage(e) });
   }
 }

package/src/app/api/swarms/start/route.ts

@@ -0,0 +1,100 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { NextResponse } from "next/server";
+
+import { errorMessage } from "@/lib/errors";
+import { getKitchenApi } from "@/lib/kitchen-api";
+import { normalizeId, resolveAgentWorkspace } from "@/lib/swarms";
+
+export async function POST(req: Request) {
+  try {
+    const body = (await req.json()) as {
+      orchestratorAgentId?: string;
+      agentId?: string; // compat
+      taskId?: string;
+      spec?: string;
+      specFile?: string;
+      baseRef?: string;
+      branch?: string;
+      tmuxSession?: string;
+      agent?: "codex" | "claude";
+      model?: string;
+      reasoning?: "low" | "medium" | "high";
+      timeoutMs?: number;
+    };
+
+    const orchestratorAgentId = normalizeId("orchestratorAgentId", String(body.orchestratorAgentId ?? body.agentId ?? ""));
+    const taskId = normalizeId("taskId", String(body.taskId ?? ""));
+
+    const spec = typeof body.spec === "string" ? body.spec : "";
+    const specFile = typeof body.specFile === "string" ? body.specFile : "";
+    if (!!spec === !!specFile) {
+      throw new Error("Provide exactly one of spec or specFile");
+    }
+
+    const orchestratorWs = await resolveAgentWorkspace(orchestratorAgentId);
+    const cliPath = path.join(orchestratorWs, ".clawdbot", "task.sh");
+
+    // Prefer spec-file to avoid shell quoting surprises.
+    let effectiveSpecFile = specFile;
+    let tmpToCleanup: string | null = null;
+
+    if (spec) {
+      const tmp = path.join(os.tmpdir(), `clawkitchen-swarm-${taskId}-${Date.now()}.md`);
+      await fs.writeFile(tmp, spec, "utf8");
+      effectiveSpecFile = tmp;
+      tmpToCleanup = tmp;
+    }
+
+    // Basic existence checks for actionable errors.
+    await fs.access(cliPath);
+
+    const timeoutMs = Number.isFinite(body.timeoutMs) ? Number(body.timeoutMs) : 120000;
+
+    const args: string[] = [
+      "bash",
+      cliPath,
+      "start",
+      "--task-id",
+      taskId,
+      "--spec-file",
+      effectiveSpecFile,
+    ];
+
+    if (typeof body.baseRef === "string" && body.baseRef.trim()) {
+      args.push("--base-ref", body.baseRef.trim());
+    }
+    if (typeof body.branch === "string" && body.branch.trim()) {
+      args.push("--branch", body.branch.trim());
+    }
+    if (typeof body.tmuxSession === "string" && body.tmuxSession.trim()) {
+      args.push("--tmux-session", body.tmuxSession.trim());
+    }
+    if (typeof body.agent === "string" && body.agent.trim()) {
+      args.push("--agent", body.agent.trim());
+    }
+    if (typeof body.model === "string" && body.model.trim()) {
+      args.push("--model", body.model.trim());
+    }
+    if (typeof body.reasoning === "string" && body.reasoning.trim()) {
+      args.push("--reasoning", body.reasoning.trim());
+    }
+
+    const api = getKitchenApi();
+    const res = await api.runtime.system.runCommandWithTimeout(args, { timeoutMs });
+
+    // best-effort tmp cleanup (fire-and-forget)
+    if (tmpToCleanup) {
+      fs.unlink(tmpToCleanup).catch(() => {});
+    }
+
+    return NextResponse.json({ ok: true, orchestratorWorkspace: orchestratorWs, stdout: res.stdout, stderr: res.stderr });
+  } catch (err: unknown) {
+    const msg = errorMessage(err);
+    const isClientError = /required|match \//i.test(msg) || msg.includes("Provide exactly one");
+    const status = isClientError ? 400 : 500;
+    return NextResponse.json({ ok: false, error: msg }, { status });
+  }
+}

package/src/app/api/swarms/status/route.ts

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { NextResponse } from "next/server";
+
+import { errorMessage } from "@/lib/errors";
+import { getKitchenApi } from "@/lib/kitchen-api";
+import { normalizeId, resolveAgentWorkspace } from "@/lib/swarms";
+
+export async function GET(req: Request) {
+  try {
+    const url = new URL(req.url);
+    const orchestratorAgentId = normalizeId(
+      "orchestratorAgentId",
+      url.searchParams.get("orchestratorAgentId") || url.searchParams.get("agentId") || "",
+    );
+
+    const orchestratorWs = await resolveAgentWorkspace(orchestratorAgentId);
+    const cliPath = path.join(orchestratorWs, ".clawdbot", "task.sh");
+    await fs.access(cliPath);
+
+    const api = getKitchenApi();
+    const res = await api.runtime.system.runCommandWithTimeout(["bash", cliPath, "status"], { timeoutMs: 30000 });
+
+    return NextResponse.json({ ok: true, orchestratorWorkspace: orchestratorWs, stdout: res.stdout, stderr: res.stderr });
+  } catch (err: unknown) {
+    const msg = errorMessage(err);
+    const status = /required|match \//i.test(msg) ? 400 : 500;
+    return NextResponse.json({ ok: false, error: msg }, { status });
+  }
+}

package/src/app/api/teams/[teamId]/tickets/assign/route.ts

@@ -0,0 +1,105 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getTicketByIdOrNumber, listTickets, stageDir, type TicketStage } from "@/lib/tickets";
+import { getWorkspaceDir, teamDirFromBaseWorkspace } from "@/lib/paths";
+
+export const dynamic = "force-dynamic";
+
+type TicketFlowConfig = {
+  laneByOwner?: Record<string, TicketStage>;
+  defaultLane?: TicketStage;
+};
+
+async function loadTicketFlowConfig(teamDir: string): Promise<TicketFlowConfig | null> {
+  const p = path.join(teamDir, "shared-context", "ticket-flow.json");
+  try {
+    const raw = await fs.readFile(p, "utf8");
+    const parsed = JSON.parse(raw) as TicketFlowConfig;
+    // Best-effort validation.
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+async function desiredStageForAssignee(opts: {
+  teamDir: string;
+  assignee: string | null;
+  currentStage: TicketStage;
+}): Promise<TicketStage> {
+  const config = await loadTicketFlowConfig(opts.teamDir);
+  if (!config) return opts.currentStage;
+
+  const key = (opts.assignee ?? "").trim();
+  if (key && config.laneByOwner && typeof config.laneByOwner[key] === "string") {
+    return config.laneByOwner[key] as TicketStage;
+  }
+
+  if (config.defaultLane) return config.defaultLane;
+  return opts.currentStage;
+}
+
+function upsertField(md: string, field: string, value: string) {
+  const re = new RegExp(`^${field}:\\s*.*$`, "mi");
+  if (re.test(md)) return md.replace(re, `${field}: ${value}`);
+
+  // Insert after the first header line, or at top if no header.
+  const lines = md.split("\n");
+  const headerIdx = lines.findIndex((l) => l.startsWith("# "));
+  const insertAt = headerIdx >= 0 ? headerIdx + 1 : 0;
+  lines.splice(insertAt, 0, `${field}: ${value}`);
+  return lines.join("\n");
+}
+
+async function ensureDir(p: string) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ teamId: string }> },
+) {
+  const { teamId } = await params;
+
+  const body = (await req.json().catch(() => null)) as null | {
+    ticket: string;
+    assignee: string;
+  };
+
+  if (!body?.ticket || !body?.assignee) {
+    return NextResponse.json({ error: "Missing ticket or assignee" }, { status: 400 });
+  }
+
+  const baseWorkspace = await getWorkspaceDir();
+  const teamDir = teamDirFromBaseWorkspace(baseWorkspace, teamId);
+
+  const ticket = await getTicketByIdOrNumber(body.ticket, teamDir);
+  if (!ticket) {
+    return NextResponse.json({ error: "Ticket not found" }, { status: 404 });
+  }
+
+  const assignee = body.assignee.trim();
+  const nextStage = await desiredStageForAssignee({ teamDir, assignee, currentStage: ticket.stage });
+
+  const currentMd = await fs.readFile(ticket.file, "utf8");
+  let updatedMd = upsertField(currentMd, "Owner", assignee);
+  updatedMd = upsertField(updatedMd, "Status", nextStage);
+
+  const filename = path.basename(ticket.file);
+  const nextPath = path.join(stageDir(nextStage, teamDir), filename);
+
+  await ensureDir(stageDir(nextStage, teamDir));
+
+  if (ticket.file !== nextPath) {
+    await fs.rename(ticket.file, nextPath);
+  }
+
+  await fs.writeFile(nextPath, updatedMd, "utf8");
+
+  // Assignment stubs are deprecated; do not create/update work/assignments/*.md.
+
+  const refreshed = (await listTickets(teamDir)).find((t) => t.number === ticket.number);
+  return NextResponse.json({ ok: true, ticket: refreshed ?? null });
+}

package/src/app/api/teams/[teamId]/tickets/assignees/route.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getWorkspaceDir, teamDirFromBaseWorkspace } from "@/lib/paths";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ teamId: string }> },
+) {
+  const { teamId } = await params;
+
+  const baseWorkspace = await getWorkspaceDir();
+  const teamDir = teamDirFromBaseWorkspace(baseWorkspace, teamId);
+  const rolesDir = path.join(teamDir, "roles");
+
+  let entries: string[] = [];
+  try {
+    entries = await fs.readdir(rolesDir);
+  } catch {
+    entries = [];
+  }
+
+  const assignees = entries.filter((e) => !e.startsWith(".")).sort();
+  return NextResponse.json({ assignees });
+}