@linanw/homebridge-mijia-remote-camera 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 linanw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,95 @@
-# Temporary Holding Version
+# 米家远程摄像头：独立 Homebridge 插件
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+插件：`@linanw/homebridge-mijia-remote-camera`，平台：`MijiaRemoteCamera`。
+
+登录、家庭选择、远程摄像头连接、快照和 HomeKit 视频由插件管理，无需独立的 viewer / relay 容器或另一个摄像头插件。摄像头可以位于其他网络。
+
+目前后端仅实现 CS2/vendor 4。已在一台小米智能摄像机 3 Pro 云台版上验证跨网络远程取流，以及真实 Apple“家庭”的配对、预览和直播。具体测试环境见下文“验证范围”；其他型号、地区和网络环境尚未逐一验证。
+
+要求 Linux x86_64、Node.js 22 或 24、Homebridge 1.9+ 或 2.x，以及支持自定义插件设置页的 Homebridge UI。适用 Synology DS1618+ 上以 host 网络运行的 Homebridge Docker。支持 glibc 和 musl；其他架构不支持。
+
+## 安装和首次导入
+
+公开 npm 包包含插件代码和由这些源码编译的自有 Java 适配器，**首次需要从已有的本地运行包导入组件**。运行组件不随 npm 分发，也不会自动从网上下载；详情见 `THIRD_PARTY_NOTICES.md`。目前支持指定版本的本地包 `homebridge-mijia-remote-camera-0.1.0.tgz`，已有该包的用户可按以下步骤迁移。没有该本地包时，npm 包本身不能提供视频功能。
+
+先停止此前连接这台摄像头的 `viewer` / `relay` 容器。若已经安装旧的无 scope 插件，先在 Homebridge 管理界面的终端内卸载并重启 Homebridge，释放旧进程：
+
+```sh
+npm uninstall -g homebridge-mijia-remote-camera
+```
+
+已有的本地 `.tgz` 文件请保留。然后在同一个管理终端安装公开包：
+
+```sh
+npm install -g @linanw/homebridge-mijia-remote-camera
+```
+
+将已有的 `homebridge-mijia-remote-camera-0.1.0.tgz` 放入 Homebridge 持久化目录，容器内通常为 `/homebridge`。在首次启用新插件之前执行一次：
+
+```sh
+mijia-camera-setup --from /homebridge/homebridge-mijia-remote-camera-0.1.0.tgz --storage /homebridge
+```
+
+导入程序只读取运行文件并核验固定 SHA-256，保留组件的 legal 目录，保存到 `/homebridge/mijia-remote-camera/runtime`。它不会导入旧包的插件代码、凭据或 Homebridge 配置；当插件正在使用该目录时，会拒绝导入。重复导入会核验并保留已有组件。已有组件损坏时会保留原目录，请先将该 `runtime` 目录移走备份后重新导入。若使用其他存储位置，请把 `--storage` 改为 Homebridge 的真实存储目录。
+
+若提示 `runtime_in_use`，请先停用当前米家平台并重启 Homebridge，待旧进程释放目录后重试。
+
+重新启动 Homebridge，打开“米家远程摄像头”的设置页，点击“启用并保存配置”，按提示再重启一次。也可向现有 `platforms` 数组加入：
+
+```json
+{
+  "platform": "MijiaRemoteCamera",
+  "name": "米家远程摄像头",
+  "region": "cn"
+}
+```
+
+保留现有 Bridge、配对 PIN、其他平台和配件配置。组件导入后无需系统 Java、Python 或新 Docker 服务。npm 升级会保留存储目录中的组件、会话和设备选择；兼容旧插件的配件 UUID。
+
+## 登录、选择家庭和配对
+
+在插件设置页选择与米家 App 相同的地区，生成小米官方登录链接，在已登录的 Edge 中打开并确认。授权后先选择自有或共享家庭，再选择摄像头并保存。插件会连接远程中继并保持连接。
+
+已有有效插件会话时可点击“使用已有登录，读取家庭”。取消或失败的授权保留原凭据。更换已发布的摄像头需要重启 Homebridge；同一摄像头更新登录或家庭选择可以刷新连接。
+
+摄像头作为独立配件发布。在 iPhone“家庭 → 添加配件 → 更多选项”中选择它，使用该摄像头启动日志中 `Please add [...] manually in Home app. Setup Code:` 后面的配对码。插件运行在子桥时，这个码可能与 Homebridge 首页的主桥配对码不同。
+
+默认最高 640×360、12 fps、700 kbps，最多一路实时视频。当前提供实时视频和快照，未接入声音、对讲、云台、运动事件、录像回放及 HomeKit Secure Video。
+
+为兼容 Apple“家庭”的媒体能力协商，插件默认公布 AAC-ELD 16 kHz 音频能力和静音 Microphone 服务；实际不采集或发送摄像头声音。家庭中可能显示麦克风控件，目前仍只提供视频。
+
+## 数据和运行管理
+
+会话、设备选择和导入的组件保存在：
+
+```text
+<Homebridge storage>/mijia-remote-camera/
+  .micam/credentials.json
+  selection.json
+  region.json
+  runtime/
+```
+
+私有目录权限为 `0700`，凭据和选择文件为 `0600`。小米 Token 不写入 Homebridge `config.json`。设置页通过 Homebridge 的受保护接口和本机 Unix socket 通信；原始视频仅监听临时的本机回环端口。Homebridge 启动后恢复所选摄像头，关闭时清理 Java、FFmpeg 和 UDP 会话，临时网络故障会自动重连。
+
+插件按单个账号、单个摄像头设计，按所选家庭及实际所有者查询完整设备分页。迁移前请备份 Homebridge 存储目录。
+
+## 验证范围
+
+实际设备验证使用一台小米智能摄像机 3 Pro 云台版，摄像头与 NAS 位于不同网络。Synology DS1618+ 上的 Homebridge Docker 使用 host 网络，Homebridge 2.0.2 / HAP 2.1.6；远程源为 HEVC，由 NAS 解码并转换为 HomeKit 视频。用户已确认 iOS 26.6.2 的 Apple“家庭”预览和直播正常。
+
+本地测试另覆盖 Homebridge 1／2 的原生 HAP CameraController、加密快照与 SRTP 发送／独立接收解码、进程清理、授权取消与原子保存、家庭作用域、真实 Homebridge 设置页 IPC 和本地 Java 启动。
+
+远程中继仍可能间歇断开并自动重连，重连期间预览和直播可能暂不可用。目前尚未完成长时间稳定性验证。
+
+## 连接诊断
+
+设置页可展开“连接诊断”，查看连接阶段、重试次数、上次失败原因及 HomeKit 快照／直播请求计数。“已收到摄像头视频”表示米家视频源已就绪；快照和直播计数则显示 HomeKit 是否已请求媒体。也可在 Homebridge 终端运行：
+
+```sh
+mijia-camera-diagnose --storage /var/lib/homebridge
+```
+
+`--storage` 必须是实例真实的存储目录，也可能是 `/homebridge`。输出不包含小米凭据、设备 ID 或视频地址。HomeKit 快照请求不会跳过连接重试间隔。
+
+能在插件中收到视频、但 Apple“家庭”添加失败时，请检查摄像头日志中的独立 HomeKit 端口及 Setup Code；摄像头端口与主桥／子桥端口不同。

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,31 @@
+# Distribution and components
+
+The code distributed in this npm package is licensed under MIT. It does not
+contain the micam backend, third-party Java runtime, FFmpeg binary, or
+ffmpeg-for-homebridge installer. The runtime manifest contains provenance and
+SHA-256 identifiers only; it does not grant rights to the identified components.
+The included `backend/bridge.jar` contains only the original MIT-licensed
+`mijia.bridge.Bridge` adapter classes built from the supplied Java source.
+No micam or Jackson implementation classes are included in that JAR.
+
+The local setup command imports runtime files already available on the user's
+machine. It does not download them or upload them to npm. Local runtime files
+are separate from the package and retain their original rights and notices.
+
+- micam, commit `2cc9d9e7607014d1d05c17bc5676544fbb0d5d24`, with local
+  authentication and home-selection fixes. Source:
+  https://github.com/eugeneRover/micam . The pinned repository has no license.
+  No redistribution permission is asserted by this package.
+- Eclipse Temurin / OpenJDK 21, Linux x64 glibc and musl. Source:
+  https://github.com/adoptium/containers . The importer retains all existing
+  runtime legal notices. Image digests and file hashes are in
+  `runtime-manifest.json`.
+- The known local runtime includes FFmpeg for Homebridge 2.2.2 / FFmpeg 8.0,
+  built with `--enable-nonfree`. That binary is excluded from this npm package.
+  Source/build information: https://github.com/homebridge/ffmpeg-for-homebridge .
+- npm resolves `@homebridge/plugin-ui-utils` (MIT), `tough-cookie` (BSD-3-Clause),
+  `tar` (BlueOak-1.0.0), and their dependencies separately, under their respective
+  licenses. They are not bundled in the published tarball.
+
+The HomeKit streaming delegate uses Homebridge's public HAP API and requires
+neither `homebridge-camera-ffmpeg` nor an independent relay service.

package/backend/Bridge.java

@@ -0,0 +1,263 @@
+package mijia.bridge;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import micam.cloud.Device;
+import micam.cloud.Home;
+import micam.cloud.HomeApiException;
+import micam.cloud.MiCloud;
+import micam.cloud.Provisioning;
+import micam.creds.CredentialStore;
+import micam.creds.Credentials;
+import micam.miss.MediaPacket;
+import micam.miss.MissClient;
+import micam.miss.MissCrypto;
+import micam.pppp.PpppConnection;
+import micam.pppp.RelaySession;
+import micam.pppp.Uid;
+import micam.server.HttpStreamServer;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.attribute.PosixFilePermissions;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.LongSupplier;
+import java.util.function.Supplier;
+
+/** Machine interface for Homebridge. No terminal prompts or raw upstream logs. */
+public final class Bridge {
+    private static final ObjectMapper JSON = new ObjectMapper();
+    private static final PrintStream OUTPUT = System.out;
+    private static final Set<String> REGIONS = Set.of("cn", "ru", "de", "sg", "us", "i2");
+    private final CredentialStore store = new CredentialStore();
+    private Credentials credentials;
+    private MiCloud cloud;
+    private boolean renewed;
+
+    private static final class Failure extends RuntimeException {
+        final int exit;
+        final String reason;
+        Failure(int exit, String reason) { super(reason); this.exit = exit; this.reason = reason; }
+    }
+
+    enum Stage {
+        DEVICE_LOOKUP("device_lookup"), PROVISIONING("provisioning"), RELAY_CONNECT("relay_connect"),
+        AUTHENTICATION("authentication"), WAITING_VIDEO("waiting_video");
+        final String value;
+        Stage(String value) { this.value = value; }
+    }
+
+    /** The first keyframe deadline is independent of subsequent non-keyframe traffic. */
+    static final class VideoWatchdog {
+        private final LongSupplier clock;
+        private final long started;
+        private final long packetTimeout;
+        private final long keyframeTimeout;
+        private long lastVideo;
+        private boolean receivedKeyframe;
+
+        VideoWatchdog(LongSupplier clock, Duration packetTimeout, Duration keyframeTimeout) {
+            this.clock = clock;
+            this.packetTimeout = packetTimeout.toNanos();
+            this.keyframeTimeout = keyframeTimeout.toNanos();
+            this.started = clock.getAsLong();
+            this.lastVideo = started;
+        }
+
+        void observe(boolean video, boolean keyframe) {
+            long now = clock.getAsLong();
+            if (now - lastVideo >= packetTimeout || (!receivedKeyframe && now - started >= keyframeTimeout)) {
+                throw new Failure(5, "no_video");
+            }
+            if (video) {
+                lastVideo = now;
+                if (keyframe) receivedKeyframe = true;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        // Even an accidental upstream println cannot contaminate the IPC channel.
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+        System.setErr(new PrintStream(OutputStream.nullOutputStream()));
+        int exit;
+        try { exit = new Bridge().run(args); }
+        catch (Failure failure) { emit(Map.of("success", false, "reason", failure.reason)); exit = failure.exit; }
+        catch (HomeApiException failure) {
+            emit(Map.of("success", false, "reason", safeReason(failure.reason()),
+                    "code", failure.code() == null ? 0 : failure.code()));
+            exit = "session_expired".equals(failure.reason()) ? 2 : 7;
+        }
+        catch (Exception failure) { emit(Map.of("success", false, "reason", "backend_failed")); exit = 3; }
+        System.exit(exit);
+    }
+
+    private int run(String[] args) throws IOException {
+        if (args.length < 2 || !REGIONS.contains(args[1])) throw new Failure(7, "invalid_request");
+        String action = args[0];
+        if (!Set.of("homes", "devices", "stream").contains(action)) throw new Failure(7, "invalid_request");
+        if (!(action.equals("homes") && args.length == 2)
+                && !(action.equals("devices") && args.length == 4)
+                && !(action.equals("stream") && args.length == 7)) throw new Failure(7, "invalid_request");
+        if (args.length >= 4) { identifier(args[2]); identifier(args[3]); }
+        if (action.equals("stream")) { identifier(args[4]); number(args[5], 1024, 65535); number(args[6], 0, 3); }
+        try { credentials = store.load(); }
+        catch (RuntimeException invalid) { throw new Failure(2, "authentication_required"); }
+        credentials.region = args[1];
+        cloud = new MiCloud(credentials);
+        if (!credentials.hasSession()) renew();
+        if (action.equals("homes") && args.length == 2) {
+            List<Map<String, Object>> homes = request(cloud::homeList).stream().map(home -> Map.<String, Object>of(
+                    "id", home.id(), "ownerId", home.ownerId(), "name", home.name(), "shared", home.shared())).toList();
+            emit(Map.of("success", true, "homes", homes));
+            return 0;
+        }
+        if (args.length < 4) throw new Failure(7, "invalid_request");
+        Home home = new Home(identifier(args[2]), identifier(args[3]), "", false);
+        if (action.equals("stream")) progress(Stage.DEVICE_LOOKUP);
+        List<Device> cameras = request(() -> cloud.deviceList(home)).stream().filter(Device::isCamera).toList();
+        if (action.equals("devices") && args.length == 4) {
+            emit(Map.of("success", true, "devices", cameras.stream().map(device -> Map.<String, Object>of(
+                    "deviceId", device.did(), "name", label(device.name()), "model", label(device.model()),
+                    "online", device.online())).toList()));
+            return 0;
+        }
+        if (!action.equals("stream") || args.length != 7) throw new Failure(7, "invalid_request");
+        String did = identifier(args[4]);
+        int port = number(args[5], 1024, 65535);
+        int quality = number(args[6], 0, 3);
+        Device device = cameras.stream().filter(camera -> did.equals(camera.did())).findFirst()
+                .orElseThrow(() -> new Failure(7, "camera_not_in_home"));
+        if (!device.online()) throw new Failure(4, "camera_offline");
+        progress(Stage.PROVISIONING);
+        Provisioning provision = request(() -> cloud.missGetVendor(did));
+        if (!provision.isCs2()) {
+            emit(Map.of("success", false, "reason", "unsupported_transport", "vendor", provision.vendorId()));
+            return 1;
+        }
+        return stream(provision, port, quality);
+    }
+
+    private <T> T request(Supplier<T> call) {
+        try { return call.get(); }
+        catch (HomeApiException failure) {
+            if (!"session_expired".equals(failure.reason()) || renewed) throw failure;
+            renew();
+            return call.get();
+        }
+    }
+
+    private void renew() {
+        if (renewed || !credentials.canRenew()) throw new Failure(2, "authentication_required");
+        renewed = true;
+        try {
+            cloud.login(null);
+            // Keep the original file intact until a complete renewal succeeds.
+            if (!credentials.hasSession()) throw new Failure(2, "authentication_required");
+            Path file = store.path();
+            Files.createDirectories(file.getParent());
+            Files.setPosixFilePermissions(file.getParent(), PosixFilePermissions.fromString("rwx------"));
+            Path temp = file.resolveSibling(".credentials-java-" + UUID.randomUUID() + ".tmp");
+            try {
+                Files.createFile(temp, PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rw-------")));
+                JSON.writeValue(temp.toFile(), credentials);
+                Files.move(temp, file, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
+            } finally { Files.deleteIfExists(temp); }
+        } catch (Exception failure) { throw new Failure(2, "authentication_required"); }
+    }
+
+    private int stream(Provisioning provision, int port, int quality) {
+        Resources resources = new Resources();
+        AtomicBoolean running = new AtomicBoolean(true);
+        Thread hook = new Thread(() -> { running.set(false); resources.close(); }, "mijia-bridge-stop");
+        Runtime.getRuntime().addShutdownHook(hook);
+        try {
+            progress(Stage.RELAY_CONNECT, provision.vendorId());
+            resources.relay = new RelaySession(Uid.parse(provision.p2pId()), provision.servers(), null);
+            RelaySession.Established established = resources.relay.connect(Duration.ofSeconds(90));
+            resources.connection = new PpppConnection(resources.relay.socket(), established.relay(), null);
+            resources.connection.start();
+            resources.camera = new MissClient(resources.connection);
+            progress(Stage.AUTHENTICATION, provision.vendorId());
+            resources.camera.authenticate(provision.clientPublic(), provision.sign(), Duration.ofSeconds(15));
+            resources.camera.useSessionKey(MissCrypto.sessionKey(provision.clientPrivate(), provision.devicePublic()));
+            progress(Stage.WAITING_VIDEO, provision.vendorId());
+            resources.camera.startVideo(quality, false);
+            VideoWatchdog watchdog = new VideoWatchdog(System::nanoTime, Duration.ofSeconds(10), Duration.ofSeconds(15));
+            while (running.get()) {
+                MediaPacket frame = resources.camera.nextMedia(Duration.ofSeconds(1));
+                watchdog.observe(frame != null && frame.isVideo(), frame != null && frame.isVideo() && frame.isKeyframe());
+                if (frame == null || !frame.isVideo()) {
+                    continue;
+                }
+                if (resources.server == null) {
+                    if (!frame.isKeyframe()) continue;
+                    resources.server = new HttpStreamServer(port, "/cam.ts", null);
+                    resources.server.start();
+                    emit(Map.of("success", true, "event", "ready", "port", port,
+                            "videoReceived", true, "codec", frame.codecName()));
+                }
+                resources.server.publish(frame);
+            }
+            return 0;
+        } catch (java.net.BindException failure) { throw new Failure(6, "port_in_use"); }
+        catch (Failure failure) { throw failure; }
+        catch (Exception failure) { throw new Failure(3, "connection_failed"); }
+        finally {
+            resources.close();
+            try { Runtime.getRuntime().removeShutdownHook(hook); }
+            catch (IllegalStateException ignored) { }
+        }
+    }
+
+    private static final class Resources {
+        volatile RelaySession relay;
+        volatile PpppConnection connection;
+        volatile MissClient camera;
+        volatile HttpStreamServer server;
+        synchronized void close() {
+            if (camera != null) { try { camera.stopVideo(); } catch (Exception ignored) { } camera = null; }
+            if (server != null) { try { server.close(); } catch (Exception ignored) { } server = null; }
+            if (connection != null) { try { connection.close(); } catch (Exception ignored) { } connection = null; }
+            if (relay != null) { try { relay.close(); } catch (Exception ignored) { } relay = null; }
+        }
+    }
+
+    private static String identifier(String value) {
+        if (value == null || !value.matches("[0-9]{1,30}")) throw new Failure(7, "invalid_request");
+        return new java.math.BigInteger(value).toString();
+    }
+    private static int number(String value, int min, int max) {
+        try { int parsed = Integer.parseInt(value); if (parsed >= min && parsed <= max) return parsed; }
+        catch (NumberFormatException ignored) { }
+        throw new Failure(7, "invalid_request");
+    }
+    private static String label(String value) {
+        if (value == null) return "";
+        String cleaned = value.replaceAll("[\\p{Cc}]", " ");
+        return cleaned.length() > 160 ? cleaned.substring(0, 160) : cleaned;
+    }
+    private static String safeReason(String value) {
+        return Set.of("session_expired", "invalid_home_selection", "invalid_home_response", "missing_home_owner",
+                "invalid_device_response", "device_pagination_incomplete", "home_request_failed", "home_request_rejected")
+                .contains(value) ? value : "discovery_failed";
+    }
+    static void progress(Stage stage) {
+        emit(Map.of("success", true, "event", "progress", "stage", stage.value));
+    }
+    static void progress(Stage stage, int vendor) {
+        emit(Map.of("success", true, "event", "progress", "stage", stage.value, "vendor", vendor));
+    }
+    private static synchronized void emit(Object value) {
+        try { OUTPUT.println(JSON.writeValueAsString(value)); OUTPUT.flush(); }
+        catch (Exception ignored) { }
+    }
+}

package/bin/diagnose.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { createRpcClient } from '../lib/rpc.mjs';
+import { safeDiagnostics } from '../lib/diagnostics.mjs';
+
+const args = process.argv.slice(2);
+if (args.length && (args.length !== 2 || args[0] !== '--storage' || !args[1] || args[1].startsWith('--'))) {
+  console.error('用法: mijia-camera-diagnose --storage <Homebridge 数据目录>');
+  process.exitCode = 2;
+} else {
+  const storage = resolve(args[1] || process.env.HOMEBRIDGE_STORAGE_PATH || process.env.UIX_STORAGE_PATH || join(homedir(), '.homebridge'));
+  try {
+    const metadata = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+    const state = await createRpcClient(join(storage, 'mijia-remote-camera')).request('status', {});
+    console.log(JSON.stringify({ pluginVersion: metadata.version, ...safeDiagnostics(state) }, null, 2));
+  } catch {
+    console.error('无法读取运行状态。请确认 Homebridge 已启动，且 --storage 指向其实际数据目录。');
+    process.exitCode = 1;
+  }
+}

package/bin/setup.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { importRuntimeAssets } from '../lib/runtime-assets.mjs';
+
+const usage = '用法: mijia-camera-setup --from <已有的本地 .tgz 或 assets 目录> --storage <Homebridge 数据目录>\n例如: mijia-camera-setup --from /homebridge/homebridge-mijia-remote-camera-0.1.0.tgz --storage /homebridge';
+const values = {};
+let valid = true;
+for (let index = 2; index < process.argv.length; index++) {
+  const key = process.argv[index];
+  if (!['--from', '--storage'].includes(key) || !process.argv[index + 1] || process.argv[index + 1].startsWith('--') || values[key]) { valid = false; break; }
+  values[key] = process.argv[++index];
+}
+if (!valid || !values['--from']) {
+  console.error(usage);
+  process.exitCode = 2;
+} else {
+  try {
+    await importRuntimeAssets({ source: resolve(values['--from']),
+      homebridgeStoragePath: resolve(values['--storage'] || process.env.UIX_STORAGE_PATH || process.env.HOMEBRIDGE_STORAGE_PATH || `${homedir()}/.homebridge`) });
+    console.log('运行组件已从本地导入并完成校验。请重启 Homebridge，然后打开插件设置登录米家。');
+  } catch (error) {
+    const messages = { runtime_in_use: 'Homebridge 正在使用此插件。请先停用插件并重启 Homebridge，再重新导入。',
+      runtime_components_missing: '本地安装包缺少运行组件。', runtime_components_invalid: '组件校验失败，请使用此前提供的完整安装包。',
+      storage_failed: '无法写入 Homebridge 数据目录，请检查目录和运行用户。' };
+    console.error(messages[error.reason] || '导入失败，请检查本地安装包路径和 Homebridge 数据目录。');
+    process.exitCode = 1;
+  }
+}

package/config.schema.json

@@ -0,0 +1,74 @@
+{
+  "pluginAlias": "MijiaRemoteCamera",
+  "pluginType": "platform",
+  "singular": true,
+  "customUi": true,
+  "customUiPath": "./homebridge-ui",
+  "headerDisplay": "首次先从已有本地运行包导入组件，再登录小米账号并选择家庭和摄像头。",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "type": "string",
+        "title": "插件名称",
+        "default": "米家远程摄像头"
+      },
+      "platform": {
+        "type": "string",
+        "default": "MijiaRemoteCamera"
+      },
+      "region": {
+        "type": "string",
+        "title": "米家地区",
+        "default": "cn",
+        "enum": [
+          "cn",
+          "sg",
+          "de",
+          "us",
+          "ru",
+          "i2"
+        ]
+      },
+      "cameraName": {
+        "type": "string",
+        "title": "摄像头显示名称",
+        "default": "米家 3 Pro",
+        "maxLength": 64
+      },
+      "quality": {
+        "type": "integer",
+        "title": "米家画质",
+        "default": 1,
+        "minimum": 0,
+        "maximum": 3
+      },
+      "maxWidth": {
+        "type": "integer",
+        "default": 640,
+        "minimum": 160,
+        "maximum": 1280,
+        "multipleOf": 2
+      },
+      "maxHeight": {
+        "type": "integer",
+        "default": 360,
+        "minimum": 120,
+        "maximum": 720,
+        "multipleOf": 2
+      },
+      "maxFPS": {
+        "type": "integer",
+        "default": 12,
+        "minimum": 1,
+        "maximum": 25
+      },
+      "maxBitrate": {
+        "type": "integer",
+        "default": 700,
+        "minimum": 100,
+        "maximum": 2000
+      }
+    }
+  }
+}