acm

acm es un lenguaje de automatización y su intérprete de línea de comandos, escrito en Rust. Controla el ratón, el teclado, las ventanas, el portapapeles, las capturas de pantalla, los procesos y el navegador (Chrome/Edge) con una sintaxis de alto nivel. Se usa igual que python:

acm script.acm                 # ejecutar un archivo
acm -e 'CLICK 500 300; WRITE "hola"'   # ejecutar código suelto
acm                            # consola interactiva (REPL)

Sirve para automatizaciones personales y para que agentes de IA controlen el PC y hagan pruebas. Ofrece salida JSON, modo simulación (--dry-run) y códigos de salida fiables.

Los scripts usan la extensión .acm. Las extensiones con argumentos configurables usan .acmx.

El IDE ejecutando examples/github.acm: abre un perfil de GitHub y avisa con un ALERT.

Instalación

No necesitas Rust. Ejecuta una sola línea:

Windows (PowerShell):

irm https://raw.githubusercontent.com/AnthonyDev65/acm-rs-compiler/main/install.ps1 | iex

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/AnthonyDev65/acm-rs-compiler/main/install.sh | sh

El instalador descarga el binario de la última Release y lo deja en el PATH (%LOCALAPPDATA%\Programs\acm\bin en Windows, ~/.local/bin en macOS/Linux). Para actualizar, vuelve a ejecutar la misma línea; para una versión concreta, define antes ACM_VERSION (por ejemplo v0.1.0). Para desinstalar, borra esa carpeta o el archivo acm.

Desde el código fuente (necesitas Rust, https://rustup.rs): cargo install --path . desde esta carpeta; se desinstala con cargo uninstall acm.

Windows, opcional: para poder abrir los .acm con doble clic o ejecutarlos como script.acm en la terminal, ejecuta acm --register.

macOS/Linux: empieza el script con #!/usr/bin/env acm y dale permisos con chmod +x.

• macOS: concede a la terminal los permisos de Accesibilidad y Grabación de pantalla.
• Linux (X11): ALERT necesita zenity o kdialog, y FOCUS necesita wmctrl o xdotool.

La web necesita Google Chrome, Edge o Brave instalados. No hace falta ningún WebDriver.

Línea de comandos

acm [OPCIONES] [ARCHIVO] [nombre=valor ...]

Los argumentos nombre=valor se convierten en variables del script. Respetan el tipo declarado con @ARG en las extensiones. Los argumentos que no siguen el formato nombre=valor van a la lista ARGS.

Códigos de salida:

Parada de emergencia (FAILSAFE): si llevas el ratón a la esquina superior izquierda (0,0), el script se detiene antes de la siguiente acción de ratón o teclado. Ctrl+C también lo cancela.

Uso desde agentes

acm --json --no-dialogs script.acm

Con --json, cada línea de la salida es un evento:

{"event":"start","script":"script.acm","statements":12}
{"event":"print","text":"..."}
{"event":"screenshot","path":"C:\\...\\captura.png"}
{"event":"error","line":7,"message":"no se encontró el elemento '#login' (esperé 10 s)"}
{"event":"done","ok":false,"code":1,"ms":5321}

Con -v también se emiten eventos step ({"event":"step","line":5,"code":"CLICK 100 200"}). Con --dry-run se emiten eventos dry con cada acción simulada.

Ejemplos de consultas rápidas:

acm -e 'PRINT json(windows())'           # lista de ventanas
acm -e 'PRINT mousex(), mousey()'        # posición del ratón
acm -e 'SCREENSHOT "pantalla.png"'       # captura completa
acm -e 'PRINT pixel(100, 200)'           # color de un píxel (#RRGGBB)

El lenguaje

• Una sentencia por línea. Puedes poner varias en la misma línea separadas por ;.
• Los comandos no distinguen mayúsculas (click = CLICK). Las variables sí.
• Los comentarios empiezan con // o #. También se permite // al final de una línea.
• La indentación es libre.
• Una sentencia puede llevar una etiqueta delante, que se ignora al ejecutar: A:PRESS 100 200.
• Si un comando termina en (N), se repite N veces, con 50 ms entre repeticiones: KEYPRESS TAB (3), WRITE "=" (40).

Valores y expresiones

Para interpolar, usa cualquier expresión dentro de ${...}: "${i * 2}", "${ips[i]}", "${upper(x)}", "${RANDOM("a","b")}".

• Si la variable no existe o el contenido no es una expresión válida (por ejemplo, código JavaScript), el texto ${...} se deja tal cual.
• Para escribir ${ literal, usa \${.
• Dentro de "..." solo se escapa \". Las rutas "C:\carpeta\archivo" funcionan sin escapar nada.
• Hay variables predefinidas: NL (salto de línea), TAB, OS (windows/macos/linux), ARGS, SCRIPT, EXITCODE (código del último EXEC) y LOOP_INDEX.

Operadores, de menor a mayor precedencia:

1. OR / ||
2. AND / &&
3. NOT
4. == != < <= > >=
5. + -
6. * / %
7. Unarios: - ! EMPTY
8. Acceso: x[i], x.length, x.metodo(args), que equivale a metodo(x, args)

• + suma si los dos lados son números, aunque sean textos numéricos como "5" + 1 → 6. En otro caso concatena: "10.0.0." + 5 → "10.0.0.5".
• "=" * 10 repite el texto.
• Las comparaciones son numéricas cuando ambos lados son números y de texto en otro caso.
• EMPTY x es verdadero si x no existe, está vacía o es una lista vacía. !EMPTY x es lo contrario.
• Índices negativos: lista[-1] es el último elemento.

Variables y funciones

VAR nombre = "Ana"          // también LET / SET
VAR ips = ["10.0.0.1", "10.0.0.2"]
contador = 0
contador += 1
contador++
ips[0] = "10.0.0.99"

FUNC saludo(quien, veces)
    FOR i = 1 TO veces
        PRINT "Hola ${quien}"
    NEXT
    RETURN veces * 2
ENDFUNC
VAR r = saludo("Ana", 2)

IMPORT "utilidades.acm"     // ejecuta otro script (ruta relativa al actual)

Dentro de una función, VAR crea una variable local. Una asignación sin VAR modifica la variable global si existe.

Control de flujo

IF (x > 5 AND nombre == "Ana")
    PRINT "sí"
ELSE IF x == 0          // también ELSEIF
    PRINT "cero"
ELSE
    PRINT "no"
ENDIF

FOR (VAR i = 0; i < ips.length; i++)    // estilo C (también con i--, i += 2)
    PRINT ips[i]
ENDFOR

FOR ip IN ips           // listas; un número N recorre 0..N-1; "a,b,c" se separa por comas
    PRINT ip
ENDFOR

FOR i = 10 TO 1 STEP -1 // estilo BASIC (cierre con NEXT o ENDFOR)
    PRINT i
NEXT

WHILE NOT windowexists("Bloc de notas")
    DELAY 200ms
ENDWHILE

LOOP 3                  // LOOP / LOOP INFINITE; cierre con ENDLOOP
    KEYPRESS F5
ENDLOOP

BREAK / CONTINUE / RETURN valor / EXIT código

• Los bloques también pueden cerrarse con END o }, y abrirse con { al final de la línea.
• Un LOOP sin ENDLOOP repite todo el resto del script.

Ratón y teclado

Nombres de tecla:

Un nombre que no es una tecla se busca como variable: VAR t = "F5"; KEYPRESS t.

Sistema, archivos y ventanas

En Windows, acm trabaja en píxeles físicos. Por eso las coordenadas coinciden con las capturas aunque la pantalla esté escalada al 125 % o al 150 %.

Web (Chrome / Edge)

El navegador se abre al usar el primer comando web y se controla por el protocolo DevTools.

Selectores: si empiezan por / o ( se tratan como XPath (//input[@id='user']); si no, como CSS (#user, .btn.primary).

Esperas: cada comando espera a que el elemento aparezca, hasta 10 s por defecto. Se cambia con WEBTIMEOUT ms.

Firefox no está soportado. Además, el navegador se cierra cuando termina acm. Para dejarlo abierto mientras lo usas, termina el script con WEBWAITCLOSE. También puedes usar acm -i o la consola interactiva.

Si el usuario cierra el navegador a mitad del script, los comandos web siguientes fallan con «el navegador se cerró» en vez de abrir otro. Solo WEBOPEN y WEBTAB abren uno nuevo.

Funciones integradas

Extensiones (.acmx)

Las directivas de cabecera definen un nombre y argumentos que se pasan como nombre=valor:

@EXTENSION "Lista de IPs"
@DESCRIPTION "Genera IPs en el Bloc de notas"
@ARG base_ip "IP base" "192.168.1"
@ARG:CHECK incluir_puerto "Incluir puerto" "false"
@ARG:SELECT protocolo "Protocolo" "http|https|ftp"          // por defecto: la primera opción
@ARG:SELECT modo "Modo" "rapido" "rapido|lento"             // valor por defecto explícito
@ARG:LIST IPS "IPs" "10.0.0.1,10.0.0.2"                     // se convierte en lista

FOR ip IN IPS
    PRINT "${protocolo}://${ip}"
ENDFOR

acm --info lista.acmx
acm lista.acmx protocolo=https IPS=1.1.1.1,8.8.8.8
acm lista.acmx --ask        # pregunta los argumentos por consola

Estructura del código

Pruebas: cargo test. Para comprobar todos los scripts sin ejecutar acciones: acm --dry-run --no-dialogs archivo.acm.

En Windows, compila desde PowerShell o cmd. En Git Bash, el link de MSYS tapa el enlazador de MSVC y la compilación falla.

Editar esta página en GitHub ↗