@jiggai/kitchen 0.1.12 → 0.2.0

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

@@ -0,0 +1,164 @@
+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,13 +1,6 @@
 import { NextResponse } from "next/server";
 import { toolsInvoke } from "@/lib/gateway";
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-type MappingStateV1 = {
-  version: 1;
-  entries: Record<string, { installedCronId: string; orphaned?: boolean }>;
-};
+import { getBaseWorkspaceFromGateway, markOrphanedInTeamWorkspaces } from "../helpers";
 
 export async function POST(req: Request) {
   const body = (await req.json()) as { id?: string };
@@ -16,63 +9,11 @@ export async function POST(req: Request) {
 
   const result = await toolsInvoke({ tool: "cron", args: { action: "remove", jobId: id } });
 
-  // Best-effort provenance cleanup: mark any mapping entry that references this cron id as orphaned.
-  // Source of truth is team workspaces' notes/cron-jobs.json written at scaffold time.
-  const orphanedIn: Array<{ teamId: string; mappingPath: string; keys: string[] }> = [];
-
+  let orphanedIn: Array<{ teamId: string; mappingPath: string; keys: string[] }> = [];
   try {
-    // Find base workspace path via gateway config.
-    const cfg = await toolsInvoke<{ content: Array<{ type: string; text?: string }> }>({
-      tool: "gateway",
-      args: { action: "config.get", raw: "{}" },
-    });
-    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;
-    const baseWorkspace = String(parsedRaw?.agents?.defaults?.workspace ?? "").trim();
-
+    const baseWorkspace = await getBaseWorkspaceFromGateway(toolsInvoke);
     if (baseWorkspace) {
-      const baseHome = path.resolve(baseWorkspace, "..");
-      const entries = await fs.readdir(baseHome, { withFileTypes: true });
-
-      for (const ent of entries) {
-        if (!ent.isDirectory()) continue;
-        if (!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;
-        }
-
-        let changed = false;
-        const keys: string[] = [];
-        try {
-          const rawMapping = await fs.readFile(mappingPath, "utf8");
-          const mapping = JSON.parse(rawMapping) as MappingStateV1;
-          if (!mapping || mapping.version !== 1 || !mapping.entries) continue;
-
-          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) {
-            await fs.writeFile(mappingPath, JSON.stringify(mapping, null, 2) + "\n", "utf8");
-            orphanedIn.push({ teamId, mappingPath, keys });
-          }
-        } catch {
-          // ignore
-        }
-      }
+      orphanedIn = await markOrphanedInTeamWorkspaces(id, baseWorkspace);
     }
   } catch {
     // ignore

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

@@ -0,0 +1,172 @@
+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/jobs/route.ts

@@ -1,18 +1,11 @@
+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 }>;
-};
-
-import fs from "node:fs/promises";
-import path from "node:path";
-import { getTeamWorkspaceDir } from "@/lib/paths";
-import { runOpenClaw } from "@/lib/openclaw";
-
-function hrefForScope(scope: { kind: "team" | "agent"; id: string }) {
-  return scope.kind === "team" ? `/teams/${encodeURIComponent(scope.id)}` : `/agents/${encodeURIComponent(scope.id)}`;
-}
+type CronToolResult = { content: Array<{ type: string; text?: string }> };
 
 export async function GET(req: Request) {
   try {
@@ -24,118 +17,36 @@ export async function GET(req: Request) {
       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;
-    if (!text) {
-      return NextResponse.json({ ok: true, jobs: [] });
-    }
-
-    const parsed = JSON.parse(text) as { jobs?: unknown[] };
-    const jobs = Array.isArray(parsed.jobs) ? parsed.jobs : [];
-
-    // Enrich: map installed cron IDs → scope (team/agent) using provenance files.
-    // This is best-effort; if anything fails, we still return raw jobs.
-    const idToScope = new Map<string, { kind: "team" | "agent"; id: string; label: string; href: string }>();
+    const jsonPayload = (result?.content as Array<{ type: string; text?: string; json?: unknown }> | undefined)?.find(
+      (c) => c.type === "json" && c.json,
+    )?.json;
 
-    try {
-      // Teams: scan known workspace-* directories for notes/cron-jobs.json
-      // NOTE: This is not intended to be ultra-fast; cron-jobs page is admin tooling.
-      const baseWorkspace = String((await (await import("@/lib/paths")).readOpenClawConfig()).agents?.defaults?.workspace ?? "").trim();
-      const baseHome = path.resolve(baseWorkspace, "..");
-      const entries = await fs.readdir(baseHome, { withFileTypes: true });
+    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: [] };
+    })();
 
-      for (const ent of entries) {
-        if (!ent.isDirectory()) continue;
-        if (!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");
-
-        // If team.json exists, treat as a team workspace.
-        try {
-          await fs.stat(teamJsonPath);
-        } catch {
-          continue;
-        }
-
-        try {
-          const raw = await fs.readFile(teamNotesCronPath, "utf8");
-          const json = JSON.parse(raw) as { entries?: Record<string, { installedCronId?: unknown; orphaned?: unknown }> };
-          const map = json.entries ?? {};
-          for (const v of Object.values(map)) {
-            if (v && !Boolean(v.orphaned)) {
-              const id = String(v.installedCronId ?? "").trim();
-              if (id) idToScope.set(id, { kind: "team", id: scopeId, label: scopeId, href: hrefForScope({ kind: "team", id: scopeId }) });
-            }
-          }
-        } catch {
-          // ignore
-        }
-      }
-
-      // Agents: use OpenClaw config list to map agent workspaces and check for notes/cron-jobs.json
-      try {
-        const cfgText = await runOpenClaw(["config", "get", "agents.list", "--no-color"]);
-        if (cfgText.ok) {
-          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, { installedCronId?: unknown; orphaned?: unknown }> };
-              const map = json.entries ?? {};
-              for (const v of Object.values(map)) {
-                if (v && !Boolean(v.orphaned)) {
-                  const id = String(v.installedCronId ?? "").trim();
-                  if (id) idToScope.set(id, { kind: "agent", id: agentId, label: agentId, href: hrefForScope({ kind: "agent", id: agentId }) });
-                }
-              }
-            } catch {
-              // ignore
-            }
-          }
-        }
-      } catch {
-        // ignore
-      }
-    } catch {
-      // ignore
-    }
+    const jobs = Array.isArray(parsed.jobs) ? parsed.jobs : [];
 
-    const enriched = 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;
-    });
+    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 });
-    }
+    if (!teamId) return NextResponse.json({ ok: true, jobs: enriched });
 
-    // If a teamId is provided, filter to only cron jobs installed for that team.
-    // Source of truth is the team workspace provenance file written by scaffold-team.
     const teamDir = await getTeamWorkspaceDir(teamId);
     const provenancePath = path.join(teamDir, "notes", "cron-jobs.json");
-
-    let installedIds: 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 ?? {};
-      installedIds = Object.values(entries)
-        .filter((e) => !Boolean(e.orphaned))
-        .map((e) => String(e.installedCronId ?? "").trim())
-        .filter(Boolean);
-    } catch {
-      installedIds = [];
-    }
-
+    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 = e instanceof Error ? e.message : String(e);
+    const msg = errorMessage(e);
     return NextResponse.json({ ok: false, error: msg }, { status: 500 });
   }
 }

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

@@ -1,7 +1,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { NextResponse } from "next/server";
-import { toolsInvoke } from "@/lib/gateway";
+import { cronJobId, type CronJobShape } from "@/lib/cron";
+import { getContentText, toolsInvoke } from "@/lib/gateway";
+import { teamDirFromBaseWorkspace } from "@/lib/paths";
 
 type MappingStateV1 = {
   version: 1;
@@ -25,7 +27,7 @@ export async function GET(req: Request) {
     tool: "gateway",
     args: { action: "config.get", raw: "{}" },
   });
-  const cfgText = result?.content?.find((c) => c.type === "text")?.text ?? "";
+  const cfgText = getContentText(result?.content) ?? "";
   if (!cfgText) {
     return NextResponse.json({ ok: false, error: "Failed to fetch config via gateway" }, { status: 500 });
   }
@@ -36,7 +38,7 @@ export async function GET(req: Request) {
   if (!baseWorkspace) {
     return NextResponse.json({ ok: false, error: "agents.defaults.workspace not set" }, { status: 500 });
   }
-  const teamDir = path.resolve(baseWorkspace, "..", `workspace-${teamId}`);
+  const teamDir = teamDirFromBaseWorkspace(baseWorkspace, teamId);
   const mappingPath = path.join(teamDir, "notes", "cron-jobs.json");
 
   let mapping: MappingStateV1 | null = null;
@@ -57,7 +59,7 @@ export async function GET(req: Request) {
     tool: "cron",
     args: { action: "list", includeDisabled: true },
   })) as { jobs: unknown[] };
-  const jobs = (parsed.jobs ?? []).filter((j) => ids.has(String((j as { id?: unknown })?.id ?? "")));
+  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,4 +1,5 @@
 import { NextResponse } from "next/server";
+import { errorMessage } from "@/lib/errors";
 import { runOpenClaw } from "@/lib/openclaw";
 
 export async function POST() {
@@ -14,6 +15,6 @@ export async function POST() {
 
     return NextResponse.json({ ok: true, scheduled: true });
   } catch (e: unknown) {
-    return NextResponse.json({ ok: false, error: e instanceof Error ? e.message : String(e) }, { status: 500 });
+    return NextResponse.json({ ok: false, error: errorMessage(e) }, { status: 500 });
   }
 }