@wingman-ai/gateway 0.1.0

package/dist/providers/credentials.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getProviderSpec } from "./registry.js";
+const CREDENTIALS_VERSION = 1;
+const CREDENTIALS_DIR = join(homedir(), ".wingman");
+const CREDENTIALS_PATH = join(CREDENTIALS_DIR, "credentials.json");
+function getCredentialsPath() {
+    return CREDENTIALS_PATH;
+}
+function emptyCredentials() {
+    return {
+        version: CREDENTIALS_VERSION,
+        updatedAt: new Date().toISOString(),
+        providers: {}
+    };
+}
+function readCredentialsFile() {
+    if (!existsSync(CREDENTIALS_PATH)) return emptyCredentials();
+    try {
+        const raw = readFileSync(CREDENTIALS_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        const providers = parsed && "object" == typeof parsed.providers && parsed.providers ? parsed.providers : {};
+        return {
+            version: "number" == typeof parsed?.version ? parsed.version : CREDENTIALS_VERSION,
+            updatedAt: "string" == typeof parsed?.updatedAt ? parsed.updatedAt : new Date().toISOString(),
+            providers
+        };
+    } catch  {
+        return emptyCredentials();
+    }
+}
+function writeCredentialsFile(data) {
+    mkdirSync(CREDENTIALS_DIR, {
+        recursive: true
+    });
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(data, null, 2));
+}
+function getProviderCredentials(provider) {
+    const file = readCredentialsFile();
+    return file.providers[provider];
+}
+function setProviderCredentials(provider, credentials) {
+    const file = readCredentialsFile();
+    file.providers[provider] = {
+        ...file.providers[provider] || {},
+        ...credentials
+    };
+    file.updatedAt = new Date().toISOString();
+    writeCredentialsFile(file);
+}
+function deleteProviderCredentials(provider) {
+    const file = readCredentialsFile();
+    if (!file.providers[provider]) return false;
+    delete file.providers[provider];
+    file.updatedAt = new Date().toISOString();
+    writeCredentialsFile(file);
+    return true;
+}
+function saveProviderToken(providerName, token) {
+    const provider = getProviderSpec(providerName);
+    if (!provider) throw new Error(`Unknown provider: "${providerName}"`);
+    const normalized = token.trim();
+    if (!normalized) throw new Error("Token is required");
+    const existing = getProviderCredentials(provider.name) || {};
+    const updated = {
+        ...existing
+    };
+    if ("oauth" === provider.type) {
+        updated.accessToken = normalized;
+        updated.tokenType = "bearer";
+    } else updated.apiKey = normalized;
+    setProviderCredentials(provider.name, updated);
+    return updated;
+}
+function resolveProviderToken(providerName) {
+    const provider = getProviderSpec(providerName);
+    if (!provider) return {
+        source: "missing"
+    };
+    for (const envVar of provider.envVars){
+        const value = process.env[envVar];
+        if (value && value.trim()) return {
+            token: value.trim(),
+            source: "env",
+            envVar
+        };
+    }
+    const credentials = getProviderCredentials(provider.name);
+    const token = credentials?.accessToken ?? credentials?.apiKey ?? credentials?.refreshToken;
+    if (token && token.trim()) return {
+        token: token.trim(),
+        source: "credentials"
+    };
+    return {
+        source: "missing"
+    };
+}
+export { deleteProviderCredentials, getCredentialsPath, getProviderCredentials, readCredentialsFile, resolveProviderToken, saveProviderToken, setProviderCredentials, writeCredentialsFile };

package/dist/providers/oauth.cjs

@@ -0,0 +1,279 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    loginWithLocalCallback: ()=>loginWithLocalCallback
+});
+const external_node_http_namespaceObject = require("node:http");
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_url_namespaceObject = require("node:url");
+const external_registry_cjs_namespaceObject = require("./registry.cjs");
+const DEFAULT_TIMEOUT_MS = 300000;
+async function loginWithLocalCallback(providerName, options = {}) {
+    const provider = (0, external_registry_cjs_namespaceObject.getProviderSpec)(providerName);
+    if (!provider || !provider.oauth) throw new Error(`OAuth is not configured for provider "${providerName}"`);
+    const session = await createOAuthSession(provider.oauth, options);
+    const openBrowser = false !== options.openBrowser;
+    if (openBrowser) try {
+        await launchBrowser(session.authorizationUrl);
+    } catch  {
+        options.onMessage?.("Unable to auto-open browser.");
+    }
+    options.onMessage?.(`Open this URL to continue:\n${session.authorizationUrl}`);
+    let callback;
+    try {
+        callback = await session.waitForCallback;
+    } finally{
+        session.close();
+    }
+    const token = await exchangeCodeForToken(provider.name, provider.oauth, {
+        code: callback.code,
+        codeVerifier: session.codeVerifier,
+        redirectUri: session.redirectUri,
+        clientId: resolveClientId(provider.oauth, options),
+        clientSecret: resolveClientSecret(provider.oauth, options)
+    });
+    return token;
+}
+async function createOAuthSession(oauth, options) {
+    const redirectHost = options.redirectHost || "127.0.0.1";
+    const redirectPort = options.redirectPort ?? 53682;
+    const redirectPath = oauth.redirectPath || "/oauth/callback";
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const usePkce = false !== oauth.usePkce;
+    const state = base64Url((0, external_node_crypto_namespaceObject.randomBytes)(16));
+    const codeVerifier = usePkce ? base64Url((0, external_node_crypto_namespaceObject.randomBytes)(32)) : "";
+    const codeChallenge = usePkce ? base64Url((0, external_node_crypto_namespaceObject.createHash)("sha256").update(codeVerifier).digest()) : "";
+    const server = (0, external_node_http_namespaceObject.createServer)();
+    const waitForCallback = new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            reject(new Error("Login timed out. Please try again."));
+            server.close();
+        }, timeoutMs);
+        server.on("request", (req, res)=>{
+            if (!req.url) {
+                res.statusCode = 400;
+                res.end("Missing request URL.");
+                return;
+            }
+            const url = new external_node_url_namespaceObject.URL(req.url, `http://${redirectHost}`);
+            if (url.pathname !== redirectPath) {
+                res.statusCode = 404;
+                res.end("Not found.");
+                return;
+            }
+            const error = url.searchParams.get("error");
+            if (error) {
+                clearTimeout(timer);
+                const errorDescription = url.searchParams.get("error_description") || error;
+                res.statusCode = 400;
+                res.end(`Login failed: ${errorDescription}`);
+                reject(new Error(`Login failed: ${errorDescription}`));
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const callbackState = url.searchParams.get("state");
+            if (!code || !callbackState) {
+                clearTimeout(timer);
+                res.statusCode = 400;
+                res.end("Missing authorization response.");
+                reject(new Error("Missing authorization response."));
+                return;
+            }
+            if (callbackState !== state) {
+                clearTimeout(timer);
+                res.statusCode = 400;
+                res.end("State mismatch.");
+                reject(new Error("State mismatch."));
+                return;
+            }
+            clearTimeout(timer);
+            res.statusCode = 200;
+            res.end("Login complete. You can close this window.");
+            resolve({
+                code,
+                state: callbackState
+            });
+        });
+    });
+    try {
+        await new Promise((resolve, reject)=>{
+            server.listen(redirectPort, redirectHost, ()=>resolve());
+            server.on("error", reject);
+        });
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to start local callback server on ${redirectHost}:${redirectPort}. ${message}. Use --redirect-port to choose a different port.`);
+    }
+    const address = server.address();
+    const redirectUri = `http://${redirectHost}:${address.port}${redirectPath}`;
+    const authorizationUrl = buildAuthorizationUrl(oauth, {
+        clientId: resolveClientId(oauth, options),
+        redirectUri,
+        state,
+        codeChallenge,
+        scopes: resolveScopes(oauth, options),
+        usePkce
+    });
+    return {
+        authorizationUrl,
+        redirectUri,
+        waitForCallback,
+        close: ()=>server.close(),
+        codeVerifier
+    };
+}
+function resolveClientId(oauth, options) {
+    const value = options.clientId || resolveEnv(oauth.clientIdEnv) || oauth.defaultClientId;
+    if (!value) {
+        const envList = oauth.clientIdEnv.join(", ");
+        throw new Error(`Missing OAuth client ID. Set ${envList} or pass --client-id.`);
+    }
+    return value;
+}
+function resolveClientSecret(oauth, options) {
+    const value = options.clientSecret || resolveEnv(oauth.clientSecretEnv || []) || oauth.defaultClientSecret;
+    return value || void 0;
+}
+function resolveScopes(oauth, options) {
+    if (options.scopes && options.scopes.length > 0) return options.scopes;
+    return oauth.scopes || [];
+}
+function buildAuthorizationUrl(oauth, input) {
+    const url = new external_node_url_namespaceObject.URL(oauth.authorizationUrl);
+    url.searchParams.set("client_id", input.clientId);
+    url.searchParams.set("redirect_uri", input.redirectUri);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("state", input.state);
+    if (input.usePkce) {
+        url.searchParams.set("code_challenge", input.codeChallenge);
+        url.searchParams.set("code_challenge_method", "S256");
+    }
+    if (input.scopes.length > 0) url.searchParams.set("scope", input.scopes.join(oauth.scopeSeparator || " "));
+    if (oauth.authorizationParams) for (const [key, value] of Object.entries(oauth.authorizationParams))url.searchParams.set(key, value);
+    return url.toString();
+}
+async function exchangeCodeForToken(providerName, oauth, input) {
+    const body = new external_node_url_namespaceObject.URLSearchParams({
+        client_id: input.clientId,
+        code: input.code,
+        redirect_uri: input.redirectUri,
+        grant_type: "authorization_code"
+    });
+    if (false !== oauth.usePkce) body.set("code_verifier", input.codeVerifier);
+    if (input.clientSecret) body.set("client_secret", input.clientSecret);
+    if (oauth.tokenParams) for (const [key, value] of Object.entries(oauth.tokenParams))body.set(key, value);
+    const response = await fetch(oauth.tokenUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Accept: "application/json",
+            ...oauth.tokenHeaders || {}
+        },
+        body: body.toString()
+    });
+    const contentType = response.headers.get("content-type") || "";
+    const rawText = await response.text();
+    let payload = {};
+    payload = "form" === oauth.tokenResponseType ? Object.fromEntries(new external_node_url_namespaceObject.URLSearchParams(rawText)) : "json" === oauth.tokenResponseType ? JSON.parse(rawText) : contentType.includes("application/json") ? JSON.parse(rawText) : Object.fromEntries(new external_node_url_namespaceObject.URLSearchParams(rawText));
+    if (!response.ok || payload.error) {
+        const description = payload.error_description || payload.error || rawText;
+        throw new Error(`Token exchange failed: ${description}`);
+    }
+    const credentials = mapTokenResponse(providerName, payload);
+    if (payload.expires_in) {
+        const expiresIn = Number(payload.expires_in);
+        if (!Number.isNaN(expiresIn)) credentials.expiresAt = new Date(Date.now() + 1000 * expiresIn).toISOString();
+    }
+    if (!credentials.expiresAt && payload.expires_at) {
+        const expiresAt = Number(payload.expires_at);
+        if (!Number.isNaN(expiresAt)) credentials.expiresAt = new Date(1000 * expiresAt).toISOString();
+    }
+    return credentials;
+}
+function mapTokenResponse(providerName, payload) {
+    const mapper = TOKEN_MAPPERS[providerName];
+    if (mapper) return mapper(payload);
+    const accessToken = payload.access_token;
+    if (!accessToken) throw new Error("Token exchange failed: missing access token.");
+    return {
+        accessToken,
+        refreshToken: payload.refresh_token,
+        tokenType: payload.token_type || "bearer"
+    };
+}
+const TOKEN_MAPPERS = {
+    copilot: (payload)=>{
+        const accessToken = payload.access_token;
+        if (!accessToken) throw new Error("Token exchange failed: missing access token.");
+        return {
+            refreshToken: accessToken,
+            tokenType: payload.token_type || "bearer"
+        };
+    }
+};
+function resolveEnv(envVars) {
+    for (const key of envVars){
+        const value = process.env[key];
+        if (value && value.trim()) return value.trim();
+    }
+}
+function base64Url(buffer) {
+    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function launchBrowser(url) {
+    const platform = process.platform;
+    if ("darwin" === platform) return void await spawnBrowser("open", [
+        url
+    ]);
+    if ("win32" === platform) return void await spawnBrowser("cmd", [
+        "/c",
+        "start",
+        "",
+        url
+    ]);
+    await spawnBrowser("xdg-open", [
+        url
+    ]);
+}
+function spawnBrowser(command, args) {
+    return new Promise((resolve, reject)=>{
+        const child = (0, external_node_child_process_namespaceObject.spawn)(command, args, {
+            stdio: "ignore",
+            detached: true
+        });
+        child.once("error", reject);
+        child.once("spawn", ()=>resolve());
+        child.unref();
+    });
+}
+exports.loginWithLocalCallback = __webpack_exports__.loginWithLocalCallback;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loginWithLocalCallback"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/providers/oauth.d.ts

@@ -0,0 +1,13 @@
+import { type ProviderName } from "./registry.js";
+import type { ProviderCredentials } from "./credentials.js";
+export interface OAuthLoginOptions {
+    clientId?: string;
+    clientSecret?: string;
+    scopes?: string[];
+    redirectHost?: string;
+    redirectPort?: number;
+    openBrowser?: boolean;
+    timeoutMs?: number;
+    onMessage?: (message: string) => void;
+}
+export declare function loginWithLocalCallback(providerName: ProviderName, options?: OAuthLoginOptions): Promise<ProviderCredentials>;

package/dist/providers/oauth.js

@@ -0,0 +1,245 @@
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { URL, URLSearchParams } from "node:url";
+import { getProviderSpec } from "./registry.js";
+const DEFAULT_TIMEOUT_MS = 300000;
+async function loginWithLocalCallback(providerName, options = {}) {
+    const provider = getProviderSpec(providerName);
+    if (!provider || !provider.oauth) throw new Error(`OAuth is not configured for provider "${providerName}"`);
+    const session = await createOAuthSession(provider.oauth, options);
+    const openBrowser = false !== options.openBrowser;
+    if (openBrowser) try {
+        await launchBrowser(session.authorizationUrl);
+    } catch  {
+        options.onMessage?.("Unable to auto-open browser.");
+    }
+    options.onMessage?.(`Open this URL to continue:\n${session.authorizationUrl}`);
+    let callback;
+    try {
+        callback = await session.waitForCallback;
+    } finally{
+        session.close();
+    }
+    const token = await exchangeCodeForToken(provider.name, provider.oauth, {
+        code: callback.code,
+        codeVerifier: session.codeVerifier,
+        redirectUri: session.redirectUri,
+        clientId: resolveClientId(provider.oauth, options),
+        clientSecret: resolveClientSecret(provider.oauth, options)
+    });
+    return token;
+}
+async function createOAuthSession(oauth, options) {
+    const redirectHost = options.redirectHost || "127.0.0.1";
+    const redirectPort = options.redirectPort ?? 53682;
+    const redirectPath = oauth.redirectPath || "/oauth/callback";
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const usePkce = false !== oauth.usePkce;
+    const state = base64Url(randomBytes(16));
+    const codeVerifier = usePkce ? base64Url(randomBytes(32)) : "";
+    const codeChallenge = usePkce ? base64Url(createHash("sha256").update(codeVerifier).digest()) : "";
+    const server = createServer();
+    const waitForCallback = new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            reject(new Error("Login timed out. Please try again."));
+            server.close();
+        }, timeoutMs);
+        server.on("request", (req, res)=>{
+            if (!req.url) {
+                res.statusCode = 400;
+                res.end("Missing request URL.");
+                return;
+            }
+            const url = new URL(req.url, `http://${redirectHost}`);
+            if (url.pathname !== redirectPath) {
+                res.statusCode = 404;
+                res.end("Not found.");
+                return;
+            }
+            const error = url.searchParams.get("error");
+            if (error) {
+                clearTimeout(timer);
+                const errorDescription = url.searchParams.get("error_description") || error;
+                res.statusCode = 400;
+                res.end(`Login failed: ${errorDescription}`);
+                reject(new Error(`Login failed: ${errorDescription}`));
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const callbackState = url.searchParams.get("state");
+            if (!code || !callbackState) {
+                clearTimeout(timer);
+                res.statusCode = 400;
+                res.end("Missing authorization response.");
+                reject(new Error("Missing authorization response."));
+                return;
+            }
+            if (callbackState !== state) {
+                clearTimeout(timer);
+                res.statusCode = 400;
+                res.end("State mismatch.");
+                reject(new Error("State mismatch."));
+                return;
+            }
+            clearTimeout(timer);
+            res.statusCode = 200;
+            res.end("Login complete. You can close this window.");
+            resolve({
+                code,
+                state: callbackState
+            });
+        });
+    });
+    try {
+        await new Promise((resolve, reject)=>{
+            server.listen(redirectPort, redirectHost, ()=>resolve());
+            server.on("error", reject);
+        });
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to start local callback server on ${redirectHost}:${redirectPort}. ${message}. Use --redirect-port to choose a different port.`);
+    }
+    const address = server.address();
+    const redirectUri = `http://${redirectHost}:${address.port}${redirectPath}`;
+    const authorizationUrl = buildAuthorizationUrl(oauth, {
+        clientId: resolveClientId(oauth, options),
+        redirectUri,
+        state,
+        codeChallenge,
+        scopes: resolveScopes(oauth, options),
+        usePkce
+    });
+    return {
+        authorizationUrl,
+        redirectUri,
+        waitForCallback,
+        close: ()=>server.close(),
+        codeVerifier
+    };
+}
+function resolveClientId(oauth, options) {
+    const value = options.clientId || resolveEnv(oauth.clientIdEnv) || oauth.defaultClientId;
+    if (!value) {
+        const envList = oauth.clientIdEnv.join(", ");
+        throw new Error(`Missing OAuth client ID. Set ${envList} or pass --client-id.`);
+    }
+    return value;
+}
+function resolveClientSecret(oauth, options) {
+    const value = options.clientSecret || resolveEnv(oauth.clientSecretEnv || []) || oauth.defaultClientSecret;
+    return value || void 0;
+}
+function resolveScopes(oauth, options) {
+    if (options.scopes && options.scopes.length > 0) return options.scopes;
+    return oauth.scopes || [];
+}
+function buildAuthorizationUrl(oauth, input) {
+    const url = new URL(oauth.authorizationUrl);
+    url.searchParams.set("client_id", input.clientId);
+    url.searchParams.set("redirect_uri", input.redirectUri);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("state", input.state);
+    if (input.usePkce) {
+        url.searchParams.set("code_challenge", input.codeChallenge);
+        url.searchParams.set("code_challenge_method", "S256");
+    }
+    if (input.scopes.length > 0) url.searchParams.set("scope", input.scopes.join(oauth.scopeSeparator || " "));
+    if (oauth.authorizationParams) for (const [key, value] of Object.entries(oauth.authorizationParams))url.searchParams.set(key, value);
+    return url.toString();
+}
+async function exchangeCodeForToken(providerName, oauth, input) {
+    const body = new URLSearchParams({
+        client_id: input.clientId,
+        code: input.code,
+        redirect_uri: input.redirectUri,
+        grant_type: "authorization_code"
+    });
+    if (false !== oauth.usePkce) body.set("code_verifier", input.codeVerifier);
+    if (input.clientSecret) body.set("client_secret", input.clientSecret);
+    if (oauth.tokenParams) for (const [key, value] of Object.entries(oauth.tokenParams))body.set(key, value);
+    const response = await fetch(oauth.tokenUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Accept: "application/json",
+            ...oauth.tokenHeaders || {}
+        },
+        body: body.toString()
+    });
+    const contentType = response.headers.get("content-type") || "";
+    const rawText = await response.text();
+    let payload = {};
+    payload = "form" === oauth.tokenResponseType ? Object.fromEntries(new URLSearchParams(rawText)) : "json" === oauth.tokenResponseType ? JSON.parse(rawText) : contentType.includes("application/json") ? JSON.parse(rawText) : Object.fromEntries(new URLSearchParams(rawText));
+    if (!response.ok || payload.error) {
+        const description = payload.error_description || payload.error || rawText;
+        throw new Error(`Token exchange failed: ${description}`);
+    }
+    const credentials = mapTokenResponse(providerName, payload);
+    if (payload.expires_in) {
+        const expiresIn = Number(payload.expires_in);
+        if (!Number.isNaN(expiresIn)) credentials.expiresAt = new Date(Date.now() + 1000 * expiresIn).toISOString();
+    }
+    if (!credentials.expiresAt && payload.expires_at) {
+        const expiresAt = Number(payload.expires_at);
+        if (!Number.isNaN(expiresAt)) credentials.expiresAt = new Date(1000 * expiresAt).toISOString();
+    }
+    return credentials;
+}
+function mapTokenResponse(providerName, payload) {
+    const mapper = TOKEN_MAPPERS[providerName];
+    if (mapper) return mapper(payload);
+    const accessToken = payload.access_token;
+    if (!accessToken) throw new Error("Token exchange failed: missing access token.");
+    return {
+        accessToken,
+        refreshToken: payload.refresh_token,
+        tokenType: payload.token_type || "bearer"
+    };
+}
+const TOKEN_MAPPERS = {
+    copilot: (payload)=>{
+        const accessToken = payload.access_token;
+        if (!accessToken) throw new Error("Token exchange failed: missing access token.");
+        return {
+            refreshToken: accessToken,
+            tokenType: payload.token_type || "bearer"
+        };
+    }
+};
+function resolveEnv(envVars) {
+    for (const key of envVars){
+        const value = process.env[key];
+        if (value && value.trim()) return value.trim();
+    }
+}
+function base64Url(buffer) {
+    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function launchBrowser(url) {
+    const platform = process.platform;
+    if ("darwin" === platform) return void await spawnBrowser("open", [
+        url
+    ]);
+    if ("win32" === platform) return void await spawnBrowser("cmd", [
+        "/c",
+        "start",
+        "",
+        url
+    ]);
+    await spawnBrowser("xdg-open", [
+        url
+    ]);
+}
+function spawnBrowser(command, args) {
+    return new Promise((resolve, reject)=>{
+        const child = spawn(command, args, {
+            stdio: "ignore",
+            detached: true
+        });
+        child.once("error", reject);
+        child.once("spawn", ()=>resolve());
+        child.unref();
+    });
+}
+export { loginWithLocalCallback };