The best way to control Claude Code, Codex and more from any computer or phone

main
ts 336 lines 10.7 KB
Raw
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 }