@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 168 lines 6.02 KB
Raw
1 import type {
2 AuthAccessSnapshot,
3 AuthApproveConnectDeviceInput,
4 AuthRevokeConnectDeviceInput,
5 AuthAccessStreamEvent,
6 AuthAccessStreamSnapshotEvent,
7 AuthCreatePairingCredentialInput,
8 AuthRevokeClientSessionInput,
9 AuthRevokePairingLinkInput,
10 } from "@t3tools/contracts";
11 import { WS_METHODS } from "@t3tools/contracts";
12 import * as Effect from "effect/Effect";
13 import type { HttpClient } from "effect/http";
14 import * as Stream from "effect/Stream";
15 import { Atom } from "effect/reactivity";
16
17 import type { EnvironmentRegistry } from "../connection/registry.ts";
18 import { subscribe } from "../rpc/client.ts";
19 import { executeConnectedEnvironmentHttpRequest } from "./environmentHttpAuth.ts";
20 import { createEnvironmentCommand, createEnvironmentSubscriptionAtomFamily } from "./runtime.ts";
21
22 const ACCESS_REQUEST_TIMEOUT_MS = 8_000;
23
24 export const EMPTY_AUTH_ACCESS_SNAPSHOT: AuthAccessSnapshot = {
25 pairingLinks: [],
26 clientSessions: [],
27 };
28
29 function upsertByKey<A>(
30 values: ReadonlyArray<A>,
31 next: A,
32 key: (value: A) => string,
33 ): ReadonlyArray<A> {
34 const nextKey = key(next);
35 return [...values.filter((value) => key(value) !== nextKey), next];
36 }
37
38 export function applyAuthAccessStreamEvent(
39 current: AuthAccessSnapshot,
40 event: AuthAccessStreamEvent,
41 ): AuthAccessSnapshot {
42 switch (event.type) {
43 case "snapshot":
44 return event.payload;
45 case "pairingLinkUpserted":
46 return {
47 ...current,
48 pairingLinks: upsertByKey(current.pairingLinks, event.payload, (value) => value.id),
49 };
50 case "pairingLinkRemoved":
51 return {
52 ...current,
53 pairingLinks: current.pairingLinks.filter((value) => value.id !== event.payload.id),
54 };
55 case "clientUpserted":
56 return {
57 ...current,
58 clientSessions: upsertByKey(
59 current.clientSessions,
60 event.payload,
61 (value) => value.sessionId,
62 ),
63 };
64 case "clientRemoved":
65 return {
66 ...current,
67 clientSessions: current.clientSessions.filter(
68 (value) => value.sessionId !== event.payload.sessionId,
69 ),
70 };
71 }
72 }
73
74 function projectAuthAccessSnapshot(
75 current: AuthAccessSnapshot,
76 event: AuthAccessStreamEvent,
77 ): readonly [AuthAccessSnapshot, ReadonlyArray<AuthAccessStreamEvent>] {
78 const snapshot = applyAuthAccessStreamEvent(current, event);
79 const projected: AuthAccessStreamSnapshotEvent = {
80 version: 1,
81 revision: event.revision,
82 type: "snapshot",
83 payload: snapshot,
84 };
85 return [snapshot, [projected]];
86 }
87
88 /** Access management runs on the chosen environment with this client's own session there. */
89 export function createAuthEnvironmentAtoms<R, E>(
90 runtime: Atom.AtomRuntime<EnvironmentRegistry | HttpClient.HttpClient | R, E>,
91 ) {
92 return {
93 createPairingCredential: createEnvironmentCommand(runtime, {
94 label: "environment-data:server:auth-create-pairing-credential",
95 execute: (input: AuthCreatePairingCredentialInput) =>
96 executeConnectedEnvironmentHttpRequest({
97 group: "auth",
98 method: "POST",
99 url: (urls) => urls.pairingCredential(),
100 timeoutMs: ACCESS_REQUEST_TIMEOUT_MS,
101 request: ({ client, headers }) => client.pairingCredential({ headers, payload: input }),
102 }),
103 }),
104 revokePairingLink: createEnvironmentCommand(runtime, {
105 label: "environment-data:server:auth-revoke-pairing-link",
106 execute: (input: AuthRevokePairingLinkInput) =>
107 executeConnectedEnvironmentHttpRequest({
108 group: "auth",
109 method: "POST",
110 url: (urls) => urls.revokePairingLink(),
111 timeoutMs: ACCESS_REQUEST_TIMEOUT_MS,
112 request: ({ client, headers }) => client.revokePairingLink({ headers, payload: input }),
113 }),
114 }),
115 revokeClient: createEnvironmentCommand(runtime, {
116 label: "environment-data:server:auth-revoke-client",
117 execute: (input: AuthRevokeClientSessionInput) =>
118 executeConnectedEnvironmentHttpRequest({
119 group: "auth",
120 method: "POST",
121 url: (urls) => urls.revokeClient(),
122 timeoutMs: ACCESS_REQUEST_TIMEOUT_MS,
123 request: ({ client, headers }) => client.revokeClient({ headers, payload: input }),
124 }),
125 }),
126 revokeOtherClients: createEnvironmentCommand(runtime, {
127 label: "environment-data:server:auth-revoke-other-clients",
128 execute: (_input: null) =>
129 executeConnectedEnvironmentHttpRequest({
130 group: "auth",
131 method: "POST",
132 url: (urls) => urls.revokeOtherClients(),
133 timeoutMs: ACCESS_REQUEST_TIMEOUT_MS,
134 request: ({ client, headers }) => client.revokeOtherClients({ headers }),
135 }).pipe(Effect.map((result) => result.revokedCount)),
136 }),
137 approveConnectDevice: createEnvironmentCommand(runtime, {
138 label: "environment-data:server:auth-approve-connect-device",
139 execute: (input: AuthApproveConnectDeviceInput) =>
140 executeConnectedEnvironmentHttpRequest({
141 group: "auth",
142 method: "POST",
143 url: (urls) => urls.approveConnectDevice(),
144 timeoutMs: ACCESS_REQUEST_TIMEOUT_MS,
145 request: ({ client, headers }) =>
146 client.approveConnectDevice({ headers, payload: input }),
147 }),
148 }),
149 revokeConnectDevice: createEnvironmentCommand(runtime, {
150 label: "environment-data:server:auth-revoke-connect-device",
151 execute: (input: AuthRevokeConnectDeviceInput) =>
152 executeConnectedEnvironmentHttpRequest({
153 group: "auth",
154 method: "POST",
155 url: (urls) => urls.revokeConnectDevice(),
156 timeoutMs: ACCESS_REQUEST_TIMEOUT_MS,
157 request: ({ client, headers }) => client.revokeConnectDevice({ headers, payload: input }),
158 }),
159 }),
160 accessChanges: createEnvironmentSubscriptionAtomFamily(runtime, {
161 label: "environment-data:server:auth-access-changes",
162 subscribe: (_input: null) =>
163 subscribe(WS_METHODS.subscribeAuthAccess, {}).pipe(
164 Stream.mapAccum(() => EMPTY_AUTH_ACCESS_SNAPSHOT, projectAuthAccessSnapshot),
165 ),
166 }),
167 };
168 }