@switchbot/homebridge-switchbot 4.3.2-beta.9 → 4.3.2

package/.github/copilot-instructions.md

@@ -0,0 +1,328 @@
+# Homebridge SwitchBot Plugin Development Guide
+
+Always reference these instructions first and fallback to search or bash commands only when you encounter unexpected information that does not match the info here.
+
+## Branch Targeting Strategy
+
+When creating pull requests, ALWAYS follow this branch targeting strategy:
+
+1. **Primary Target:** Look for branches that start with "beta-" (e.g., `beta-4.3.2`, `beta-4.4.0`)
+   - If a beta branch exists, target the most recent beta branch for your PR
+   - Beta branches are used for testing and staging changes before they go to the main branch
+
+2. **Beta Branch Creation:** If no beta branches exist, create one based on the next possible version
+   - Parse the current version from `package.json` (e.g., "4.3.1")
+   - Determine version increment type using issue/PR labels (patch/minor/major)
+   - Calculate the appropriate next version based on detected labels
+   - Create a new beta branch with the format `beta-X.Y.Z` (e.g., `beta-4.3.2`)
+   - Base the new beta branch on the `latest` branch
+   - Push the new beta branch to origin and target it for the PR
+
+3. **Fallback Target:** Only if beta branch creation fails, target the `latest` branch
+   - The `latest` branch is the main development branch when no beta releases are in progress
+
+4. **Branch Detection and Creation:** Use these methods to check and create branches:
+   - **Detection:** GitHub API: Use `github-mcp-server-list_branches` to get all branches and filter for "beta-" prefix
+   - **Detection:** Git command: `git ls-remote --heads origin | grep beta | sort -V | tail -1` to find the latest beta branch
+   - **Version parsing:** Extract version from package.json: `node -p "require('./package.json').version"`
+   - **Label Detection:** Check for version increment labels on the issue/PR:
+     - Use GitHub API to get issue/PR labels
+     - Look for labels: `patch`, `minor`, `major`
+     - These labels should be set before assigning the issue to Copilot
+   - **Version Increment Logic:** Choose increment type based on detected labels:
+     - **patch label found:** `node -p "const v=require('./package.json').version.split('.'); v[2]=parseInt(v[2])+1; v.join('.')"` (4.3.1 → 4.3.2)
+     - **minor label found:** `node -p "const v=require('./package.json').version.split('.'); v[1]=parseInt(v[1])+1; v[2]='0'; v.join('.')"` (4.3.1 → 4.4.0)
+     - **major label found:** `node -p "const v=require('./package.json').version.split('.'); v[0]=parseInt(v[0])+1; v[1]='0'; v[2]='0'; v.join('.')"` (4.3.1 → 5.0.0)
+     - **No relevant labels:** Default to patch increment as fallback
+     - **Multiple increment labels:** Use highest priority (major > minor > patch)
+   - **Label-Based Beta Branch Creation:**
+     ```bash
+     # Detect version increment type from issue/PR labels
+     # Use GitHub API: github-mcp-server-get_issue or github-mcp-server-get_pull_request
+     # Check labels array for: patch, minor, major
+     
+     # Calculate next version based on detected labels
+     if [[ labels contains "major" ]]; then
+       NEXT_VERSION=$(node -p "const v=require('./package.json').version.split('.'); v[0]=parseInt(v[0])+1; v[1]='0'; v[2]='0'; v.join('.')")
+     elif [[ labels contains "minor" ]]; then
+       NEXT_VERSION=$(node -p "const v=require('./package.json').version.split('.'); v[1]=parseInt(v[1])+1; v[2]='0'; v.join('.')")
+     else
+       # Default to patch increment (includes when "patch" label found or no labels)
+       NEXT_VERSION=$(node -p "const v=require('./package.json').version.split('.'); v[2]=parseInt(v[2])+1; v.join('.')")
+     fi
+     
+     BETA_BRANCH="beta-${NEXT_VERSION}"
+     
+     # Create and push the beta branch from latest
+     git fetch origin
+     git checkout -b "${BETA_BRANCH}" origin/latest
+     git push origin "${BETA_BRANCH}"
+     ```
+   - Always verify the target branch exists before creating the PR
+
+**NEVER target other branches** unless specifically instructed, and avoid targeting:
+- Individual feature branches (copilot/*, fix/*, etc.)
+- Release branches that are not beta branches
+- The main branch directly
+
+This ensures proper workflow where changes are tested in beta branches before being merged to the main development line.
+
+### Branch Targeting Validation and Troubleshooting
+
+**Before Starting Work:**
+1. **Verify Issue Labels:** Check that the assigned issue has appropriate version increment labels (`patch`, `minor`, or `major`)
+2. **Check Existing Beta Branches:** Use GitHub API or Git commands to identify current beta branches
+3. **Validate Target Branch:** Confirm the target beta branch exists or can be created successfully
+
+**Validation Commands:**
+```bash
+# Check for existing beta branches
+git ls-remote --heads origin | grep "beta-" | sort -V
+
+# Get current version for reference
+node -p "require('./package.json').version"
+
+# Example: Calculate next patch version
+node -p "const v=require('./package.json').version.split('.'); v[2]=parseInt(v[2])+1; v.join('.')"
+```
+
+**Troubleshooting Common Issues:**
+- **No version labels on issue:** Proceed with patch increment but notify in PR description
+- **Beta branch creation fails:** Fall back to targeting `latest` branch and document in PR
+- **Multiple conflicting labels:** Use highest priority (major > minor > patch) and document decision
+- **Network/API failures:** Use Git commands as fallback for branch detection
+
+### Label Requirements for Version Management
+
+**⚠️ CRITICAL REQUIREMENT:** Before assigning issues to Copilot, project maintainers **MUST** set appropriate version increment labels. This is required for proper branch targeting and version management.
+
+**Required Labels:**
+- **`patch`** - Bug fixes, documentation updates, minor improvements (4.3.1 → 4.3.2)
+- **`minor`** - New features, device support additions, non-breaking enhancements (4.3.1 → 4.4.0)  
+- **`major`** - Breaking changes, API modifications, major architectural updates (4.3.1 → 5.0.0)
+
+**Label Priority:** If multiple increment labels are present, the highest priority is used (major > minor > patch).
+
+**Fallback Behavior:** If no version increment labels are found, the system defaults to patch increment to ensure conservative version management.
+
+**Validation Process:** Copilot will:
+1. Check for required labels on the assigned issue
+2. Log a warning if no version increment labels are found
+3. Proceed with patch increment as fallback
+4. Create or target the appropriate beta branch based on version increment
+
+## Working Effectively
+
+### Bootstrap and Build Process
+Run these commands in sequence to set up and build the project:
+
+1. **Install dependencies:**
+   ```bash
+   npm install --legacy-peer-deps
+   ```
+   - CRITICAL: Must use `--legacy-peer-deps` flag due to TypeDoc dependency conflicts
+   - Takes approximately 30-45 seconds
+   - This is a known workaround documented in the codebase
+
+2. **Build the project:**
+   ```bash
+   npm run build
+   ```
+   - Takes approximately 7-10 seconds
+   - Compiles TypeScript and copies UI files
+   - Output goes to `dist/` directory
+
+3. **Run tests:**
+   ```bash
+   npm run test
+   ```
+   - Takes approximately 2-3 seconds  
+   - Currently minimal test suite (1 test file)
+   - Use `npm run test:watch` for continuous testing during development
+
+4. **Generate documentation:**
+   ```bash
+   npm run docs
+   ```
+   - Takes approximately 5-10 seconds
+   - Generates TypeDoc documentation in `docs/` directory
+
+### Full Build and Validation Workflow
+Complete validation workflow (approximately 30-45 seconds total):
+```bash
+npm install --legacy-peer-deps && npm run build && npm run test && npm run docs && npm run docs:lint && npm run docs:theme
+```
+- NEVER CANCEL: Set timeout to 90+ seconds for this complete workflow
+- This validates TypeScript compilation, plugin loading, and documentation generation
+
+### Development Commands
+
+- **Watch mode for development:**
+  ```bash
+  npm run watch
+  ```
+  - Builds, links plugin locally, and starts nodemon for file watching
+  - Requires local Homebridge installation
+
+- **Clean build artifacts:**
+  ```bash
+  npm run clean
+  ```
+  - Removes `dist/` directory
+
+- **Check for outdated dependencies:**
+  ```bash
+  npm run check
+  ```
+  - WARNING: This will fail due to dependency conflicts - use with `--legacy-peer-deps`
+
+### Known Issues and Workarounds
+
+- **Linting fails:** `npm run lint` and `npm run lint:fix` currently fail due to ESLint configuration conflicts with import/extensions rule. Document any code style issues manually.
+
+- **Dependency conflicts:** Always use `--legacy-peer-deps` flag for npm install due to TypeDoc theme dependency version mismatches.
+
+- **Coverage and docs artifacts:** Add `coverage/` and `docs/` to `.gitignore` to prevent committing build artifacts.
+
+## Validation Scenarios
+
+### Manual Plugin Validation
+After making changes, ALWAYS run these validation steps:
+
+1. **Verify plugin builds and loads:**
+   ```bash
+   npm run build && node -e "
+   try {
+     const plugin = require('./dist/index.js');
+     console.log('Plugin loads successfully');
+     console.log('Plugin type:', typeof plugin.default);
+   } catch (e) {
+     console.error('Plugin load failed:', e.message);
+   }"
+   ```
+
+2. **Test plugin registration:**
+   - Plugin exports a default function that registers with Homebridge
+   - Uses `PLUGIN_NAME = '@switchbot/homebridge-switchbot'` and `PLATFORM_NAME = 'SwitchBot'`
+   - Main platform class is `SwitchBotPlatform`
+
+3. **Validate TypeScript compilation:**
+   - Must have no TypeScript errors
+   - Check `dist/` directory contains all expected `.js`, `.d.ts`, and `.map` files
+
+4. **Test documentation generation:**
+   ```bash
+   npm run docs:lint
+   ```
+   - Must pass without warnings when using `--treatWarningsAsErrors`
+
+### Code Coverage Validation
+Run comprehensive test coverage analysis:
+```bash
+npm run test-coverage
+```
+- Current coverage is minimal (~1.36% overall)
+- Coverage reports generated in `coverage/` directory
+
+## Codebase Navigation
+
+### Project Structure
+```
+├── src/                     # Source TypeScript files
+│   ├── device/             # Device implementations (21 files)
+│   │   ├── device.ts       # Base device class (deviceBase)
+│   │   ├── bot.ts          # SwitchBot Bot device
+│   │   ├── curtain.ts      # SwitchBot Curtain device
+│   │   └── ...             # Other device implementations
+│   ├── irdevice/           # IR device implementations (10 files)
+│   │   ├── irdevice.ts     # Base IR device class
+│   │   ├── tv.ts           # TV IR control
+│   │   └── ...             # Other IR device implementations
+│   ├── homebridge-ui/      # Plugin configuration UI
+│   │   ├── server.ts       # UI backend server
+│   │   └── public/         # UI frontend files
+│   ├── platform.ts         # Main platform class (SwitchBotPlatform)
+│   ├── settings.ts         # Configuration interfaces and constants
+│   ├── utils.ts            # Utility functions
+│   └── index.ts            # Plugin entry point
+├── config.schema.json      # Homebridge configuration schema
+├── dist/                   # Compiled JavaScript output
+├── docs/                   # Generated TypeDoc documentation  
+└── coverage/               # Test coverage reports
+```
+
+### Key Development Areas
+
+- **Adding new devices:** Extend `src/device/device.ts` base class, implement in new file under `src/device/`
+- **Adding IR devices:** Extend `src/irdevice/irdevice.ts` base class, implement in new file under `src/irdevice/`
+- **Configuration changes:** Update `src/settings.ts` and `config.schema.json`
+- **Platform modifications:** Edit `src/platform.ts` (main class with 2800+ lines)
+- **Utility functions:** Modify `src/utils.ts` for shared functionality
+
+### Device Connection Types
+This plugin supports two connection methods to SwitchBot devices:
+1. **OpenAPI Connection:** Requires SwitchBot Cloud API token/secret, works through SwitchBot Hub
+2. **BLE (Bluetooth Low Energy):** Direct device connection, requires device MAC addresses
+
+### Common Development Tasks
+
+- **Testing device implementations:** Focus on `src/device/` and `src/irdevice/` directories
+- **Configuration UI changes:** Modify `src/homebridge-ui/` files and rebuild with `npm run plugin-ui`
+- **Platform logic changes:** Edit `src/platform.ts` - the main orchestration file
+- **Adding device support:** Create new device class extending `deviceBase` or IR device class
+
+### Important File Relationships
+- Always update both device implementation AND platform.ts when adding new device types
+- Configuration schema changes require updates to settings.ts interfaces
+- Device MAC address validation is handled in utils.ts (`formatDeviceIdAsMac`)
+- BLE connection handling is in the base device classes
+
+## Build Time Expectations
+
+- **npm install --legacy-peer-deps:** 30-45 seconds
+- **npm run build:** 7-10 seconds  
+- **npm run test:** 2-3 seconds
+- **npm run docs:** 5-10 seconds
+- **Complete validation workflow:** 30-45 seconds total
+- **NEVER CANCEL:** Always wait for builds to complete, set timeouts to 90+ seconds for safety
+
+## CI/CD Integration
+
+The project uses GitHub Actions for CI:
+- **Build workflow:** `.github/workflows/build.yml` runs Node.js build and test, then ESLint
+- **Required checks:** Build must pass, tests must pass
+- **Known CI issue:** ESLint currently fails due to configuration conflicts
+
+Always run the complete validation workflow locally before committing:
+```bash
+npm run build && npm run test && npm run docs:lint
+```
+
+## Complete Workflow Examples
+
+### Example 1: Issue with Proper Labels
+**Scenario:** Issue #1234 assigned to Copilot with `minor` label
+
+**Workflow:**
+1. **Label Detection:** Copilot detects `minor` label → target version 4.4.0
+2. **Branch Check:** Look for existing beta branches: `git ls-remote --heads origin | grep beta-`
+3. **Beta Branch Creation:** No beta-4.4.0 exists → create from latest branch
+4. **PR Targeting:** Target the new beta-4.4.0 branch
+5. **Development:** Make changes, test, commit to beta branch
+
+### Example 2: Issue without Version Labels
+**Scenario:** Issue #1276 assigned to Copilot with no version increment labels
+
+**Workflow:**
+1. **Label Detection:** No version labels found → default to patch increment
+2. **Version Calculation:** Current 4.3.1 → next patch 4.3.2
+3. **Branch Check:** beta-4.3.2 already exists → target existing branch
+4. **Development:** Make changes, document label requirement in PR description
+
+### Example 3: Multiple Version Labels
+**Scenario:** Issue assigned with both `minor` and `patch` labels
+
+**Workflow:**
+1. **Label Priority:** minor (higher priority) overrides patch
+2. **Version Target:** Calculate minor increment instead of patch
+3. **Documentation:** Note in PR description why minor was chosen over patch

package/.github/scripts/npm-version-script-esm-auto.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+/**
+ * Standalone ESM implementation — self-contained so this file can be copied
+ * into other repos without pulling any other files.
+ */
+
+import assert from 'node:assert'
+import child_process from 'node:child_process'
+import fs from 'node:fs'
+import process from 'node:process'
+// Minimal, in-file semver utilities used by this script.
+// This avoids an external dependency so the script can run in environments
+// where `semver` isn't installed.
+const semver = {
+	// Very small validation: match major.minor.patch with optional prerelease/build
+	valid(v) {
+		return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/.test(v)
+	},
+	// Return prerelease identifiers array or null
+	prerelease(v) {
+		const m = v.match(/^\d+\.\d+\.\d+-(.+)$/)
+		return m ? m[1].split('.') : null
+	},
+	// Compare two semver strings in reverse order (for rcompare use)
+	rcompare(a, b) {
+		// Use standard semver precedence rules for major.minor.patch; ignore prerelease complexity except that prerelease is lower than release
+		const pa = a.split('-')
+		const pb = b.split('-')
+		const aCore = pa[0].split('.').map(Number)
+		const bCore = pb[0].split('.').map(Number)
+		for (let i = 0; i < 3; i++) {
+			if (aCore[i] > bCore[i]) return -1
+			if (aCore[i] < bCore[i]) return 1
+		}
+		// equal core; releases (no prerelease) are greater than prerelease
+		if (pa.length === 1 && pb.length > 1) return -1
+		if (pa.length > 1 && pb.length === 1) return 1
+		// both same prerelease status: compare as strings
+		if (a > b) return -1
+		if (a < b) return 1
+		return 0
+	},
+	// Increment version by 'major'|'minor'|'patch'
+	inc(v, level) {
+		if (!this.valid(v)) throw new Error(`Invalid semver passed to inc: ${v}`)
+		// strip prerelease/build
+		const core = v.split('-')[0].split('+')[0]
+		const parts = core.split('.').map(Number)
+		switch (level) {
+			case 'major':
+				parts[0] += 1
+				parts[1] = 0
+				parts[2] = 0
+				break
+			case 'minor':
+				parts[1] += 1
+				parts[2] = 0
+				break
+			case 'patch':
+			default:
+				parts[2] += 1
+				break
+		}
+		return parts.join('.')
+	}
+}
+
+const BRANCH_VERSION_PATTERN = /^([A-Z]+)-(\d+\.\d+\.\d+)$/i
+
+// Load package.json
+const packageJSON = JSON.parse(fs.readFileSync('package.json', 'utf8'))
+
+const refArgument = process.argv[2]
+const tagArgument = process.argv[3] || 'latest'
+const prLabel = process.argv[4] || null // optional PR label: major, minor, patch
+
+if (!refArgument) {
+	console.error('ref argument is missing')
+	console.error('Usage: npm-version-script-esm.js <ref> [tag] [pr_label]')
+	process.exit(1)
+}
+
+/**
+ * Queries the NPM registry for the latest version for the provided base version and tag.
+ * If the tag is latest, then the base version is returned if it exists. For other tags, the latest
+ * version found for that base version and tag is returned.
+ * @param baseVersion The base version to query for, e.g. 2.0.0
+ * @param tag The tag to query for, e.g. beta or latest
+ * @returns {string} Returns the version, or '' if not found
+ */
+function getTagVersionFromNpm(baseVersion, tag) {
+	try {
+		return JSON.parse(child_process.execSync(`npm info ${packageJSON.name} versions --json`).toString('utf8').trim())
+			.filter(v => (tag === 'latest' ? v === baseVersion : v.startsWith(`${baseVersion}-${tag}.`)))
+			.reduce((_, current) => current, '')
+	} catch (e) {
+		console.error(`Failed to query the npm registry for the latest version for tag: ${tag}`, e)
+		// throw e;
+		return ''
+	}
+}
+
+function getLatestStableVersionFromNpm() {
+	try {
+		const versions = JSON.parse(child_process.execSync(`npm info ${packageJSON.name} versions --json`).toString('utf8').trim())
+		if (!Array.isArray(versions) || versions.length === 0) return ''
+
+		// Only consider stable semver versions (no prerelease)
+		const stable = versions.filter(v => semver.valid(v) && !semver.prerelease(v))
+		if (stable.length === 0) return ''
+
+		// Sort descending and return the highest
+		const sorted = stable.sort(semver.rcompare)
+		return sorted[0]
+	} catch (e) {
+		console.error('Failed to query the npm registry for published versions', e)
+		return ''
+	}
+}
+
+function desiredTargetVersion(ref) {
+	// ref is a GitHub action ref string
+	if (ref.startsWith('refs/pull/')) {
+		throw new Error('The version script was executed inside a PR!')
+	}
+
+	assert(ref.startsWith('refs/heads/'))
+	const branchName = ref.slice('refs/heads/'.length)
+
+	const results = branchName.match(BRANCH_VERSION_PATTERN)
+	if (results !== null) {
+		if (results[1].toLowerCase() !== tagArgument.toLowerCase()) {
+			console.warn(`The base branch name (${results[1]}) differs from the tag name ${tagArgument}`)
+		}
+
+		return results[2]
+	}
+
+	if (branchName === 'latest') {
+		// For latest branch, start with package.json version as base
+		return packageJSON.version
+	}
+
+	throw new Error(`Malformed branch name for ref: ${ref}. Must be beta-x.x.x, alpha-x.x.x, or 'latest'`)
+}
+
+function bumpVersion(baseVersion, prLabel) {
+	const label = (prLabel || 'patch').toLowerCase()
+	if (!semver.valid(baseVersion)) {
+		throw new Error(`Invalid base version passed to bumpVersion: ${baseVersion}`)
+	}
+
+	switch (label) {
+		case 'major':
+			return semver.inc(baseVersion, 'major')
+		case 'minor':
+			return semver.inc(baseVersion, 'minor')
+		case 'patch':
+		default:
+			return semver.inc(baseVersion, 'patch')
+	}
+}
+
+const baseVersion = desiredTargetVersion(refArgument)
+let publishTag = baseVersion
+
+if (refArgument.includes('latest')) {
+	if (prLabel) {
+		// For latest branch when a PR label is provided, bump according to PR label
+		publishTag = bumpVersion(baseVersion, prLabel)
+	} else {
+		// No PR label: determine next version based on the highest published stable version
+		const latestPublishedStable = getLatestStableVersionFromNpm()
+		if (latestPublishedStable) {
+			console.warn(`Latest published stable version is ${latestPublishedStable}; bumping patch`)
+			publishTag = bumpVersion(latestPublishedStable, 'patch')
+		} else {
+			console.warn('No published stable versions found; bumping package.json version patch')
+			publishTag = bumpVersion(baseVersion, 'patch')
+		}
+	}
+} else {
+	// For alpha/beta, query npm for latest
+	const latestReleasedVersion = getTagVersionFromNpm(baseVersion, tagArgument)
+	if (latestReleasedVersion) {
+		console.warn(`Latest published version for ${baseVersion} with tag ${tagArgument} is ${latestReleasedVersion}`)
+		publishTag = latestReleasedVersion
+	} else {
+		console.warn(`No published versions for ${baseVersion} with tag ${tagArgument}`)
+	}
+}
+
+if (packageJSON.version !== publishTag) {
+	console.warn(`Updating version in package.json from ${packageJSON.version} to ${publishTag}`)
+	packageJSON.version = publishTag
+	fs.writeFileSync('package.json', JSON.stringify(packageJSON, null, 2))
+
+	// perform the same change to the package-lock.json
+	const packageLockJSON = JSON.parse(fs.readFileSync('package-lock.json', 'utf8'))
+	packageLockJSON.version = publishTag
+	fs.writeFileSync('package-lock.json', JSON.stringify(packageLockJSON, null, 2))
+} else {
+	console.warn(`Version in package.json is already ${packageJSON.version}`)
+}
+
+console.log(publishTag)

package/.github/workflows/beta-release.yml

@@ -7,22 +7,20 @@ on:
 
 jobs:
   build_and_test:
-    uses: OpenWonderLabs/.github/.github/workflows/nodejs-build-and-test.yml@latest
+    uses: homebridge/.github/.github/workflows/nodejs-build-and-test.yml@latest
     with:
-      enable_coverage: true
+      enable_coverage: false
     secrets:
       token: ${{ secrets.GITHUB_TOKEN }}
-
   lint:
     needs: build_and_test
-    uses: OpenWonderLabs/.github/.github/workflows/eslint.yml@latest
+    uses: homebridge/.github/.github/workflows/eslint.yml@latest
 
   publish:
     needs: lint
-    if: ${{ github.repository == 'OpenWonderLabs/homebridge-switchbot' }}
     permissions:
       id-token: write
-    uses: OpenWonderLabs/.github/.github/workflows/npm-publish-esm.yml@latest
+    uses: homebridge/.github/.github/workflows/npm-publish-esm.yml@latest
     with:
       tag: 'beta'
       dynamically_adjust_version: true
@@ -33,8 +31,7 @@ jobs:
 
   pre-release:
     needs: publish
-    if: ${{ github.repository == 'OpenWonderLabs/homebridge-switchbot' }}
-    uses: OpenWonderLabs/.github/.github/workflows/pre-release.yml@latest
+    uses: homebridge/.github/.github/workflows/pre-release.yml@latest
     with:
       npm_version: ${{ needs.publish.outputs.NPM_VERSION }}
       body: |
@@ -45,12 +42,11 @@ jobs:
   github-releases-to-discord:
     name: Discord Webhooks
     needs: [build_and_test,publish]
-    if: ${{ github.repository == 'OpenWonderLabs/homebridge-switchbot' }}
-    uses: OpenWonderLabs/.github/.github/workflows/discord-webhooks.yml@latest
+    uses: homebridge/.github/.github/workflows/discord-webhooks.yml@latest
     with:
       title: "SwitchBot Beta Release"
       description: |
         Version `v${{ needs.publish.outputs.NPM_VERSION }}`
-      url: "https://github.com/homebridge/camera-utils/releases/tag/v${{ needs.publish.outputs.NPM_VERSION }}"
+      url: "https://github.com/OpenWonderLabs/homebridge-switchbot/releases/tag/v${{ needs.publish.outputs.NPM_VERSION }}"
     secrets:
-      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK_URL_BETA || secrets.DISCORD_WEBHOOK_URL_LATEST }}
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK_URL_LATEST }}

package/.github/workflows/release.yml

@@ -1,39 +1,71 @@
-name: Release
+name: Unified Release
 
 on:
-  release:
-    types: [published]
+  push:
+    branches:
+      #- "alpha-*"
+      #- "beta-*"
+      - latest
+  workflow_dispatch:
 
 jobs:
-  build_and_test:
-    uses: OpenWonderLabs/.github/.github/workflows/nodejs-build-and-test.yml@latest
+  # 1️⃣ Determine release type, ESM status, and branch name
+  determine-release-type:
+    uses: homebridge/.github/.github/workflows/determine-release-type.yml@latest
     with:
-      enable_coverage: true
-    secrets:
-      token: ${{ secrets.GITHUB_TOKEN }}
+      ref_name: ${{ github.ref_name }}
+
+  # 2️⃣ Update version and changelog using the scripts
+  update-version:
+    needs: determine-release-type
+    uses: homebridge/.github/.github/workflows/update-version.yml@latest
+    with:
+      release_type: ${{ needs.determine-release-type.outputs.release_type }}
+      is_esm: ${{ needs.determine-release-type.outputs.is_esm == 'true' }}
 
-  publish:
-    needs: build_and_test
-    if: ${{ github.repository == 'OpenWonderLabs/homebridge-switchbot' }}
+  # 3️⃣ Publish to NPM and create GitHub release
+  publish-release:
+    needs: [determine-release-type, update-version]
     permissions:
       id-token: write
-    uses: OpenWonderLabs/.github/.github/workflows/npm-publish-esm.yml@latest
+      contents: write
+    uses: homebridge/.github/.github/workflows/publish-release.yml@latest
+    with:
+      release_type: ${{ needs.determine-release-type.outputs.release_type }}
+      version: ${{ needs.update-version.outputs.version }}
+      is_esm: ${{ needs.determine-release-type.outputs.is_esm == 'true' }}
     secrets:
-      npm_auth_token: ${{ secrets.npm_token }}
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+  # 4️⃣ Promote branch if this is a prerelease (alpha/beta)
+  promote-branch:
+    needs: [determine-release-type, publish-release]
+    if: ${{ needs.determine-release-type.outputs.release_type != 'latest' && needs.determine-release-type.outputs.release_type != 'skip' }}
+    uses: homebridge/.github/.github/workflows/promote-branch.yml@latest
+    with:
+      branch_name: ${{ needs.determine-release-type.outputs.branch_name }}
+      release_type: ${{ needs.determine-release-type.outputs.release_type }}
+      is_esm: ${{ needs.determine-release-type.outputs.is_esm == 'true' }}
 
+  # 5️⃣ Notify if any previous job fails
+  workflow-failure:
+    if: ${{ failure() }}
+    needs: [determine-release-type, update-version, publish-release, promote-branch]
+    uses: homebridge/.github/.github/workflows/report-failure.yml@latest
+    with:
+      workflow_name: ${{ github.workflow }}
+      job_name: ${{ github.job }}
+      run_url: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+  # 6️⃣ Post to Discord
   github-releases-to-discord:
     name: Discord Webhooks
-    needs: [build_and_test,publish]
-    if: ${{ github.repository == 'OpenWonderLabs/homebridge-switchbot' }}
-    uses: OpenWonderLabs/.github/.github/workflows/discord-webhooks.yml@latest
+    needs: [determine-release-type, update-version, publish-release]
+    uses: homebridge/.github/.github/workflows/discord-webhooks.yml@latest
     with:
       title: "SwitchBot Release"
       description: |
-        Version `v${{ needs.publish.outputs.NPM_VERSION }}`
-      url: "https://github.com/homebridge/camera-utils/releases/tag/v${{ needs.publish.outputs.NPM_VERSION }}"
+        Version `v${{ needs.update-version.outputs.version }}`
+      url: "https://github.com/OpenWonderLabs/homebridge-switchbot/releases/tag/v${{ needs.update-version.outputs.version }}"
     secrets:
       DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK_URL_LATEST }}
-
-
-
-