@skillbuilder/minitool-cli-auth 0.0.0-beta-20261027053041051

package/lib/managed-credential-store.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedCredentialStore = void 0;
+const node_util_1 = require("node:util");
+const minitool_cli_config_1 = require("@skillbuilder/minitool-cli-config");
+const credential_store_1 = require("./credential-store");
+const keyring_credential_store_1 = require("./keyring-credential-store");
+function normalizeStoredCredential(credential) {
+    const json = JSON.stringify((0, minitool_cli_config_1.parseAuthFileConfig)(credential));
+    return (0, minitool_cli_config_1.parseAuthFileConfig)(JSON.parse(json));
+}
+/** 文件与系统凭据库之间的显式存储策略。 */
+class ManagedCredentialStore {
+    files;
+    file;
+    keyring;
+    constructor(files, file = new credential_store_1.FileCredentialStore(files), keyring = new keyring_credential_store_1.KeyringCredentialStore(files.paths.auth)) {
+        this.files = files;
+        this.file = file;
+        this.keyring = keyring;
+    }
+    getMode() {
+        return this.files.readGlobal().credentialStore;
+    }
+    inspect(probeKeyring = false) {
+        const configuredMode = this.getMode();
+        const keyringStatus = probeKeyring || configuredMode === "keychain" ? this.inspectKeyring() : undefined;
+        return {
+            configuredMode,
+            provider: configuredMode === "keychain" ? (0, keyring_credential_store_1.getSystemCredentialStoreName)() : "auth.json (0600)",
+            protection: configuredMode === "keychain" ? "os_protected_store" : "restricted_plaintext_file",
+            ...keyringStatus,
+        };
+    }
+    get() {
+        if (this.getMode() === "file")
+            return this.file.get();
+        const credential = this.keyring.get();
+        this.file.delete();
+        return credential;
+    }
+    update(config) {
+        const mode = this.getMode();
+        this.writeVerified(this.store(mode), config, "登录态保存校验失败");
+        if (mode === "keychain")
+            this.file.delete();
+    }
+    delete() {
+        let mode;
+        try {
+            mode = this.getMode();
+        }
+        catch (error) {
+            if (!(error instanceof minitool_cli_config_1.ConfigFileContentError))
+                throw error;
+        }
+        this.file.delete();
+        try {
+            this.keyring.delete();
+        }
+        catch (error) {
+            if (mode !== "file" || !(error instanceof keyring_credential_store_1.KeyringUnavailableError))
+                throw error;
+        }
+    }
+    use(mode) {
+        const current = this.getMode();
+        if (mode === current)
+            return { changed: false, migrated: false, sourceRetained: false };
+        const source = this.store(current);
+        const target = this.store(mode);
+        let credential;
+        try {
+            credential = source.get();
+        }
+        catch (error) {
+            if (current === "keychain" &&
+                mode === "file" &&
+                (error instanceof keyring_credential_store_1.KeyringUnavailableError || error instanceof keyring_credential_store_1.KeyringAccessError)) {
+                this.setMode("file");
+                return { changed: true, migrated: false, sourceRetained: true };
+            }
+            throw error;
+        }
+        if (credential)
+            this.writeVerified(target, credential, "凭据存储切换校验失败");
+        else if (mode === "keychain")
+            this.keyring.probe();
+        try {
+            this.setMode(mode);
+        }
+        catch (error) {
+            if (credential)
+                target.delete();
+            throw error;
+        }
+        try {
+            source.delete();
+        }
+        catch (error) {
+            this.setMode(current);
+            if (credential)
+                target.delete();
+            throw error;
+        }
+        return { changed: true, migrated: credential !== null, sourceRetained: false };
+    }
+    store(mode) {
+        return mode === "keychain" ? this.keyring : this.file;
+    }
+    setMode(mode) {
+        this.files.writeGlobal({ schemaVersion: 1, credentialStore: mode });
+    }
+    inspectKeyring() {
+        try {
+            this.keyring.probe();
+            return { keyringAvailable: true };
+        }
+        catch (error) {
+            return {
+                keyringAvailable: false,
+                keyringIssue: error instanceof keyring_credential_store_1.KeyringUnavailableError ? "package_unavailable" : "access_error",
+            };
+        }
+    }
+    writeVerified(store, credential, errorMessage) {
+        const expected = normalizeStoredCredential(credential);
+        store.update(expected);
+        if ((0, node_util_1.isDeepStrictEqual)(store.get(), expected))
+            return;
+        store.delete();
+        throw new Error(errorMessage);
+    }
+}
+exports.ManagedCredentialStore = ManagedCredentialStore;

package/lib/secret-auth.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretAuthService = exports.HttpSecretAuthApi = void 0;
+const node_crypto_1 = require("node:crypto");
+const minitool_cli_config_1 = require("@skillbuilder/minitool-cli-config");
+const auth_state_1 = require("./auth-state");
+const LOGIN_SERVICE_UNAVAILABLE = "登录服务暂不可用，请稍后重试";
+const INVALID_SECRET_CREDENTIAL = "Secret ID 或 Secret Key 无效，请检查后重试";
+function loginServiceUnavailable(cause) {
+    return new Error(LOGIN_SERVICE_UNAVAILABLE, { cause });
+}
+class HttpSecretAuthApi {
+    endpointUrl;
+    request;
+    constructor(endpointUrl, request = fetch) {
+        this.endpointUrl = endpointUrl;
+        this.request = request;
+    }
+    async check(payload) {
+        if (!this.endpointUrl)
+            throw loginServiceUnavailable();
+        let endpoint;
+        try {
+            endpoint = new URL(this.endpointUrl);
+        }
+        catch (error) {
+            throw loginServiceUnavailable(error);
+        }
+        if ((endpoint.protocol !== "https:" &&
+            !(endpoint.protocol === "http:" && ["localhost", "127.0.0.1"].includes(endpoint.hostname))) ||
+            endpoint.username ||
+            endpoint.password ||
+            endpoint.search ||
+            endpoint.hash) {
+            throw loginServiceUnavailable();
+        }
+        let response;
+        try {
+            response = await this.request(endpoint, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(20_000),
+            });
+        }
+        catch (error) {
+            throw loginServiceUnavailable(error);
+        }
+        if (response.status === 401 || response.status === 403) {
+            throw new Error(INVALID_SECRET_CREDENTIAL);
+        }
+        if (!response.ok)
+            throw loginServiceUnavailable();
+        let data;
+        try {
+            data = (await response.json());
+        }
+        catch (error) {
+            throw loginServiceUnavailable(error);
+        }
+        if (!data || typeof data.code !== "number")
+            throw loginServiceUnavailable();
+        return data;
+    }
+}
+exports.HttpSecretAuthApi = HttpSecretAuthApi;
+function formatProofMinute(now) {
+    const date = new Date(now);
+    const pad = (value) => String(value).padStart(2, "0");
+    return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}${pad(date.getHours())}${pad(date.getMinutes())}`;
+}
+function toCreator(userInfo) {
+    if (!userInfo?.user_id)
+        return undefined;
+    return {
+        creatorId: userInfo.user_id,
+        displayName: userInfo.nick ?? userInfo.nickname ?? userInfo.user_id,
+        avatarUrl: userInfo.avatar,
+        description: userInfo.desc,
+    };
+}
+function normalizeServerTimestamp(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+        return null;
+    // 兼容旧接口注释中的秒级时间戳；当前真实接口返回 13 位毫秒时间戳。
+    const milliseconds = value < 1_000_000_000_000 ? value * 1000 : value;
+    try {
+        new Date(milliseconds).toISOString();
+        return milliseconds;
+    }
+    catch {
+        return null;
+    }
+}
+/** Secret Key 仅用于一次签名，永不进入 CredentialStore。 */
+class SecretAuthService {
+    store;
+    api;
+    storage;
+    now;
+    constructor(store, api, storage, now = Date.now) {
+        this.store = store;
+        this.api = api;
+        this.storage = storage;
+        this.now = now;
+    }
+    createProof(secretId, secretKey, nonce) {
+        return (0, node_crypto_1.createHash)("md5")
+            .update(`${secretId}#${secretKey}#${nonce}#${formatProofMinute(this.now())}`)
+            .digest("hex");
+    }
+    async loginWithSecret(secretId, secretKey) {
+        const normalizedSecretId = secretId.trim();
+        if (!normalizedSecretId || !secretKey.trim())
+            throw new Error("Secret ID 和 Secret Key 不能为空");
+        if (Buffer.byteLength(normalizedSecretId, "utf8") > minitool_cli_config_1.MAX_SECRET_ID_BYTES) {
+            throw new Error("Secret ID 长度超出限制");
+        }
+        if (Buffer.byteLength(secretKey, "utf8") > minitool_cli_config_1.MAX_SESSION_TOKEN_BYTES) {
+            throw new Error("Secret Key 长度超出限制");
+        }
+        const nonce = (0, node_crypto_1.randomBytes)(8).toString("hex");
+        const proof = this.createProof(normalizedSecretId, secretKey, nonce);
+        const response = await this.api.check({
+            secret_id: normalizedSecretId,
+            nonce,
+            cli_token: proof,
+        });
+        if (response.code !== 0)
+            throw new Error(INVALID_SECRET_CREDENTIAL);
+        const responseData = response.data;
+        const sessionToken = responseData?.cli_token;
+        const ttl = responseData?.expire_in_sec;
+        const returnedSecretId = responseData?.secret_id;
+        const issuedAt = normalizeServerTimestamp(responseData?.create_at);
+        if ((returnedSecretId !== undefined && returnedSecretId !== normalizedSecretId) ||
+            typeof sessionToken !== "string" ||
+            !sessionToken.trim() ||
+            Buffer.byteLength(sessionToken, "utf8") > minitool_cli_config_1.MAX_SESSION_TOKEN_BYTES ||
+            typeof ttl !== "number" ||
+            !Number.isSafeInteger(ttl) ||
+            ttl <= 0 ||
+            issuedAt === null) {
+            throw new Error("登录服务返回异常，本次登录态未保存，请稍后重试");
+        }
+        const expiresAtMs = issuedAt + ttl * 1000;
+        if (!Number.isFinite(issuedAt) || !Number.isSafeInteger(expiresAtMs)) {
+            throw new Error("登录服务返回异常，本次登录态未保存，请稍后重试");
+        }
+        let expiresAt;
+        try {
+            expiresAt = new Date(expiresAtMs).toISOString();
+        }
+        catch {
+            throw new Error("登录服务返回异常，本次登录态未保存，请稍后重试");
+        }
+        const creator = toCreator(responseData?.userInfo);
+        this.store.update({
+            schemaVersion: 1,
+            method: "secret",
+            secretId: normalizedSecretId,
+            sessionToken,
+            issuedAt: new Date(issuedAt).toISOString(),
+            expiresAt,
+            creator,
+        });
+        return { secretId: normalizedSecretId, expiresAt, creator };
+    }
+    readStoredCredential() {
+        const credential = this.store.get();
+        if (!credential || credential.method !== "secret")
+            return { status: "missing" };
+        return Date.parse(credential.expiresAt) > this.now()
+            ? { status: "valid", credential }
+            : { status: "expired", credential };
+    }
+    async getAuthState() {
+        let stored;
+        let source;
+        try {
+            stored = this.readStoredCredential();
+            source = this.storage.getMode() === "keychain" ? "os_keychain" : "local_file";
+        }
+        catch {
+            return { status: "unavailable", reason: "credential_store_error" };
+        }
+        if (stored.status === "missing")
+            return { status: "anonymous", reason: "not_logged_in" };
+        if (stored.status === "expired")
+            return { status: "anonymous", reason: "expired" };
+        const { credential } = stored;
+        const identitySnapshot = credential.creator?.creatorId
+            ? {
+                creatorId: credential.creator.creatorId,
+                displayName: credential.creator.displayName ?? credential.creator.creatorId,
+                avatarUrl: credential.creator.avatarUrl,
+                description: credential.creator.description,
+            }
+            : null;
+        return {
+            status: "authenticated",
+            method: "secret",
+            source,
+            identitySnapshot,
+            expiresAt: credential.expiresAt,
+        };
+    }
+    async getAccessToken() {
+        const stored = this.readStoredCredential();
+        if (stored.status === "missing")
+            throw new auth_state_1.AuthenticationRequiredError();
+        if (stored.status === "expired") {
+            this.store.delete();
+            throw new auth_state_1.AuthenticationRequiredError("登录态已过期，请重新登录。");
+        }
+        return stored.credential.sessionToken;
+    }
+    async whoAmI() {
+        const state = (0, auth_state_1.requireAuthenticatedAuthState)(await this.getAuthState());
+        if (!state.identitySnapshot)
+            throw new auth_state_1.CreatorIdentityUnavailableError();
+        return state.identitySnapshot;
+    }
+    async logout() {
+        this.store.delete();
+    }
+}
+exports.SecretAuthService = SecretAuthService;

package/lib/secret-auth.test.js

@@ -0,0 +1,248 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_test_1 = __importDefault(require("node:test"));
+const minitool_cli_config_1 = require("@skillbuilder/minitool-cli-config");
+const credential_store_1 = require("./credential-store");
+const secret_auth_1 = require("./secret-auth");
+const NOW = Date.parse("2026-09-22T10:00:00.000Z");
+function makeService(t, api) {
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), "redminitool-auth-test-"));
+    t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+    const files = new minitool_cli_config_1.ConfigFiles(home);
+    return {
+        files,
+        service: new secret_auth_1.SecretAuthService(new credential_store_1.FileCredentialStore(files), api, { getMode: () => "file" }, () => NOW),
+    };
+}
+(0, node_test_1.default)("Secret Key 只参与签名；落盘的是服务端返回的会话 token", async (t) => {
+    const api = {
+        async check(request) {
+            strict_1.default.equal(request.secret_id, "secret-id");
+            strict_1.default.match(request.nonce, /^[a-f0-9]{16}$/);
+            strict_1.default.notEqual(request.cli_token, "server-session");
+            return {
+                code: 0,
+                msg: "ok",
+                data: {
+                    secret_id: "secret-id",
+                    cli_token: "server-session",
+                    create_at: NOW,
+                    expire_in_sec: 3600,
+                    userInfo: { user_id: "creator-1", nick: "Creator" },
+                },
+            };
+        },
+    };
+    const { files, service } = makeService(t, api);
+    const result = await service.loginWithSecret("secret-id", "never-persist-this-key");
+    strict_1.default.equal(result.creator?.creatorId, "creator-1");
+    strict_1.default.equal(await service.getAccessToken(), "server-session");
+    strict_1.default.equal((await service.getAuthState()).status, "authenticated");
+    strict_1.default.equal((await service.whoAmI()).creatorId, "creator-1");
+    strict_1.default.equal(files.readGlobal().credentialStore, "file");
+    strict_1.default.equal(fs.existsSync(files.paths.config), true);
+    strict_1.default.equal(fs.readFileSync(files.paths.auth, "utf8").includes("never-persist-this-key"), false);
+    strict_1.default.equal(fs.readFileSync(files.paths.config, "utf8").includes("server-session"), false);
+});
+(0, node_test_1.default)("服务端没有有效会话时不落盘；过期后清理凭据", async (t) => {
+    const { files, service } = makeService(t, {
+        async check() {
+            return {
+                code: 0,
+                msg: "ok",
+                data: { secret_id: "id", cli_token: "", create_at: NOW, expire_in_sec: 3600 },
+            };
+        },
+    });
+    await strict_1.default.rejects(service.loginWithSecret("id", "key"), /登录服务返回异常/);
+    strict_1.default.equal(files.readAuth(), null);
+    files.writeAuth({
+        schemaVersion: 1,
+        method: "secret",
+        secretId: "id",
+        sessionToken: "expired",
+        issuedAt: new Date(NOW - 7200_000).toISOString(),
+        expiresAt: new Date(NOW - 3600_000).toISOString(),
+    });
+    strict_1.default.deepEqual(await service.getAuthState(), { status: "anonymous", reason: "expired" });
+    strict_1.default.notEqual(files.readAuth(), null);
+    await strict_1.default.rejects(service.getAccessToken(), { code: "AUTHENTICATION_REQUIRED" });
+    strict_1.default.equal(files.readAuth(), null);
+});
+(0, node_test_1.default)("凭据存储故障与未登录分开表达", async () => {
+    const store = {
+        get() {
+            throw new Error("provider failed");
+        },
+        update() { },
+        delete() { },
+    };
+    const service = new secret_auth_1.SecretAuthService(store, { check: async () => ({ code: 0, msg: "ok", data: null }) }, { getMode: () => "file" }, () => NOW);
+    strict_1.default.deepEqual(await service.getAuthState(), {
+        status: "unavailable",
+        reason: "credential_store_error",
+    });
+    await strict_1.default.rejects(service.whoAmI(), { code: "CREDENTIAL_STORE_UNAVAILABLE" });
+});
+(0, node_test_1.default)("兼容真实 cli_auth：不回传 secret_id，确认后的签名即短期登录凭据", async (t) => {
+    const { files, service } = makeService(t, {
+        async check(request) {
+            return {
+                code: 0,
+                msg: "ok",
+                data: {
+                    cli_token: request.cli_token,
+                    create_at: NOW,
+                    expire_in_sec: 7200,
+                },
+            };
+        },
+    });
+    const result = await service.loginWithSecret("id", "key");
+    strict_1.default.equal(result.secretId, "id");
+    const stored = files.readAuth();
+    strict_1.default.equal(stored?.method, "secret");
+    if (stored?.method !== "secret")
+        throw new Error("预期 Secret 凭据");
+    strict_1.default.equal(stored.secretId, "id");
+    strict_1.default.match(stored.sessionToken, /^[a-f0-9]{32}$/);
+    strict_1.default.equal(files.readAuth()?.issuedAt, new Date(NOW).toISOString());
+    strict_1.default.equal(files.readAuth()?.expiresAt, new Date(NOW + 7200_000).toISOString());
+});
+(0, node_test_1.default)("Secret ID 规范化后签名和保存，Secret Key 不做破坏性 trim", async (t) => {
+    const { files, service } = makeService(t, {
+        async check(request) {
+            strict_1.default.equal(request.secret_id, "id");
+            return {
+                code: 0,
+                msg: "ok",
+                data: {
+                    secret_id: "id",
+                    cli_token: "server-session",
+                    create_at: NOW,
+                    expire_in_sec: 3600,
+                },
+            };
+        },
+    });
+    const result = await service.loginWithSecret("  id  ", " key-with-significant-spaces ");
+    strict_1.default.equal(result.secretId, "id");
+    const stored = files.readAuth();
+    strict_1.default.equal(stored?.method, "secret");
+    if (stored?.method !== "secret")
+        throw new Error("预期 Secret 凭据");
+    strict_1.default.equal(stored.secretId, "id");
+});
+(0, node_test_1.default)("拒绝服务端返回错配身份或不可表示的有效期", async (t) => {
+    const mismatch = makeService(t, {
+        async check() {
+            return {
+                code: 0,
+                msg: "ok",
+                data: {
+                    secret_id: "another-id",
+                    cli_token: "server-session",
+                    create_at: NOW,
+                    expire_in_sec: 3600,
+                },
+            };
+        },
+    });
+    await strict_1.default.rejects(mismatch.service.loginWithSecret("id", "key"), /登录服务返回异常/);
+    strict_1.default.equal(mismatch.files.readAuth(), null);
+    const overflow = makeService(t, {
+        async check(request) {
+            return {
+                code: 0,
+                msg: "ok",
+                data: {
+                    secret_id: request.secret_id,
+                    cli_token: "server-session",
+                    create_at: NOW,
+                    expire_in_sec: Number.MAX_SAFE_INTEGER,
+                },
+            };
+        },
+    });
+    await strict_1.default.rejects(overflow.service.loginWithSecret("id", "key"), /登录服务返回异常/);
+    strict_1.default.equal(overflow.files.readAuth(), null);
+});
+(0, node_test_1.default)("认证接口拒绝非本机 HTTP，且不向用户暴露内部地址规则", async () => {
+    let requested = false;
+    const api = new secret_auth_1.HttpSecretAuthApi("http://example.com", async () => {
+        requested = true;
+        throw new Error("不应请求");
+    });
+    await strict_1.default.rejects(api.check({ secret_id: "id", nonce: "nonce", cli_token: "proof" }), /登录服务暂不可用/);
+    strict_1.default.equal(requested, false);
+});
+(0, node_test_1.default)("未配置正式认证接口时返回对外错误，且不暴露内部配置", async () => {
+    let requested = false;
+    const api = new secret_auth_1.HttpSecretAuthApi(undefined, async () => {
+        requested = true;
+        throw new Error("不应请求");
+    });
+    const error = await api
+        .check({ secret_id: "id", nonce: "nonce", cli_token: "proof" })
+        .then(() => null)
+        .catch((reason) => reason);
+    strict_1.default.match(String(error), /登录服务暂不可用/);
+    strict_1.default.doesNotMatch(String(error), /配置/i);
+    strict_1.default.equal(requested, false);
+});
+(0, node_test_1.default)("网络与服务端错误不向终端泄露底层异常或 HTTP 状态", async () => {
+    const networkApi = new secret_auth_1.HttpSecretAuthApi("https://example.com/auth", async () => {
+        throw new Error("ECONNREFUSED internal-host:8443");
+    });
+    const networkError = await networkApi
+        .check({ secret_id: "id", nonce: "nonce", cli_token: "proof" })
+        .then(() => null)
+        .catch((reason) => reason);
+    strict_1.default.equal(String(networkError), "Error: 登录服务暂不可用，请稍后重试");
+    const serverApi = new secret_auth_1.HttpSecretAuthApi("https://example.com/auth", async () => new Response(null, { status: 503 }));
+    const serverError = await serverApi
+        .check({ secret_id: "id", nonce: "nonce", cli_token: "proof" })
+        .then(() => null)
+        .catch((reason) => reason);
+    strict_1.default.equal(String(serverError), "Error: 登录服务暂不可用，请稍后重试");
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@skillbuilder/minitool-cli-auth",
+  "version": "0.0.0-beta-20261027053041051",
+  "description": "redminitool credential storage and Secret login lifecycle",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
+  "files": [
+    "lib",
+    "types"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@skillbuilder/minitool-cli-config": "0.0.0-beta-20261027053041051"
+  },
+  "optionalDependencies": {
+    "@napi-rs/keyring": "2.0.0"
+  },
+  "license": "ISC"
+}