import { useAtomValue } from "@effect/atom-react";
import {
AuthEnvironmentMaintainScope,
type AuthSessionState,
managedUpdatesDenial,
sessionGrantsScope,
} from "@t3tools/contracts";
import type { AsyncResult } from "effect/reactivity";
import { environmentSession } from "~/state/session";
import type {
DesktopUpdateChannel,
EnvironmentId,
ServerInstallation,
ServerSelfUpdateCapability,
} from "@t3tools/contracts";
import type { ServerUpdateStage, ServerUpdateState } from "@t3tools/client-runtime/state/server";
import {
isAtomCommandInterrupted,
settlePromise,
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
import { CircleArrowUpIcon } from "lucide-react";
import { type ComponentProps, useRef, useState } from "react";
import { requestConfirmDialog } from "~/confirmDialog";
import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
import { serverEnvironment, updateOutdatedServer } from "~/state/server";
import { appAtomRegistry } from "~/rpc/atomRegistry";
import { useAtomCommand } from "~/state/use-atom-command";
import { useServerConfigs } from "~/state/entities";
import { useManagedPolicy } from "~/state/managedPolicy";
import { environmentPresentations } from "~/state/presentation";
import { ManagedControl } from "./ManagedPolicy";
import { manualServerUpdateCommand } from "~/versionSkew";
import { crossesReleaseTrack } from "@t3tools/shared/cliRelease";
import { Button } from "./ui/button";
import { toastManager } from "./ui/toast";
import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
const UPDATE_STAGE_LABELS: Record<ServerUpdateStage, string> = {
downloading: "Downloading…",
installing: "Downloading…",
resuming: "Restarting…",
};
const pendingUpdateEnvironmentIds = new Set<EnvironmentId>();
export function serverUpdateStageLabel(stage: ServerUpdateStage): string {
return UPDATE_STAGE_LABELS[stage];
}
/** Why the environment's policy refuses server updates, read outside render. */
function readUpdatesDenial(environmentId: EnvironmentId): string | undefined {
return managedUpdatesDenial(
appAtomRegistry.get(environmentPresentations.serverConfigsAtom).get(environmentId)
?.managedPolicy,
);
}
const CROSS_TRACK_NOTE = "Switch tracks in About → Update track";
/** Hosts refuse a Stable/Nightly crossing outside a track switch, which checks the database first. */
function refusedCrossing(
target: {
readonly selfUpdate: ServerSelfUpdateCapability | null;
readonly targetVersion: string;
readonly channel?: DesktopUpdateChannel | undefined;
},
serverVersion: string | undefined,
): boolean {
return (
target.channel === undefined &&
target.selfUpdate !== null &&
serverVersion !== undefined &&
crossesReleaseTrack(serverVersion, target.targetVersion)
);
}
function CrossTrackNote() {
return <span className="text-muted-foreground text-xs">{CROSS_TRACK_NOTE}</span>;
}
function updateFailureMessage(error: unknown): string {
return error instanceof Error ? error.message : "Server update failed.";
}
export interface ServerUpdateTarget {
readonly environmentId: EnvironmentId;
readonly serverLabel: string;
readonly selfUpdate: ServerSelfUpdateCapability | null;
readonly installation?: ServerInstallation | undefined;
readonly desktopAppUpdate?: boolean;
readonly targetVersion: string;
/** Set only by a track switch; the host's desktop app moves to this track. */
readonly channel?: DesktopUpdateChannel;
/** A track switch's checked release migration; the host re-checks its own database. */
readonly targetDatabaseMigration?: number;
/** The host already runs its track's newest build and only saves the track. */
readonly trackOnly?: boolean;
}
type UpdateButtonProps = Pick<ComponentProps<typeof Button>, "variant" | "size" | "className"> & {
readonly label?: string;
readonly appearance?: "button" | "icon";
};
export type ServerUpdateOutcome =
| { readonly status: "updated" | "skipped" }
| { readonly status: "failed"; readonly message: string };
/** Toasts its success or failure unless `quiet`; never rejects. */
export function useServerUpdate() {
const updateServer = useAtomCommand(serverEnvironment.updateServer, { reportFailure: false });
return async (
target: ServerUpdateTarget,
{ quiet = false }: { readonly quiet?: boolean } = {},
): Promise<ServerUpdateOutcome> => {
const { environmentId, serverLabel, selfUpdate, targetVersion } = target;
const denial = readUpdatesDenial(environmentId);
if (denial !== undefined) {
if (!quiet) {
toastManager.add({
type: "error",
title: `${serverLabel} not updated`,
description: denial,
});
}
return { status: "failed", message: denial };
}
if (
!canUpdateServer(appAtomRegistry.get(environmentSession.sessionStateAtom(environmentId))) ||
pendingUpdateEnvironmentIds.has(environmentId)
)
return { status: "skipped" };
pendingUpdateEnvironmentIds.add(environmentId);
const result = await updateServer({
environmentId,
input: {
targetVersion,
...(target.channel === undefined ? {} : { channel: target.channel }),
...(target.targetDatabaseMigration === undefined
? {}
: { targetDatabaseMigration: target.targetDatabaseMigration }),
},
});
pendingUpdateEnvironmentIds.delete(environmentId);
if (result._tag === "Failure") {
if (isAtomCommandInterrupted(result)) return { status: "skipped" };
const message = updateFailureMessage(squashAtomCommandFailure(result));
if (!quiet) {
toastManager.add({
type: "error",
title: `${serverLabel} update failed`,
description: message,
});
}
return { status: "failed", message };
}
if (!quiet) {
toastManager.add({
type: "success",
title: `${serverLabel} updated`,
description:
selfUpdate === "desktop-managed"
? `Desktop app relaunched on ${result.value.targetVersion}.`
: `Reconnected on t3@${result.value.targetVersion}.`,
});
}
return { status: "updated" };
};
}
export function ServerUpdatesAction({
targets,
label = "Update all",
variant = "outline",
size = "xs",
className,
}: UpdateButtonProps & {
readonly targets: ReadonlyArray<ServerUpdateTarget>;
}) {
const update = useServerUpdate();
const serverConfigs = useServerConfigs();
const pending = useRef(false);
const [isPending, setIsPending] = useState(false);
const eligible = targets.filter(
(target) =>
target.selfUpdate !== null &&
(target.selfUpdate !== "desktop-managed" || target.desktopAppUpdate) &&
managedUpdatesDenial(serverConfigs.get(target.environmentId)?.managedPolicy) === undefined &&
!refusedCrossing(target, serverConfigs.get(target.environmentId)?.environment.serverVersion),
);
const handleUpdate = async () => {
if (pending.current) return;
pending.current = true;
setIsPending(true);
await settlePromise(async () => {
const available = eligible.filter(
(target) => !pendingUpdateEnvironmentIds.has(target.environmentId),
);
const desktopTargets = available.filter((target) => target.selfUpdate === "desktop-managed");
if (desktopTargets.length > 0) {
const confirmed =
(await requestConfirmDialog(
`Update the T3 Code desktop apps on ${desktopTargets.map((target) => target.serverLabel).join(", ")}? They will close and relaunch on those machines.`,
)) ?? true;
if (!confirmed) return;
}
await Promise.all(available.map((target) => update(target)));
});
pending.current = false;
setIsPending(false);
};
return (
<Button
size={size}
variant={variant}
className={className}
disabled={isPending || eligible.length === 0}
onClick={() => void handleUpdate()}
>
{label}
</Button>
);
}
export function canUpdateServer(
result: AsyncResult.AsyncResult<AuthSessionState, unknown>,
): boolean {
if (result._tag !== "Success" || !result.value.authenticated) return false;
return sessionGrantsScope(result.value, AuthEnvironmentMaintainScope);
}
export function ServerUpdateProgress({
state,
}: {
readonly state: Exclude<ServerUpdateState, { status: "idle" }>;
}) {
if (state.status === "failed") {
return (
<div className="mt-1 flex min-w-0 items-center gap-2 text-xs text-destructive" role="alert">
<span className="size-1.5 shrink-0 rounded-full bg-destructive" aria-hidden="true" />
<Tooltip>
<TooltipTrigger render={<span className="min-w-0 truncate">{state.message}</span>} />
<TooltipPopup side="top">{state.message}</TooltipPopup>
</Tooltip>
</div>
);
}
return (
<div className="mt-1 flex items-center gap-2 text-xs font-medium text-foreground">
<span className="size-1.5 shrink-0 rounded-full bg-foreground" aria-hidden="true" />
<span>{serverUpdateStageLabel(state.stage)}</span>
</div>
);
}
/** client-runtime owns self-updates so unmounting during reconnect preserves operation state. */
export function ServerUpdateAction({
environmentId,
serverLabel,
selfUpdate,
installation,
desktopAppUpdate = false,
targetVersion,
channel,
label = "Update",
variant = "outline",
size = "xs",
className,
appearance = "button",
}: ServerUpdateTarget & UpdateButtonProps) {
const isDesktopAppUpdate = selfUpdate === "desktop-managed";
const serverVersion = useServerConfigs().get(environmentId)?.environment.serverVersion;
const sessionStateAtom = environmentSession.sessionStateAtom(environmentId);
const canUpdate = useAtomValue(sessionStateAtom, canUpdateServer);
const updatesDenial = managedUpdatesDenial(useManagedPolicy(environmentId));
const update = useServerUpdate();
const { copyToClipboard } = useCopyToClipboard<{ command: string }>({
target: installation?.kind === "npm-global" ? "update command" : "relaunch command",
onCopy: ({ command }) => {
toastManager.add({
type: "success",
title:
installation?.kind === "npm-global" ? "Update command copied" : "Relaunch command copied",
description:
installation?.kind === "npm-global"
? `Run \`${command}\` on ${serverLabel}, then restart t3 with your usual options.`
: `Stop t3 on ${serverLabel}, then relaunch with \`${command}\` using the same subcommand and options. This does not update an installed t3 command.`,
});
},
onError: (error) => {
toastManager.add({
type: "error",
title: "Could not copy update command",
description: error.message,
});
},
});
const handleUpdate = async () => {
if (
!canUpdateServer(appAtomRegistry.get(sessionStateAtom)) ||
pendingUpdateEnvironmentIds.has(environmentId)
) {
return;
}
if (isDesktopAppUpdate) {
const confirmed =
(await requestConfirmDialog(
`Update the T3 Code desktop app that runs the ${serverLabel}? It will close and relaunch on that machine.`,
)) ?? true;
if (!confirmed) {
return;
}
}
if (!canUpdateServer(appAtomRegistry.get(sessionStateAtom))) return;
await update({
environmentId,
serverLabel,
selfUpdate,
desktopAppUpdate,
targetVersion,
});
};
if (updatesDenial !== undefined) {
return appearance === "icon" ? (
<ManagedControl reason={updatesDenial}>
<Button size="icon-xs" variant="ghost-muted" aria-label={updatesDenial} disabled>
<CircleArrowUpIcon className="size-3.5" />
</Button>
</ManagedControl>
) : (
<span className="text-muted-foreground text-xs">{updatesDenial}</span>
);
}
if (selfUpdate === "desktop-managed" && !desktopAppUpdate) {
return (
<span className="text-muted-foreground text-xs">
Update the desktop app on that machine to update this server.
</span>
);
}
if (refusedCrossing({ selfUpdate, targetVersion, channel }, serverVersion)) {
return <CrossTrackNote />;
}
const manualCommand =
selfUpdate === null ? manualServerUpdateCommand(targetVersion, installation) : null;
const actionLabel =
manualCommand !== null
? installation?.kind === "npm-global"
? "Copy update command"
: "Copy relaunch command"
: label;
const onClick =
manualCommand !== null
? () => copyToClipboard(manualCommand, { command: manualCommand })
: () => void handleUpdate();
if (appearance === "icon") {
return (
<Tooltip>
<TooltipTrigger
render={
<Button
size="icon-xs"
variant="ghost-muted"
className={className}
aria-label={`${actionLabel} for ${serverLabel}`}
disabled={manualCommand === null && !canUpdate}
onClick={onClick}
/>
}
>
<CircleArrowUpIcon className="size-3.5" />
</TooltipTrigger>
<TooltipPopup side="top">{actionLabel}</TooltipPopup>
</Tooltip>
);
}
return (
<Button
size={size}
variant={variant}
className={className}
disabled={manualCommand === null && !canUpdate}
onClick={onClick}
>
{actionLabel}
</Button>
);
}
/** Read the host descriptor's version because the host never delivers server config. */
export function OutdatedServerUpdateAction({
environmentId,
serverLabel,
fromVersion,
targetVersion,
label = "Update",
}: {
readonly environmentId: EnvironmentId;
readonly serverLabel: string;
readonly fromVersion: string | undefined;
readonly targetVersion: string;
readonly label?: string;
}) {
const update = useAtomCommand(updateOutdatedServer, { reportFailure: false });
const handleUpdate = async () => {
if (pendingUpdateEnvironmentIds.has(environmentId)) return;
pendingUpdateEnvironmentIds.add(environmentId);
const result = await update({
environmentId,
input: { targetVersion },
...(fromVersion === undefined ? {} : { fromVersion }),
});
pendingUpdateEnvironmentIds.delete(environmentId);
if (result._tag === "Failure") {
if (isAtomCommandInterrupted(result)) return;
toastManager.add({
type: "error",
title: `${serverLabel} update failed`,
description: updateFailureMessage(squashAtomCommandFailure(result)),
});
return;
}
toastManager.add({
type: "success",
title: `${serverLabel} updated`,
description: `Reconnected on t3@${result.value.targetVersion}.`,
});
};
if (fromVersion !== undefined && crossesReleaseTrack(fromVersion, targetVersion)) {
return <CrossTrackNote />;
}
return (
<Button size="xs" variant="outline" onClick={() => void handleUpdate()}>
{label}
</Button>
);
}