import { DeviceHostUpdates } from "./DeviceHostUpdates";
import type { DevicePlatform, DeviceServiceState, EnvironmentId } from "@t3tools/contracts";
import { Check } from "lucide-react";
import { Check as CheckGlyph, CircleAlert } from "lucide";
import { AuthSettingsWriteScope } from "@t3tools/contracts";
import { useAtomMount } from "@effect/atom-react";
import { useState } from "react";
import { Button } from "~/components/ui/button";
import { DialogClose } from "~/components/ui/dialog";
import { MorphIcon } from "~/components/MorphIcon";
import { WizardHeader, WizardPanel, WizardSteps, WizardFooter } from "~/components/ui/wizard";
import { Spinner } from "~/components/ui/spinner";
import { Switch } from "~/components/ui/switch";
import { deviceEnvironment, deviceHostProbeAtom, NO_DEVICE_PROBE_ATOM } from "~/state/device";
import { useAtomCommand } from "~/state/use-atom-command";
import { readEnvironmentScope, useEnvironmentScope } from "~/state/session";
import { cn } from "~/lib/utils";
const platformName = (platform: DevicePlatform) => (platform === "ios" ? "iOS" : "Android");
const deviceHubDescription =
"Enable this environment to open simulators and emulators, whether they run here or on a remote device host.";
const agentDeviceDescription =
"Allow new agent sessions in this environment to start and control local and remote devices, with required tools set up automatically.";
/** Platforms whose latest listing on a ready host may be missing devices. */
export const incompleteListings = (
status: DeviceServiceState["hostStatuses"][string] | undefined,
) =>
(["ios", "android"] as const).filter(
(platform) =>
status?.status === "ready" &&
(status.incompletePlatforms?.includes(platform) ||
(platform === "android" && status.androidDiscoveryIncomplete === true)),
);
export const isAndroidDiscoveryUncertain = (state: DeviceServiceState) =>
Object.values(state.hostStatuses).some((status) =>
incompleteListings(status).includes("android"),
);
/**
* `hostStatus` only tracks this machine. A machine without simulator tooling never
* starts its own hub, so setup and the panel must also count remote device hosts.
*/
export function deviceHubReadiness(state: DeviceServiceState) {
const statuses = Object.values(state.hostStatuses).map((host) => host.status);
const ready = state.hostStatus === "ready" || statuses.includes("ready");
const busy =
!ready &&
[state.hostStatus, ...statuses].some(
(status) => status === "installing" || status === "starting",
);
return { ready, busy };
}
/** A ready host keeps its devices usable but may still carry a discovery warning. */
function deviceHostDiagnostics(
hosts: ReadonlyArray<Pick<DeviceServiceState["hosts"][number], "id" | "label">>,
hostStatuses: DeviceServiceState["hostStatuses"],
) {
return hosts.flatMap((host) => {
const status = hostStatuses[host.id];
return status?.status === "ready" && status.detail
? [{ hostId: host.id, label: host.label, detail: status.detail }]
: [];
});
}
function DeviceHostDiagnostics(props: {
readonly hosts: ReadonlyArray<Pick<DeviceServiceState["hosts"][number], "id" | "label">>;
readonly hostStatuses: DeviceServiceState["hostStatuses"];
readonly className?: string;
}) {
const diagnostics = deviceHostDiagnostics(props.hosts, props.hostStatuses);
if (diagnostics.length === 0) return null;
return (
<div role="status" className={cn("space-y-1 text-xs text-muted-foreground", props.className)}>
{diagnostics.map(({ hostId, label, detail }) => (
<p key={hostId} className="whitespace-pre-line break-words">
{label}: {detail}
</p>
))}
</div>
);
}
export function platformSetupStatus(state: DeviceServiceState, platform: DevicePlatform) {
const hasDevices = state.devices.some((device) => device.platform === platform);
if (platform === "android" && !hasDevices && isAndroidDiscoveryUncertain(state)) {
return {
ready: false,
message: "The Android device list may be incomplete. Check the device host and try again.",
};
}
const availabilities = state.hosts.flatMap((host) =>
host.platforms
.filter((candidate) => candidate.platform === platform)
.map((candidate) => ({ ...candidate, host })),
);
const supportingHosts = availabilities
.filter((candidate) => candidate.available)
.map((candidate) => candidate.host);
if (supportingHosts.length === 0) {
return {
ready: false,
message: availabilities[0]?.reason ?? `${platformName(platform)} support was not detected.`,
};
}
const readyHosts = supportingHosts.filter(
(host) =>
state.hostStatuses[host.id]?.status === "ready" ||
(host.kind === "local" && state.hostStatus === "ready"),
);
if (readyHosts.length > 0 && !hasDevices) {
if (
readyHosts.some((host) =>
state.hostStatuses[host.id]?.incompletePlatforms?.includes(platform),
)
) {
return {
ready: false,
message: `No ${platformName(platform)} devices were listed because device discovery reported a problem.`,
};
}
return {
ready: false,
message:
platform === "ios"
? "Xcode is installed, but no iOS Simulator is available. Install a runtime in Xcode Settings → Components."
: "The Android SDK is installed, but no virtual device exists. Create one in Android Studio → Device Manager.",
};
}
const remoteHost = supportingHosts.every((host) => host.kind !== "local")
? supportingHosts[0]
: undefined;
const location = remoteHost ? ` on ${remoteHost.label}` : "";
return {
ready: true,
message:
remoteHost?.kind === "eas"
? `${remoteHost.label} starts ${platform === "ios" ? "iOS Simulators" : "Android emulators"} in the cloud with EAS Simulator.`
: platform === "ios"
? `Xcode and iOS Simulator are available${location}.`
: `The Android SDK and Emulator are available${location}.`,
};
}
export function DeviceSetup(props: {
readonly environmentId: EnvironmentId;
readonly state: DeviceServiceState;
readonly onComplete?: () => void;
}) {
const canConfigure = useEnvironmentScope(props.environmentId, AuthSettingsWriteScope);
const configure = useAtomCommand(deviceEnvironment.configure);
const list = useAtomCommand(deviceEnvironment.list, { reportFailure: false });
const [pending, setPending] = useState<"hub" | "check" | "agent" | "complete" | null>(null);
const [step, setStep] = useState(0);
const enabled = props.state.hostStatus !== "disabled";
const { ready, busy } = deviceHubReadiness(props.state);
const localPlatformsUnavailable = props.state.hosts.some(
(host) => host.kind === "local" && !host.platforms.some((platform) => platform.available),
);
useAtomMount(enabled ? deviceHostProbeAtom(props.environmentId) : NO_DEVICE_PROBE_ATOM);
const update = async (
kind: NonNullable<typeof pending>,
input: { enabled?: boolean; agentAccessEnabled?: boolean; onboardingCompleted?: boolean },
) => {
if (!readEnvironmentScope(props.environmentId, AuthSettingsWriteScope)) return;
setPending(kind);
const result = await configure({ environmentId: props.environmentId, input });
setPending(null);
if (kind === "complete" && result._tag === "Success") props.onComplete?.();
};
return (
<>
<WizardHeader
title="Set up devices"
description="Review what runs on this environment before using simulators and emulators."
>
<WizardSteps
steps={["Device hub", "Simulators", "Agent access"]}
currentStep={step}
onStepChange={setStep}
isStepDisabled={(requested) => busy || pending !== null || requested > step}
/>
</WizardHeader>
<WizardPanel>
<DeviceHostUpdates state={props.state} environmentId={props.environmentId} />
{step === 0 ? (
<section className="space-y-3 text-sm">
<h3 className="font-medium">Enable the device hub</h3>
<div className="flex items-start justify-between gap-4">
<p className="text-muted-foreground">{deviceHubDescription}</p>
<Switch
checked={enabled}
disabled={!canConfigure || busy || pending !== null}
aria-label="Enable device hub"
onCheckedChange={(checked) =>
void update("hub", {
enabled: Boolean(checked),
...(checked ? {} : { agentAccessEnabled: false }),
})
}
/>
</div>
<DeviceHubSetupStatus
state={props.state}
pending={pending === "hub" || (busy && pending !== "agent")}
/>
</section>
) : null}
{step === 1 || (step === 0 && enabled && localPlatformsUnavailable) ? (
<section className={cn("space-y-3 text-sm", step === 0 && "mt-4")}>
<h3 className="font-medium">Check simulator support</h3>
<DevicePlatformSetup
state={props.state}
checking={pending === "check"}
disabled={!enabled || busy || pending !== null}
onCheck={() => {
setPending("check");
void list({ environmentId: props.environmentId, input: {} }).finally(() =>
setPending(null),
);
}}
/>
</section>
) : null}
{step === 2 ? (
<section className="space-y-3 text-sm">
<h3 className="font-medium">Allow agent control</h3>
<div className="flex items-start justify-between gap-4">
<p className="text-muted-foreground">{agentDeviceDescription}</p>
<Switch
checked={props.state.agentAccessEnabled}
disabled={!canConfigure || !enabled || busy || pending !== null}
aria-label="Allow agents to control devices"
onCheckedChange={(checked) =>
void update("agent", { agentAccessEnabled: Boolean(checked) })
}
/>
</div>
<AgentDeviceSetupStatus state={props.state} pending={pending === "agent"} />
<p className="text-xs text-muted-foreground">
Leave this off to keep manual device controls without giving agents access.
</p>
</section>
) : null}
{props.state.hostStatus === "failed" && props.state.hostStatusDetail ? (
<p role="alert" className="mt-3 text-xs text-destructive">
{props.state.hostStatusDetail}
</p>
) : null}
</WizardPanel>
<WizardFooter>
{step === 0 ? (
<DialogClose render={<Button variant="outline" />}>Cancel</DialogClose>
) : (
<Button
variant="outline"
disabled={busy || pending !== null}
onClick={() => setStep(step - 1)}
>
Back
</Button>
)}
{step < 2 ? (
<Button disabled={!ready || pending !== null} onClick={() => setStep(step + 1)}>
Continue
</Button>
) : (
<Button
disabled={!canConfigure || !ready || pending !== null}
onClick={() => void update("complete", { onboardingCompleted: true })}
>
{pending === "complete" ? "Saving…" : "Done"}
</Button>
)}
</WizardFooter>
</>
);
}
export function DeviceHubSetupStatus({
state,
pending,
compact = false,
}: {
readonly state: DeviceServiceState;
readonly pending: boolean;
readonly compact?: boolean;
}) {
if (!pending && !deviceHubReadiness(state).ready) return null;
return (
<p role="status" className="flex items-center gap-2 text-xs text-muted-foreground">
{pending ? <Spinner size="xs" /> : <Check className="size-3 text-success" />}
{pending
? state.hostStatus === "installing"
? compact
? "Installing…"
: "Installing device hub…"
: state.hostStatus === "starting"
? compact
? "Starting…"
: "Starting device hub…"
: compact
? "Updating…"
: "Updating device hub…"
: "Device hub is ready."}
</p>
);
}
function DevicePlatformSetup(props: {
readonly state: DeviceServiceState;
readonly checking: boolean;
readonly disabled: boolean;
readonly onCheck: () => void;
}) {
return (
<div className="space-y-3">
<PlatformStatus platform="iOS" status={platformSetupStatus(props.state, "ios")} />
<PlatformStatus platform="Android" status={platformSetupStatus(props.state, "android")} />
<DeviceHostDiagnostics hosts={props.state.hosts} hostStatuses={props.state.hostStatuses} />
<p className="text-xs text-muted-foreground">
You can use either platform. Fixing a missing platform does not block the other one.
</p>
<Button size="compact" variant="outline" disabled={props.disabled} onClick={props.onCheck}>
{props.checking ? <Spinner size="xs" /> : null}
{props.checking ? "Checking…" : "Check again"}
</Button>
</div>
);
}
export function AgentDeviceSetupStatus(props: {
readonly state: DeviceServiceState;
readonly pending: boolean;
readonly compact?: boolean;
}) {
if (props.pending) {
const label =
props.state.hostStatus === "installing"
? props.compact
? "Installing…"
: "Installing agent tools…"
: props.state.hostStatus === "starting"
? props.compact
? "Starting…"
: "Starting agent tools…"
: props.compact
? "Updating…"
: "Updating agent access…";
return (
<p role="status" className="flex items-center gap-2 text-xs text-muted-foreground">
<Spinner size="xs" />
{label}
</p>
);
}
if (
props.state.agentAccessEnabled &&
deviceHubReadiness(props.state).ready &&
props.state.hosts.some((host) => host.agentDeviceInstalled)
) {
return (
<p role="status" className="flex items-center gap-2 text-xs text-muted-foreground">
<Check className="size-3 text-success" />
Agent tools are ready.
</p>
);
}
return null;
}
function PlatformStatus(props: {
readonly platform: string;
readonly status: { readonly ready: boolean; readonly message: string };
readonly compact?: boolean;
}) {
return (
<div
className={cn("flex gap-2", !props.compact && "rounded-md border border-border/60 px-3 py-2")}
>
<MorphIcon
className={cn(
"mt-0.5 size-4 shrink-0",
props.status.ready ? "text-success" : "text-muted-foreground",
)}
icon={props.status.ready ? CheckGlyph : CircleAlert}
/>
<div className={cn(props.compact && props.status.ready && "flex items-center gap-2")}>
<p className="font-medium">{props.platform}</p>
<p className="text-xs text-muted-foreground">
{props.compact && props.status.ready ? "Ready" : props.status.message}
</p>
</div>
</div>
);
}