import { useAuth } from "@clerk/react";
import { useAtomValue } from "@effect/atom-react";
import type {
AgentSessionProjectCandidate,
EnvironmentId,
ProjectId,
ProviderInstanceId,
ScopedProjectRef,
ServerConfig,
ServerProvider,
} from "@t3tools/contracts";
import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime/environment";
import {
isAtomCommandInterrupted,
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
import {
AgentSessionSource,
AuthTerminalOperateScope,
CommandId,
defaultInstanceIdForDriver,
AuthOrchestrationOperateScope,
isManagedDriverAllowed,
ProviderDriverKind,
ThreadId,
} from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import {
ArrowRightIcon,
CheckIcon,
ChevronRightIcon,
CloudIcon,
LinkIcon,
MonitorIcon,
TerminalIcon,
} from "lucide-react";
import { useEffect, useRef, useState } from "react";
import { TYPOGRAPHY_ADVANCED_STORAGE_KEY } from "../../appearanceFonts";
import { useLocalStorage } from "../../hooks/useLocalStorage";
import { hasCloudPublicConfig } from "../../cloud/publicConfig";
import { PRIVACY_POLICY_URL } from "../../legalLinks";
import { useT3ConnectAuthPrompt } from "../clerk/useT3ConnectAuthPrompt";
import { completeOnboarding } from "../../onboarding/firstRun";
import {
groupOnboardingProjects,
partitionOnboardingProjects,
onboardingProjectKey,
resolveOnboardingLandingProject,
resolveOnboardingProjectId,
type OnboardingProjectGroup,
splitOnboardingProjectPath,
} from "../../onboarding/projectImport.logic";
import {
getOnboardingProviderState,
resolveOnboardingProviderInstallCommand,
resolveOnboardingProviderLoginCommand,
selectOnboardingProvidersByDriver,
} from "../../onboarding/providerReadiness.logic";
import { newProjectId, randomUUID } from "../../lib/utils";
import { agentSessionImport } from "../../state/agentSessions";
import { readProjects, waitForProject } from "../../state/entities";
import { useEnvironments, usePrimaryEnvironment } from "../../state/environments";
import {
managedInstanceLocks,
managedTelemetryOffMessage,
usePrimaryManagedPolicy,
} from "../../state/managedPolicy";
import {
isOnboardingRelayEnvironment,
resolveOnboardingSetup,
} from "../../onboarding/targetEnvironment.logic";
import { useProjectScans } from "../../onboarding/useProjectScans";
import { projectEnvironment } from "../../state/projects";
import { serverEnvironment } from "../../state/server";
import {
readEnvironmentScope,
useEnvironmentScope,
useEnvironmentsWithScope,
} from "../../state/session";
import { terminalEnvironment } from "../../state/terminal";
import { useAtomCommand } from "../../state/use-atom-command";
import { connectPairing } from "../../connection/onboarding";
import { getProviderSummary } from "../settings/providerStatus";
import { providerClients } from "../settings/providerDriverMeta";
import { ChatGptWelcomeCoordinator } from "../settings/ChatGptWelcomeCoordinator";
import { AddManagedCodexAccountDialog, CodexSetupSection } from "../settings/CodexSetupSection";
import { readCodexSetupMode } from "../settings/CodexSetupSection.logic";
import { buildProviderInstanceUpdatePatch } from "../settings/SettingsPanels.logic";
import { TerminalViewport } from "../ThreadTerminalDrawer";
import { CloudEnvironmentConnectRows } from "../cloud/CloudEnvironmentConnectList";
import { presentSavedCloudEnvironmentConnection } from "../cloud/cloudEnvironmentConnectionPresentation";
import { ProviderInstanceIcon } from "../chat/ProviderInstanceIcon";
import { T3Wordmark } from "../T3Wordmark";
import { Alert, AlertDescription } from "../ui/alert";
import { Button } from "../ui/button";
import { CommandBlock } from "../CommandBlock";
import { Checkbox } from "../ui/checkbox";
import { Collapsible, CollapsiblePanel, CollapsibleTrigger } from "../ui/collapsible";
import { Input } from "../ui/input";
import { Tooltip, TooltipTrigger, TooltipPopup } from "../ui/tooltip";
import { ScrollArea } from "../ui/scroll-area";
import { Spinner } from "../ui/spinner";
import { WizardPanel, WizardSteps, WizardPopup, WizardHeader } from "../ui/wizard";
import { Dialog } from "../ui/dialog";
import { toastManager } from "../ui/toast";
import { cn } from "../../lib/utils";
import { formatRelativeTime } from "../../timestampFormat";
type WizardStep = "connection" | "agents" | "import";
const NO_ENVIRONMENTS: readonly EnvironmentId[] = [];
const AGENT_ONBOARDING_THREAD_ID = ThreadId.make("onboarding-agent-setup");
const ONBOARDING_STAGES = ["Connect", "Agents", "Projects"] as const;
const SCAN_LIMIT_MESSAGE = "Scan limit reached. Some projects or conversations may be missing.";
export function WelcomeWizard({
localAvailable,
onDone,
resumeEnvironmentId,
}: {
readonly localAvailable: boolean;
readonly resumeEnvironmentId?: EnvironmentId | undefined;
readonly onDone: (projectRef?: ScopedProjectRef) => void | Promise<void>;
}) {
const [step, setStep] = useState<WizardStep>(resumeEnvironmentId ? "agents" : "connection");
const { environments } = useEnvironments();
const [selection, setSelection] = useState<ReadonlySet<EnvironmentId> | null>(null);
// Share the registry for the wizard's lifetime so unchecked computers are not auto-selected again.
const [autoSelectedComputers] = useState(() => new Set<EnvironmentId>());
const [setupIds, setSetupIds] = useState<readonly EnvironmentId[]>(
resumeEnvironmentId ? [resumeEnvironmentId] : [],
);
const [importSelection, setImportSelection] = useState<ImportSelection | null>(null);
const [isImporting, setIsImporting] = useState(false);
const finishingPromiseRef = useRef<Promise<boolean> | null>(null);
const completionErrorToastIdRef = useRef<ReturnType<typeof toastManager.add> | null>(null);
const primaryEnvironment = usePrimaryEnvironment();
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- marks newly listed computers in the shared auto-select registry once and selects the enabled ones
useEffect(() => {
const newComputers = environments.filter(
(environment) => !autoSelectedComputers.has(environment.environmentId),
);
if (newComputers.length === 0) return;
for (const environment of newComputers) {
autoSelectedComputers.add(environment.environmentId);
}
const enabledComputers = newComputers.filter((environment) => environment.entry.enabled);
if (enabledComputers.length === 0) return;
// oxlint-disable-next-line react/set-state-in-effect -- The registry marks each computer once, and only after commit; render must not mutate it.
setSelection(
(current) =>
new Set([
...(current ?? []),
...enabledComputers.map((environment) => environment.environmentId),
]),
);
}, [autoSelectedComputers, environments]);
const selectedIds =
selection ?? new Set(primaryEnvironment ? [primaryEnvironment.environmentId] : []);
const scans = useProjectScans(step === "import" ? setupIds : NO_ENVIRONMENTS);
const isLoadingProjects =
step === "import" &&
scans.every((scan) => scan.data === null) &&
scans.some((scan) => scan.isPending);
const startSetup = (ids: readonly EnvironmentId[]) => {
if (ids.length === 0) return;
setSetupIds(ids);
setStep("agents");
};
const stageIndex = step === "agents" ? 1 : step === "import" ? 2 : 0;
const finish = (
projectRef?: ScopedProjectRef,
importWarning?: string,
importedThreadCount = 0,
) => {
if (finishingPromiseRef.current !== null) return finishingPromiseRef.current;
if (completionErrorToastIdRef.current !== null) {
toastManager.close(completionErrorToastIdRef.current);
completionErrorToastIdRef.current = null;
}
const completion = completeOnboarding()
.then(async () => {
if (completionErrorToastIdRef.current !== null) {
toastManager.close(completionErrorToastIdRef.current);
completionErrorToastIdRef.current = null;
}
await onDone(projectRef);
if (importWarning) {
toastManager.add({
type: "warning",
title: "Some history was not imported",
description: importWarning,
timeout: 0,
});
} else if (importedThreadCount > 0) {
toastManager.add({
type: "success",
title: `Imported ${importedThreadCount} ${importedThreadCount === 1 ? "thread" : "threads"}`,
});
}
return true;
})
.catch(() => {
const errorToast = {
type: "error",
title: "Could not finish setup",
description: "Your settings could not be saved. Try again.",
} as const;
if (completionErrorToastIdRef.current === null) {
completionErrorToastIdRef.current = toastManager.add(errorToast);
} else {
toastManager.update(completionErrorToastIdRef.current, errorToast);
}
return false;
})
.finally(() => {
if (finishingPromiseRef.current === completion) {
finishingPromiseRef.current = null;
}
});
finishingPromiseRef.current = completion;
return completion;
};
return (
<Dialog
open
disablePointerDismissal
onOpenChange={(_, event) => {
event.cancel();
if (event.reason === "close-press" && !isImporting) void finish();
}}
>
<WizardPopup
size="wide"
bottomStickOnMobile={false}
initialFocus={() => document.getElementById("onboarding-pairing-url") ?? true}
>
<WizardHeader
title="Set up T3 Code"
identity={
<div className="flex items-baseline gap-1.5" role="img" aria-label="T3 Code">
<T3Wordmark className="h-4 w-auto shrink-0" aria-hidden />
<span className="text-2xl font-medium tracking-tight text-muted-foreground">
Code
</span>
</div>
}
>
<WizardSteps
steps={ONBOARDING_STAGES}
currentStep={stageIndex}
isStepDisabled={(index) => isImporting || index >= stageIndex}
onStepChange={(index) => {
if (isImporting || index > stageIndex) return;
setStep(index === 0 ? "connection" : "agents");
}}
/>
</WizardHeader>
<WizardPanel holdHeight={isLoadingProjects}>
{step === "connection" ? (
<ConnectionStep
expandPairingInitially={!localAvailable && !hasCloudPublicConfig()}
selectedIds={selectedIds}
autoSelectedComputers={autoSelectedComputers}
onSelectionChange={setSelection}
onToggleEnvironment={(environmentId, checked) =>
setSelection((current) => {
const next = new Set(current ?? selectedIds);
if (checked) next.add(environmentId);
else next.delete(environmentId);
return next;
})
}
onContinue={() =>
startSetup(resolveOnboardingSetup(environments, selectedIds).environmentIds)
}
onPaired={(environmentId) => {
setSelection(new Set([...selectedIds, environmentId]));
}}
/>
) : step === "agents" ? (
<AgentsStep environmentIds={setupIds} onContinue={() => setStep("import")} />
) : (
<ImportStep
scans={scans}
importSelection={importSelection}
onImportSelectionChange={setImportSelection}
isImporting={isImporting}
setIsImporting={setIsImporting}
onDone={finish}
/>
)}
</WizardPanel>
</WizardPopup>
<ChatGptWelcomeCoordinator />
</Dialog>
);
}
function ConnectionStep({
autoSelectedComputers,
expandPairingInitially,
selectedIds,
onSelectionChange,
onToggleEnvironment,
onContinue,
onPaired,
}: {
readonly autoSelectedComputers: Set<EnvironmentId>;
readonly expandPairingInitially: boolean;
readonly selectedIds: ReadonlySet<EnvironmentId>;
readonly onSelectionChange: (ids: ReadonlySet<EnvironmentId>) => void;
readonly onToggleEnvironment: (environmentId: EnvironmentId, checked: boolean) => void;
readonly onContinue: () => void;
readonly onPaired: (environmentId: EnvironmentId) => void;
}) {
const { environments } = useEnvironments();
const telemetryOff = managedTelemetryOffMessage(usePrimaryManagedPolicy());
const cloudEnabled = hasCloudPublicConfig();
const directEnvironments = environments.filter(
(environment) => !cloudEnabled || !isOnboardingRelayEnvironment(environment),
);
const [pairingOpen, setPairingOpen] = useState(expandPairingInitially);
const [isPairing, setIsPairing] = useState(false);
const { ready, skippedIds } = resolveOnboardingSetup(environments, selectedIds);
const skippedLabels = environments
.filter((environment) => skippedIds.includes(environment.environmentId))
.map((environment) => environment.label);
const continueRef = useRef<HTMLButtonElement>(null);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- moves DOM focus to the Continue button once setup is ready and nothing else holds focus
useEffect(() => {
if (
ready &&
(document.activeElement === document.body ||
document.activeElement?.getAttribute("role") === "dialog")
) {
continueRef.current?.focus();
}
}, [ready]);
return (
<>
<h1 className="text-2xl font-semibold tracking-tight text-foreground">
Connect your computers
</h1>
<p className="mt-2.5 text-sm leading-relaxed text-muted-foreground">
Choose one or more computers. We’ll set up agents and projects on each.
</p>
{directEnvironments.length > 0 ? (
<fieldset className="mt-5 space-y-2">
<legend className="sr-only">Computers to set up</legend>
{directEnvironments.map((environment) => (
<label
key={environment.environmentId}
className="flex cursor-pointer items-center gap-3 rounded-lg border border-border bg-background px-3 py-3"
>
<Checkbox
checked={selectedIds.has(environment.environmentId)}
onCheckedChange={(checked) => {
const next = new Set(selectedIds);
if (checked) next.add(environment.environmentId);
else next.delete(environment.environmentId);
onSelectionChange(next);
}}
/>
<MonitorIcon className="size-4 shrink-0 text-muted-foreground" />
<span className="min-w-0 flex-1">
<span className="flex items-baseline justify-between gap-3">
<span className="min-w-0 text-sm font-medium break-words">
{environment.label}
</span>
<span className="shrink-0 text-xs text-muted-foreground">
{!environment.entry.enabled && environment.connection.phase !== "unsupported"
? "Off"
: presentSavedCloudEnvironmentConnection(environment.connection).buttonLabel}
</span>
</span>
{environment.displayUrl ? (
<span className="mt-0.5 block text-xs break-all text-muted-foreground">
{environment.displayUrl}
</span>
) : null}
{environment.connection.phase === "unsupported" && environment.connection.error ? (
<span className="mt-0.5 block text-xs text-muted-foreground">
{environment.connection.error}
</span>
) : null}
</span>
</label>
))}
</fieldset>
) : null}
<div className="mt-4 space-y-2">
{cloudEnabled ? (
<ConnectAccountOption
autoSelectedComputers={autoSelectedComputers}
disabled={isPairing}
selectedIds={selectedIds}
onToggleEnvironment={onToggleEnvironment}
/>
) : null}
<div className="rounded-lg border border-border bg-background">
<Collapsible open={pairingOpen} onOpenChange={setPairingOpen}>
<CollapsibleTrigger
disabled={isPairing}
render={
<Button
variant="ghost"
size="sm-multiline"
className="min-h-14 w-full justify-start"
/>
}
>
<LinkIcon className="size-4 text-muted-foreground" />
<span className="flex-1 text-left">Add a computer</span>
<ChevronRightIcon
className={cn("size-4 text-muted-foreground", pairingOpen && "rotate-90")}
/>
</CollapsibleTrigger>
<CollapsiblePanel>
<div className="px-3 pb-3">
<PairingForm
isPairing={isPairing}
setIsPairing={setIsPairing}
onPaired={(environmentId) => {
setPairingOpen(false);
onPaired(environmentId);
requestAnimationFrame(() => continueRef.current?.focus());
}}
/>
</div>
</CollapsiblePanel>
</Collapsible>
</div>
</div>
{skippedLabels.length > 0 ? (
<p className="mt-4 text-xs text-muted-foreground">
Not connected, so setup skips {skippedLabels.join(", ")}. You can set{" "}
{skippedLabels.length === 1 ? "it" : "them"} up later from Settings.
</p>
) : null}
<div className="mt-6 flex flex-col-reverse gap-4 sm:flex-row sm:items-center sm:justify-between sm:gap-6">
<p className="min-w-0 text-xs leading-relaxed text-muted-foreground">
{telemetryOff ?? "T3 Code collects anonymous usage data to help us improve it."} To read
more about how your data is used{telemetryOff === undefined ? " and how to opt out" : ""},
see our{" "}
<a
className="underline underline-offset-2 hover:text-foreground"
href={PRIVACY_POLICY_URL}
target="_blank"
rel="noreferrer noopener"
>
privacy policy
</a>
.
</p>
<Button
className="shrink-0 self-end"
ref={continueRef}
autoFocus={!expandPairingInitially}
disabled={!ready || isPairing}
onClick={onContinue}
>
Continue
<ArrowRightIcon className="size-3.5" />
</Button>
</div>
</>
);
}
function ConnectAccountOption({
autoSelectedComputers,
disabled,
selectedIds,
onToggleEnvironment,
}: {
readonly autoSelectedComputers: Set<EnvironmentId>;
readonly disabled: boolean;
readonly selectedIds: ReadonlySet<EnvironmentId>;
readonly onToggleEnvironment: (environmentId: EnvironmentId, checked: boolean) => void;
}) {
const { environments } = useEnvironments();
const { isLoaded, isSignedIn } = useAuth({ treatPendingAsSignedOut: false });
const { openAuthPrompt } = useT3ConnectAuthPrompt();
const [expanded, setExpanded] = useState(true);
const [discoveryReady, setDiscoveryReady] = useState(false);
const onDiscoveryReady = () => setDiscoveryReady(true);
return (
<div className="rounded-lg border border-border bg-background">
<Collapsible open={expanded && !!isSignedIn && discoveryReady} onOpenChange={setExpanded}>
<CollapsibleTrigger
disabled={disabled || !isLoaded}
onClick={(event) => {
if (!isSignedIn) {
event.preventDefault();
setExpanded(true);
openAuthPrompt();
}
}}
render={
<Button variant="ghost" size="sm-multiline" className="min-h-14 w-full justify-start" />
}
>
<CloudIcon className="size-4 text-muted-foreground" />
<span className="flex-1 text-left">T3 Connect</span>
<span className="text-xs text-muted-foreground">
{!isLoaded
? "Loading sign-in…"
: !isSignedIn
? "Sign in"
: !discoveryReady
? "Loading computers…"
: null}
</span>
<ChevronRightIcon
className={cn("size-4 text-muted-foreground", expanded && isSignedIn && "rotate-90")}
/>
</CollapsibleTrigger>
<CollapsiblePanel keepMounted>
<div className="px-3 pb-3">
<div className="mb-3 space-y-1.5">
{isSignedIn ? (
<CloudEnvironmentConnectRows
primaryEnvironmentId={null}
savedEnvironments={environments}
showSavedEnvironments
onDiscoveryReady={onDiscoveryReady}
selection={{ selectedIds, onChange: onToggleEnvironment, autoSelectedComputers }}
refreshWhileEmpty
empty={
<p className="py-3 text-sm text-muted-foreground">No computers linked yet.</p>
}
/>
) : null}
</div>
<p className="text-sm text-muted-foreground">
Run this on each computer you want to connect.
</p>
<CommandBlock command="npx t3 connect" className="mt-3" />
<p className="mt-3 text-xs text-muted-foreground">
Keep T3 Code running. Select the computers you want to set up above.
</p>
</div>
</CollapsiblePanel>
</Collapsible>
</div>
);
}
function PairingForm({
isPairing,
setIsPairing,
onPaired,
}: {
readonly isPairing: boolean;
readonly setIsPairing: (value: boolean) => void;
readonly onPaired: (environmentId: EnvironmentId) => void;
}) {
const connectPairingEnvironment = useAtomCommand(connectPairing, { reportFailure: false });
const [pairingUrl, setPairingUrl] = useState("");
const [errorMessage, setErrorMessage] = useState("");
const mountedRef = useRef(true);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- tracks mount so a pairing request that settles after unmount does not set state
useEffect(() => {
mountedRef.current = true;
return () => {
mountedRef.current = false;
};
}, []);
const submit = async () => {
if (isPairing || pairingUrl.trim().length === 0) return;
setIsPairing(true);
setErrorMessage("");
const result = await connectPairingEnvironment({ pairingUrl: pairingUrl.trim() });
if (!mountedRef.current) return;
setIsPairing(false);
if (result._tag === "Success") {
onPaired(result.value);
return;
}
if (isAtomCommandInterrupted(result)) return;
const cause = squashAtomCommandFailure(result);
setErrorMessage(cause instanceof Error ? cause.message : "Pairing failed.");
};
return (
<>
<form
className="space-y-3"
onSubmit={(event) => {
event.preventDefault();
void submit();
}}
>
<div>
<label className="block text-sm text-muted-foreground" htmlFor="onboarding-pairing-url">
Pairing link
</label>
<Input
id="onboarding-pairing-url"
autoFocus
aria-invalid={errorMessage.length > 0}
aria-describedby={errorMessage ? "onboarding-pairing-error" : undefined}
className="mt-2"
size="lg"
autoCapitalize="none"
autoComplete="off"
autoCorrect="off"
spellCheck={false}
nativeInput
readOnly={isPairing}
placeholder="https://your-server:5230/pair#token=…"
value={pairingUrl}
onChange={(event) => setPairingUrl(event.currentTarget.value)}
onKeyDown={(event) => {
if (
event.key === "Enter" &&
(event.nativeEvent.isComposing || event.keyCode === 229)
) {
event.preventDefault();
}
}}
/>
</div>
{errorMessage ? (
<Alert id="onboarding-pairing-error" variant="error">
<AlertDescription>{errorMessage}</AlertDescription>
</Alert>
) : null}
<Collapsible>
<div className="flex items-center justify-between gap-3">
<CollapsibleTrigger
type="button"
className="group flex items-center gap-1 text-sm text-muted-foreground hover:text-foreground"
>
<ChevronRightIcon className="size-3.5 group-data-panel-open:rotate-90" />
Need a pairing link?
</CollapsibleTrigger>
<Button type="submit" disabled={isPairing || pairingUrl.trim().length === 0}>
{isPairing ? "Pairing..." : "Pair"}
</Button>
</div>
<CollapsiblePanel>
<p className="pt-3 text-sm text-muted-foreground">
On the computer with your code, start T3 Code or run{" "}
<code className="font-mono">npx t3 serve</code>, then run:
</p>
<CommandBlock command="npx t3 pair" className="mt-2" />
<p className="mt-2 text-xs leading-relaxed text-muted-foreground">
On a tailnet, run <code className="font-mono">npx t3 pair --tailscale</code> instead.
</p>
</CollapsiblePanel>
</Collapsible>
</form>
</>
);
}
const PRIMARY_AGENT_DRIVERS = ["codex", "claudeAgent"] as const;
type OnboardingAgentDriver = (typeof PRIMARY_AGENT_DRIVERS)[number];
interface AgentTerminalSession {
readonly environmentId: EnvironmentId;
readonly driver: OnboardingAgentDriver;
readonly providerInstanceId: ServerProvider["instanceId"];
readonly cwd: string;
readonly command: string;
readonly keybindings: ServerConfig["keybindings"];
}
function AgentsStep({
environmentIds,
onContinue,
}: {
readonly environmentIds: readonly EnvironmentId[];
readonly onContinue: () => void;
}) {
const { environments } = useEnvironments();
return (
<StepShell
title="Connect your agents"
description="Choose an agent to start coding. You can add more later."
>
<ScrollArea scrollFade className="mt-5 h-auto max-h-[min(32rem,55dvh)]">
<div className="space-y-5 pr-3">
{environmentIds.map((environmentId) => (
<ConnectedAgentsStep
key={environmentId}
environmentId={environmentId}
machineLabel={
environments.find((environment) => environment.environmentId === environmentId)
?.label ?? "Computer"
}
/>
))}
</div>
</ScrollArea>
<div className="mt-6 flex justify-end">
<Button autoFocus onClick={onContinue}>
Continue
<ArrowRightIcon className="size-3.5" />
</Button>
</div>
</StepShell>
);
}
function ConnectedAgentsStep({
environmentId,
machineLabel,
}: {
readonly environmentId: EnvironmentId;
readonly machineLabel: string;
}) {
const providers = useAtomValue(serverEnvironment.providersValueAtom(environmentId));
const refreshProviders = useAtomCommand(serverEnvironment.refreshProviders, {
reportFailure: false,
});
const serverConfig = useAtomValue(serverEnvironment.configValueAtom(environmentId));
const [terminalSession, setTerminalSession] = useState<AgentTerminalSession | null>(null);
const [addingAccount, setAddingAccount] = useState(false);
const [createdAccount, setCreatedAccount] = useState<{
instanceId: ProviderInstanceId;
displayName: string;
autoStart: boolean;
} | null>(null);
const canOperateTerminal = useEnvironmentScope(environmentId, AuthTerminalOperateScope);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- asks the environment to refresh its provider list when the environment changes
useEffect(() => {
void refreshProviders({ environmentId, input: {} });
}, [environmentId, refreshProviders]);
const byDriver = selectOnboardingProvidersByDriver(providers);
const managedPolicy = serverConfig?.managedPolicy;
// A policy that owns Codex's launch settings also rules out ChatGPT's own runtime.
const chatGptAllowed =
managedInstanceLocks(managedPolicy, ProviderDriverKind.make("codex"))?.configKeys.has(
"setupMode",
) !== true;
const primaryAgents = PRIMARY_AGENT_DRIVERS.filter((driver) =>
isManagedDriverAllowed(managedPolicy, ProviderDriverKind.make(driver)),
).flatMap((driver) => {
const instances =
driver === "codex" ? providers?.filter((provider) => provider.driver === driver) : undefined;
return instances?.length
? instances.map((provider) => ({ driver, provider, instanceId: provider.instanceId }))
: [{ driver, provider: byDriver.get(driver), instanceId: byDriver.get(driver)?.instanceId }];
});
if (createdAccount) {
const index = primaryAgents.findIndex(
(agent) => agent.instanceId === createdAccount.instanceId,
);
const [existing] = index >= 0 ? primaryAgents.splice(index, 1) : [];
primaryAgents.unshift(
existing ?? {
driver: "codex",
provider: undefined,
instanceId: createdAccount.instanceId,
},
);
}
return (
<section>
<h2 className="mb-2 text-sm font-medium">{machineLabel}</h2>
{!canOperateTerminal ? (
<p className="mb-2 text-sm text-muted-foreground">
This connection cannot control terminals.
</p>
) : null}
<div className="space-y-1.5">
{primaryAgents.map(({ driver, provider, instanceId }) =>
driver === "codex" && serverConfig !== null ? (
<OnboardingCodexSetup
key={instanceId ?? driver}
environmentId={environmentId}
provider={provider}
serverConfig={serverConfig}
createdAccount={instanceId === createdAccount?.instanceId ? createdAccount : null}
onAutoStartConsumed={() =>
setCreatedAccount((account) => (account ? { ...account, autoStart: false } : null))
}
terminalOpen={terminalSession?.driver === driver}
onOpenTerminal={() => {
if (
provider === undefined ||
!readEnvironmentScope(environmentId, AuthTerminalOperateScope)
)
return;
setTerminalSession({
environmentId,
driver,
providerInstanceId: provider.instanceId,
cwd: serverConfig.cwd,
command: provider.installed
? resolveOnboardingProviderLoginCommand(
provider,
serverConfig.settings,
serverConfig.environment.platform.os,
)
: resolveOnboardingProviderInstallCommand(
driver,
serverConfig.environment.platform.os,
),
keybindings: serverConfig.keybindings,
});
}}
/>
) : (
<AgentCard
key={driver}
driver={driver}
provider={provider}
terminalOpen={terminalSession?.driver === driver}
terminalAvailable={serverConfig !== null && canOperateTerminal}
onOpenTerminal={() => {
if (
provider === undefined ||
serverConfig === null ||
!readEnvironmentScope(environmentId, AuthTerminalOperateScope)
)
return;
setTerminalSession({
environmentId,
driver,
providerInstanceId: provider.instanceId,
cwd: serverConfig.cwd,
command: provider.installed
? resolveOnboardingProviderLoginCommand(
provider,
serverConfig.settings,
serverConfig.environment.platform.os,
)
: resolveOnboardingProviderInstallCommand(
driver,
serverConfig.environment.platform.os,
),
keybindings: serverConfig.keybindings,
});
}}
/>
),
)}
</div>
{chatGptAllowed &&
providers?.some(
(provider) =>
provider.driver === "codex" && getOnboardingProviderState(provider) === "ready",
) ? (
<div className="mt-3">
<Button size="xs" variant="ghost-muted" onClick={() => setAddingAccount(true)}>
Connect another ChatGPT account
</Button>
</div>
) : null}
{addingAccount ? (
<AddManagedCodexAccountDialog
environmentId={environmentId}
onClose={() => setAddingAccount(false)}
onAccountCreated={(instanceId, displayName) =>
setCreatedAccount({ instanceId, displayName, autoStart: true })
}
/>
) : null}
{terminalSession !== null ? (
<AgentInstallTerminal
key={`${terminalSession.environmentId}:${terminalSession.providerInstanceId}:${terminalSession.driver}`}
session={terminalSession}
onClose={() => {
setTerminalSession(null);
void refreshProviders({ environmentId, input: {} });
}}
/>
) : null}
</section>
);
}
function OnboardingCodexSetup({
createdAccount,
onAutoStartConsumed,
environmentId,
provider,
serverConfig,
terminalOpen,
onOpenTerminal,
}: {
readonly environmentId: EnvironmentId;
readonly provider: ServerProvider | undefined;
readonly serverConfig: ServerConfig;
readonly terminalOpen: boolean;
readonly onOpenTerminal: () => void;
readonly createdAccount: {
instanceId: ProviderInstanceId;
displayName: string;
autoStart: boolean;
} | null;
readonly onAutoStartConsumed: () => void;
}) {
const canOperateTerminal = useEnvironmentScope(environmentId, AuthTerminalOperateScope);
const update = useAtomCommand(serverEnvironment.updateSettings, "Codex setup settings");
const instanceId =
createdAccount?.instanceId ??
provider?.instanceId ??
defaultInstanceIdForDriver(ProviderDriverKind.make("codex"));
const settings = serverConfig.settings;
const instance = settings.providerInstances[instanceId] ?? {
driver: ProviderDriverKind.make("codex"),
config: createdAccount ? { enabled: true, setupMode: "managed" } : {},
};
const mode = readCodexSetupMode(instance.config);
const existingChosen =
mode === "existing" &&
instance.config !== null &&
typeof instance.config === "object" &&
"setupMode" in instance.config &&
instance.config.setupMode === "existing";
const changeMode = (setupMode: "managed" | "existing") => {
void update({
environmentId,
input: {
patch: buildProviderInstanceUpdatePatch({
settings,
instanceId,
instance: {
...instance,
enabled: true,
config: {
...(instance.config !== null && typeof instance.config === "object"
? instance.config
: {}),
enabled: true,
setupMode,
},
},
}),
},
});
};
return existingChosen ? (
<AgentCard
driver="codex"
provider={provider}
terminalOpen={terminalOpen}
terminalAvailable={canOperateTerminal}
onOpenTerminal={onOpenTerminal}
/>
) : (
<CodexSetupSection
presentation="onboarding"
autoStart={createdAccount?.autoStart === true}
displayName={createdAccount?.displayName}
onAutoStartConsumed={onAutoStartConsumed}
environmentId={environmentId}
instanceId={instanceId}
provider={provider}
mode={mode}
enabled={provider?.enabled ?? true}
onModeChange={changeMode}
/>
);
}
function AgentCard({
driver,
provider,
terminalOpen,
terminalAvailable,
onOpenTerminal,
}: {
readonly driver: OnboardingAgentDriver;
readonly provider: ServerProvider | undefined;
readonly terminalOpen: boolean;
readonly terminalAvailable: boolean;
readonly onOpenTerminal: () => void;
}) {
const meta = providerClients.get(ProviderDriverKind.make(driver));
const displayName =
provider?.displayName || (driver === "claudeAgent" ? "Claude Code" : (meta?.label ?? driver));
const summary = getProviderSummary(provider);
const providerState = getOnboardingProviderState(provider);
return (
<div className="flex items-center gap-3 rounded-lg border border-border bg-background px-4 py-4">
<ProviderInstanceIcon
driverKind={ProviderDriverKind.make(driver)}
displayName={displayName}
iconClassName="size-5"
/>
<div className="min-w-0 flex-1">
<span className="block text-sm font-medium text-foreground">{displayName}</span>
<p className="mt-0.5 text-xs leading-relaxed break-words whitespace-pre-wrap text-muted-foreground">
{providerState === "ready" ? "Ready to code." : summary.headline}
{providerState !== "ready" && summary.detail ? ` · ${summary.detail}` : ""}
</p>
</div>
<div className="shrink-0">
{providerState === "ready" ? (
<span className="inline-flex items-center gap-1.5 text-xs font-medium text-success-foreground">
<CheckIcon className="size-3.5" />
Ready
</span>
) : providerState === "checking" ? (
<span className="text-xs text-muted-foreground">Checking...</span>
) : providerState === "disabled" ? (
<span className="text-xs text-muted-foreground">Disabled</span>
) : providerState === "attention" ? (
<span className="text-xs text-muted-foreground">{summary.headline}</span>
) : (
<Button
size="xs"
variant="ghost"
onClick={onOpenTerminal}
disabled={terminalOpen || !terminalAvailable}
>
<TerminalIcon className="size-3.5" />
{providerState === "signIn" ? "Sign in" : "Install"}
</Button>
)}
</div>
</div>
);
}
function AgentInstallTerminal({
session,
onClose,
}: {
readonly session: AgentTerminalSession;
readonly onClose: () => void;
}) {
const { command, cwd, driver, environmentId, keybindings, providerInstanceId } = session;
const canOperateTerminal = useEnvironmentScope(environmentId, AuthTerminalOperateScope);
const [advancedTypography] = useLocalStorage(
TYPOGRAPHY_ADVANCED_STORAGE_KEY,
false,
Schema.Boolean,
);
const openTerminal = useAtomCommand(terminalEnvironment.open, { reportFailure: false });
const writeTerminal = useAtomCommand(terminalEnvironment.write, { reportFailure: false });
const closeTerminal = useAtomCommand(terminalEnvironment.close, { reportFailure: false });
const setupQueueRef = useRef(Promise.resolve());
const setupGenerationRef = useRef(0);
const activeSetupGenerationRef = useRef<number | null>(null);
const [terminalId] = useState(() => `onboarding-${driver}-${randomUUID()}`);
const threadRef = scopeThreadRef(environmentId, AGENT_ONBOARDING_THREAD_ID);
const [setupAttempt, setSetupAttempt] = useState(0);
const [setupState, setSetupState] = useState<
"preparing" | "ready" | "openFailed" | "writeFailed"
>("preparing");
const terminalReady = setupState === "ready" || setupState === "writeFailed";
// StrictMode can finish a cancelled open after replacement setup; it must not close or pre-type into that
// session.
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- opens the setup PTY, types the command into it, and closes it on cleanup
useEffect(() => {
const generation = setupGenerationRef.current + 1;
setupGenerationRef.current = generation;
activeSetupGenerationRef.current = generation;
// oxlint-disable-next-line react/set-state-in-effect -- A retry or a new command reopens the terminal, which shows as preparing until the open settles.
setSetupState("preparing");
setupQueueRef.current = setupQueueRef.current.then(async () => {
if (activeSetupGenerationRef.current !== generation) return;
if (!readEnvironmentScope(environmentId, AuthTerminalOperateScope)) {
setSetupState("openFailed");
return;
}
const opened = await openTerminal({
environmentId,
input: {
threadId: AGENT_ONBOARDING_THREAD_ID,
terminalId,
cwd,
providerInstanceId,
},
});
if (opened._tag !== "Success") {
if (activeSetupGenerationRef.current === generation) setSetupState("openFailed");
return;
}
if (activeSetupGenerationRef.current !== generation) return;
if (!readEnvironmentScope(environmentId, AuthTerminalOperateScope)) {
setSetupState("writeFailed");
return;
}
const wrote = await writeTerminal({
environmentId,
input: { threadId: AGENT_ONBOARDING_THREAD_ID, terminalId, data: command },
});
if (activeSetupGenerationRef.current !== generation) return;
setSetupState(wrote._tag === "Success" ? "ready" : "writeFailed");
});
// Revocation leaves the PTY running; close only while terminal access remains.
return () => {
if (activeSetupGenerationRef.current === generation) {
activeSetupGenerationRef.current = null;
}
setupQueueRef.current = setupQueueRef.current.then(async () => {
if (!readEnvironmentScope(environmentId, AuthTerminalOperateScope)) return;
await closeTerminal({
environmentId,
input: { threadId: AGENT_ONBOARDING_THREAD_ID, terminalId, deleteHistory: true },
});
});
};
}, [
closeTerminal,
command,
cwd,
environmentId,
openTerminal,
providerInstanceId,
// oxlint-disable-next-line react/exhaustive-effect-dependencies -- Retry bumps setupAttempt to open the terminal again.
setupAttempt,
terminalId,
writeTerminal,
]);
return (
<div
data-thread-terminal-drawer
className="mt-4 overflow-hidden rounded-lg border border-border/70 bg-background text-foreground"
>
<div className="flex items-center justify-between border-b border-border/60 bg-background/60 px-3 py-1.5">
<span className="text-2xs font-medium text-muted-foreground">
{!canOperateTerminal ? (
"This connection cannot control terminals."
) : setupState === "writeFailed" ? (
<>
Run <code className="rounded bg-muted px-1 font-mono">{command}</code> in this
terminal.
</>
) : setupState === "ready" ? (
"Review the command, then press Enter to run it."
) : setupState === "openFailed" ? (
"Could not open the setup terminal."
) : (
"Preparing command..."
)}
</span>
<div className="flex items-center gap-1">
{setupState === "openFailed" ? (
<Button
size="xs"
variant="ghost"
disabled={!canOperateTerminal}
onClick={() => {
if (readEnvironmentScope(environmentId, AuthTerminalOperateScope)) {
setSetupAttempt((value) => value + 1);
}
}}
>
Retry
</Button>
) : null}
<Button size="xs" variant="ghost-muted" onClick={onClose}>
Close
</Button>
</div>
</div>
<div className="h-64">
{terminalReady ? (
<TerminalViewport
threadRef={threadRef}
threadId={AGENT_ONBOARDING_THREAD_ID}
terminalId={terminalId}
terminalLabel={`Install ${driver}`}
cwd={cwd}
providerInstanceId={providerInstanceId}
advancedTypography={advancedTypography}
onSessionExited={onClose}
autoFocus
visible
keybindings={keybindings}
/>
) : null}
</div>
</div>
);
}
const IMPORT_PERMISSION_MESSAGE = "This connection cannot import projects or thread history.";
interface ImportSelection {
// Computers whose projects were listed when the selection changed; later ones get the defaults.
readonly environmentIds: ReadonlySet<EnvironmentId>;
readonly keys: ReadonlySet<string>;
}
function ImportStep({
scans,
importSelection,
onImportSelectionChange,
isImporting,
setIsImporting,
onDone,
}: {
readonly scans: ReturnType<typeof useProjectScans>;
readonly importSelection: ImportSelection | null;
readonly onImportSelectionChange: (next: ImportSelection) => void;
readonly isImporting: boolean;
readonly setIsImporting: (value: boolean) => void;
readonly onDone: (
projectRef?: ScopedProjectRef,
importWarning?: string,
importedThreadCount?: number,
) => Promise<boolean>;
}) {
const { environments } = useEnvironments();
const writableEnvironments = useEnvironmentsWithScope(scans, AuthOrchestrationOperateScope);
const createProject = useAtomCommand(projectEnvironment.create, { reportFailure: false });
const importThreads = useAtomCommand(agentSessionImport, { reportFailure: false });
const importWarningRef = useRef("");
const importedThreadCountRef = useRef(0);
const importedProjectsRef = useRef(new Map<string, ScopedProjectRef>());
const projectsWithImportedHistoryRef = useRef(new Map<string, ScopedProjectRef>());
const lastImportSelectionRef = useRef<ReadonlyArray<string>>([]);
const projectAttemptsRef = useRef(
new Map<string, { readonly projectId: ProjectId; readonly commandId: CommandId }>(),
);
const importGenerationRef = useRef(0);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- bumps the import generation on mount and unmount so in-flight imports drop stale results
useEffect(() => {
importGenerationRef.current += 1;
return () => {
importGenerationRef.current += 1;
};
}, []);
const { available: candidates, recent } = partitionOnboardingProjects(
scans.flatMap((scan) =>
(scan.data?.candidates ?? []).map((candidate) => ({
...candidate,
environmentId: scan.environmentId,
key: onboardingProjectKey(scan.environmentId, candidate.path),
})),
),
);
const recentKeys = new Set(recent.map((candidate) => candidate.key));
const selected = candidates.filter((candidate) =>
importSelection?.environmentIds.has(candidate.environmentId)
? importSelection.keys.has(candidate.key)
: recentKeys.has(candidate.key),
);
const selectedKeys = new Set(selected.map((candidate) => candidate.key));
const setSelectedKeys = (keys: ReadonlySet<string>) =>
onImportSelectionChange({
environmentIds: new Set(
scans.flatMap((scan) => (scan.data === null ? [] : [scan.environmentId])),
),
keys,
});
const canImport = selected.every((candidate) =>
writableEnvironments.has(candidate.environmentId),
);
const [importError, setImportError] = useState("");
const visibleImportError = !canImport
? IMPORT_PERMISSION_MESSAGE
: importError === IMPORT_PERMISSION_MESSAGE
? ""
: importError;
const finishAfterImport = () => {
const projectRef = resolveOnboardingLandingProject(
lastImportSelectionRef.current,
projectsWithImportedHistoryRef.current,
importedProjectsRef.current,
);
if (projectRef === undefined) {
void onDone(undefined, importWarningRef.current, importedThreadCountRef.current);
return;
}
setIsImporting(true);
const importGeneration = importGenerationRef.current;
// waitForProject gives up after its timeout, so a project that never reaches the client
// still finishes setup, just without landing in it.
void waitForProject(projectRef)
.then(
() => projectRef,
() => undefined,
)
.then(async (landing) => {
if (importGeneration !== importGenerationRef.current) return;
const completed = await onDone(
landing,
importWarningRef.current,
importedThreadCountRef.current,
);
if (!completed) setIsImporting(false);
});
};
const runImport = async (selection: typeof candidates) => {
if (isImporting) return;
const hasAccess = () =>
selection.every((candidate) =>
readEnvironmentScope(candidate.environmentId, AuthOrchestrationOperateScope),
);
const stopForDeniedAccess = () => {
setIsImporting(false);
setImportError(IMPORT_PERMISSION_MESSAGE);
};
if (!hasAccess()) {
stopForDeniedAccess();
return;
}
if (selection.length === 0) {
void onDone();
return;
}
setIsImporting(true);
importWarningRef.current = "";
importedThreadCountRef.current = 0;
lastImportSelectionRef.current = selection.map((candidate) => candidate.key);
const importGeneration = importGenerationRef.current;
const importedProjects = importedProjectsRef.current;
const projectAttempts = projectAttemptsRef.current;
let importedProjectsCount =
importedProjects.size > 0
? selection.filter((candidate) => importedProjects.has(candidate.key)).length
: 0;
let importedThreadCount = 0;
let skippedThreadCount = 0;
const refreshEnvironments = new Set<EnvironmentId>();
for (const candidate of selection) {
const { environmentId } = candidate;
if (
importGeneration !== importGenerationRef.current ||
importedProjects !== importedProjectsRef.current
) {
return;
}
if (!hasAccess()) {
stopForDeniedAccess();
return;
}
if (importedProjects.has(candidate.key)) continue;
let projectId = resolveOnboardingProjectId(readProjects(), environmentId, candidate);
if (projectId === null) {
let attempt = projectAttempts.get(candidate.key);
if (attempt === undefined) {
const nextProjectId = newProjectId();
attempt = {
projectId: nextProjectId,
commandId: CommandId.make(`onboarding:project:create:${nextProjectId}`),
};
projectAttempts.set(candidate.key, attempt);
}
projectId = attempt.projectId;
const result = await createProject({
environmentId,
input: {
projectId,
commandId: attempt.commandId,
title: candidate.title,
workspaceRoot: candidate.path,
createWorkspaceRootIfMissing: false,
defaultModelSelection: null,
},
});
if (
importGeneration !== importGenerationRef.current ||
importedProjects !== importedProjectsRef.current
) {
return;
}
if (result._tag !== "Success") {
if (!isAtomCommandInterrupted(result)) {
projectAttempts.delete(candidate.key);
refreshEnvironments.add(environmentId);
}
continue;
}
}
if (!hasAccess()) {
stopForDeniedAccess();
return;
}
const threadImportResult = await importThreads({
environmentId,
input: { projectId, expectedWorkspaceRoot: candidate.path },
});
if (
importGeneration !== importGenerationRef.current ||
importedProjects !== importedProjectsRef.current
) {
return;
}
if (threadImportResult._tag === "Success") {
importedThreadCount += threadImportResult.value.importedCount;
skippedThreadCount += threadImportResult.value.skippedCount;
if (threadImportResult.value.importedCount > 0) {
projectsWithImportedHistoryRef.current.set(
candidate.key,
scopeProjectRef(environmentId, projectId),
);
}
if (threadImportResult.value.skippedCount === 0) {
importedProjectsCount += 1;
importedProjects.set(candidate.key, scopeProjectRef(environmentId, projectId));
}
} else if (!isAtomCommandInterrupted(threadImportResult)) {
projectAttempts.delete(candidate.key);
refreshEnvironments.add(environmentId);
}
}
for (const scan of scans) {
if (refreshEnvironments.has(scan.environmentId)) scan.refresh();
}
setIsImporting(false);
importedThreadCountRef.current = importedThreadCount;
if (importedProjectsCount < selection.length) {
if (importedThreadCount > 0 && skippedThreadCount > 0) {
importWarningRef.current = `Imported ${importedThreadCount} ${importedThreadCount === 1 ? "thread" : "threads"}. ${skippedThreadCount} ${skippedThreadCount === 1 ? "thread" : "threads"} could not be imported.`;
} else if (skippedThreadCount > 0) {
importWarningRef.current = `${skippedThreadCount} ${skippedThreadCount === 1 ? "thread could" : "threads could"} not be imported.`;
} else if (importedThreadCount > 0) {
importWarningRef.current = `Imported ${importedThreadCount} ${importedThreadCount === 1 ? "thread" : "threads"}. Some thread history could not be imported.`;
} else {
importWarningRef.current = "Could not import thread history.";
}
}
finishAfterImport();
};
if (scans.every((scan) => scan.data === null) && scans.some((scan) => scan.isPending)) {
return (
<div className="flex h-full min-h-40 flex-col">
<h1 className="text-2xl font-semibold tracking-tight text-foreground">Your projects</h1>
<div className="flex flex-1 flex-col items-center justify-center gap-3 py-6">
<Spinner size="lg" tone="muted" />
<p className="text-center text-sm text-muted-foreground">
Looking for projects from Claude Code and Codex…
</p>
</div>
<div className="flex justify-end">
<Button variant="ghost-muted" onClick={() => void onDone()}>
Do not import projects
</Button>
</div>
</div>
);
}
return (
<StepShell
title="Import your projects"
description="Import projects and conversations from Claude Code and Codex on your selected computers."
>
{candidates.length > 0 ? (
<div className="mt-5 flex items-center justify-between gap-3 text-xs text-muted-foreground">
<span role="status">
{selected.length} of {candidates.length} selected
</span>
<div className="flex items-center gap-1">
<Button
variant="ghost"
size="xs"
disabled={isImporting || selected.length === candidates.length}
onClick={() => setSelectedKeys(new Set(candidates.map((item) => item.key)))}
>
Select all
</Button>
<Button
variant="ghost"
size="xs"
disabled={isImporting || selected.length === 0}
onClick={() => setSelectedKeys(new Set())}
>
Select none
</Button>
</div>
</div>
) : null}
<ScrollArea scrollFade className="mt-2 h-auto max-h-80">
<div className="space-y-5 pr-3">
{scans.map((scan) => {
const scanCandidates = candidates.filter(
(candidate) => candidate.environmentId === scan.environmentId,
);
const label =
environments.find((environment) => environment.environmentId === scan.environmentId)
?.label ?? "Computer";
return (
<fieldset
key={scan.environmentId}
className="min-w-0 space-y-0.5"
disabled={isImporting}
>
{scans.length > 1 ? (
<legend className="mb-2 text-sm font-medium">{label}</legend>
) : null}
{scan.isPending && scan.data === null ? (
<div className="flex items-center gap-2 py-3 text-sm text-muted-foreground">
<Spinner size="md" />
Looking for projects…
</div>
) : scan.error !== null ? (
<div
role="alert"
className="flex items-center justify-between gap-3 text-sm text-muted-foreground"
>
<span>Could not check projects. {scan.error}</span>
<Button variant="ghost" size="sm" onClick={scan.refresh}>
Retry
</Button>
</div>
) : scanCandidates.length === 0 ? (
<p className="py-2 text-sm text-muted-foreground">
No existing Claude Code or Codex projects found.
</p>
) : null}
{scan.data?.truncated ? (
<p className="text-xs text-muted-foreground" role="status">
{SCAN_LIMIT_MESSAGE}
</p>
) : null}
<ImportCandidateList
candidates={scanCandidates}
selectedKeys={selectedKeys}
onSelectionChange={setSelectedKeys}
/>
</fieldset>
);
})}
</div>
</ScrollArea>
{visibleImportError ? (
<p className="mt-3 text-sm text-destructive">{visibleImportError}</p>
) : null}
<div className="mt-6 flex flex-wrap items-center justify-end gap-3">
<Button variant="ghost-muted" disabled={isImporting} onClick={finishAfterImport}>
Do not import projects
</Button>
<Button
autoFocus
disabled={!canImport || isImporting || selected.length === 0}
onClick={() => void runImport(selected)}
>
{isImporting
? "Importing…"
: `Import ${selected.length} ${selected.length === 1 ? "project" : "projects"}`}
</Button>
</div>
</StepShell>
);
}
type ImportCandidate = AgentSessionProjectCandidate & {
readonly environmentId: EnvironmentId;
readonly key: string;
};
function ImportCandidateList({
candidates,
selectedKeys,
onSelectionChange,
}: {
readonly candidates: ReadonlyArray<ImportCandidate>;
readonly selectedKeys: ReadonlySet<string>;
readonly onSelectionChange: (next: ReadonlySet<string>) => void;
}) {
const { repositories, other } = groupOnboardingProjects(candidates);
const setKeys = (keys: ReadonlyArray<string>, checked: boolean) => {
const next = new Set(selectedKeys);
for (const key of keys) {
if (checked) next.add(key);
else next.delete(key);
}
onSelectionChange(next);
};
const otherSelected = other.filter((candidate) => selectedKeys.has(candidate.key)).length;
return (
<>
{repositories.map((group) => (
<ImportRepositoryGroup
key={group.key}
group={group}
selectedKeys={selectedKeys}
onToggle={setKeys}
/>
))}
{other.length > 0 ? (
<Collapsible>
<div className="flex items-center gap-2.5 rounded-md px-2 py-1.5 hover:bg-muted/40">
<Checkbox
checked={otherSelected === other.length}
indeterminate={otherSelected > 0 && otherSelected < other.length}
onCheckedChange={(checked) =>
setKeys(
other.map((candidate) => candidate.key),
checked === true,
)
}
/>
<CollapsibleTrigger className="group flex min-w-0 flex-1 items-center gap-1.5 text-left">
<ChevronRightIcon className="size-3.5 shrink-0 text-muted-foreground transition-transform group-data-panel-open:rotate-90" />
<span className="truncate text-sm text-muted-foreground">Other folders</span>
<span className="ml-auto shrink-0 text-xs text-muted-foreground tabular-nums">
{other.length} {other.length === 1 ? "folder" : "folders"}
</span>
</CollapsibleTrigger>
</div>
<CollapsiblePanel>
{other.map((candidate) => (
<ImportCandidateRow
key={candidate.key}
candidate={candidate}
path={candidate.path}
nested
checked={selectedKeys.has(candidate.key)}
onCheckedChange={(checked) => setKeys([candidate.key], checked)}
/>
))}
</CollapsiblePanel>
</Collapsible>
) : null}
</>
);
}
function ImportRepositoryGroup({
group,
selectedKeys,
onToggle,
}: {
readonly group: OnboardingProjectGroup<ImportCandidate>;
readonly selectedKeys: ReadonlySet<string>;
readonly onToggle: (keys: ReadonlyArray<string>, checked: boolean) => void;
}) {
const keys = group.candidates.map((candidate) => candidate.key);
const selectedCount = keys.filter((key) => selectedKeys.has(key)).length;
const single = group.candidates.length === 1;
const only = group.candidates[0];
if (single && only !== undefined) {
return (
<ImportCandidateRow
candidate={only}
label={group.label}
path={only.path}
checked={selectedKeys.has(only.key)}
onCheckedChange={(checked) => onToggle([only.key], checked)}
/>
);
}
return (
<Collapsible defaultOpen>
<div className="flex items-center gap-2.5 rounded-md px-2 py-1.5 hover:bg-muted/40">
<Checkbox
checked={selectedCount === keys.length}
indeterminate={selectedCount > 0 && selectedCount < keys.length}
onCheckedChange={(checked) => onToggle(keys, checked === true)}
/>
<CollapsibleTrigger className="group flex min-w-0 flex-1 items-center gap-1.5 text-left">
<ChevronRightIcon className="size-3.5 shrink-0 text-muted-foreground transition-transform group-data-panel-open:rotate-90" />
<span className="truncate text-sm font-medium">{group.label}</span>
<ImportRowMeta
sources={[...new Set(group.candidates.flatMap((c) => c.sources))]}
threadCount={group.threadCount}
lastActiveAt={group.lastActiveAt}
/>
</CollapsibleTrigger>
</div>
<CollapsiblePanel>
{group.candidates.map((candidate) => (
<ImportCandidateRow
key={candidate.key}
candidate={candidate}
path={candidate.path}
nested
checked={selectedKeys.has(candidate.key)}
onCheckedChange={(checked) => onToggle([candidate.key], checked)}
/>
))}
</CollapsiblePanel>
</Collapsible>
);
}
function ProjectPathText({
path,
className,
}: {
readonly path: string;
readonly className?: string;
}) {
const { name, parent } = splitOnboardingProjectPath(path);
return (
<span className={cn("flex min-w-0 items-baseline font-mono", className)}>
{parent.length > 0 ? <span className="truncate">{parent}</span> : null}
<span className="max-w-full shrink-0 truncate">{name}</span>
</span>
);
}
function ImportCandidateRow({
candidate,
label,
path,
nested = false,
checked,
onCheckedChange,
}: {
readonly candidate: ImportCandidate;
readonly label?: string;
readonly path?: string;
readonly nested?: boolean;
readonly checked: boolean;
readonly onCheckedChange: (checked: boolean) => void;
}) {
return (
<label
className={cn(
"flex cursor-pointer items-center gap-2.5 rounded-md px-2 py-1.5 hover:bg-muted/40 has-disabled:cursor-default",
nested && "pl-8",
)}
>
<Checkbox checked={checked} onCheckedChange={(value) => onCheckedChange(value === true)} />
<Tooltip>
<TooltipTrigger
render={<span className="flex min-w-0 flex-1 items-baseline gap-2 truncate" />}
>
{label !== undefined ? (
<span className="truncate text-sm font-medium">{label}</span>
) : null}
{path !== undefined ? (
<ProjectPathText
path={path}
className={label === undefined ? "text-xs" : "text-2xs text-muted-foreground"}
/>
) : null}
</TooltipTrigger>
<TooltipPopup variant="code">{candidate.path}</TooltipPopup>