rn-update-cli 1.0.0

package/lib/auto-update.js

@@ -0,0 +1,507 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 Node 子进程、文件系统、环境变量、全局包管理器布局与本地化文案
+ * [OUTPUT]: 对外提供 PackageManager、AutoUpdateNotice、全局包管理器探测及后台更新编排
+ * [POS]: CLI 后台自更新边界，负责包管理器归属、锁与失败重试，不参与前台命令分发
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectGlobalPackageManager = detectGlobalPackageManager;
+exports.buildUpdateCommand = buildUpdateCommand;
+exports.launchAutoUpdate = launchAutoUpdate;
+exports.consumeAutoUpdateNotice = consumeAutoUpdateNotice;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const PACKAGE_NAME = 'rn-update-cli';
+const WORKER_ENV = 'RNU_AUTO_UPDATE_WORKER';
+const CANDIDATE_ENV = 'RNU_AUTO_UPDATE_CANDIDATE';
+const LOCK_STALE_MS = 10 * 60 * 1000;
+const UPDATE_TIMEOUT_MS = 2 * 60 * 1000;
+const NETWORK_RETRY_MS = 6 * 60 * 60 * 1000;
+const FAILURE_RETRY_MS = 24 * 60 * 60 * 1000;
+const PERMISSION_RETRY_MS = 7 * 24 * 60 * 60 * 1000;
+const OUTPUT_LIMIT = 32 * 1024;
+function cacheDir() {
+    if (process.env.XDG_CACHE_HOME) {
+        return path_1.default.join(process.env.XDG_CACHE_HOME, PACKAGE_NAME);
+    }
+    switch (process.platform) {
+        case 'darwin':
+            return path_1.default.join((0, os_1.homedir)(), 'Library', 'Caches', PACKAGE_NAME);
+        case 'win32':
+            return path_1.default.join(process.env.LOCALAPPDATA ?? path_1.default.join((0, os_1.homedir)(), 'AppData', 'Local'), PACKAGE_NAME, 'Cache');
+        default:
+            return path_1.default.join((0, os_1.homedir)(), '.cache', PACKAGE_NAME);
+    }
+}
+function stateFile() {
+    return path_1.default.join(cacheDir(), 'auto-update.json');
+}
+function lockDir() {
+    return path_1.default.join(cacheDir(), 'auto-update.lock');
+}
+function readState() {
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(stateFile(), 'utf8'));
+        if (!parsed ||
+            !['running', 'updated', 'failed'].includes(parsed.status) ||
+            typeof parsed.targetVersion !== 'string' ||
+            typeof parsed.attemptedAt !== 'number') {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeState(state) {
+    try {
+        (0, fs_1.mkdirSync)(cacheDir(), { recursive: true });
+        const temporary = `${stateFile()}.${process.pid}.tmp`;
+        (0, fs_1.writeFileSync)(temporary, JSON.stringify(state));
+        (0, fs_1.renameSync)(temporary, stateFile());
+    }
+    catch {
+        // A read-only cache must never interfere with the CLI or the update.
+    }
+}
+function normalizePath(value) {
+    let resolved = path_1.default.resolve(value);
+    try {
+        resolved = fs_1.realpathSync.native(resolved);
+    }
+    catch {
+        // The caller may supply a path that was replaced during an update.
+    }
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+function isWithin(child, parent) {
+    const relative = path_1.default.relative(normalizePath(parent), normalizePath(child));
+    return (relative === '' ||
+        (!relative.startsWith('..') && !path_1.default.isAbsolute(relative)));
+}
+function managerFromUserAgent(env) {
+    const value = `${env.npm_config_user_agent ?? ''} ${env.npm_execpath ?? ''}`.toLowerCase();
+    if (/\bbun(?:\/|\s|$)/.test(value))
+        return 'bun';
+    if (/\bpnpm(?:\/|\s|$)/.test(value))
+        return 'pnpm';
+    if (/\byarn(?:\/|\s|$)/.test(value))
+        return 'yarn';
+    if (/\bnpm(?:\/|\s|$)/.test(value))
+        return 'npm';
+    return undefined;
+}
+function parseManager(value) {
+    const manager = value?.trim().toLowerCase();
+    return manager === 'npm' ||
+        manager === 'pnpm' ||
+        manager === 'yarn' ||
+        manager === 'bun'
+        ? manager
+        : undefined;
+}
+/**
+ * Identify the package manager that owns this global installation. Project
+ * lockfiles are deliberately ignored: they say how the app is installed, not
+ * how this CLI was installed.
+ */
+function detectGlobalPackageManager({ packageRoot, env = process.env, npmGlobalDir, yarnGlobalDir, }) {
+    const root = normalizePath(packageRoot);
+    const normalized = root.replaceAll('\\', '/').toLowerCase();
+    if (yarnGlobalDir && isWithin(root, yarnGlobalDir))
+        return 'yarn';
+    if (npmGlobalDir && isWithin(root, npmGlobalDir))
+        return 'npm';
+    if (/\/(?:\.bun|bun)\/install\/global\/node_modules\//.test(normalized)) {
+        return 'bun';
+    }
+    if (/\/pnpm\/global\/[^/]+\//.test(normalized))
+        return 'pnpm';
+    if (/\/(?:\.config\/yarn\/global|yarn\/data\/global)\/node_modules\//.test(normalized)) {
+        return 'yarn';
+    }
+    // Custom npm prefixes conventionally use <prefix>/lib/node_modules on
+    // Unix and <prefix>/node_modules on Windows. Only accept the generic form
+    // when the package is outside the current project, so npx and local installs
+    // are never self-modified.
+    const cwdNodeModules = path_1.default.join(normalizePath(process.cwd()), 'node_modules');
+    const configuredPrefixModules = env.npm_config_prefix
+        ? path_1.default.join(normalizePath(env.npm_config_prefix), 'node_modules')
+        : undefined;
+    const looksGlobal = normalized.includes('/lib/node_modules/') ||
+        (process.platform === 'win32' &&
+            (normalized.includes('/npm/node_modules/') ||
+                (configuredPrefixModules && isWithin(root, configuredPrefixModules))));
+    if (looksGlobal && !isWithin(root, cwdNodeModules)) {
+        return (parseManager(env.RNU_AUTO_UPDATE_PACKAGE_MANAGER) ??
+            managerFromUserAgent(env) ??
+            'npm');
+    }
+    return undefined;
+}
+function globalDirectories() {
+    try {
+        const dirs = require('global-dirs');
+        return {
+            npmGlobalDir: dirs.npm?.packages,
+            npmPrefix: dirs.npm?.prefix,
+            yarnGlobalDir: dirs.yarn?.packages,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function sanitizeRegistryUrl(value) {
+    try {
+        const registry = new URL(value);
+        if (registry.protocol !== 'http:' && registry.protocol !== 'https:') {
+            return 'https://registry.npmjs.org/';
+        }
+        // Credentials belong in the user's package-manager configuration, not in
+        // a process argument or our state file.
+        registry.username = '';
+        registry.password = '';
+        return registry.toString();
+    }
+    catch {
+        return 'https://registry.npmjs.org/';
+    }
+}
+function buildUpdateCommand(manager, targetVersion, registryUrl, installPrefix) {
+    const target = `${PACKAGE_NAME}@${targetVersion}`;
+    const registry = sanitizeRegistryUrl(registryUrl);
+    // Windows package managers are .cmd shims and therefore run through
+    // cmd.exe. Keep the URL out of that command line (it may contain shell
+    // metacharacters); runPackageManager supplies the same value through the
+    // environment instead.
+    const registryArgs = process.platform === 'win32' ? [] : [`--registry=${registry}`];
+    switch (manager) {
+        case 'pnpm':
+            return {
+                command: process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm',
+                args: ['add', '--global', target, '--reporter=silent', ...registryArgs],
+            };
+        case 'yarn':
+            return {
+                command: process.platform === 'win32' ? 'yarn.cmd' : 'yarn',
+                args: [
+                    'global',
+                    'add',
+                    target,
+                    '--non-interactive',
+                    '--silent',
+                    ...registryArgs,
+                ],
+            };
+        case 'bun':
+            return {
+                command: process.platform === 'win32' ? 'bun.exe' : 'bun',
+                args: ['add', '--global', target, '--no-progress', ...registryArgs],
+            };
+        default:
+            return {
+                command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+                args: [
+                    'install',
+                    '--global',
+                    target,
+                    ...(installPrefix && process.platform !== 'win32'
+                        ? [`--prefix=${installPrefix}`]
+                        : []),
+                    '--no-audit',
+                    '--no-fund',
+                    '--loglevel=error',
+                    ...registryArgs,
+                ],
+            };
+    }
+}
+function inferNpmPrefix(packageRoot, npmGlobalDir, npmPrefix) {
+    if (npmGlobalDir && npmPrefix && isWithin(packageRoot, npmGlobalDir)) {
+        return normalizePath(npmPrefix);
+    }
+    const modules = path_1.default.dirname(normalizePath(packageRoot));
+    if (path_1.default.basename(modules).toLowerCase() !== 'node_modules') {
+        return undefined;
+    }
+    const modulesParent = path_1.default.dirname(modules);
+    return path_1.default.basename(modulesParent).toLowerCase() === 'lib'
+        ? path_1.default.dirname(modulesParent)
+        : modulesParent;
+}
+function isDisabled(env) {
+    const disabled = (value) => value === '0' || value?.toLowerCase() === 'false';
+    const enabled = (value) => value === '1' || value?.toLowerCase() === 'true';
+    return (disabled(env.RNU_AUTO_UPDATE) ||
+        enabled(env.RNU_DISABLE_AUTO_UPDATE) ||
+        enabled(env.NO_UPDATE_NOTIFIER) ||
+        enabled(env.CI));
+}
+function shouldRetry(state, target) {
+    if (!state || state.targetVersion !== target)
+        return true;
+    if (state.status === 'updated')
+        return false;
+    if (state.status === 'running') {
+        return Date.now() - state.attemptedAt >= LOCK_STALE_MS;
+    }
+    return !state.retryAt || state.retryAt <= Date.now();
+}
+/**
+ * Start a detached updater after the foreground command has completed. This
+ * function is synchronous on purpose: it is safe to call from process.exit.
+ */
+function launchAutoUpdate(currentVersion, targetVersion, env = process.env) {
+    if (!targetVersion ||
+        targetVersion === currentVersion ||
+        isDisabled(env) ||
+        !shouldRetry(readState(), targetVersion)) {
+        return false;
+    }
+    const packageRoot = path_1.default.resolve(__dirname, '..');
+    const directories = globalDirectories();
+    const detected = detectGlobalPackageManager({
+        packageRoot,
+        env,
+        npmGlobalDir: directories.npmGlobalDir,
+        yarnGlobalDir: directories.yarnGlobalDir,
+    });
+    if (!detected)
+        return false;
+    const packageManager = parseManager(env.RNU_AUTO_UPDATE_PACKAGE_MANAGER) ?? detected;
+    let registryUrl = 'https://registry.npmjs.org/';
+    try {
+        const registryModule = require('registry-auth-token/registry-url');
+        const getRegistryUrl = (registryModule.default ?? registryModule);
+        registryUrl = getRegistryUrl('');
+    }
+    catch {
+        // Keep the public npm registry fallback when config parsing fails.
+    }
+    const candidate = {
+        currentVersion,
+        targetVersion,
+        packageRoot: normalizePath(packageRoot),
+        packageManager,
+        registryUrl: sanitizeRegistryUrl(registryUrl),
+        installPrefix: packageManager === 'npm' && detected === 'npm'
+            ? inferNpmPrefix(packageRoot, directories.npmGlobalDir, directories.npmPrefix)
+            : undefined,
+    };
+    try {
+        const worker = (0, child_process_1.spawn)(process.execPath, [__filename], {
+            detached: true,
+            env: {
+                ...env,
+                [WORKER_ENV]: '1',
+                [CANDIDATE_ENV]: JSON.stringify(candidate),
+            },
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        worker.once('error', () => { });
+        worker.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function acquireLock() {
+    try {
+        (0, fs_1.mkdirSync)(cacheDir(), { recursive: true });
+        try {
+            (0, fs_1.mkdirSync)(lockDir());
+            return true;
+        }
+        catch {
+            if ((0, fs_1.existsSync)(lockDir()) &&
+                Date.now() - (0, fs_1.statSync)(lockDir()).mtimeMs >= LOCK_STALE_MS) {
+                (0, fs_1.rmSync)(lockDir(), { force: true, recursive: true });
+                (0, fs_1.mkdirSync)(lockDir());
+                return true;
+            }
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function appendBounded(current, chunk) {
+    const combined = `${current}${chunk.toString()}`;
+    return combined.length > OUTPUT_LIMIT
+        ? combined.slice(combined.length - OUTPUT_LIMIT)
+        : combined;
+}
+function classifyFailure(error) {
+    if (/eacces|eperm|permission denied|access is denied/i.test(error)) {
+        return 'permission';
+    }
+    if (/econn|enet|eai_again|enotfound|timed?\s*out|timeout|certificate|socket|network|fetch/i.test(error)) {
+        return 'network';
+    }
+    if (/enoent|not recognized|command not found/i.test(error)) {
+        return 'package-manager';
+    }
+    return 'unknown';
+}
+function retryDelay(kind) {
+    if (kind === 'permission')
+        return PERMISSION_RETRY_MS;
+    if (kind === 'network')
+        return NETWORK_RETRY_MS;
+    return FAILURE_RETRY_MS;
+}
+function compactMessage(value) {
+    return value
+        .split(String.fromCharCode(27))
+        .map((part, index) => index === 0 ? part : part.replace(/^\[[0-9;]*m/, ''))
+        .join('')
+        .trim()
+        .slice(-2000);
+}
+async function runPackageManager(command, args, registryUrl, installPrefix) {
+    return new Promise((resolve) => {
+        let output = '';
+        let settled = false;
+        const child = (0, child_process_1.spawn)(command, args, {
+            env: {
+                ...process.env,
+                npm_config_audit: 'false',
+                npm_config_fund: 'false',
+                ...(installPrefix
+                    ? {
+                        NPM_CONFIG_PREFIX: installPrefix,
+                        npm_config_prefix: installPrefix,
+                    }
+                    : {}),
+                npm_config_registry: sanitizeRegistryUrl(registryUrl),
+                npm_config_update_notifier: 'false',
+            },
+            shell: process.platform === 'win32' && command.endsWith('.cmd'),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        const finish = (code, extra = '') => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, output: appendBounded(output, extra) });
+        };
+        child.stdout?.on('data', (chunk) => {
+            output = appendBounded(output, chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            output = appendBounded(output, chunk);
+        });
+        child.once('error', (error) => finish(127, error.message));
+        child.once('close', (code, signal) => finish(code ?? 1, signal ? `\nTerminated by ${signal}` : ''));
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            finish(124, '\nUpdate timed out');
+        }, UPDATE_TIMEOUT_MS);
+    });
+}
+async function runWorker(candidate) {
+    if (!acquireLock())
+        return;
+    const previous = readState();
+    const running = {
+        ...candidate,
+        status: 'running',
+        attemptedAt: Date.now(),
+        failureCount: previous?.targetVersion === candidate.targetVersion
+            ? (previous.failureCount ?? 0) + 1
+            : 1,
+    };
+    writeState(running);
+    try {
+        if (process.platform !== 'win32') {
+            (0, fs_1.accessSync)(path_1.default.dirname(candidate.packageRoot), fs_1.constants.W_OK);
+        }
+    }
+    catch (error) {
+        const failureKind = 'permission';
+        writeState({
+            ...running,
+            status: 'failed',
+            finishedAt: Date.now(),
+            retryAt: Date.now() + retryDelay(failureKind),
+            failureKind,
+            message: compactMessage(String(error)),
+        });
+        (0, fs_1.rmSync)(lockDir(), { force: true, recursive: true });
+        return;
+    }
+    const update = buildUpdateCommand(candidate.packageManager, candidate.targetVersion, candidate.registryUrl, candidate.installPrefix);
+    const result = await runPackageManager(update.command, update.args, candidate.registryUrl, candidate.installPrefix);
+    if (result.code === 0) {
+        writeState({
+            ...running,
+            status: 'updated',
+            finishedAt: Date.now(),
+            message: undefined,
+        });
+    }
+    else {
+        const detail = compactMessage(result.output);
+        const failureKind = classifyFailure(detail);
+        writeState({
+            ...running,
+            status: 'failed',
+            finishedAt: Date.now(),
+            retryAt: Date.now() + retryDelay(failureKind),
+            failureKind,
+            message: detail,
+        });
+    }
+    (0, fs_1.rmSync)(lockDir(), { force: true, recursive: true });
+}
+function consumeAutoUpdateNotice(currentVersion) {
+    const state = readState();
+    if (!state || state.reportedAt)
+        return undefined;
+    if (state.status === 'updated' && currentVersion === state.targetVersion) {
+        writeState({ ...state, reportedAt: Date.now() });
+        return {
+            kind: 'updated',
+            currentVersion: state.currentVersion,
+            targetVersion: state.targetVersion,
+        };
+    }
+    if (state.status === 'failed' && state.failureKind === 'permission') {
+        writeState({ ...state, reportedAt: Date.now() });
+        const update = buildUpdateCommand(state.packageManager, state.targetVersion, state.registryUrl, state.installPrefix);
+        return {
+            kind: 'permission',
+            currentVersion,
+            targetVersion: state.targetVersion,
+            command: [update.command, ...update.args].join(' '),
+        };
+    }
+    return undefined;
+}
+if (process.env[WORKER_ENV] === '1') {
+    try {
+        const candidate = JSON.parse(process.env[CANDIDATE_ENV] ?? '');
+        if (candidate?.packageRoot &&
+            candidate.targetVersion &&
+            parseManager(candidate.packageManager)) {
+            void runWorker(candidate).catch(() => {
+                (0, fs_1.rmSync)(lockDir(), { force: true, recursive: true });
+            });
+        }
+    }
+    catch {
+        // Malformed worker input is ignored; foreground CLI operation is over.
+    }
+}

package/lib/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * [INPUT]: 依赖 cli.json 命令声明、动态命令加载器、会话存储、版本提示与本地源码/编译产物时间戳
+ * [OUTPUT]: 对外提供 Pakta CLI 进程入口；统一解析参数、恢复会话、调度命令和输出错误，并阻止源码仓库运行过期 lib
+ * [POS]: CLI 最外层适配器，只负责进程生命周期与命令分发；业务发布、上传和网络协议下沉到 commands 与领域模块
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("./api");
+const commands_1 = require("./commands");
+const utils_1 = require("./utils");
+const i18n_1 = require("./utils/i18n");
+function isTruthyEnv(value) {
+    return value === '1' || value?.toLowerCase() === 'true';
+}
+function newestSourceMtime(directory) {
+    let newest = 0;
+    for (const entry of fs_1.default.readdirSync(directory, { withFileTypes: true })) {
+        const entryPath = path_1.default.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            newest = Math.max(newest, newestSourceMtime(entryPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.ts')) {
+            newest = Math.max(newest, fs_1.default.statSync(entryPath).mtimeMs);
+        }
+    }
+    return newest;
+}
+function assertFreshLocalBuild() {
+    const projectRoot = path_1.default.resolve(__dirname, '..');
+    const sourceRoot = path_1.default.join(projectRoot, 'src');
+    if (path_1.default.basename(__dirname) !== 'lib' || !fs_1.default.existsSync(sourceRoot)) {
+        return;
+    }
+    if (newestSourceMtime(sourceRoot) > fs_1.default.statSync(__filename).mtimeMs) {
+        throw new Error('CLI 编译产物已过期。请在 rn-update-cli 目录执行 npm run build 后重试。');
+    }
+}
+function printUsage(exitCode = 1) {
+    console.log('React Native Update CLI');
+    console.log('');
+    console.log('Commands:');
+    for (const name of commands_1.commandNames) {
+        console.log(`  ${name}`);
+    }
+    console.log('');
+    console.log('Special commands:');
+    console.log('  list: List all available commands');
+    console.log('  help: Show this help message');
+    console.log('');
+    console.log('Visit `https://github.com/reactnativecn/react-native-update` for document.');
+    process.exit(exitCode);
+}
+/**
+ * Errors reaching the top level are almost always about the user's input,
+ * project or network: print their message. The stack trace, which only helps
+ * when the CLI itself is at fault, is printed on request (RNU_DEBUG=1).
+ */
+function reportError(err) {
+    if (isTruthyEnv(process.env.RNU_DEBUG)) {
+        console.error(err instanceof Error ? err.stack : err);
+        // fetch failures wrap the real reason (ECONNREFUSED, TLS, ...) as `cause`
+        for (let cause = err?.cause; cause; cause = cause?.cause) {
+            console.error('Caused by:', cause);
+        }
+        return;
+    }
+    console.error(err instanceof Error ? err.message : String(err));
+    console.error((0, i18n_1.t)('errorStackHint'));
+}
+async function run() {
+    try {
+        assertFreshLocalBuild();
+    }
+    catch (err) {
+        reportError(err);
+        process.exit(1);
+    }
+    const versionOnly = ['-v', '--version', 'version'].includes(process.argv[2] ?? '');
+    // The registry check for newer versions runs alongside the command (from a
+    // 1-day cache when possible) and only ever delays `-v`/`version` itself; its
+    // hint is printed once the command is done, or at exit for commands that
+    // exit on their own.
+    const versionCheck = await (0, utils_1.printVersionCommand)({ wait: versionOnly });
+    if (versionOnly) {
+        versionCheck.startAutoUpdate();
+        process.exit();
+    }
+    process.on('exit', (code) => {
+        if (code === 0) {
+            versionCheck.printHints();
+            versionCheck.startAutoUpdate();
+        }
+    });
+    try {
+        // inside the try: an unknown command or option is reported like any other
+        // error instead of crashing with an unhandled rejection
+        const argv = require('cli-arguments').parse(require('../cli.json'));
+        global.NO_INTERACTIVE =
+            Boolean(argv.options['no-interactive']) ||
+                isTruthyEnv(process.env.NO_INTERACTIVE);
+        global.USE_ACC_OSS =
+            Boolean(argv.options.acc) || isTruthyEnv(process.env.USE_ACC_OSS);
+        await (0, api_1.loadSession)();
+        if (argv.command === 'help' || argv.command === 'list') {
+            printUsage(0);
+        }
+        const handler = (0, commands_1.loadCommandHandler)(argv.command);
+        if (!handler) {
+            throw new Error((0, i18n_1.t)('unknownCommand', { command: argv.command }));
+        }
+        await handler(argv);
+        // a check still in flight (cold cache) gets a short grace period; the
+        // registry request itself is unref'd, so exiting never waits on it
+        await versionCheck.settle(500);
+        versionCheck.printHints();
+        versionCheck.startAutoUpdate();
+    }
+    catch (err) {
+        if (err?.status === 401) {
+            console.log((0, i18n_1.t)('loginFirst'));
+            process.exit(1);
+        }
+        reportError(err);
+        process.exit(1);
+    }
+}
+run();

package/lib/bundle-pack.d.ts

@@ -0,0 +1,6 @@
+/**
+ * [INPUT]: 依赖文件系统、路径、yazl ZIP 写入器、本地化文案与 ZIP 条目压缩策略
+ * [OUTPUT]: 对外提供 packBundle，将 bundle 目录打包为 CLI 发布制品
+ * [POS]: CLI PPK 制品打包器，只决定条目边界和压缩方式，不负责 bundle 生成与上传
+ */
+export declare function packBundle(dir: string, output: string, bundleName?: string): Promise<void>;