@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 394 lines 14 KB
Raw
1 import { EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts";
2 import * as Schema from "effect/Schema";
3 import { Atom, type AtomRegistry } from "effect/reactivity";
4
5 import {
6 flattenQueuedThreadMessages,
7 groupQueuedThreadMessages,
8 type QueuedThreadMessage,
9 } from "./thread-outbox-model";
10 import type { ThreadOutboxStorage } from "./thread-outbox-storage";
11
12 export class ThreadOutboxManagerError extends Schema.TaggedError<ThreadOutboxManagerError>()(
13 "ThreadOutboxManagerError",
14 {
15 operation: Schema.Literals([
16 "load",
17 "enqueue",
18 "update",
19 "remove",
20 "clear-environment-load",
21 "clear-environment-remove",
22 ]),
23 environmentId: Schema.NullOr(EnvironmentId),
24 threadId: Schema.NullOr(ThreadId),
25 messageId: Schema.NullOr(MessageId),
26 cause: Schema.Defect(),
27 },
28 ) {
29 override get message(): string {
30 return `Thread outbox operation ${this.operation} failed for environment ${this.environmentId ?? "unknown"}, thread ${this.threadId ?? "unknown"}, message ${this.messageId ?? "unknown"}.`;
31 }
32 }
33
34 export interface ThreadOutboxManagerOptions {
35 readonly registry: AtomRegistry.AtomRegistry;
36 readonly storage: ThreadOutboxStorage;
37 readonly warn?: (message: string, error: unknown) => void;
38 }
39
40 export function createThreadOutboxManager(options: ThreadOutboxManagerOptions) {
41 const queuedMessagesByThreadKeyAtom = Atom.make<
42 Record<string, ReadonlyArray<QueuedThreadMessage>>
43 >({}).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-outbox:queued-messages"));
44 const warn =
45 options.warn ??
46 ((message: string, error: unknown) => {
47 console.warn(message, error);
48 });
49 let loadPromise: Promise<boolean> | null = null;
50 let mutationQueue: Promise<void> = Promise.resolve();
51 const revisions = new Map<MessageId, number>();
52 const bumpRevision = (messageId: MessageId): void => {
53 revisions.set(messageId, (revisions.get(messageId) ?? 0) + 1);
54 };
55
56 const serialize = <A>(mutation: () => Promise<A>): Promise<A> => {
57 const result = mutationQueue.then(mutation, mutation);
58 mutationQueue = result.then(
59 () => undefined,
60 () => undefined,
61 );
62 return result;
63 };
64
65 const currentMessages = (): ReadonlyArray<QueuedThreadMessage> =>
66 flattenQueuedThreadMessages(options.registry.get(queuedMessagesByThreadKeyAtom));
67
68 const setMessages = (messages: ReadonlyArray<QueuedThreadMessage>): void => {
69 options.registry.set(queuedMessagesByThreadKeyAtom, groupQueuedThreadMessages(messages));
70 };
71
72 // Partial loads expose readable messages; return true only on complete loads to protect unreadable records' files.
73 const load = (): Promise<boolean> => {
74 if (loadPromise !== null) {
75 return loadPromise;
76 }
77 loadPromise = serialize(async () => {
78 const result = await options.storage.load();
79 const current = currentMessages();
80 const currentIds = new Set(current.map((message) => message.messageId));
81 const recovered = result.messages.filter(
82 (message) => !currentIds.has(message.messageId) && !revisions.has(message.messageId),
83 );
84 if (recovered.length > 0) setMessages([...recovered, ...current]);
85 if (result.errors.length > 0) {
86 throw new AggregateError(result.errors, "Some queued messages could not be read.");
87 }
88 return true;
89 }).catch((cause) => {
90 loadPromise = null;
91 warn(
92 "[thread-outbox] failed to load persisted messages",
93 new ThreadOutboxManagerError({
94 operation: "load",
95 environmentId: null,
96 threadId: null,
97 messageId: null,
98 cause,
99 }),
100 );
101 return false;
102 });
103 return loadPromise;
104 };
105
106 const enqueue = (message: QueuedThreadMessage): Promise<void> => {
107 bumpRevision(message.messageId);
108 setMessages([
109 ...currentMessages().filter((candidate) => candidate.messageId !== message.messageId),
110 message,
111 ]);
112 return serialize(async () => {
113 try {
114 await options.storage.write(message);
115 } catch (cause) {
116 // Rollback by reference: a retry with the same id may already own a newer optimistic entry.
117 setMessages(currentMessages().filter((candidate) => candidate !== message));
118 // Remove compensating persisted copies after rollback unless a same-id entry survives, or restart resurrects rejected messages.
119 if (!currentMessages().some((candidate) => candidate.messageId === message.messageId)) {
120 try {
121 await options.storage.remove(message);
122 } catch {}
123 }
124 throw new ThreadOutboxManagerError({
125 operation: "enqueue",
126 environmentId: message.environmentId,
127 threadId: message.threadId,
128 messageId: message.messageId,
129 cause,
130 });
131 }
132 });
133 };
134
135 // Confirm durability before dispatch so a failed write cannot follow successful delivery.
136 const confirmQueued = (message: QueuedThreadMessage): Promise<boolean> =>
137 serialize(async () => currentMessages().some((candidate) => candidate === message));
138
139 // Enqueue may publish during writes; persist the winning revision before settling to avoid stale crash recovery.
140 const update = (message: QueuedThreadMessage, expectedRevision?: number): Promise<boolean> =>
141 serialize(async () => {
142 const staleOrMissing = (): boolean =>
143 !currentMessages().some((candidate) => candidate.messageId === message.messageId) ||
144 (expectedRevision !== undefined &&
145 (revisions.get(message.messageId) ?? 0) !== expectedRevision);
146 if (staleOrMissing()) {
147 return false;
148 }
149 try {
150 await options.storage.write(message);
151 } catch (cause) {
152 throw new ThreadOutboxManagerError({
153 operation: "update",
154 environmentId: message.environmentId,
155 threadId: message.threadId,
156 messageId: message.messageId,
157 cause,
158 });
159 }
160 if (staleOrMissing()) {
161 const winner = currentMessages().find(
162 (candidate) => candidate.messageId === message.messageId,
163 );
164 if (winner !== undefined) {
165 try {
166 await options.storage.write(winner);
167 } catch {}
168 }
169 return false;
170 }
171 bumpRevision(message.messageId);
172 setMessages([
173 ...currentMessages().filter((candidate) => candidate.messageId !== message.messageId),
174 message,
175 ]);
176 return true;
177 });
178
179 /**
180 * Applies `change` to the message as it stands when this mutation's turn comes, so concurrent
181 * changes compose instead of failing on each other's revision. `null` leaves it unchanged.
182 */
183 const modify = (
184 messageId: MessageId,
185 change: (message: QueuedThreadMessage) => QueuedThreadMessage | null,
186 ): Promise<boolean> =>
187 serialize(async () => {
188 const current = currentMessages().find((candidate) => candidate.messageId === messageId);
189 const next = current === undefined ? null : change(current);
190 if (current === undefined || next === null) return false;
191 const revision = revisions.get(messageId) ?? 0;
192 try {
193 await options.storage.write(next);
194 } catch (cause) {
195 throw new ThreadOutboxManagerError({
196 operation: "update",
197 environmentId: next.environmentId,
198 threadId: next.threadId,
199 messageId,
200 cause,
201 });
202 }
203 // An enqueue publishes without waiting its turn; when one replaced the message during the
204 // write, it wins and stays durable.
205 if ((revisions.get(messageId) ?? 0) !== revision || !currentMessages().includes(current)) {
206 const winner = currentMessages().find((candidate) => candidate.messageId === messageId);
207 if (winner !== undefined) {
208 try {
209 await options.storage.write(winner);
210 } catch {}
211 }
212 return false;
213 }
214 bumpRevision(messageId);
215 setMessages(currentMessages().map((candidate) => (candidate === current ? next : candidate)));
216 return true;
217 });
218
219 // Check live ownership too; editor locks can change without message revision updates.
220 const remove = (
221 message: QueuedThreadMessage,
222 expectedRevision?: number,
223 canRemove?: () => boolean,
224 ): Promise<QueuedThreadMessage | null> =>
225 serialize(async () => {
226 const removalCanceled = (): boolean =>
227 (expectedRevision !== undefined &&
228 (revisions.get(message.messageId) ?? 0) !== expectedRevision) ||
229 canRemove?.() === false;
230 if (removalCanceled()) {
231 return null;
232 }
233 const removed =
234 currentMessages().find((candidate) => candidate.messageId === message.messageId) ?? message;
235 try {
236 await options.storage.remove(message);
237 } catch (cause) {
238 throw new ThreadOutboxManagerError({
239 operation: "remove",
240 environmentId: message.environmentId,
241 threadId: message.threadId,
242 messageId: message.messageId,
243 cause,
244 });
245 }
246 if (removalCanceled()) {
247 // Enqueue or editor locks can win during removal; persist the live winner before the next queued mutation.
248 const winner = currentMessages().find(
249 (candidate) => candidate.messageId === message.messageId,
250 );
251 if (winner !== undefined) {
252 try {
253 await options.storage.write(winner);
254 } catch (cause) {
255 throw new ThreadOutboxManagerError({
256 operation: "remove",
257 environmentId: message.environmentId,
258 threadId: message.threadId,
259 messageId: message.messageId,
260 cause,
261 });
262 }
263 }
264 return null;
265 }
266 setMessages(
267 currentMessages().filter((candidate) => candidate.messageId !== message.messageId),
268 );
269 // Tombstone revisions: restarting a same-id retry at one would match stale pre-removal writers (ABA).
270 bumpRevision(message.messageId);
271 return removed;
272 });
273
274 const clearEnvironment = (
275 environmentId: EnvironmentId,
276 ): Promise<ReadonlyArray<QueuedThreadMessage>> => {
277 // Capture revisions now but read messages after prior mutations; later changes must escape this clear request.
278 const revisionsAtRequest = new Map(revisions);
279 return serialize(async () => {
280 const persisted = await options.storage
281 .load()
282 .then((result) => {
283 if (result.errors.length > 0) {
284 throw new AggregateError(result.errors, "Some queued messages could not be read.");
285 }
286 return result.messages;
287 })
288 .catch((cause) => {
289 throw new ThreadOutboxManagerError({
290 operation: "clear-environment-load",
291 environmentId,
292 threadId: null,
293 messageId: null,
294 cause,
295 });
296 });
297 const allMessages = flattenQueuedThreadMessages(
298 groupQueuedThreadMessages([...persisted, ...currentMessages()]),
299 );
300 const candidates = allMessages.filter(
301 (message) =>
302 message.environmentId === environmentId &&
303 (revisions.get(message.messageId) ?? 0) ===
304 (revisionsAtRequest.get(message.messageId) ?? 0),
305 );
306 const candidateRevisions = new Map(
307 candidates.map(
308 (message) => [message.messageId, revisions.get(message.messageId) ?? 0] as const,
309 ),
310 );
311 const removedFromStorage = new Set<MessageId>();
312
313 await Promise.all(
314 candidates.map(async (message) => {
315 try {
316 await options.storage.remove(message);
317 removedFromStorage.add(message.messageId);
318 } catch (cause) {
319 warn(
320 "[thread-outbox] failed to clear persisted message",
321 new ThreadOutboxManagerError({
322 operation: "clear-environment-remove",
323 environmentId: message.environmentId,
324 threadId: message.threadId,
325 messageId: message.messageId,
326 cause,
327 }),
328 );
329 }
330 }),
331 );
332
333 await Promise.all(
334 candidates.map(async (message) => {
335 if (
336 !removedFromStorage.has(message.messageId) ||
337 (revisions.get(message.messageId) ?? 0) === candidateRevisions.get(message.messageId)
338 ) {
339 return;
340 }
341 const retained = currentMessages().find(
342 (candidate) => candidate.messageId === message.messageId,
343 );
344 if (retained === undefined) {
345 return;
346 }
347 try {
348 await options.storage.write(retained);
349 } catch (cause) {
350 warn(
351 "[thread-outbox] failed to restore message retained during environment clear",
352 new ThreadOutboxManagerError({
353 operation: "clear-environment-remove",
354 environmentId: retained.environmentId,
355 threadId: retained.threadId,
356 messageId: retained.messageId,
357 cause,
358 }),
359 );
360 }
361 }),
362 );
363
364 const removed = candidates.filter(
365 (message) =>
366 removedFromStorage.has(message.messageId) &&
367 (revisions.get(message.messageId) ?? 0) === candidateRevisions.get(message.messageId),
368 );
369 const removedMessageIds = new Set(removed.map((message) => message.messageId));
370 const reconciledMessages = flattenQueuedThreadMessages(
371 groupQueuedThreadMessages([...allMessages, ...currentMessages()]),
372 ).filter((message) => !removedMessageIds.has(message.messageId));
373 for (const message of removed) {
374 bumpRevision(message.messageId);
375 }
376 setMessages(reconciledMessages);
377 // Report the actual removed messages so caller-owned attachment cleanup includes records loaded here.
378 return removed;
379 });
380 };
381
382 return {
383 queuedMessagesByThreadKeyAtom,
384 serialize,
385 load,
386 enqueue,
387 confirmQueued,
388 revisionOf: (messageId: MessageId): number => revisions.get(messageId) ?? 0,
389 update,
390 modify,
391 remove,
392 clearEnvironment,
393 };
394 }