@qihongmu/dsh-plugins-scheduled-task 0.1.0

package/lib/types/spec.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The external scheduled-task domain declaration: record schema and the
+ * `defineDomain` spec the service opens (mirrors the storage-domain pattern).
+ * @module @qihongmu/dsh-plugins-scheduled-task/src/spec
+ */
+import { z } from 'zod';
+import { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { ScheduledTaskId } from './types.ts';
+/**
+ * Durable shape of one task record. `title`/`prompt` are non-empty after
+ * trimming; `rule` carries the schedule and next target; timestamps are ISO-8601.
+ */
+export declare const scheduledTaskRecord: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<ScheduledTaskId, string>>;
+    title: z.ZodString;
+    prompt: z.ZodString;
+    rule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"after">;
+        afterSeconds: z.ZodNumber;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"at">;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"every">;
+        everySeconds: z.ZodNumber;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hourly">;
+        minute: z.ZodNumber;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"daily">;
+        time: z.ZodString;
+        time_zone: z.ZodString;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"weekly">;
+        weekdays: z.ZodArray<z.ZodNumber>;
+        time: z.ZodString;
+        time_zone: z.ZodString;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"monthly">;
+        dayOfMonth: z.ZodNumber;
+        time: z.ZodString;
+        time_zone: z.ZodString;
+        scheduledAt: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+    }>;
+    sessionId: z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>;
+    createdAt: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>>;
+    confirmBeforeChange: z.ZodBoolean;
+    lastRunAt: z.ZodOptional<z.ZodString>;
+    lastReadAt: z.ZodOptional<z.ZodString>;
+    lastError: z.ZodOptional<z.ZodObject<{
+        at: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One stored task record, inferred from {@link scheduledTaskRecord}. */
+export type ScheduledTaskRecord = z.infer<typeof scheduledTaskRecord>;
+/** The scheduled-task domain spec: one `tasks` table keyed by task id. */
+export declare const scheduledTaskDomainSpec: {
+    name: string;
+    version: number;
+    tables: {
+        tasks: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<ScheduledTaskId, {
+            id: ScheduledTaskId;
+            title: string;
+            prompt: string;
+            rule: {
+                kind: "after";
+                afterSeconds: number;
+                scheduledAt: string;
+            } | {
+                kind: "at";
+                scheduledAt: string;
+            } | {
+                kind: "every";
+                everySeconds: number;
+                scheduledAt: string;
+            } | {
+                kind: "hourly";
+                minute: number;
+                scheduledAt: string;
+            } | {
+                kind: "daily";
+                time: string;
+                time_zone: string;
+                scheduledAt: string;
+            } | {
+                kind: "weekly";
+                weekdays: number[];
+                time: string;
+                time_zone: string;
+                scheduledAt: string;
+            } | {
+                kind: "monthly";
+                dayOfMonth: number;
+                time: string;
+                time_zone: string;
+                scheduledAt: string;
+            };
+            status: "active" | "paused" | "completed";
+            sessionId: SessionId;
+            createdAt: string;
+            confirmBeforeChange: boolean;
+            workspaceId?: string | undefined;
+            cwd?: string | undefined;
+            model?: {
+                provider: string;
+                model: string;
+            } | undefined;
+            lastRunAt?: string | undefined;
+            lastReadAt?: string | undefined;
+            lastError?: {
+                at: string;
+                message: string;
+            } | undefined;
+        }>;
+    };
+};
+//# sourceMappingURL=spec.d.ts.map

package/lib/types/spec.js

@@ -0,0 +1,89 @@
+/**
+ * The external scheduled-task domain declaration: record schema and the
+ * `defineDomain` spec the service opens (mirrors the storage-domain pattern).
+ * @module @qihongmu/dsh-plugins-scheduled-task/src/spec
+ */
+import { z } from 'zod';
+import { SessionId } from '@deepseek-ai/dsh-session/types';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+/** Task id schema at the durable boundary; branding has no runtime representation. */
+const scheduledTaskId = z.string().transform(value => value);
+/** Session id schema; branding has no runtime representation. */
+const sessionId = z.string().transform(SessionId);
+const afterRule = z.object({
+    kind: z.literal('after'),
+    afterSeconds: z.number().int().positive(),
+    scheduledAt: z.string(),
+});
+const atRule = z.object({
+    kind: z.literal('at'),
+    scheduledAt: z.string(),
+});
+const everyRule = z.object({
+    kind: z.literal('every'),
+    everySeconds: z.number().int().min(300),
+    scheduledAt: z.string(),
+});
+const hourlyRule = z.object({
+    kind: z.literal('hourly'),
+    minute: z.number().int().min(0).max(59),
+    scheduledAt: z.string(),
+});
+const dailyRule = z.object({
+    kind: z.literal('daily'),
+    time: z.string(),
+    time_zone: z.string(),
+    scheduledAt: z.string(),
+});
+const weeklyRule = z.object({
+    kind: z.literal('weekly'),
+    weekdays: z.array(z.number().int().min(1).max(7)).min(1),
+    time: z.string(),
+    time_zone: z.string(),
+    scheduledAt: z.string(),
+});
+const monthlyRule = z.object({
+    kind: z.literal('monthly'),
+    dayOfMonth: z.number().int().min(1).max(31),
+    time: z.string(),
+    time_zone: z.string(),
+    scheduledAt: z.string(),
+});
+const rule = z.discriminatedUnion('kind', [
+    afterRule, atRule, everyRule, hourlyRule, dailyRule, weeklyRule, monthlyRule,
+]);
+/** Provider/model pair stored on a task. */
+const model = z.object({
+    provider: z.string().min(1),
+    model: z.string().min(1),
+});
+/**
+ * Durable shape of one task record. `title`/`prompt` are non-empty after
+ * trimming; `rule` carries the schedule and next target; timestamps are ISO-8601.
+ */
+export const scheduledTaskRecord = z.object({
+    id: scheduledTaskId,
+    title: z.string().min(1),
+    prompt: z.string().min(1),
+    rule,
+    status: z.enum(['active', 'paused', 'completed']),
+    sessionId,
+    createdAt: z.string(),
+    workspaceId: z.string().optional(),
+    cwd: z.string().optional(),
+    model: model.optional(),
+    confirmBeforeChange: z.boolean(),
+    lastRunAt: z.string().optional(),
+    lastReadAt: z.string().optional(),
+    /** Failure of the most recent run-admission attempt, if it did not succeed. */
+    lastError: z.object({
+        at: z.string(),
+        message: z.string().min(1),
+    }).optional(),
+});
+/** The scheduled-task domain spec: one `tasks` table keyed by task id. */
+export const scheduledTaskDomainSpec = defineDomain({
+    name: 'scheduled_task',
+    version: 1,
+    tables: { tasks: domainTable(scheduledTaskRecord) },
+});

package/lib/types/types.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Wire-facing global scheduled-task value types (client-safe; no DSH repo edits).
+ * @module @qihongmu/dsh-plugins-scheduled-task
+ */
+import type { Branded } from '@deepseek-ai/dsh-brand';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** Stable task identity that is unique and never reused. */
+export type ScheduledTaskId = Branded<'ScheduledTaskId'>;
+/** Lifecycle a task can occupy; `completed` is terminal and set only after a one-shot fires. */
+export type ScheduledTaskStatus = 'active' | 'paused' | 'completed';
+/** Selector statuses the browser may set directly; `completed` is scheduler-derived. */
+export type ScheduledTaskSettableStatus = 'active' | 'paused';
+/** One-shot delayed rule: fire once `afterSeconds` after creation. */
+export interface AfterScheduledTaskRule {
+    kind: 'after';
+    afterSeconds: number;
+    scheduledAt: string;
+}
+/** One-shot absolute rule: fire at one exact instant. */
+export interface AtScheduledTaskRule {
+    kind: 'at';
+    scheduledAt: string;
+}
+/** Fixed-rate rule: fire every `everySeconds`, creation-anchored. */
+export interface EveryScheduledTaskRule {
+    kind: 'every';
+    everySeconds: number;
+    scheduledAt: string;
+}
+/**
+ * Recurring wall-clock rules: each carries its next absolute `scheduledAt` (the
+ * earliest un-fired occurrence past its anchor) plus the params needed to
+ * advance to the following occurrence in the local time zone.
+ */
+/** Hourly rule: fire at `minute` (0-59) past each hour, in the process zone. */
+export interface HourlyScheduledTaskRule {
+    kind: 'hourly';
+    minute: number;
+    scheduledAt: string;
+}
+/** Daily rule: fire each day at `time` (HH:mm) in `time_zone`. */
+export interface DailyScheduledTaskRule {
+    kind: 'daily';
+    time: string;
+    time_zone: string;
+    scheduledAt: string;
+}
+/** Weekly rule: fire on each selected weekday (1=Mon..7=Sun) at `time` in `time_zone`. */
+export interface WeeklyScheduledTaskRule {
+    kind: 'weekly';
+    weekdays: number[];
+    time: string;
+    time_zone: string;
+    scheduledAt: string;
+}
+/** Monthly rule: fire on `dayOfMonth` (1-31) at `time` in `time_zone`; months without the day are skipped. */
+export interface MonthlyScheduledTaskRule {
+    kind: 'monthly';
+    dayOfMonth: number;
+    time: string;
+    time_zone: string;
+    scheduledAt: string;
+}
+/** The scheduled-task rule union. */
+export type ScheduledTaskRule = AfterScheduledTaskRule | AtScheduledTaskRule | EveryScheduledTaskRule | HourlyScheduledTaskRule | DailyScheduledTaskRule | WeeklyScheduledTaskRule | MonthlyScheduledTaskRule;
+/** Structured local-calendar absolute input accepted by `at`. */
+export interface ScheduledTaskAtInput {
+    date: string;
+    time: string;
+    time_zone: string;
+}
+/** Hourly selector: fire each hour at `minute` (0-59) past the hour. */
+export interface ScheduledTaskHourlyInput {
+    minute: number;
+}
+/** Daily selector: fire each day at `time` (HH:mm) in `time_zone`. */
+export interface ScheduledTaskDailyInput {
+    time: string;
+    time_zone: string;
+}
+/** Weekly selector: fire on each weekday (1=Mon..7=Sun) at `time` in `time_zone`. */
+export interface ScheduledTaskWeeklyInput {
+    weekdays: number[];
+    time: string;
+    time_zone: string;
+}
+/** Monthly selector: fire on `dayOfMonth` (1-31) at `time` in `time_zone`. */
+export interface ScheduledTaskMonthlyInput {
+    dayOfMonth: number;
+    time: string;
+    time_zone: string;
+}
+/** Provider/model pair a scheduled task runs with (applied as the agent's options at fire time). */
+export interface ScheduledTaskModel {
+    provider: string;
+    model: string;
+}
+/** Common create/update carry fields (not part of the schedule selector). */
+export interface ScheduledTaskCarryFields {
+    /** The task instruction (the Prompt executed at fire time). */
+    prompt?: string;
+    /** Optional project workspace id the task runs in (drives the run directory). */
+    workspaceId?: string;
+    /** Canonical project path used as the run session `cwd`. */
+    cwd?: string;
+    /** Provider/model the task runs with; absent keeps the deployment default. */
+    model?: ScheduledTaskModel;
+    /** Whether to ask the user before the run makes changes (approval policy `ask`). */
+    confirmBeforeChange?: boolean;
+}
+/** One schedule selector, exactly one of which is required on create. */
+export interface ScheduledTaskScheduleSelectorFields {
+    after_seconds?: number;
+    at?: ScheduledTaskAtInput;
+    every_seconds?: number;
+    hourly?: ScheduledTaskHourlyInput;
+    daily?: ScheduledTaskDailyInput;
+    weekly?: ScheduledTaskWeeklyInput;
+    monthly?: ScheduledTaskMonthlyInput;
+}
+/** Create input: a non-empty title, a non-empty prompt, and exactly one schedule selector. */
+export interface ScheduledTaskCreateInput extends ScheduledTaskCarryFields, ScheduledTaskScheduleSelectorFields {
+    title: string;
+    prompt: string;
+}
+/** Update input: any supplied field replaces the stored one; an absent selector keeps the current rule. */
+export interface ScheduledTaskUpdateInput extends ScheduledTaskCarryFields, ScheduledTaskScheduleSelectorFields {
+    title?: string;
+}
+/** Coarse display phase derived from status + wall clock. */
+export type ScheduledTaskState = 'scheduled' | 'overdue' | 'completed';
+/** Complete client-facing view of one task. */
+export interface ScheduledTaskView {
+    id: ScheduledTaskId;
+    title: string;
+    prompt: string;
+    rule: ScheduledTaskRule;
+    status: ScheduledTaskStatus;
+    sessionId: SessionId;
+    createdAt: string;
+    workspaceId?: string;
+    cwd?: string;
+    model?: ScheduledTaskModel;
+    confirmBeforeChange: boolean;
+    lastRunAt?: string;
+    nextRunAt?: string;
+    state: ScheduledTaskState;
+    unread: boolean;
+    /** Failure of the most recent run-admission attempt, if it did not succeed. */
+    lastError?: ScheduledTaskRunError;
+}
+/** One failed run admission (session creation/queueing), kept for surfacing. */
+export interface ScheduledTaskRunError {
+    /** ISO-8601 instant of the failure. */
+    at: string;
+    /** Rendered failure message (process-side diagnostics wording). */
+    message: string;
+}
+/** Closed v1 management error codes. */
+export type ScheduledTaskErrorCode = 'invalid_title' | 'invalid_prompt' | 'invalid_selector' | 'invalid_rule' | 'invalid_time_zone' | 'not_future' | 'time_out_of_range' | 'frequency_too_high' | 'task_not_found' | 'internal_error';
+/** Successful or failed create/update/status mutation. */
+export type ScheduledTaskMutationResult = {
+    ok: true;
+    task: ScheduledTaskView;
+} | {
+    ok: false;
+    code: ScheduledTaskErrorCode;
+    message: string;
+};
+/** Successful or failed delete. */
+export type ScheduledTaskDeleteResult = {
+    ok: true;
+    deleted: boolean;
+} | {
+    ok: false;
+    code: ScheduledTaskErrorCode;
+    message: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,5 @@
+/**
+ * Wire-facing global scheduled-task value types (client-safe; no DSH repo edits).
+ * @module @qihongmu/dsh-plugins-scheduled-task
+ */
+export {};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@qihongmu/dsh-plugins-scheduled-task",
+  "version": "0.1.0",
+  "license": "MIT",
+  "author": "Qihong <qihong.m.u+dev@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qihongmu/dsh-plugins.git",
+    "directory": "packages/scheduled-task/host"
+  },
+  "description": "External user plugin: global scheduled tasks for DeepSeek Harness (host Service + scheduler + Remote surface), no changes to the dsh library.",
+  "type": "module",
+  "main": "lib/types/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/types/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/types/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/dsh-agent": "*",
+    "@deepseek-ai/dsh-brand": "*",
+    "@deepseek-ai/dsh-invariants": "*",
+    "@deepseek-ai/dsh-llm": "*",
+    "@deepseek-ai/dsh-schedule": "*",
+    "@deepseek-ai/dsh-session": "*",
+    "@deepseek-ai/dsh-storage-domain": "*",
+    "@deepseek-ai/dsh-typert-protocol": "*"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "!lib/**/*.map",
+    "!lib/**/*.tsbuildinfo"
+  ]
+}