@heybox/hb-sdk 0.3.3 → 0.4.0

package/dist/cli-chunks/login-B-A53Sta.cjs

@@ -0,0 +1,193 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var node_http = require('node:http');
+var session = require('./session-CMBN3o9z.cjs');
+var browser = require('./browser-RAy8e8cV.cjs');
+var index = require('./index-io4h3kr-.cjs');
+require('node:path');
+require('fs');
+require('constants');
+require('stream');
+require('util');
+require('assert');
+require('path');
+require('node:process');
+require('node:buffer');
+require('node:url');
+require('node:util');
+require('node:child_process');
+require('node:fs/promises');
+require('node:os');
+require('node:fs');
+require('node:module');
+require('os');
+require('readline');
+require('tty');
+require('events');
+require('buffer');
+
+const HEYBOX_CALLBACK_HOST = '127.0.0.1';
+const HEYBOX_CALLBACK_PATH = '/heybox/callback';
+const HEYBOX_CALLBACK_DONE_PATH = '/heybox/callback/done';
+const DEFAULT_HEYBOX_CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+function createHeyboxLoginUrl(callbackUrl, state, options = {}) {
+    const url = new URL(session.resolveHeyboxLoginBaseUrl(options));
+    url.searchParams.set('mode', 'cli');
+    url.searchParams.set('redirect_url', callbackUrl);
+    url.searchParams.set('state', state);
+    return url.toString();
+}
+function parseHeyboxCallbackUrl(rawUrl, expectedState) {
+    const url = new URL(rawUrl, `http://${HEYBOX_CALLBACK_HOST}`);
+    if (url.pathname !== HEYBOX_CALLBACK_PATH) {
+        throw new Error('Heybox 登录回调路径不正确');
+    }
+    if (readRequiredQueryParam(url, 'state') !== expectedState) {
+        throw new Error('Heybox 登录回调 state 校验失败');
+    }
+    return {
+        heyboxId: readRequiredQueryParam(url, 'heybox_id'),
+        pkey: readRequiredQueryParam(url, 'pkey'),
+        xXhhHeyboxId: readRequiredQueryParam(url, 'x_xhh_heyboxid'),
+    };
+}
+async function waitForHeyboxBrowserCallback(options = {}) {
+    const expectedState = node_crypto.randomBytes(16).toString('hex');
+    const timeoutMs = options.timeoutMs ?? DEFAULT_HEYBOX_CALLBACK_TIMEOUT_MS;
+    const openBrowser = options.openBrowser ?? browser.openExternalUrl;
+    let timer = null;
+    const loginCallback = {};
+    const server = node_http.createServer((request, response) => {
+        try {
+            const requestUrl = new URL(request.url, `http://${HEYBOX_CALLBACK_HOST}`);
+            if (requestUrl.pathname === HEYBOX_CALLBACK_DONE_PATH) {
+                sendBrowserResponse(response, 200, 'Heybox 登录成功，可以回到终端继续。');
+                return;
+            }
+            const callbackPayload = parseHeyboxCallbackUrl(request.url, expectedState);
+            redirectToCleanCallbackPage(response, () => loginCallback.resolve(callbackPayload));
+        }
+        catch (error) {
+            sendBrowserResponse(response, 400, `Heybox 登录失败: ${index.readErrorMessage(error)}`);
+            loginCallback.reject(error);
+        }
+    });
+    try {
+        const payload = await new Promise((resolve, reject) => {
+            loginCallback.resolve = resolve;
+            loginCallback.reject = reject;
+            server.once('error', reject);
+            server.listen(0, HEYBOX_CALLBACK_HOST, () => {
+                void handleServerListening(server, expectedState, {
+                    loginBaseUrl: options.loginBaseUrl,
+                    onBrowserOpenResult: options.onBrowserOpenResult,
+                    onLoginUrl: options.onLoginUrl,
+                    openBrowser,
+                }).catch(reject);
+            });
+            timer = setTimeout(() => {
+                reject(new Error('Heybox 浏览器登录超时，请重新运行 hb-sdk login'));
+            }, timeoutMs);
+        });
+        return payload;
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+        await closeServer(server);
+    }
+}
+async function handleServerListening(server, expectedState, options) {
+    const address = server.address();
+    const callbackUrl = new URL(`http://${HEYBOX_CALLBACK_HOST}:${address.port}${HEYBOX_CALLBACK_PATH}`);
+    callbackUrl.searchParams.set('state', expectedState);
+    const loginUrl = createHeyboxLoginUrl(callbackUrl.toString(), expectedState, { loginBaseUrl: options.loginBaseUrl });
+    options.onLoginUrl?.(loginUrl);
+    const opened = await options.openBrowser(loginUrl).catch(() => false);
+    options.onBrowserOpenResult?.(opened, loginUrl);
+}
+function readRequiredQueryParam(url, name) {
+    const value = url.searchParams.get(name)?.trim() || '';
+    if (!value) {
+        throw new Error(`Heybox 登录回调缺少 ${name}`);
+    }
+    return value;
+}
+function sendBrowserResponse(response, statusCode, message) {
+    response.writeHead(statusCode, {
+        'Content-Type': 'text/html; charset=utf-8',
+    });
+    response.end(`<!doctype html><meta charset="utf-8"><title>hb-sdk Heybox 登录</title><body>${message}</body>`);
+}
+function redirectToCleanCallbackPage(response, onSent) {
+    response.writeHead(302, {
+        Location: HEYBOX_CALLBACK_DONE_PATH,
+        'Cache-Control': 'no-store',
+    });
+    response.end(onSent);
+}
+function closeServer(server) {
+    return new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}
+
+async function loginToHeybox(options = {}) {
+    const logger = options.logger ?? index.createCliLogger();
+    const waitForBrowserCallback = options.waitForBrowserCallback ?? waitForHeyboxBrowserCallback;
+    const env = options.env ?? process.env;
+    const loginBaseUrl = session.resolveHeyboxLoginBaseUrl({ ...options, env });
+    logger.section('Heybox 浏览器登录');
+    logger.debug(`登录入口环境: ${loginBaseUrl}`);
+    const payload = await logger.task('等待浏览器登录回调', () => waitForBrowserCallback({
+        loginBaseUrl,
+        openBrowser: options.openBrowser,
+        onLoginUrl(loginUrl) {
+            logger.debug(`浏览器入口: ${loginUrl}`);
+            logger.info('请在打开的页面完成登录，成功后 hb-sdk 会自动接收登录态。');
+        },
+        onBrowserOpenResult(opened, loginUrl) {
+            if (opened) {
+                logger.success('已打开 Heybox 登录页');
+                return;
+            }
+            logger.warn('当前环境无法直接打开浏览器');
+            logger.info('请打开这个链接完成 Heybox 登录:');
+            logger.info(loginUrl);
+        },
+        timeoutMs: options.timeoutMs,
+    }), { successText: '已接收 Heybox 登录态' });
+    const session$1 = session.createHeyboxAuthSession(payload, { ...options, loginBaseUrl });
+    await session.writeHeyboxAuthSession(session$1, options);
+    logger.success(`Heybox 登录成功：${session$1.heyboxId}`);
+    logger.debug(`cache: ${session.getAuthCacheFilePath(options)}`);
+    logger.info('验证命令: hb-sdk login status');
+}
+async function printLoginStatus(options = {}) {
+    const logger = options.logger ?? index.createCliLogger();
+    const status = await session.readRedactedHeyboxAuthStatus(options);
+    logger.section('Heybox 登录态');
+    if (!status.loggedIn) {
+        logger.warn('未登录');
+        logger.info('下一步: hb-sdk login');
+        logger.debug(`cache: ${status.cacheFile}`);
+        return;
+    }
+    logger.success('已登录');
+    logger.info(`heyboxId: ${status.heyboxId}`);
+    logger.info(`loginBaseUrl: ${status.loginBaseUrl}`);
+    logger.info(`loggedInAt: ${status.loggedInAt}`);
+    logger.debug(`cache: ${status.cacheFile}`);
+}
+async function clearLoginStatus(options = {}) {
+    const logger = options.logger ?? index.createCliLogger();
+    await session.clearHeyboxAuthSession(options);
+    logger.success('已清理 Heybox 登录态');
+    logger.debug(`cache: ${session.getAuthCacheFilePath(options)}`);
+}
+
+exports.clearLoginStatus = clearLoginStatus;
+exports.loginToHeybox = loginToHeybox;
+exports.printLoginStatus = printLoginStatus;