homebridge-aiseg-awning-window-command 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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

@@ -0,0 +1,62 @@
+# homebridge-aiseg-awning-window-command
+
+Homebridge plugin for AiSEG2 awning windows
+
+## Overview
+
+This is a command-based Homebridge platform plugin for AiSEG-controlled devices.
+
+The plugin calls external commands for actions and optional status polling.
+It is designed for environments where a separate script can already operate the target AiSEG device.
+
+## Requirements
+
+- Homebridge 2.x
+- Node.js 22 or later
+- Working command or script for device operation
+- Optional status command for state polling
+
+## Installation
+
+```bash
+npm install -g homebridge-aiseg-awning-window-command
+```
+
+## Configuration
+
+Use the Homebridge UI to configure this plugin.
+
+Typical settings include:
+
+- display name
+- command path
+- open / close / stop / position commands where supported
+- status command
+- polling interval
+- movement guard / transition timing where supported
+
+## Notes
+
+This plugin does not include AiSEG login or operation scripts.
+Prepare and test the command scripts before configuring Homebridge.
+
+A command should be tested manually first, for example:
+
+```bash
+python3 /path/to/script.py target status
+python3 /path/to/script.py target open
+python3 /path/to/script.py target close
+```
+
+## Troubleshooting
+
+If the accessory does not respond:
+
+1. Run the configured command manually.
+2. Confirm the command path is correct inside the Homebridge environment.
+3. Confirm the Homebridge container has permission to execute the command.
+4. Check Homebridge logs for command timeout or stderr output.
+
+## Disclaimer
+
+This project is not affiliated with Apple, Homebridge, Panasonic, or AiSEG.

package/config.schema.json

@@ -0,0 +1,121 @@
+{
+  "pluginAlias": "AiSegAwningWindowCommand",
+  "pluginType": "platform",
+  "singular": true,
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "title": "名前",
+        "type": "string",
+        "default": "AiSEG Awning Windows",
+        "description": "Homebridge上で表示する名前を入力します。"
+      },
+      "host": {
+        "title": "AiSEG IPアドレス",
+        "description": "AiSEG本体のIPアドレスまたはホスト名を入力します。公開版では既定値を設定していません。",
+        "type": "string"
+      },
+      "deviceId": {
+        "title": "デバイスID",
+        "description": "通常は 3261です。必要な場合のみ変更します。",
+        "type": "string",
+        "default": "3261"
+      },
+      "eoj": {
+        "title": "EOJ（機器種別）",
+        "description": "AiSEG2のEOJです。通常は 0x026501 です。",
+        "type": "string",
+        "default": "0x026501"
+      },
+      "password": {
+        "title": "パスワード",
+        "description": "AiSEGのパスワードを入力します。公開版では既定値を設定していません。",
+        "type": "string",
+        "format": "password"
+      },
+      "pollIntervalSeconds": {
+        "title": "状態確認間隔",
+        "description": "状態を確認する間隔を秒単位で指定します。短くしすぎると機器やネットワークの負荷が増える場合があります。",
+        "type": "integer",
+        "default": 5,
+        "minimum": 1
+      },
+      "motionGuardSeconds": {
+        "title": "動作中ガード時間 秒",
+        "description": "開閉操作中に古い状態通知を無視するためのガード時間です。",
+        "type": "integer",
+        "default": 5,
+        "minimum": 0
+      },
+      "openAcceptDelaySeconds": {
+        "title": "開操作",
+        "description": "開操作に関する設定です。",
+        "type": "integer",
+        "default": 45,
+        "minimum": 0
+      },
+      "tiltMotionGuardSeconds": {
+        "title": "角度操作ガード時間 秒",
+        "description": "角度操作中に古い状態通知を無視するための最大ガード時間です。",
+        "type": "integer",
+        "default": 65,
+        "minimum": 0
+      },
+      "tiltVentAcceptDelaySeconds": {
+        "title": "半開状態受け入れ待機時間 秒",
+        "description": "半開・換気状態を角度操作完了として受け入れるまでの最小待機時間です。",
+        "type": "integer",
+        "default": 12,
+        "minimum": 0
+      },
+      "commandTimeoutSeconds": {
+        "title": "タイムアウト",
+        "description": "コマンドや通信のタイムアウト時間を秒単位で指定します。",
+        "type": "integer",
+        "minimum": 1
+      },
+      "stopSwitchAutoOffMs": {
+        "title": "停止操作",
+        "description": "停止操作に関する設定です。",
+        "type": "integer",
+        "default": 1000,
+        "minimum": 100
+      },
+      "windows": {
+        "title": "窓",
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "title": "名前",
+              "type": "string",
+              "description": "Homebridge上で表示する名前を入力します。"
+            },
+            "aisegId": {
+              "title": "Id",
+              "type": "string",
+              "description": "このオーニング窓のAiSEG2固有IDを入力します。HomeKit用の一意IDはこの値から自動生成されます。"
+            },
+            "showStopSwitch": {
+              "title": "停止操作",
+              "type": "boolean",
+              "default": true,
+              "description": "停止操作に関する設定です。"
+            },
+            "stopSwitchName": {
+              "title": "停止操作",
+              "type": "string",
+              "description": "停止操作に関する設定です。"
+            }
+          },
+          "required": [
+            "name",
+            "aisegId"
+          ]
+        }
+      }
+    }
+  }
+}

package/index.js

@@ -0,0 +1,583 @@
+"use strict";
+
+const { exec } = require("child_process");
+
+const PLUGIN_NAME = "homebridge-aiseg-awning-window-command";
+const PLATFORM_NAME = "AiSegAwningWindowCommand";
+
+module.exports = (api) => {
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, AiSegAwningWindowPlatform);
+};
+
+class AiSegAwningWindowPlatform {
+  constructor(log, config, api) {
+    this.log = log;
+    this.config = config || {};
+    this.api = api;
+    this.Service = api.hap.Service;
+    this.Characteristic = api.hap.Characteristic;
+    this.cachedAccessories = [];
+
+    this.api.on("didFinishLaunching", () => {
+      this.discoverDevices();
+    });
+  }
+
+  configureAccessory(accessory) {
+    this.cachedAccessories.push(accessory);
+  }
+
+  discoverDevices() {
+    const windows = Array.isArray(this.config.windows) ? this.config.windows : [];
+    const activeUUIDs = new Set();
+
+    for (const cfg of windows) {
+      const aisegId = getWindowAisegId(cfg);
+      const name = cfg.name || aisegId || "AiSEG Window";
+
+      if (!aisegId) {
+        this.log.warn(`[${name}] skipped because Id is missing`);
+        continue;
+      }
+
+      const windowUUID = this.api.hap.uuid.generate(`${PLUGIN_NAME}:window:${aisegId}`);
+      activeUUIDs.add(windowUUID);
+
+      let windowAccessory = this.cachedAccessories.find((a) => a.UUID === windowUUID);
+      const isNewWindow = !windowAccessory;
+
+      if (!windowAccessory) {
+        windowAccessory = new this.api.platformAccessory(name, windowUUID);
+      }
+
+      windowAccessory.context.plugin = PLUGIN_NAME;
+      windowAccessory.context.kind = "window";
+      windowAccessory.context.aisegId = aisegId;
+
+      new AwningWindow(this, windowAccessory, cfg);
+
+      if (isNewWindow) {
+        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [windowAccessory]);
+      }
+
+      if (cfg.showStopSwitch !== false) {
+        const stopName = cfg.stopSwitchName || `${name} 停止`;
+        const stopUUID = this.api.hap.uuid.generate(`${PLUGIN_NAME}:stop:${aisegId}`);
+        activeUUIDs.add(stopUUID);
+
+        let stopAccessory = this.cachedAccessories.find((a) => a.UUID === stopUUID);
+        const isNewStop = !stopAccessory;
+
+        if (!stopAccessory) {
+          stopAccessory = new this.api.platformAccessory(stopName, stopUUID);
+        }
+
+        stopAccessory.context.plugin = PLUGIN_NAME;
+        stopAccessory.context.kind = "stop";
+        stopAccessory.context.aisegId = aisegId;
+
+        new StopSwitch(this, stopAccessory, cfg, stopName);
+
+        if (isNewStop) {
+          this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [stopAccessory]);
+        }
+      }
+    }
+
+    const stale = this.cachedAccessories.filter((a) => {
+      return a.context && a.context.plugin === PLUGIN_NAME && !activeUUIDs.has(a.UUID);
+    });
+
+    if (stale.length > 0) {
+      this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, stale);
+    }
+
+    this.log.info(`Configured ${windows.length} AiSEG awning window(s)`);
+  }
+}
+
+class AwningWindow {
+  constructor(platform, accessory, config) {
+    this.platform = platform;
+    this.log = platform.log;
+    this.Service = platform.Service;
+    this.Characteristic = platform.Characteristic;
+
+    this.accessory = accessory;
+    this.config = config;
+    this.name = config.name || getWindowAisegId(config) || "AiSEG Window";
+
+    this.pollIntervalSeconds = numberOr(config.pollIntervalSeconds, platform.config.pollIntervalSeconds, 5);
+    this.commandTimeoutSeconds = numberOr(config.commandTimeoutSeconds, platform.config.commandTimeoutSeconds, 20);
+    this.motionGuardSeconds = numberOr(config.motionGuardSeconds, platform.config.motionGuardSeconds, 5);
+    this.openAcceptDelaySeconds = numberOr(config.openAcceptDelaySeconds, platform.config.openAcceptDelaySeconds, 45);
+    this.tiltMotionGuardSeconds = numberOr(config.tiltMotionGuardSeconds, platform.config.tiltMotionGuardSeconds, 65);
+    this.tiltVentAcceptDelaySeconds = numberOr(config.tiltVentAcceptDelaySeconds, platform.config.tiltVentAcceptDelaySeconds, 12);
+
+    this.currentPosition = 0;
+    this.targetPosition = 0;
+    this.currentTilt = 0;
+    this.targetTilt = 0;
+    this.lastHalfTilt = 30;
+    this.positionState = this.Characteristic.PositionState.STOPPED;
+
+    this.expectedState = null;
+    this.motionStartedAt = 0;
+    this.motionUntil = 0;
+    this.lastUnknownStatus = "";
+
+    this.setup();
+
+    this.pollStatus();
+
+    if (this.pollIntervalSeconds > 0) {
+      setInterval(() => this.pollStatus(), this.pollIntervalSeconds * 1000);
+    }
+  }
+
+  setup() {
+    this.accessory.getService(this.Service.AccessoryInformation)
+      .setCharacteristic(this.Characteristic.Manufacturer, "AiSEG2")
+      .setCharacteristic(this.Characteristic.Model, "Awning Window Command")
+      .setCharacteristic(this.Characteristic.SerialNumber, getWindowAisegId(this.config) || this.name);
+
+    this.service =
+      this.accessory.getService(this.Service.WindowCovering) ||
+      this.accessory.addService(this.Service.WindowCovering, this.name);
+
+    this.service.setCharacteristic(this.Characteristic.Name, this.name);
+
+    this.service.getCharacteristic(this.Characteristic.CurrentPosition)
+      .setProps({ minValue: 0, maxValue: 100, minStep: 1 })
+      .onGet(() => this.currentPosition);
+
+    this.service.getCharacteristic(this.Characteristic.TargetPosition)
+      .setProps({ minValue: 0, maxValue: 100, minStep: 1 })
+      .onGet(() => this.targetPosition)
+      .onSet(async (value) => this.setTargetPosition(value));
+
+    this.service.getCharacteristic(this.Characteristic.PositionState)
+      .onGet(() => this.positionState);
+
+    this.service.getCharacteristic(this.Characteristic.CurrentHorizontalTiltAngle)
+      .setProps({ minValue: 0, maxValue: 60, minStep: 15 })
+      .onGet(() => this.currentTilt);
+
+    this.service.getCharacteristic(this.Characteristic.TargetHorizontalTiltAngle)
+      .setProps({ minValue: 0, maxValue: 60, minStep: 15 })
+      .onGet(() => this.targetTilt)
+      .onSet(async (value) => this.setTargetTilt(value));
+
+    this.updateHomeKit();
+  }
+
+  async setTargetPosition(value) {
+    const raw = clamp(Number(value), 0, 100);
+    const normalized = raw <= 50 ? 0 : 100;
+
+    this.log.info(`[${this.name}] TargetPosition ${raw} -> ${normalized}`);
+
+    this.targetPosition = normalized;
+    this.service.getCharacteristic(this.Characteristic.TargetPosition).updateValue(normalized);
+
+    if (normalized === 0) {
+      this.targetTilt = 0;
+      this.service.getCharacteristic(this.Characteristic.TargetHorizontalTiltAngle).updateValue(0);
+      this.startMotion("closed", this.motionGuardSeconds, 0);
+      await this.runAction("close", "close");
+    } else {
+      this.targetTilt = 60;
+      this.service.getCharacteristic(this.Characteristic.TargetHorizontalTiltAngle).updateValue(60);
+      this.startMotion("open", Math.max(this.motionGuardSeconds, this.openAcceptDelaySeconds), 60);
+      await this.runAction("open", "open");
+    }
+  }
+
+  async setTargetTilt(value) {
+    const raw = clamp(Number(value), 0, 60);
+    const snapped = snapTilt(raw);
+
+    this.log.info(`[${this.name}] TargetHorizontalTiltAngle ${raw} -> ${snapped}`);
+
+    this.targetTilt = snapped;
+    this.service.getCharacteristic(this.Characteristic.TargetHorizontalTiltAngle).updateValue(snapped);
+
+    if (snapped === 0) {
+      this.targetPosition = 0;
+      this.service.getCharacteristic(this.Characteristic.TargetPosition).updateValue(0);
+      this.startMotion("closed", this.motionGuardSeconds, 0);
+      await this.runAction("close", "tilt 0 / close");
+      return;
+    }
+
+    if (snapped === 60) {
+      this.targetPosition = 100;
+      this.service.getCharacteristic(this.Characteristic.TargetPosition).updateValue(100);
+      this.startMotion("open", Math.max(this.motionGuardSeconds, this.openAcceptDelaySeconds), 60);
+      await this.runAction("open", "tilt 60 / open");
+      return;
+    }
+
+    this.lastHalfTilt = snapped;
+    this.targetPosition = 50;
+    this.service.getCharacteristic(this.Characteristic.TargetPosition).updateValue(50);
+
+    if (snapped === 15) {
+      this.startMotion("angle1", this.tiltMotionGuardSeconds, 15);
+      await this.runAction("angle1", "angle1");
+    } else if (snapped === 30) {
+      this.startMotion("angle2", this.tiltMotionGuardSeconds, 30);
+      await this.runAction("angle2", "angle2");
+    } else {
+      this.startMotion("angle3", this.tiltMotionGuardSeconds, 45);
+      await this.runAction("angle3", "angle3");
+    }
+  }
+
+  startMotion(expectedState, guardSeconds, expectedTilt) {
+    this.expectedState = expectedState;
+
+    const now = Date.now();
+    this.motionStartedAt = now;
+    const seconds = numberOr(guardSeconds, this.motionGuardSeconds, 5);
+    this.motionUntil = now + seconds * 1000;
+
+    const expectedPosition =
+      expectedState === "closed" ? 0 :
+      expectedState === "open" ? 100 :
+      50;
+
+    const numericExpectedTilt = Number(expectedTilt);
+    const isTiltMotion =
+      expectedState === "angle1" ||
+      expectedState === "angle2" ||
+      expectedState === "angle3";
+
+    if (expectedPosition > this.currentPosition) {
+      this.positionState = this.Characteristic.PositionState.INCREASING;
+    } else if (expectedPosition < this.currentPosition) {
+      this.positionState = this.Characteristic.PositionState.DECREASING;
+    } else if (Number.isFinite(numericExpectedTilt) && numericExpectedTilt > this.currentTilt) {
+      this.positionState = this.Characteristic.PositionState.INCREASING;
+    } else if (Number.isFinite(numericExpectedTilt) && numericExpectedTilt < this.currentTilt) {
+      this.positionState = this.Characteristic.PositionState.DECREASING;
+    } else {
+      this.positionState = this.Characteristic.PositionState.STOPPED;
+    }
+
+    this.targetPosition = expectedPosition;
+
+    if (isTiltMotion && this.currentPosition === expectedPosition) {
+      if (this.positionState === this.Characteristic.PositionState.INCREASING) {
+        this.currentPosition = 49;
+      } else if (this.positionState === this.Characteristic.PositionState.DECREASING) {
+        this.currentPosition = 51;
+      }
+    }
+
+    this.service.getCharacteristic(this.Characteristic.CurrentPosition).updateValue(this.currentPosition);
+    this.service.getCharacteristic(this.Characteristic.TargetPosition).updateValue(this.targetPosition);
+    this.service.getCharacteristic(this.Characteristic.PositionState).updateValue(this.positionState);
+  }
+
+  async pollStatus() {
+    try {
+      const stdout = await this.runAction("status", "status", true);
+      const parsed = this.parseStatus(stdout);
+
+      if (!parsed) {
+        const text = String(stdout || "").trim();
+        if (text && text !== this.lastUnknownStatus) {
+          this.lastUnknownStatus = text;
+          this.log.warn(`[${this.name}] Unknown status: ${text}`);
+        }
+        return;
+      }
+
+      this.lastUnknownStatus = "";
+      this.applyStatus(parsed);
+    } catch (err) {
+      this.log.warn(`[${this.name}] status failed: ${err.message}`);
+    }
+  }
+
+  parseStatus(stdout) {
+    const text = String(stdout || "").trim().toLowerCase();
+
+    if (!text || text === "unknown") {
+      return null;
+    }
+
+    if (text.includes("angle1")) {
+      return { state: "angle1", pos: 50, tilt: 15, target: 50 };
+    }
+
+    if (text.includes("angle2")) {
+      return { state: "angle2", pos: 50, tilt: 30, target: 50 };
+    }
+
+    if (text.includes("angle3")) {
+      return { state: "angle3", pos: 50, tilt: 45, target: 50 };
+    }
+
+    if (text.includes("closed") || text === "close") {
+      return { state: "closed", pos: 0, tilt: 0, target: 0 };
+    }
+
+    if (text.includes("open")) {
+      return { state: "open", pos: 100, tilt: 60, target: 100 };
+    }
+
+    if (text.includes("vent") || text.includes("half") || text.includes("tilt") || text.includes("angle")) {
+      return { state: "vent", pos: 50, tilt: this.lastHalfTilt || 30, target: 50 };
+    }
+
+    return null;
+  }
+
+  applyStatus(parsed) {
+    if (Date.now() < this.motionUntil && this.expectedState) {
+      if (!this.acceptStatusDuringMotion(parsed.state, this.expectedState)) {
+        return;
+      }
+    }
+
+    this.expectedState = null;
+    this.motionUntil = 0;
+
+    this.currentPosition = parsed.pos;
+    this.targetPosition = parsed.target;
+    this.currentTilt = parsed.tilt;
+    this.targetTilt = parsed.tilt;
+    this.positionState = this.Characteristic.PositionState.STOPPED;
+
+    if (parsed.pos === 50 && parsed.tilt > 0) {
+      this.lastHalfTilt = parsed.tilt;
+    }
+
+    this.updateHomeKit();
+  }
+
+  acceptStatusDuringMotion(actual, expected) {
+    if (expected === "closed") {
+      return actual === "closed";
+    }
+
+    if (expected === "open") {
+      const elapsedSeconds = (Date.now() - (this.motionStartedAt || 0)) / 1000;
+      return actual === "open" && elapsedSeconds >= this.openAcceptDelaySeconds;
+    }
+
+    const elapsedSeconds = (Date.now() - (this.motionStartedAt || 0)) / 1000;
+    const acceptVent =
+      actual === "vent" &&
+      elapsedSeconds >= this.tiltVentAcceptDelaySeconds;
+
+    if (expected === "angle1") {
+      return actual === "angle1" || acceptVent;
+    }
+
+    if (expected === "angle2") {
+      return actual === "angle2" || acceptVent;
+    }
+
+    if (expected === "angle3") {
+      return actual === "angle3" || acceptVent;
+    }
+
+    return true;
+  }
+
+  updateHomeKit() {
+    this.service.getCharacteristic(this.Characteristic.CurrentPosition).updateValue(this.currentPosition);
+    this.service.getCharacteristic(this.Characteristic.TargetPosition).updateValue(this.targetPosition);
+    this.service.getCharacteristic(this.Characteristic.PositionState).updateValue(this.positionState);
+    this.service.getCharacteristic(this.Characteristic.CurrentHorizontalTiltAngle).updateValue(this.currentTilt);
+    this.service.getCharacteristic(this.Characteristic.TargetHorizontalTiltAngle).updateValue(this.targetTilt);
+  }
+
+  async runAction(action, label, returnStdout) {
+    const command = buildAisegWindowCommand(getWindowScriptKey(this.config), action);
+    const env = buildAisegEnv(this.platform.config, this.config);
+
+    if (!returnStdout) {
+      this.log.info(`[${this.name}] run ${label}: ${command}`);
+    }
+
+    const stdout = await runCommand(command, this.commandTimeoutSeconds, env);
+    return stdout;
+  }
+}
+
+class StopSwitch {
+  constructor(platform, accessory, config, name) {
+    this.platform = platform;
+    this.log = platform.log;
+    this.Service = platform.Service;
+    this.Characteristic = platform.Characteristic;
+    this.accessory = accessory;
+    this.config = config;
+    this.name = name;
+
+    this.commandTimeoutSeconds = numberOr(config.commandTimeoutSeconds, platform.config.commandTimeoutSeconds, 20);
+    this.autoOffMs = numberOr(config.stopSwitchAutoOffMs, platform.config.stopSwitchAutoOffMs, 1000);
+
+    this.setup();
+  }
+
+  setup() {
+    this.accessory.getService(this.Service.AccessoryInformation)
+      .setCharacteristic(this.Characteristic.Manufacturer, "AiSEG2")
+      .setCharacteristic(this.Characteristic.Model, "Awning Window Stop Switch")
+      .setCharacteristic(this.Characteristic.SerialNumber, `${getWindowAisegId(this.config) || this.name}-stop`);
+
+    this.service =
+      this.accessory.getService(this.Service.Switch) ||
+      this.accessory.addService(this.Service.Switch, this.name);
+
+    this.service.setCharacteristic(this.Characteristic.Name, this.name);
+
+    this.service.getCharacteristic(this.Characteristic.On)
+      .onGet(() => false)
+      .onSet(async (value) => {
+        if (value === true) {
+          await this.stop();
+        }
+      });
+
+    this.service.getCharacteristic(this.Characteristic.On).updateValue(false);
+  }
+
+  async stop() {
+    const command = buildAisegWindowCommand(getWindowScriptKey(this.config), "stop");
+
+    try {
+      this.log.info(`[${this.name}] run stop: ${command}`);
+      await runCommand(command, this.commandTimeoutSeconds, buildAisegEnv(this.platform.config, this.config));
+    } catch (err) {
+      this.log.error(`[${this.name}] stop failed: ${err.message}`);
+    } finally {
+      setTimeout(() => {
+        this.service.getCharacteristic(this.Characteristic.On).updateValue(false);
+      }, this.autoOffMs);
+    }
+  }
+}
+
+function getWindowAisegId(config) {
+  return String((config && (config.aisegId || config.id)) || "").trim();
+}
+
+function getWindowScriptKey(config) {
+  if (!config) {
+    return "";
+  }
+
+  const explicit = String(config.scriptKey || "").trim();
+  if (explicit) {
+    return explicit;
+  }
+
+  const name = String(config.name || "").toLowerCase();
+
+  if (name.includes("東") || name.includes("east")) {
+    return "east";
+  }
+
+  if (name.includes("西") || name.includes("west")) {
+    return "west";
+  }
+
+  return getWindowAisegId(config);
+}
+
+function buildAisegWindowCommand(scriptKey, action) {
+  return `python3 /homebridge/scripts/aiseg_window.py ${shellQuote(scriptKey)} ${shellQuote(action)}`;
+}
+
+function buildAisegEnv(platformConfig, windowConfig) {
+  const env = Object.assign({}, process.env);
+
+  env.AISEG_USER = "aiseg";
+
+  const host = platformConfig && platformConfig.host;
+  if (host !== undefined && host !== null && String(host) !== "") {
+    env.AISEG_HOST = String(host);
+    env.AISEG_IP = String(host);
+  }
+
+  const password = platformConfig && platformConfig.password;
+  if (password !== undefined && password !== null && String(password) !== "") {
+    env.AISEG_PASSWORD = String(password);
+  }
+
+  env.AISEG_DEVICE_ID = String((platformConfig && platformConfig.deviceId) || "3261");
+  env.AISEG_EOJ = String((platformConfig && platformConfig.eoj) || "0x026501");
+
+  const aisegId = getWindowAisegId(windowConfig);
+  if (aisegId) {
+    env.AISEG_ID = aisegId;
+  }
+
+  return env;
+}
+
+function runCommand(command, timeoutSeconds, env) {
+  return new Promise((resolve, reject) => {
+    exec(command, {
+      timeout: timeoutSeconds * 1000,
+      maxBuffer: 1024 * 1024,
+      env: env || process.env
+    }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(`${err.message}${stderr ? " / " + stderr.trim() : ""}`));
+        return;
+      }
+
+      resolve(stdout);
+    });
+  });
+}
+
+function snapTilt(value) {
+  if (value <= 7) {
+    return 0;
+  }
+
+  if (value <= 22) {
+    return 15;
+  }
+
+  if (value <= 37) {
+    return 30;
+  }
+
+  if (value <= 52) {
+    return 45;
+  }
+
+  return 60;
+}
+
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+
+  return Math.max(min, Math.min(max, value));
+}
+
+function numberOr(...values) {
+  for (const value of values) {
+    const num = Number(value);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+
+  return 0;
+}
+
+function shellQuote(value) {
+  return "'" + String(value).replace(/'/g, "'\\''") + "'";
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "homebridge-aiseg-awning-window-command",
+  "version": "0.2.2",
+  "description": "Homebridge plugin for AiSEG2 awning windows",
+  "main": "index.js",
+  "keywords": [
+    "homebridge-plugin",
+    "aiseg",
+    "awning",
+    "window",
+    "homekit",
+    "homebridge",
+    "command"
+  ],
+  "engines": {
+    "homebridge": ">=1.8.0",
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "config.schema.json",
+    "README.md",
+    "LICENSE"
+  ]
+}