The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as Deferred from "effect/Deferred"; |
| 2 | import * as Effect from "effect/Effect"; |
| 3 | import * as FileSystem from "effect/FileSystem"; |
| 4 | import * as Option from "effect/Option"; |
| 5 | import * as Path from "effect/Path"; |
| 6 | |
| 7 | /** The SDK withholds stdout until tool results; tail task_started files for live output. |
| 8 | * The private Claude layout can change; failures omit live output and retain the final result. */ |
| 9 | |
| 10 | const CLAUDE_TASK_OUTPUT_POLL_MS = 250; |
| 11 | /** Bound discovery when Claude never writes the file. */ |
| 12 | const MAX_LOCATE_ATTEMPTS = 40; |
| 13 | /** Skip ahead of fast writers; only the tail is displayed. */ |
| 14 | const MAX_READ_BYTES = 256 * 1024; |
| 15 | |
| 16 | /** Claude Code's per-user temp root, or none where it has no uid (Windows). */ |
| 17 | export function claudeTaskOutputRoot( |
| 18 | environment: Readonly<Record<string, string | undefined>> | undefined, |
| 19 | path: Path.Path, |
| 20 | cwd: string | null, |
| 21 | platform: NodeJS.Platform, |
| 22 | ): string | undefined { |
| 23 | const uid = process.getuid?.(); |
| 24 | if (uid === undefined) return undefined; |
| 25 | // Claude Code's macOS build falls back to /tmp and ignores the TMPDIR that |
| 26 | // launchd always sets. Its other builds use `os.tmpdir()`, which reads these |
| 27 | // from the environment it was launched with. A relative value is relative |
| 28 | // to Claude's working directory, not this server's. |
| 29 | const fallback = |
| 30 | platform === "darwin" |
| 31 | ? "/tmp" |
| 32 | : environment?.TMPDIR || environment?.TMP || environment?.TEMP || "/tmp"; |
| 33 | const base = environment?.CLAUDE_CODE_TMPDIR?.trim() || fallback; |
| 34 | return path.resolve(cwd ?? ".", base, `claude-${uid}`); |
| 35 | } |
| 36 | |
| 37 | const locate = Effect.fn("ClaudeTaskOutputTail.locate")(function* (input: { |
| 38 | readonly root: string; |
| 39 | readonly sessionId: string; |
| 40 | readonly taskId: string; |
| 41 | }) { |
| 42 | const fileSystem = yield* FileSystem.FileSystem; |
| 43 | const path = yield* Path.Path; |
| 44 | const projects = yield* fileSystem.readDirectory(input.root).pipe(Effect.orElseSucceed(() => [])); |
| 45 | for (const project of projects) { |
| 46 | const candidate = path.join( |
| 47 | input.root, |
| 48 | project, |
| 49 | input.sessionId, |
| 50 | "tasks", |
| 51 | `${input.taskId}.output`, |
| 52 | ); |
| 53 | if (yield* fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false))) { |
| 54 | return Option.some(candidate); |
| 55 | } |
| 56 | } |
| 57 | return Option.none<string>(); |
| 58 | }); |
| 59 | |
| 60 | /** Complete stop on tool result or turn end, then await the effect; it performs a final read before returning. */ |
| 61 | export const tailClaudeTaskOutput = Effect.fn("ClaudeTaskOutputTail.tail")(function* (input: { |
| 62 | readonly root: string; |
| 63 | readonly sessionId: string; |
| 64 | readonly taskId: string; |
| 65 | readonly stop: Deferred.Deferred<void>; |
| 66 | readonly onChunk: (chunk: string) => Effect.Effect<void>; |
| 67 | }) { |
| 68 | const fileSystem = yield* FileSystem.FileSystem; |
| 69 | const pause = Deferred.await(input.stop).pipe( |
| 70 | Effect.as(true), |
| 71 | Effect.timeoutOrElse({ |
| 72 | duration: CLAUDE_TASK_OUTPUT_POLL_MS, |
| 73 | orElse: () => Effect.succeed(false), |
| 74 | }), |
| 75 | ); |
| 76 | let file = Option.none<string>(); |
| 77 | for (let attempt = 0; Option.isNone(file); attempt += 1) { |
| 78 | file = yield* locate(input); |
| 79 | if (Option.isSome(file)) break; |
| 80 | if (attempt + 1 >= MAX_LOCATE_ATTEMPTS || (yield* pause)) return; |
| 81 | } |
| 82 | const filePath = file.value; |
| 83 | let decoder = new TextDecoder("utf-8", { fatal: false }); |
| 84 | let offset = 0; |
| 85 | let last = yield* Deferred.isDone(input.stop); |
| 86 | while (true) { |
| 87 | const size = yield* fileSystem.stat(filePath).pipe( |
| 88 | Effect.map((info) => Number(info.size)), |
| 89 | Effect.orElseSucceed(() => offset), |
| 90 | ); |
| 91 | if (size < offset) { |
| 92 | offset = 0; |
| 93 | decoder = new TextDecoder("utf-8", { fatal: false }); |
| 94 | } |
| 95 | if (size > offset) { |
| 96 | const start = size - offset > MAX_READ_BYTES ? size - MAX_READ_BYTES : offset; |
| 97 | const bytes = yield* Effect.scoped( |
| 98 | Effect.gen(function* () { |
| 99 | const handle = yield* fileSystem.open(filePath, { flag: "r" }); |
| 100 | yield* handle.seek(BigInt(start), "start"); |
| 101 | return yield* handle.readAlloc(size - start); |
| 102 | }), |
| 103 | ).pipe(Effect.orElseSucceed(() => Option.none<Uint8Array>())); |
| 104 | if (Option.isSome(bytes)) { |
| 105 | // Skipped output must not splice two unrelated lines together. |
| 106 | const skipped = start > offset; |
| 107 | let first = 0; |
| 108 | if (skipped) { |
| 109 | // Reset partial UTF-8 bytes, and skip the rest of a code point the cut landed inside. |
| 110 | decoder = new TextDecoder("utf-8", { fatal: false }); |
| 111 | while (((bytes.value[first] ?? 0) & 0xc0) === 0x80) first += 1; |
| 112 | } |
| 113 | offset = start + bytes.value.byteLength; |
| 114 | const text = |
| 115 | (skipped ? "\n" : "") + decoder.decode(bytes.value.subarray(first), { stream: true }); |
| 116 | if (text.length > 0) yield* input.onChunk(text); |
| 117 | } |
| 118 | } |
| 119 | if (last) { |
| 120 | const rest = decoder.decode(); |
| 121 | if (rest.length > 0) yield* input.onChunk(rest); |
| 122 | return; |
| 123 | } |
| 124 | last = yield* pause; |
| 125 | } |
| 126 | }); |