@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 72 lines 2.8 KB
Raw
1 // @effect-diagnostics nodeBuiltinImport:off - Private local IPC framing, shared by server and lean CLI.
2 import type * as NodeNet from "node:net";
3 import * as Effect from "effect/Effect";
4 import * as Schema from "effect/Schema";
5
6 export const Request = Schema.Struct({
7 version: Schema.Literal(1),
8 instanceId: Schema.NonEmptyString,
9 environmentId: Schema.NonEmptyString,
10 profileKey: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/u)),
11 });
12 export const Response = Schema.Struct({ token: Schema.NonEmptyString });
13 // Selectors are small; tokens can be larger JWTs. Never truncate either frame
14 // into something that could be accepted.
15 export const REQUEST_BYTES = 1024;
16 export const RESPONSE_BYTES = 64 * 1024;
17 // Idle/incomplete peers and blocked response consumers must not retain sockets.
18 export const SOCKET_IDLE_MS = 5_000;
19 // Existing lock retry (40s), OAuth (20s), plus startup/store headroom (20s).
20 export const COMMAND_TIMEOUT_MS = 80_000;
21 class ProtocolError extends Schema.TaggedError<ProtocolError>()("ManagedTokenProtocolError", {}) {
22 override get message(): string {
23 return "The managed token frame was invalid or incomplete.";
24 }
25 }
26
27 export const readFrame = (socket: NodeNet.Socket, maxBytes: number, timeoutMs: number) =>
28 Effect.callback<string, ProtocolError>((resume) => {
29 let bytes = Buffer.alloc(0);
30 const fail = () => resume(Effect.fail(new ProtocolError()));
31 const onData = (chunk: Buffer) => {
32 if (bytes.length + chunk.length > maxBytes) return fail();
33 bytes = Buffer.concat([bytes, chunk]);
34 const end = bytes.indexOf(10);
35 if (end < 0) return;
36 if (end !== bytes.length - 1) return fail();
37 resume(Effect.succeed(bytes.subarray(0, end).toString("utf8")));
38 };
39 socket.on("data", onData);
40 socket.once("error", fail);
41 socket.once("close", fail);
42 socket.once("end", fail);
43 return Effect.sync(() => {
44 socket.off("data", onData);
45 socket.off("error", fail);
46 socket.off("close", fail);
47 socket.off("end", fail);
48 });
49 }).pipe(
50 Effect.timeoutOrElse({ duration: timeoutMs, orElse: () => Effect.fail(new ProtocolError()) }),
51 );
52
53 export const writeFrame = (socket: NodeNet.Socket, frame: string, maxBytes: number) =>
54 Effect.callback<void, ProtocolError>((resume) => {
55 if (socket.destroyed || Buffer.byteLength(frame) + 1 > maxBytes) {
56 resume(Effect.fail(new ProtocolError()));
57 return;
58 }
59 const fail = () => resume(Effect.fail(new ProtocolError()));
60 socket.once("error", fail);
61 socket.once("close", fail);
62 socket.end(`${frame}\n`, () => resume(Effect.void));
63 return Effect.sync(() => {
64 socket.off("error", fail);
65 socket.off("close", fail);
66 });
67 }).pipe(
68 Effect.timeoutOrElse({
69 duration: SOCKET_IDLE_MS,
70 orElse: () => Effect.fail(new ProtocolError()),
71 }),
72 );