feat: friendly duration format for schedule (30s/5min/1h/2d/PT30M)

Author: javazys

package.json

@@ -1,6 +1,6 @@
 {
     "name": "opencode-supertask",
-    "version": "0.1.5",
+    "version": "0.1.6",
     "description": "AI Agent 任务调度系统 — OpenCode 插件 + CLI + Gateway 常驻进程",
     "type": "module",
     "main": "dist/plugin/supertask.js",

plugin/supertask.ts

@@ -10,6 +10,7 @@ import { type Plugin, type Hooks, tool } from "@opencode-ai/plugin";
 import { TaskService } from "@core/services/task.service";
 import { TaskTemplateService } from "@core/services/task-template.service";
 import { getDb, sqlite } from "@core/db";
+import { parseDuration } from "@core/duration";
 import { ensureGateway } from "../src/daemon/pm2";
 
 let _initialized = false;
@@ -460,8 +461,8 @@ export const SuperTaskPlugin: Plugin = async () => {
                         .object({
                             type: tool.schema.enum(["cron", "delayed", "recurring"]).describe("调度类型"),
                             cron_expr: tool.schema.string().optional().describe("cron 表达式（cron 类型必填，如 '0 9 * * 1-5'）"),
-                            run_at: tool.schema.number().optional().describe("执行时间戳 ms（delayed 类型必填）"),
-                            interval_ms: tool.schema.number().optional().describe("间隔毫秒（recurring 类型必填）"),
+                            delay: tool.schema.string().optional().describe("延迟时间（delayed 类型必填），友好格式如 '30s' '5min' '1h' '2d'，也支持 ISO 8601 duration 如 'PT30M'"),
+                            interval: tool.schema.string().optional().describe("循环间隔（recurring 类型必填），友好格式如 '1h' '30min' '5s'，也支持 ISO 8601 duration 如 'PT1H'"),
                         })
                         .describe("调度配置"),
                     max_instances: tool.schema.number().optional().describe("最大并发实例数，默认 1"),
@@ -474,6 +475,26 @@ export const SuperTaskPlugin: Plugin = async () => {
                             return JSON.stringify({ error: "schedule is required" });
                         }
                         const scheduleType = args.schedule.type as import("@core/db/schema").ScheduleType;
+
+                        let cronExpr = args.schedule.cron_expr;
+                        let intervalMs: number | null = null;
+                        let runAt: number | null = null;
+
+                        if (scheduleType === "delayed" && args.schedule.delay) {
+                            const delayMs = parseDuration(args.schedule.delay);
+                            if (delayMs === null) {
+                                return JSON.stringify({ error: `Invalid delay format: "${args.schedule.delay}". Use formats like "30s", "5min", "1h", "2d"` });
+                            }
+                            runAt = Date.now() + delayMs;
+                        }
+
+                        if (scheduleType === "recurring" && args.schedule.interval) {
+                            intervalMs = parseDuration(args.schedule.interval);
+                            if (intervalMs === null) {
+                                return JSON.stringify({ error: `Invalid interval format: "${args.schedule.interval}". Use formats like "30s", "5min", "1h", "2d"` });
+                            }
+                        }
+
                         const tmpl = await TaskTemplateService.create({
                             name: args.name,
                             agent: args.agent,
@@ -483,9 +504,9 @@ export const SuperTaskPlugin: Plugin = async () => {
                             importance: args.importance ?? 3,
                             urgency: args.urgency ?? 3,
                             scheduleType,
-                            cronExpr: args.schedule.cron_expr,
-                            intervalMs: args.schedule.interval_ms,
-                            runAt: args.schedule.run_at,
+                            cronExpr,
+                            intervalMs,
+                            runAt,
                             maxInstances: args.max_instances,
                             maxRetries: args.max_retries,
                             retryBackoffMs: args.retry_backoff_ms,

src/cli/index.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { TaskService } from '@core/services/task.service';
 import { TaskTemplateService } from '@core/services/task-template.service';
 import { closeDb } from '@core/db';
+import { parseDuration } from '@core/duration';
 import type { TaskStatus, ScheduleType } from '@core/db/schema';
 
 async function withDb<T>(fn: () => Promise<T>): Promise<T> {
@@ -221,8 +222,8 @@ program
             .requiredOption('-p, --prompt <prompt>', '提示词')
             .requiredOption('-t, --type <type>', '调度类型：cron/delayed/recurring')
             .option('--cron <expr>', 'cron 表达式（cron 类型必填）')
-            .option('--interval <ms>', '间隔毫秒（recurring 类型必填）')
-            .option('--run-at <ms>', '执行时间戳 ms（delayed 类型必填）')
+            .option('--delay <duration>', '延迟时间（delayed 类型必填），如 30s / 5min / 1h / 2d')
+            .option('--interval <duration>', '循环间隔（recurring 类型必填），如 1h / 30min / 5s')
             .option('-m, --model <model>', '模型')
             .option('-c, --category <category>', '分类', 'general')
             .option('-i, --importance <number>', '重要程度 1-5', '3')
@@ -231,6 +232,25 @@ program
             .option('--max-retries <number>', '最大重试次数', '3')
             .option('--retry-backoff <ms>', '退避基础间隔 ms', '30000')
             .action(async (options) => withDb(async () => {
+                let intervalMs: number | null = null;
+                let runAt: number | null = null;
+
+                if (options.interval) {
+                    intervalMs = parseDuration(options.interval);
+                    if (intervalMs === null) {
+                        console.error(JSON.stringify({ error: `Invalid interval: "${options.interval}". Use 30s / 5min / 1h / 2d` }));
+                        process.exit(1);
+                    }
+                }
+                if (options.delay) {
+                    const delayMs = parseDuration(options.delay);
+                    if (delayMs === null) {
+                        console.error(JSON.stringify({ error: `Invalid delay: "${options.delay}". Use 30s / 5min / 1h / 2d` }));
+                        process.exit(1);
+                    }
+                    runAt = Date.now() + delayMs;
+                }
+
                 const tmpl = await TaskTemplateService.create({
                     name: options.name,
                     agent: options.agent,
@@ -241,8 +261,8 @@ program
                     urgency: parseInt(options.urgency),
                     scheduleType: options.type as ScheduleType,
                     cronExpr: options.cron,
-                    intervalMs: options.interval ? parseInt(options.interval) : null,
-                    runAt: options.runAt ? parseInt(options.runAt) : null,
+                    intervalMs,
+                    runAt,
                     maxInstances: parseInt(options.maxInstances),
                     maxRetries: parseInt(options.maxRetries),
                     retryBackoffMs: parseInt(options.retryBackoff),

src/core/duration.ts

@@ -0,0 +1,32 @@
+const DURATION_REGEX = /^(\d+(?:\.\d+)?)\s*(ms|s|sec|seconds?|min|minutes?|m|h|hours?|d|days?|w|weeks?)$/i;
+const ISO8601_REGEX = /^P(?:([.\d]+)D)?(?:T(?:([.\d]+)H)?(?:([.\d]+)M)?(?:([.\d]+)S)?)?$/i;
+
+export function parseDuration(input: string): number | null {
+    const trimmed = input.trim();
+
+    const simple = DURATION_REGEX.exec(trimmed);
+    if (simple) {
+        const value = parseFloat(simple[1]);
+        const unit = simple[2].toLowerCase();
+        if (unit === "ms") return value;
+        if (unit === "s" || unit === "sec" || unit === "second" || unit === "seconds") return value * 1000;
+        if (unit === "min" || unit === "minute" || unit === "minutes" || unit === "m") return value * 60_000;
+        if (unit === "h" || unit === "hour" || unit === "hours") return value * 3_600_000;
+        if (unit === "d" || unit === "day" || unit === "days") return value * 86_400_000;
+        if (unit === "w" || unit === "week" || unit === "weeks") return value * 604_800_000;
+    }
+
+    const iso = ISO8601_REGEX.exec(trimmed);
+    if (iso) {
+        const days = parseFloat(iso[1] ?? "0");
+        const hours = parseFloat(iso[2] ?? "0");
+        const minutes = parseFloat(iso[3] ?? "0");
+        const seconds = parseFloat(iso[4] ?? "0");
+        return ((days * 86400) + (hours * 3600) + (minutes * 60) + seconds) * 1000;
+    }
+
+    const asNumber = Number(trimmed);
+    if (!isNaN(asNumber) && asNumber > 0) return asNumber;
+
+    return null;
+}

tests/duration.test.ts

@@ -0,0 +1,80 @@
+import { describe, test, expect } from "bun:test";
+import { parseDuration } from "../src/core/duration";
+
+describe("parseDuration", () => {
+    test("秒", () => {
+        expect(parseDuration("30s")).toBe(30_000);
+        expect(parseDuration("1s")).toBe(1000);
+        expect(parseDuration("5sec")).toBe(5000);
+        expect(parseDuration("10seconds")).toBe(10_000);
+        expect(parseDuration("2 second")).toBe(2000);
+    });
+
+    test("分钟", () => {
+        expect(parseDuration("1min")).toBe(60_000);
+        expect(parseDuration("5min")).toBe(300_000);
+        expect(parseDuration("30minutes")).toBe(1_800_000);
+        expect(parseDuration("1 minute")).toBe(60_000);
+        expect(parseDuration("1m")).toBe(60_000);
+    });
+
+    test("小时", () => {
+        expect(parseDuration("1h")).toBe(3_600_000);
+        expect(parseDuration("2h")).toBe(7_200_000);
+        expect(parseDuration("1hours")).toBe(3_600_000);
+        expect(parseDuration("1 hour")).toBe(3_600_000);
+    });
+
+    test("天", () => {
+        expect(parseDuration("1d")).toBe(86_400_000);
+        expect(parseDuration("2d")).toBe(172_800_000);
+        expect(parseDuration("1days")).toBe(86_400_000);
+        expect(parseDuration("3 day")).toBe(259_200_000);
+    });
+
+    test("周", () => {
+        expect(parseDuration("1w")).toBe(604_800_000);
+        expect(parseDuration("2weeks")).toBe(1_209_600_000);
+    });
+
+    test("毫秒", () => {
+        expect(parseDuration("500ms")).toBe(500);
+        expect(parseDuration("1000ms")).toBe(1000);
+    });
+
+    test("小数", () => {
+        expect(parseDuration("1.5h")).toBe(5_400_000);
+        expect(parseDuration("0.5d")).toBe(43_200_000);
+    });
+
+    test("ISO 8601 duration", () => {
+        expect(parseDuration("PT30M")).toBe(1_800_000);
+        expect(parseDuration("PT1H")).toBe(3_600_000);
+        expect(parseDuration("PT1H30M")).toBe(5_400_000);
+        expect(parseDuration("P1DT12H")).toBe(129_600_000);
+        expect(parseDuration("PT45S")).toBe(45_000);
+    });
+
+    test("纯数字（毫秒）", () => {
+        expect(parseDuration("60000")).toBe(60_000);
+        expect(parseDuration("1000")).toBe(1000);
+    });
+
+    test("大小写不敏感", () => {
+        expect(parseDuration("1H")).toBe(3_600_000);
+        expect(parseDuration("5Min")).toBe(300_000);
+        expect(parseDuration("2D")).toBe(172_800_000);
+    });
+
+    test("带空格", () => {
+        expect(parseDuration("  1h  ")).toBe(3_600_000);
+        expect(parseDuration("5 min")).toBe(300_000);
+    });
+
+    test("无效输入返回 null", () => {
+        expect(parseDuration("abc")).toBeNull();
+        expect(parseDuration("")).toBeNull();
+        expect(parseDuration("0")).toBeNull();
+        expect(parseDuration("-1h")).toBeNull();
+    });
+});