expect(result.formattedTime).toBe("Saturday, May 30th, 2026 - 12:00");

expect(result.timeLine).toContain("Reference UTC: 2026-05-30 12:00 UTC");

});

it("falls back to epoch when both nowMs and Date.now are outside Date range", () => {

vi.spyOn(Date, "now").mockReturnValue(8_640_000_000_000_001);

const result = resolveCronStyleNow(

{ agents: { defaults: { userTimezone: "UTC", timeFormat: "24" } } },

8_640_000_000_000_001,

);

expect(result.timeLine).toContain("Reference UTC: 1970-01-01 00:00 UTC");

});

});

import { asDateTimestampMs } from "../shared/number-coercion.js";

import { resolveDateTimestampMs } from "../shared/number-coercion.js";

import {

type TimeFormatPreference,

formatUserTime,

export function resolveCronStyleNow(cfg: TimeConfigLike, nowMs: number): CronStyleNow {

const userTimezone = resolveUserTimezone(cfg.agents?.defaults?.userTimezone);

const userTimeFormat = resolveUserTimeFormat(cfg.agents?.defaults?.timeFormat);

const timestampMs = asDateTimestampMs(nowMs) ?? Date.now();

const timestampMs = resolveDateTimestampMs(nowMs);

const date = new Date(timestampMs);

const formattedTime = formatUserTime(date, userTimezone, userTimeFormat) ?? date.toISOString();

const utcTime = date.toISOString().replace("T", " ").slice(0, 16) + " UTC";

expect(formatDateStamp(8_640_000_000_000_001, "UTC")).toBe("2026-05-30");

});

it("falls back to epoch when both nowMs and Date.now are outside Date range", () => {

vi.spyOn(Date, "now").mockReturnValue(8_640_000_000_000_001);

expect(formatDateStamp(8_640_000_000_000_001, "UTC")).toBe("1970-01-01");

});

});

import { execFileSync } from "node:child_process";

import { asDateTimestampMs } from "../shared/number-coercion.js";

import { resolveDateTimestampMs } from "../shared/number-coercion.js";

export type TimeFormatPreference = "auto" | "12" | "24";

export type ResolvedTimeFormat = "12" | "24";

}

export function formatDateStamp(nowMs: number, timeZone: string): string {

const timestampMs = asDateTimestampMs(nowMs) ?? Date.now();

const timestampMs = resolveDateTimestampMs(nowMs);

const date = new Date(timestampMs);

const parts = new Intl.DateTimeFormat("en-US", {

timeZone,

);

});

it("falls back to epoch when injected nowMs and Date.now are outside Date range", async () => {

await withOpenClawTestState(

{

layout: "state-only",

prefix: "openclaw-backup-invalid-fallback-now-",

scenario: "minimal",

},

async (state) => {

const outputDir = state.path("backups");

await fs.mkdir(outputDir, { recursive: true });

const dateNowSpy = vi.spyOn(Date, "now").mockReturnValue(8_640_000_000_000_001);

try {

const result = await createBackupArchive({

output: outputDir,

dryRun: true,

includeWorkspace: false,

nowMs: 8_640_000_000_000_001,

});

expect(result.createdAt).toBe("1970-01-01T00:00:00.000Z");

expect(path.basename(result.archivePath)).toContain("openclaw-backup.tar.gz");

expect(path.basename(result.archivePath)).not.toContain("NaN");

} finally {

dateNowSpy.mockRestore();

}

},

);

});

it("skips current live volatile state files while preserving workspace locks", async () => {

await withOpenClawTestState(

{

resolveBackupPlanFromDisk,

} from "../commands/backup-shared.js";

import { isPathWithin } from "../commands/cleanup-utils.js";

import { asDateTimestampMs } from "../shared/number-coercion.js";

import { resolveDateTimestampMs } from "../shared/number-coercion.js";

import { resolveHomeDir, resolveUserPath } from "../utils.js";

import { resolveRuntimeServiceVersion } from "../version.js";

import { isVolatileBackupPath } from "./backup-volatile-filter.js";

export async function createBackupArchive(

opts: BackupCreateOptions = {},

): Promise<BackupCreateResult> {

const nowMs = asDateTimestampMs(opts.nowMs) ?? Date.now();

const nowMs = resolveDateTimestampMs(opts.nowMs);

const archiveRoot = buildBackupArchiveRoot(nowMs);

const onlyConfig = Boolean(opts.onlyConfig);

const includeWorkspace = onlyConfig ? false : (opts.includeWorkspace ?? true);

resolveNonNegativeIntegerOption,

resolveOptionalIntegerOption,

resolvePositiveTimerTimeoutMs,

resolveDateTimestampMs,

parseStrictFiniteNumber,

parseStrictInteger,

parseStrictNonNegativeInteger,

});

test("timestamp fallback helpers resolve Date-invalid timestamps", () => {

expect(resolveDateTimestampMs(1_000)).toBe(1_000);

expect(resolveDateTimestampMs(Number.POSITIVE_INFINITY, 1_000)).toBe(1_000);

expect(resolveDateTimestampMs(Number.POSITIVE_INFINITY, Number.NaN)).toBe(0);

expect(resolveTimestampMsToIsoString(0)).toBe("1970-01-01T00:00:00.000Z");

expect(resolveTimestampMsToIsoString(Number.POSITIVE_INFINITY, 1_000)).toBe(

"1970-01-01T00:00:01.000Z",

return timestampMs === undefined ? undefined : new Date(timestampMs).toISOString();

}

export function resolveDateTimestampMs(

value: unknown,

fallbackValue: unknown = Date.now(),

): number {

return asDateTimestampMs(value) ?? asDateTimestampMs(fallbackValue) ?? 0;

}

export function resolveTimestampMsToIsoString(

value: unknown,

fallbackValue: unknown = Date.now(),