Atajo macOS para copia y pegar contraseñas al instante

¿Cuántas veces has ido al Llavero de macOS para copiar una contraseña con alguien mirando la pantalla por encima del hombro?

Con este método puedes tener una contraseña lista para pegar simplemente pulsando un atajo de teclado, sin abrir el llavero, sin mostrar nada en pantalla y sin que falle el pegado.

El comando que funciona siempre

Para conseguir que una contraseña se copie/pegue correctamente al portapapeles utilizaremos el comando de shell printf.

 TERMINAL MAC

printf '%s' 'TU_CONTRASEÑA' | /usr/bin/pbcopy

Este comando deja la contraseña lista para pegar, sin saltos de línea ni caracteres ocultos.

¿Cómo convertirlo en un Atajo? (Automator)

1. Abre Automator y crea una Acción rápida.
2. Configura: “El flujo de trabajo recibe” → sin datos de entrada.
3. Añade la acción Ejecutar script de shell.
4. Selecciona /bin/zsh o /bin/bash.
5. Pega el comando anterior.
6. Guarda la acción y asígnale un atajo de teclado.

A partir de ahora solo tienes que pulsar el atajo y pegar la contraseña directamente, sin pasar por el llavero.

Opcional: forzar UTF-8 si usas símbolos especiales

Si la contraseña incluye caracteres especiales o símbolos poco habituales, podemos forzar que se copien y peguen correctamente evitando cualquier error de codificación de la siguiente manera:

 TERMINAL MAC

export LC_CTYPE=UTF-8
printf '%s' 'TU_CONTRASEÑA' | /usr/bin/pbcopy

Normalmente no hace falta, pero evita problemas con símbolos poco habituales.

¿Quieres que subamos el listón?

Ahora vamos a hacer que la contraseña se borre automáticamente del portapapeles pasados unos segundos, para que no quede accesible más tiempo del necesario.

La idea es sencilla: copiamos la contraseña como antes, esperamos unos segundos y, pasado ese tiempo, vaciamos el portapapeles de forma automática.

 TERMINAL MAC

printf '%s' 'TU_CONTRASEÑA' | /usr/bin/pbcopy
sleep 30
CURRENT="$(pbpaste)"

if [ "$CURRENT" = "TU_CONTRASEÑA" ]; then
  printf '' | /usr/bin/pbcopy
fi

Esta versión solo borra el portapapeles si, pasado el tiempo indicado, sigue conteniendo la contraseña. Si has copiado otra cosa, no interfiere.

Asignar un atajo de teclado a la Acción rápida

Una vez guardada la Acción rápida en Automator, el último paso es asignarle un atajo de teclado para poder usarla en cualquier momento sin abrir nada.

1. Abre Ajustes del sistema.
2. Entra en Teclado → "Atajos de teclado…".
3. En el menú lateral, selecciona Servicios > General.
4. Busca tu Acción rápida (aparece con el nombre con el que la guardaste).
5. Haz clic en Añadir atajo y pulsa la combinación de teclas que quieras usar.

Elige un atajo que no esté ya en uso y que recuerdes fácilmente, ya que será el que pulses cada vez que quieras copiar la contraseña.

A partir de ese momento, solo tienes que pulsar el atajo y pegar la contraseña directamente donde la necesites, sin abrir el llavero ni mostrar nada en pantalla.

Cómo crear un icono .icns para tu app en macOS usando solo Terminal

 macOS • Iconos personalizados PRO

Convierte un PNG del Escritorio (por ejemplo el icono de QRSCAN) en un icono .icns profesional para tus apps de macOS.

Vamos a usar solo herramientas nativas: sips para generar los tamaños y iconutil para crear el .icns final.

1. Requisitos previos

• Un Mac con macOS (Intel o Apple Silicon).
• Un archivo PNG cuadrado en el Escritorio, por ejemplo qrscan.png, idealmente 1024x1024 px.
• Terminal (Zsh por defecto).

Puedes adaptar el nombre del archivo (por ejemplo miapp.png), pero en los ejemplos usaremos qrscan.png.

2. Crear la carpeta de iconos (.iconset)

Primero creamos la carpeta donde irán todas las versiones de tamaño del icono:

 TERMINAL MAC

cd ~/Desktop
mkdir qrscan.iconset

Si tu PNG no se llama qrscan.png, cambia el nombre en los comandos de esta guía.

3. Generar todos los tamaños de icono con sips

macOS usa distintos tamaños de icono según el contexto (Dock, Finder, vista previa…). Vamos a generarlos todos a partir de tu PNG original.

Ejecuta este bloque tal cual (asegúrate de estar en el Escritorio):

 TERMINAL MAC

cd ~/Desktop

sips -z 16 16   qrscan.png --out qrscan.iconset/icon_16x16.png
sips -z 32 32   qrscan.png --out qrscan.iconset/icon_16x16@2x.png

sips -z 32 32   qrscan.png --out qrscan.iconset/icon_32x32.png
sips -z 64 64   qrscan.png --out qrscan.iconset/icon_32x32@2x.png

sips -z 128 128 qrscan.png --out qrscan.iconset/icon_128x128.png
sips -z 256 256 qrscan.png --out qrscan.iconset/icon_128x128@2x.png

sips -z 256 256 qrscan.png --out qrscan.iconset/icon_256x256.png
sips -z 512 512 qrscan.png --out qrscan.iconset/icon_256x256@2x.png

sips -z 512 512 qrscan.png --out qrscan.iconset/icon_512x512.png
cp qrscan.png qrscan.iconset/icon_512x512@2x.png

Si partes de un PNG de 1024x1024 px, las versiones @2x (retina) se verán nítidas en todos los tamaños.

4. Convertir la carpeta .iconset en un .icns

Ahora empaquetamos la carpeta qrscan.iconset en un único archivo qrscan.icns, que es el formato de iconos oficial de macOS.

 TERMINAL MAC

cd ~/Desktop
iconutil -c icns qrscan.iconset

Si no hay errores, tendrás en tu Escritorio un archivo llamado qrscan.icns.

Puedes eliminar la carpeta qrscan.iconset si ya no la necesitas, dejando solo el .icns.

5. Aplicar el icono .icns a una app (Automator, utilidades, etc.)

Para apps sencillas (Automator, herramientas internas), el truco más simple sigue siendo usar Vista Previa y la ventana de “Obtener información”.

1. Haz doble clic en qrscan.icns para abrirlo con Vista Previa.
2. En Vista Previa, ve a Edición → Seleccionar todo (o ⌘A).
3. Después, ve a Edición → Copiar (o ⌘C).
4. En Finder, localiza tu app (por ejemplo Leer QR.app).
5. Haz clic derecho sobre la app y selecciona Obtener información (o pulsa ⌘I).
6. En la ventana de información, haz clic una vez sobre el pequeño icono de arriba a la izquierda (junto al nombre de la app) hasta que quede resaltado.
7. Pulsa ⌘V para pegar el icono .icns que tienes en el portapapeles.

El nuevo icono se propagará al Dock, Spotlight y Finder. Si no lo ves al momento, cierra y vuelve a abrir la app, o reinicia sesión.

6. Resumen

• Partes de un PNG cuadrado en el Escritorio (qrscan.png).
• Generas todos los tamaños en una carpeta .iconset con sips.
• Creas un .icns profesional con iconutil.
• Aplicás el icono a cualquier app usando Vista Previa + “Obtener información”.

Perfecto para dar identidad visual a utilidades como QRSCAN, lanzadores de scripts y apps internas de tu ecosistema macOS.

Cómo crear QRSCAN en tu Mac para leer códigos QR en PDF, JPG y PNG

 macOS • QRSCAN Profesional

Convierte tu Mac en un lector de códigos QR profesional usando Python, un entorno virtual aislado y un comando rápido llamado qrscan.

1. Requisitos previos

Solo necesitas tres cosas:

• macOS con Terminal (Intel o Apple Silicon).
• Python 3 preinstalado (todos los Mac modernos lo traen).
• Homebrew instalado.

Comprueba todo con:

 TERMINAL

python3 --version
brew --version

Si eso aparece correcto, continúa. No necesitaremos usar pip global, así que no habrá errores.

2. Crear el entorno virtual seguro

Vamos a crear un entorno completamente aislado llamado qrscan-env:

 TERMINAL

python3 -m venv ~/qrscan-env
source ~/qrscan-env/bin/activate

Instala las dependencias dentro del entorno:

 TERMINAL

pip install opencv-python pillow pdf2image

Instala poppler con Homebrew (para leer PDF):

 TERMINAL

brew install poppler

Durante la instalación de poppler, la Terminal mostrará muchos mensajes, descargas y líneas de texto que parecen “caóticas”. Es completamente normal: Homebrew está compilando e instalando dependencias internas. Simplemente espera a que el proceso termine y vuelva a aparecer el prompt del Terminal.

3. Crear el script ~/leer_qr.py

Pega este script completo:

 TERMINAL

cat > ~/leer_qr.py << 'EOF'
import sys, os
from PIL import Image
import numpy as np
import cv2
from pdf2image import convert_from_path

detector = cv2.QRCodeDetector()

def leer_qr_en_imagen(ruta):
    img = Image.open(ruta).convert("RGB")
    arr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)

    textos = []

    try:
        ok, decoded, pts, _ = detector.detectAndDecodeMulti(arr)
        if ok:
            textos += [t for t in decoded if t]
    except:
        t, _, _ = detector.detectAndDecode(arr)
        if t:
            textos.append(t)

    return textos

def leer_qr_en_pdf(ruta):
    paginas = convert_from_path(ruta, dpi=300)
    resultados = []
    for i, p in enumerate(paginas):
        t = f"/tmp/qrscan_{i}.png"
        p.save(t, "PNG")
        resultados += leer_qr_en_imagen(t)
        os.remove(t)
    return resultados

if len(sys.argv) < 2:
    print("Uso: python3 leer_qr.py archivo.pdf|jpg|png")
    sys.exit()

archivo = sys.argv[1]

if not os.path.exists(archivo):
    print("Archivo no encontrado:", archivo)
    sys.exit()

if archivo.lower().endswith(".pdf"):
    r = leer_qr_en_pdf(archivo)
else:
    r = leer_qr_en_imagen(archivo)

if not r:
    print("No se encontró ningún QR")
else:
    print("=== QR DETECTADOS ===")
    for x in r:
        print(x)
EOF

4. Crear el comando rápido qrscan

Con esto podrás leer QR desde cualquier sitio simplemente escribiendo qrscan archivo.pdf.

Crea ~/bin si no existe:

 TERMINAL

mkdir -p ~/bin

Crea el script:

 TERMINAL

cat > ~/bin/qrscan << 'EOF'
#!/bin/zsh
"$HOME/qrscan-env/bin/python" "$HOME/leer_qr.py" "$@"
EOF

chmod +x ~/bin/qrscan

Añádelo al PATH:

 TERMINAL

echo 'export PATH="$HOME/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

5. Cómo usar QRSCAN

Una vez instalado, puedes leer códigos QR de cualquier archivo PDF, JPG o PNG simplemente usando el comando qrscan.

Ejemplo con PDF:

 TERMINAL

qrscan "/ruta/a/diseño.pdf"

Ejemplo con imagen:

 TERMINAL

qrscan "/ruta/a/imagen.png"

Ten en cuenta que el proceso puede tardar unos segundos, especialmente en PDFs con varias páginas. Una vez analizado el archivo, el comando mostrará en Terminal todos los enlaces detectados dentro de los códigos QR.

6. Acción rápida en Finder: clic derecho → “Leer QR”

Vamos a crear una Acción rápida (Quick Action) que te permitirá leer códigos QR directamente desde el menú contextual del Finder: seleccionas cualquier PDF, JPG o PNG → botón derecho → Acciones rápidas → Leer QR. Es la forma más cómoda de usar QRScan en tu día a día.

6.1 Configurar la Acción rápida en Automator

1. Abre Automator.
2. Pulsa Nuevo documento.
3. Selecciona Acción rápida.
4. Configura la parte superior así:
   • El flujo de trabajo recibe: archivos o carpetas
   • En: Finder.app
   • Imagen: Acción
   • Color: Negro
5. En la barra lateral izquierda, busca “Ejecutar script de shell” y arrástralo al flujo.
6. Configura:
   • Shell: /bin/zsh
   • Pasar datos de entrada: como argumentos

Pega este script final, 100% funcional para PDF multipágina, JPG y PNG:

 TERMINAL MAC

export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"

PY="$HOME/qrscan-env/bin/python3"

for f in "$@"
do
  RESULT=$("$PY" "$HOME/leer_qr.py" "$f" \
    | grep -v '^=== QR DETECTADOS ===' \
    | sed '/^[[:space:]]*$/d' \
    | head -n 1)

  if [ -z "$RESULT" ]; then
    osascript -e 'display dialog "No se detectó ningún QR en el archivo seleccionado." with title "QRScan" buttons {"OK"} default button 1'
  else
    printf "%s" "$RESULT" | pbcopy

    osascript -e '
      display dialog "El contenido del QR se ha copiado al portapapeles:" & return & return & (the clipboard as text) ¬
      with title "QRScan - enlace copiado" buttons {"OK"} default button 1
    '
  fi
done

Guarda la acción con el nombre Leer QR. Ahora aparecerá automáticamente en: clic derecho → Acciones rápidas → Leer QR.

Esta acción puede tardar unos segundos en mostrar el resultado, especialmente si el archivo es un PDF multipágina o contiene varios códigos QR.

Haz clic para ampliar la imagen — configuración correcta de la Acción rápida “Leer QR”.

7. Crear una app (.app) arrastrar-y-soltar

Si quieres tener un acceso rápido en tu Dock o Escritorio, puedes crear una aplicación llamada Leer QR.app para arrastrar archivos PDF/JPG/PNG encima y obtener el enlace del QR al instante.

7.1. Crear la aplicación en Automator

Abre Automator y selecciona Aplicación como tipo de documento:

1. Abre Automator en tu Mac.
2. Selecciona Nuevo documento.
3. Elige la opción Aplicación (muy importante).
4. En la biblioteca de acciones, busca “Ejecutar un script de shell” y arrástralo al flujo.
5. Configura así:
   • Shell: /bin/zsh
   • Pasar datos de entrada: como argumentos

Pega el siguiente script dentro del campo de Automator:

 AUTOMATOR (zsh)

for f in "$@"
do
  "$HOME/qrscan-env/bin/python" "$HOME/leer_qr.py" "$f"
done

Guarda la aplicación con el nombre Leer QR.app y colócala en Aplicaciones o en el Escritorio. Si quieres un acceso aún más rápido, arrástrala al Dock.

Ahora podrás arrastrar cualquier archivo PDF, JPG o PNG encima del icono de Leer QR.app. La app ejecutará el script y mostrará en Terminal el enlace del QR detectado.

8. Crear un Atajo de macOS (Shortcuts)

También puedes crear un atajo para leer códigos QR desde Spotlight, desde la barra de menús o incluso asignarle un atajo de teclado. Este método también usa el entorno virtual qrscan-env.

8.1. Crear un atajo que pide un archivo y lee el QR

1. Abre la app Atajos en tu Mac.
2. Crea un nuevo atajo llamado Leer QR (archivo).
3. Añade la acción “Seleccionar archivo”. Esta acción permite elegir un PDF, JPG o PNG.
4. Añade la acción “Ejecutar script de shell”. Configúrala así:
   • Shell: /bin/zsh
   • Entrada: archivo seleccionado

Pega este script dentro del bloque:

 ATAJOS (zsh)

PY="$HOME/qrscan-env/bin/python3"
"$PY" "$HOME/leer_qr.py" "$1"

Puedes añadir una acción final de Notificación para mostrar los enlaces QR o una acción para copiarlos al portapapeles. El proceso puede tardar unos segundos si el PDF es grande.

9. Resumen

Ya tienes un ecosistema completo para leer códigos QR en tu Mac:

• qrscan — comando rápido profesional.
• Acción rápida en Finder.
• App arrastrar-y-soltar.
• Atajo de macOS.