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

main
ts 647 lines 21.2 KB
Raw
1 import * as Cause from "effect/Cause";
2 import * as Deferred from "effect/Deferred";
3 import * as Duration from "effect/Duration";
4 import * as Effect from "effect/Effect";
5 import * as Exit from "effect/Exit";
6 import * as Fiber from "effect/Fiber";
7 import type * as FileSystem from "effect/FileSystem";
8 import * as Layer from "effect/Layer";
9 import type * as Path from "effect/Path";
10 import * as Queue from "effect/Queue";
11 import * as Sink from "effect/Sink";
12 import * as Stdio from "effect/Stdio";
13 import * as Stream from "effect/Stream";
14
15 import * as CursorAgentSdk from "./CursorAgentSdk.ts";
16 import {
17 type CursorWorkerMessage,
18 type CursorWorkerRequest,
19 type SerializedRunnerFailure,
20 decodeWorkerFrame,
21 encodeWorkerFrame,
22 serializeRunResult,
23 serializeWorkerError,
24 } from "./CursorAgentSdkWorkerProtocol.ts";
25 import * as CursorSdk from "./CursorSdk.ts";
26 import { runCursorTextGenerationInProcess } from "./textGeneration.ts";
27
28 const CLOSE_GRACE = Duration.seconds(3);
29
30 function toRunnerFailure(method: string, cause: unknown): SerializedRunnerFailure {
31 if (CursorAgentSdk.isCursorAgentSdkRunnerError(cause)) {
32 return {
33 method: cause.method,
34 cause: serializeWorkerError(cause.cause),
35 };
36 }
37 return {
38 method,
39 cause: serializeWorkerError(cause),
40 };
41 }
42
43 function exitFailure(
44 method: string,
45 exit: Exit.Failure<unknown, unknown>,
46 ): SerializedRunnerFailure {
47 const squashed = Cause.squash(exit.cause);
48 return toRunnerFailure(method, squashed);
49 }
50
51 /** Runs the Cursor SDK worker loop over Effect's `Stdio` service until `close` or stdin EOF. */
52 const runCursorSdkWorkerWithStdio = Effect.fn("CursorAgentSdkWorker.run")(function* (options?: {
53 readonly shutdownSignal?: Deferred.Deferred<void>;
54 }) {
55 const stdio = yield* Stdio.Stdio;
56 const cursorSdk = yield* CursorSdk.CursorSdk;
57 const workerScope = yield* Effect.scope;
58 const shutdownSignal = options?.shutdownSignal ?? (yield* Deferred.make<void>());
59 const outgoing = yield* Queue.unbounded<string, Cause.Done>();
60
61 const writerFiber = yield* Stream.fromQueue(outgoing).pipe(
62 Stream.run(stdio.stdout()),
63 Effect.ignoreCause,
64 Effect.forkScoped,
65 );
66
67 const writeMessage = (message: CursorWorkerMessage): void => {
68 Queue.offerUnsafe(outgoing, encodeWorkerFrame(message));
69 };
70
71 let activeSendStarts = 0;
72 // One worker hosts every Cursor session; each session is keyed by its open request id.
73 const sessions = new Map<number, CursorAgentSdk.CursorAgentSdkSession>();
74 const openingSessionIds = new Set<number>();
75 const pendingClosedSessionIds = new Set<number>();
76 // Other sessions keep the worker alive, so an abandoned generation must be interrupted here.
77 const textGenerations = new Map<number, Fiber.Fiber<unknown, unknown>>();
78 const activeRuns = new Map<
79 number,
80 { readonly sessionId: number; readonly run: CursorAgentSdk.CursorAgentSdkRun }
81 >();
82 const backgroundShellStops = new Map<string, () => void>();
83 const startingSendIds = new Set<number>();
84 const pendingCancelledSendIds = new Set<number>();
85 const sessionIdByOptions = new WeakMap<object, number>();
86 let shuttingDown = false;
87
88 const runner = yield* CursorAgentSdk.makeCursorAgentSdkRunner((input) => {
89 const boundSessionId = sessionIdByOptions.get(input.options);
90 return (event) =>
91 Effect.sync(() => {
92 if (activeSendStarts > 0 && event.payload.type === "run.cancel") {
93 writeMessage({
94 type: "protocolLog",
95 providerSessionId: input.providerSessionId,
96 ...(boundSessionId === undefined ? {} : { sessionId: boundSessionId }),
97 event,
98 });
99 }
100 });
101 });
102
103 // Untraced: called from closeSession/close/shutdown handlers that already carry spans.
104 const closeSession = Effect.fnUntraced(function* (
105 sessionId: number,
106 ): Effect.fn.Return<Exit.Exit<void, CursorAgentSdk.CursorAgentSdkRunnerError>> {
107 const shellPrefix = `${sessionId}:`;
108 for (const key of backgroundShellStops.keys()) {
109 if (key.startsWith(shellPrefix)) backgroundShellStops.delete(key);
110 }
111 if (openingSessionIds.has(sessionId)) {
112 pendingClosedSessionIds.add(sessionId);
113 }
114 const current = sessions.get(sessionId);
115 sessions.delete(sessionId);
116 for (const [sendId, entry] of activeRuns.entries()) {
117 if (entry.sessionId === sessionId) {
118 activeRuns.delete(sendId);
119 }
120 }
121 if (current === undefined) {
122 return Exit.void;
123 }
124 const closeExit = yield* Effect.exit(current.close.pipe(Effect.timeoutOption(CLOSE_GRACE)));
125 return Exit.isFailure(closeExit) ? closeExit : Exit.void;
126 });
127
128 // Untraced: shutdown helper invoked from close request or finalizer.
129 const closeAllSessions = Effect.fnUntraced(function* () {
130 const ids = Array.from(new Set([...sessions.keys(), ...openingSessionIds]));
131 return yield* Effect.forEach(ids, (sessionId) => closeSession(sessionId), {
132 concurrency: "unbounded",
133 });
134 });
135
136 // Untraced: dispatches one decoded worker request; inner runner operations carry spans.
137 const handleRequest = Effect.fnUntraced(function* (
138 req: CursorWorkerRequest,
139 ): Effect.fn.Return<void> {
140 if (shuttingDown && req.type !== "close") {
141 writeMessage({
142 type: "response",
143 id: req.id,
144 ok: false,
145 error: toRunnerFailure(req.type, new Error("Cursor SDK worker is shutting down.")),
146 });
147 return;
148 }
149
150 switch (req.type) {
151 case "open": {
152 openingSessionIds.add(req.id);
153 sessionIdByOptions.set(req.options, req.id);
154 const exit = yield* Effect.exit(
155 runner.open({
156 operation: req.operation,
157 ...(req.agentId === undefined ? {} : { agentId: req.agentId }),
158 ...(req.storeCwd === undefined ? {} : { storeCwd: req.storeCwd }),
159 options: req.options,
160 threadId: req.threadId,
161 providerSessionId: req.providerSessionId,
162 }),
163 ).pipe(
164 Effect.ensuring(
165 Effect.sync(() => {
166 openingSessionIds.delete(req.id);
167 }),
168 ),
169 );
170 if (Exit.isFailure(exit)) {
171 pendingClosedSessionIds.delete(req.id);
172 writeMessage({
173 type: "response",
174 id: req.id,
175 ok: false,
176 error: exitFailure("open", exit),
177 });
178 return;
179 }
180 if (pendingClosedSessionIds.delete(req.id)) {
181 yield* exit.value.close.pipe(Effect.timeoutOption(CLOSE_GRACE), Effect.ignore);
182 const aborted = Object.assign(new Error("Cursor session was closed while opening."), {
183 name: "AbortError",
184 });
185 writeMessage({
186 type: "response",
187 id: req.id,
188 ok: false,
189 error: toRunnerFailure("open", aborted),
190 });
191 return;
192 }
193 sessions.set(req.id, exit.value);
194 writeMessage({
195 type: "response",
196 id: req.id,
197 ok: true,
198 result: { agentId: exit.value.agentId },
199 });
200 return;
201 }
202
203 case "send": {
204 const session = sessions.get(req.sessionId);
205 if (session === undefined) {
206 writeMessage({
207 type: "response",
208 id: req.id,
209 ok: false,
210 error: toRunnerFailure("run.start", new Error("Cursor SDK session is not open.")),
211 });
212 return;
213 }
214 startingSendIds.add(req.id);
215 activeSendStarts += 1;
216 const exit = yield* Effect.exit(
217 session.send({
218 message: req.message,
219 ...(req.options === undefined ? {} : { options: req.options }),
220 ...(req.summarize === undefined ? {} : { summarize: req.summarize }),
221 ...(req.resume === undefined ? {} : { resume: req.resume }),
222 onDelta: (update) =>
223 Effect.sync(() => {
224 if (sessions.has(req.sessionId) && !pendingCancelledSendIds.has(req.id)) {
225 writeMessage({ type: "delta", sendId: req.id, update });
226 }
227 }),
228 ...(req.listenBackgroundShells === true
229 ? {
230 onBackgroundShell: (event: CursorAgentSdk.CursorBackgroundShellEvent) =>
231 Effect.sync(() => {
232 const key = `${req.sessionId}:${event.id}`;
233 if (event.type === "started") {
234 backgroundShellStops.set(key, event.stop);
235 writeMessage({
236 type: "backgroundShell",
237 sessionId: req.sessionId,
238 event: {
239 type: "started",
240 id: event.id,
241 pid: event.pid,
242 command: event.command,
243 },
244 });
245 return;
246 }
247 backgroundShellStops.delete(key);
248 writeMessage({
249 type: "backgroundShell",
250 sessionId: req.sessionId,
251 event,
252 });
253 }),
254 }
255 : {}),
256 }),
257 ).pipe(
258 Effect.ensuring(
259 Effect.sync(() => {
260 startingSendIds.delete(req.id);
261 activeSendStarts -= 1;
262 }),
263 ),
264 );
265 if (Exit.isFailure(exit)) {
266 pendingCancelledSendIds.delete(req.id);
267 writeMessage({
268 type: "response",
269 id: req.id,
270 ok: false,
271 error: exitFailure(req.resume === true ? "run.resume" : "run.start", exit),
272 });
273 return;
274 }
275 const run = exit.value;
276 // Session closed or cancel arrived while send was starting: stop the run immediately.
277 if (!sessions.has(req.sessionId) || pendingCancelledSendIds.delete(req.id)) {
278 yield* run.cancel.pipe(Effect.timeoutOption(CLOSE_GRACE), Effect.ignore);
279 const aborted = Object.assign(new Error("Cursor run was cancelled while starting."), {
280 name: "AbortError",
281 });
282 writeMessage({
283 type: "response",
284 id: req.id,
285 ok: false,
286 error: toRunnerFailure(req.resume === true ? "run.resume" : "run.start", aborted),
287 });
288 return;
289 }
290 activeRuns.set(req.id, { sessionId: req.sessionId, run });
291 writeMessage({
292 type: "response",
293 id: req.id,
294 ok: true,
295 result: { runId: run.runId, agentId: run.agentId },
296 });
297 yield* Effect.exit(run.wait).pipe(
298 Effect.tap((waitExit) =>
299 Effect.sync(() => {
300 activeRuns.delete(req.id);
301 if (Exit.isFailure(waitExit)) {
302 writeMessage({
303 type: "runDone",
304 sendId: req.id,
305 ok: false,
306 error: exitFailure("run.wait", waitExit),
307 });
308 return;
309 }
310 writeMessage({
311 type: "runDone",
312 sendId: req.id,
313 ok: true,
314 result: serializeRunResult(waitExit.value),
315 });
316 }),
317 ),
318 Effect.asVoid,
319 Effect.forkIn(workerScope),
320 );
321 return;
322 }
323
324 case "stopBackgroundShell": {
325 const key = `${req.sessionId}:${req.shellId}`;
326 const stop = backgroundShellStops.get(key);
327 backgroundShellStops.delete(key);
328 yield* Effect.try({ try: () => stop?.(), catch: () => undefined }).pipe(Effect.ignore);
329 writeMessage({ type: "response", id: req.id, ok: true, result: null });
330 return;
331 }
332
333 case "steer": {
334 const entry = activeRuns.get(req.sendId);
335 if (entry?.run.steer === undefined) {
336 writeMessage({
337 type: "response",
338 id: req.id,
339 ok: true,
340 result: "revert_to_followup",
341 });
342 return;
343 }
344 const exit = yield* Effect.exit(entry.run.steer(req.text));
345 if (Exit.isFailure(exit)) {
346 writeMessage({
347 type: "response",
348 id: req.id,
349 ok: false,
350 error: exitFailure("run.steer", exit),
351 });
352 return;
353 }
354 writeMessage({ type: "response", id: req.id, ok: true, result: exit.value });
355 return;
356 }
357
358 case "cancel": {
359 const entry = activeRuns.get(req.sendId);
360 if (entry === undefined) {
361 if (startingSendIds.has(req.sendId)) {
362 pendingCancelledSendIds.add(req.sendId);
363 }
364 writeMessage({ type: "response", id: req.id, ok: true, result: null });
365 return;
366 }
367 const exit = yield* Effect.exit(entry.run.cancel);
368 if (Exit.isFailure(exit)) {
369 writeMessage({
370 type: "response",
371 id: req.id,
372 ok: false,
373 error: exitFailure("run.cancel", exit),
374 });
375 return;
376 }
377 writeMessage({ type: "response", id: req.id, ok: true, result: null });
378 return;
379 }
380
381 case "listMessages": {
382 const session = sessions.get(req.sessionId);
383 if (session === undefined) {
384 writeMessage({
385 type: "response",
386 id: req.id,
387 ok: false,
388 error: toRunnerFailure(
389 "agent.messages.list",
390 new Error("Cursor SDK session is not open."),
391 ),
392 });
393 return;
394 }
395 const exit = yield* Effect.exit(session.listMessages);
396 if (Exit.isFailure(exit)) {
397 writeMessage({
398 type: "response",
399 id: req.id,
400 ok: false,
401 error: exitFailure("agent.messages.list", exit),
402 });
403 return;
404 }
405 writeMessage({ type: "response", id: req.id, ok: true, result: exit.value });
406 return;
407 }
408
409 case "readContextUsage": {
410 const session = sessions.get(req.sessionId);
411 if (session?.readContextUsage === undefined) {
412 writeMessage({ type: "response", id: req.id, ok: true, result: null });
413 return;
414 }
415 const exit = yield* Effect.exit(session.readContextUsage);
416 if (Exit.isFailure(exit)) {
417 writeMessage({
418 type: "response",
419 id: req.id,
420 ok: false,
421 error: exitFailure("agent.checkpoint.load", exit),
422 });
423 return;
424 }
425 writeMessage({ type: "response", id: req.id, ok: true, result: exit.value ?? null });
426 return;
427 }
428
429 case "runCheckpointed": {
430 const session = sessions.get(req.sessionId);
431 if (session?.runCheckpointed === undefined) {
432 writeMessage({ type: "response", id: req.id, ok: true, result: false });
433 return;
434 }
435 const exit = yield* Effect.exit(session.runCheckpointed(req.runId));
436 if (Exit.isFailure(exit)) {
437 writeMessage({
438 type: "response",
439 id: req.id,
440 ok: false,
441 error: exitFailure("agent.run.get", exit),
442 });
443 return;
444 }
445 writeMessage({ type: "response", id: req.id, ok: true, result: exit.value });
446 return;
447 }
448
449 case "rewindAfterRun": {
450 const session = sessions.get(req.sessionId);
451 if (session?.rewindAfterRun === undefined) {
452 writeMessage({ type: "response", id: req.id, ok: true, result: null });
453 return;
454 }
455 const exit = yield* Effect.exit(session.rewindAfterRun(req.runId));
456 if (Exit.isFailure(exit)) {
457 writeMessage({
458 type: "response",
459 id: req.id,
460 ok: false,
461 error: exitFailure("agent.rewind", exit),
462 });
463 return;
464 }
465 writeMessage({ type: "response", id: req.id, ok: true, result: null });
466 return;
467 }
468
469 case "textGenerate": {
470 const fiber = yield* Effect.forkIn(
471 runCursorTextGenerationInProcess(req).pipe(
472 Effect.provideService(CursorSdk.CursorSdk, cursorSdk),
473 ),
474 workerScope,
475 );
476 textGenerations.set(req.id, fiber);
477 const exit = yield* Fiber.await(fiber).pipe(
478 Effect.ensuring(
479 Effect.sync(() => {
480 textGenerations.delete(req.id);
481 }),
482 ),
483 );
484 if (Exit.isFailure(exit)) {
485 writeMessage({
486 type: "response",
487 id: req.id,
488 ok: false,
489 error: exitFailure("textGenerate", exit),
490 });
491 return;
492 }
493 writeMessage({
494 type: "response",
495 id: req.id,
496 ok: true,
497 result: serializeRunResult(exit.value),
498 });
499 return;
500 }
501
502 case "cancelTextGenerate": {
503 const fiber = textGenerations.get(req.textGenerateId);
504 if (fiber !== undefined) {
505 yield* Effect.forkIn(Fiber.interrupt(fiber), workerScope);
506 }
507 writeMessage({ type: "response", id: req.id, ok: true, result: null });
508 return;
509 }
510
511 case "closeSession": {
512 const exit = yield* closeSession(req.sessionId);
513 writeMessage(
514 Exit.isFailure(exit)
515 ? { type: "response", id: req.id, ok: false, error: exitFailure("agent.close", exit) }
516 : { type: "response", id: req.id, ok: true, result: null },
517 );
518 return;
519 }
520
521 case "close": {
522 shuttingDown = true;
523 const exits = yield* closeAllSessions();
524 const exit = exits.find(Exit.isFailure) ?? Exit.void;
525 if (Exit.isFailure(exit)) {
526 writeMessage({
527 type: "response",
528 id: req.id,
529 ok: false,
530 error: exitFailure("agent.close", exit),
531 });
532 } else {
533 writeMessage({ type: "response", id: req.id, ok: true, result: null });
534 }
535 yield* Deferred.succeed(shutdownSignal, undefined);
536 return;
537 }
538 }
539 });
540
541 const dispatchLine = (line: string): Effect.Effect<void> => {
542 if (line.trim().length === 0) return Effect.void;
543 let parsed: CursorWorkerRequest;
544 try {
545 parsed = decodeWorkerFrame(line) as CursorWorkerRequest;
546 } catch (cause) {
547 return Effect.logWarning("Invalid Cursor SDK worker frame.", { cause });
548 }
549 return handleRequest(parsed).pipe(
550 Effect.catchCause((cause) =>
551 Effect.sync(() => {
552 writeMessage({
553 type: "response",
554 id: parsed.id,
555 ok: false,
556 error: toRunnerFailure(parsed.type, Cause.squash(cause)),
557 });
558 }),
559 ),
560 Effect.forkIn(workerScope),
561 Effect.asVoid,
562 );
563 };
564
565 yield* stdio.stdin.pipe(
566 Stream.interruptWhen(Deferred.await(shutdownSignal)),
567 Stream.decodeText(),
568 Stream.splitLines,
569 Stream.runForEach(dispatchLine),
570 Effect.ignoreCause,
571 );
572
573 shuttingDown = true;
574 yield* Effect.forEach(Array.from(textGenerations.values()), (fiber) => Fiber.interrupt(fiber), {
575 concurrency: "unbounded",
576 discard: true,
577 });
578 yield* closeAllSessions().pipe(Effect.ignore);
579 yield* Queue.end(outgoing);
580 yield* Fiber.await(writerFiber).pipe(Effect.timeoutOption(CLOSE_GRACE), Effect.ignore);
581 });
582
583 export async function runCursorSdkWorker(
584 platformLayer: Layer.Layer<FileSystem.FileSystem | Path.Path | Stdio.Stdio>,
585 ): Promise<void> {
586 // Electron has already booted in Node mode; strip the flag so agent shells do not inherit it.
587 delete process.env.ELECTRON_RUN_AS_NODE;
588
589 // Reserve fd 1 exclusively for NDJSON frames; redirect stray SDK logs to stderr.
590 const rawStdoutWrite = process.stdout.write.bind(process.stdout);
591 const stderrWrite = process.stderr.write.bind(process.stderr);
592 process.stdout.on("error", () => {});
593 process.stderr.on("error", () => {});
594 process.stdout.write = stderrWrite as typeof process.stdout.write;
595 console.log = console.info = console.debug = console.warn = console.error;
596
597 const rawStdoutSink = Sink.forEach((chunk: string | Uint8Array) =>
598 Effect.callback<void>((resume) => {
599 try {
600 rawStdoutWrite(chunk, () => resume(Effect.void));
601 } catch {
602 resume(Effect.void);
603 }
604 }),
605 );
606
607 const workerStdioLayer = Layer.effect(
608 Stdio.Stdio,
609 Effect.map(Stdio.Stdio, (baseStdio) =>
610 Stdio.make({
611 args: baseStdio.args,
612 stdin: baseStdio.stdin,
613 stdout: () => rawStdoutSink,
614 stderr: baseStdio.stderr,
615 }),
616 ),
617 );
618
619 const program = Effect.scoped(
620 Effect.gen(function* () {
621 const shutdownSignal = yield* Deferred.make<void>();
622 const onSignal = () => {
623 Deferred.doneUnsafe(shutdownSignal, Exit.void);
624 };
625 yield* Effect.acquireRelease(
626 Effect.sync(() => {
627 process.on("SIGTERM", onSignal);
628 process.on("SIGINT", onSignal);
629 }),
630 () =>
631 Effect.sync(() => {
632 process.off("SIGTERM", onSignal);
633 process.off("SIGINT", onSignal);
634 }),
635 );
636 yield* runCursorSdkWorkerWithStdio({ shutdownSignal });
637 }),
638 ).pipe(
639 Effect.provide(
640 Layer.mergeAll(CursorSdk.layer, workerStdioLayer).pipe(Layer.provideMerge(platformLayer)),
641 ),
642 );
643
644 await Effect.runPromise(program);
645 // SDK keep-alive handles can outlive session disposal; exit explicitly once stdout has flushed.
646 process.exit(0);
647 }