daikin-airbase 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lake
+
+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,53 @@
+# TypeScript Daikin Airbase Library
+This library is used to communicate with Daikin Airbase devices.
+
+## Supported Devices
+
+- Wireless LAN connecting Adaptor for Ducted Split Systems
+  - 🇦🇺 `BRP15B61`
+
+> [!TIP]
+> Does this library support your system? Please add your model number and country flag here!
+
+## Supported Features
+The following features have been tested
+- Get/Set Temperature
+- Get/Set Fan Speed
+- Get/Set Power
+- Get/Set Mode
+- Get/Set Zones On/Off
+
+## Not Yet Implemented
+The following features are not yet implemented. 
+A lot of these are not supported by my particular device. Some i just didn't need to implement.
+
+**Pull Requests are welcome!**
+- Get/Set Humidity
+- Get/Set Zones Temperature
+- Get/Set Zones Humidity
+- Timers
+
+## Usage
+There are a collection of examples in the `examples` folder. As a very basic example:
+```typescript
+import {DaikinClient} from "../src";
+const client = new DaikinClient({ host: EXAMPLE_HOST });
+await client.setTargetTemprature(24);
+```
+
+## Security and Warranty
+This library is not affiliated with Daikin. I take no responsibility for any damages caused by this library. Use at your own risk.
+
+Issues within the endpoints provided by Daikin are not covered by this library. Any security concerns should be disclosed to Daikin.
+
+> [!WARNING]
+> Daikin exposes your wifi password in plain text with the get_wifi_setting. 
+> Make sure you don't connect your system to the internet!
+
+## Development
+All contributions are welcome! Please make sure everything is tested on your own device before submitting a pull request.
+
+There is no real strict style guide, but please try to follow the existing code.
+- Raw endpoints should be in the `src/api/` and the client should wrap and map them to nicer objects in `src/`
+- A list of all available endpoints can be found in [ENDPOINTS.md](https://github.com/Lachee/daikin-airbase/blob/main/ENDPOINTS.md). 
+  - These were extracted from the [App's](https://play.google.com/store/apps/details?id=au.com.daikin.airbase&hl=en_AU) strings.

package/dist/index.cjs

@@ -0,0 +1,353 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  API: () => API,
+  DaikinClient: () => DaikinClient,
+  basic_info: () => basic_info,
+  discover: () => discover,
+  get_zone_settings: () => get_zone_settings
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ParamParser.ts
+function parse(str) {
+  const result = {};
+  const parts = str.split(",");
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (key === void 0) continue;
+    const maybeNumber = Number(value);
+    if (Number.isNaN(maybeNumber)) {
+      result[key] = decodeURIComponent(`${value}`);
+    } else {
+      result[key] = maybeNumber;
+    }
+  }
+  return result;
+}
+
+// src/api/API.ts
+var import_node_http = __toESM(require("http"), 1);
+var API = class {
+  host;
+  constructor(host) {
+    this.host = host;
+  }
+  async request(endpoint, parameters) {
+    const body = await new Promise((resolve, reject) => {
+      const url = new URL(`/skyfi${endpoint}`, `http://${this.host}/`);
+      const queries = [];
+      if (parameters) {
+        for (const key in parameters) {
+          const value = parameters[key];
+          if (value === void 0) continue;
+          const encoded = encodeURIComponent(`${value || ""}`);
+          queries.push(`${key}=${encoded}`);
+        }
+      }
+      const search = queries.length > 0 ? `?${queries.join("&")}` : "";
+      const req = import_node_http.default.request(
+        {
+          host: url.hostname,
+          port: url.port,
+          path: url.pathname + search,
+          // important
+          method: "GET",
+          headers: {
+            Accept: "*/*",
+            Connection: "close"
+          }
+        },
+        (res) => {
+          let data = "";
+          res.setEncoding("utf8");
+          res.on("data", (c) => data += c);
+          res.on("end", () => resolve(data));
+        }
+      );
+      req.on("error", reject);
+      req.end();
+    });
+    return parse(body);
+  }
+};
+
+// src/api/Discover.ts
+var import_node_dgram = __toESM(require("dgram"), 1);
+var DISCOVERY_PORT = 30050;
+var DISCOVERY_ADDRESS = "255.255.255.255";
+function discover(timeoutMs = 3e3) {
+  return new Promise((resolve, reject) => {
+    const availableUnits = /* @__PURE__ */ new Map();
+    const socket = import_node_dgram.default.createSocket("udp4");
+    const payload = Buffer.from("DAIKIN_UDP/common/basic_info", "utf8");
+    const finish = () => {
+      socket.close();
+      resolve([...availableUnits.values()]);
+    };
+    socket.once("error", (err) => {
+      socket.close();
+      reject(err);
+    });
+    socket.on("message", (msg, rinfo) => {
+      const raw = msg.toString("utf8");
+      const info = parse(raw);
+      const key = `${info.mac || info.id || rinfo.address}`;
+      availableUnits.set(key, {
+        discoveredAddress: rinfo.address,
+        discoveredPort: rinfo.port,
+        ...info
+      });
+    });
+    socket.bind(0, "0.0.0.0", () => {
+      try {
+        socket.setBroadcast(true);
+        socket.send(payload, DISCOVERY_PORT, DISCOVERY_ADDRESS, (err) => {
+          if (err) {
+            socket.close();
+            reject(err);
+            return;
+          }
+          setTimeout(finish, timeoutMs);
+        });
+      } catch (err) {
+        socket.close();
+        reject(err);
+      }
+    });
+  });
+}
+
+// src/api/common/basic_info.ts
+var basic_info = (http2) => http2.request("/common/basic_info");
+
+// src/api/aircon/get_zone_setting.ts
+var get_zone_settings = (http2) => http2.request("/aircon/get_zone_setting");
+
+// src/api/aircon/set_zone_setting.ts
+var set_zone_setting = (http2, params) => http2.request("/aircon/set_zone_setting", params);
+
+// src/Zones.ts
+var Zones = class {
+  zones = [];
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** Refreshes the cached zone state */
+  async refresh() {
+    const response = await get_zone_settings(this.client.api);
+    const zoneNames = response.zone_name.split(";");
+    const zoneState = response.zone_onoff.split(";");
+    return this.zones = zoneNames.map((name, index) => ({
+      name,
+      state: zoneState[index] === "1"
+    }));
+  }
+  /**
+   * Gets the state of all cached zones.
+   */
+  getCachedZones() {
+    return [...this.zones];
+  }
+  /**
+   * Gets all zones' state
+   */
+  async getZones() {
+    return await this.refresh();
+  }
+  /**
+   * Gets the cached state of a zone
+   * @param name
+   */
+  getCachedZone(name) {
+    return this.zones.find((zone) => zone.name === name)?.state;
+  }
+  /**
+   * Gets the state of a Zone
+   * @param name
+   */
+  async getZone(name) {
+    const zones = await this.refresh();
+    return zones.find((zone) => zone.name === name)?.state;
+  }
+  /**
+   * Sets a Zone's state
+   * @param name
+   * @param state
+   */
+  async setZone(name, state) {
+    await this.setZones([{ name, state }]);
+  }
+  /**
+   * Sets multiple zones' state
+   * @param changes
+   */
+  async setZones(changes) {
+    await this.refresh();
+    for (const change of changes) {
+      const existingZone = this.zones.find((z) => z.name === change.name);
+      if (existingZone) {
+        existingZone.state = change.state;
+      }
+    }
+    const response = await set_zone_setting(this.client.api, {
+      zone_name: this.zones.map((zone) => zone.name).join(";"),
+      zone_onoff: this.zones.map((zone) => zone.state ? "1" : "0").join(";")
+    });
+    if (response.ret !== "OK")
+      throw new Error(`Failed to set zones: ${response.ret}`);
+  }
+};
+
+// src/api/aircon/get_control_info.ts
+var get_control_info = (http2) => http2.request("/aircon/get_control_info");
+
+// src/api/aircon/set_control_info.ts
+var set_control_info = (http2, params) => http2.request("/aircon/set_control_info", params);
+
+// src/DaikinClient.ts
+var DaikinClient = class {
+  options;
+  api;
+  zones;
+  cachedControlInfo;
+  constructor(options) {
+    this.options = options;
+    if ("host" in options) {
+      this.api = new API(options.host);
+    } else {
+      this.api = new API(options.device.discoveredAddress);
+    }
+    this.zones = new Zones(this);
+  }
+  async getControlInfo() {
+    const response = await get_control_info(this.api);
+    const responseValues = Object.entries(response);
+    return this.cachedControlInfo = {
+      mode: Number(response.mode),
+      fanSpeed: Number(response.f_rate),
+      fanAuto: response.f_auto != 0,
+      fanAirside: response.f_airside != 0,
+      targetTemperature: response.stemp,
+      sensorTemperatures: responseValues.filter(([k, v]) => k.startsWith("dt")).map(([k, v]) => +v),
+      power: response.pow != 0,
+      status: Number(response.operate),
+      swinging: response.f_dir != 0,
+      isFilterDirty: response.filter_sign_info != 0,
+      isCentrallyControlled: response.cent != 0,
+      remoteControlType: Number(response.remo)
+    };
+  }
+  getCachedControlInfo() {
+    return this.cachedControlInfo;
+  }
+  async getPowered() {
+    return (await this.getControlInfo()).power;
+  }
+  async setPowered(state) {
+    return await this.setControlInfo({ power: state });
+  }
+  async getMode() {
+    return (await this.getControlInfo()).mode;
+  }
+  async setMode(mode) {
+    return await this.setControlInfo({ mode });
+  }
+  async getFan() {
+    const info = await this.getControlInfo();
+    return {
+      speed: info.fanSpeed,
+      auto: info.fanAuto
+    };
+  }
+  async setFan(fan) {
+    return await this.setControlInfo({ fanSpeed: fan.speed, fanAuto: fan.auto });
+  }
+  async getTargetTemperature() {
+    return (await this.getControlInfo()).targetTemperature;
+  }
+  async setTargetTemperature(temperature) {
+    return await this.setControlInfo({ targetTemperature: temperature });
+  }
+  async getSensorTemperatures() {
+    return (await this.getControlInfo()).sensorTemperatures;
+  }
+  async getStatus() {
+    return (await this.getControlInfo()).status;
+  }
+  async setControlInfo(info) {
+    const latest = await this.getControlInfo();
+    const update = { ...latest, ...info };
+    const bool = (v) => v ? 1 : 0;
+    const response = await set_control_info(this.api, {
+      f_airside: bool(update.fanAirside),
+      f_auto: bool(update.fanAuto),
+      f_dir: bool(update.swinging),
+      f_rate: update.fanSpeed,
+      mode: update.mode,
+      pow: bool(update.power),
+      stemp: update.targetTemperature
+    });
+    if (response.ret !== "OK")
+      throw new Error(`Failed to update control info: ${response.ret}`);
+    this.cachedControlInfo = update;
+  }
+  async getBasicInfo() {
+    const response = await basic_info(this.api);
+    return {
+      type: response.type,
+      region: response.reg,
+      version: response.ver,
+      name: response.name,
+      method: response.method,
+      port: response.port,
+      id: response.id,
+      password: response.pw,
+      ssid: response.ssid,
+      led: response.led === 1,
+      adp_mode: response.adp_mode,
+      adp_kind: response.adp_kind
+    };
+  }
+  static async discover(timeoutMs = 3e3) {
+    return discover(timeoutMs);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API,
+  DaikinClient,
+  basic_info,
+  discover,
+  get_zone_settings
+});

package/dist/index.d.cts

@@ -0,0 +1,183 @@
+type Params = Record<string, number | string>;
+
+type DaikinResponse = {
+    ret: 'OK';
+};
+declare class API {
+    readonly host: string;
+    constructor(host: string);
+    request(endpoint: string, parameters?: Record<string, string | number | undefined | null>): Promise<Params>;
+}
+
+type BasicInfoResponse = DaikinResponse & {
+    type: 'aircon';
+    reg: 'string';
+    dst: number;
+    ver: 'string';
+    rev: 'string';
+    pow: number;
+    err: number;
+    location: number;
+    name: 'string';
+    icon: number;
+    method: 'polling';
+    port: number;
+    id: 'string';
+    pw: 'string';
+    lpw_flag: number;
+    adp_kind: number;
+    led: number;
+    en_setzone: number;
+    mac: string;
+    adp_mode: 'run';
+    ssid: 'string';
+    err_type: string;
+    err_code: number;
+    en_ch: number;
+    holiday: number;
+    en_hol: number;
+    sync_time: number;
+};
+declare const basic_info: (http: API) => Promise<BasicInfoResponse>;
+
+type DiscoveredDevice = BasicInfoResponse & {
+    discoveredAddress: string;
+    discoveredPort: number;
+};
+declare function discover(timeoutMs?: number): Promise<DiscoveredDevice[]>;
+
+type ZoneSettingResponse = DaikinResponse & {
+    zone_name: string;
+    zone_onoff: string;
+};
+declare const get_zone_settings: (http: API) => Promise<ZoneSettingResponse>;
+
+type ZoneState = {
+    name: string;
+    state: boolean;
+};
+declare class Zones {
+    private zones;
+    private readonly client;
+    constructor(client: DaikinClient);
+    /** Refreshes the cached zone state */
+    refresh(): Promise<ZoneState[]>;
+    /**
+     * Gets the state of all cached zones.
+     */
+    getCachedZones(): ZoneState[];
+    /**
+     * Gets all zones' state
+     */
+    getZones(): Promise<ZoneState[]>;
+    /**
+     * Gets the cached state of a zone
+     * @param name
+     */
+    getCachedZone(name: string): boolean | undefined;
+    /**
+     * Gets the state of a Zone
+     * @param name
+     */
+    getZone(name: string): Promise<boolean | undefined>;
+    /**
+     * Sets a Zone's state
+     * @param name
+     * @param state
+     */
+    setZone(name: string, state: boolean): Promise<void>;
+    /**
+     * Sets multiple zones' state
+     * @param changes
+     */
+    setZones(changes: ZoneState[]): Promise<void>;
+}
+
+type BasicInfo = {
+    type: 'aircon';
+    region: string;
+    version: string;
+    name: string;
+    method: 'polling';
+    port: number;
+    id: string;
+    password: string;
+    ssid: string;
+    led: boolean;
+    adp_mode: 'run';
+    adp_kind: number;
+};
+declare enum ControlMode {
+    Fan = 0,
+    Hot = 1,
+    Cool = 2,
+    Auto = 3,
+    Dry = 4
+}
+declare enum FanSpeed {
+    Low = 1,
+    Medium = 3,
+    High = 5
+}
+declare enum Status {
+    Stopped = 0,
+    Operating = 1,
+    Idle = 2
+}
+declare enum RemoteType {
+    None = 0,
+    Wired = 1,
+    Wireless = 2
+}
+type ControlInfo = {
+    mode: ControlMode;
+    fanSpeed: FanSpeed;
+    fanAuto: boolean;
+    fanAirside: boolean;
+    targetTemperature: number;
+    sensorTemperatures: number[];
+    power: boolean;
+    status: Status;
+    swinging: boolean;
+    isFilterDirty: boolean;
+    isCentrallyControlled: boolean;
+    remoteControlType: RemoteType;
+};
+
+type DeviceOption = {
+    device: DiscoveredDevice;
+};
+type HostOption = {
+    host: string;
+};
+type DaikinClientOptions = (DeviceOption | HostOption) & {
+    password?: string;
+};
+type Fan = {
+    speed: FanSpeed;
+    auto: boolean;
+};
+declare class DaikinClient {
+    private readonly options;
+    readonly api: API;
+    readonly zones: Zones;
+    private cachedControlInfo;
+    constructor(options: DaikinClientOptions);
+    getControlInfo(): Promise<ControlInfo>;
+    getCachedControlInfo(): ControlInfo | undefined;
+    getPowered(): Promise<boolean>;
+    setPowered(state: boolean): Promise<void>;
+    getMode(): Promise<ControlMode>;
+    setMode(mode: ControlMode): Promise<void>;
+    getFan(): Promise<Fan>;
+    setFan(fan: Fan): Promise<void>;
+    getTargetTemperature(): Promise<number>;
+    setTargetTemperature(temperature: number): Promise<void>;
+    getSensorTemperatures(): Promise<number[]>;
+    getStatus(): Promise<Status>;
+    setControlInfo(info: Partial<ControlInfo>): Promise<void>;
+    getBasicInfo(): Promise<BasicInfo>;
+    static discover(timeoutMs?: number): Promise<DiscoveredDevice[]>;
+}
+
+export { API, type BasicInfoResponse, DaikinClient, type DaikinClientOptions, type DaikinResponse, type DiscoveredDevice, type Fan, type ZoneSettingResponse, basic_info, discover, get_zone_settings };

package/dist/index.d.ts

@@ -0,0 +1,183 @@
+type Params = Record<string, number | string>;
+
+type DaikinResponse = {
+    ret: 'OK';
+};
+declare class API {
+    readonly host: string;
+    constructor(host: string);
+    request(endpoint: string, parameters?: Record<string, string | number | undefined | null>): Promise<Params>;
+}
+
+type BasicInfoResponse = DaikinResponse & {
+    type: 'aircon';
+    reg: 'string';
+    dst: number;
+    ver: 'string';
+    rev: 'string';
+    pow: number;
+    err: number;
+    location: number;
+    name: 'string';
+    icon: number;
+    method: 'polling';
+    port: number;
+    id: 'string';
+    pw: 'string';
+    lpw_flag: number;
+    adp_kind: number;
+    led: number;
+    en_setzone: number;
+    mac: string;
+    adp_mode: 'run';
+    ssid: 'string';
+    err_type: string;
+    err_code: number;
+    en_ch: number;
+    holiday: number;
+    en_hol: number;
+    sync_time: number;
+};
+declare const basic_info: (http: API) => Promise<BasicInfoResponse>;
+
+type DiscoveredDevice = BasicInfoResponse & {
+    discoveredAddress: string;
+    discoveredPort: number;
+};
+declare function discover(timeoutMs?: number): Promise<DiscoveredDevice[]>;
+
+type ZoneSettingResponse = DaikinResponse & {
+    zone_name: string;
+    zone_onoff: string;
+};
+declare const get_zone_settings: (http: API) => Promise<ZoneSettingResponse>;
+
+type ZoneState = {
+    name: string;
+    state: boolean;
+};
+declare class Zones {
+    private zones;
+    private readonly client;
+    constructor(client: DaikinClient);
+    /** Refreshes the cached zone state */
+    refresh(): Promise<ZoneState[]>;
+    /**
+     * Gets the state of all cached zones.
+     */
+    getCachedZones(): ZoneState[];
+    /**
+     * Gets all zones' state
+     */
+    getZones(): Promise<ZoneState[]>;
+    /**
+     * Gets the cached state of a zone
+     * @param name
+     */
+    getCachedZone(name: string): boolean | undefined;
+    /**
+     * Gets the state of a Zone
+     * @param name
+     */
+    getZone(name: string): Promise<boolean | undefined>;
+    /**
+     * Sets a Zone's state
+     * @param name
+     * @param state
+     */
+    setZone(name: string, state: boolean): Promise<void>;
+    /**
+     * Sets multiple zones' state
+     * @param changes
+     */
+    setZones(changes: ZoneState[]): Promise<void>;
+}
+
+type BasicInfo = {
+    type: 'aircon';
+    region: string;
+    version: string;
+    name: string;
+    method: 'polling';
+    port: number;
+    id: string;
+    password: string;
+    ssid: string;
+    led: boolean;
+    adp_mode: 'run';
+    adp_kind: number;
+};
+declare enum ControlMode {
+    Fan = 0,
+    Hot = 1,
+    Cool = 2,
+    Auto = 3,
+    Dry = 4
+}
+declare enum FanSpeed {
+    Low = 1,
+    Medium = 3,
+    High = 5
+}
+declare enum Status {
+    Stopped = 0,
+    Operating = 1,
+    Idle = 2
+}
+declare enum RemoteType {
+    None = 0,
+    Wired = 1,
+    Wireless = 2
+}
+type ControlInfo = {
+    mode: ControlMode;
+    fanSpeed: FanSpeed;
+    fanAuto: boolean;
+    fanAirside: boolean;
+    targetTemperature: number;
+    sensorTemperatures: number[];
+    power: boolean;
+    status: Status;
+    swinging: boolean;
+    isFilterDirty: boolean;
+    isCentrallyControlled: boolean;
+    remoteControlType: RemoteType;
+};
+
+type DeviceOption = {
+    device: DiscoveredDevice;
+};
+type HostOption = {
+    host: string;
+};
+type DaikinClientOptions = (DeviceOption | HostOption) & {
+    password?: string;
+};
+type Fan = {
+    speed: FanSpeed;
+    auto: boolean;
+};
+declare class DaikinClient {
+    private readonly options;
+    readonly api: API;
+    readonly zones: Zones;
+    private cachedControlInfo;
+    constructor(options: DaikinClientOptions);
+    getControlInfo(): Promise<ControlInfo>;
+    getCachedControlInfo(): ControlInfo | undefined;
+    getPowered(): Promise<boolean>;
+    setPowered(state: boolean): Promise<void>;
+    getMode(): Promise<ControlMode>;
+    setMode(mode: ControlMode): Promise<void>;
+    getFan(): Promise<Fan>;
+    setFan(fan: Fan): Promise<void>;
+    getTargetTemperature(): Promise<number>;
+    setTargetTemperature(temperature: number): Promise<void>;
+    getSensorTemperatures(): Promise<number[]>;
+    getStatus(): Promise<Status>;
+    setControlInfo(info: Partial<ControlInfo>): Promise<void>;
+    getBasicInfo(): Promise<BasicInfo>;
+    static discover(timeoutMs?: number): Promise<DiscoveredDevice[]>;
+}
+
+export { API, type BasicInfoResponse, DaikinClient, type DaikinClientOptions, type DaikinResponse, type DiscoveredDevice, type Fan, type ZoneSettingResponse, basic_info, discover, get_zone_settings };

package/dist/index.js

@@ -0,0 +1,312 @@
+// src/ParamParser.ts
+function parse(str) {
+  const result = {};
+  const parts = str.split(",");
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (key === void 0) continue;
+    const maybeNumber = Number(value);
+    if (Number.isNaN(maybeNumber)) {
+      result[key] = decodeURIComponent(`${value}`);
+    } else {
+      result[key] = maybeNumber;
+    }
+  }
+  return result;
+}
+
+// src/api/API.ts
+import http from "http";
+var API = class {
+  host;
+  constructor(host) {
+    this.host = host;
+  }
+  async request(endpoint, parameters) {
+    const body = await new Promise((resolve, reject) => {
+      const url = new URL(`/skyfi${endpoint}`, `http://${this.host}/`);
+      const queries = [];
+      if (parameters) {
+        for (const key in parameters) {
+          const value = parameters[key];
+          if (value === void 0) continue;
+          const encoded = encodeURIComponent(`${value || ""}`);
+          queries.push(`${key}=${encoded}`);
+        }
+      }
+      const search = queries.length > 0 ? `?${queries.join("&")}` : "";
+      const req = http.request(
+        {
+          host: url.hostname,
+          port: url.port,
+          path: url.pathname + search,
+          // important
+          method: "GET",
+          headers: {
+            Accept: "*/*",
+            Connection: "close"
+          }
+        },
+        (res) => {
+          let data = "";
+          res.setEncoding("utf8");
+          res.on("data", (c) => data += c);
+          res.on("end", () => resolve(data));
+        }
+      );
+      req.on("error", reject);
+      req.end();
+    });
+    return parse(body);
+  }
+};
+
+// src/api/Discover.ts
+import dgram from "dgram";
+var DISCOVERY_PORT = 30050;
+var DISCOVERY_ADDRESS = "255.255.255.255";
+function discover(timeoutMs = 3e3) {
+  return new Promise((resolve, reject) => {
+    const availableUnits = /* @__PURE__ */ new Map();
+    const socket = dgram.createSocket("udp4");
+    const payload = Buffer.from("DAIKIN_UDP/common/basic_info", "utf8");
+    const finish = () => {
+      socket.close();
+      resolve([...availableUnits.values()]);
+    };
+    socket.once("error", (err) => {
+      socket.close();
+      reject(err);
+    });
+    socket.on("message", (msg, rinfo) => {
+      const raw = msg.toString("utf8");
+      const info = parse(raw);
+      const key = `${info.mac || info.id || rinfo.address}`;
+      availableUnits.set(key, {
+        discoveredAddress: rinfo.address,
+        discoveredPort: rinfo.port,
+        ...info
+      });
+    });
+    socket.bind(0, "0.0.0.0", () => {
+      try {
+        socket.setBroadcast(true);
+        socket.send(payload, DISCOVERY_PORT, DISCOVERY_ADDRESS, (err) => {
+          if (err) {
+            socket.close();
+            reject(err);
+            return;
+          }
+          setTimeout(finish, timeoutMs);
+        });
+      } catch (err) {
+        socket.close();
+        reject(err);
+      }
+    });
+  });
+}
+
+// src/api/common/basic_info.ts
+var basic_info = (http2) => http2.request("/common/basic_info");
+
+// src/api/aircon/get_zone_setting.ts
+var get_zone_settings = (http2) => http2.request("/aircon/get_zone_setting");
+
+// src/api/aircon/set_zone_setting.ts
+var set_zone_setting = (http2, params) => http2.request("/aircon/set_zone_setting", params);
+
+// src/Zones.ts
+var Zones = class {
+  zones = [];
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /** Refreshes the cached zone state */
+  async refresh() {
+    const response = await get_zone_settings(this.client.api);
+    const zoneNames = response.zone_name.split(";");
+    const zoneState = response.zone_onoff.split(";");
+    return this.zones = zoneNames.map((name, index) => ({
+      name,
+      state: zoneState[index] === "1"
+    }));
+  }
+  /**
+   * Gets the state of all cached zones.
+   */
+  getCachedZones() {
+    return [...this.zones];
+  }
+  /**
+   * Gets all zones' state
+   */
+  async getZones() {
+    return await this.refresh();
+  }
+  /**
+   * Gets the cached state of a zone
+   * @param name
+   */
+  getCachedZone(name) {
+    return this.zones.find((zone) => zone.name === name)?.state;
+  }
+  /**
+   * Gets the state of a Zone
+   * @param name
+   */
+  async getZone(name) {
+    const zones = await this.refresh();
+    return zones.find((zone) => zone.name === name)?.state;
+  }
+  /**
+   * Sets a Zone's state
+   * @param name
+   * @param state
+   */
+  async setZone(name, state) {
+    await this.setZones([{ name, state }]);
+  }
+  /**
+   * Sets multiple zones' state
+   * @param changes
+   */
+  async setZones(changes) {
+    await this.refresh();
+    for (const change of changes) {
+      const existingZone = this.zones.find((z) => z.name === change.name);
+      if (existingZone) {
+        existingZone.state = change.state;
+      }
+    }
+    const response = await set_zone_setting(this.client.api, {
+      zone_name: this.zones.map((zone) => zone.name).join(";"),
+      zone_onoff: this.zones.map((zone) => zone.state ? "1" : "0").join(";")
+    });
+    if (response.ret !== "OK")
+      throw new Error(`Failed to set zones: ${response.ret}`);
+  }
+};
+
+// src/api/aircon/get_control_info.ts
+var get_control_info = (http2) => http2.request("/aircon/get_control_info");
+
+// src/api/aircon/set_control_info.ts
+var set_control_info = (http2, params) => http2.request("/aircon/set_control_info", params);
+
+// src/DaikinClient.ts
+var DaikinClient = class {
+  options;
+  api;
+  zones;
+  cachedControlInfo;
+  constructor(options) {
+    this.options = options;
+    if ("host" in options) {
+      this.api = new API(options.host);
+    } else {
+      this.api = new API(options.device.discoveredAddress);
+    }
+    this.zones = new Zones(this);
+  }
+  async getControlInfo() {
+    const response = await get_control_info(this.api);
+    const responseValues = Object.entries(response);
+    return this.cachedControlInfo = {
+      mode: Number(response.mode),
+      fanSpeed: Number(response.f_rate),
+      fanAuto: response.f_auto != 0,
+      fanAirside: response.f_airside != 0,
+      targetTemperature: response.stemp,
+      sensorTemperatures: responseValues.filter(([k, v]) => k.startsWith("dt")).map(([k, v]) => +v),
+      power: response.pow != 0,
+      status: Number(response.operate),
+      swinging: response.f_dir != 0,
+      isFilterDirty: response.filter_sign_info != 0,
+      isCentrallyControlled: response.cent != 0,
+      remoteControlType: Number(response.remo)
+    };
+  }
+  getCachedControlInfo() {
+    return this.cachedControlInfo;
+  }
+  async getPowered() {
+    return (await this.getControlInfo()).power;
+  }
+  async setPowered(state) {
+    return await this.setControlInfo({ power: state });
+  }
+  async getMode() {
+    return (await this.getControlInfo()).mode;
+  }
+  async setMode(mode) {
+    return await this.setControlInfo({ mode });
+  }
+  async getFan() {
+    const info = await this.getControlInfo();
+    return {
+      speed: info.fanSpeed,
+      auto: info.fanAuto
+    };
+  }
+  async setFan(fan) {
+    return await this.setControlInfo({ fanSpeed: fan.speed, fanAuto: fan.auto });
+  }
+  async getTargetTemperature() {
+    return (await this.getControlInfo()).targetTemperature;
+  }
+  async setTargetTemperature(temperature) {
+    return await this.setControlInfo({ targetTemperature: temperature });
+  }
+  async getSensorTemperatures() {
+    return (await this.getControlInfo()).sensorTemperatures;
+  }
+  async getStatus() {
+    return (await this.getControlInfo()).status;
+  }
+  async setControlInfo(info) {
+    const latest = await this.getControlInfo();
+    const update = { ...latest, ...info };
+    const bool = (v) => v ? 1 : 0;
+    const response = await set_control_info(this.api, {
+      f_airside: bool(update.fanAirside),
+      f_auto: bool(update.fanAuto),
+      f_dir: bool(update.swinging),
+      f_rate: update.fanSpeed,
+      mode: update.mode,
+      pow: bool(update.power),
+      stemp: update.targetTemperature
+    });
+    if (response.ret !== "OK")
+      throw new Error(`Failed to update control info: ${response.ret}`);
+    this.cachedControlInfo = update;
+  }
+  async getBasicInfo() {
+    const response = await basic_info(this.api);
+    return {
+      type: response.type,
+      region: response.reg,
+      version: response.ver,
+      name: response.name,
+      method: response.method,
+      port: response.port,
+      id: response.id,
+      password: response.pw,
+      ssid: response.ssid,
+      led: response.led === 1,
+      adp_mode: response.adp_mode,
+      adp_kind: response.adp_kind
+    };
+  }
+  static async discover(timeoutMs = 3e3) {
+    return discover(timeoutMs);
+  }
+};
+export {
+  API,
+  DaikinClient,
+  basic_info,
+  discover,
+  get_zone_settings
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "daikin-airbase",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "build:example": "tsup example/basic_example.ts --format esm --out-dir dist/example",
+    "dev:example": "npm run build:example && node dist/example/basic_example.js"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}