Como mostrar no Slack a música que você está ouvindo no Spotify

Às vezes, uma pequena curiosidade técnica termina em uma automação divertida.

Eu queria descobrir se existia uma forma de mostrar no meu perfil do Slack a música que estava ouvindo no Spotify, semelhante ao recurso de atividade musical presente em outras plataformas.

Depois de vasculhar algumas opções na internet, encontrei soluções comerciais que faziam algo parecido. Porém, também encontrei um pequeno projeto open source no GitHub chamado Spotify Slack Status, criado por Tomas Hubelbauer.

O projeto tem uma proposta simples: consultar a música que está sendo reproduzida no aplicativo do Spotify no macOS e usar a API do Slack para colocar o artista e o nome da faixa no status do usuário.  

O resultado ficou assim:

🎧 Rick & Renner - Fim de semana

🎧 Rick & Renner - Fim de semana

🎧 Rick & Renner - Fim de semana

Sim, o primeiro teste acabou sendo com Rick & Renner.

Como a integração funciona

O projeto é essencialmente um script Shell executado localmente no Mac.

A cada intervalo de aproximadamente dez segundos, ele realiza o seguinte fluxo:

1. Verifica qual é o status atual do usuário no Slack.

2. Confirma se o Spotify está aberto.

3. Consulta o estado do player.

4. Identifica o artista e o nome da música.

5. Atualiza o perfil do Slack usando sua API.

6. Define uma expiração curta para evitar que uma música antiga permaneça no perfil.

O script usa o AppleScript do macOS para conversar com o Spotify:

osascript -e 'tell application "Spotify" to artist of current track'

osascript -e 'tell application "Spotify" to artist of current track'

osascript -e 'tell application "Spotify" to artist of current track'

E utiliza o método users.profile.set da API do Slack para atualizar o status. A permissão users.profile:write permite editar as informações e o status do perfil do usuário.  

Uma proteção importante do projeto

O script não substitui indiscriminadamente qualquer status existente.

Antes de atualizar a música, ele consulta o status atual usando a permissão:

users.profile:read

users.profile:read

users.profile:read

Ele somente modifica o perfil quando:

O status está vazio

O status está vazio

O status está vazio

ou quando o emoji atual é:

:headphones:

:headphones:

:headphones:

Isso significa que um status manual como:

🏡 Trabalhando de casa

🏡 Trabalhando de casa

🏡 Trabalhando de casa

não será removido pelo script.

Durante o primeiro teste, inclusive, o Terminal começou a retornar:

Status atual do Slack é :house_with_garden:. Aguardando 10 segundos

Status atual do Slack é :house_with_garden:. Aguardando 10 segundos

Status atual do Slack é :house_with_garden:. Aguardando 10 segundos

Depois que limpei o status manual, a música apareceu normalmente.

Esse comportamento é previsto pelo próprio projeto e evita que a automação apague avisos mais importantes, como reunião, férias, almoço ou ausência temporária.  

O que foi necessário instalar

A implementação foi feita no macOS e utilizou:

Spotify para macOS
Slack
Homebrew
jq
Git
Terminal

Spotify para macOS
Slack
Homebrew
jq
Git
Terminal

Spotify para macOS
Slack
Homebrew
jq
Git
Terminal

O jq é usado para interpretar e montar os objetos JSON enviados e recebidos pela API do Slack.

A instalação foi feita com:

brew install jq

brew install jq

brew install jq

Depois, criamos um aplicativo personalizado dentro do workspace do Slack.

Configurando o aplicativo no Slack

No painel de desenvolvimento do Slack, criamos um novo aplicativo do tipo From scratch.

Dentro de:

OAuth & Permissions

OAuth & Permissions

OAuth & Permissions

foram adicionados os seguintes User Token Scopes:

users.profile:read
users.profile:write

users.profile:read
users.profile:write

users.profile:read
users.profile:write

É importante usar escopos de usuário e não escopos de bot.

Essa integração atua em nome do próprio usuário autenticado, portanto utiliza um User OAuth Token, normalmente iniciado por:

xoxp

xoxp

xoxp

Depois de instalar o aplicativo no workspace, o Slack gera esse token.

Ele é salvo localmente em um arquivo chamado:

slack.pat

slack.pat

slack.pat

Esse arquivo nunca deve ser enviado ao GitHub, incluído em commits, compartilhado em prints ou armazenado em locais públicos.

Para limitar o acesso local ao arquivo, usamos:

chmod 600 slack.pat

chmod 600 slack.pat

chmod 600 slack.pat

Isso mantém a leitura e a edição restritas ao proprietário do arquivo.

Baixando o projeto

O projeto original está disponível no GitHub:

github.com/TomasHubelbauer/spotify-slack-status

github.com/TomasHubelbauer/spotify-slack-status

github.com/TomasHubelbauer/spotify-slack-status

O repositório é bastante minimalista. Atualmente, ele contém essencialmente um README com o código e as instruções da implementação.  

Criamos uma pasta local:

mkdir -p ~/spotify-slack-status
cd ~/spotify-slack-status

mkdir -p ~/spotify-slack-status
cd ~/spotify-slack-status

mkdir -p ~/spotify-slack-status
cd ~/spotify-slack-status

Depois inicializamos o Git e buscamos o conteúdo do repositório:

git init
git remote add origin https://github.com/TomasHubelbauer/spotify-slack-status.git
git fetch origin
git checkout -t origin/main

git init
git remote add origin https://github.com/TomasHubelbauer/spotify-slack-status.git
git fetch origin
git checkout -t origin/main

git init
git remote add origin https://github.com/TomasHubelbauer/spotify-slack-status.git
git fetch origin
git checkout -t origin/main

Como o script estava documentado no README, criamos manualmente o arquivo:

nano spotify-slack-status.sh

nano spotify-slack-status.sh

nano spotify-slack-status.sh

Após inserir o código, tornamos o arquivo executável:

chmod +x spotify-slack-status.sh

chmod +x spotify-slack-status.sh

chmod +x spotify-slack-status.sh

Criando o script

O repositório original utiliza um script Shell para consultar o Spotify e atualizar o status do Slack.

Na pasta do projeto, criamos o arquivo:

nano spotify-slack-status.sh

nano spotify-slack-status.sh

nano spotify-slack-status.sh

Dentro dele, inserimos o código abaixo:

#!/bin/bash

DIR="$(cd "$(dirname "$0")" && pwd)"
TOKEN_FILE="$DIR/slack.pat"
DELAY=10

if ! command -v jq >/dev/null 2>&1; then
  echo "Erro: jq não está instalado."
  echo "Instale com: brew install jq"
  exit 1
fi

if [ ! -f "$TOKEN_FILE" ]; then
  echo "Erro: arquivo slack.pat não encontrado em:"
  echo "$TOKEN_FILE"
  exit 1
fi

TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"

if [ -z "$TOKEN" ]; then
  echo "Erro: o arquivo slack.pat está vazio."
  exit 1
fi

echo "Spotify Slack Status iniciado."
echo "Pressione Control + C para encerrar."

while true; do
  PROFILE_RESPONSE="$(
    curl \
      --silent \
      --show-error \
      --header "Authorization: Bearer $TOKEN" \
      "https://slack.com/api/users.profile.get"
  )"

  PROFILE_OK="$(echo "$PROFILE_RESPONSE" | jq -r '.ok // false')"

  if [ "$PROFILE_OK" != "true" ]; then
    PROFILE_ERROR="$(echo "$PROFILE_RESPONSE" | jq -r '.error // "erro desconhecido"')"
    echo "Erro ao consultar o Slack: $PROFILE_ERROR"

    sleep "$DELAY"
    continue
  fi

  EMOJI="$(echo "$PROFILE_RESPONSE" | jq -r '.profile.status_emoji // ""')"

  if [ -n "$EMOJI" ] && [ "$EMOJI" != ":headphones:" ]; then
    echo "Status manual encontrado: $EMOJI. Nenhuma alteração será feita."

    sleep "$DELAY"
    continue
  fi

  if ! pgrep -x "Spotify" >/dev/null 2>&1; then
    echo "Spotify não está aberto."

    sleep "$DELAY"
    continue
  fi

  STATE="$(
    osascript \
      -e 'tell application "Spotify" to player state' \
      2>/dev/null
  )"

  if [ "$STATE" != "playing" ]; then
    echo "Spotify está aberto, mas nenhuma música está tocando."

    sleep "$DELAY"
    continue
  fi

  ARTIST="$(
    osascript \
      -e 'tell application "Spotify" to artist of current track' \
      2>/dev/null
  )"

  SONG="$(
    osascript \
      -e 'tell application "Spotify" to name of current track' \
      2>/dev/null
  )"

  STATUS_TEXT="$ARTIST - $SONG"
  EXPIRATION="$(date -v+1M +%s)"

  REQUEST_JSON="$(
    jq -n \
      --arg text "$STATUS_TEXT" \
      --arg emoji ":headphones:" \
      --argjson expiration "$EXPIRATION" \
      '{
        profile: {
          status_text: $text,
          status_emoji: $emoji,
          status_expiration: $expiration
        }
      }'
  )"

  UPDATE_RESPONSE="$(
    curl \
      --silent \
      --show-error \
      --request POST \
      --header "Authorization: Bearer $TOKEN" \
      --header "Content-Type: application/json; charset=utf-8" \
      --data "$REQUEST_JSON" \
      "https://slack.com/api/users.profile.set"
  )"

  UPDATE_OK="$(echo "$UPDATE_RESPONSE" | jq -r '.ok // false')"

  if [ "$UPDATE_OK" = "true" ]; then
    echo "$(date '+%Y-%m-%d %H:%M:%S') | $STATUS_TEXT"
  else
    UPDATE_ERROR="$(echo "$UPDATE_RESPONSE" | jq -r '.error // "erro desconhecido"')"
    echo "Erro ao atualizar o Slack: $UPDATE_ERROR"
  fi

  sleep "$DELAY"
done

#!/bin/bash

DIR="$(cd "$(dirname "$0")" && pwd)"
TOKEN_FILE="$DIR/slack.pat"
DELAY=10

if ! command -v jq >/dev/null 2>&1; then
  echo "Erro: jq não está instalado."
  echo "Instale com: brew install jq"
  exit 1
fi

if [ ! -f "$TOKEN_FILE" ]; then
  echo "Erro: arquivo slack.pat não encontrado em:"
  echo "$TOKEN_FILE"
  exit 1
fi

TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"

if [ -z "$TOKEN" ]; then
  echo "Erro: o arquivo slack.pat está vazio."
  exit 1
fi

echo "Spotify Slack Status iniciado."
echo "Pressione Control + C para encerrar."

while true; do
  PROFILE_RESPONSE="$(
    curl \
      --silent \
      --show-error \
      --header "Authorization: Bearer $TOKEN" \
      "https://slack.com/api/users.profile.get"
  )"

  PROFILE_OK="$(echo "$PROFILE_RESPONSE" | jq -r '.ok // false')"

  if [ "$PROFILE_OK" != "true" ]; then
    PROFILE_ERROR="$(echo "$PROFILE_RESPONSE" | jq -r '.error // "erro desconhecido"')"
    echo "Erro ao consultar o Slack: $PROFILE_ERROR"

    sleep "$DELAY"
    continue
  fi

  EMOJI="$(echo "$PROFILE_RESPONSE" | jq -r '.profile.status_emoji // ""')"

  if [ -n "$EMOJI" ] && [ "$EMOJI" != ":headphones:" ]; then
    echo "Status manual encontrado: $EMOJI. Nenhuma alteração será feita."

    sleep "$DELAY"
    continue
  fi

  if ! pgrep -x "Spotify" >/dev/null 2>&1; then
    echo "Spotify não está aberto."

    sleep "$DELAY"
    continue
  fi

  STATE="$(
    osascript \
      -e 'tell application "Spotify" to player state' \
      2>/dev/null
  )"

  if [ "$STATE" != "playing" ]; then
    echo "Spotify está aberto, mas nenhuma música está tocando."

    sleep "$DELAY"
    continue
  fi

  ARTIST="$(
    osascript \
      -e 'tell application "Spotify" to artist of current track' \
      2>/dev/null
  )"

  SONG="$(
    osascript \
      -e 'tell application "Spotify" to name of current track' \
      2>/dev/null
  )"

  STATUS_TEXT="$ARTIST - $SONG"
  EXPIRATION="$(date -v+1M +%s)"

  REQUEST_JSON="$(
    jq -n \
      --arg text "$STATUS_TEXT" \
      --arg emoji ":headphones:" \
      --argjson expiration "$EXPIRATION" \
      '{
        profile: {
          status_text: $text,
          status_emoji: $emoji,
          status_expiration: $expiration
        }
      }'
  )"

  UPDATE_RESPONSE="$(
    curl \
      --silent \
      --show-error \
      --request POST \
      --header "Authorization: Bearer $TOKEN" \
      --header "Content-Type: application/json; charset=utf-8" \
      --data "$REQUEST_JSON" \
      "https://slack.com/api/users.profile.set"
  )"

  UPDATE_OK="$(echo "$UPDATE_RESPONSE" | jq -r '.ok // false')"

  if [ "$UPDATE_OK" = "true" ]; then
    echo "$(date '+%Y-%m-%d %H:%M:%S') | $STATUS_TEXT"
  else
    UPDATE_ERROR="$(echo "$UPDATE_RESPONSE" | jq -r '.error // "erro desconhecido"')"
    echo "Erro ao atualizar o Slack: $UPDATE_ERROR"
  fi

  sleep "$DELAY"
done

#!/bin/bash

DIR="$(cd "$(dirname "$0")" && pwd)"
TOKEN_FILE="$DIR/slack.pat"
DELAY=10

if ! command -v jq >/dev/null 2>&1; then
  echo "Erro: jq não está instalado."
  echo "Instale com: brew install jq"
  exit 1
fi

if [ ! -f "$TOKEN_FILE" ]; then
  echo "Erro: arquivo slack.pat não encontrado em:"
  echo "$TOKEN_FILE"
  exit 1
fi

TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"

if [ -z "$TOKEN" ]; then
  echo "Erro: o arquivo slack.pat está vazio."
  exit 1
fi

echo "Spotify Slack Status iniciado."
echo "Pressione Control + C para encerrar."

while true; do
  PROFILE_RESPONSE="$(
    curl \
      --silent \
      --show-error \
      --header "Authorization: Bearer $TOKEN" \
      "https://slack.com/api/users.profile.get"
  )"

  PROFILE_OK="$(echo "$PROFILE_RESPONSE" | jq -r '.ok // false')"

  if [ "$PROFILE_OK" != "true" ]; then
    PROFILE_ERROR="$(echo "$PROFILE_RESPONSE" | jq -r '.error // "erro desconhecido"')"
    echo "Erro ao consultar o Slack: $PROFILE_ERROR"

    sleep "$DELAY"
    continue
  fi

  EMOJI="$(echo "$PROFILE_RESPONSE" | jq -r '.profile.status_emoji // ""')"

  if [ -n "$EMOJI" ] && [ "$EMOJI" != ":headphones:" ]; then
    echo "Status manual encontrado: $EMOJI. Nenhuma alteração será feita."

    sleep "$DELAY"
    continue
  fi

  if ! pgrep -x "Spotify" >/dev/null 2>&1; then
    echo "Spotify não está aberto."

    sleep "$DELAY"
    continue
  fi

  STATE="$(
    osascript \
      -e 'tell application "Spotify" to player state' \
      2>/dev/null
  )"

  if [ "$STATE" != "playing" ]; then
    echo "Spotify está aberto, mas nenhuma música está tocando."

    sleep "$DELAY"
    continue
  fi

  ARTIST="$(
    osascript \
      -e 'tell application "Spotify" to artist of current track' \
      2>/dev/null
  )"

  SONG="$(
    osascript \
      -e 'tell application "Spotify" to name of current track' \
      2>/dev/null
  )"

  STATUS_TEXT="$ARTIST - $SONG"
  EXPIRATION="$(date -v+1M +%s)"

  REQUEST_JSON="$(
    jq -n \
      --arg text "$STATUS_TEXT" \
      --arg emoji ":headphones:" \
      --argjson expiration "$EXPIRATION" \
      '{
        profile: {
          status_text: $text,
          status_emoji: $emoji,
          status_expiration: $expiration
        }
      }'
  )"

  UPDATE_RESPONSE="$(
    curl \
      --silent \
      --show-error \
      --request POST \
      --header "Authorization: Bearer $TOKEN" \
      --header "Content-Type: application/json; charset=utf-8" \
      --data "$REQUEST_JSON" \
      "https://slack.com/api/users.profile.set"
  )"

  UPDATE_OK="$(echo "$UPDATE_RESPONSE" | jq -r '.ok // false')"

  if [ "$UPDATE_OK" = "true" ]; then
    echo "$(date '+%Y-%m-%d %H:%M:%S') | $STATUS_TEXT"
  else
    UPDATE_ERROR="$(echo "$UPDATE_RESPONSE" | jq -r '.error // "erro desconhecido"')"
    echo "Erro ao atualizar o Slack: $UPDATE_ERROR"
  fi

  sleep "$DELAY"
done

Depois, salvamos o arquivo no nano:

Control + O
Enter
Control + X

Control + O
Enter
Control + X

Control + O
Enter
Control + X

Em seguida, tornamos o script executável:

chmod +x spotify-slack-status.sh

chmod +x spotify-slack-status.sh

chmod +x spotify-slack-status.sh

O que o código faz

O script começa identificando a pasta em que está instalado:

DIR="$(cd "$(dirname "$0")" && pwd)"

DIR="$(cd "$(dirname "$0")" && pwd)"

DIR="$(cd "$(dirname "$0")" && pwd)"

Isso permite localizar o arquivo slack.pat mesmo quando o comando é iniciado a partir de outro diretório.

O token do Slack é carregado com:

TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"

TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"

TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"

O comando tr remove possíveis quebras de linha inseridas ao salvar o arquivo.

Depois, o script consulta o perfil atual no Slack:

curl \
  --header "Authorization: Bearer $TOKEN" \
  "https://slack.com/api/users.profile.get"

curl \
  --header "Authorization: Bearer $TOKEN" \
  "https://slack.com/api/users.profile.get"

curl \
  --header "Authorization: Bearer $TOKEN" \
  "https://slack.com/api/users.profile.get"

O retorno é processado pelo jq para verificar se a requisição foi aceita e qual é o emoji do status atual.

A proteção contra substituição de status manual está nesta condição:

if [ -n "$EMOJI" ] && [ "$EMOJI" != ":headphones:" ]; then
  echo "Status manual encontrado: $EMOJI. Nenhuma alteração será feita."

  sleep "$DELAY"
  continue
fi

if [ -n "$EMOJI" ] && [ "$EMOJI" != ":headphones:" ]; then
  echo "Status manual encontrado: $EMOJI. Nenhuma alteração será feita."

  sleep "$DELAY"
  continue
fi

if [ -n "$EMOJI" ] && [ "$EMOJI" != ":headphones:" ]; then
  echo "Status manual encontrado: $EMOJI. Nenhuma alteração será feita."

  sleep "$DELAY"
  continue
fi

Portanto, se o usuário estiver com um status como:

🏡 Trabalhando de casa

🏡 Trabalhando de casa

🏡 Trabalhando de casa

o script não substitui esse status pela música.

Depois, ele verifica se o Spotify está aberto:

pgrep -x "Spotify"

pgrep -x "Spotify"

pgrep -x "Spotify"

O estado do player é consultado por AppleScript:

osascript -e 'tell application "Spotify" to player state'

osascript -e 'tell application "Spotify" to player state'

osascript -e 'tell application "Spotify" to player state'

Quando há uma faixa tocando, o artista e o título são obtidos com:

osascript -e 'tell application "Spotify" to artist of current track'
osascript -e 'tell application "Spotify" to name of current track'

osascript -e 'tell application "Spotify" to artist of current track'
osascript -e 'tell application "Spotify" to name of current track'

osascript -e 'tell application "Spotify" to artist of current track'
osascript -e 'tell application "Spotify" to name of current track'

O status enviado ao Slack segue este formato:

Artista - Música

Artista - Música

Artista - Música

O JSON da requisição é montado pelo jq:

jq -n \
  --arg text "$STATUS_TEXT" \
  --arg emoji ":headphones:" \
  --argjson expiration "$EXPIRATION" \
  '{
    profile: {
      status_text: $text,
      status_emoji: $emoji,
      status_expiration: $expiration
    }
  }'

jq -n \
  --arg text "$STATUS_TEXT" \
  --arg emoji ":headphones:" \
  --argjson expiration "$EXPIRATION" \
  '{
    profile: {
      status_text: $text,
      status_emoji: $emoji,
      status_expiration: $expiration
    }
  }'

jq -n \
  --arg text "$STATUS_TEXT" \
  --arg emoji ":headphones:" \
  --argjson expiration "$EXPIRATION" \
  '{
    profile: {
      status_text: $text,
      status_emoji: $emoji,
      status_expiration: $expiration
    }
  }'

Finalmente, o status é atualizado pelo método users.profile.set:

curl \
  --request POST \
  --header "Authorization: Bearer $TOKEN" \
  --header "Content-Type: application/json; charset=utf-8" \
  --data "$REQUEST_JSON" \
  "https://slack.com/api/users.profile.set"

curl \
  --request POST \
  --header "Authorization: Bearer $TOKEN" \
  --header "Content-Type: application/json; charset=utf-8" \
  --data "$REQUEST_JSON" \
  "https://slack.com/api/users.profile.set"

curl \
  --request POST \
  --header "Authorization: Bearer $TOKEN" \
  --header "Content-Type: application/json; charset=utf-8" \
  --data "$REQUEST_JSON" \
  "https://slack.com/api/users.profile.set"

O código configura uma expiração de aproximadamente um minuto. Como o processo atualiza o status periodicamente enquanto a música está tocando, ele permanece ativo. Se o script for encerrado, o status musical desaparece depois da expiração, evitando que uma faixa antiga continue aparecendo indefinidamente.

Protegendo o token do Slack

Também vale adicionar uma seção antes do código explicando o .gitignore.

Crie o arquivo:

nano .gitignore

nano .gitignore

nano .gitignore

Adicione:

slack.pat
.env
*.log

slack.pat
.env
*.log

slack.pat
.env
*.log

Depois, confirme que o token não será versionado:

git status

git status

git status

O arquivo slack.pat não deve aparecer entre os arquivos que serão adicionados ao commit.

Além disso, mantenha as permissões locais restritas:

chmod 600 slack.pat

chmod 600 slack.pat

chmod 600 slack.pat

Assim o post fica realmente reproduzível, porque entrega não apenas a explicação, mas também o script completo utilizado no teste.

Executando a integração

Para iniciar o compartilhamento da música, basta executar:

cd ~/spotify-slack-status
./spotify-slack-status.sh

cd ~/spotify-slack-status
./spotify-slack-status.sh

cd ~/spotify-slack-status
./spotify-slack-status.sh

Enquanto o processo estiver rodando, o Terminal acompanha o Spotify e atualiza o Slack.

Quando a API aceita a alteração, o retorno é semelhante a:

2026-07-22T10:48:00-03:00 | Rick & Renner - Fim de semana | true

2026-07-22T10:48:00-03:00 | Rick & Renner - Fim de semana | true

2026-07-22T10:48:00-03:00 | Rick & Renner - Fim de semana | true

O valor true indica que o Slack aceitou a atualização.

Para encerrar o processo:

Control + C

Control + C

Control + C

No meu caso, preferi manter a execução manual por enquanto. Quando quero compartilhar o que estou ouvindo, abro o Terminal e inicio o script.

O que ainda pode ser melhorado

Embora o projeto funcione, ele é uma implementação simples e pode evoluir bastante.

Iniciar automaticamente com o macOS

É possível configurar um LaunchAgent para iniciar o script automaticamente após o login.

Com isso, o fluxo seria:

Ligar o Mac
Abrir o Spotify
Reproduzir uma música
Atualizar o Slack automaticamente

Ligar o Mac
Abrir o Spotify
Reproduzir uma música
Atualizar o Slack automaticamente

Ligar o Mac
Abrir o Spotify
Reproduzir uma música
Atualizar o Slack automaticamente

Nesse cenário, não seria necessário abrir o Terminal manualmente.

Atualizar somente quando a música mudar

Atualmente, o script consulta o estado periodicamente e pode repetir chamadas mesmo quando a música continua igual.

Uma versão otimizada poderia manter em memória a última faixa enviada:

Última música enviada:
Metallica - One

Música atual:
Metallica - One

Resultado:
Nenhuma atualização necessária

Última música enviada:
Metallica - One

Música atual:
Metallica - One

Resultado:
Nenhuma atualização necessária

Última música enviada:
Metallica - One

Música atual:
Metallica - One

Resultado:
Nenhuma atualização necessária

Quando a faixa mudasse:

Música atual:
Megadeth - Holy Wars

Música atual:
Megadeth - Holy Wars

Música atual:
Megadeth - Holy Wars

Somente então seria realizada uma nova chamada ao Slack.

Isso reduziria chamadas desnecessárias à API e deixaria o processo mais eficiente.

Limpar o status ao pausar ou fechar o Spotify

Outra melhoria seria detectar quando:

A música foi pausada
O Spotify foi fechado
A reprodução terminou

A música foi pausada
O Spotify foi fechado
A reprodução terminou

A música foi pausada
O Spotify foi fechado
A reprodução terminou

Nesse caso, o script poderia remover imediatamente o status musical, em vez de depender apenas da expiração configurada.

Criar logs estruturados

Uma versão mais robusta poderia registrar:

Data e horário
Música identificada
Resposta da API
Falhas de autenticação
Erros do Spotify
Mudanças de status manual

Data e horário
Música identificada
Resposta da API
Falhas de autenticação
Erros do Spotify
Mudanças de status manual

Data e horário
Música identificada
Resposta da API
Falhas de autenticação
Erros do Spotify
Mudanças de status manual

Os logs ajudariam no diagnóstico caso a integração parasse de funcionar.

Usar variáveis de ambiente

Em vez de armazenar o token diretamente em um arquivo simples, a aplicação poderia trabalhar com:

.env
macOS Keychain
1Password CLI
GitHub Codespaces Secrets

.env
macOS Keychain
1Password CLI
GitHub Codespaces Secrets

.env
macOS Keychain
1Password CLI
GitHub Codespaces Secrets

No macOS, o Keychain seria uma opção interessante para manter o token protegido e evitar sua exposição em arquivos comuns.

Criar um aplicativo para a barra de menus

A evolução mais interessante seria transformar o script em um aplicativo de menu para macOS.

Ele poderia apresentar:

Ativar integração
Pausar integração
Mostrar música atual
Limpar status
Iniciar automaticamente
Configurar intervalo
Ver logs

Ativar integração
Pausar integração
Mostrar música atual
Limpar status
Iniciar automaticamente
Configurar intervalo
Ver logs

Ativar integração
Pausar integração
Mostrar música atual
Limpar status
Iniciar automaticamente
Configurar intervalo
Ver logs

Isso eliminaria a necessidade de utilizar comandos no Terminal.

Suportar outros players

O mesmo conceito poderia ser expandido para:

Apple Music
YouTube Music
Deezer
Tidal
Last.fm

Apple Music
YouTube Music
Deezer
Tidal
Last.fm

Apple Music
YouTube Music
Deezer
Tidal
Last.fm

No caso do YouTube Music, por exemplo, uma extensão de navegador poderia capturar a faixa ativa e enviá-la para o serviço local.

Suportar outras plataformas corporativas

Além do Slack, a ideia poderia ser aplicada a:

Microsoft Teams
Discord
Mattermost
Google Chat

Microsoft Teams
Discord
Mattermost
Google Chat

Microsoft Teams
Discord
Mattermost
Google Chat

Cada plataforma possui sua própria API e suas próprias restrições, mas a arquitetura geral seria semelhante.

Uma possível arquitetura mais completa

Uma evolução técnica poderia ser construída com Node.js, Go ou Python.

A estrutura poderia separar responsabilidades:

Player Provider
Responsável por identificar a música atual

Status Provider
Responsável por atualizar Slack, Teams ou Discord

State Manager
Responsável por comparar a faixa atual com a anterior

Credential Manager
Responsável por armazenar tokens com segurança

Scheduler
Responsável por controlar os intervalos de verificação

Logger
Responsável pelo histórico e diagnóstico

Player Provider
Responsável por identificar a música atual

Status Provider
Responsável por atualizar Slack, Teams ou Discord

State Manager
Responsável por comparar a faixa atual com a anterior

Credential Manager
Responsável por armazenar tokens com segurança

Scheduler
Responsável por controlar os intervalos de verificação

Logger
Responsável pelo histórico e diagnóstico

Player Provider
Responsável por identificar a música atual

Status Provider
Responsável por atualizar Slack, Teams ou Discord

State Manager
Responsável por comparar a faixa atual com a anterior

Credential Manager
Responsável por armazenar tokens com segurança

Scheduler
Responsável por controlar os intervalos de verificação

Logger
Responsável pelo histórico e diagnóstico

Um arquivo de configuração poderia determinar o comportamento:

{
  "player": "spotify",
  "statusProvider": "slack",
  "intervalSeconds": 10,
  "updateOnlyOnChange": true,
  "preserveManualStatus": true,
  "clearWhenPaused": true,
  "startAtLogin": false
}

{
  "player": "spotify",
  "statusProvider": "slack",
  "intervalSeconds": 10,
  "updateOnlyOnChange": true,
  "preserveManualStatus": true,
  "clearWhenPaused": true,
  "startAtLogin": false
}

{
  "player": "spotify",
  "statusProvider": "slack",
  "intervalSeconds": 10,
  "updateOnlyOnChange": true,
  "preserveManualStatus": true,
  "clearWhenPaused": true,
  "startAtLogin": false
}

Essa arquitetura permitiria transformar uma pequena automação em uma ferramenta multiplataforma e extensível.

Considerações de segurança

O principal ponto de atenção é o token do Slack.

O token utilizado possui permissão para consultar e modificar o perfil do usuário autenticado. Portanto:

Nunca publique o token
Nunca envie o arquivo slack.pat ao GitHub
Nunca compartilhe prints com o token visível
Utilize permissões mínimas
Revogue o token caso ele seja exposto

Nunca publique o token
Nunca envie o arquivo slack.pat ao GitHub
Nunca compartilhe prints com o token visível
Utilize permissões mínimas
Revogue o token caso ele seja exposto

Nunca publique o token
Nunca envie o arquivo slack.pat ao GitHub
Nunca compartilhe prints com o token visível
Utilize permissões mínimas
Revogue o token caso ele seja exposto

Também é recomendável incluir o arquivo no .gitignore:

slack.pat
.env
*.log

slack.pat
.env
*.log

slack.pat
.env
*.log

Embora seja uma integração simples, ela utiliza credenciais reais de acesso à API e deve seguir os mesmos cuidados aplicados a qualquer projeto de desenvolvimento.

Conclusão

Essa foi uma pequena brincadeira técnica que acabou reunindo vários conceitos úteis:

Automação no macOS
AppleScript
Shell Script
APIs REST
OAuth
Tokens de usuário
JSON
Permissões do Slack
Segurança de credenciais
Git e GitHub

Automação no macOS
AppleScript
Shell Script
APIs REST
OAuth
Tokens de usuário
JSON
Permissões do Slack
Segurança de credenciais
Git e GitHub

Automação no macOS
AppleScript
Shell Script
APIs REST
OAuth
Tokens de usuário
JSON
Permissões do Slack
Segurança de credenciais
Git e GitHub

O resultado foi uma integração funcional, gratuita e open source para mostrar no Slack o que está tocando no Spotify.

No formato atual, ela já resolve o objetivo. Basta executar o script quando quiser compartilhar a música.

Ao mesmo tempo, existe espaço para evoluir o projeto com inicialização automática, cache de músicas, armazenamento seguro de credenciais, suporte a outros players e uma interface nativa para o macOS.

É um bom exemplo de como um pequeno projeto encontrado no GitHub pode servir tanto para resolver uma curiosidade quanto para explorar integrações, APIs e possibilidades de desenvolvimento.