@heybox/hb-sdk 0.6.6-alpha.1 → 0.6.6-alpha.3

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';
@@ -565,13 +600,13 @@ export default defineConfig({
 
 插件只接受单页应用：输出目录只能存在入口 `index.html`。build 会用结构化 HTML parser 校验入口，并把平台 CSP 插入 `<head>` 首位；已有 CSP 会原样保留，两份策略按浏览器交集生效。正式策略禁止 `fetch`、XHR、WebSocket、EventSource、Beacon、Worker、iframe、表单和对象加载等浏览器原生出口；业务网络请求应使用 `network.request()`。dev 使用相同策略，只额外放行当前 Vite 的精确 HMR WebSocket 地址。
 
-meta refresh、外部 anchor、`dns-prefetch`、`preconnect`、`prerender`、外部资源 URL 和额外 HTML 会使 build 失败。内联 script/style 允许，但 `unsafe-eval` 不允许。`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-De-QADpA.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+var fs$1 = require('node:fs');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var index$1 = require('./index-BQm5XmMC.cjs');
+var runtimeGate = require('./runtime-gate-B2MQf1vc.cjs');
+var index = require('./index-QAkYgxPI.cjs');
+var projectVite = require('./project-vite-VcJMyz1l.cjs');
+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 mode = (runtime.env ?? process.env).HB_SDK_ENV?.trim() || undefined;
+    await fs.rm(distDir, { force: true, recursive: true });
+    try {
+        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;
+    }
+    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) => index$1.shouldUploadDistFile(file.relativePath));
+    const sizeError = index$1.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 = index$1.normalizeRelativePath(relDir ? `${relDir}/${entry.name}` : entry.name);
+            const link = await fs.lstat(absPath);
+            if (link.isSymbolicLink()) {
+                throw new Error(`dist 目录包含 symlink，拒绝处理：${relPath}`);
+            }
+            if (index$1.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-CvZs9ZBf.cjs

@@ -0,0 +1,311 @@
+'use strict';
+
+var session = require('./session-YJ8xNESM.cjs');
+var index = require('./index-BQm5XmMC.cjs');
+var fs$1 = require('node:fs');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+
+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(index.DEVELOPER_ENTITY_LIST_API_PATH, {}, runtime);
+}
+async function switchDeveloperEntity(options, runtime) {
+    return (await remotePostForm(index.DEVELOPER_ENTITY_SWITCH_API_PATH, options, runtime, { requireResult: false })) ?? {};
+}
+async function getDeveloperAccessStatus(runtime) {
+    return remoteGet(index.USER_MINIPROGRAM_ACCESS_STATUS_API_PATH, {}, runtime);
+}
+async function listUserMiniprograms(options, runtime) {
+    return remoteGet(index.LIST_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function createUserMiniprogram(runtime) {
+    return remotePostForm(index.CREATE_USER_MINIPROGRAM_API_PATH, {}, runtime);
+}
+async function getUserMiniprogramDetail(options, runtime) {
+    return remoteGet(index.DETAIL_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function getPreviewAllowlist(options, runtime) {
+    return remoteGet(index.USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH, options, runtime);
+}
+async function updatePreviewAllowlist(options, runtime) {
+    return remotePostForm(index.UPDATE_USER_MINIPROGRAM_PREVIEW_ALLOWLIST_API_PATH, options, runtime);
+}
+async function createUserMiniprogramLeaderboard(options, runtime) {
+    return remotePostForm(index.CREATE_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime);
+}
+async function getUserMiniprogramLeaderboard(options, runtime) {
+    return remoteGet(index.DETAIL_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime);
+}
+async function listUserMiniprogramLeaderboards(options, runtime) {
+    return remoteGet(index.LIST_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime);
+}
+async function deleteUserMiniprogramLeaderboard(options, runtime) {
+    return (await remotePostForm(index.DELETE_USER_MINIPROGRAM_LEADERBOARD_API_PATH, options, runtime, { requireResult: false })) ?? {};
+}
+async function precheckUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(index.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(index.SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH, form, runtime);
+}
+async function getVersionPreviewInfo(options, runtime) {
+    return remoteGet(index.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(index.WITHDRAW_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function releaseUserMiniprogramVersion(options, runtime) {
+    return remotePostForm(index.RELEASE_USER_MINIPROGRAM_VERSION_API_PATH, options, runtime);
+}
+async function takeDownUserMiniprogram(options, runtime) {
+    return remotePostForm(index.TAKE_DOWN_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function reopenUserMiniprogram(options, runtime) {
+    return remotePostForm(index.REOPEN_USER_MINIPROGRAM_API_PATH, options, runtime);
+}
+async function updateSquareDisplay(options, runtime) {
+    return remotePostForm(index.UPDATE_SQUARE_DISPLAY_API_PATH, options, runtime);
+}
+async function listUserMiniprogramVersions(options, runtime) {
+    return remoteGet(index.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.createRemoteApiClientForEnvironment = createRemoteApiClientForEnvironment;
+exports.getBoundMiniProgram = getBoundMiniProgram;
+exports.readBoundMiniProgramId = readBoundMiniProgramId;
+exports.readBoundMiniProgramIdFromPackageJson = readBoundMiniProgramIdFromPackageJson;
+exports.readMiniProgramProjectPackage = readMiniProgramProjectPackage;
+exports.resolveRemoteEnvironment = resolveRemoteEnvironment;
+exports.writeBoundMiniProgramId = writeBoundMiniProgramId;

package/dist/cli-chunks/{create-DlU4nWz_.cjs → create-B5gGBaSV.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-gP0K2xx1.cjs');
+var index = require('./index-QAkYgxPI.cjs');
 require('node:module');
 require('os');
 require('readline');

package/dist/cli-chunks/{dev-Bb4U965a.cjs → dev-BcCWCeac.cjs}

@@ -1,23 +1,24 @@
 'use strict';
 
-var node_module = require('node:module');
 var fs = require('node:fs');
-var fs$1 = require('node:fs/promises');
 var os = require('node:os');
 var path = require('node:path');
-var node_url = require('node:url');
 var net = require('node:net');
 var promises = require('node:dns/promises');
 var node_http = require('node:http');
 var node_crypto = require('node:crypto');
 var undici = require('undici');
 var browser = require('./browser-RAy8e8cV.cjs');
-var index = require('./index-gP0K2xx1.cjs');
-var context = require('./context-D-cb_pNY.cjs');
+var index = require('./index-QAkYgxPI.cjs');
+var projectVite = require('./project-vite-VcJMyz1l.cjs');
+var context = require('./context-CvZs9ZBf.cjs');
+var fs$1 = require('node:fs/promises');
 require('node:process');
 require('node:buffer');
+require('node:url');
 require('node:util');
 require('node:child_process');
+require('node:module');
 require('path');
 require('os');
 require('readline');
@@ -27,9 +28,10 @@ require('events');
 require('stream');
 require('buffer');
 require('util');
-require('./session-BRwveiW8.cjs');
+require('./session-YJ8xNESM.cjs');
 require('fs');
 require('constants');
+require('./index-BQm5XmMC.cjs');
 
 class Locked extends Error {
 	constructor(port) {
@@ -1257,7 +1259,7 @@ function cloneDefaultPermissionState() {
 /** 构建时替换为当前发布包的实际版本。 */
 const HB_SDK_VERSION = typeof undefined === 'string'
     ? undefined
-    : '0.6.6-alpha.1';
+    : '0.6.6-alpha.3';
 
 class DevPermissionOverrideStoreError extends Error {
     code;
@@ -1405,7 +1407,7 @@ async function runDevCommand(options, runtime = {}) {
         hmrHost: createLanInterfaceCandidates(networkInterfaceSnapshot)[0]?.address,
         port: appPort,
     };
-    const projectRoot = findProjectRoot(runtime.cwd ?? process.cwd());
+    const projectRoot = projectVite.findProjectRoot(runtime.cwd ?? process.cwd());
     const devLaunchContext = await loadDevLaunchContext({
         env: runtime.env,
         fetchImpl,
@@ -1427,7 +1429,7 @@ async function runDevCommand(options, runtime = {}) {
         }),
         projectRoot,
     });
-    const vite = await logger.task('正在加载项目 Vite', () => loadProjectVite(projectRoot), { successText: '已加载项目 Vite' });
+    const vite = await logger.task('正在加载项目 Vite', () => projectVite.loadProjectVite(projectRoot), { successText: '已加载项目 Vite' });
     const appServer = await logger.task('正在创建 Vite dev server', () => withManagedDevOutputEnv(() => vite.createServer(createViteServerOptions(projectRoot, resolvedOptions)), runtime.env), { successText: '已创建 Vite dev server' });
     await logger.task('正在启动 Vite dev server', () => appServer.listen(appPort), {
         successText: 'Vite dev server 已启动',
@@ -1623,39 +1625,6 @@ async function loadRemoteDevContextWithTimeout(options) {
         }
     }
 }
-function findProjectRoot(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 Error('当前目录或父目录未找到 package.json');
-        }
-        current = parent;
-    }
-}
-async function loadProjectVite(projectRoot) {
-    const projectRequire = node_module.createRequire(path.join(projectRoot, 'package.json'));
-    try {
-        const packageJson = JSON.parse(await fs$1.readFile(path.join(projectRoot, 'package.json'), 'utf8'));
-        if (!hasPackageDependency(packageJson, 'vite')) {
-            throw new Error('package.json 未声明 vite');
-        }
-        const viteEntry = projectRequire.resolve('vite');
-        return (await import(node_url.pathToFileURL(viteEntry).href));
-    }
-    catch (error) {
-        throw new Error(`当前项目未安装 vite。请先安装项目依赖，或将 vite 放到项目 devDependencies。原始错误: ${index.readErrorMessage(error)}`);
-    }
-}
-function hasPackageDependency(packageJson, name) {
-    return Boolean(packageJson.dependencies?.[name] ||
-        packageJson.devDependencies?.[name] ||
-        packageJson.optionalDependencies?.[name] ||
-        packageJson.peerDependencies?.[name]);
-}
 function createViteServerOptions(projectRoot, options) {
     const configFile = resolveProjectViteConfig(projectRoot);
     const server = {