"I would like to know if it's possible to turn off the monitor and the computer at the same time with just one command? In the free version? With the example command, the monitor enters power saving mode, but doesn't turn off completely...

Question for Windows please"

You can run multiple commands in one command by putting && between commands, like this:

Now you can use it to generate commands using AI - checkout this video.

I've never tried "wake-on-wlan" but in theory it's possible with the right hardware.
https://documentation.ubuntu.com/core/explanation/system-snaps/network-manager/how-to-guides/configure-the-snap/wake-on-wlan/

I can say, "Alexa, bulb 1 red" or "Alexa bulb 1 off" etc.

I can also say, "Use @TRIGGERcmd to turn bulb 1 blue" using the MCP tool with ChatGPT.

Example commands:

Turn the bulb on:

python3 c:\tools\tuyabulb.py --id abcdefghijklmnop123456 --key "123456!@ABCcdefh" --ip 192.168.86.25 on

Set the color to red:

python3 c:\tools\tuyabulb.py --id abcdefghijklmnop123456 --key "123456!@ABCcdefh" --ip 192.168.86.25 red

Set the brightness to 60 percent:

python3 c:\tools\tuyabulb.py --id abcdefghijklmnop123456 --key "123456!@ABCcdefh" --ip 192.168.86.25 60

Here's the script:

#!/usr/bin/env python3
import argparse
import ipaddress
import platform
import subprocess
import sys
import tinytuya

# Predefined color presets (RGB values)
COLOR_PRESETS = {
    "red": (255, 0, 0),
    "green": (0, 255, 0),
    "blue": (0, 0, 255),
    "white": (255, 255, 255),
    "yellow": (255, 255, 0),
    "cyan": (0, 255, 255),
    "magenta": (255, 0, 255),
    "orange": (255, 165, 0),
    "purple": (128, 0, 128),
    "pink": (255, 192, 203),
}


def ping_host(ip: str, timeout: int = 1) -> bool:
    """Ping a host to check if it's reachable. Returns True if ping succeeds."""
    param = "-n" if platform.system().lower() == "windows" else "-c"
    timeout_param = "-w" if platform.system().lower() == "windows" else "-W"
    timeout_value = str(timeout * 1000) if platform.system().lower() == "windows" else str(timeout)
    
    command = ["ping", param, "1", timeout_param, timeout_value, ip]
    try:
        result = subprocess.run(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout + 1)
        return result.returncode == 0
    except (subprocess.TimeoutExpired, Exception):
        return False


def make_device(device_id: str, ip: str, local_key: str, version: str | None):
    # BulbDevice works for most Tuya bulbs. If yours isn't a "bulb" type, use Device instead.
    d = tinytuya.BulbDevice(device_id, ip, local_key)
    d.set_socketPersistent(True)   # keep socket open for reliability
    d.set_socketTimeout(5)         # seconds

    # Many Tuya WiFi bulbs are 3.3. Some are 3.1. If you're unsure, try 3.3 first.
    if version:
        d.set_version(float(version))
    else:
        d.set_version(3.3)

    return d


def main():
    p = argparse.ArgumentParser(description="Local control of a Tuya bulb via tinytuya (no cloud).")
    p.add_argument("--id", required=True, help="Tuya device id")
    p.add_argument("--ip", help="Bulb IP address on your LAN")
    p.add_argument("--subnet", help="Subnet to scan (e.g. 192.168.1.0/24)")
    p.add_argument("--start-from", help="IP address to start scanning from (only with --subnet)")
    p.add_argument("--key", required=True, help="Tuya localKey (16+ chars)")
    p.add_argument("--ver", default=None, help="Protocol version (e.g. 3.3 or 3.1). Default: 3.3")
    p.add_argument("cmd", help="Command: off, on, status, color name (red, green, etc.), or brightness 0-100")
    args = p.parse_args()

    # Determine command type
    cmd_lower = args.cmd.lower()
    if cmd_lower in ["off", "on", "status"]:
        cmd_type = cmd_lower
    elif cmd_lower in COLOR_PRESETS:
        cmd_type = "color"
        preset_color = cmd_lower
    elif args.cmd.isdigit():
        brightness_val = int(args.cmd)
        if 0 <= brightness_val <= 100:
            cmd_type = "brightness"
        else:
            p.error("Brightness must be between 0-100")
    else:
        p.error(f"Invalid command: {args.cmd}. Use: off, on, status, color name, or brightness (0-100)")

    # Validate that either --ip or --subnet is provided
    if not args.ip and not args.subnet:
        p.error("Either --ip or --subnet must be specified")
    if args.ip and args.subnet:
        p.error("Cannot specify both --ip and --subnet")
    if args.start_from and not args.subnet:
        p.error("--start-from can only be used with --subnet")

    # Determine which IPs to try
    if args.subnet:
        try:
            network = ipaddress.ip_network(args.subnet, strict=False)
            all_ips = [str(ip) for ip in network.hosts()]
            
            # Filter to start from specified IP if provided
            if args.start_from:
                start_ip = ipaddress.ip_address(args.start_from)
                # Verify start IP is in the subnet
                if start_ip not in network:
                    print(f"ERROR: Start IP {args.start_from} is not in subnet {args.subnet}", file=sys.stderr)
                    return 1
                # Filter to IPs >= start_from
                ips_to_try = [ip for ip in all_ips if ipaddress.ip_address(ip) >= start_ip]
                print(f"Scanning subnet {args.subnet} from {args.start_from} ({len(ips_to_try)} hosts)...", file=sys.stderr)
            else:
                ips_to_try = all_ips
                print(f"Scanning subnet {args.subnet} ({len(ips_to_try)} hosts)...", file=sys.stderr)
        except ValueError as e:
            print(f"ERROR: Invalid subnet or IP format: {e}", file=sys.stderr)
            return 1
    else:
        ips_to_try = [args.ip]

    # Try each IP until one works
    last_error = None
    for ip in ips_to_try:
        if args.subnet:
            print(f"Trying {ip}...", file=sys.stderr)
            # Quick ping check to skip unreachable hosts
            if not ping_host(ip):
                continue
        
        dev = make_device(args.id, ip, args.key, args.ver)

        dev = make_device(args.id, ip, args.key, args.ver)

        try:
            if cmd_type == "off":
                r = dev.turn_off()
            elif cmd_type == "on":
                r = dev.turn_on()
            elif cmd_type == "brightness":
                r = dev.set_brightness_percentage(brightness_val)
            elif cmd_type == "color":
                # Get RGB values from preset
                rgb = COLOR_PRESETS[preset_color]
                # Set the color
                r = dev.set_colour(rgb[0], rgb[1], rgb[2])
            else:
                r = dev.status()

            # Check if the device responded with an errora
            if isinstance(r, dict) and r.get("Error"):
                if args.subnet:
                    # During subnet scan, continue to next IP on error
                    last_error = r.get("Error")
                    continue
                else:
                    # For direct IP, print error and exit
                    print(r)
                    return 2

            # Success! Print result and exit
            if args.subnet:
                print(f"SUCCESS: Device found at {ip}", file=sys.stderr)
            print(r)
            return 0

        except Exception as e:
            last_error = e
            if not args.subnet:
                print(f"ERROR: {e}", file=sys.stderr)
                return 1
            # For subnet scan, continue to next IP
            continue
        finally:
            try:
                dev.set_socketPersistent(False)
            except Exception:
                pass

    # If we get here with subnet scan, none of the IPs worked
    if args.subnet:
        print(f"ERROR: Device not found in subnet {args.subnet}. Last error: {last_error}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    raise SystemExit(main())

This is my commands.json entry:

 {
  "trigger": "Tuya Bulb 1",
  "command": "python3 c:\\tools\\tuyabulb.py --id abcdefghijklmnop123456 --key \"123456!@ABCcdefh\" --ip 192.168.86.25",
  "offCommand": "",
  "ground": "foreground",
  "voice": "bulb 1",
  "voiceReply": "",
  "allowParams": "true",
  "mcpToolDescription": "Controls the state of light bulb 1.  Parameters are: on, off, red, green, blue, white, yellow, cyan, magenta, orange, purple, pink, or brightness percentage from 0 to 100"
 }

Here's a Youtube video showing how it works: https://youtu.be/ctV8TUvcQuI

This shows me telling the Claude AI LLM to lookup a Youtube video and play it on my Roku.

This is my claude_desktop_config.json file:

{
  "mcpServers": {
    "triggercmd": {
      "command": "C:\\tools\\triggercmd-mcp-windows-amd64.exe"
    },
    "youtube": {
            "command": "C:\\Users\\russe\\AppData\\Local\\Microsoft\\WindowsApps\\python.exe",
            "args": [
                "-m", "uv", "run", "--directory", 
                "C:\\tools\\mcp\\youtube-mcp", 
                "youtube_server.py"
            ],
            "env": {
                "YOUTUBE_API_KEY": "(get your own)"
            }
    }
  }
}

This is my TRIGGERcmd command from commands.json:

 {
  "trigger": "Youtube Upstairs Roku",
  "command": "c:\\tools\\yt-upstairs-roku.bat",
  "offCommand": "",
  "ground": "foreground",
  "voice": "",
  "voiceReply": "",
  "allowParams": "true",
  "mcpToolDescription": "Shows a specific video on my upstairs Roku.  The parameter specifies the video by its Youtube video ID. "
 }

This is my yt-upstairs-roku.bat file:

curl -v -XPOST "http://192.168.1.12:8060/launch/837?contentId=%1"

192.168.86.127 is the IP of my upstairs Roku.
837 is the ID of the Youtube app on Roku.
%1 is a placeholder for the parameter (the Youtube video ID).

winget upgrade --all

Then your command would run that script with a command like this:

If you don't want to create a script, you can generally run multiple commands with one command line by separating the commands with && like this:

Make sure to adjust the folder paths. I doubt you'll put your script in d:\appdev\triggercmd\youtube-dl or put your downloaded files in m:\videos\youtube like I did.

Create a folder, open a cmd window in that folder, and type these to create the virtual environment with the yt_dlp python module:

python3 -m venv myenv
myenv\Scripts\activate.bat
pip3 install yt_dlp

youtube-dl.bat contents:

setlocal enabledelayedexpansion

:: This version of the script differs from the one in the Youtube video in that it handles any of these Youtube URL formats:
:: https://www.youtube.com/watch?v=KqfRiPy5gFs
:: https://youtu.be/KqfRiPy5gFs
:: KqfRiPy5gFs

:: Combine all arguments into a single string
set "input="
for %%A in (%*) do (
    set "input=!input! %%A"
)

:: Remove leading spaces
set "input=%input:~1%"

:: Check if the input contains "youtu.be" format and extract the video ID
echo %input% | findstr /C:"youtu.be" >nul
if not errorlevel 1 (
    set "id=%input:~17%"  :: Strip "https://youtu.be/"
)

:: Check if the input contains "youtube.com/watch?v=" format and extract the video ID
if not defined id (
    echo %input% | findstr /C:"youtube.com/watch?v=" >nul
    if not errorlevel 1 (
        set "id=%input:~32%"  :: Strip "https://www.youtube.com/watch?v="
    )
)

:: If input is just the ID, no need for stripping
if not defined id (
    set "id=%input%"
)

:: Ensure the ID is exactly 11 characters long
set "id=%id:~0,11%"

echo YouTube Video ID: %id%

:: Go to the folder where I want the files to be created
cd /d m:\videos\youtube

:: Activate the Python virtual environment that has the yt_dlp module installed
call d:\appdev\triggercmd\youtube-dl\myenv\Scripts\activate.bat

:: Run the python script to download the video and metadata
python d:\appdev\triggercmd\youtube-dl\youtube-dl.py %id%  > debug.log 2>&1

youtube-dl.py contents:

import yt_dlp
import json, uuid, sys

def download_video_metadata(video_url):
    ydl_opts = {
        'quiet': True,
        'skip_download': True,
        'force_generic_extractor': False,
    }
    
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        try:
            info_dict = ydl.extract_info(video_url, download=False)
            return info_dict
        except Exception as e:
            print(f"Error: {e}")
            return None

def download_video(video_url):
    ydl_opts = {
        'quiet': False,
        'outtmpl': '%(title)s.%(ext)s',
    }
    
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        try:
            ydl.download([video_url])
        except Exception as e:
            print(f"Error: {e}")

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python3 youtube-dl.py <YouTube Video URL>")
        sys.exit(1)

    video_url = sys.argv[1]
    metadata = download_video_metadata(video_url)
    
    if metadata:
        print("Metadata:")

        filename=metadata.get('title', uuid.uuid4()) + ".json"
        with open(filename, "w") as file:
            json.dump(metadata, file, indent=4)

        print("Downloading video...")
        download_video(video_url)

Make sure you enable parameters:

If you want to create a panel, you can use this regex to accept any text: ^.*$

There is a command to turn off second monitor only and to turn on again?

The formula is, "Alexa, turn on/off [voice word]."

That's assuming you're using the TRIGGERcmd Smart Home skill.

In this example, I can say

"Alexa, turn on calculator." to open it.
"Alexa, turn off calculator." to close it.

7d94e408-a352-4c03-b195-3c512a638539-image.png

Preciso de um comando que "Entre" quando em suspensão.

Ele não possui senha, mas necessitar clicar em ENTRE para voltar a Area de Trabalho.

Also, by manually, I assume you mean when you run it manually from the command line it works. What if you run it manually via TRIGGERcmd using the green Trigger button on the website, or from the green Play arrow in the GUI Editor ? We should make sure those work before attempting Alexa.

I think you meant the shutdown command, not wakeonlan because this command would shutdown a Windows computer in 30 seconds:

You can use it to add your commands, like this:

a7b17bdd-a9ef-4adb-873d-82486d97e561-image.png

To open the GUI Command Editor, right click the TRIGGERcmd Agent's tray icon first:

20784eb0-6554-40e4-824a-450bb3dfe7e7-image.png

I made this video on how to install nircmd so you can run it from anywhere:
https://www.youtube.com/watch?v=xub4pjenLVs