The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { isWebhookDedupeTemplate, scheduledTaskThreadMode } from "@t3tools/contracts"; |
| 2 | import type { |
| 3 | ModelSelection, |
| 4 | ServerConfig, |
| 5 | ProjectId, |
| 6 | RuntimeMode, |
| 7 | ScheduledTask, |
| 8 | ScheduledTaskThreadMode, |
| 9 | ScheduledTaskUpsertSchedule, |
| 10 | ScheduledTaskWebhookSignature, |
| 11 | ThreadId, |
| 12 | } from "@t3tools/contracts"; |
| 13 | |
| 14 | import { DEFAULT_SERVER_SETTINGS } from "@t3tools/contracts"; |
| 15 | import { |
| 16 | parseMaxDeliveryAge, |
| 17 | parseWebhookFilterDrafts, |
| 18 | webhookFilterDrafts, |
| 19 | webhookFilterDraftsChanged, |
| 20 | type WebhookFilterDraft, |
| 21 | } from "@t3tools/client-runtime/scheduled-task-webhook"; |
| 22 | import { |
| 23 | resolveProjectSettings, |
| 24 | type LegacyProjectSettingsFields, |
| 25 | } from "@t3tools/shared/projectSettings"; |
| 26 | import { |
| 27 | buildModelOptions, |
| 28 | resolveDefaultableModelSelection, |
| 29 | resolveNewTaskModelSelection, |
| 30 | } from "../../lib/modelOptions"; |
| 31 | |
| 32 | export function scheduledTaskDefaultModel( |
| 33 | config: ServerConfig | null, |
| 34 | project: (LegacyProjectSettingsFields & { readonly id: ProjectId }) | null, |
| 35 | ): ModelSelection | null { |
| 36 | const settings = config?.settings ?? DEFAULT_SERVER_SETTINGS; |
| 37 | const configured = resolveProjectSettings(settings, project?.id ?? null, project).settings |
| 38 | .defaultModelSelection; |
| 39 | const projectDefaultSelection = |
| 40 | resolveDefaultableModelSelection(config, configured, project?.id ?? null) ?? |
| 41 | resolveDefaultableModelSelection(config, settings.defaultModelSelection, project?.id ?? null); |
| 42 | return resolveNewTaskModelSelection({ |
| 43 | draftSelection: null, |
| 44 | projectDefaultSelection, |
| 45 | stickySelection: null, |
| 46 | modelOptions: buildModelOptions( |
| 47 | config, |
| 48 | projectDefaultSelection, |
| 49 | undefined, |
| 50 | project?.id ?? null, |
| 51 | ), |
| 52 | }); |
| 53 | } |
| 54 | |
| 55 | export type ScheduleDraft = { |
| 56 | readonly mode: "fixed_time" | "once" | "interval" | "webhook"; |
| 57 | readonly timeOfDay: string; |
| 58 | /** ISO time for a one-time run. Empty until the user picks the "Once" mode. */ |
| 59 | readonly runAt: string; |
| 60 | readonly weekdays: ReadonlyArray<number>; |
| 61 | readonly intervalMinutes: string; |
| 62 | readonly signature: ScheduledTaskWebhookSignature | null; |
| 63 | readonly maxDeliveryAgeMinutes: string; |
| 64 | readonly replayKey: string; |
| 65 | readonly coalesceKey: string; |
| 66 | readonly coalesceWindowSeconds: string; |
| 67 | readonly filters: ReadonlyArray<WebhookFilterDraft>; |
| 68 | /** The filter rows the form opened with. */ |
| 69 | readonly savedFilters: ReadonlyArray<WebhookFilterDraft>; |
| 70 | }; |
| 71 | |
| 72 | export const DEFAULT_SCHEDULE: ScheduleDraft = { |
| 73 | mode: "fixed_time", |
| 74 | timeOfDay: "09:00", |
| 75 | runAt: "", |
| 76 | weekdays: [1, 2, 3, 4, 5], |
| 77 | intervalMinutes: "15", |
| 78 | signature: null, |
| 79 | maxDeliveryAgeMinutes: "", |
| 80 | replayKey: "", |
| 81 | coalesceKey: "", |
| 82 | coalesceWindowSeconds: "", |
| 83 | filters: [], |
| 84 | savedFilters: [], |
| 85 | }; |
| 86 | |
| 87 | export function scheduleDraftForTask(task: Pick<ScheduledTask, "schedule">): ScheduleDraft { |
| 88 | switch (task.schedule.type) { |
| 89 | case "fixed_time": |
| 90 | return { |
| 91 | ...DEFAULT_SCHEDULE, |
| 92 | timeOfDay: task.schedule.timeOfDay, |
| 93 | weekdays: task.schedule.weekdays?.length |
| 94 | ? [...new Set(task.schedule.weekdays)].sort((a, b) => a - b) |
| 95 | : [0, 1, 2, 3, 4, 5, 6], |
| 96 | }; |
| 97 | case "once": |
| 98 | return { ...DEFAULT_SCHEDULE, mode: "once", runAt: task.schedule.runAt }; |
| 99 | case "interval": |
| 100 | return { |
| 101 | ...DEFAULT_SCHEDULE, |
| 102 | mode: "interval", |
| 103 | intervalMinutes: String(Math.max(1, task.schedule.everyMs / 60_000)), |
| 104 | }; |
| 105 | case "webhook": |
| 106 | return { |
| 107 | ...DEFAULT_SCHEDULE, |
| 108 | mode: "webhook", |
| 109 | signature: task.schedule.signature, |
| 110 | replayKey: task.schedule.dedupe?.replayKey ?? "", |
| 111 | coalesceKey: task.schedule.dedupe?.coalesceKey ?? "", |
| 112 | coalesceWindowSeconds: |
| 113 | task.schedule.dedupe?.coalesceWindowSeconds === undefined |
| 114 | ? "" |
| 115 | : String(task.schedule.dedupe.coalesceWindowSeconds), |
| 116 | maxDeliveryAgeMinutes: |
| 117 | task.schedule.maxDeliveryAgeMinutes == null |
| 118 | ? "" |
| 119 | : String(task.schedule.maxDeliveryAgeMinutes), |
| 120 | filters: webhookFilterDrafts(task.schedule.filters), |
| 121 | savedFilters: webhookFilterDrafts(task.schedule.filters), |
| 122 | }; |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | export function parseIntervalMinutes(value: string): number { |
| 127 | return Number(value.trim().replace(",", ".")); |
| 128 | } |
| 129 | |
| 130 | export function scheduleFromDraft(draft: ScheduleDraft): ScheduledTaskUpsertSchedule | null { |
| 131 | if (draft.mode === "webhook") { |
| 132 | const maxDeliveryAgeMinutes = parseMaxDeliveryAge(draft.maxDeliveryAgeMinutes); |
| 133 | if (maxDeliveryAgeMinutes === undefined) return null; |
| 134 | const replayKey = draft.replayKey.trim(); |
| 135 | const coalesceKey = draft.coalesceKey.trim(); |
| 136 | if ([replayKey, coalesceKey].some((key) => key && !isWebhookDedupeTemplate(key))) return null; |
| 137 | const coalesceWindowSeconds = draft.coalesceWindowSeconds?.trim() |
| 138 | ? Number(draft.coalesceWindowSeconds) |
| 139 | : undefined; |
| 140 | if ( |
| 141 | coalesceWindowSeconds !== undefined && |
| 142 | (!Number.isInteger(coalesceWindowSeconds) || |
| 143 | coalesceWindowSeconds < 10 || |
| 144 | coalesceWindowSeconds > 3600) |
| 145 | ) |
| 146 | return null; |
| 147 | const parsedFilters = parseWebhookFilterDrafts(draft.filters); |
| 148 | if (!("filters" in parsedFilters)) return null; |
| 149 | // No secret is sent, so the server keeps the stored one. |
| 150 | return { |
| 151 | type: "webhook", |
| 152 | signature: |
| 153 | draft.signature === null |
| 154 | ? null |
| 155 | : { |
| 156 | header: draft.signature.header, |
| 157 | encoding: draft.signature.encoding, |
| 158 | prefix: draft.signature.prefix, |
| 159 | }, |
| 160 | maxDeliveryAgeMinutes, |
| 161 | ...(replayKey || coalesceKey || coalesceWindowSeconds !== undefined |
| 162 | ? { |
| 163 | dedupe: { |
| 164 | ...(replayKey ? { replayKey } : {}), |
| 165 | ...(coalesceKey ? { coalesceKey } : {}), |
| 166 | ...(coalesceWindowSeconds === undefined ? {} : { coalesceWindowSeconds }), |
| 167 | }, |
| 168 | } |
| 169 | : { dedupe: {} }), |
| 170 | // Only edited filters are sent; the server keeps the stored ones otherwise. |
| 171 | ...(webhookFilterDraftsChanged(draft.savedFilters, draft.filters) |
| 172 | ? { filters: parsedFilters.filters } |
| 173 | : {}), |
| 174 | }; |
| 175 | } |
| 176 | if (draft.mode === "once") { |
| 177 | const runAt = new Date(draft.runAt); |
| 178 | return Number.isNaN(runAt.getTime()) ? null : { type: "once", runAt: runAt.toISOString() }; |
| 179 | } |
| 180 | if (draft.mode === "interval") { |
| 181 | const minutes = parseIntervalMinutes(draft.intervalMinutes); |
| 182 | const everyMs = Math.round(minutes * 60_000); |
| 183 | return minutes >= 1 && Number.isSafeInteger(everyMs) ? { type: "interval", everyMs } : null; |
| 184 | } |
| 185 | const weekdays = [...new Set(draft.weekdays)].sort((a, b) => a - b); |
| 186 | if ( |
| 187 | !/^([01]?\d|2[0-3]):[0-5]\d$/.test(draft.timeOfDay) || |
| 188 | weekdays.length === 0 || |
| 189 | weekdays.some((day) => !Number.isInteger(day) || day < 0 || day > 6) |
| 190 | ) { |
| 191 | return null; |
| 192 | } |
| 193 | return { |
| 194 | type: "fixed_time", |
| 195 | timeOfDay: draft.timeOfDay, |
| 196 | ...(weekdays.length === 7 ? {} : { weekdays }), |
| 197 | }; |
| 198 | } |
| 199 | |
| 200 | type Workspace = "worktree" | "root" | "existing_worktree"; |
| 201 | export type ScheduledTaskDraft = { |
| 202 | readonly task: ScheduledTask | null; |
| 203 | readonly title: string; |
| 204 | readonly prompt: string; |
| 205 | readonly projectId: ProjectId | null; |
| 206 | readonly threadId: ThreadId | null; |
| 207 | readonly modelSelection: ModelSelection | null; |
| 208 | readonly modelSelectionIsExplicit: boolean; |
| 209 | readonly schedule: ScheduleDraft; |
| 210 | readonly threadMode: ScheduledTaskThreadMode; |
| 211 | readonly workspace: Workspace; |
| 212 | readonly baseRef: string; |
| 213 | readonly checkoutPath: string; |
| 214 | readonly enabled: boolean; |
| 215 | readonly startFromOrigin: boolean; |
| 216 | readonly runtimeMode: RuntimeMode; |
| 217 | }; |
| 218 | |
| 219 | function draftSignature(draft: ScheduledTaskDraft): string { |
| 220 | return JSON.stringify([ |
| 221 | draft.title, |
| 222 | draft.prompt, |
| 223 | draft.projectId, |
| 224 | draft.threadId, |
| 225 | draft.modelSelection?.instanceId, |
| 226 | draft.modelSelection?.model, |
| 227 | [...(draft.modelSelection?.options ?? [])] |
| 228 | .sort((a, b) => a.id.localeCompare(b.id)) |
| 229 | .map((option) => [option.id, option.value]), |
| 230 | draft.schedule.mode, |
| 231 | draft.schedule.timeOfDay, |
| 232 | draft.schedule.runAt, |
| 233 | [...draft.schedule.weekdays].sort((a, b) => a - b), |
| 234 | draft.schedule.intervalMinutes, |
| 235 | draft.schedule.maxDeliveryAgeMinutes, |
| 236 | draft.schedule.replayKey, |
| 237 | draft.schedule.coalesceKey, |
| 238 | draft.schedule.coalesceWindowSeconds, |
| 239 | draft.schedule.filters.map(({ path, op, value }) => [path, op, value]), |
| 240 | draft.threadMode, |
| 241 | draft.workspace, |
| 242 | draft.baseRef, |
| 243 | draft.checkoutPath, |
| 244 | draft.enabled, |
| 245 | draft.startFromOrigin, |
| 246 | draft.runtimeMode, |
| 247 | ]); |
| 248 | } |
| 249 | |
| 250 | export function hasScheduledTaskDraftChanges( |
| 251 | initial: ScheduledTaskDraft, |
| 252 | current: ScheduledTaskDraft, |
| 253 | ): boolean { |
| 254 | return draftSignature(initial) !== draftSignature(current); |
| 255 | } |
| 256 | |
| 257 | export function moveDraftToThread( |
| 258 | draft: ScheduledTaskDraft, |
| 259 | thread: { readonly id: ThreadId; readonly projectId: ProjectId }, |
| 260 | ): ScheduledTaskDraft { |
| 261 | return { |
| 262 | ...draft, |
| 263 | threadId: thread.id, |
| 264 | projectId: thread.projectId, |
| 265 | threadMode: draft.threadMode === "new_thread" ? "continue" : draft.threadMode, |
| 266 | }; |
| 267 | } |
| 268 | |
| 269 | /** Leaves the thread but keeps the mode. Matches MCP: new threads stay out of the shared checkout. */ |
| 270 | export function unbindDraftFromThread(draft: ScheduledTaskDraft): ScheduledTaskDraft { |
| 271 | if (draft.threadId === null) return draft; |
| 272 | return { |
| 273 | ...draft, |
| 274 | threadId: null, |
| 275 | ...(draft.workspace === "root" |
| 276 | ? { workspace: "worktree" as const, startFromOrigin: true } |
| 277 | : {}), |
| 278 | }; |
| 279 | } |
| 280 | |
| 281 | export function changeDraftProject( |
| 282 | draft: ScheduledTaskDraft, |
| 283 | projectId: ProjectId, |
| 284 | ): ScheduledTaskDraft { |
| 285 | if (projectId === draft.projectId) return draft; |
| 286 | return { ...unbindDraftFromThread(draft), projectId }; |
| 287 | } |
| 288 | |
| 289 | export function createDraft( |
| 290 | projectId: ProjectId | null, |
| 291 | modelSelection: ModelSelection | null, |
| 292 | ): ScheduledTaskDraft { |
| 293 | return { |
| 294 | task: null, |
| 295 | title: "", |
| 296 | prompt: "", |
| 297 | projectId, |
| 298 | threadId: null, |
| 299 | modelSelection, |
| 300 | modelSelectionIsExplicit: false, |
| 301 | schedule: DEFAULT_SCHEDULE, |
| 302 | threadMode: "new_thread", |
| 303 | workspace: "worktree", |
| 304 | baseRef: "", |
| 305 | checkoutPath: "", |
| 306 | enabled: true, |
| 307 | startFromOrigin: true, |
| 308 | runtimeMode: "full-access", |
| 309 | }; |
| 310 | } |
| 311 | |
| 312 | export function editDraft(task: ScheduledTask): ScheduledTaskDraft { |
| 313 | return { |
| 314 | task, |
| 315 | title: task.title, |
| 316 | prompt: task.prompt, |
| 317 | projectId: task.projectId, |
| 318 | threadId: task.threadId, |
| 319 | modelSelection: task.modelSelection, |
| 320 | modelSelectionIsExplicit: true, |
| 321 | schedule: scheduleDraftForTask(task), |
| 322 | threadMode: scheduledTaskThreadMode(task), |
| 323 | workspace: task.workspaceStrategy.type, |
| 324 | baseRef: task.workspaceStrategy.type === "worktree" ? task.workspaceStrategy.baseRef : "", |
| 325 | checkoutPath: |
| 326 | task.workspaceStrategy.type === "existing_worktree" |
| 327 | ? task.workspaceStrategy.worktreePath |
| 328 | : "", |
| 329 | enabled: task.enabled, |
| 330 | startFromOrigin: |
| 331 | task.workspaceStrategy.type === "worktree" |
| 332 | ? (task.workspaceStrategy.startFromOrigin ?? false) |
| 333 | : true, |
| 334 | runtimeMode: task.runtimeMode, |
| 335 | }; |
| 336 | } |