@getjack/jack 0.1.12 → 0.1.14

package/package.json

@@ -1,16 +1,13 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.12",
+	"version": "0.1.14",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",
 	"bin": {
 		"jack": "./src/index.ts"
 	},
-	"files": [
-		"src",
-		"templates"
-	],
+	"files": ["src", "templates"],
 	"engines": {
 		"bun": ">=1.0.0"
 	},

package/src/commands/down.ts

@@ -88,13 +88,10 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			info(`Found "${name}" on jack cloud, linking locally...`);
 		}
 
-
 		// Guard against mismatched resolutions when an explicit name is provided
 		if (hasExplicitName && resolved) {
 			const matches =
-				name === resolved.slug ||
-				name === resolved.name ||
-				name === resolved.remote?.projectId;
+				name === resolved.slug || name === resolved.name || name === resolved.remote?.projectId;
 			if (!matches) {
 				error(`Refusing to undeploy '${name}' because it resolves to '${resolved.slug}'.`);
 				info("Use the exact slug/name shown by 'jack info' and try again.");

package/src/commands/login.ts

@@ -1,13 +1,4 @@
-import { input } from "@inquirer/prompts";
-import { type DeviceAuthResponse, pollDeviceToken, startDeviceAuth } from "../lib/auth/client.ts";
-import { type AuthCredentials, saveCredentials } from "../lib/auth/store.ts";
-import {
-	checkUsernameAvailable,
-	getCurrentUserProfile,
-	setUsername,
-} from "../lib/control-plane.ts";
-import { celebrate, error, info, spinner, success, warn } from "../lib/output.ts";
-import { identifyUser } from "../lib/telemetry.ts";
+import { type LoginFlowOptions, runLoginFlow } from "../lib/auth/login-flow.ts";
 
 interface LoginOptions {
 	/** Skip the initial "Logging in..." message (used when called from auto-login) */
@@ -15,197 +6,13 @@ interface LoginOptions {
 }
 
 export default async function login(options: LoginOptions = {}): Promise<void> {
-	if (!options.silent) {
-		info("Logging in to jack cloud...");
-		console.error("");
-	}
+	const flowOptions: LoginFlowOptions = {
+		silent: options.silent,
+	};
 
-	const spin = spinner("Starting login...");
-	let deviceAuth: DeviceAuthResponse;
+	const result = await runLoginFlow(flowOptions);
 
-	try {
-		deviceAuth = await startDeviceAuth();
-		spin.stop();
-	} catch (err) {
-		spin.stop();
-		error(err instanceof Error ? err.message : "Failed to start login");
+	if (!result.success) {
 		process.exit(1);
 	}
-
-	celebrate("Your code:", [deviceAuth.user_code]);
-	info(`Opening ${deviceAuth.verification_uri} in your browser...`);
-	console.error("");
-
-	// Open browser - use Bun.spawn for cross-platform
-	try {
-		const platform = process.platform;
-		const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-		Bun.spawn([cmd, deviceAuth.verification_uri_complete]);
-	} catch {
-		info(`If the browser didn't open, go to: ${deviceAuth.verification_uri_complete}`);
-	}
-
-	const pollSpin = spinner("Waiting for you to complete login in browser...");
-	const interval = (deviceAuth.interval || 5) * 1000;
-	const expiresAt = Date.now() + deviceAuth.expires_in * 1000;
-
-	while (Date.now() < expiresAt) {
-		await sleep(interval);
-
-		try {
-			const tokens = await pollDeviceToken(deviceAuth.device_code);
-
-			if (tokens) {
-				pollSpin.stop();
-
-				// Default to 5 minutes if expires_in not provided
-				const expiresIn = tokens.expires_in ?? 300;
-				const creds: AuthCredentials = {
-					access_token: tokens.access_token,
-					refresh_token: tokens.refresh_token,
-					expires_at: Math.floor(Date.now() / 1000) + expiresIn,
-					user: tokens.user,
-				};
-				await saveCredentials(creds);
-
-				// Link user identity for cross-platform analytics
-				await identifyUser(tokens.user.id, { email: tokens.user.email });
-
-				console.error("");
-				const displayName = tokens.user.first_name || "Logged in";
-				success(tokens.user.first_name ? `Welcome back, ${displayName}` : displayName);
-
-				// Prompt for username if not set
-				await promptForUsername(tokens.user.email);
-				return;
-			}
-		} catch (err) {
-			pollSpin.stop();
-			error(err instanceof Error ? err.message : "Login failed");
-			process.exit(1);
-		}
-	}
-
-	pollSpin.stop();
-	error("Login timed out. Please try again.");
-	process.exit(1);
-}
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
-async function promptForUsername(email: string): Promise<void> {
-	// Skip in non-TTY environments
-	if (!process.stdout.isTTY) {
-		return;
-	}
-
-	const spin = spinner("Checking account...");
-
-	try {
-		const profile = await getCurrentUserProfile();
-		spin.stop();
-
-		// If user already has a username, skip
-		if (profile?.username) {
-			return;
-		}
-
-		console.error("");
-		info("Choose a username for your jack cloud account.");
-		info("URLs will look like: alice-vibes.runjack.xyz");
-		console.error("");
-
-		// Generate suggestions from $USER env var and email
-		const suggestions = generateUsernameSuggestions(email);
-
-		let username: string | null = null;
-
-		while (!username) {
-			// Show suggestions if available
-			if (suggestions.length > 0) {
-				info(`Suggestions: ${suggestions.join(", ")}`);
-			}
-
-			const inputUsername = await input({
-				message: "Username:",
-				default: suggestions[0],
-				validate: (value) => {
-					if (!value || value.length < 3) {
-						return "Username must be at least 3 characters";
-					}
-					if (value.length > 39) {
-						return "Username must be 39 characters or less";
-					}
-					if (value !== value.toLowerCase()) {
-						return "Username must be lowercase";
-					}
-					if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]{1,2}$/.test(value)) {
-						return "Use only lowercase letters, numbers, and hyphens";
-					}
-					return true;
-				},
-			});
-
-			// Check availability
-			const checkSpin = spinner("Checking availability...");
-			const availability = await checkUsernameAvailable(inputUsername);
-			checkSpin.stop();
-
-			if (!availability.available) {
-				warn(availability.error || `Username "${inputUsername}" is already taken. Try another.`);
-				continue;
-			}
-
-			// Try to set the username
-			const setSpin = spinner("Setting username...");
-			try {
-				await setUsername(inputUsername);
-				setSpin.stop();
-				username = inputUsername;
-				success(`Username set to "${username}"`);
-			} catch (err) {
-				setSpin.stop();
-				warn(err instanceof Error ? err.message : "Failed to set username");
-			}
-		}
-	} catch (err) {
-		spin.stop();
-		// Non-fatal - user can set username later
-		warn("Could not set username. You can set it later.");
-	}
-}
-
-function generateUsernameSuggestions(email: string): string[] {
-	const suggestions: string[] = [];
-
-	// Try $USER environment variable first
-	const envUser = process.env.USER || process.env.USERNAME;
-	if (envUser) {
-		const normalized = normalizeToUsername(envUser);
-		if (normalized && normalized.length >= 3) {
-			suggestions.push(normalized);
-		}
-	}
-
-	// Try email local part
-	const emailLocal = email.split("@")[0];
-	if (emailLocal) {
-		const normalized = normalizeToUsername(emailLocal);
-		if (normalized && normalized.length >= 3 && !suggestions.includes(normalized)) {
-			suggestions.push(normalized);
-		}
-	}
-
-	return suggestions.slice(0, 3); // Max 3 suggestions
-}
-
-function normalizeToUsername(input: string): string {
-	return input
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "")
-		.slice(0, 39);
-}
-

package/src/lib/auth/ensure-auth.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Unit tests for ensure-auth.ts
+ *
+ * Tests the auth gate decision tree for project creation.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from "bun:test";
+
+// Mock modules before importing the module under test
+const mockIsLoggedIn = mock(() => Promise.resolve(false));
+const mockHasWrangler = mock(() => Promise.resolve(false));
+const mockIsAuthenticated = mock(() => Promise.resolve(false));
+const mockRunLoginFlow = mock(() => Promise.resolve({ success: true }));
+const mockPromptSelect = mock(() => Promise.resolve(0));
+const mockTrack = mock(() => {});
+
+mock.module("./store.ts", () => ({
+	isLoggedIn: mockIsLoggedIn,
+}));
+
+mock.module("../wrangler.ts", () => ({
+	hasWrangler: mockHasWrangler,
+	isAuthenticated: mockIsAuthenticated,
+}));
+
+mock.module("./login-flow.ts", () => ({
+	runLoginFlow: mockRunLoginFlow,
+}));
+
+mock.module("../hooks.ts", () => ({
+	promptSelect: mockPromptSelect,
+}));
+
+mock.module("../telemetry.ts", () => ({
+	Events: { AUTH_GATE_RESOLVED: "auth_gate_resolved" },
+	track: mockTrack,
+}));
+
+// Import after mocking
+import { ensureAuthForCreate } from "./ensure-auth.ts";
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe("ensureAuthForCreate", () => {
+	beforeEach(() => {
+		// Reset all mocks to default state
+		mockIsLoggedIn.mockReset();
+		mockHasWrangler.mockReset();
+		mockIsAuthenticated.mockReset();
+		mockRunLoginFlow.mockReset();
+		mockPromptSelect.mockReset();
+		mockTrack.mockReset();
+
+		// Set default return values
+		mockIsLoggedIn.mockResolvedValue(false);
+		mockHasWrangler.mockResolvedValue(false);
+		mockIsAuthenticated.mockResolvedValue(false);
+		mockRunLoginFlow.mockResolvedValue({ success: true });
+		mockPromptSelect.mockResolvedValue(0);
+
+		// Suppress console.error during tests
+		spyOn(console, "error").mockImplementation(() => {});
+	});
+
+	afterEach(() => {
+		mock.restore();
+	});
+
+	// ==========================================================================
+	// PRD Test Scenarios
+	// ==========================================================================
+
+	describe("PRD Decision Tree", () => {
+		it("proceeds immediately if already logged into jack cloud", async () => {
+			// Scenario: Existing jack cloud user
+			mockIsLoggedIn.mockResolvedValue(true);
+
+			const result = await ensureAuthForCreate();
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(false);
+			expect(mockRunLoginFlow).not.toHaveBeenCalled();
+			expect(mockPromptSelect).not.toHaveBeenCalled();
+			expect(mockTrack).toHaveBeenCalledWith("auth_gate_resolved", {
+				mode: "managed",
+				reason: "already_logged_in",
+			});
+		});
+
+		it("proceeds with managed mode if logged in, even with wrangler available", async () => {
+			// Scenario: Existing jack cloud user + wrangler
+			mockIsLoggedIn.mockResolvedValue(true);
+			mockHasWrangler.mockResolvedValue(true);
+			mockIsAuthenticated.mockResolvedValue(true);
+
+			const result = await ensureAuthForCreate();
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(false);
+			expect(mockPromptSelect).not.toHaveBeenCalled();
+		});
+
+		it("prompts for choice when wrangler + CF auth available", async () => {
+			// Scenario: Fresh user, wrangler + CF auth
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(true);
+			mockIsAuthenticated.mockResolvedValue(true);
+			mockPromptSelect.mockResolvedValue(0); // User chooses jack cloud
+
+			const result = await ensureAuthForCreate({ interactive: true });
+
+			expect(mockPromptSelect).toHaveBeenCalled();
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(true);
+			expect(mockRunLoginFlow).toHaveBeenCalled();
+		});
+
+		it("returns BYO mode when user chooses their Cloudflare account", async () => {
+			// Scenario: Fresh user with wrangler + CF auth, chooses BYO
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(true);
+			mockIsAuthenticated.mockResolvedValue(true);
+			mockPromptSelect.mockResolvedValue(1); // User chooses BYO
+
+			const result = await ensureAuthForCreate({ interactive: true });
+
+			expect(result.mode).toBe("byo");
+			expect(result.didLogin).toBe(false);
+			expect(mockRunLoginFlow).not.toHaveBeenCalled();
+			expect(mockTrack).toHaveBeenCalledWith("auth_gate_resolved", {
+				mode: "byo",
+				reason: "user_chose_byo",
+			});
+		});
+
+		it("auto-starts jack cloud login when no wrangler installed", async () => {
+			// Scenario: Fresh user, no wrangler
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(false);
+
+			const result = await ensureAuthForCreate({ interactive: true });
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(true);
+			expect(mockRunLoginFlow).toHaveBeenCalled();
+			expect(mockPromptSelect).not.toHaveBeenCalled();
+			expect(mockTrack).toHaveBeenCalledWith("auth_gate_resolved", {
+				mode: "managed",
+				reason: "auto_login_no_wrangler",
+			});
+		});
+
+		it("auto-starts jack cloud login when wrangler installed but not authenticated", async () => {
+			// Scenario: Fresh user, wrangler installed but not logged in
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(true);
+			mockIsAuthenticated.mockResolvedValue(false);
+
+			const result = await ensureAuthForCreate({ interactive: true });
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(true);
+			expect(mockRunLoginFlow).toHaveBeenCalled();
+			expect(mockPromptSelect).not.toHaveBeenCalled();
+			expect(mockTrack).toHaveBeenCalledWith("auth_gate_resolved", {
+				mode: "managed",
+				reason: "auto_login_no_cf_auth",
+			});
+		});
+	});
+
+	// ==========================================================================
+	// Force Flags
+	// ==========================================================================
+
+	describe("Force flags", () => {
+		it("respects forceByo flag without checking auth", async () => {
+			mockIsLoggedIn.mockResolvedValue(true); // Even if logged in
+
+			const result = await ensureAuthForCreate({ forceByo: true });
+
+			expect(result.mode).toBe("byo");
+			expect(result.didLogin).toBe(false);
+			expect(mockTrack).toHaveBeenCalledWith("auth_gate_resolved", {
+				mode: "byo",
+				reason: "forced_byo",
+			});
+		});
+
+		it("respects forceManaged flag and triggers login if needed", async () => {
+			mockIsLoggedIn.mockResolvedValue(false);
+
+			const result = await ensureAuthForCreate({ forceManaged: true });
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(true);
+			expect(mockRunLoginFlow).toHaveBeenCalled();
+		});
+
+		it("respects forceManaged flag without login if already logged in", async () => {
+			mockIsLoggedIn.mockResolvedValue(true);
+
+			const result = await ensureAuthForCreate({ forceManaged: true });
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(false);
+			expect(mockRunLoginFlow).not.toHaveBeenCalled();
+		});
+
+		it("throws error when both forceManaged and forceByo are set", async () => {
+			await expect(
+				ensureAuthForCreate({ forceManaged: true, forceByo: true }),
+			).rejects.toThrow("Cannot use both --managed and --byo flags");
+		});
+	});
+
+	// ==========================================================================
+	// Non-interactive mode
+	// ==========================================================================
+
+	describe("Non-interactive mode", () => {
+		it("uses BYO mode when wrangler + CF auth available in non-interactive mode", async () => {
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(true);
+			mockIsAuthenticated.mockResolvedValue(true);
+
+			const result = await ensureAuthForCreate({ interactive: false });
+
+			expect(result.mode).toBe("byo");
+			expect(result.didLogin).toBe(false);
+			expect(mockPromptSelect).not.toHaveBeenCalled();
+			expect(mockTrack).toHaveBeenCalledWith("auth_gate_resolved", {
+				mode: "byo",
+				reason: "non_interactive_fallback",
+			});
+		});
+
+		it("throws error in non-interactive mode when no auth available", async () => {
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(false);
+
+			await expect(ensureAuthForCreate({ interactive: false })).rejects.toThrow(
+				"Not logged in and wrangler not authenticated",
+			);
+		});
+
+		it("proceeds with managed mode in non-interactive if already logged in", async () => {
+			mockIsLoggedIn.mockResolvedValue(true);
+
+			const result = await ensureAuthForCreate({ interactive: false });
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(false);
+		});
+	});
+
+	// ==========================================================================
+	// Edge cases
+	// ==========================================================================
+
+	describe("Edge cases", () => {
+		it("handles Esc key during prompt (defaults to jack cloud login)", async () => {
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(true);
+			mockIsAuthenticated.mockResolvedValue(true);
+			mockPromptSelect.mockResolvedValue(-1); // Esc key
+
+			const result = await ensureAuthForCreate({ interactive: true });
+
+			expect(result.mode).toBe("managed");
+			expect(result.didLogin).toBe(true);
+			expect(mockRunLoginFlow).toHaveBeenCalled();
+		});
+
+		it("throws error when login flow fails", async () => {
+			mockIsLoggedIn.mockResolvedValue(false);
+			mockHasWrangler.mockResolvedValue(false);
+			mockRunLoginFlow.mockResolvedValue({ success: false });
+
+			await expect(ensureAuthForCreate({ interactive: true })).rejects.toThrow("Login failed");
+		});
+	});
+});

package/src/lib/auth/ensure-auth.ts

@@ -0,0 +1,165 @@
+/**
+ * Auth gate for project creation
+ *
+ * Implements the decision tree from PRD-LOGIN-PROMPT-ON-NEW.md:
+ * 1. Jack cloud logged in -> return 'managed', no prompt
+ * 2. Wrangler installed + CF authenticated -> offer choice via promptSelect
+ * 3. Otherwise -> auto-start jack cloud login
+ */
+
+import type { DeployMode } from "../project-link.ts";
+import { Events, track } from "../telemetry.ts";
+import { hasWrangler, isAuthenticated } from "../wrangler.ts";
+import { isLoggedIn } from "./store.ts";
+
+export interface EnsureAuthResult {
+	mode: DeployMode;
+	didLogin: boolean;
+}
+
+export interface EnsureAuthOptions {
+	interactive?: boolean;
+	forceManaged?: boolean;
+	forceByo?: boolean;
+}
+
+type AuthGateReason =
+	| "already_logged_in"
+	| "forced_managed"
+	| "forced_byo"
+	| "user_chose_managed"
+	| "user_chose_byo"
+	| "auto_login_no_wrangler"
+	| "auto_login_no_cf_auth"
+	| "non_interactive_fallback";
+
+/**
+ * Ensure authentication is in place before project creation.
+ *
+ * Decision tree:
+ * 1. If forceManaged or forceByo flags are set, respect them
+ * 2. If already logged into jack cloud -> return 'managed'
+ * 3. If wrangler installed AND authenticated to Cloudflare -> offer choice
+ * 4. Otherwise -> auto-start jack cloud login
+ */
+export async function ensureAuthForCreate(
+	options: EnsureAuthOptions = {},
+): Promise<EnsureAuthResult> {
+	const { interactive = true, forceManaged, forceByo } = options;
+
+	// Handle explicit flags first
+	if (forceManaged && forceByo) {
+		throw new Error("Cannot use both --managed and --byo flags. Choose one.");
+	}
+
+	if (forceByo) {
+		track(Events.AUTH_GATE_RESOLVED, { mode: "byo", reason: "forced_byo" as AuthGateReason });
+		return { mode: "byo", didLogin: false };
+	}
+
+	if (forceManaged) {
+		// Need to ensure logged in for managed mode
+		const loggedIn = await isLoggedIn();
+		if (loggedIn) {
+			track(Events.AUTH_GATE_RESOLVED, {
+				mode: "managed",
+				reason: "forced_managed" as AuthGateReason,
+			});
+			return { mode: "managed", didLogin: false };
+		}
+		// Force managed but not logged in - run login flow
+		await runLoginFlow();
+		track(Events.AUTH_GATE_RESOLVED, {
+			mode: "managed",
+			reason: "forced_managed" as AuthGateReason,
+		});
+		return { mode: "managed", didLogin: true };
+	}
+
+	// Step 1: Check if already logged into jack cloud
+	const loggedIn = await isLoggedIn();
+	if (loggedIn) {
+		track(Events.AUTH_GATE_RESOLVED, {
+			mode: "managed",
+			reason: "already_logged_in" as AuthGateReason,
+		});
+		return { mode: "managed", didLogin: false };
+	}
+
+	// Step 2: Check if wrangler is installed AND authenticated to Cloudflare
+	const wranglerInstalled = await hasWrangler();
+	const cfAuthenticated = wranglerInstalled && (await isAuthenticated());
+
+	if (cfAuthenticated && interactive) {
+		// Offer choice between jack cloud and BYO
+		const { promptSelect } = await import("../hooks.ts");
+
+		console.error("");
+		console.error("  How do you want to deploy?");
+		console.error("");
+
+		const choice = await promptSelect([
+			"Jack Cloud (recommended) - instant deploys, no setup",
+			"My Cloudflare account - use existing wrangler auth",
+		]);
+
+		if (choice === 0) {
+			// User chose jack cloud - start login
+			await runLoginFlow();
+			track(Events.AUTH_GATE_RESOLVED, {
+				mode: "managed",
+				reason: "user_chose_managed" as AuthGateReason,
+			});
+			return { mode: "managed", didLogin: true };
+		}
+		if (choice === 1) {
+			// User chose BYO
+			track(Events.AUTH_GATE_RESOLVED, { mode: "byo", reason: "user_chose_byo" as AuthGateReason });
+			return { mode: "byo", didLogin: false };
+		}
+		// User pressed Esc - default to jack cloud login
+		await runLoginFlow();
+		track(Events.AUTH_GATE_RESOLVED, {
+			mode: "managed",
+			reason: "user_chose_managed" as AuthGateReason,
+		});
+		return { mode: "managed", didLogin: true };
+	}
+
+	// Non-interactive mode with wrangler available - use BYO
+	if (cfAuthenticated && !interactive) {
+		track(Events.AUTH_GATE_RESOLVED, {
+			mode: "byo",
+			reason: "non_interactive_fallback" as AuthGateReason,
+		});
+		return { mode: "byo", didLogin: false };
+	}
+
+	// Step 3: No viable BYO path - auto-start jack cloud login
+	const reason: AuthGateReason = !wranglerInstalled
+		? "auto_login_no_wrangler"
+		: "auto_login_no_cf_auth";
+
+	if (!interactive) {
+		// Non-interactive and no auth available - this is an error condition
+		throw new Error(
+			"Not logged in and wrangler not authenticated. Run 'jack login' or 'wrangler login' first.",
+		);
+	}
+
+	// Auto-start login (no prompt - there's only one viable path)
+	await runLoginFlow();
+	track(Events.AUTH_GATE_RESOLVED, { mode: "managed", reason });
+	return { mode: "managed", didLogin: true };
+}
+
+/**
+ * Run the login flow (dynamic import to avoid circular dependency)
+ */
+async function runLoginFlow(): Promise<void> {
+	const { runLoginFlow: doLogin } = await import("./login-flow.ts");
+	const result = await doLogin({ silent: false });
+	if (!result.success) {
+		throw new Error("Login failed");
+	}
+}