@heybox/hb-sdk 0.6.6-alpha.2 → 0.6.6-alpha.4

package/README.md

@@ -132,6 +132,10 @@ await share.showShareMenu({
   title: '我的小程序页面',
   desc: '来自黑盒小程序的分享',
   imageUrl: 'https://imgheybox.max-c.com/demo.png',
+  post: {
+    topicIds: [235709],
+    topics: ['无畏契约战绩'],
+  },
 });
 ```
 
@@ -139,15 +143,23 @@ await share.showShareMenu({
 `/tools/common_share?user_miniprogram_id=...` 分享落地页。只有确实要分享外部
 HTTP(S) 页面时才显式传 `url`。
 
+`post` 用于给“转发到社区”预置可编辑的分区与话题。`topicIds` 接受正整数或非空字符串并按首次出现顺序去重；`topics` 只传话题内容，不要包含首尾 `#`。`showShareMenu()` 只支持一个默认分区，并且不能与 `channel` 同时使用；本地 Mock、App Dev Shell 和开发 Runtime 会直接拒绝这类错误，生产 Runtime 会过滤非法项、只取第一个分区并继续普通分享。`post: null` 等同于不配置。
+
 截图分享：
 
 ```ts
 await share.screenshot({
   delay: 100,
   saveToAlbum: true,
+  post: {
+    topicIds: [235709, 66739],
+    topics: ['无畏契约战绩'],
+  },
 });
 ```
 
+截图分享支持多个预置分区；分区与话题仍由用户在客户端发帖页中确认和修改，SDK 不会直接发布内容。
+
 ### 基础 UI
 
 ```ts
@@ -385,6 +397,7 @@ try {
 | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
 | `hb-sdk create <project-name>`                                                                           | 创建外部小程序模板。                                                                                                    |
 | `hb-sdk dev [--runtime-url <url>]`                                                                       | 启动 Vite 和浏览器 mock 宿主；远端权限可用时使用真实快照，否则以缺失快照启动并默认拒绝受管能力。                      |
+| `hb-sdk build [--env <name>]`                                                                            | 直接使用项目 Vite 构建固定的 `dist/` 生产产物；不执行类型检查，也不要求登录或绑定小程序。                            |
 | `hb-sdk login [--login-base-url <url>] [--no-select-entity]`                                             | 登录 Heybox，并把 CLI 自己需要的登录态和登录入口环境保存在本地缓存中；默认会引导多主体用户选择服务端 current entity。   |
 | `hb-sdk login status`                                                                                    | 查看脱敏后的 CLI 登录态。                                                                                               |
 | `hb-sdk login clear`                                                                                     | 清理 CLI 登录态。                                                                                                       |
@@ -414,6 +427,28 @@ try {
 
 所有命令都支持 `--verbose` / `-v`。默认输出只展示关键阶段状态、可访问 URL、下一步命令和可直接处理的错误提示；需要排查后端 envelope、HTTP 状态、trace id、原始响应体、cache 路径、API origin、逐文件上传进度或提交审核原始失败原因时，再追加 `--verbose` 查看详细调试信息。交互式终端会用颜色、符号和 loading 动画区分成功、警告、错误与耗时步骤；CI、非 TTY 和管道输出会退化为 `[hb-sdk] LEVEL ...` 这种稳定文本行。
 
+## hb-sdk build
+
+生产构建推荐使用：
+
+```bash
+hb-sdk build [--env <name>] [--verbose]
+```
+
+`hb-sdk build` 直接调用当前项目安装的 Vite，固定清理并重新生成 `dist/`，然后校验 `index.html`、`manifest.json` 和可上传产物。命令只负责生产构建，不执行 `scripts.build` 或 TypeScript 类型检查，也不需要 CLI 登录、项目绑定或远端网络。`--env <name>` 用于选择同名构建环境；除 `--env` 和 `--verbose` 外不提供其他构建参数。
+
+项目必须在 `vite.config.ts` 中显式注册 `miniappManifest()`。推荐让项目脚本保留类型检查：
+
+```json
+{
+  "scripts": {
+    "build": "vue-tsc --noEmit && hb-sdk build"
+  }
+}
+```
+
+现有项目继续使用 `vite build` 仍然兼容，不会被自动迁移；新模板和新文档以 `hb-sdk build` 作为生产构建入口。`hb-sdk remote deploy` 仍执行项目自己的 `scripts.build`，因此会保留项目定义的类型检查和其他发布前步骤。
+
 ## hb-sdk remote deploy
 
 `hb-sdk remote deploy` 把版本预检、build、CDN 上传、提交审核 API 串成单条命令。顶层 `hb-sdk deploy` 已删除；旧脚本必须改成 `hb-sdk remote deploy`。命令前置要求：
@@ -538,7 +573,7 @@ CLI 登录态只供 CLI 命令访问黑盒接口时复用，不会注入 iframe
 
 ## Manifest
 
-`@heybox/hb-sdk/vite` 提供构建时插件 `miniappManifest()`。Vite 项目完成 `vite build` 后，会在输出目录写入 `manifest.json`：
+`@heybox/hb-sdk/vite` 提供构建时插件 `miniappManifest()`。项目通过 `hb-sdk build` 完成生产构建后，会在固定的 `dist/` 中写入 `manifest.json`：
 
 ```json
 {
@@ -547,7 +582,7 @@ CLI 登录态只供 CLI 命令访问黑盒接口时复用，不会注入 iframe
 }
 ```
 
-`version` 来自小程序项目自身的 `package.json.version`，`sdkVersion` 来自当前安装 SDK 的构建版本且不能由业务覆盖。`hb-sdk create` 生成的模板默认已注册插件；现有 Vite 项目可以在 `vite.config.ts` 中手动接入：
+`version` 来自小程序项目自身的 `package.json.version`，`sdkVersion` 来自当前安装 SDK 的构建版本且不能由业务覆盖。`hb-sdk build` 要求项目显式注册这个插件；`hb-sdk create` 生成的模板默认已注册，现有 Vite 项目可以在 `vite.config.ts` 中手动接入：
 
 ```ts
 import { miniappManifest } from '@heybox/hb-sdk/vite';
@@ -563,15 +598,17 @@ export default defineConfig({
 
 工坊小程序构建产物只能在兼容的小黑盒 Runtime 中启动。普通浏览器直接打开时不会执行标准业务脚本，并会提示在小黑盒 APP 内打开。项目应使用标准 Vite module 入口。
 
-插件只接受单页应用：输出目录只能存在入口 `index.html`。build 和 dev 都不会注入平台 CSP；项目已有的 CSP 会原样保留。浏览器原生 `fetch`、XHR、WebSocket、EventSource、Beacon、Worker、iframe 和表单等能力不再由 SDK 构建产物统一限制，是否可用由宿主环境、项目自身策略和审核规则共同决定；需要宿主授权的业务网络请求仍应使用 `network.request()`。
+插件只接受单页应用：输出目录只能存在入口 `index.html`。`hb-sdk dev` 和 `hb-sdk remote deploy` 会读取绑定小程序的远端 Runtime 权限；仅当 `network.request` 已启用且 `useOfficialDomain=true` 时跳过平台 CSP，否则 build 会把平台 CSP 插入 `<head>` 首位。直接运行 `vite build`、匿名 dev、非法快照或远端权限读取失败时均继续注入。已有 CSP 始终原样保留；注入平台 CSP 时，两份策略按浏览器交集生效。
+
+平台 CSP 会禁止 `fetch`、XHR、WebSocket、EventSource、Beacon、Worker、iframe、表单和对象加载等浏览器原生出口；dev 只额外放行当前 Vite 的精确 HMR WebSocket 地址。跳过平台 CSP 时，这些能力不再由 SDK 构建产物统一限制，但需要宿主授权的业务网络请求仍应使用 `network.request()`。本地 Mock 权限覆盖不会改变构建 CSP，构建判定始终以远端权限快照为准。
 
-meta refresh、外部 anchor、`dns-prefetch`、`preconnect`、`prerender`、外部资源 URL 和额外 HTML 仍会使 build 失败。`dev` 和手动 Vite build 不再请求远端最低 SDK 版本；构建仍会把当前 `sdkVersion` 写入 Manifest，`hb-sdk remote deploy` 仍校验 Manifest 结构并经过服务端 precheck / submit-audit 策略。
+meta refresh、外部 anchor、`dns-prefetch`、`preconnect`、`prerender`、外部资源 URL 和额外 HTML 会使 build 失败。内联 script/style 允许，但 `unsafe-eval` 不允许。`dev`、`hb-sdk build` 和手动 Vite build 都不请求远端最低 SDK 版本；构建仍会把当前 `sdkVersion` 写入 Manifest，`hb-sdk remote deploy` 仍校验 Manifest 结构并经过服务端 precheck / submit-audit 策略。
 
 失败与警告语义：
 
-- 读取 `package.json` 失败或 JSON 解析失败：`vite build` 直接失败，并输出具体原因。
-- `package.json.version` 不是非空字符串：`vite build` 直接失败。
-- `package.json.version` 仍是模板默认值 `0.0.0`：`vite build` 直接失败，必须改成实际 SemVer。
+- 读取 `package.json` 失败或 JSON 解析失败：build 直接失败，并输出具体原因。
+- `package.json.version` 不是非空字符串：build 直接失败。
+- `package.json.version` 仍是模板默认值 `0.0.0`：build 直接失败，必须改成实际 SemVer。
 - 版本号不是严格 SemVer、包含 build metadata 或缺少 `sdkVersion`：build/deploy 直接失败。
 
 `manifest.json` 不部署到 CDN，只交给发布流水线读取后上送后台；Host 通过后台 API 间接读取版本信息。第一阶段只支持 Vite 项目，非 Vite 打包器未来通过其他子入口扩展。

package/dist/cli-chunks/build-C54stoRf.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+var fs$1 = require('node:fs');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var runtimePermissionEnv = require('./runtime-permission-env-BSs4uCNa.cjs');
+var runtimeGate = require('./runtime-gate--rPXjiG6.cjs');
+var index = require('./index-19i3Dr5H.cjs');
+var projectVite = require('./project-vite-Dl3OoQjL.cjs');
+require('node:async_hooks');
+require('node:module');
+require('path');
+require('os');
+require('readline');
+require('tty');
+require('assert');
+require('events');
+require('stream');
+require('buffer');
+require('util');
+require('node:url');
+
+async function runBuildCommand(_options = {}, runtime = {}) {
+    const logger = runtime.logger ?? index.createCliLogger();
+    const projectRoot = projectVite.findProjectRoot(runtime.cwd ?? process.cwd());
+    const distDir = path.join(projectRoot, 'dist');
+    const env = runtime.env ?? process.env;
+    const mode = env.HB_SDK_ENV?.trim() || undefined;
+    const skipPlatformCsp = runtimePermissionEnv.shouldSkipMiniappPlatformCspFromEnv(env);
+    await fs.rm(distDir, { force: true, recursive: true });
+    try {
+        return await runtimePermissionEnv.withMiniappPlatformCspEnv(skipPlatformCsp, async () => {
+            const vite = await logger.task('正在加载项目 Vite', () => projectVite.loadProjectVite(projectRoot), {
+                successText: '已加载项目 Vite',
+            });
+            await logger.task('正在构建小程序', () => vite.build({
+                root: projectRoot,
+                ...(mode ? { mode } : {}),
+                plugins: [createFixedBuildOutputPlugin(projectRoot)],
+                build: {
+                    outDir: 'dist',
+                    emptyOutDir: true,
+                    watch: null,
+                    write: true,
+                },
+            }), { successText: 'Vite 构建完成' });
+            const result = await validateBuildOutput(projectRoot, logger);
+            logger.success(`构建完成: dist/ | manifest version ${result.version} | sdkVersion ${result.sdkVersion} | 待上传文件 ${result.fileCount} 个 | ${formatSize(result.totalBytes)}`);
+            return result;
+        }, env);
+    }
+    catch (error) {
+        await fs.rm(distDir, { force: true, recursive: true });
+        throw error;
+    }
+}
+function createFixedBuildOutputPlugin(projectRoot) {
+    const distDir = path.join(projectRoot, 'dist');
+    return {
+        name: 'heybox:fixed-miniapp-build-output',
+        configResolved(config) {
+            if (path.resolve(config.root, config.build.outDir) !== distDir || config.build.watch || config.build.write === false) {
+                throw new Error('hb-sdk build 必须执行一次性落盘构建，并输出到项目 dist 目录');
+            }
+            const outputs = Array.isArray(config.build.rollupOptions.output) ? config.build.rollupOptions.output : [config.build.rollupOptions.output];
+            for (const output of outputs) {
+                if (!output)
+                    continue;
+                if (output.file || output.dir) {
+                    throw new Error('hb-sdk build 不允许通过 Rollup output.dir/file 覆盖固定的 dist 输出目录');
+                }
+            }
+        },
+    };
+}
+async function validateBuildOutput(projectRoot, logger) {
+    const distDir = path.join(projectRoot, 'dist');
+    const entryHtmlPath = path.join(distDir, 'index.html');
+    const manifestPath = path.join(distDir, 'manifest.json');
+    if (!fs$1.existsSync(entryHtmlPath)) {
+        throw new Error('未找到 dist/index.html，Vite 构建产物不完整');
+    }
+    if (!fs$1.existsSync(manifestPath)) {
+        throw new Error('未找到 dist/manifest.json，请在 Vite 配置中显式启用 miniappManifest()');
+    }
+    const entryHtml = await fs.readFile(entryHtmlPath, 'utf8');
+    if (!runtimeGate.hasMiniappRuntimeGate(entryHtml)) {
+        throw new Error('dist/index.html 缺少平台 Runtime 启动门禁，请在 Vite 配置中显式启用 miniappManifest()');
+    }
+    const { manifest, hadBom } = runtimeGate.parseMiniappManifestJson(await fs.readFile(manifestPath, 'utf8'), 'dist/manifest.json');
+    if (hadBom) {
+        logger.warn('dist/manifest.json 包含 BOM，已自动剥离');
+    }
+    const { sdkVersion, version } = runtimeGate.validateMiniappManifestForDeploy(manifest);
+    const allFiles = await walkDistFiles(distDir);
+    const uploadFiles = allFiles.filter((file) => runtimePermissionEnv.shouldUploadDistFile(file.relativePath));
+    const sizeError = runtimePermissionEnv.validateUploadTotalSize(uploadFiles);
+    if (sizeError) {
+        throw new Error(sizeError.replace('重新 deploy', '重新 build'));
+    }
+    return {
+        distDir,
+        fileCount: uploadFiles.length,
+        sdkVersion,
+        totalBytes: uploadFiles.reduce((total, file) => total + file.size, 0),
+        version,
+    };
+}
+async function walkDistFiles(distDir) {
+    const results = [];
+    await walk(distDir, '');
+    return results;
+    async function walk(absDir, relDir) {
+        const entries = await fs.readdir(absDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const absPath = path.join(absDir, entry.name);
+            const relPath = runtimePermissionEnv.normalizeRelativePath(relDir ? `${relDir}/${entry.name}` : entry.name);
+            const link = await fs.lstat(absPath);
+            if (link.isSymbolicLink()) {
+                throw new Error(`dist 目录包含 symlink，拒绝处理：${relPath}`);
+            }
+            if (runtimePermissionEnv.relativePathContainsNodeModulesSegment(relPath)) {
+                throw new Error(`dist 目录含 node_modules：${relPath}`);
+            }
+            if (entry.isDirectory()) {
+                await walk(absPath, relPath);
+            }
+            else if (entry.isFile()) {
+                results.push({ relativePath: relPath, size: (await fs.stat(absPath)).size });
+            }
+        }
+    }
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KiB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
+
+exports.runBuildCommand = runBuildCommand;

package/dist/cli-chunks/context-DvTynj3F.cjs

@@ -0,0 +1,410 @@
+'use strict';
+
+var session = require('./session-DJEuhrgq.cjs');
+var runtimePermissionEnv = require('./runtime-permission-env-BSs4uCNa.cjs');
+var fs$1 = require('node:fs');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+
+const MANAGED_RUNTIME_PERMISSION_KEYS = new Set(['network.request']);
+/**
+ * 判断 permission key 是否由 Runtime 权限快照管理。
+ *
+ * @param key 待判断的 permission key。
+ * @returns 该 key 需要读取 Runtime 权限快照时返回 `true`。
+ */
+function isManagedMiniProgramRuntimePermissionKey(key) {
+    return MANAGED_RUNTIME_PERMISSION_KEYS.has(key);
+}
+/**
+ * 解析服务端权限快照；格式不完整时整份快照失效并 fail closed。
+ *
+ * @param snapshot 待校验的服务端权限快照。
+ * @returns 解析状态和通过校验的受管权限。
+ */
+function parseMiniProgramRuntimePermissions(snapshot) {
+    if (!isRecord(snapshot) || snapshot.schema_version !== 1 || !Array.isArray(snapshot.entries)) {
+        return { valid: false, permissions: {} };
+    }
+    if (snapshot.revision !== undefined && (typeof snapshot.revision !== 'number' || !Number.isInteger(snapshot.revision) || snapshot.revision < 0)) {
+        return { valid: false, permissions: {} };
+    }
+    const seenKeys = new Set();
+    const permissions = {};
+    for (const rawEntry of snapshot.entries) {
+        if (!isRecord(rawEntry) || typeof rawEntry.key !== 'string' || !rawEntry.key.trim()) {
+            return { valid: false, permissions: {} };
+        }
+        const key = rawEntry.key.trim();
+        if (seenKeys.has(key) || (rawEntry.status !== 'enabled' && rawEntry.status !== 'disabled') || !isRecord(rawEntry.config)) {
+            return { valid: false, permissions: {} };
+        }
+        seenKeys.add(key);
+        if (!isManagedMiniProgramRuntimePermissionKey(key)) {
+            continue;
+        }
+        if (key === 'network.request' && typeof rawEntry.config.useOfficialDomain !== 'boolean') {
+            return { valid: false, permissions: {} };
+        }
+        permissions[key] = {
+            key,
+            status: rawEntry.status,
+            config: { useOfficialDomain: rawEntry.config.useOfficialDomain },
+        };
+    }
+    return { valid: true, permissions };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+const DEFAULT_PERMISSION_STATE = {
+    networkRequest: {
+        status: 'disabled',
+        useOfficialDomain: false,
+    },
+};
+function createMiniProgramMockPermissionState(context) {
+    const parsed = parseMiniProgramRuntimePermissions(context.runtimePermissions);
+    const networkRequest = parsed.permissions['network.request'];
+    return parsed.valid && networkRequest
+        ? {
+            networkRequest: {
+                status: networkRequest.status,
+                useOfficialDomain: networkRequest.config.useOfficialDomain === true,
+            },
+        }
+        : cloneDefaultPermissionState();
+}
+function shouldSkipMiniappPlatformCsp(runtimePermissions) {
+    const parsed = parseMiniProgramRuntimePermissions(runtimePermissions);
+    const networkRequest = parsed.permissions['network.request'];
+    return parsed.valid && networkRequest?.status === 'enabled' && networkRequest.config.useOfficialDomain === true;
+}
+function createMiniProgramMockRuntimePermissions(state) {
+    return {
+        schema_version: 1,
+        entries: [
+            {
+                key: 'network.request',
+                status: state.networkRequest.status,
+                config: {
+                    useOfficialDomain: state.networkRequest.useOfficialDomain,
+                },
+            },
+        ],
+    };
+}
+function cloneDefaultPermissionState() {
+    return {
+        networkRequest: { ...DEFAULT_PERMISSION_STATE.networkRequest },
+    };
+}
+
+function createRemoteApiClient(options) {
+    return {
+        listDeveloperEntities: () => listDeveloperEntities(options),
+        switchDeveloperEntity: (requestOptions) => switchDeveloperEntity(requestOptions, options),
+        getDeveloperAccessStatus: () => getDeveloperAccessStatus(options),
+        listUserMiniprograms: (requestOptions = {}) => listUserMiniprograms(requestOptions, options),
+        createUserMiniprogram: () => createUserMiniprogram(options),
+        getUserMiniprogramDetail: (requestOptions) => getUserMiniprogramDetail(requestOptions, options),
+        getPreviewAllowlist: (requestOptions) => getPreviewAllowlist(requestOptions, options),
+        updatePreviewAllowlist: (requestOptions) => updatePreviewAllowlist(requestOptions, options),
+        createUserMiniprogramLeaderboard: (requestOptions) => createUserMiniprogramLeaderboard(requestOptions, options),
+        getUserMiniprogramLeaderboard: (requestOptions) => getUserMiniprogramLeaderboard(requestOptions, options),
+        listUserMiniprogramLeaderboards: (requestOptions) => listUserMiniprogramLeaderboards(requestOptions, options),
+        deleteUserMiniprogramLeaderboard: (requestOptions) => deleteUserMiniprogramLeaderboard(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),
+        updateSquareDisplay: (requestOptions) => updateSquareDisplay(requestOptions, options),
+        listUserMiniprogramVersions: (requestOptions) => listUserMiniprogramVersions(requestOptions, options),
+    };
+}
+async function listDeveloperEntities(runtime) {
+    return remoteGet(runtimePermissionEnv.DEVELOPER_ENTITY_LIST_API_PATH, {}, runtime);
+}
+async function switchDeveloperEntity(options, runtime) {
+    return (await remotePostForm(runtimePermissionEnv.DEVELOPER_ENTITY_SWITCH_API_PATH, options, runtime, { requireResult: false })) ?? {};
+}
+async function getDeveloperAccessStatus(runtime) {
+    return remoteGet(runtimePermissionEnv.USER_MINIPROGRAM_ACCESS_STATUS_API_PATH, {}, runtime);
+}
+async function listUserMiniprograms(options, runtime) {
+    return remoteGet(runtimePermissionEnv.LIST_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function createUserMiniprogram(runtime) {
+    return remotePostForm(runtimePermissionEnv.CREATE_USER_MINIPROGRAM_API_PATH, {}, runtime);
+}
+async function getUserMiniprogramDetail(options, runtime) {
+    return remoteGet(runtimePermissionEnv.DETAIL_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function getPreviewAllowlist(options, runtime) {
+    return remoteGet(runtimePermissionEnv.USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH, options, runtime);
+}
+async function updatePreviewAllowlist(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.UPDATE_USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH, options, runtime);
+}
+async function createUserMiniprogramLeaderboard(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.CREATE_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime);
+}
+async function getUserMiniprogramLeaderboard(options, runtime) {
+    return remoteGet(runtimePermissionEnv.DETAIL_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime);
+}
+async function listUserMiniprogramLeaderboards(options, runtime) {
+    return remoteGet(runtimePermissionEnv.LIST_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime);
+}
+async function deleteUserMiniprogramLeaderboard(options, runtime) {
+    return (await remotePostForm(runtimePermissionEnv.DELETE_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime, { requireResult: false })) ?? {};
+}
+async function precheckUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.PRECHECK_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function submitUserMiniprogramAudit(options, runtime) {
+    const form = { ...options };
+    if (form.manifest && typeof form.manifest !== 'string') {
+        form.manifest = JSON.stringify(form.manifest);
+    }
+    return remotePostForm(runtimePermissionEnv.SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH, form, runtime);
+}
+async function getVersionPreviewInfo(options, runtime) {
+    return remoteGet(runtimePermissionEnv.USER_MINIPROGRAM_VERSION_PREVIEW_INFO_API_PATH, {
+        mini_program_id: options.mini_program_id,
+        preview_version: options.version,
+    }, runtime);
+}
+async function withdrawUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.WITHDRAW_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function releaseUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.RELEASE_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function takeDownUserMiniprogram(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.TAKE_DOWN_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function reopenUserMiniprogram(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.REOPEN_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function updateSquareDisplay(options, runtime) {
+    return remotePostForm(runtimePermissionEnv.UPDATE_SQUARE_DISPLAY_API_PATH, options, runtime);
+}
+async function listUserMiniprogramVersions(options, runtime) {
+    return remoteGet(runtimePermissionEnv.LIST_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function remoteGet(path, query, runtime) {
+    const pathWithQuery = createPathWithQuery(path, query);
+    const context = session.createHeyboxOpenPlatformRequestContext(runtime.session, pathWithQuery);
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const response = await fetchImpl(session.createHeyboxApiUrl(runtime.baseUrl ?? context.baseUrl, pathWithQuery, context.platformParams), {
+        method: 'GET',
+        headers: context.headers,
+    });
+    return readRequiredResult(response, pathWithQuery);
+}
+async function remotePostForm(path, fields, runtime, options = {}) {
+    const context = session.createHeyboxOpenPlatformRequestContext(runtime.session, path, {
+        contentType: 'application/x-www-form-urlencoded',
+    });
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const response = await fetchImpl(session.createHeyboxApiUrl(runtime.baseUrl ?? context.baseUrl, path, context.platformParams), {
+        method: 'POST',
+        headers: context.headers,
+        body: createFormBody(fields),
+    });
+    if (options.requireResult === false) {
+        return readOptionalResult(response, path);
+    }
+    return readRequiredResult(response, path);
+}
+async function readRequiredResult(response, pathWithQuery) {
+    const result = await session.readHeyboxApiEnvelope(response, { pathWithQuery, requireResult: true });
+    return result;
+}
+async function readOptionalResult(response, pathWithQuery) {
+    return session.readHeyboxApiEnvelope(response, { pathWithQuery, requireResult: false });
+}
+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$1.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.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 readBoundMiniProgramId(startDir) {
+    return readBoundMiniProgramIdFromPackageJson((await readMiniProgramProjectPackage(startDir)).packageJson);
+}
+async function requireBoundMiniProgramId(startDir) {
+    const context = await readMiniProgramProjectPackage(startDir);
+    const miniProgramId = readBoundMiniProgramIdFromPackageJson(context.packageJson);
+    if (!miniProgramId) {
+        throw new MiniProgramProjectBindingError(`当前项目未绑定小程序。请先运行 hb-sdk remote create 或 hb-sdk remote bind <mini-program-id>。\n配置位置：${context.packageJsonPath}#heybox.miniProgramId`, 'MINI_PROGRAM_UNBOUND');
+    }
+    return { ...context, miniProgramId };
+}
+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.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,
+    });
+}
+async function getBoundMiniProgram(options = {}, runtime = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const binding = await requireBoundMiniProgramId(cwd);
+    const api = await resolveRemoteApiClient(options, runtime);
+    const detail = await api.getUserMiniprogramDetail({ mini_program_id: binding.miniProgramId });
+    return {
+        ...binding,
+        detail,
+    };
+}
+async function resolveRemoteApiClient(options, runtime) {
+    if (runtime.apiClient) {
+        return runtime.apiClient;
+    }
+    return createRemoteApiClientForEnvironment(await resolveRemoteEnvironment(options, runtime));
+}
+function isTruthyEnvFlag(value) {
+    return ['1', 'true', 'yes', 'on'].includes(String(value ?? '')
+        .trim()
+        .toLowerCase());
+}
+
+exports.MiniProgramProjectBindingError = MiniProgramProjectBindingError;
+exports.createMiniProgramMockPermissionState = createMiniProgramMockPermissionState;
+exports.createMiniProgramMockRuntimePermissions = createMiniProgramMockRuntimePermissions;
+exports.createRemoteApiClientForEnvironment = createRemoteApiClientForEnvironment;
+exports.getBoundMiniProgram = getBoundMiniProgram;
+exports.parseMiniProgramRuntimePermissions = parseMiniProgramRuntimePermissions;
+exports.readBoundMiniProgramId = readBoundMiniProgramId;
+exports.readBoundMiniProgramIdFromPackageJson = readBoundMiniProgramIdFromPackageJson;
+exports.readMiniProgramProjectPackage = readMiniProgramProjectPackage;
+exports.resolveRemoteEnvironment = resolveRemoteEnvironment;
+exports.shouldSkipMiniappPlatformCsp = shouldSkipMiniappPlatformCsp;
+exports.writeBoundMiniProgramId = writeBoundMiniProgramId;

package/dist/cli-chunks/{create-CxjB3oSo.cjs → create-uQS30kS_.cjs}

@@ -5,7 +5,7 @@ var fs = require('node:fs/promises');
 var path = require('node:path');
 var require$$0 = require('fs');
 var require$$1 = require('path');
-var index = require('./index-ByDy5HXi.cjs');
+var index = require('./index-19i3Dr5H.cjs');
 require('node:module');
 require('os');
 require('readline');