TL;DR#

Ejecuta múltiples instancias aisladas de Cursor (trabajo/personal) en macOS con dos funciones de shell: picursor() lanza una instancia separada de Cursor, y cursor-sync() mantiene ambas instancias actualizadas con la misma versión de la aplicación, configuraciones y extensiones. Aislamiento completo para cuentas, pero configuración consistente en todas partes.

Lo que obtienes:

  • Sesiones separadas de Cursor con diferentes cuentas
  • Auto-sincronización: mismas extensiones, configuraciones y atajos de teclado
  • Un comando para mantener todo actualizado
  • Configuración en 5 minutos

Requisitos#

Antes de comenzar, asegúrate de tener:

  • macOS (esta guía es específica para macOS)
  • Cursor IDE instalado en /Applications/Cursor.app
  • Shell Zsh (predeterminado en macOS moderno)
  • Conocimientos básicos de terminal (editar archivos de configuración del shell)
  • Acceso sudo (necesario para copiar la aplicación)
  • rsync (preinstalado en macOS)

El Problema: El Dilema de un Desarrollador#

Imagina esto: Eres un desarrollador que ama usar Cursor, el editor de código potenciado por IA. Lo usas para proyectos de trabajo durante el día, conectado con tu cuenta corporativa. Pero cuando llega la noche y quieres trabajar en proyectos personales, enfrentas una elección frustrante: cerrar sesión y volver a iniciar con tu cuenta personal, o comprometerte mezclando contextos de trabajo y personales.

Quizás hayas intentado cambiar entre cuentas manualmente. Tal vez hayas lidiado con la molestia de perder tu configuración, extensiones y personalizaciones cada vez que cambias. O quizás simplemente te hayas rendido y decidido mantener todo en una cuenta, sacrificando la separación limpia entre trabajo y vida personal.

Tenía que haber una mejor manera.

El Viaje a una Solución#

El avance vino de este artículo de Medium que exploraba ejecutar múltiples instancias de Cursor. Pero simplemente lanzar una instancia separada no era suficiente. El verdadero desafío era mantener ambas instancias actualizadas sin gestionar todo manualmente dos veces.

Después de algo de experimentación, desarrollé un enfoque de dos funciones que resuelve ambos problemas:

  1. picursor() - Lanzar una instancia personal de Cursor completamente aislada
  2. cursor-sync() - Mantener ambas instancias en perfecta sincronización

Déjame guiarte a través de cómo funciona cada pieza y por qué importa.

La Función de Lanzamiento: picursor()#

Primero, necesitamos una forma de lanzar una instancia separada de Cursor que no interfiera con la principal. Aquí está la función:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

picursor() {
  # Lanzar con aislamiento completo para prevenir compartir sesiones
  # Usar --new-window asegura que se abra en la instancia aislada correcta
  nohup "/Applications/Cursor-Personal.app/Contents/MacOS/Cursor" \
    --user-data-dir="$HOME/.cursor-personal" \
    --extensions-dir="$HOME/.cursor-personal/extensions" \
    --no-first-run \
    --new-window \
    --disable-dev-shm-usage \
    "$@" >/dev/null 2>&1 &
}

Desglosándolo#

Examinemos qué hace cada flag y por qué es necesario:

--user-data-dir="$HOME/.cursor-personal"

Este es el corazón del aislamiento. Al especificar un directorio de datos de usuario separado, nos aseguramos de que todas las configuraciones, preferencias, sesiones de inicio y caché se almacenen completamente separadas de la instancia principal de Cursor. Tus cuentas de trabajo y personales nunca se cruzan.

--extensions-dir="$HOME/.cursor-personal/extensions"

Las extensiones también se almacenan por separado. Esto significa que técnicamente podrías tener diferentes extensiones en cada instancia, aunque luego las sincronizaremos para mantener las cosas consistentes.

--no-first-run

Omite la pantalla de bienvenida y el asistente de configuración inicial. Como estamos sincronizando configuraciones desde la instancia principal, no necesitamos pasar por la configuración nuevamente.

--new-window

Fuerza a la aplicación a abrir una nueva ventana en la instancia aislada en lugar de potencialmente abrir en una ventana existente de la instancia principal de Cursor.

--disable-dev-shm-usage

Un flag de gestión de memoria que previene problemas con memoria compartida, particularmente útil al ejecutar múltiples aplicaciones basadas en Electron.

nohup ... >/dev/null 2>&1 &

Esta técnica de shell hace tres cosas:

  • nohup - Mantiene el proceso ejecutándose incluso si cierras la terminal
  • >/dev/null 2>&1 - Redirige la salida y errores a /dev/null (mantiene tu terminal limpia)
  • & - Ejecuta el proceso en segundo plano

Usando picursor()#

Una vez que esta función está en tu ~/.zshrc, usarla es simple:

1
2
3
4
5
6
7
8

# Abrir Cursor-Personal en el directorio actual
picursor .

# Abrir un proyecto específico
picursor ~/Projects/mi-proyecto-personal

# Simplemente lanzarlo
picursor

La Función de Sincronización: cursor-sync()#

Lanzar una instancia separada resuelve el problema del aislamiento, pero ahora tienes un nuevo desafío: mantener ambas instancias actualizadas y sincronizadas. Cuando tu Cursor principal se actualiza a una nueva versión, tu instancia personal se queda atrás. Cuando instalas una extensión útil o ajustas tus atajos de teclado, no se transfieren.

Entra cursor-sync() - una solución de sincronización integral que maneja tres aspectos críticos:

Función Completa#

Aquí está la función completa (la desglosaremos pieza por pieza a continuación):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

cursor-sync() {
  local main_app="/Applications/Cursor.app"
  local personal_app="/Applications/Cursor-Personal.app"
  local main_config="$HOME/Library/Application Support/Cursor"
  local personal_config="$HOME/.cursor-personal"

  echo "=== Cursor Sync ==="
  echo ""

  # Verificar si existe el Cursor principal
  if [ ! -d "$main_app" ]; then
    echo "❌ Cursor.app principal no encontrado en $main_app"
    return 1
  fi

  # Paso 1: Verificar y actualizar la versión de la aplicación
  local main_version=$(defaults read "$main_app/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)
  local personal_version=$(defaults read "$personal_app/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)

  echo "📦 Versiones de la Aplicación:"
  echo "   Cursor Principal: v$main_version"
  echo "   Cursor-Personal: v$personal_version"
  echo ""

  if [ "$main_version" != "$personal_version" ]; then
    echo "🔄 Actualizando Cursor-Personal a v$main_version..."

    # Terminar cualquier instancia en ejecución
    pkill -f "Cursor-Personal.app" 2>/dev/null
    sleep 2

    # Eliminar versión antigua (necesita sudo ya que es propiedad de root)
    sudo rm -rf "$personal_app"

    # Copiar nueva versión
    sudo cp -R "$main_app" "$personal_app"

    # Arreglar propiedad
    sudo chown -R $(whoami):staff "$personal_app"

    echo "✓ Aplicación actualizada a v$main_version"
    echo ""
  else
    echo "✓ La versión de la aplicación está actualizada"
    echo ""
  fi

  # Paso 2: Sincronizar configuraciones y extensiones
  echo "⚙️  Sincronizando configuraciones y extensiones..."

  # Crear respaldo
  if [ -d "$personal_config/User" ]; then
    cp -r "$personal_config/User" "$personal_config/User.backup.$(date +%Y%m%d_%H%M%S)" 2>/dev/null
  fi

  # Sincronizar configuraciones de Usuario (atajos de teclado, settings.json, snippets, etc.)
  mkdir -p "$personal_config/User"
  if [ -d "$main_config/User" ]; then
    rsync -av --exclude='globalStorage' --exclude='workspaceStorage' --exclude='History' \
      "$main_config/User/" "$personal_config/User/" 2>&1 | grep -v "sending incremental" | grep -v "sent.*received" | grep -v "total size"
  fi

  # Sincronizar extensiones
  if [ -d "$main_config/extensions" ]; then
    mkdir -p "$personal_config/extensions"
    rsync -av "$main_config/extensions/" "$personal_config/extensions/" 2>&1 | grep -v "sending incremental" | grep -v "sent.*received" | grep -v "total size"
  fi

  echo ""
  echo "✓ Sincronización completa! Cursor-Personal está ahora totalmente actualizado."
  echo "💡 Ejecuta 'picursor' para lanzar con todas las últimas características."
}

1. Sincronización de Versión de la Aplicación# 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Verificar versiones
local main_version=$(defaults read "$main_app/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)
local personal_version=$(defaults read "$personal_app/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)

if [ "$main_version" != "$personal_version" ]; then
  echo "🔄 Actualizando Cursor-Personal a v$main_version..."

  # Terminar instancias en ejecución
  pkill -f "Cursor-Personal.app" 2>/dev/null
  sleep 2

  # Eliminar versión antigua y copiar nueva
  sudo rm -rf "$personal_app"
  sudo cp -R "$main_app" "$personal_app"
  sudo chown -R $(whoami):staff "$personal_app"
fi

La función compara números de versión entre tu Cursor principal y Cursor-Personal. Cuando difieren:

  1. Detiene graciosamente cualquier instancia de Cursor-Personal en ejecución
  2. Elimina el Cursor-Personal.app desactualizado
  3. Copia la aplicación actualizada completa desde el Cursor principal
  4. Arregla la propiedad para que puedas ejecutarla sin problemas de permisos

Nota los requisitos de sudo - los archivos de aplicación en /Applications/ típicamente son propiedad de root, así que necesitamos privilegios elevados para modificarlos.

2. Sincronización de Configuraciones# 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Crear respaldo de seguridad
if [ -d "$personal_config/User" ]; then
  cp -r "$personal_config/User" "$personal_config/User.backup.$(date +%Y%m%d_%H%M%S)" 2>/dev/null
fi

# Sincronizar configuraciones de Usuario
mkdir -p "$personal_config/User"
if [ -d "$main_config/User" ]; then
  rsync -av --exclude='globalStorage' --exclude='workspaceStorage' --exclude='History' \
    "$main_config/User/" "$personal_config/User/"
fi

Esta sección sincroniza todas tus configuraciones siendo inteligente sobre qué excluir:

Lo que se Sincroniza:

  • settings.json - Todas tus preferencias del editor
  • keybindings.json - Atajos de teclado personalizados
  • snippets/ - Fragmentos de código que has creado
  • Preferencias de tema
  • Preferencias de estado de UI

Lo que se Excluye:

  • globalStorage - Contiene datos específicos de la instancia y tokens
  • workspaceStorage - Configuraciones y estado específicos del proyecto
  • History - Archivos recientemente abiertos e historial de búsqueda

¿Por qué excluir estos? Porque son específicos de la instancia. No quieres que tus proyectos de trabajo aparezcan en los archivos recientes de Cursor personal, y definitivamente no quieres compartir tokens de autenticación entre instancias.

3. Sincronización de Extensiones# 

1
2
3
4

if [ -d "$main_config/extensions" ]; then
  mkdir -p "$personal_config/extensions"
  rsync -av "$main_config/extensions/" "$personal_config/extensions/"
fi

Esto asegura que cada extensión instalada en tu Cursor principal esté disponible en Cursor-Personal. Instala ESLint, Prettier o cualquier otra extensión una vez, y aparece en ambas instancias.

Seguridad Primero: Respaldos Automáticos#

Nota esta línea:

1

cp -r "$personal_config/User" "$personal_config/User.backup.$(date +%Y%m%d_%H%M%S)" 2>/dev/null

Antes de cada sincronización, la función crea un respaldo con marca de tiempo de la carpeta User de tu instancia personal. Si algo sale mal, puedes restaurar desde User.backup.20260114_143022 o cualquier marca de tiempo que se haya creado.

Configurándolo Todo#

¿Listo para implementar esto en tu propio flujo de trabajo? Aquí está cómo:

Paso 1: Agregar Funciones a tu Shell#

Abre tu archivo ~/.zshrc:

1
2
3

nano ~/.zshrc
# o
vim ~/.zshrc

Agrega ambas funciones picursor() y cursor-sync() al final del archivo. Copia las funciones completas de antes en esta publicación:

  • La función picursor() (de la sección “La Función de Lanzamiento”)
  • La función cursor-sync() (de la sección “La Función de Sincronización”)

Paso 2: Recargar tu Shell# 

1

source ~/.zshrc

Paso 3: Configuración Inicial#

Ejecuta la función de sincronización para crear tu instancia Cursor-Personal:

1

cursor-sync

Esto:

  • Copiará Cursor.app a Cursor-Personal.app
  • Creará el directorio ~/.cursor-personal
  • Sincronizará todas tus configuraciones y extensiones

Necesitarás ingresar tu contraseña cuando se te solicite (para los comandos sudo).

Paso 4: Lanzar tu Instancia Personal# 

1
2

# Reemplaza con la ruta real de tu proyecto
picursor ~/Projects/mi-proyecto-personal

La primera vez que lances, necesitarás iniciar sesión con tu cuenta personal de Cursor. Después de eso, ambas instancias mantienen sesiones separadas.

Nota: Reemplaza ~/Projects/mi-proyecto-personal con la ruta real al directorio de tu proyecto.

El Flujo de Trabajo Diario#

Una vez configurado, tu flujo de trabajo se vuelve bellamente simple:

Para proyectos de trabajo:

1
2
3

# Solo usa Cursor normalmente
cursor .
# o ábrelo desde tu dock/aplicaciones

Para proyectos personales:

1

picursor ~/Projects/proyecto-personal

Después de actualizaciones o instalar nuevas extensiones:

1

cursor-sync

Ejecuta cursor-sync cuando:

  • Tu Cursor principal se actualiza a una nueva versión
  • Instalas una nueva extensión que quieres en ambas instancias
  • Modificas configuraciones o atajos de teclado
  • Quieres asegurar que ambas instancias sean idénticas

Los Beneficios#

Después de usar esta configuración por un tiempo, varias ventajas se volvieron claras:

Aislamiento Completo: Las cuentas de trabajo y personales nunca interactúan. Diferentes sesiones de inicio, diferentes archivos recientes, diferentes configuraciones de espacio de trabajo.

Experiencia Consistente: Ambas instancias tienen las mismas extensiones, atajos de teclado y configuraciones. La memoria muscular funciona igual en todas partes.

Mantenimiento Fácil: Un comando (cursor-sync) mantiene todo actualizado. Sin copiado manual, sin olvidar qué extensiones has instalado dónde.

Experimentación Segura: ¿Quieres probar una nueva extensión o configuración en tu instancia personal primero? Adelante - tú controlas qué se sincroniza y cuándo.

Cero Sobrecarga de Cambio de Contexto: Sin iniciar y cerrar sesión, sin verificar qué cuenta estás usando, sin momentos de “ups, cuenta equivocada”.

Consejos y Mejores Prácticas#

Sincroniza Después de Cada Actualización: Adquiere el hábito de ejecutar cursor-sync cuando veas que Cursor se ha actualizado. Toma segundos y asegura que no olvidarás.

Marca tus Comandos de Proyecto: Agrega alias para tus proyectos comunes:

1
2
3

# Agregar estos a tu ~/.zshrc
alias proyectotrabajo="cursor ~/Work/proyecto-empresa"
alias proyectopersonal="picursor ~/Projects/proyecto-personal"

Reemplaza las rutas con los directorios reales de tus proyectos.

Verifica Números de Versión: La función de sincronización muestra números de versión. Si difieren significativamente, podrías querer sincronizar antes de comenzar a trabajar.

Entiende Qué se Comparte: Recuerda que las extensiones y configuraciones se sincronizan automáticamente, pero el historial del proyecto, archivos abiertos y autenticación no. Eso es por diseño.

Conclusión#

Gestionar múltiples instancias de Cursor no tiene que ser doloroso. Con estas dos funciones, obtienes lo mejor de ambos mundos: aislamiento completo entre contextos de trabajo y personales, con sincronización sin esfuerzo de las cosas que deberían compartirse.

La configuración toma cinco minutos. Los beneficios duran para siempre.

Ahora, en lugar de elegir entre conveniencia y separación, tienes ambas. Tus proyectos de trabajo permanecen en tu instancia de trabajo, tus proyectos personales en tu instancia personal, y tu productividad permanece alta en ambos.

Algún error o sugerencia? No dudes en contactarme en nte111da@gmail.com.