1
import { eg, type TypeFromCodec } from "@cloudflare/util-en-garde";
2
 
3
import { CommitSha, ProjectId, RunId, UnixTimestampMs } from "@/contracts/common";
4
import { AcceptedRunSnapshot } from "./project-run";
5
import { ProjectRunStatus, ProjectRunTerminalStatus } from "./primitives";
6
 
7
const NullableTimestamp = eg.union([UnixTimestampMs, eg.null]);
8
 
9
export const ClaimRunWorkInput = eg.exactStrict(
10
  eg.object({
11
    projectId: ProjectId,
12
    runId: RunId,
13
  }),
14
);
15
export type ClaimRunWorkInput = TypeFromCodec<typeof ClaimRunWorkInput>;
16
 
17
export const ClaimRunWorkStaleReason = eg.union([
18
  eg.literal("run_missing"),
19
  eg.literal("run_active"),
20
  eg.literal("canceled"),
21
  eg.literal("superseded"),
22
  eg.literal("already_terminal"),
23
  eg.literal("not_currently_executable"),
24
]);
25
export type ClaimRunWorkStaleReason = TypeFromCodec<typeof ClaimRunWorkStaleReason>;
26
 
27
const ExecuteRunWork = eg.exactStrict(
28
  eg.object({
29
    kind: eg.literal("execute"),
30
    snapshot: AcceptedRunSnapshot,
31
  }),
32
);
33
 
34
const StaleRunWork = eg.exactStrict(
35
  eg.object({
36
    kind: eg.literal("stale"),
37
    reason: ClaimRunWorkStaleReason,
38
  }),
39
);
40
 
41
export const ClaimRunWorkResult = eg.union([ExecuteRunWork, StaleRunWork]);
42
export type ClaimRunWorkResult = TypeFromCodec<typeof ClaimRunWorkResult>;
43
export type ExecuteRunWork = Extract<ClaimRunWorkResult, { kind: "execute" }>;
44
 
45
export const RunControlState = eg.exactStrict(
46
  eg.object({
47
    runId: RunId,
48
    status: ProjectRunStatus,
49
    cancelRequestedAt: NullableTimestamp,
50
  }),
51
);
52
export type RunControlState = TypeFromCodec<typeof RunControlState>;
53
 
54
export const RequestRunCancelInput = eg.exactStrict(
55
  eg.object({
56
    projectId: ProjectId,
57
    runId: RunId,
58
  }),
59
);
60
export type RequestRunCancelInput = TypeFromCodec<typeof RequestRunCancelInput>;
61
 
62
export const RequestRunCancelResult = RunControlState;
63
export type RequestRunCancelResult = TypeFromCodec<typeof RequestRunCancelResult>;
64
 
65
export const RunHeartbeatInput = eg.exactStrict(
66
  eg.object({
67
    projectId: ProjectId,
68
    runId: RunId,
69
  }),
70
);
71
export type RunHeartbeatInput = TypeFromCodec<typeof RunHeartbeatInput>;
72
 
73
export const RunHeartbeatResult = eg.union([RunControlState, eg.null]);
74
export type RunHeartbeatResult = TypeFromCodec<typeof RunHeartbeatResult>;
75
 
76
export const RecoverWorkflowDispatchFailureInput = eg.exactStrict(
77
  eg.object({
78
    projectId: ProjectId,
79
    runId: RunId,
80
    errorMessage: eg.string,
81
  }),
82
);
83
export type RecoverWorkflowDispatchFailureInput = TypeFromCodec<typeof RecoverWorkflowDispatchFailureInput>;
84
 
85
const RecoverWorkflowDispatchFailureRearmedResult = eg.exactStrict(
86
  eg.object({
87
    kind: eg.literal("rearmed"),
88
  }),
89
);
90
 
91
const RecoverWorkflowDispatchFailureAlreadyActiveResult = eg.exactStrict(
92
  eg.object({
93
    kind: eg.literal("already_active"),
94
  }),
95
);
96
 
97
const RecoverWorkflowDispatchFailureTerminalResult = eg.exactStrict(
98
  eg.object({
99
    kind: eg.literal("terminal"),
100
  }),
101
);
102
 
103
const RecoverWorkflowDispatchFailureStaleResult = eg.exactStrict(
104
  eg.object({
105
    kind: eg.literal("stale"),
106
  }),
107
);
108
 
109
export const RecoverWorkflowDispatchFailureResult = eg.union([
110
  RecoverWorkflowDispatchFailureRearmedResult,
111
  RecoverWorkflowDispatchFailureAlreadyActiveResult,
112
  RecoverWorkflowDispatchFailureTerminalResult,
113
  RecoverWorkflowDispatchFailureStaleResult,
114
]);
115
export type RecoverWorkflowDispatchFailureResult = TypeFromCodec<typeof RecoverWorkflowDispatchFailureResult>;
116
 
117
export const FinalizeRunExecutionInput = eg.exactStrict(
118
  eg.object({
119
    projectId: ProjectId,
120
    runId: RunId,
121
    terminalStatus: ProjectRunTerminalStatus,
122
    lastError: eg.union([eg.string, eg.null]),
123
    sandboxDestroyed: eg.boolean,
124
  }),
125
);
126
export type FinalizeRunExecutionInput = TypeFromCodec<typeof FinalizeRunExecutionInput>;
127
 
128
export const FinalizeRunExecutionResult = eg.exactStrict(
129
  eg.object({
130
    snapshot: AcceptedRunSnapshot,
131
  }),
132
);
133
export type FinalizeRunExecutionResult = TypeFromCodec<typeof FinalizeRunExecutionResult>;
134
 
135
export const RecordRunResolvedCommitInput = eg.exactStrict(
136
  eg.object({
137
    projectId: ProjectId,
138
    runId: RunId,
139
    commitSha: CommitSha,
140
  }),
141
);
142
export type RecordRunResolvedCommitInput = TypeFromCodec<typeof RecordRunResolvedCommitInput>;
143
 
144
const RecordRunResolvedCommitAppliedResult = eg.exactStrict(
145
  eg.object({
146
    kind: eg.literal("applied"),
147
  }),
148
);
149
 
150
const RecordRunResolvedCommitStaleResult = eg.exactStrict(
151
  eg.object({
152
    kind: eg.literal("stale"),
153
    status: eg.union([ProjectRunStatus, eg.null]),
154
  }),
155
);
156
 
157
export const RecordRunResolvedCommitResult = eg.union([
158
  RecordRunResolvedCommitAppliedResult,
159
  RecordRunResolvedCommitStaleResult,
160
]);
161
export type RecordRunResolvedCommitResult = TypeFromCodec<typeof RecordRunResolvedCommitResult>;