@heybox/hb-sdk 0.4.3 → 0.4.5

package/dist/cli-chunks/{deploy-Bz0-WpHy.cjs → remote-DjaOc1VS.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
+var promises = require('node:readline/promises');
 var childProcess = require('node:child_process');
 var fs = require('node:fs');
 var fs$1 = require('node:fs/promises');
 var path = require('node:path');
-var promises = require('node:readline/promises');
-var session = require('./session-BQs0wf65.cjs');
-var index = require('./index-ovy_xoLn.cjs');
+var session = require('./session-BAgaqpNL.cjs');
+var index = require('./index-BYMTp2I6.cjs');
 var node_crypto = require('node:crypto');
 
 var re = {exports: {}};
@@ -2859,8 +2859,21 @@ function formatReason(error) {
 
 const MINIAPP_UPLOAD_SCOPE = 'activity';
 const ACTIVITY_UPLOAD_KEY_MAX_LENGTH = 64;
+const USER_MINIPROGRAM_ACCESS_STATUS_API_PATH = '/mall/developer/user_miniprogram/access_status';
+const LIST_USER_MINIPROGRAM_API_PATH = '/mall/developer/user_miniprogram/list';
+const CREATE_USER_MINIPROGRAM_API_PATH = '/mall/developer/user_miniprogram/create';
+const UPDATE_USER_MINIPROGRAM_API_PATH = '/mall/developer/user_miniprogram/update';
+const DETAIL_USER_MINIPROGRAM_API_PATH = '/mall/developer/user_miniprogram/detail';
+const USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH = '/mall/developer/user_miniprogram/preview_allowlist';
+const UPDATE_USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH = '/mall/developer/user_miniprogram/preview_allowlist/update';
 const PRECHECK_USER_MINIPROGRAM_VERSION_API_PATH = '/mall/developer/user_miniprogram/version/precheck';
 const SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH = '/mall/developer/user_miniprogram/version/submit_audit';
+const USER_MINIPROGRAM_VERSION_PREVIEW_INFO_API_PATH = '/mall/developer/user_miniprogram/version/preview_info';
+const WITHDRAW_USER_MINIPROGRAM_VERSION_API_PATH = '/mall/developer/user_miniprogram/version/withdraw';
+const RELEASE_USER_MINIPROGRAM_VERSION_API_PATH = '/mall/developer/user_miniprogram/version/release';
+const TAKE_DOWN_USER_MINIPROGRAM_API_PATH = '/mall/developer/user_miniprogram/take_down';
+const REOPEN_USER_MINIPROGRAM_API_PATH = '/mall/developer/user_miniprogram/reopen';
+const LIST_USER_MINIPROGRAM_VERSION_API_PATH = '/mall/developer/user_miniprogram/version/list';
 const FNV_OFFSET = 0x811c9dc5;
 const FNV_PRIME = 0x01000193;
 function normalizeRelativePath(relativePath) {
@@ -3328,7 +3341,7 @@ async function createDefaultCosClient(uploadToken) {
     };
 }
 async function loadCosConstructor() {
-    const cosModule = await Promise.resolve().then(function () { return require('./index-DQAFCtK1.cjs'); }).then(function (n) { return n.index; });
+    const cosModule = await Promise.resolve().then(function () { return require('./index-DRsyeAcg.cjs'); }).then(function (n) { return n.index; });
     return cosModule.default;
 }
 function formatSize(bytes) {
@@ -3371,14 +3384,14 @@ function isRecord(value) {
     return Object.prototype.toString.call(value) === '[object Object]';
 }
 
-async function precheckUserMiniprogramVersion(options, runtime = {}) {
+async function precheckUserMiniprogramVersion$1(options, runtime = {}) {
     return postUserMiniprogramVersionForm(PRECHECK_USER_MINIPROGRAM_VERSION_API_PATH, options, {
         version: options.version,
         release_note: options.releaseNote,
         auto_publish: String(options.autoPublish),
     }, runtime);
 }
-async function submitUserMiniprogramAudit(options, runtime = {}) {
+async function submitUserMiniprogramAudit$1(options, runtime = {}) {
     return postUserMiniprogramVersionForm(SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH, options, {
         manifest: JSON.stringify(options.manifest),
         release_note: options.releaseNote,
@@ -3460,7 +3473,10 @@ async function runDeployCommand(options, runtime = {}) {
         }, runtime, apiBaseUrl, projectRoot, logger);
         const pm = detectPackageManager(projectRoot);
         logger.info(`开始构建: ${pm} run build`);
-        await runBuildScript(pm, projectRoot, runtime.spawn ?? childProcess.spawn);
+        await runBuildScript(pm, projectRoot, runtime.spawn ?? childProcess.spawn, {
+            outputMode: options.buildOutputMode ?? 'inherit',
+            stderr: runtime.stderr,
+        });
         logger.success('构建完成');
     }
     else {
@@ -3502,15 +3518,36 @@ async function runDeployCommand(options, runtime = {}) {
         throw translateHeyboxDeployError(error, { projectRoot, stage: 'upload', version });
     }
     try {
-        submitAuditResult = await logger.task('正在提交审核', () => (runtime.submitUserMiniprogramAudit ?? submitUserMiniprogramAudit)({ session: session$1, miniProgramId, manifest, releaseNote, autoPublish }, { baseUrl: apiBaseUrl, fetchImpl: runtime.fetchImpl }), { successText: '审核提交完成' });
+        submitAuditResult = await logger.task('正在提交审核', () => (runtime.submitUserMiniprogramAudit ?? submitUserMiniprogramAudit$1)({ session: session$1, miniProgramId, manifest, releaseNote, autoPublish }, { baseUrl: apiBaseUrl, fetchImpl: runtime.fetchImpl }), { successText: '审核提交完成' });
     }
     catch (error) {
         throw translateHeyboxDeployError(error, { projectRoot, stage: 'submitAudit', version });
     }
-    logger.success(`提交审核成功：${miniProgramId} ${version}`);
-    logger.info(`发布策略：${autoPublish ? '审核通过后自动发布' : '审核通过后需在开放平台手动发布'}`);
-    if (submitAuditResult.preview_url) {
-        logger.info(`Preview URL: ${submitAuditResult.preview_url}`);
+    printDeploySuccess({ autoPublish, logger, miniProgramId, mode: options.successOutputMode ?? 'legacy', previewUrl: submitAuditResult.preview_url, version });
+    return {
+        autoPublish,
+        changed: true,
+        miniProgramId,
+        ...(submitAuditResult.preview_url ? { previewUrl: submitAuditResult.preview_url } : {}),
+        version,
+    };
+}
+function printDeploySuccess(options) {
+    options.logger.success(`提交审核成功：${options.miniProgramId} ${options.version}`);
+    if (options.mode === 'remote') {
+        options.logger.info(`发布策略：${options.autoPublish ? '审核通过后自动发布' : '审核通过后需手动发布'}`);
+        if (options.previewUrl) {
+            options.logger.info(`Preview URL: ${options.previewUrl}`);
+            options.logger.info('允许他人预览：hb-sdk remote allowlist add <heybox_id>');
+        }
+        options.logger.info(options.autoPublish
+            ? '下一步：hb-sdk remote versions'
+            : `下一步：hb-sdk remote versions；审核通过后运行 hb-sdk remote release ${options.version}`);
+        return;
+    }
+    options.logger.info(`发布策略：${options.autoPublish ? '审核通过后自动发布' : '审核通过后需在开放平台手动发布'}`);
+    if (options.previewUrl) {
+        options.logger.info(`Preview URL: ${options.previewUrl}`);
     }
 }
 function findProjectRoot(startDir) {
@@ -3574,7 +3611,7 @@ async function maybePromptReleaseNote(runtime) {
     }
     const isTTY = runtime.isTTY ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
     if (!isTTY) {
-        throw new Error('非交互环境执行 hb-sdk deploy 必须传 --release-note <text>');
+        throw new Error('非交互环境执行 hb-sdk remote deploy 必须传 --release-note <text>');
     }
     const input = runtime.stdin ?? process.stdin;
     const output = runtime.stdout ?? process.stdout;
@@ -3588,7 +3625,7 @@ async function maybePromptReleaseNote(runtime) {
 }
 async function runVersionPrecheck(options, runtime, apiBaseUrl, projectRoot, logger) {
     try {
-        await logger.task(`正在预检版本 ${options.version}`, () => (runtime.precheckUserMiniprogramVersion ?? precheckUserMiniprogramVersion)(options, {
+        await logger.task(`正在预检版本 ${options.version}`, () => (runtime.precheckUserMiniprogramVersion ?? precheckUserMiniprogramVersion$1)(options, {
             baseUrl: apiBaseUrl,
             fetchImpl: runtime.fetchImpl,
         }), { successText: `版本 ${options.version} 预检通过` });
@@ -3605,12 +3642,18 @@ function detectPackageManager(projectRoot) {
     }
     return 'npm';
 }
-async function runBuildScript(pm, cwd, spawnImpl) {
+async function runBuildScript(pm, cwd, spawnImpl, options) {
     await new Promise((resolve, reject) => {
+        const pipeStdoutToStderr = options.outputMode === 'stderr';
         const child = spawnImpl(pm, ['run', 'build'], {
             cwd,
-            stdio: 'inherit',
+            stdio: pipeStdoutToStderr ? ['inherit', 'pipe', 'inherit'] : 'inherit',
         });
+        if (pipeStdoutToStderr) {
+            child.stdout?.on('data', (chunk) => {
+                (options.stderr ?? process.stderr).write(chunk);
+            });
+        }
         child.on('error', reject);
         child.on('exit', (code) => {
             if (code === 0) {
@@ -3719,12 +3762,745 @@ function suggestNextPatchVersion(version) {
     return `${matched[1]}.${matched[2]}.${Number(matched[3]) + 1}`;
 }
 
-var deploy = /*#__PURE__*/Object.freeze({
+function createRemoteApiClient(options) {
+    return {
+        getDeveloperAccessStatus: () => getDeveloperAccessStatus(options),
+        listUserMiniprograms: (requestOptions = {}) => listUserMiniprograms(requestOptions, options),
+        createUserMiniprogram: (requestOptions) => createUserMiniprogram(requestOptions, options),
+        updateUserMiniprogram: (requestOptions) => updateUserMiniprogram(requestOptions, options),
+        getUserMiniprogramDetail: (requestOptions) => getUserMiniprogramDetail(requestOptions, options),
+        getPreviewAllowlist: (requestOptions) => getPreviewAllowlist(requestOptions, options),
+        updatePreviewAllowlist: (requestOptions) => updatePreviewAllowlist(requestOptions, options),
+        precheckUserMiniprogramVersion: (requestOptions) => precheckUserMiniprogramVersion(requestOptions, options),
+        submitUserMiniprogramAudit: (requestOptions) => submitUserMiniprogramAudit(requestOptions, options),
+        getVersionPreviewInfo: (requestOptions) => getVersionPreviewInfo(requestOptions, options),
+        withdrawUserMiniprogramVersion: (requestOptions) => withdrawUserMiniprogramVersion(requestOptions, options),
+        releaseUserMiniprogramVersion: (requestOptions) => releaseUserMiniprogramVersion(requestOptions, options),
+        takeDownUserMiniprogram: (requestOptions) => takeDownUserMiniprogram(requestOptions, options),
+        reopenUserMiniprogram: (requestOptions) => reopenUserMiniprogram(requestOptions, options),
+        listUserMiniprogramVersions: (requestOptions) => listUserMiniprogramVersions(requestOptions, options),
+    };
+}
+async function getDeveloperAccessStatus(runtime) {
+    return remoteGet(USER_MINIPROGRAM_ACCESS_STATUS_API_PATH, {}, runtime);
+}
+async function listUserMiniprograms(options, runtime) {
+    return remoteGet(LIST_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function createUserMiniprogram(options, runtime) {
+    return remotePostForm(CREATE_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function updateUserMiniprogram(options, runtime) {
+    return remotePostForm(UPDATE_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function getUserMiniprogramDetail(options, runtime) {
+    return remoteGet(DETAIL_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function getPreviewAllowlist(options, runtime) {
+    return remoteGet(USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH, options, runtime);
+}
+async function updatePreviewAllowlist(options, runtime) {
+    return remotePostForm(UPDATE_USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH, options, runtime);
+}
+async function precheckUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(PRECHECK_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function submitUserMiniprogramAudit(options, runtime) {
+    return remotePostForm(SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH, {
+        ...options,
+        manifest: typeof options.manifest === 'string' ? options.manifest : JSON.stringify(options.manifest),
+    }, runtime);
+}
+async function getVersionPreviewInfo(options, runtime) {
+    return remoteGet(USER_MINIPROGRAM_VERSION_PREVIEW_INFO_API_PATH, options, runtime);
+}
+async function withdrawUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(WITHDRAW_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function releaseUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(RELEASE_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function takeDownUserMiniprogram(options, runtime) {
+    return remotePostForm(TAKE_DOWN_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function reopenUserMiniprogram(options, runtime) {
+    return remotePostForm(REOPEN_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function listUserMiniprogramVersions(options, runtime) {
+    return remoteGet(LIST_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function remoteGet(path, query, runtime) {
+    const pathWithQuery = createPathWithQuery(path, query);
+    const context = createHeyboxOpenPlatformRequestContext(runtime.session, pathWithQuery);
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const response = await fetchImpl(createHeyboxApiUrl(runtime.baseUrl ?? context.baseUrl, pathWithQuery, context.platformParams), {
+        method: 'GET',
+        headers: context.headers,
+    });
+    return readRequiredResult(response, pathWithQuery);
+}
+async function remotePostForm(path, fields, runtime) {
+    const context = createHeyboxOpenPlatformRequestContext(runtime.session, path, {
+        contentType: 'application/x-www-form-urlencoded',
+    });
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const response = await fetchImpl(createHeyboxApiUrl(runtime.baseUrl ?? context.baseUrl, path, context.platformParams), {
+        method: 'POST',
+        headers: context.headers,
+        body: createFormBody(fields),
+    });
+    return readRequiredResult(response, path);
+}
+async function readRequiredResult(response, pathWithQuery) {
+    const result = await readHeyboxApiEnvelope(response, { pathWithQuery, requireResult: true });
+    return result;
+}
+function createPathWithQuery(path, query) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null && value !== '') {
+            params.set(key, String(value));
+        }
+    }
+    const queryString = params.toString();
+    return queryString ? `${path}?${queryString}` : path;
+}
+function createFormBody(fields) {
+    const body = new URLSearchParams();
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            body.set(key, value.join(','));
+            continue;
+        }
+        if (typeof value === 'object') {
+            body.set(key, JSON.stringify(value));
+            continue;
+        }
+        body.set(key, String(value));
+    }
+    return body.toString();
+}
+
+class MiniProgramProjectBindingError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'MiniProgramProjectBindingError';
+    }
+}
+function findMiniProgramProjectRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new MiniProgramProjectBindingError('当前目录或父目录未找到 package.json', 'PACKAGE_JSON_NOT_FOUND');
+        }
+        current = parent;
+    }
+}
+async function readMiniProgramProjectPackage(startDir) {
+    const projectRoot = findMiniProgramProjectRoot(startDir);
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    const raw = await fs$1.readFile(packageJsonPath, 'utf8');
+    let packageJson;
+    try {
+        packageJson = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MiniProgramProjectBindingError(`package.json 不是合法 JSON：${packageJsonPath}\n${message}`, 'PACKAGE_JSON_INVALID');
+    }
+    return {
+        projectRoot,
+        packageJsonPath,
+        packageJson,
+        raw,
+        indent: detectJsonIndent(raw),
+        trailingNewline: raw.endsWith('\r\n') ? '\r\n' : raw.endsWith('\n') ? '\n' : '',
+    };
+}
+function readBoundMiniProgramIdFromPackageJson(packageJson) {
+    const value = packageJson.heybox?.miniProgramId;
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+async function writeBoundMiniProgramId(startDir, miniProgramId, options = {}) {
+    const context = await readMiniProgramProjectPackage(startDir);
+    const normalizedMiniProgramId = String(miniProgramId).trim();
+    if (!normalizedMiniProgramId) {
+        throw new MiniProgramProjectBindingError('miniProgramId 不能为空', 'PACKAGE_JSON_INVALID');
+    }
+    const currentMiniProgramId = readBoundMiniProgramIdFromPackageJson(context.packageJson);
+    if (currentMiniProgramId && currentMiniProgramId !== normalizedMiniProgramId && !options.force) {
+        throw new MiniProgramProjectBindingError(`当前项目已绑定小程序 ${currentMiniProgramId}。如需覆盖本地绑定，请使用 --force。`, 'MINI_PROGRAM_BINDING_EXISTS');
+    }
+    if (currentMiniProgramId === normalizedMiniProgramId) {
+        return {
+            ...context,
+            changed: false,
+            miniProgramId: normalizedMiniProgramId,
+        };
+    }
+    if (context.packageJson.heybox !== undefined && !isPlainObject(context.packageJson.heybox)) {
+        throw new MiniProgramProjectBindingError('package.json heybox 字段必须是对象，不能写入 miniProgramId', 'PACKAGE_JSON_HEYBOX_INVALID');
+    }
+    context.packageJson.heybox = {
+        ...(context.packageJson.heybox ?? {}),
+        miniProgramId: normalizedMiniProgramId,
+    };
+    await fs$1.writeFile(context.packageJsonPath, `${JSON.stringify(context.packageJson, null, context.indent)}${context.trailingNewline || '\n'}`, 'utf8');
+    return {
+        ...context,
+        changed: true,
+        miniProgramId: normalizedMiniProgramId,
+    };
+}
+function detectJsonIndent(raw) {
+    const match = raw.match(/\n(\s+)"[^"]+":/);
+    return match?.[1] ?? 2;
+}
+function isPlainObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+async function resolveRemoteEnvironment(options = {}, runtime = {}) {
+    const env = options.env ?? process.env;
+    const apiBaseUrl = session.resolveHeyboxApiBaseUrl({ ...options, env });
+    const loginBaseUrl = session.resolveHeyboxLoginBaseUrl({ ...options, env });
+    const session$1 = options.session ?? (await (runtime.requireAuthSession ?? session.requireHeyboxAuthSession)({ loginBaseUrl }));
+    return {
+        apiBaseUrl,
+        loginBaseUrl,
+        allowUnsafeApiBaseUrl: options.allowUnsafeApiBaseUrl === true || isTruthyEnvFlag(env.HB_SDK_ALLOW_UNSAFE_API_BASE_URL),
+        env,
+        fetchImpl: runtime.fetchImpl ?? options.fetchImpl ?? fetch,
+        session: session$1,
+    };
+}
+function createRemoteApiClientForEnvironment(environment) {
+    return createRemoteApiClient({
+        baseUrl: environment.apiBaseUrl,
+        fetchImpl: environment.fetchImpl,
+        session: environment.session,
+    });
+}
+function isTruthyEnvFlag(value) {
+    return ['1', 'true', 'yes', 'on'].includes(String(value ?? '')
+        .trim()
+        .toLowerCase());
+}
+
+async function runRemoteCommand(options, runtime = {}) {
+    if (options.command === 'deploy') {
+        return runRemoteDeployCommand(options, runtime);
+    }
+    const context = await createRemoteCommandContext(options, runtime);
+    switch (options.command) {
+        case 'access':
+            return remoteAccess(options, context, runtime);
+        case 'list':
+            return remoteList(options, context, runtime);
+        case 'create':
+            return remoteCreate(options, context, runtime);
+        case 'bind':
+            return remoteBind(options, context, runtime);
+        case 'info':
+            return remoteInfo(options, context, runtime);
+        case 'update':
+            return remoteUpdate(options, context, runtime);
+        case 'allowlist:list':
+            return remoteAllowlistList(options, context, runtime);
+        case 'allowlist:add':
+        case 'allowlist:remove':
+        case 'allowlist:set':
+            return remoteAllowlistWrite(options, context, runtime);
+        case 'versions':
+            return remoteVersions(options, context, runtime);
+        case 'preview':
+            return remotePreview(options, context, runtime);
+        case 'release':
+        case 'withdraw':
+        case 'take-down':
+        case 'reopen':
+            return remoteDangerousWrite(options, context, runtime);
+        default:
+            throw new Error(`不支持的 remote 命令：${String(options.command)}`);
+    }
+}
+async function runRemoteDeployCommand(options, runtime) {
+    const logger = resolveRemoteLogger(options, runtime);
+    const deployRuntime = {
+        cwd: runtime.cwd,
+        fetchImpl: runtime.fetchImpl,
+        isTTY: runtime.isTTY,
+        logger: options.json ? createJsonSafeLogger(runtime) : logger,
+        requireAuthSession: runtime.requireAuthSession,
+        stdin: runtime.stdin,
+        stdout: runtime.stdout,
+    };
+    const deployOptions = {
+        allowUnsafeApiBaseUrl: options.allowUnsafeApiBaseUrl,
+        apiBaseUrl: options.apiBaseUrl,
+        autoPublish: options.autoPublish,
+        env: options.env,
+        loginBaseUrl: options.loginBaseUrl,
+        releaseNote: options.releaseNote,
+        skipBuild: options.skipBuild,
+        buildOutputMode: options.json ? 'stderr' : 'inherit',
+        successOutputMode: 'remote',
+    };
+    const result = await (runtime.runDeployCommand ?? runDeployCommand)(deployOptions, deployRuntime);
+    const output = result ?? { changed: true };
+    return finishRemoteCommand(options, runtime, output);
+}
+async function createRemoteCommandContext(options, runtime) {
+    const logger = resolveRemoteLogger(options, runtime);
+    const environment = await resolveRemoteEnvironment({
+        allowUnsafeApiBaseUrl: options.allowUnsafeApiBaseUrl,
+        apiBaseUrl: options.apiBaseUrl,
+        env: options.env,
+        fetchImpl: runtime.fetchImpl,
+        loginBaseUrl: options.loginBaseUrl,
+    }, {
+        fetchImpl: runtime.fetchImpl,
+        requireAuthSession: runtime.requireAuthSession,
+    });
+    const packageJson = await readMiniProgramProjectPackage(runtime.cwd ?? process.cwd());
+    const binding = readBoundMiniProgramIdFromPackageJson(packageJson.packageJson);
+    const api = {
+        ...adaptRemoteApiClient(createRemoteApiClientForEnvironment(environment)),
+        ...runtime.api,
+    };
+    logger.debug(`Heybox API: ${environment.apiBaseUrl}`);
+    return {
+        api,
+        apiBaseUrl: environment.apiBaseUrl,
+        binding,
+        logger,
+        loginBaseUrl: environment.loginBaseUrl,
+        packageJson,
+        session: environment.session,
+    };
+}
+function adaptRemoteApiClient(api) {
+    return {
+        accessStatus: () => api.getDeveloperAccessStatus(),
+        listMiniPrograms: ({ keyword, status }) => api.listUserMiniprograms({ keyword, status, offset: 0, limit: 200 }),
+        createMiniProgram: ({ name, previewImageUrl }) => api.createUserMiniprogram({ name, ...(previewImageUrl ? { preview_image_url: previewImageUrl } : {}) }),
+        updateMiniProgram: ({ miniProgramId, name, previewImageUrl }) => api.updateUserMiniprogram({ mini_program_id: miniProgramId, name, preview_image_url: previewImageUrl }),
+        getMiniProgramDetail: (miniProgramId) => api.getUserMiniprogramDetail({ mini_program_id: miniProgramId }),
+        getAllowlist: (miniProgramId) => api.getPreviewAllowlist({ mini_program_id: miniProgramId }),
+        updateAllowlist: ({ miniProgramId, heyboxIds }) => api.updatePreviewAllowlist({ mini_program_id: miniProgramId, heybox_ids: heyboxIds }),
+        listVersions: (miniProgramId) => api.listUserMiniprogramVersions({ mini_program_id: miniProgramId, offset: 0, limit: 50 }),
+        getPreviewInfo: ({ miniProgramId, version }) => api.getVersionPreviewInfo({ mini_program_id: miniProgramId, preview_version: version }),
+        releaseVersion: ({ miniProgramId, version }) => api.releaseUserMiniprogramVersion({ mini_program_id: miniProgramId, version }),
+        withdrawVersion: ({ miniProgramId, reason, version }) => api.withdrawUserMiniprogramVersion({ mini_program_id: miniProgramId, version, reason }),
+        takeDown: (miniProgramId) => api.takeDownUserMiniprogram({ mini_program_id: miniProgramId }),
+        reopen: (miniProgramId) => api.reopenUserMiniprogram({ mini_program_id: miniProgramId }),
+    };
+}
+async function remoteAccess(options, context, runtime) {
+    const result = await context.api.accessStatus();
+    const output = { changed: false, access: toCamelCaseDeep(result) };
+    if (!options.json) {
+        context.logger.info(`Access status: ${String(result.status ?? 'unknown')}`);
+        if (result.developer_name) {
+            context.logger.info(`Developer: ${String(result.developer_name)}`);
+        }
+        if (result.disabled_reason) {
+            context.logger.warn(`Disabled reason: ${String(result.disabled_reason)}`);
+        }
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteList(options, context, runtime) {
+    const result = await context.api.listMiniPrograms({ keyword: options.keyword, status: options.status });
+    const items = Array.isArray(result.items) ? result.items : [];
+    const outputItems = items.map((item) => ({ ...toCamelCaseDeep(item), bound: item.mini_program_id === context.binding }));
+    const output = { changed: false, items: outputItems, total: readNumber(result.total, items.length) };
+    if (!options.json) {
+        if (items.length === 0) {
+            context.logger.info('未找到远端小程序');
+        }
+        else {
+            for (const item of items) {
+                const marker = item.mini_program_id === context.binding ? '* ' : '  ';
+                context.logger.info(`${marker}${item.mini_program_id ?? '--'}  ${item.name ?? '--'}  status=${item.status ?? '--'}  version=${item.version || item.latest_version_status || '--'}`);
+            }
+        }
+        if (!context.binding) {
+            context.logger.info('当前项目尚未绑定远端小程序。绑定已有小程序：hb-sdk remote bind <mini-program-id>');
+        }
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteCreate(options, context, runtime) {
+    if (context.binding && !options.forceBind) {
+        throw new Error(`当前项目已绑定 ${context.binding}；如需覆盖，请使用 --force-bind`);
+    }
+    const name = requireNonEmpty(options.name, 'remote create 必须传 --name <name>');
+    const previewImageUrl = validateOptionalHttpsUrl(options.previewImageUrl, '--preview-image-url');
+    const access = await context.api.accessStatus();
+    if (access.status !== 'approved') {
+        throw new Error(`当前 CLI 用户没有创建开发者用户小程序权限：${String(access.status ?? 'unknown')}`);
+    }
+    const result = await context.api.createMiniProgram({ name, previewImageUrl });
+    const miniProgramId = requireMiniProgramId(result);
+    await writeBoundMiniProgramId(context.packageJson.projectRoot, miniProgramId, { force: options.forceBind });
+    const output = { changed: true, miniProgramId, remote: toCamelCaseDeep(result) };
+    if (!options.json) {
+        context.logger.success(`创建并绑定成功：${miniProgramId}`);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteBind(options, context, runtime) {
+    const miniProgramId = requireNonEmpty(options.miniProgramId, 'remote bind 必须传 <mini-program-id>');
+    if (context.binding && context.binding !== miniProgramId && !options.force) {
+        throw new Error(`当前项目已绑定 ${context.binding}；如需覆盖本地绑定，请使用 --force`);
+    }
+    const detail = await context.api.getMiniProgramDetail(miniProgramId);
+    const verifiedId = requireMiniProgramId(detail);
+    const changed = context.binding !== verifiedId;
+    if (changed) {
+        await writeBoundMiniProgramId(context.packageJson.projectRoot, verifiedId, { force: options.force });
+    }
+    const output = { changed, miniProgramId: verifiedId, remote: toCamelCaseDeep(detail) };
+    if (!options.json) {
+        context.logger.success(changed ? `绑定成功：${verifiedId}` : `已绑定：${verifiedId}`);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteInfo(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const detail = await context.api.getMiniProgramDetail(miniProgramId);
+    const output = { changed: false, miniProgramId, detail: toCamelCaseDeep(detail) };
+    if (!options.json) {
+        printMiniProgramDetail(context.logger, detail);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteUpdate(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const hasName = options.name !== undefined;
+    const hasPreviewImageUrl = options.previewImageUrl !== undefined;
+    if (!hasName && !hasPreviewImageUrl) {
+        throw new Error('remote update 至少需要传 --name 或 --preview-image-url');
+    }
+    const detail = await context.api.getMiniProgramDetail(miniProgramId);
+    const nextName = hasName ? requireNonEmpty(options.name, '--name 不能为空') : requireNonEmpty(detail.name, '远端详情缺少 name，无法补全 update 请求');
+    const nextPreviewImageUrl = hasPreviewImageUrl
+        ? validateOptionalHttpsUrl(options.previewImageUrl, '--preview-image-url') ?? ''
+        : String(detail.preview_image_url ?? '');
+    const result = await context.api.updateMiniProgram({ miniProgramId, name: nextName, previewImageUrl: nextPreviewImageUrl });
+    const output = { changed: true, miniProgramId, remote: toCamelCaseDeep(result) };
+    if (!options.json) {
+        context.logger.success(`更新成功：${miniProgramId}`);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteAllowlistList(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const result = await context.api.getAllowlist(miniProgramId);
+    const output = {
+        changed: false,
+        items: toCamelCaseDeep(Array.isArray(result.items) ? result.items : []),
+        limit: readNumber(result.limit, 0),
+        miniProgramId,
+    };
+    if (!options.json) {
+        printAllowlist(context.logger, result);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteAllowlistWrite(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const inputIds = parseHeyboxIds(options.heyboxIds ?? []);
+    const current = await context.api.getAllowlist(miniProgramId);
+    const nextIds = mergeAllowlistIds(options.command, current, inputIds);
+    assertAllowlistLimit(nextIds, current.limit);
+    const result = await context.api.updateAllowlist({ miniProgramId, heyboxIds: nextIds });
+    const output = {
+        changed: true,
+        items: toCamelCaseDeep(Array.isArray(result.items) ? result.items : []),
+        limit: readNumber(result.limit, readNumber(current.limit, 0)),
+        miniProgramId,
+    };
+    if (!options.json) {
+        context.logger.success(`白名单已更新：${nextIds.join(',') || '(empty)'}`);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteVersions(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const result = await context.api.listVersions(miniProgramId);
+    const items = Array.isArray(result.items) ? result.items : [];
+    const output = { changed: false, items: toCamelCaseDeep(items), miniProgramId, total: readNumber(result.total, items.length) };
+    if (!options.json) {
+        for (const item of items) {
+            context.logger.info(`${item.version ?? '--'}  status=${item.status ?? '--'}  preview=${item.preview_url ?? '--'}  publish=${item.publish_url ?? '--'}`);
+        }
+        if (items.length === 0) {
+            context.logger.info('暂无远端版本');
+        }
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remotePreview(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const version = requireNonEmpty(options.version, 'remote preview 必须传 <version>');
+    const result = await context.api.getPreviewInfo({ miniProgramId, version });
+    const previewUrl = String(result.preview_url || result.publish_url || result.page_url || '');
+    const output = { changed: false, miniProgramId, previewUrl, version, preview: toCamelCaseDeep(result) };
+    if (!options.json) {
+        context.logger.info(previewUrl ? `Preview URL: ${previewUrl}` : `版本 ${version} 暂无 preview URL`);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+async function remoteDangerousWrite(options, context, runtime) {
+    const miniProgramId = requireBinding(context);
+    const version = options.command === 'release' || options.command === 'withdraw' ? requireNonEmpty(options.version, `remote ${options.command} 必须传 <version>`) : undefined;
+    const detail = await context.api.getMiniProgramDetail(miniProgramId);
+    await confirmDangerousRemoteChange(options, runtime, context.logger, {
+        miniProgramId,
+        name: detail.name,
+        operation: options.command,
+        status: detail.status,
+        version,
+    });
+    if (options.command === 'release') {
+        const result = await context.api.releaseVersion({ miniProgramId, version: version });
+        return finishDangerousWrite(options, runtime, context.logger, miniProgramId, result, { status: result.status, version });
+    }
+    if (options.command === 'withdraw') {
+        const result = await context.api.withdrawVersion({ miniProgramId, reason: options.reason, version: version });
+        return finishDangerousWrite(options, runtime, context.logger, miniProgramId, result, { status: result.status, version });
+    }
+    if (options.command === 'take-down') {
+        const result = await context.api.takeDown(miniProgramId);
+        return finishDangerousWrite(options, runtime, context.logger, miniProgramId, result, { status: result.status });
+    }
+    const result = await context.api.reopen(miniProgramId);
+    return finishDangerousWrite(options, runtime, context.logger, miniProgramId, result, { status: result.status });
+}
+function finishDangerousWrite(options, runtime, logger, miniProgramId, result, extras) {
+    const output = { changed: true, miniProgramId, ...extras, remote: toCamelCaseDeep(result) };
+    if (!options.json) {
+        logger.success(`操作成功：${options.command} ${miniProgramId}`);
+    }
+    return finishRemoteCommand(options, runtime, output);
+}
+function finishRemoteCommand(options, runtime, output) {
+    const normalized = toCamelCaseDeep(output);
+    if (options.json) {
+        writeStdout(runtime, `${JSON.stringify(normalized)}\n`);
+    }
+    return normalized;
+}
+function resolveRemoteLogger(options, runtime) {
+    if (options.json) {
+        return createJsonSafeLogger(runtime);
+    }
+    if (runtime.logger) {
+        return runtime.logger;
+    }
+    return index.createCliLogger({
+        isTTY: runtime.isTTY,
+        stderr: runtime.stderr,
+        stdout: runtime.stdout,
+    });
+}
+function createJsonSafeLogger(runtime) {
+    const stderr = runtime.stderr ?? process.stderr;
+    return index.createCliLogger({
+        isTTY: runtime.isTTY,
+        stderr,
+        stdout: stderr,
+    });
+}
+function writeStdout(runtime, message) {
+    (runtime.stdout ?? process.stdout).write(message);
+}
+function requireBinding(context) {
+    if (!context.binding) {
+        throw new Error('当前项目尚未绑定远端小程序，请先运行 hb-sdk remote create 或 hb-sdk remote bind <mini-program-id>');
+    }
+    return context.binding;
+}
+function requireMiniProgramId(result) {
+    const miniProgramId = result.mini_program_id;
+    if (typeof miniProgramId !== 'string' || !miniProgramId.trim()) {
+        throw new Error('远端响应缺少 mini_program_id');
+    }
+    return miniProgramId.trim();
+}
+function requireNonEmpty(value, message) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    if (!normalized) {
+        throw new Error(message);
+    }
+    return normalized;
+}
+function validateOptionalHttpsUrl(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const raw = requireNonEmpty(value, `${label} 不能为空`);
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error(`${label} 必须是合法 HTTPS URL`);
+    }
+    if (url.protocol !== 'https:') {
+        throw new Error(`${label} 只接受 HTTPS URL`);
+    }
+    return raw;
+}
+function parseHeyboxIds(values) {
+    if (values.length === 0) {
+        throw new Error('请传入至少一个十进制 heybox_id');
+    }
+    const ids = [];
+    for (const value of values) {
+        const raw = String(value).trim();
+        if (!/^(0|[1-9]\d*)$/.test(raw)) {
+            throw new Error(`heybox_id 只接受十进制数字：${value}`);
+        }
+        const id = Number(raw);
+        if (!Number.isSafeInteger(id) || id <= 0) {
+            throw new Error(`heybox_id 超出有效范围：${value}`);
+        }
+        if (!ids.includes(id)) {
+            ids.push(id);
+        }
+    }
+    return ids;
+}
+function mergeAllowlistIds(command, current, inputIds) {
+    const items = Array.isArray(current.items) ? current.items : [];
+    const ownerIds = items.filter((item) => item.is_owner === true && isValidHeyboxIdNumber(item.heybox_id)).map((item) => item.heybox_id);
+    const currentIds = items.filter((item) => isValidHeyboxIdNumber(item.heybox_id)).map((item) => item.heybox_id);
+    if (command === 'allowlist:add') {
+        return uniqueNumbers([...currentIds, ...inputIds]);
+    }
+    if (command === 'allowlist:remove') {
+        return uniqueNumbers(currentIds.filter((id) => ownerIds.includes(id) || !inputIds.includes(id)));
+    }
+    return uniqueNumbers([...ownerIds, ...inputIds.filter((id) => !ownerIds.includes(id))]);
+}
+function assertAllowlistLimit(ids, limit) {
+    const parsedLimit = typeof limit === 'number' && Number.isFinite(limit) ? limit : undefined;
+    if (parsedLimit !== undefined && ids.length > parsedLimit) {
+        throw new Error(`内测白名单最多 ${parsedLimit} 人，当前操作会变为 ${ids.length} 人`);
+    }
+}
+function uniqueNumbers(values) {
+    const result = [];
+    for (const value of values) {
+        if (!result.includes(value)) {
+            result.push(value);
+        }
+    }
+    return result;
+}
+function isValidHeyboxIdNumber(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+async function confirmDangerousRemoteChange(options, runtime, logger, context) {
+    const lines = [
+        `操作：${context.operation}`,
+        `Mini-program: ${context.miniProgramId}`,
+        `名称：${context.name || '--'}`,
+        `当前状态：${context.status || '--'}`,
+        ...(context.version ? [`目标版本：${context.version}`] : []),
+    ];
+    if (!options.json) {
+        for (const line of lines) {
+            logger.info(line);
+        }
+    }
+    else if (!options.yes) {
+        for (const line of lines) {
+            logger.info(line, { stream: 'stderr' });
+        }
+    }
+    if (options.yes) {
+        return;
+    }
+    const isTTY = runtime.isTTY ?? Boolean(process.stdin.isTTY && process.stderr.isTTY);
+    if (!isTTY) {
+        throw new Error(`非交互环境执行 hb-sdk remote ${context.operation} 必须传 --yes`);
+    }
+    const accepted = runtime.promptConfirm
+        ? await runtime.promptConfirm(`确认执行 ${context.operation}？`)
+        : await promptConfirm(`确认执行 ${context.operation}？输入 yes 继续: `, runtime);
+    if (!accepted) {
+        throw new Error('已取消操作');
+    }
+}
+async function promptConfirm(message, runtime) {
+    const input = runtime.stdin ?? process.stdin;
+    const output = runtime.stderr ?? process.stderr;
+    const rl = promises.createInterface({ input, output: output });
+    try {
+        const answer = await rl.question(message);
+        return answer.trim().toLowerCase() === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+function printMiniProgramDetail(logger, detail) {
+    logger.info(`Mini-program: ${detail.mini_program_id ?? '--'}`);
+    logger.info(`Name: ${detail.name ?? '--'}`);
+    logger.info(`Status: ${detail.status ?? '--'}`);
+    logger.info(`Version: ${detail.version || detail.latest_version_status || '--'}`);
+    if (detail.publish_url) {
+        logger.info(`Publish URL: ${detail.publish_url}`);
+    }
+}
+function printAllowlist(logger, result) {
+    const items = Array.isArray(result.items) ? result.items : [];
+    logger.info(`Limit: ${readNumber(result.limit, 0)}`);
+    if (items.length === 0) {
+        logger.info('内测白名单为空');
+        return;
+    }
+    for (const item of items) {
+        logger.info(`${item.heybox_id ?? '--'}${item.is_owner ? ' (owner)' : ''}${item.nickname ? ` ${item.nickname}` : ''}`);
+    }
+}
+function readNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function toCamelCaseDeep(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => toCamelCaseDeep(item));
+    }
+    if (!value || Object.prototype.toString.call(value) !== '[object Object]') {
+        return value;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        result[toCamelKey(key)] = toCamelCaseDeep(item);
+    }
+    return result;
+}
+function toCamelKey(key) {
+    return key.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+
+var remote = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  resolveDeployReleaseNote: resolveDeployReleaseNote,
-  runDeployCommand: runDeployCommand,
-  validateDeployReleaseNote: validateDeployReleaseNote
+  runRemoteCommand: runRemoteCommand
 });
 
-exports.deploy = deploy;
+exports.remote = remote;
 exports.requireSemver = requireSemver;