py-auth-client 0.1.4 → 0.1.5

package/dist/client.js

@@ -1,20 +1,35 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthClient = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
 const errors_1 = require("./errors");
 const crypto_1 = require("./crypto");
 const cache_1 = require("./cache");
 const device_1 = require("./device");
 const http_1 = require("./http");
+const storage_1 = require("./storage");
+const stateBundle_1 = require("./stateBundle");
+const sdkMeta_1 = require("./sdkMeta");
+const SECONDS_PER_MINUTE = 60;
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_DAY = 86400;
+const HEARTBEAT_TIMEOUT_MS = 2_000;
+const HEARTBEAT_LIGHT_TIMEOUT_MS = 4_000;
 class AuthClient {
     serverUrl;
     softwareName;
     softwareVersion;
     deviceId;
     deviceInfo;
+    deviceInfoDeferred;
     clientSecret;
     debug;
     cache;
+    stateBundleExistedBeforeInit;
     constructor(config) {
         if (!config.serverUrl)
             throw new Error("serverUrl不能为空");
@@ -29,43 +44,82 @@ class AuthClient {
         this.softwareVersion = config.softwareVersion ?? "0.0.0";
         this.clientSecret = secret;
         this.debug = !!config.debug;
-        this.deviceId = (0, device_1.buildDeviceId)(this.serverUrl, config.deviceId, this.softwareName);
-        this.deviceInfo = {
-            ...(config.deviceInfo ?? (0, device_1.collectDeviceInfo)()),
-            software_version: this.softwareVersion,
-        };
-        const enableCache = config.enableCache ?? true;
         const cacheValidityDays = config.cacheValidityDays ?? 7;
         const checkIntervalDays = config.checkIntervalDays ?? 2;
-        if (enableCache) {
-            this.cache = new cache_1.AuthCache({
-                cacheDir: config.cacheDir,
-                deviceId: this.deviceId,
-                serverUrl: this.serverUrl,
-                softwareName: this.softwareName,
-                cacheValidityDays,
-                checkIntervalDays,
-            });
+        const storageBase = (0, storage_1.getClientStorageRoot)();
+        const stateBundleExistedBeforeInit = node_fs_1.default.existsSync((0, stateBundle_1.bundlePath)(this.serverUrl, storageBase));
+        const hasStableDeviceId = !!config.deviceId || !!(0, device_1.loadPersistedDeviceId)(this.serverUrl, this.softwareName, storageBase);
+        this.deviceId = (0, device_1.buildDeviceId)(this.serverUrl, config.deviceId, this.softwareName, storageBase);
+        if (config.deviceInfo) {
+            this.deviceInfoDeferred = false;
+            this.deviceInfo = {
+                ...config.deviceInfo,
+                software_version: this.softwareVersion,
+                sdk: (0, sdkMeta_1.baseSdk)(process.version),
+            };
+        }
+        else if (hasStableDeviceId) {
+            this.deviceInfoDeferred = true;
+            this.deviceInfo = {
+                software_version: this.softwareVersion,
+                sdk: (0, sdkMeta_1.baseSdk)(process.version),
+            };
+        }
+        else {
+            this.deviceInfoDeferred = false;
+            this.deviceInfo = {
+                ...(0, device_1.collectDeviceInfo)(),
+                software_version: this.softwareVersion,
+                sdk: (0, sdkMeta_1.baseSdk)(process.version),
+            };
         }
+        this.cache = new cache_1.AuthCache({
+            storageRoot: storageBase,
+            deviceId: this.deviceId,
+            serverUrl: this.serverUrl,
+            softwareName: this.softwareName,
+            cacheValidityDays,
+            checkIntervalDays,
+        });
+        if (this.deviceInfoDeferred) {
+            const snap = this.cache.loadDeviceInfoSnapshot();
+            if (snap && typeof snap === "object") {
+                this.deviceInfo = {
+                    ...snap,
+                    software_version: this.softwareVersion,
+                    sdk: (0, sdkMeta_1.baseSdk)(process.version),
+                };
+                this.deviceInfoDeferred = false;
+            }
+        }
+        this.stateBundleExistedBeforeInit = stateBundleExistedBeforeInit;
     }
     logDebug(msg) {
         if (this.debug) {
-            // 不加额外依赖，直接输出
-            // eslint-disable-next-line no-console
-            console.debug(`[ts-auth-client][DEBUG] ${msg}`);
+            console.debug(`[ts][DEBUG] ${msg}`);
         }
     }
+    ensureFullDeviceInfo() {
+        if (!this.deviceInfoDeferred)
+            return;
+        this.deviceInfo = {
+            ...(0, device_1.collectDeviceInfo)(),
+            software_version: this.softwareVersion,
+            sdk: (0, sdkMeta_1.baseSdk)(process.version),
+        };
+        this.deviceInfoDeferred = false;
+    }
     formatRemainingTime(cachedAtSeconds) {
-        if (!cachedAtSeconds || cachedAtSeconds <= 0 || !this.cache)
+        if (!cachedAtSeconds || cachedAtSeconds <= 0)
             return "未知";
         const now = Date.now() / 1000;
         const elapsed = now - cachedAtSeconds;
         const remaining = this.cache.cacheValiditySeconds - elapsed;
         if (remaining <= 0)
             return "已过期";
-        const days = Math.floor(remaining / 86400);
-        const hours = Math.floor((remaining % 86400) / 3600);
-        const minutes = Math.floor((remaining % 3600) / 60);
+        const days = Math.floor(remaining / SECONDS_PER_DAY);
+        const hours = Math.floor((remaining % SECONDS_PER_DAY) / SECONDS_PER_HOUR);
+        const minutes = Math.floor((remaining % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
         const parts = [];
         if (days > 0)
             parts.push(`${days}天`);
@@ -75,37 +129,55 @@ class AuthClient {
             parts.push(`${minutes}分钟`);
         return parts.join("");
     }
-    async checkOnline() {
+    async postHeartbeatDeviceInfo(deviceInfoPayload, heartbeatTimes, timeoutMs) {
+        const device_info = {
+            ...deviceInfoPayload,
+            sdk: {
+                ...(deviceInfoPayload.sdk ?? (0, sdkMeta_1.baseSdk)(process.version)),
+                heartbeat_times: heartbeatTimes,
+            },
+        };
+        const requestData = {
+            device_id: this.deviceId,
+            software_name: this.softwareName,
+            device_info,
+        };
+        const encrypted = (0, crypto_1.encryptData)(JSON.stringify(requestData), this.clientSecret);
+        const { status, json, text } = await (0, http_1.postJson)(`${this.serverUrl}/api/auth/heartbeat`, { encrypted_data: encrypted }, timeoutMs);
+        if (status === 200) {
+            const token = json?.encrypted_data ?? "";
+            const decryptedText = token ? (0, crypto_1.decryptData)(token, this.clientSecret) : null;
+            if (!decryptedText) {
+                this.logDebug("在线订阅响应解密失败");
+                return { authorized: false, message: "解密响应失败", success: false, from_cache: false };
+            }
+            const decrypted = JSON.parse(decryptedText);
+            this.logDebug(`在线订阅成功，authorized=${!!decrypted.authorized}`);
+            return {
+                authorized: !!decrypted.authorized,
+                message: decrypted.message ?? "",
+                success: true,
+                from_cache: false,
+            };
+        }
+        const detail = json?.detail;
+        const msg = status === 403 && typeof detail === "string" ? detail : `服务器错误: ${status}`;
+        this.logDebug(`在线订阅失败，status=${status}, message=${msg}; raw=${text}`);
+        return { authorized: false, message: msg, success: false, from_cache: false, is_auth_error: status === 403 };
+    }
+    async checkOnlineLight(heartbeatTimes) {
         try {
-            this.logDebug("开始在线订阅请求...");
-            const requestData = {
-                device_id: this.deviceId,
-                software_name: this.softwareName,
-                device_info: this.deviceInfo,
+            this.logDebug("轻量在线订阅请求（不等待全量 device_info / 公网 IP）...");
+            const light = {
+                ...this.deviceInfo,
+                software_version: this.softwareVersion,
+                system: {
+                    ...(this.deviceInfo.system ?? {}),
+                    hostname: this.deviceInfo.system?.hostname?.trim() || node_os_1.default.hostname(),
+                    os: this.deviceInfo.system?.os || process.platform,
+                },
             };
-            const encrypted = (0, crypto_1.encryptData)(JSON.stringify(requestData), this.clientSecret);
-            const { status, json, text } = await (0, http_1.postJson)(`${this.serverUrl}/api/auth/heartbeat`, { encrypted_data: encrypted }, 10_000);
-            if (status === 200) {
-                const token = json?.encrypted_data ?? "";
-                const decryptedText = token ? (0, crypto_1.decryptData)(token, this.clientSecret) : null;
-                if (!decryptedText) {
-                    this.logDebug("在线订阅响应解密失败");
-                    return { authorized: false, message: "解密响应失败", success: false, from_cache: false };
-                }
-                const decrypted = JSON.parse(decryptedText);
-                this.logDebug(`在线订阅成功，authorized=${!!decrypted.authorized}`);
-                return {
-                    authorized: !!decrypted.authorized,
-                    message: decrypted.message ?? "",
-                    success: true,
-                    from_cache: false,
-                };
-            }
-            // Python 逻辑：403 取 detail，其它返回 “服务器错误: status”
-            const detail = json?.detail;
-            const msg = status === 403 && typeof detail === "string" ? detail : `服务器错误: ${status}`;
-            this.logDebug(`在线订阅失败，status=${status}, message=${msg}; raw=${text}`);
-            return { authorized: false, message: msg, success: false, from_cache: false, is_auth_error: status === 403 };
+            return await this.postHeartbeatDeviceInfo(light, heartbeatTimes, HEARTBEAT_LIGHT_TIMEOUT_MS);
         }
         catch (e) {
             const msg = e?.name === "AbortError" ? "连接失败: timeout" : `连接失败: ${String(e?.message ?? e)}`;
@@ -113,29 +185,68 @@ class AuthClient {
             return { authorized: false, message: msg, success: false, from_cache: false };
         }
     }
-    async checkAuthorization() {
-        if (!this.cache) {
-            return this.checkOnline();
-        }
-        let cacheData = this.cache.getCache();
-        let cacheValid = false;
-        if (cacheData?.cachedAt) {
-            const elapsed = Date.now() / 1000 - cacheData.cachedAt;
-            if (elapsed < this.cache.cacheValiditySeconds) {
-                cacheValid = true;
-                this.logDebug("命中有效缓存，直接授权通过");
+    async checkOnline(heartbeatTimes) {
+        try {
+            const hasPublicIp = typeof this.deviceInfo.network?.public_ip === "string" &&
+                this.deviceInfo.network.public_ip.trim() !== "";
+            const needPublicIp = this.deviceInfoDeferred || !hasPublicIp;
+            const pubPromise = needPublicIp ? (0, device_1.fetchPublicIp)() : Promise.resolve("");
+            this.ensureFullDeviceInfo();
+            this.logDebug("开始在线订阅请求...");
+            const pub = await pubPromise;
+            const nw = { ...(this.deviceInfo.network ?? {}) };
+            if (pub)
+                nw.public_ip = pub;
+            if (pub) {
+                this.deviceInfo = { ...this.deviceInfo, network: nw };
             }
+            const device_info = {
+                ...this.deviceInfo,
+                ...(Object.keys(nw).length > 0 ? { network: nw } : {}),
+            };
+            return await this.postHeartbeatDeviceInfo(device_info, heartbeatTimes, HEARTBEAT_TIMEOUT_MS);
+        }
+        catch (e) {
+            const msg = e?.name === "AbortError" ? "连接失败: timeout" : `连接失败: ${String(e?.message ?? e)}`;
+            this.logDebug(`在线订阅请求异常: ${msg}`);
+            return { authorized: false, message: msg, success: false, from_cache: false };
+        }
+    }
+    persistOnlineResult(result, heartbeatIfAuthorized) {
+        const snap = result.authorized
+            ? JSON.parse(JSON.stringify(this.deviceInfo))
+            : undefined;
+        this.cache.saveCache(result.authorized, result.message, result.authorized ? heartbeatIfAuthorized : undefined, snap);
+    }
+    async checkAuthorization(_forceOnline = false) {
+        if (this.debug) {
+            const cf = this.cache.cacheFile;
+            const fileNow = node_fs_1.default.existsSync(cf);
+            const pre = this.stateBundleExistedBeforeInit;
+            let desc = "不存在（持久化可能失败）";
+            if (fileNow && pre)
+                desc = "启动前已存在";
+            else if (fileNow && !pre)
+                desc = "启动前不存在，构造客户端时已新建（device_id 持久化）";
+            else if (!fileNow && pre)
+                desc = "启动前曾有，当前缺失（异常）";
+            this.logDebug(`状态包: ${cf} | ${desc}`);
         }
+        const snap = this.cache.snapshotForAuthorizationCheck();
+        const cacheData = snap.cacheData;
+        const cacheValid = this.cache.isCacheTTLValid(cacheData);
         if (cacheValid) {
+            this.logDebug("本地缓存仍在有效期内（在线失败时可作后备）");
             this.logDebug("缓存有效，继续尝试在线订阅来更新订阅");
         }
         else {
             this.logDebug(cacheData ? "缓存存在但已过期，准备发起在线订阅请求" : "未找到缓存，准备发起在线订阅请求");
         }
-        const onlineResult = await this.checkOnline();
+        const nextHb = snap.storedHeartbeatTimes + 1;
+        const onlineResult = await this.checkOnline(nextHb);
         if (onlineResult.success) {
             this.logDebug("在线订阅成功，更新缓存");
-            this.cache.saveCache(onlineResult.authorized, onlineResult.message);
+            this.persistOnlineResult(onlineResult, nextHb);
             return onlineResult;
         }
         if (cacheValid && cacheData) {
@@ -150,17 +261,80 @@ class AuthClient {
         }
         return onlineResult;
     }
-    async requireAuthorization() {
-        const result = await this.checkAuthorization();
-        if (!result.success) {
-            throw new errors_1.AuthorizationError({
-                message: result.message,
-                result,
-                deviceId: this.deviceId,
-                serverUrl: this.serverUrl,
-            });
+    async checkAuthorizationProgressive(_forceOnline = false) {
+        if (this.debug) {
+            const cf = this.cache.cacheFile;
+            const fileNow = node_fs_1.default.existsSync(cf);
+            const pre = this.stateBundleExistedBeforeInit;
+            let desc = "不存在（持久化可能失败）";
+            if (fileNow && pre)
+                desc = "启动前已存在";
+            else if (fileNow && !pre)
+                desc = "启动前不存在，构造客户端时已新建（device_id 持久化）";
+            else if (!fileNow && pre)
+                desc = "启动前曾有，当前缺失（异常）";
+            this.logDebug(`状态包: ${cf} | ${desc}`);
+        }
+        const snap = this.cache.snapshotForAuthorizationCheck();
+        const cacheData = snap.cacheData;
+        const cacheValid = this.cache.isCacheTTLValid(cacheData);
+        if (cacheValid) {
+            this.logDebug("本地缓存仍在有效期内（在线失败时可作后备）");
+            this.logDebug("缓存有效，继续尝试在线订阅来更新订阅");
         }
-        if (!result.authorized) {
+        else {
+            this.logDebug(cacheData ? "缓存存在但已过期，准备发起在线订阅请求" : "未找到缓存，准备发起在线订阅请求");
+        }
+        const nextHb = snap.storedHeartbeatTimes + 1;
+        const rFast = await this.checkOnlineLight(nextHb);
+        if (rFast.success) {
+            if (rFast.authorized) {
+                this.logDebug("在线订阅成功，更新缓存");
+                this.persistOnlineResult(rFast, nextHb);
+                this.logDebug("轻量心跳已落盘，发起全量 device_info 补全心跳...");
+                const rFull = await this.checkOnline(nextHb + 1);
+                if (rFull.success) {
+                    this.logDebug("在线订阅成功，更新缓存");
+                    this.persistOnlineResult(rFull, rFull.authorized ? nextHb + 1 : undefined);
+                    return rFull;
+                }
+                const gc = this.cache.getCache();
+                if (gc && this.cache.isCacheTTLValid(gc)) {
+                    const remaining = this.formatRemainingTime(gc.cachedAt);
+                    this.logDebug(`补全心跳失败，沿用轻量结果，订阅剩余时间: ${remaining}`);
+                    return {
+                        authorized: gc.authorized,
+                        message: gc.message,
+                        success: true,
+                        from_cache: true,
+                    };
+                }
+                return rFull;
+            }
+            this.persistOnlineResult(rFast, undefined);
+            return rFast;
+        }
+        const onlineResult = await this.checkOnline(nextHb);
+        if (onlineResult.success) {
+            this.logDebug("在线订阅成功，更新缓存");
+            this.persistOnlineResult(onlineResult, onlineResult.authorized ? nextHb : undefined);
+            return onlineResult;
+        }
+        if (cacheValid && cacheData) {
+            const remaining = this.formatRemainingTime(cacheData.cachedAt);
+            this.logDebug(`在线订阅失败，但缓存有效，使用缓存结果，订阅剩余时间: ${remaining}`);
+            return {
+                authorized: cacheData.authorized,
+                message: cacheData.message,
+                success: true,
+                from_cache: true,
+            };
+        }
+        return onlineResult;
+    }
+    async requireAuthorization(forceOnline = false) {
+        const result = await this.checkAuthorization(forceOnline);
+        if (!result.success || !result.authorized) {
             throw new errors_1.AuthorizationError({
                 message: result.message,
                 result,
@@ -171,35 +345,59 @@ class AuthClient {
         return true;
     }
     clearCache() {
-        if (!this.cache)
-            return true;
         return this.cache.clearCache();
     }
+    canSoftLaunch() {
+        const c = this.cache.getCache();
+        return !!(c?.authorized && this.cache.isCacheTTLValid(c));
+    }
+    startBackgroundRefresh(options) {
+        const soft = this.canSoftLaunch();
+        const fo = options?.forceOnline ?? false;
+        void this.checkAuthorizationProgressive(fo).then((r) => {
+            options?.onDone?.(r);
+        }, (err) => {
+            options?.onDone?.({
+                authorized: false,
+                success: false,
+                from_cache: false,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        });
+        return soft;
+    }
     async getAuthorizationInfo() {
-        const result = await this.checkAuthorization();
-        const info = {
-            authorized: result.authorized,
-            success: result.success,
-            from_cache: result.from_cache,
-            message: result.message,
-            device_id: this.deviceId,
-            server_url: this.serverUrl,
-        };
-        if (this.cache) {
-            const cache = this.cache.getCache();
-            if (cache) {
-                const remaining = this.formatRemainingTime(cache.cachedAt);
-                info.remaining_time = remaining;
-                info.cache_valid = this.cache.isCacheValid();
-                info.cached_at = cache.cachedAt;
-                if (cache.cachedAt > 0) {
-                    info.cached_at_readable = new Date(cache.cachedAt * 1000).toISOString().replace("T", " ").slice(0, 19);
-                }
+        const cache = this.cache.getCache();
+        const info = cache
+            ? {
+                authorized: cache.authorized,
+                success: true,
+                from_cache: true,
+                message: cache.message,
+                device_id: this.deviceId,
+                server_url: this.serverUrl,
+                remaining_time: this.formatRemainingTime(cache.cachedAt),
+                cache_valid: this.cache.isCacheTTLValid(cache),
+                cached_at: cache.cachedAt,
+                cached_at_readable: cache.cachedAt > 0
+                    ? new Date(cache.cachedAt * 1000).toISOString().replace("T", " ").slice(0, 19)
+                    : undefined,
             }
-            else {
-                info.remaining_time = "无缓存";
-                info.cache_valid = false;
+            : {
+                authorized: false,
+                success: false,
+                from_cache: false,
+                message: "无本地授权缓存",
+                device_id: this.deviceId,
+                server_url: this.serverUrl,
+                remaining_time: "无缓存",
+                cache_valid: false,
+            };
+        if (this.debug) {
+            try {
+                this.logDebug(`授权信息摘要:\n${JSON.stringify(info, null, 2)}`);
             }
+            catch { }
         }
         return info;
     }

package/dist/device.d.ts

@@ -1,5 +1,5 @@
 import type { DeviceInfo } from "./types";
-export declare function loadPersistedDeviceId(serverUrl: string, softwareName: string): string | null;
-export declare function persistDeviceId(serverUrl: string, softwareName: string, deviceId: string): void;
-export declare function buildDeviceId(serverUrl: string, providedDeviceId: string | undefined, softwareName: string): string;
+export declare function loadPersistedDeviceId(serverUrl: string, softwareName: string, baseDir: string): string | null;
+export declare function buildDeviceId(serverUrl: string, providedDeviceId: string | undefined, softwareName: string, baseDir: string): string;
 export declare function collectDeviceInfo(): DeviceInfo;
+export declare function fetchPublicIp(): Promise<string>;