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

main
ts 230 lines 8.01 KB
Raw
1 import type { ProviderApprovalDecision, ProviderApprovalOption } from "@t3tools/contracts";
2 import * as Schema from "effect/Schema";
3 import type * as EffectCodexSchema from "effect-codex-app-server/schema";
4
5 const NullableMcpElicitationString = Schema.NullOr(Schema.String);
6 const McpElicitationMetadata = Schema.Struct({
7 app: Schema.optionalKey(NullableMcpElicitationString),
8 app_name: Schema.optionalKey(NullableMcpElicitationString),
9 appName: Schema.optionalKey(NullableMcpElicitationString),
10 connector_name: Schema.optionalKey(NullableMcpElicitationString),
11 connectorName: Schema.optionalKey(NullableMcpElicitationString),
12 allowPersistentApproval: Schema.optionalKey(Schema.NullOr(Schema.Boolean)),
13 persist: Schema.optionalKey(
14 Schema.NullOr(Schema.Union([Schema.String, Schema.Array(Schema.String)])),
15 ),
16 target: Schema.optionalKey(
17 Schema.NullOr(
18 Schema.Struct({
19 app: Schema.optionalKey(NullableMcpElicitationString),
20 name: Schema.optionalKey(NullableMcpElicitationString),
21 }),
22 ),
23 ),
24 tool_params: Schema.optionalKey(
25 Schema.NullOr(
26 Schema.Struct({
27 app: Schema.optionalKey(NullableMcpElicitationString),
28 app_name: Schema.optionalKey(NullableMcpElicitationString),
29 }),
30 ),
31 ),
32 });
33 const McpElicitationFormField = Schema.Struct({
34 type: Schema.optionalKey(NullableMcpElicitationString),
35 title: Schema.optionalKey(NullableMcpElicitationString),
36 description: Schema.optionalKey(NullableMcpElicitationString),
37 default: Schema.optionalKey(Schema.Json),
38 enum: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.String))),
39 enumNames: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.String))),
40 oneOf: Schema.optionalKey(
41 Schema.NullOr(
42 Schema.Array(
43 Schema.Struct({
44 const: Schema.String,
45 title: Schema.optionalKey(NullableMcpElicitationString),
46 }),
47 ),
48 ),
49 ),
50 });
51 const McpElicitationForm = Schema.Struct({
52 properties: Schema.optionalKey(Schema.Record(Schema.String, McpElicitationFormField)),
53 required: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.String))),
54 });
55 const isMcpElicitationMetadata = Schema.is(McpElicitationMetadata);
56 const isMcpElicitationForm = Schema.is(McpElicitationForm);
57
58 type McpElicitationPersistenceDecision = Extract<
59 ProviderApprovalDecision,
60 "acceptForSession" | "acceptAlways"
61 >;
62
63 function mcpElicitationPersistenceDecision(
64 value: string,
65 ): McpElicitationPersistenceDecision | null {
66 const normalized = value.toLowerCase();
67 if (normalized.includes("session")) return "acceptForSession";
68 if (
69 normalized.includes("always") ||
70 normalized.includes("permanent") ||
71 normalized.includes("forever") ||
72 normalized.includes("persistent")
73 ) {
74 return "acceptAlways";
75 }
76 return null;
77 }
78
79 // Claude hands over the same MCP request with its own envelope; these are the
80 // only fields the response is built from.
81 type McpElicitationResponseInput = {
82 readonly mode: string;
83 readonly requestedSchema?: unknown;
84 };
85
86 function mcpElicitationFormFields(payload: McpElicitationResponseInput) {
87 if (payload.mode === "url" || !isMcpElicitationForm(payload.requestedSchema)) {
88 return undefined;
89 }
90 return payload.requestedSchema;
91 }
92
93 function mcpElicitationFieldOptions(field: typeof McpElicitationFormField.Type) {
94 if (field.oneOf) {
95 return field.oneOf.map((option) => ({ value: option.const, label: option.title }));
96 }
97 return (field.enum ?? []).map((value, index) => ({
98 value,
99 label: field.enumNames?.[index],
100 }));
101 }
102
103 function isMcpElicitationPersistenceField(
104 key: string,
105 field: typeof McpElicitationFormField.Type,
106 ): boolean {
107 return (
108 mcpElicitationPersistenceDecision(key) !== null ||
109 key.toLowerCase() === "persist" ||
110 mcpElicitationPersistenceDecision(field.title ?? "") !== null ||
111 mcpElicitationPersistenceDecision(field.description ?? "") !== null
112 );
113 }
114
115 export function describeMcpElicitation(
116 payload: EffectCodexSchema.McpServerElicitationRequestParams,
117 ): { readonly appName: string; readonly options: ReadonlyArray<ProviderApprovalOption> } {
118 const metadata = isMcpElicitationMetadata(payload._meta) ? payload._meta : undefined;
119 const appName =
120 metadata?.app_name ??
121 metadata?.appName ??
122 metadata?.app ??
123 metadata?.target?.app ??
124 metadata?.target?.name ??
125 metadata?.tool_params?.app_name ??
126 metadata?.tool_params?.app ??
127 payload.message.match(/^Allow ChatGPT to use (.+?)\?$/i)?.[1] ??
128 metadata?.connector_name ??
129 metadata?.connectorName ??
130 payload.serverName;
131 const persistenceOptions = new Map<McpElicitationPersistenceDecision, string>();
132 const persist = metadata?.persist;
133 for (const value of typeof persist === "string" ? [persist] : (persist ?? [])) {
134 const decision = mcpElicitationPersistenceDecision(value);
135 if (decision) persistenceOptions.set(decision, "");
136 }
137 if (metadata?.allowPersistentApproval) {
138 persistenceOptions.set("acceptAlways", "");
139 }
140
141 const form = mcpElicitationFormFields(payload);
142 for (const [key, field] of Object.entries(form?.properties ?? {})) {
143 for (const option of mcpElicitationFieldOptions(field)) {
144 const decision = mcpElicitationPersistenceDecision(option.value);
145 if (decision) persistenceOptions.set(decision, option.label ?? "");
146 }
147 if (field.type === "boolean" && isMcpElicitationPersistenceField(key, field)) {
148 persistenceOptions.set("acceptAlways", field.title ?? "");
149 }
150 }
151
152 return {
153 appName,
154 options: [
155 { decision: "cancel", label: "Cancel" },
156 { decision: "decline", label: "Decline" },
157 ...(persistenceOptions.has("acceptForSession") &&
158 toMcpElicitationResponse(payload, "acceptForSession").action === "accept"
159 ? [
160 {
161 decision: "acceptForSession" as const,
162 label: persistenceOptions.get("acceptForSession") || "Always allow this session",
163 },
164 ]
165 : []),
166 ...(persistenceOptions.has("acceptAlways") &&
167 toMcpElicitationResponse(payload, "acceptAlways").action === "accept"
168 ? [
169 {
170 decision: "acceptAlways" as const,
171 label: persistenceOptions.get("acceptAlways") || "Always allow",
172 },
173 ]
174 : []),
175 { decision: "accept", label: "Approve" },
176 ],
177 };
178 }
179
180 export function toMcpElicitationResponse(
181 payload: McpElicitationResponseInput,
182 decision: ProviderApprovalDecision,
183 ): EffectCodexSchema.McpServerElicitationRequestResponse {
184 if (decision === "decline" || decision === "cancel") {
185 return { action: decision };
186 }
187
188 // T3 cannot answer these itself. `decline` reads as the user's refusal, and Codex's browser
189 // plugin saves it as a thread-wide site denial; `cancel` leaves no saved decision.
190 if (payload.mode === "url") {
191 return { action: "cancel" };
192 }
193
194 const persist =
195 decision === "acceptForSession"
196 ? "session"
197 : decision === "acceptAlways"
198 ? "always"
199 : undefined;
200 const form = mcpElicitationFormFields(payload);
201 const content: Record<string, Schema.Json> = {};
202
203 for (const [key, field] of Object.entries(form?.properties ?? {})) {
204 const options = mcpElicitationFieldOptions(field);
205 const chosenOption = options.find((option) =>
206 persist
207 ? mcpElicitationPersistenceDecision(option.value) === decision
208 : /^(?:once|accept|approve|allow)(?:[_\s-]*(?:once(?:[_\s-]*only)?|this[_\s-]*time))?$/i.test(
209 option.value.trim(),
210 ) && mcpElicitationPersistenceDecision(option.value) === null,
211 );
212 if (chosenOption) {
213 content[key] = chosenOption.value;
214 } else if (field.type === "boolean" && isMcpElicitationPersistenceField(key, field)) {
215 content[key] = decision === "acceptAlways";
216 } else if (field.default !== undefined && field.default !== null) {
217 content[key] = field.default;
218 }
219 }
220
221 if (form?.required?.some((key) => !Object.hasOwn(content, key))) {
222 return { action: "cancel" };
223 }
224
225 return {
226 action: "accept",
227 ...(persist ? { _meta: { persist } } : {}),
228 ...(form ? { content } : {}),
229 };
230 }