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

main
ts 182 lines 6.45 KB
Raw
1 import { thrownErrorMessage } from "@t3tools/client-runtime/errors";
2 import { AuthOrchestrationOperateScope, type ProjectIconOverride } from "@t3tools/contracts";
3 import {
4 isAtomCommandInterrupted,
5 mapAtomCommandResult,
6 squashAtomCommandFailure,
7 type AtomCommandResult,
8 } from "@t3tools/client-runtime/state/runtime";
9 import { AsyncResult } from "effect/reactivity";
10 import * as Cause from "effect/Cause";
11 import { msg } from "gt-react";
12
13 import { stackedThreadToast, toastManager } from "../components/ui/toast";
14 import { m } from "../i18n/messages";
15 import type { SidebarProjectGroupMember } from "../sidebarProjectGrouping";
16 import { useProjects, useServerConfigs } from "../state/entities";
17 import { readEnvironment } from "../state/environments";
18 import { projectEnvironment } from "../state/projects";
19 import { readEnvironmentScope, useEnvironmentsWithScope } from "../state/session";
20 import { useOrchestrationCommand } from "../state/use-orchestration-command";
21
22 export type ProjectGroupUpdate = Partial<{
23 title: string;
24 faviconPath: string | null;
25 projectIcon: ProjectIconOverride | null;
26 pinned: boolean;
27 archived: boolean;
28 }>;
29
30 type ProjectGroupMember = Pick<
31 SidebarProjectGroupMember,
32 "environmentId" | "id" | "environmentLabel"
33 >;
34
35 /**
36 * Writes one update to each checkout of a project, one machine at a time, and
37 * reports the first failure as a toast. Every machine must be connected first.
38 */
39 export function useProjectGroupUpdate() {
40 const serverConfigs = useServerConfigs();
41 const updateProject = useOrchestrationCommand(projectEnvironment.update, {
42 reportFailure: false,
43 });
44
45 const updateProjectGroup = async <TMember extends ProjectGroupMember>(
46 members: ReadonlyArray<TMember>,
47 input: ProjectGroupUpdate | ((member: TMember) => ProjectGroupUpdate),
48 failureTitle: string,
49 ): Promise<AtomCommandResult<void, unknown>> => {
50 const denied = checkProjectAccess(members, failureTitle);
51 if (denied) return denied;
52 const unavailable = members.find((member) => {
53 const environment = readEnvironment(member.environmentId);
54 return environment?.connection.phase !== "connected" || !environment.serverConfig;
55 });
56 if (unavailable) {
57 return failWith(
58 failureTitle,
59 unavailable.environmentLabel == null
60 ? m(msg("Connect the selected environment and try again."))
61 : m(
62 msg("Connect {environment} and try again.", {
63 environment: unavailable.environmentLabel,
64 }),
65 ),
66 );
67 }
68 for (const member of members) {
69 // Access can be revoked between writes.
70 const revoked = checkProjectAccess([member], failureTitle);
71 if (revoked) return revoked;
72 const result = mapAtomCommandResult(
73 await updateProject({
74 environmentId: member.environmentId,
75 input: {
76 projectId: member.id,
77 ...(typeof input === "function" ? input(member) : input),
78 },
79 }),
80 () => undefined,
81 );
82 if (result._tag === "Failure") {
83 reportProjectFailure(
84 members.length > 1
85 ? member.environmentLabel == null
86 ? m(msg("{title} on the current environment", { title: failureTitle }))
87 : m(
88 msg("{title} on {environment}", {
89 title: failureTitle,
90 environment: member.environmentLabel,
91 }),
92 )
93 : failureTitle,
94 result,
95 );
96 return result;
97 }
98 }
99 return AsyncResult.success(undefined);
100 };
101
102 /** Older servers drop pin and archive, so their projects do not offer them. */
103 const canOrganizeProjectGroup = (members: ReadonlyArray<ProjectGroupMember>) =>
104 members.every(
105 (member) =>
106 serverConfigs.get(member.environmentId)?.environment.capabilities.projectOrganization ===
107 true,
108 );
109
110 return { updateProjectGroup, canOrganizeProjectGroup };
111 }
112
113 /** Pin state for a project group, shared by every list that can pin or unpin a project. */
114 export function useProjectPin() {
115 const { updateProjectGroup, canOrganizeProjectGroup } = useProjectGroupUpdate();
116 const environments = [...new Set(useProjects().map((project) => project.environmentId))].map(
117 (environmentId) => ({ environmentId }),
118 );
119 const operableEnvironmentIds = useEnvironmentsWithScope(
120 environments,
121 AuthOrchestrationOperateScope,
122 );
123 type PinnableGroup = {
124 readonly memberProjects: ReadonlyArray<ProjectGroupMember>;
125 readonly pinned: boolean;
126 };
127 const canPinProjectGroup = (group: PinnableGroup) =>
128 canOrganizeProjectGroup(group.memberProjects) &&
129 group.memberProjects.every((member) => operableEnvironmentIds.has(member.environmentId));
130 const setProjectGroupPinned = (group: PinnableGroup, pinned: boolean) => {
131 void updateProjectGroup(
132 group.memberProjects,
133 { pinned },
134 pinned ? m(msg("Failed to pin project")) : m(msg("Failed to unpin project")),
135 );
136 };
137 return {
138 canPinProjectGroup,
139 setProjectGroupPinned,
140 toggleProjectGroupPin: (group: PinnableGroup) => setProjectGroupPinned(group, !group.pinned),
141 };
142 }
143
144 /** Reports the first member this connection cannot change, and returns that failure. */
145 export function checkProjectAccess(
146 members: ReadonlyArray<ProjectGroupMember>,
147 failureTitle: string,
148 ): AtomCommandResult<void, unknown> | null {
149 const denied = members.find(
150 (member) => !readEnvironmentScope(member.environmentId, AuthOrchestrationOperateScope),
151 );
152 return denied
153 ? failWith(
154 failureTitle,
155 denied.environmentLabel == null
156 ? m(msg("This connection cannot change projects in this environment."))
157 : m(
158 msg("This connection cannot change projects in {environment}.", {
159 environment: denied.environmentLabel,
160 }),
161 ),
162 )
163 : null;
164 }
165
166 export function reportProjectFailure(title: string, result: AtomCommandResult<unknown, unknown>) {
167 if (result._tag !== "Failure" || isAtomCommandInterrupted(result)) return;
168 const error = squashAtomCommandFailure(result);
169 toastManager.add(
170 stackedThreadToast({
171 type: "error",
172 title,
173 description: thrownErrorMessage(error, m) ?? m(msg("An error occurred.")),
174 }),
175 );
176 }
177
178 function failWith(title: string, message: string): AtomCommandResult<void, unknown> {
179 const result = AsyncResult.failure<void, Error>(Cause.fail(new Error(message)));
180 reportProjectFailure(title, result);
181 return result;
182 }