public let offset: Int?

public let query: String?

public let enabled: AnyCodable?

public let schedulekind: AnyCodable?

public let lastrunstatus: AnyCodable?

public let sortby: AnyCodable?

public let sortdir: AnyCodable?

public let agentid: String?

offset: Int?,

query: String?,

enabled: AnyCodable?,

schedulekind: AnyCodable?,

lastrunstatus: AnyCodable?,

sortby: AnyCodable?,

sortdir: AnyCodable?,

agentid: String?)

self.offset = offset

self.query = query

self.enabled = enabled

self.schedulekind = schedulekind

self.lastrunstatus = lastrunstatus

self.sortby = sortby

self.sortdir = sortdir

self.agentid = agentid

case offset

case query

case enabled

case schedulekind = "scheduleKind"

case lastrunstatus = "lastRunStatus"

case sortby = "sortBy"

case sortdir = "sortDir"

case agentid = "agentId"

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

import { describe, expect, it } from "vitest";

import { createMockCronStateForJobs } from "./service.test-harness.js";

import { listPage } from "./service/ops.js";

expect(page.jobs.map((job) => job.id)).toEqual(["job-main", "job-ops"]);

});

it("matches job ids in listPage text search", async () => {

const jobs = [

createBaseJob({ id: "daily-report", name: "Morning report" }),

createBaseJob({ id: "tax-digest", name: "Finance digest" }),

];

const state = createMockCronStateForJobs({ jobs });

const page = await listPage(state, { query: "tax" });

expect(page.jobs.map((job) => job.id)).toEqual(["tax-digest"]);

});

it("applies schedule and last-run status filters before paging", async () => {

const nextRunAtMs = Date.parse("2030-02-27T15:30:00.000Z");

const jobs = [

createBaseJob({

id: "at-unknown",

schedule: { kind: "at", at: "2030-02-27T15:30:00.000Z" },

state: { nextRunAtMs },

}),

createBaseJob({

id: "cron-error",

schedule: { kind: "cron", expr: "0 9 * * *" },

state: { nextRunAtMs, lastStatus: "error" },

}),

createBaseJob({

id: "cron-unknown",

schedule: { kind: "cron", expr: "0 10 * * *" },

state: { nextRunAtMs },

}),

];

const state = createMockCronStateForJobs({ jobs });

const storeDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-cron-list-page-"));

try {

state.deps.storePath = path.join(storeDir, "jobs.json");

const page = await listPage(state, {

scheduleKind: "cron",

lastRunStatus: "unknown",

limit: 1,

});

expect(page.jobs.map((job) => job.id)).toEqual(["cron-unknown"]);

expect(page.total).toBe(1);

expect(page.hasMore).toBe(false);

} finally {

await fs.rm(storeDir, { recursive: true, force: true });

}

});

});

import type { CronJob } from "../types.js";

import type { CronJob, CronRunStatus } from "../types.js";

export type CronJobsEnabledFilter = "all" | "enabled" | "disabled";

export type CronJobsScheduleKindFilter = "all" | "at" | "every" | "cron";

export type CronJobsLastRunStatusFilter = "all" | CronRunStatus | "unknown";

export type CronJobsSortBy = "nextRunAtMs" | "updatedAtMs" | "name";

export type CronSortDir = "asc" | "desc";

offset?: number;

query?: string;

enabled?: CronJobsEnabledFilter;

scheduleKind?: CronJobsScheduleKindFilter;

lastRunStatus?: CronJobsLastRunStatusFilter;

sortBy?: CronJobsSortBy;

sortDir?: CronSortDir;

agentId?: string;

} from "./jobs.js";

import type {

CronJobsEnabledFilter,

CronJobsLastRunStatusFilter,

CronJobsScheduleKindFilter,

CronJobsSortBy,

CronListPageOptions,

CronListPageResult,

return opts?.includeDisabled ? "all" : "enabled";

}

function resolveScheduleKindFilter(opts?: CronListPageOptions): CronJobsScheduleKindFilter {

if (

opts?.scheduleKind === "all" ||

opts?.scheduleKind === "at" ||

opts?.scheduleKind === "every" ||

opts?.scheduleKind === "cron"

) {

return opts.scheduleKind;

}

return "all";

}

function resolveLastRunStatusFilter(opts?: CronListPageOptions): CronJobsLastRunStatusFilter {

if (

opts?.lastRunStatus === "all" ||

opts?.lastRunStatus === "ok" ||

opts?.lastRunStatus === "error" ||

opts?.lastRunStatus === "skipped" ||

opts?.lastRunStatus === "unknown"

) {

return opts.lastRunStatus;

}

return "all";

}

function resolveJobLastRunStatus(job: CronJob): CronJobsLastRunStatusFilter {

return job.state.lastRunStatus ?? job.state.lastStatus ?? "unknown";

}

function sortJobs(jobs: CronJob[], sortBy: CronJobsSortBy, sortDir: CronSortDir) {

const dir = sortDir === "desc" ? -1 : 1;

return jobs.toSorted((a, b) => {

await ensureLoadedForRead(state);

const query = normalizeLowercaseStringOrEmpty(opts?.query);

const enabledFilter = resolveEnabledFilter(opts);

const scheduleKindFilter = resolveScheduleKindFilter(opts);

const lastRunStatusFilter = resolveLastRunStatusFilter(opts);

const sortBy = opts?.sortBy ?? "nextRunAtMs";

const sortDir = opts?.sortDir ?? "asc";

const requestedAgentId = normalizeOptionalAgentId(opts?.agentId);

) {

return false;

}

if (scheduleKindFilter !== "all" && job.schedule.kind !== scheduleKindFilter) {

return false;

}

if (lastRunStatusFilter !== "all" && resolveJobLastRunStatus(job) !== lastRunStatusFilter) {

return false;

}

if (!query) {

return true;

}

const haystack = normalizeLowercaseStringOrEmpty(

[job.name, job.description ?? "", job.agentId ?? ""].join(" "),

[job.id, job.name, job.description ?? "", job.agentId ?? ""].join(" "),

);

return haystack.includes(query);

});

offset: 0,

query: "daily",

enabled: "all",

scheduleKind: "cron",

lastRunStatus: "unknown",

sortBy: "nextRunAtMs",

sortDir: "asc",

agentId: "ops",

}),

).toBe(true);

expect(validateCronListParams({ offset: -1 })).toBe(false);

expect(validateCronListParams({ agentId: "" })).toBe(false);

expect(validateCronListParams({ scheduleKind: "yearly" })).toBe(false);

expect(validateCronListParams({ lastRunStatus: "pending" })).toBe(false);

});

it("enforces runs limit minimum for id and jobId selectors", () => {

Type.Literal("enabled"),

Type.Literal("disabled"),

]);

const CronJobsScheduleKindFilterSchema = Type.Union([

Type.Literal("all"),

Type.Literal("at"),

Type.Literal("every"),

Type.Literal("cron"),

]);

const CronJobsLastRunStatusFilterSchema = Type.Union([

Type.Literal("all"),

Type.Literal("ok"),

Type.Literal("error"),

Type.Literal("skipped"),

Type.Literal("unknown"),

]);

const CronJobsSortBySchema = Type.Union([

Type.Literal("nextRunAtMs"),

Type.Literal("updatedAtMs"),

offset: Type.Optional(Type.Integer({ minimum: 0 })),

query: Type.Optional(Type.String()),

enabled: Type.Optional(CronJobsEnabledFilterSchema),

scheduleKind: Type.Optional(CronJobsScheduleKindFilterSchema),

lastRunStatus: Type.Optional(CronJobsLastRunStatusFilterSchema),

sortBy: Type.Optional(CronJobsSortBySchema),

sortDir: Type.Optional(CronSortDirSchema),

agentId: Type.Optional(NonEmptyString),

offset?: number;

query?: string;

enabled?: "all" | "enabled" | "disabled";

scheduleKind?: "all" | "at" | "every" | "cron";

lastRunStatus?: "all" | "ok" | "error" | "skipped" | "unknown";

sortBy?: "nextRunAtMs" | "updatedAtMs" | "name";

sortDir?: "asc" | "desc";

agentId?: string;

offset: p.offset,

query: p.query,

enabled: p.enabled,

scheduleKind: p.scheduleKind,

lastRunStatus: p.lastRunStatus,

sortBy: p.sortBy,

sortDir: p.sortDir,

agentId: p.agentId,

return value as Record<string, unknown>;

}

function requireArray(value: unknown, label: string): unknown[] {

function requireArray(value: unknown, label: string): Array<unknown> {

expect(Array.isArray(value), label).toBe(true);

return value as unknown[];

return value as Array<unknown>;

}

function expectFields(record: Record<string, unknown>, expected: Record<string, unknown>) {

}

function expectDiagnosticCodes(diagnostics: unknown, expectedCodes: string[]) {

const codes = requireArray(diagnostics, "diagnostics").map(

(diagnostic) => requireRecord(diagnostic, "diagnostic").code,

);

const codes: Array<unknown> = [];

for (const diagnostic of requireArray(diagnostics, "diagnostics")) {

codes.push(requireRecord(diagnostic, "diagnostic").code);

}

expect(codes).toEqual(expectedCodes);

}

updateCronRunsFilter(state, { cronRunsScope: "job" });

await loadCronRuns(state, jobId);

},

onLoadMoreJobs: () => loadCronJobsPage(state, { append: true }),

onLoadMoreJobs: () => loadCronJobsPage(state, { append: true, tableFilters: true }),

onJobsFiltersChange: async (patch) => {

updateCronJobsFilter(state, patch);

const shouldReload =

typeof patch.cronJobsQuery === "string" ||

Boolean(patch.cronJobsEnabledFilter) ||

Boolean(patch.cronJobsScheduleKindFilter) ||

Boolean(patch.cronJobsLastStatusFilter) ||

Boolean(patch.cronJobsSortBy) ||

Boolean(patch.cronJobsSortDir);

if (shouldReload) {

await loadCronJobsPage(state, { append: false });

await loadCronJobsPage(state, { append: false, tableFilters: true });

}

},

onJobsFiltersReset: async () => {

cronJobsSortBy: "nextRunAtMs",

cronJobsSortDir: "asc",

});

await loadCronJobsPage(state, { append: false });

await loadCronJobsPage(state, { append: false, tableFilters: true });

},

onLoadMoreRuns: () => loadMoreCronRuns(state),

onRunsFiltersChange: async (patch) => {

expectCommonAgentsTabRefresh(host);

expect(mocks.loadChannelsMock).toHaveBeenCalledWith(host, false);

expect(mocks.loadCronStatusMock).toHaveBeenCalledOnce();

expect(mocks.loadCronJobsPageMock).toHaveBeenCalledOnce();

expect(mocks.loadCronJobsPageMock).toHaveBeenCalledWith(host, { tableFilters: false });

expect(mocks.loadCronRunsMock).toHaveBeenCalledWith(host, "job-123");

expect(mocks.loadAgentFilesMock).not.toHaveBeenCalled();

expect(mocks.loadAgentSkillsMock).not.toHaveBeenCalled();

expect(outcome).toBe("resolved");

expect(mocks.loadChannelsMock).toHaveBeenCalledWith(host, false);

expect(mocks.loadCronStatusMock).toHaveBeenCalledOnce();

expect(mocks.loadCronJobsPageMock).toHaveBeenCalledOnce();

expect(mocks.loadCronJobsPageMock).toHaveBeenCalledWith(host, { tableFilters: true });

expect(mocks.loadCronRunsMock).toHaveBeenCalledOnce();

});