// Browser login for a terminal. // The CLI can't receive an OAuth redirect, so it listens on 127.0.0.1 at a // free port. The browser brings back a single use code, which the CLI swaps // for tokens over a direct call. Tokens never travel through a URL. import http from "node:http"; import { deviceKeyFingerprint, generateDeviceSigningKey } from "@storeenv/core"; import open from "open"; import { StoreEnvError } from "@storeenv/core"; import { CLIENT_VERSION, api } from "./api.js"; import { deleteConfig, readConfig, updateConfig } from "./config.js"; import { deviceInfo, newDeviceKeys } from "./identity.js"; export const getToken = () => readConfig().token || null; export const ensureAuthenticated = () => { if (!getToken()) throw new StoreEnvError("SE_AUTH_REQUIRED"); }; const page = (title, body) => `StoreEnv

${title}

${body}

`; export const startCallbackServer = () => { let settle; const result = new Promise((resolve) => { settle = resolve; }); let respond = null; const server = http.createServer((req, res) => { const url = new URL(req.url, "http://127.0.0.1"); if (url.pathname !== "/callback") { res.writeHead(404).end(); return; } respond = (location, title, body) => { if (location) res.writeHead(302, { Location: location }).end(); else res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(page(title, body)); server.close(); }; settle({ code: url.searchParams.get("code"), state: url.searchParams.get("state"), error: url.searchParams.get("error") }); }); return new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", () => { resolve({ callbackUrl: `http://127.0.0.1:${server.address().port}/callback`, result, finish: (...args) => respond?.(...args), close: () => server.close(), }); }); }); }; export const openBrowser = async (url) => { try { await open(url); return true; } catch { return false; } }; export const login = async ({ browser = true, onUrl, timeoutMs = 5 * 60_000 } = {}) => { const callback = await startCallbackServer(); const keys = newDeviceKeys(); // This device's signing key (S1). It goes with the request so the device // that approves can certify it; it is stored once the identity arrives. const signing = generateDeviceSigningKey(); const shownKey = deviceKeyFingerprint(keys.publicKey, signing.publicKeyBase64); const previous = readConfig(); let timer; try { const start = await api.startLogin({ callback: callback.callbackUrl, ...deviceInfo(), clientVersion: CLIENT_VERSION, ephemeralPublicKey: keys.publicKey, signingKey: signing.publicKeyBase64, deviceId: previous.deviceId, }); const opened = browser ? await openBrowser(start.url) : false; // The device key is worked out here, from this device's own key, so an // approver can check the server didn't swap it (see core trust.js). onUrl?.({ url: start.url, code: start.code, opened, deviceKey: shownKey }); const timeout = new Promise((_, reject) => { timer = setTimeout(() => reject(new StoreEnvError("SE_AUTH_STATE_EXPIRED", "Timed out waiting for the browser.")), timeoutMs); }); const answer = await Promise.race([callback.result, timeout]); if (answer.error || !answer.code || answer.state !== start.state) { callback.finish(null, "Login cancelled", "You can close this tab and return to your terminal."); throw new StoreEnvError("SE_AUTH_REQUIRED", answer.error === "denied" ? "The login was cancelled in the browser." : "The login could not be completed.", { hint: "Run: storeenv login" }); } let session; try { session = await api.exchange({ code: answer.code, state: answer.state }); } catch (error) { callback.finish(null, "This login link has expired", "Run storeenv login again in your terminal."); throw error; } updateConfig({ token: session.token, refreshToken: session.refreshToken, expiresAt: Date.now() + session.expiresIn * 1000, userId: session.user.id, login: session.user.login, deviceId: session.device.id, deviceName: session.device.name, webUrl: session.webUrl, }); // Send the browser on: new accounts set up their key, everyone else // lands on the confirmation page. const next = session.user.hasIdentity ? `${session.webUrl}/auth/cli/success?code=${encodeURIComponent(session.approvalCode || "")}` : `${session.webUrl}/onboarding?cli=${encodeURIComponent(session.approvalCode || "")}`; callback.finish(next); return { user: session.user, device: session.device, approvalCode: session.approvalCode, deviceSecret: keys.secretKey, deviceKey: shownKey, signingKey: signing.privateKey, webUrl: session.webUrl }; } finally { clearTimeout(timer); callback.close(); } }; export const logout = async ({ everywhere = false } = {}) => { try { if (getToken()) await api.logout(everywhere); } catch { // The local session is removed even when the server can't be reached. } // The device record survives a sign out, so the next login reuses it. const config = readConfig(); deleteConfig(); const keep = {}; for (const field of ["apiUrl", "webUrl", "deviceId", "deviceName"]) if (config[field]) keep[field] = config[field]; if (Object.keys(keep).length) updateConfig(keep); };