@jiggai/kitchen 0.3.1 → 0.3.3

package/src/app/api/channels/bindings/route.ts

@@ -1,63 +0,0 @@
-import { NextResponse } from "next/server";
-import { errorMessage } from "@/lib/errors";
-import { gatewayConfigGet, gatewayConfigPatch } from "@/lib/gateway";
-import { safeJsonParse } from "@/lib/json";
-import { isRecord } from "@/lib/type-guards";
-
-export async function GET() {
-  try {
-    const { raw, hash } = await gatewayConfigGet();
-    const parsed = safeJsonParse(raw);
-    const root = isRecord(parsed) ? parsed : {};
-    const channels = isRecord(root.channels) ? root.channels : {};
-    return NextResponse.json({ ok: true, hash, channels });
-  } catch (e: unknown) {
-    const msg = errorMessage(e);
-    return NextResponse.json({ ok: false, error: msg }, { status: 500 });
-  }
-}
-
-type UpsertBody = {
-  provider: string;
-  config: Record<string, unknown>;
-};
-
-export async function PUT(req: Request) {
-  try {
-    const body = (await req.json()) as UpsertBody;
-    const provider = String(body?.provider ?? "").trim();
-    if (!provider) return NextResponse.json({ ok: false, error: "provider is required" }, { status: 400 });
-
-    const cfg = isRecord(body?.config) ? body.config : null;
-    if (!cfg) return NextResponse.json({ ok: false, error: "config must be an object" }, { status: 400 });
-
-    // v1 validation (Telegram as reference)
-    if (provider === "telegram") {
-      const botToken = String(cfg.botToken ?? "").trim();
-      if (!botToken) return NextResponse.json({ ok: false, error: "telegram.botToken is required" }, { status: 400 });
-    }
-
-    await gatewayConfigPatch({ channels: { [provider]: cfg } }, `ClawKitchen Channels upsert: ${provider}`);
-    return NextResponse.json({ ok: true });
-  } catch (e: unknown) {
-    const msg = errorMessage(e);
-    return NextResponse.json({ ok: false, error: msg }, { status: 500 });
-  }
-}
-
-type DeleteBody = { provider: string };
-
-export async function DELETE(req: Request) {
-  try {
-    const body = (await req.json()) as DeleteBody;
-    const provider = String(body?.provider ?? "").trim();
-    if (!provider) return NextResponse.json({ ok: false, error: "provider is required" }, { status: 400 });
-
-    // Patch semantics: setting a provider to null removes/clears it in the gateway config patcher.
-    await gatewayConfigPatch({ channels: { [provider]: null } }, `ClawKitchen Channels delete: ${provider}`);
-    return NextResponse.json({ ok: true });
-  } catch (e: unknown) {
-    const msg = errorMessage(e);
-    return NextResponse.json({ ok: false, error: msg }, { status: 500 });
-  }
-}

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

@@ -1,164 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import {
-  buildIdToScopeMap,
-  getInstalledIdsForTeam,
-  enrichJobsWithScope,
-  markOrphanedInTeamWorkspaces,
-  getBaseWorkspaceFromGateway,
-} from "../helpers";
-
-vi.mock("@/lib/openclaw", () => ({
-  runOpenClaw: vi.fn(),
-}));
-vi.mock("node:fs/promises", () => ({
-  default: {
-    readdir: vi.fn(),
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-    stat: vi.fn(),
-  },
-}));
-
-import { runOpenClaw } from "@/lib/openclaw";
-import fs from "node:fs/promises";
-
-describe("cron helpers", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-    vi.mocked(fs.readdir).mockReset();
-    vi.mocked(fs.readFile).mockReset();
-    vi.mocked(fs.writeFile).mockReset();
-    vi.mocked(fs.stat).mockReset();
-  });
-
-  describe("getInstalledIdsForTeam", () => {
-    it("returns installed cron ids from provenance file", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({
-          entries: {
-            "recipe.lead": { installedCronId: "cron-1", orphaned: false },
-            "recipe.qa": { installedCronId: "cron-2", orphaned: false },
-          },
-        })
-      );
-      const result = await getInstalledIdsForTeam("/path/to/cron-jobs.json");
-      expect(result).toEqual(["cron-1", "cron-2"]);
-    });
-
-    it("filters out orphaned entries", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({
-          entries: {
-            a: { installedCronId: "cron-1", orphaned: false },
-            b: { installedCronId: "cron-2", orphaned: true },
-          },
-        })
-      );
-      const result = await getInstalledIdsForTeam("/path/to/file");
-      expect(result).toEqual(["cron-1"]);
-    });
-
-    it("returns empty array on read error", async () => {
-      vi.mocked(fs.readFile).mockRejectedValue(new Error("not found"));
-      const result = await getInstalledIdsForTeam("/path/to/file");
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("enrichJobsWithScope", () => {
-    it("adds scope to jobs when id matches", () => {
-      const idToScope = new Map([
-        ["job-1", { kind: "team" as const, id: "team1", label: "team1", href: "/teams/team1" }],
-      ]);
-      const jobs = [{ id: "job-1", name: "Job 1" }, { id: "job-2", name: "Job 2" }];
-      const result = enrichJobsWithScope(jobs, idToScope);
-      expect(result[0]).toHaveProperty("scope");
-      expect((result[0] as { scope: { id: string } }).scope.id).toBe("team1");
-      expect(result[1]).not.toHaveProperty("scope");
-    });
-
-    it("preserves job when no scope", () => {
-      const idToScope = new Map();
-      const jobs = [{ id: "job-1" }];
-      const result = enrichJobsWithScope(jobs, idToScope);
-      expect(result[0]).toEqual({ id: "job-1" });
-    });
-  });
-
-  describe("buildIdToScopeMap", () => {
-    it("collects team and agent scopes", async () => {
-      vi.mocked(fs.readdir).mockResolvedValue([
-        { name: "workspace-team1", isDirectory: () => true } as never,
-      ]);
-      vi.mocked(fs.stat).mockResolvedValue({} as never);
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({
-          entries: {
-            "recipe.lead": { installedCronId: "cron-1", orphaned: false },
-          },
-        })
-      );
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        stdout: JSON.stringify([{ id: "agent1", workspace: "/ws/agent1" }]),
-        stderr: "",
-        exitCode: 0,
-      });
-      const result = await buildIdToScopeMap("/home/.openclaw/workspace");
-      expect(result.size).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("markOrphanedInTeamWorkspaces", () => {
-    it("marks matching cron as orphaned", async () => {
-      vi.mocked(fs.readdir).mockResolvedValue([
-        { name: "workspace-team1", isDirectory: () => true } as never,
-      ]);
-      vi.mocked(fs.stat).mockResolvedValue({} as never);
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({
-          version: 1,
-          entries: {
-            "recipe.lead": { installedCronId: "cron-1", orphaned: false },
-          },
-        })
-      );
-      const result = await markOrphanedInTeamWorkspaces("cron-1", "/home/.openclaw/workspace");
-      expect(result.length).toBeGreaterThanOrEqual(0);
-      expect(fs.writeFile).toHaveBeenCalled();
-    });
-
-    it("returns empty when no match", async () => {
-      vi.mocked(fs.readdir).mockResolvedValue([]);
-      const result = await markOrphanedInTeamWorkspaces("cron-99", "/home/.openclaw/workspace");
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("getBaseWorkspaceFromGateway", () => {
-    it("extracts workspace from gateway config", async () => {
-      const toolsInvoke = vi.fn().mockResolvedValue({
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              result: {
-                raw: JSON.stringify({
-                  agents: { defaults: { workspace: "/home/.openclaw/workspace" } },
-                }),
-              },
-            }),
-          },
-        ],
-      });
-      const result = await getBaseWorkspaceFromGateway(toolsInvoke);
-      expect(result).toBe("/home/.openclaw/workspace");
-    });
-
-    it("returns empty when no config", async () => {
-      const toolsInvoke = vi.fn().mockResolvedValue({ content: [] });
-      const result = await getBaseWorkspaceFromGateway(toolsInvoke);
-      expect(result).toBe("");
-    });
-  });
-});

package/src/app/api/cron/delete/route.ts

@@ -1,23 +0,0 @@
-import { NextResponse } from "next/server";
-import { toolsInvoke } from "@/lib/gateway";
-import { getBaseWorkspaceFromGateway, markOrphanedInTeamWorkspaces } from "../helpers";
-
-export async function POST(req: Request) {
-  const body = (await req.json()) as { id?: string };
-  const id = String(body.id ?? "").trim();
-  if (!id) return NextResponse.json({ ok: false, error: "id is required" }, { status: 400 });
-
-  const result = await toolsInvoke({ tool: "cron", args: { action: "remove", jobId: id } });
-
-  let orphanedIn: Array<{ teamId: string; mappingPath: string; keys: string[] }> = [];
-  try {
-    const baseWorkspace = await getBaseWorkspaceFromGateway(toolsInvoke);
-    if (baseWorkspace) {
-      orphanedIn = await markOrphanedInTeamWorkspaces(id, baseWorkspace);
-    }
-  } catch {
-    // ignore
-  }
-
-  return NextResponse.json({ ok: true, id, result, orphanedIn });
-}

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

@@ -1,172 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { runOpenClaw } from "@/lib/openclaw";
-
-export type CronScope = { kind: "team" | "agent"; id: string; label: string; href: string };
-
-function hrefForScope(scope: { kind: "team" | "agent"; id: string }) {
-  return scope.kind === "team" ? `/teams/${encodeURIComponent(scope.id)}` : `/agents/${encodeURIComponent(scope.id)}`;
-}
-
-type CronEntry = { installedCronId?: unknown; orphaned?: unknown };
-
-function addEntriesToScopeMap(
-  entries: Record<string, CronEntry>,
-  scopeId: string,
-  kind: "team" | "agent",
-  idToScope: Map<string, CronScope>
-): void {
-  for (const v of Object.values(entries)) {
-    if (v && !Boolean(v.orphaned)) {
-      const id = String(v.installedCronId ?? "").trim();
-      if (id) idToScope.set(id, { kind, id: scopeId, label: scopeId, href: hrefForScope({ kind, id: scopeId }) });
-    }
-  }
-}
-
-async function collectAgentScopes(idToScope: Map<string, CronScope>): Promise<void> {
-  try {
-    const cfgText = await runOpenClaw(["config", "get", "agents.list", "--no-color"]);
-    if (!cfgText.ok) return;
-    const list = JSON.parse(String(cfgText.stdout ?? "[]")) as Array<{ id?: unknown; workspace?: unknown }>;
-    for (const a of list) {
-      const agentId = String(a.id ?? "");
-      const workspace = String(a.workspace ?? "");
-      if (!agentId || !workspace) continue;
-      const cronPath = path.join(workspace, "notes", "cron-jobs.json");
-      try {
-        const raw = await fs.readFile(cronPath, "utf8");
-        const json = JSON.parse(raw) as { entries?: Record<string, CronEntry> };
-        addEntriesToScopeMap(json.entries ?? {}, agentId, "agent", idToScope);
-      } catch {
-        // ignore
-      }
-    }
-  } catch {
-    // ignore
-  }
-}
-
-export async function buildIdToScopeMap(baseWorkspace: string): Promise<Map<string, CronScope>> {
-  const idToScope = new Map<string, CronScope>();
-  const baseHome = path.resolve(baseWorkspace, "..");
-  const entries = await fs.readdir(baseHome, { withFileTypes: true });
-
-  for (const ent of entries) {
-    if (!ent.isDirectory() || !ent.name.startsWith("workspace-")) continue;
-    const scopeId = ent.name.replace(/^workspace-/, "");
-    const teamJsonPath = path.join(baseHome, ent.name, "team.json");
-    const teamNotesCronPath = path.join(baseHome, ent.name, "notes", "cron-jobs.json");
-    try {
-      await fs.stat(teamJsonPath);
-    } catch {
-      continue;
-    }
-    try {
-      const raw = await fs.readFile(teamNotesCronPath, "utf8");
-      const json = JSON.parse(raw) as { entries?: Record<string, CronEntry> };
-      addEntriesToScopeMap(json.entries ?? {}, scopeId, "team", idToScope);
-    } catch {
-      // ignore
-    }
-  }
-
-  await collectAgentScopes(idToScope);
-  return idToScope;
-}
-
-export async function getInstalledIdsForTeam(provenancePath: string): Promise<string[]> {
-  try {
-    const text = await fs.readFile(provenancePath, "utf8");
-    const json = JSON.parse(text) as { entries?: Record<string, { installedCronId?: unknown; orphaned?: unknown }> };
-    const entries = json.entries ?? {};
-    return Object.values(entries)
-      .filter((e) => !Boolean(e.orphaned))
-      .map((e) => String(e.installedCronId ?? "").trim())
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-export function enrichJobsWithScope(
-  jobs: unknown[],
-  idToScope: Map<string, CronScope>
-): Array<unknown & { scope?: CronScope }> {
-  return jobs.map((j) => {
-    const id = String((j as { id?: unknown }).id ?? "");
-    const scope = id ? idToScope.get(id) : undefined;
-    return (scope ? { ...(j as object), scope } : j) as unknown & { scope?: CronScope };
-  });
-}
-
-type MappingStateV1 = {
-  version: 1;
-  entries: Record<string, { installedCronId: string; orphaned?: boolean }>;
-};
-
-async function markOrphanedInOneMapping(
-  id: string,
-  mappingPath: string,
-  teamId: string
-): Promise<{ teamId: string; mappingPath: string; keys: string[] } | null> {
-  try {
-    const rawMapping = await fs.readFile(mappingPath, "utf8");
-    const mapping = JSON.parse(rawMapping) as MappingStateV1;
-    if (!mapping || mapping.version !== 1 || !mapping.entries) return null;
-
-    let changed = false;
-    const keys: string[] = [];
-    for (const [k, v] of Object.entries(mapping.entries)) {
-      if (String(v?.installedCronId ?? "").trim() === id && !v.orphaned) {
-        mapping.entries[k] = { ...v, orphaned: true };
-        changed = true;
-        keys.push(k);
-      }
-    }
-    if (!changed) return null;
-    await fs.writeFile(mappingPath, JSON.stringify(mapping, null, 2) + "\n", "utf8");
-    return { teamId, mappingPath, keys };
-  } catch {
-    return null;
-  }
-}
-
-export async function markOrphanedInTeamWorkspaces(
-  id: string,
-  baseWorkspace: string
-): Promise<Array<{ teamId: string; mappingPath: string; keys: string[] }>> {
-  const orphanedIn: Array<{ teamId: string; mappingPath: string; keys: string[] }> = [];
-  const baseHome = path.resolve(baseWorkspace, "..");
-  const entries = await fs.readdir(baseHome, { withFileTypes: true });
-
-  for (const ent of entries) {
-    if (!ent.isDirectory() || !ent.name.startsWith("workspace-")) continue;
-    const teamId = ent.name.replace(/^workspace-/, "");
-    const teamJsonPath = path.join(baseHome, ent.name, "team.json");
-    const mappingPath = path.join(baseHome, ent.name, "notes", "cron-jobs.json");
-    try {
-      await fs.stat(teamJsonPath);
-    } catch {
-      continue;
-    }
-    const result = await markOrphanedInOneMapping(id, mappingPath, teamId);
-    if (result) orphanedIn.push(result);
-  }
-
-  return orphanedIn;
-}
-
-export async function getBaseWorkspaceFromGateway(
-  toolsInvoke: (opts: { tool: string; args?: Record<string, unknown> }) => Promise<unknown>
-): Promise<string> {
-  const cfg = (await toolsInvoke({
-    tool: "gateway",
-    args: { action: "config.get", raw: "{}" },
-  })) as { content?: Array<{ type: string; text?: string }> };
-  const cfgText = cfg?.content?.find((c) => c.type === "text")?.text ?? "";
-  const env = cfgText ? (JSON.parse(cfgText) as { result?: { raw?: string } }) : null;
-  const raw = String(env?.result?.raw ?? "");
-  const parsedRaw = raw ? (JSON.parse(raw) as { agents?: { defaults?: { workspace?: string } } }) : null;
-  return String(parsedRaw?.agents?.defaults?.workspace ?? "").trim();
-}

package/src/app/api/cron/job/route.ts

@@ -1,22 +0,0 @@
-import { NextResponse } from "next/server";
-import { toolsInvoke } from "@/lib/gateway";
-
-export async function POST(req: Request) {
-  const body = (await req.json()) as { id?: string; action?: string };
-  const id = String(body.id ?? "").trim();
-  const action = String(body.action ?? "").trim();
-
-  if (!id) return NextResponse.json({ ok: false, error: "id is required" }, { status: 400 });
-  if (!["enable", "disable", "run"].includes(action)) {
-    return NextResponse.json({ ok: false, error: "action must be enable|disable|run" }, { status: 400 });
-  }
-
-  if (action === "run") {
-    const result = await toolsInvoke({ tool: "cron", args: { action: "run", jobId: id } });
-    return NextResponse.json({ ok: true, action, id, result });
-  }
-
-  const patch = { enabled: action === "enable" };
-  const result = await toolsInvoke({ tool: "cron", args: { action: "update", jobId: id, patch } });
-  return NextResponse.json({ ok: true, action, id, result });
-}

package/src/app/api/cron/jobs/route.ts

@@ -1,52 +0,0 @@
-import path from "node:path";
-import { NextResponse } from "next/server";
-import { toolsInvoke } from "@/lib/gateway";
-import { readOpenClawConfig, getTeamWorkspaceDir } from "@/lib/paths";
-import { errorMessage } from "@/lib/errors";
-import { buildIdToScopeMap, getInstalledIdsForTeam, enrichJobsWithScope } from "../helpers";
-
-type CronToolResult = { content: Array<{ type: string; text?: string }> };
-
-export async function GET(req: Request) {
-  try {
-    const url = new URL(req.url);
-    const teamId = String(url.searchParams.get("teamId") ?? "").trim();
-
-    const result = await toolsInvoke<CronToolResult>({
-      tool: "cron",
-      args: { action: "list", includeDisabled: true },
-    });
-
-    // Tool responses may come back as either:
-    // - {type:"text", text:"{...}"} (stringified JSON)
-    // - {type:"json", json:{...}} (already-parsed)
-    const text = result?.content?.find((c) => c.type === "text")?.text;
-    const jsonPayload = (result?.content as Array<{ type: string; text?: string; json?: unknown }> | undefined)?.find(
-      (c) => c.type === "json" && c.json,
-    )?.json;
-
-    const parsed = ((): { jobs?: unknown[] } => {
-      if (jsonPayload && typeof jsonPayload === "object") return jsonPayload as { jobs?: unknown[] };
-      if (text && text.trim()) return JSON.parse(text) as { jobs?: unknown[] };
-      return { jobs: [] };
-    })();
-
-    const jobs = Array.isArray(parsed.jobs) ? parsed.jobs : [];
-
-    const baseWorkspace = String((await readOpenClawConfig()).agents?.defaults?.workspace ?? "").trim();
-    const idToScope = baseWorkspace ? await buildIdToScopeMap(baseWorkspace) : new Map();
-    const enriched = enrichJobsWithScope(jobs, idToScope);
-
-    if (!teamId) return NextResponse.json({ ok: true, jobs: enriched });
-
-    const teamDir = await getTeamWorkspaceDir(teamId);
-    const provenancePath = path.join(teamDir, "notes", "cron-jobs.json");
-    const installedIds = await getInstalledIdsForTeam(provenancePath);
-    const filtered = enriched.filter((j) => installedIds.includes(String((j as { id?: unknown }).id ?? "")));
-
-    return NextResponse.json({ ok: true, jobs: filtered, teamId, provenancePath, installedIds });
-  } catch (e: unknown) {
-    const msg = errorMessage(e);
-    return NextResponse.json({ ok: false, error: msg }, { status: 500 });
-  }
-}

package/src/app/api/cron/recipe-installed/route.ts

@@ -1,65 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { NextResponse } from "next/server";
-import { cronJobId, type CronJobShape } from "@/lib/cron";
-import { getContentText, toolsInvoke } from "@/lib/gateway";
-import { teamDirFromBaseWorkspace } from "@/lib/paths";
-
-type MappingStateV1 = {
-  version: 1;
-  entries: Record<string, { installedCronId: string; orphaned?: boolean }>;
-};
-
-async function readJson<T>(p: string): Promise<T> {
-  const raw = await fs.readFile(p, "utf8");
-  return JSON.parse(raw) as T;
-}
-
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const teamId = String(url.searchParams.get("teamId") ?? "").trim();
-  if (!teamId) {
-    return NextResponse.json({ ok: false, error: "teamId is required" }, { status: 400 });
-  }
-
-  // Team workspace root is a sibling of agents.defaults.workspace: ~/.openclaw/workspace-<teamId>
-  const result = await toolsInvoke<{ content: Array<{ type: string; text?: string }> }>({
-    tool: "gateway",
-    args: { action: "config.get", raw: "{}" },
-  });
-  const cfgText = getContentText(result?.content) ?? "";
-  if (!cfgText) {
-    return NextResponse.json({ ok: false, error: "Failed to fetch config via gateway" }, { status: 500 });
-  }
-  const env = JSON.parse(cfgText) as { result?: { raw?: string } };
-  const raw = String(env.result?.raw ?? "");
-  const parsedRaw = raw ? (JSON.parse(raw) as { agents?: { defaults?: { workspace?: string } } }) : null;
-  const baseWorkspace = String(parsedRaw?.agents?.defaults?.workspace ?? "").trim();
-  if (!baseWorkspace) {
-    return NextResponse.json({ ok: false, error: "agents.defaults.workspace not set" }, { status: 500 });
-  }
-  const teamDir = teamDirFromBaseWorkspace(baseWorkspace, teamId);
-  const mappingPath = path.join(teamDir, "notes", "cron-jobs.json");
-
-  let mapping: MappingStateV1 | null = null;
-  try {
-    mapping = await readJson<MappingStateV1>(mappingPath);
-  } catch {
-    // no mapping (yet)
-    mapping = null;
-  }
-
-  const ids = new Set(
-    Object.values(mapping?.entries ?? {})
-      .filter((e) => e && typeof e.installedCronId === "string" && !e.orphaned)
-      .map((e) => e.installedCronId)
-  );
-
-  const parsed = (await toolsInvoke<{ jobs: unknown[] }>({
-    tool: "cron",
-    args: { action: "list", includeDisabled: true },
-  })) as { jobs: unknown[] };
-  const jobs = (parsed.jobs ?? []).filter((j) => ids.has(cronJobId(j as CronJobShape)));
-
-  return NextResponse.json({ ok: true, teamId, teamDir, mappingPath, jobCount: jobs.length, jobs });
-}

package/src/app/api/gateway/restart/route.ts

@@ -1,20 +0,0 @@
-import { NextResponse } from "next/server";
-import { errorMessage } from "@/lib/errors";
-import { runOpenClaw } from "@/lib/openclaw";
-
-export async function POST() {
-  try {
-    // NOTE: Kitchen runs inside the OpenClaw gateway process.
-    // If we synchronously restart the gateway while holding an HTTP request open, the browser
-    // can see a client-side exception / aborted fetch.
-    //
-    // Schedule the restart and respond immediately.
-    setTimeout(() => {
-      void runOpenClaw(["gateway", "restart"]);
-    }, 50);
-
-    return NextResponse.json({ ok: true, scheduled: true });
-  } catch (e: unknown) {
-    return NextResponse.json({ ok: false, error: errorMessage(e) }, { status: 500 });
-  }
-}