Capítulo 38: Configuração da sincronização com GitHub

A sincronização com GitHub transforma o seu espaço de trabalho do SeaMeet numa árvore Markdown privada e controlada por versões que vive no seu próprio repositório GitHub. Cada vez que edita uma nota, retitula uma gravação ou afina uma página wiki, o SeaMeet silenciosamente faz commit da alteração em segundo plano e empurra-a para o GitHub. Abra o SeaMeet num portátil diferente e as suas notas chegam no primeiro arranque — sem Dropbox no meio, sem servidor Seasalt no ciclo. O repositório é seu, os dados são seus, e pode navegar por eles diretamente em github.com se alguma vez quiser.

O modelo é simples: o seu repositório GitHub é o armazenamento. O SeaMeet não corre um serviço de sincronização. Instala uma pequena GitHub App na sua conta, obtém um token OAuth por utilizador, e usa esse token para empurrar e puxar commits Git diretamente. Porque o armazenamento é o nível gratuito do GitHub — que lhe dá repositórios privados ilimitados — a sincronização é efetivamente gratuita. E porque cada espaço de trabalho SeaMeet é o seu próprio repositório, pode manter espaços de trabalho de trabalho e pessoais totalmente separados.

Objetivos do capítulo

Depois de ler este capítulo, será capaz de:

Instalar a SeaMeet GitHub App na sua conta ou organização
Autorizar o SeaMeet via OAuth e deixá-lo criar um repositório de sincronização privado para si
Ler a barra de estado de sincronização e compreender cada estado na máquina de estado de sincronização
Reconhecer quando o OAuth se auto-atualizou em segundo plano e quando precisa de re-autorizar manualmente
Resolver um conflito de sincronização quando a mesma nota foi editada em dois dispositivos
Afinar o painel de Definições de sincronização (auto-sincronização, intervalo de sincronização, sincronização no arranque)
Resolver os modos de falha mais comuns

Pré-requisitos

Antes de começar, certifique-se de que tem:

Uma conta GitHub — nível gratuito é suficiente; não precisa de GitHub Pro
Uma autorização de sincronização ativa — incluída com os níveis BYOK Pro e Sync Pro. Se o seu nível de faturação não incluir sincronização, o ecrã Definições de sincronização mostrará um banner "Subscribe to enable sync". Ver Capítulo 35: Assinatura e faturação para detalhes do plano.
Um espaço de trabalho aberto no SeaMeet — a sincronização anexa-se ao espaço de trabalho ativo, não à aplicação como um todo. Se tem vários espaços de trabalho, cada um é o seu próprio repositório GitHub.
Acesso à internet a funcionar — o fluxo de configuração abre o GitHub no seu navegador predefinido

Um repositório por espaço de trabalho. O SeaMeet cria um repositório privado separado para cada espaço de trabalho que ligar. Isto mantém notas de trabalho e notas pessoais limpamente isoladas e significa que pode desligar uma sem tocar na outra.

Configuração passo a passo

A configuração da primeira vez demora cerca de 90 segundos: autorize o SeaMeet no GitHub, deixe-o criar o seu repositório, espere pelo carregamento inicial, e está pronto.

Passo 1: abrir Definições de sincronização

Clique no ícone de engrenagem Definições
Abra o separador Sync na barra esquerda
Verá o cartão de cabeçalho "Sync with GitHub"

Se não vê o separador Sync, o seu nível de assinatura não inclui sincronização — ver Capítulo 35 para atualizar.

Se vê um banner que lê "Back up your notes to a private GitHub repo with BYOK Pro", tem uma conta gratuita. Clique no banner para abrir o paywall, ou salte o resto deste capítulo até ter subscrito.

Passo 2: clicar "Set Up GitHub Sync"

O estado vazio das Definições de sincronização mostra três mosaicos de benefício ("Gratuito e privado", "Efetivamente ilimitado", "Um repositório por espaço de trabalho") e um botão primário Set Up GitHub Sync no fundo.

Clique nele. O seu navegador predefinido abre numa página de autorização do GitHub.

Passo 3: instalar a SeaMeet GitHub App (uma vez)

A primeira vez que autoriza o SeaMeet, o GitHub pedir-lhe-á para instalar a SeaMeet GitHub App na sua conta. Este é um passo único por conta GitHub (ou por organização, se quer sincronizar para um repositório propriedade da organização).

Na página de instalação do GitHub:

Escolha a conta ou organização para a qual quer que o SeaMeet escreva
Escolha "All repositories" ou "Only select repositories" — a App SeaMeet precisa de permissões contents: write e administration: write para que possa criar o repositório de sincronização em seu nome
Clique em Install & Authorize

O GitHub leva-o de volta ao SeaMeet. O painel de Definições de sincronização agora mostra:

┌──────────────────────────────────────────────────────┐
│   ✓ Autorizado                                       │
│   ⟳ A criar repositório e a carregar...              │
└──────────────────────────────────────────────────────┘

Porquê uma GitHub App e não um token OAuth simples? As GitHub Apps têm permissões granulares por repositório e tokens de atualização rotativos. O SeaMeet apenas tem acesso de escrita aos repositórios que escolheu explicitamente, e o token de acesso OAuth expira a cada 8 horas — mesmo que fosse fugido, a janela seria pequena. (Ver a secção Auto-atualização OAuth abaixo para como o SeaMeet mantém isso invisível para si.)

Passo 4: criação de repositório (automática)

O SeaMeet agora chama a API do GitHub em seu nome e:

Cria um repositório privado com o nome do seu espaço de trabalho (ex.: seameet-work-notes)
Inicializa um repositório Git local dentro da pasta do seu espaço de trabalho se ainda não existir
Corre git init, escreve um .gitignore que exclui ficheiros áudio/vídeo/captura de ecrã, e faz um commit inicial
Adiciona o novo repositório GitHub como origin
Empurra o commit inicial

Verá a barra de estado no fundo da barra lateral transitar por:

A criar repositório...  →  A sincronizar...  →  Sincronizado · agora mesmo

É tudo. O seu espaço de trabalho está agora apoiado por GitHub.

Passo 5: a primeira sincronização corre automaticamente

A partir daqui, o SeaMeet faz commits automáticos a cada 5 minutos (por predefinição) sempre que tem alterações por guardar, e empurra para o GitHub imediatamente após cada commit. No próximo lançamento do SeaMeet, a aplicação puxa do GitHub antes mesmo de começar a editar — para que alterações feitas noutro dispositivo apareçam no momento em que a aplicação abre.

A máquina de estado de sincronização

O SyncManager do SeaMeet corre uma pequena máquina de estado e transmite o seu estado atual ao renderer. A SyncStatusBar da barra lateral e o painel de Definições de sincronização ambos leem deste estado. Compreender os estados ajuda-o a ler a UI com precisão.

                      ┌─────────────┐
                      │    idle     │ ◄──────┐
                      └──────┬──────┘        │
                             │ mudança fich. │
                             ▼               │
                      ┌─────────────┐        │
                ┌────►│   pending   │        │
                │     └──────┬──────┘        │
       mudança  │            │ timer commit  │
       fich.    │            ▼               │
                │     ┌─────────────┐        │
                │     │ committing  │        │
                │     └──────┬──────┘        │
                │            ▼               │
                │     ┌─────────────┐        │
                │     │   pushing   │        │
                │     └──────┬──────┘        │
                │            ▼               │
                │     ┌─────────────┐        │
                │     │   synced    │── 5s ──┘
                │     └─────────────┘
                │
                │     ┌─────────────┐
                ├─────┤   pulling   │  (arranque ou push rejeitado)
                │     └─────────────┘
                │
                │     ┌─────────────┐
                ├─────┤  conflict   │  → utilizador resolve → syncing → synced
                │     └─────────────┘
                │
                │     ┌─────────────┐
                ├─────┤   offline   │  → rede volta → repetir
                │     └─────────────┘
                │
                │     ┌─────────────┐
                ├─────┤   timeout   │  → utilizador clica Retry
                │     └─────────────┘
                │
                │     ┌────────────────┐
                └─────┤ token-expired  │ → cartão de re-autorização
                      └────────────────┘

Eis o que cada estado significa na UI:

Estado	Rótulo da barra de estado	O que significa
idle	"Sincronizado · há 2 min"	Nada pendente, último commit foi limpo
pending	"Pendente..."	Tem alterações por guardar; o timer de commit disparará no próximo intervalo
committing	"A sincronizar..."	Um commit Git está em curso localmente
pushing	"A empurrar..."	Commit local completo; a empurrar para o GitHub
pulling	"A puxar..."	Ou sincronização de arranque, ou push foi rejeitado e estamos a puxar primeiro
syncing	"A sincronizar..."	A terminar um rebase após resolução de conflito
synced	"Sincronizado · agora mesmo"	Sucesso acabado de completar; mostrado por 5 segundos, depois volta a idle
conflict	"Conflito de sincronização"	Local e remoto editaram o mesmo ficheiro. A UI revela o fluxo de resolução de conflito.
error	"Erro de sincronização"	Uma falha não de rede, não de conflito (ex.: falha git). Repete automaticamente com backoff exponencial até 5 vezes.
offline	"Offline"	Rede inalcançável. Tentará novamente na próxima mudança de ficheiro ou após 60 segundos.
timeout	"Sincronização expirou"	Um comando git demorou mais do que 60 segundos (ver Proteção de Timeout de Sincronização abaixo)
token-expired	"Re-autorizar"	A atualização OAuth falhou e o utilizador tem de re-autorizar manualmente
installing-app	"A instalar GitHub App..."	À espera que o utilizador termine o passo de instalação da GitHub App no seu navegador
creating-repo	"A criar repositório..."	Fluxo de configuração está a criar o repositório GitHub e a empurrar o commit inicial

Se a barra de estado está a mostrar um spinner, isso é atividade normal em segundo plano. Se está âmbar ou vermelha, veja a secção Resolução de problemas abaixo.

Auto-atualização OAuth

As GitHub Apps emitem tokens de acesso de utilizador que expiram a cada 8 horas, mais um token de atualização que é válido por 6 meses. O SeaMeet gere isto por si para que quase nunca tenha de pensar nisso.

Como funciona:

Quando o SeaMeet está prestes a empurrar ou puxar, SyncManager._refreshTokenIfNeeded() verifica se o token atual expira dentro dos próximos 5 minutos.
Se sim, o SeaMeet chama o endpoint /login/oauth/access_token do GitHub com o token de atualização armazenado. O GitHub devolve um novo token de acesso e roda o token de atualização. O SeaMeet escreve ambos de volta para o ficheiro de tokens encriptado no disco.
O comando Git então corre com o token recém-atualizado. Não vê nada no ecrã — toda a atualização demora bem menos do que um segundo.

Tratamento de falhas transitórias: se a chamada de atualização falha porque a rede está instável ou o GitHub devolveu um 5xx (um REFRESH_NETWORK_ERROR), o SeaMeet não deita fora o token existente. Em vez disso, a sincronização entra no estado offline e tenta novamente mais tarde. Isto importa porque o token existente pode ainda ser válido por mais vários minutos — descartá-lo num soluço de rede transitório iria desligá-lo da sincronização desnecessariamente.

Coalescência de atualização concorrente: o GitHub roda o token de atualização sempre que o usa, pelo que duas atualizações concorrentes correriam e uma invalidaria a outra. O SeaMeet colapsa chamadas de atualização concorrentes numa única Promise em curso (_refreshPromise) para que a sincronização de arranque e o push com tentativa nunca lutem pelo token rotativo.

Quando a atualização realmente falha: se o GitHub devolve REFRESH_TOKEN_EXPIRED — significando que o token de atualização de 6 meses expirou ou foi revogado — o SeaMeet:

Elimina o ficheiro de tokens encriptado do disco
Entra no estado terminal token-expired
Mostra um cartão âmbar nas Definições de sincronização:

┌──────────────────────────────────────────────────────┐
│ ⚠  A autorização do GitHub expirou. Por favor         │
│    re-autorize para retomar a sincronização.          │
│                                                       │
│  [ ↻ Re-autorizar GitHub ]                            │
└──────────────────────────────────────────────────────┘

Clique em Re-autorizar GitHub. É enviado de volta pelo fluxo OAuth — mas como a GitHub App já está instalada, é um único clique para confirmar e está pronto em cerca de 10 segundos. O SeaMeet depois retira qualquer token desatualizado do seu git config local (o token antigo pode estar incorporado no URL de origin) antes do próximo push, para que não fique em ciclo numa credencial morta.

Proteção de timeout de sincronização

Comandos Git podem ficar pendurados para sempre se uma rede ficar silenciosa a meio da transferência — um socket TCP pode ficar num estado semi-aberto sem nunca levantar um erro. O SeaMeet envolve cada push e pull Git num timeout AbortController de 60 segundos.

Se um push ou pull não completa em 60 segundos, o SeaMeet:

Aborta o subprocesso git
Entra no estado timeout
Mostra um cartão âmbar nas Definições de sincronização:

┌──────────────────────────────────────────────────────┐
│ ⚠  Sincronização expirou. Isto pode ser causado por  │
│    um problema de rede ou autorização GitHub expirada.│
│                                                       │
│  [ ↻ Tentar novamente ]   [ Re-autorizar GitHub ]     │
└──────────────────────────────────────────────────────┘

Tentar novamente corre commitNow outra vez. Este é o botão certo para clicar se acha que a sua rede caiu brevemente. Re-autorizar GitHub corre o fluxo OAuth novamente; clique nisto se o timeout continuar a ocorrer, o que geralmente significa que o seu token é o problema em vez da rede.

O estado regressa a idle automaticamente após cerca de 30 segundos mesmo que não clique em nada — a sincronização tentará novamente na próxima mudança de ficheiro.

Resolução de conflitos

Um conflito acontece quando o mesmo ficheiro foi editado em dois dispositivos desde a última sincronização. Exemplo: escreveu um parágrafo em meetings/2026-06-03-standup.md no seu portátil, depois mais tarde editou o mesmo parágrafo na máquina de um amigo. Quando o segundo dispositivo empurra, o GitHub rejeita o push porque as histórias divergem.

O SeaMeet lida com isto:

Puxando as alterações remotas com um rebase
Detetando os marcadores de conflito de fusão
Entrando no estado conflict
Revelando o conflito na barra de estado da barra lateral (que se torna clicável) e no painel de conflito das Definições de sincronização

Clicar na barra de estado quando a sincronização está em conflict abre o Modal de resolução de conflitos:

┌──────────────────────────────────────────────────────────┐
│  ⚠  Conflito de sincronização       1 / 2          [×]   │
├──────────────────────────────────────────────────────────┤
│                                                          │
│  "2026-06-03-standup.md" foi alterado noutro dispositivo.│
│                                                          │
│  ┌────────────────────────┐  ┌────────────────────────┐  │
│  │ ✎  Editar manualmente  │  │ ✦  Fusão por agente    │  │
│  └────────────────────────┘  └────────────────────────┘  │
│                                                          │
└──────────────────────────────────────────────────────────┘

Tem duas opções:

Editar manualmente — abre o ficheiro de conflito no editor predefinido do seu sistema com os marcadores padrão do Git <<<<<<< / ======= / >>>>>>> no lugar. Edite o ficheiro para os resolver, guarde, depois volte ao SeaMeet e clique em Concluído. O SeaMeet faz stage do ficheiro resolvido e continua o rebase.

Fusão por agente (apenas BYOK Pro, requer Agente IA configurado) — envia ambas as versões para o seu Agente IA configurado (GitHub Copilot ou Claude Code, ver Capítulo 36: Guia de configuração BYOK) e pede-lhe para produzir uma versão fundida que mantenha a intenção de ambos os lados. A saída do agente é staged automaticamente; verá um spinner "A terminar sincronização..." enquanto o rebase completa.

Se há vários conflitos de uma vez, o modal mostra um contador (1 / 2, 2 / 2) e setas em galão no painel de conflito das Definições de sincronização para que possa percorrê-los um de cada vez.

Opções "Manter o meu" / "Manter o deles" / "Manter ambos" surgem como escolhas naturais quando está dentro do editor manual: deixe apenas o texto da sua versão entre os marcadores, apenas o texto da versão remota, ou intercale ambos. O botão Fusão por agente efetivamente faz "manter ambos, inteligentemente."

E se cometer um erro? Conflitos de sincronização não são destrutivos. O Git mantém o conteúdo original "nosso" e "deles" no índice, e getConflictVersions(filePath) pode obter qualquer um em qualquer ponto durante a resolução. Não perderá trabalho acidentalmente.

O painel de Definições de sincronização

Uma vez ligado, as Definições de sincronização (Definições → Sync) dão-lhe um único ecrã com tudo num só lugar:

┌─────────────────────────────────────────────────────────────┐
│  ✓ Sync & Backup                                            │
│  As suas notas e wiki são sincronizadas automaticamente.    │
│  Gravações de áudio, vídeo e capturas de ecrã não são       │
│  sincronizadas.                                             │
├─────────────────────────────────────────────────────────────┤
│  ⓘ  https://github.com/you/seameet-work-notes                │
│  🕒 Última sincronização: há 4 minutos                       │
├─────────────────────────────────────────────────────────────┤
│  Auto-sincronização                              [ ON  ◉ ]  │
│  Intervalo de sincronização                     [ 5 min ▾ ] │
│  Ramo                                                main   │
│  Última sincronização                       há 4 minutos    │
├─────────────────────────────────────────────────────────────┤
│  Auto-sincronização em alterações                [ ON  ◉ ]  │
│  Sincronizar no arranque                         [ ON  ◉ ]  │
├─────────────────────────────────────────────────────────────┤
│  [ ⤓ Sincronizar agora ]                                    │
├─────────────────────────────────────────────────────────────┤
│  [ ↗ Ver no GitHub ]    [ Desligar ]                        │
└─────────────────────────────────────────────────────────────┘

Os controlos, de cima para baixo:

Auto-sincronização — alternador principal para o timer de commit em segundo plano. Desligado significa que o SeaMeet apenas faz commit quando clica em Sincronizar agora.
Intervalo de sincronização — quão frequentemente o timer de commit dispara. Escolhas são 1 / 5 / 10 / 30 minutos. Predefinição é 5 minutos. Um intervalo de 1 minuto é bom para tomar notas ativamente; 30 minutos é bom para espaços de trabalho com poucas edições onde prefere agrupar commits.
Ramo — o ramo Git para o qual o SeaMeet sincroniza. Quase sempre main. Apenas leitura na UI.
Última sincronização — marca temporal relativa do último push bem-sucedido.
Auto-sincronização em alterações — quando ativada, pushes acontecem imediatamente após cada commit local (o caso típico). Quando desativada, o SeaMeet faz commit localmente mas só empurra quando clica em Sincronizar agora. Útil se quer agrupar pushes (ex.: numa ligação medida).
Sincronizar no arranque — quando ativada, o SeaMeet puxa do GitHub no momento em que a aplicação é lançada. Recomendado a menos que tenha uma ligação muito lenta.
Sincronizar agora — forçar um ciclo imediato de commit e push. Não espera pelo timer. Útil antes de fechar o seu portátil.
Ver no GitHub — abre o repositório no seu navegador.
Desligar — limpa o token OAuth armazenado, elimina o ficheiro de tokens encriptado, e remove origin do seu repositório Git local. Os seus ficheiros Markdown locais e histórico Git ficam intocados — apenas a ligação ao GitHub é cortada.

O que é sincronizado (e o que não é)

Isto está documentado no índice da parte, mas vale a pena repetir aqui:

Sincronizado	Não sincronizado
Notas (ficheiros `.md`)	Gravações de áudio (`.webm`, `.mp3`)
Páginas wiki (ficheiros `.md`)	Gravações de vídeo (`.webm`, `.mp4`)
Manifestos de gravação (metadados JSON)	Capturas de ecrã (`.png`, `.jpg`)
Resumos de IA e transcrições	Gerações de IA em cache
Grafo de wikilinks	Definições da aplicação
`.gitignore`	Estado de rascunho do editor

O .gitignore que o SeaMeet escreve exclui todas as categorias de binários grandes. Isto é intencional: repositórios privados gratuitos do GitHub limitam a 1 GB, e um vídeo de 30 minutos comeria isso sozinho. O SeaMeet mantém multimédia no seu disco local e sincroniza apenas o Markdown leve.

Se quer sincronização completa de multimédia, esse é o nível Sync Pro — ver Capítulo 35.

Resolução de problemas

"Autorização falhou" logo após clicar Set Up GitHub Sync

Causas e correções:

Bloqueador de pop-up — se nenhuma janela de navegador abriu, o seu SO ou navegador pode ter bloqueado o lançamento. Clique em Set Up GitHub Sync novamente e confirme quaisquer pedidos de pop-up.
Negou as permissões da GitHub App — volte pelo fluxo e aceite os escopos contents: write + administration: write. Sem administration: write o SeaMeet não pode criar o repositório por si.
Erro de incompatibilidade de estado — feche quaisquer outras janelas do SeaMeet que possam estar a correr no mesmo fluxo OAuth, depois tente novamente.

Erro de "Permissões do repositório" durante a configuração

O erro lê algo como "GitHub App tem permissão 'contents: read', mas precisa de 'contents: write'." Isto significa que instalou uma versão mais antiga da App.

Correção:

Abra github.com/settings/installations
Encontre SeaMeet na lista e clique em Configure
Em Repository permissions, altere Contents e Administration para Read and write
Guarde, depois desinstale e reinstale a app — o GitHub só aplica novas permissões na reinstalação
Volte a correr Set Up GitHub Sync no SeaMeet

"Não foi possível contactar GitHub" / sincronização presa em "Offline"

Falha de rede. O SeaMeet tentará novamente automaticamente quando:

Faz qualquer mudança de ficheiro (aciona uma tentativa imediata)
60 segundos decorrem desde a última tentativa

Se a sua rede está de volta e a sincronização ainda mostra Offline após alguns minutos:

Clique em Sincronizar agora para forçar uma tentativa
Se isso expira: verifique se a sua firewall não está a bloquear github.com
Como último recurso, reinicie o SeaMeet — a sincronização de arranque disparará no lançamento

Sincronização presa em "Pendente"

Isto geralmente significa que o timer de auto-commit ainda não disparou. Por predefinição dispara a cada 5 minutos. Não quer esperar? Clique em Sincronizar agora.

Se Sincronizar agora não move a sincronização para além de Pendente, verifique:

Está num nível de faturação que inclui sincronização? Abra Definições de sincronização — se vê o banner de subscrição, a sincronização está desativada na camada de autorização.
Há alterações por commit fora da árvore Markdown? O timer de auto-commit só dispara quando _pendingChanges não está vazio.

"Vejo o cartão de token expirado"

Este é o fim esperado do ciclo de vida de atualização OAuth — o seu token de atualização de 6 meses expirou, ou revogou a GitHub App, ou alterou a sua palavra-passe do GitHub (o que invalida todos os tokens OAuth).

Correção: clique em Re-autorizar GitHub no cartão. O fluxo é o mesmo da configuração inicial mas salta o passo de instalação da GitHub App (já a tem instalada). Demora cerca de 10 segundos.

O painel de resolução de conflitos não fecha

O painel só fecha uma vez que todos os conflitos na lista sejam resolvidos. Se vê o contador (1 / 3), use as setas em galão no painel de conflito das Definições de sincronização para percorrer os ficheiros restantes. Cada um precisa de uma resolução explícita (edição manual + Concluído, ou Fusão por agente).

Se o painel insiste que há conflitos mas não vê marcadores nos seus ficheiros, clique em Sincronizar agora — um estado conflict desatualizado será limpo na próxima tentativa de sincronização bem-sucedida.

Ciclos de "Push rejeitado"

Se a sincronização alterna entre pushing e pulling repetidamente, o GitHub está a rejeitar os seus pushes porque o remoto continua a avançar. Isto pode acontecer se:

Outra instância do SeaMeet está a correr contra o mesmo repositório e a empurrar mais depressa do que esta consegue acompanhar — feche a outra instância.
Alguém (ou alguma ferramenta) está a fazer commit para o repositório GitHub a partir de fora do SeaMeet — pause a ferramenta externa até o seu clone local apanhar.

Notas de segurança

Onde o token OAuth é armazenado: no porta-chaves do seu SO via a API safeStorage do Electron. Em Windows isso é DPAPI, em macOS é Keychain Services, em Linux é libsecret. O blob encriptado é escrito para <userData>/github-token.enc com modo de ficheiro 0o600. O ficheiro contém o token de acesso, o token de atualização, a marca temporal de expiração, e o ID de cliente, segredo de cliente e slug da GitHub App.

O que não é armazenado em argv: o token OAuth nunca é passado como argumento -c http.extraHeader=... para o git, porque argv é visível a outros utilizadores via ps aux. Em vez disso, o cabeçalho Authorization é injetado através da variável de ambiente GIT_CONFIG_PARAMETERS, que é privada ao processo. Outros utilizadores na mesma máquina não conseguem ver o seu token.

O que acaba no disco no repositório: ficheiros Markdown simples. Sem tokens, sem segredos, sem credenciais. O .gitignore exclui ficheiros multimédia, mas ainda deve evitar colar segredos em corpos de notas — esses serão sincronizados.

Revogar acesso: para cortar imediatamente o acesso do SeaMeet a um repositório, desinstale a SeaMeet GitHub App em github.com/settings/installations. A próxima tentativa de sincronização falhará com token-expired e o SeaMeet limpará o seu token local. As suas notas locais ficam intocadas.

Referência rápida

┌─────────────────────────────────────────────────────────────┐
│                   GITHUB SYNC                               │
│                   Referência rápida                         │
├─────────────────────────────────────────────────────────────┤
│  Abrir Definições Sync │ Definições → Sync                  │
│  Configuração 1ª vez   │ Clicar "Set Up GitHub Sync"        │
│  Escopos necessários   │ contents: write, admin: write      │
│  Nomenclatura de repo  │ Um repo privado por espaço trabalho│
├─────────────────────────────────────────────────────────────┤
│  Intervalo sync pred.  │ 5 minutos (1 / 5 / 10 / 30)        │
│  Forçar sincronização  │ Botão "Sincronizar agora"          │
│  Auto-sync em push     │ Ligado (alternador em Definições)  │
│  Sync no arranque      │ Ligado (alternador em Definições)  │
├─────────────────────────────────────────────────────────────┤
│  Margem atualiz. OAuth │ 5 minutos antes da expiração       │
│  Timeout comando Git   │ 60 segundos (AbortController)      │
│  Limite auto-retry     │ 5 tentativas, backoff exponencial  │
│  Armazenamento token   │ Porta-chaves SO (safeStorage)      │
├─────────────────────────────────────────────────────────────┤
│  UI de conflito        │ Clicar barra estado em conflito    │
│  Resolver manualmente  │ Editar marcadores → Concluído      │
│  Fusão por agente      │ BYOK Pro + Agente IA configurado   │
├─────────────────────────────────────────────────────────────┤
│  Desligar              │ Definições Sync → Desligar         │
│  Revogar do GitHub     │ github.com/settings/installations  │
│  Ver repositório       │ Ligação "Ver no GitHub"            │
└─────────────────────────────────────────────────────────────┘

Última atualização: 2026-06-04

← Capítulo 37: Fornecedor GitHub Copilot | (fim do manual — voltar ao Índice)

Configuração da sincronização com GitHub