$ $
Instalação
Configure um alias persistente (uma vez)
curl -s https://cpynet.com/install.sh -o install.sh && bash -n install.sh && . install.shSHA256 do install.sh: 86bd4b2171ea3f0e8e845df8585e69a3d452eb94855bbab7dd097c8af9b96887
Ler o install.sh antes de executá-lo
# cpynet installer - fetches the cpy/pst shell functions from https://cpynet.com/alias,
# adds a source line to your shell's rc file (once, never duplicated), and
# loads them into this session right now.
#
# Dot-sourced (". install.sh"), not run as a subprocess - that's what makes
# cpy/pst usable immediately in this terminal, not just in new ones.
CPYNET_RC=~/.bashrc
[ -n "$ZSH_VERSION" ] && CPYNET_RC=~/.zshrc
if curl -s https://cpynet.com/alias -o ~/.cpy.sh && bash -n ~/.cpy.sh; then
grep -qxF 'source ~/.cpy.sh' "$CPYNET_RC" || echo 'source ~/.cpy.sh' >> "$CPYNET_RC"
. ~/.cpy.sh
echo "cpynet installed - cpy and pst are ready"
else
echo "install failed, try again"
fi
unset CPYNET_RC
SHA256 do script que o install.sh baixa (~/.cpy.sh): 8161c889a7240a3958267ffdb1697cff311246b5c4aaf57c02d44aa1d397a17e
Leia esse script também (também funciona como instalação manual - copie a função abaixo diretamente)
cpy() {
local password="" ttl="" reads="" e2e="" a
for a in "$@"; do case "$a" in
-password=*) password="${a#-password=}" ;;
-ttl=*) ttl="${a#-ttl=}" ;;
-reads=*) reads="${a#-reads=}" ;;
-e) e2e=1 ;;
esac; done
local qs=""
[ -n "$ttl" ] && qs="ttl=$ttl"
[ -n "$reads" ] && qs="${qs:+$qs&}reads=$reads"
local target="https://llmtag.com/"
[ -n "$qs" ] && target="https://llmtag.com/?$qs"
local input key=""
if [ -n "$e2e" ]; then
key=$(openssl rand -base64 24)
input=$(openssl enc -aes-256-cbc -pbkdf2 -salt -a -A -pass "pass:$key") || return 1
else
input=$(cat)
fi
local url
if [ -n "$password" ]; then
url=$(printf '%s' "$input" | curl -sS --fail-with-body -L -H "X-Password: $password" --data-binary @- "$target") || return 1
else
url=$(printf '%s' "$input" | curl -sS --fail-with-body -L --data-binary @- "$target") || return 1
fi
local bare="${url%%\?*}"
echo "${bare##*/}"
echo "curl \"$url\""
if [ -n "$key" ]; then
echo "key (share separately, never with the link/code): $key"
fi
}
pst() {
local password="" id="" key="" a
for a in "$@"; do case "$a" in
-password=*) password="${a#-password=}" ;;
-key=*) key="${a#-key=}" ;;
*) id="$a" ;;
esac; done
if [ -z "$id" ]; then echo "usage: pst <code> [-password=xxx] [-key=xxx]" >&2; return 1; fi
local target="https://llmtag.com/$id"
[ -n "$password" ] && target="$target?p=$password"
local text
text=$(curl -sS --fail-with-body "$target") || return 1
if [ -n "$key" ]; then
text=$(printf '%s' "$text" | openssl enc -d -aes-256-cbc -pbkdf2 -a -A -pass "pass:$key") || { echo "decrypt failed - wrong key?" >&2; return 1; }
fi
printf '%s\n' "$text"
if command -v pbcopy >/dev/null 2>&1; then printf '%s' "$text" | pbcopy
elif command -v wl-copy >/dev/null 2>&1; then printf '%s' "$text" | wl-copy
elif command -v xclip >/dev/null 2>&1; then printf '%s' "$text" | xclip -selection clipboard
elif command -v xsel >/dev/null 2>&1; then printf '%s' "$text" | xsel --clipboard
elif command -v clip.exe >/dev/null 2>&1; then printf '%s' "$text" | clip.exe
fi
}
Depois, basta: comando | cpy — imprime o código de 6 dígitos e um comando curl pronto para uso em duas linhas. Para proteger com senha: comando | cpy -password=xxx. Para o sentido de leitura: pst 123456 — imprime o conteúdo no stdout e também copia para a área de transferência se conseguir (pbcopy/wl-copy/xclip/xsel/clip.exe).
Os links são gerados no domínio curto https://llmtag.com; o comando de instalação acima baixa do site principal, https://cpynet.com - o mesmo serviço, apenas um domínio curto separado reservado para links.
Windows / PowerShell
Invoke-RestMethod https://cpynet.com/install.ps1 -OutFile install.ps1; . .\install.ps1SHA256 do install.ps1: 0ab2333a4ea86b1b8797c2b8251daa368d485dfeaa6dfcaad90c076d0217b43c
Ler o install.ps1 antes de executá-lo
# cpynet installer - fetches the cpy/pst PowerShell functions from
# https://cpynet.com/alias.ps1, adds a dot-source line to $PROFILE (once, never duplicated),
# and loads them into this session right now.
#
# Dot-sourced (". .\install.ps1"), not run as a subprocess - that's what
# makes cpy/pst usable immediately in this session, not just in new ones.
$ErrorActionPreference = 'Stop'
try {
Invoke-RestMethod https://cpynet.com/alias.ps1 -OutFile "$HOME/.cpy.ps1"
if (-not (Test-Path $PROFILE)) { New-Item -ItemType File -Path $PROFILE -Force | Out-Null }
if (-not (Select-String -Path $PROFILE -Pattern '\.cpy\.ps1' -Quiet -ErrorAction SilentlyContinue)) {
Add-Content $PROFILE "`n. `"$HOME/.cpy.ps1`""
}
. "$HOME/.cpy.ps1"
Write-Output "cpynet installed - cpy and pst are ready"
} catch {
Write-Output "install failed, try again"
}
SHA256 do script que o install.ps1 baixa (~/.cpy.ps1): 356ae02c39d58c86d717899969cf961e519eac156105140671c63941b9b5aa17
Leia esse script também (também funciona como instalação manual - copie as funções abaixo diretamente)
function cpy {
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline = $true)]
[string[]]$InputObject,
[string]$Password = "",
[string]$Ttl = "",
[string]$Reads = ""
)
begin { $lines = New-Object System.Collections.Generic.List[string] }
process { if ($null -ne $InputObject) { foreach ($l in $InputObject) { $lines.Add($l) } } }
end {
$text = $lines -join "`n"
$qs = @()
if ($Ttl) { $qs += "ttl=$Ttl" }
if ($Reads) { $qs += "reads=$Reads" }
$target = "https://llmtag.com/"
if ($qs.Count -gt 0) { $target = "https://llmtag.com/?" + ($qs -join '&') }
$headers = @{}
if ($Password) { $headers["X-Password"] = $Password }
try {
$url = (Invoke-RestMethod -Uri $target -Method Post -Body $text -Headers $headers -ContentType "text/plain; charset=utf-8").Trim()
} catch {
Write-Error $_
return
}
$bare = $url -replace '\?.*$', ''
$code = $bare -replace '.*/', ''
Write-Output $code
Write-Output "curl `"$url`""
}
}
function pst {
[CmdletBinding()]
param(
[Parameter(Position = 0)]
[string]$Code = "",
[string]$Password = ""
)
if (-not $Code) { Write-Error "usage: pst <code> [-Password xxx]"; return }
$target = "https://llmtag.com/$Code"
if ($Password) { $target = "$target`?p=$Password" }
try {
$text = Invoke-RestMethod -Uri $target -Method Get
} catch {
Write-Error $_
return
}
Write-Output $text
if (Get-Command Set-Clipboard -ErrorAction SilentlyContinue) {
$text | Set-Clipboard
}
}
Isso adiciona as funções cpy/pst ao $PROFILE uma vez - depois, "texto" | cpy e pst 123456 funcionam da mesma forma que na versão bash (os parâmetros usam o próprio estilo do PowerShell: cpy -Ttl 1h -Reads 3 -Password xxx, pst 123456 -Password xxx).
Uso
Usando a interface web
1. Digite seu texto
Cole seu texto ou código na aba escrever e clique em enviar.
2. Compartilhe o código, link ou QR
Ao enviar, um código de 6 dígitos, um comando curl pronto para uso e um código QR escaneável são gerados.
3. Digite o código
Na aba ler, digite o código — ou escaneie o código QR com o celular.
4. Lê uma vez, depois some
O conteúdo aparece instantaneamente e é excluído permanentemente do servidor — o mesmo código não funcionará uma segunda vez.
Enviar pelo terminal
comando | curl --data-binary @- https://llmtag.com/A resposta é um link puro, pronto para uso.
Ler pelo terminal
curl "seu-link"Lido uma vez e depois excluído permanentemente. Instalou o alias acima? pst 123456.
Proteger com senha
Preencha o campo de senha abaixo — o link virá automaticamente com ?p=senha.
Windows / PowerShell
Invoke-RestMethod -Method Post -Body "texto" -Uri https://llmtag.com/Invoke-RestMethod "seu-link"O Invoke-RestMethod nativo também funciona, em vez do curl.exe.
Integração API / CI
Adicione Accept: application/json à requisição de criação para receber {"code","url","expires_at"} em vez de texto simples - mais fácil de processar em um script. Referência completa, incluindo códigos de status (400/401/404/413/429/503) e um exemplo com GitHub Actions: /api.
Perguntas frequentes
Quantas vezes um código pode ser usado?
Apenas uma vez. É excluído permanentemente do servidor no instante em que é lido.
O que acontece quando o tempo acaba?
Mesmo que ninguém o leia, o paste é excluído automaticamente - nenhum vestígio fica no servidor.
Como uso com a área de transferência desativada?
O CPYNET nunca toca na área de transferência - tudo passa pelo curl a partir do terminal, então uma área de transferência desativada não faz diferença.
O servidor vê ou armazena o que eu colo?
O texto fica somente na memória, nunca é gravado em disco - é excluído permanentemente no momento em que é lido ou quando o tempo acaba. Se protegido por senha, fica armazenado criptografado com AES-256-GCM.
Funciona no Windows?
Sim - no PowerShell, digite curl.exe em vez do alias curl, caso contrário textos longos podem ser truncados no console. Ou use o Invoke-RestMethod nativo, ou instale as funções cpy/pst pela seção Windows / PowerShell acima.
Qual é o tamanho máximo e o comprimento do código?
Até 2 MB, um código de 6 dígitos, exclui automaticamente em 2min por padrão - selecionável até 1d (o parâmetro ?ttl=, ou o seletor de TTL na aba escrever). Autodestrói após 1 leitura por padrão - selecionável até 10 leituras (o parâmetro ?reads=, ou o seletor de leituras).
Por que o CPYNET?
Criado para ambientes onde compartilhar a área de transferência não é uma opção: servidores remotos via SSH, máquinas onde o acesso à área de transferência é bloqueado por política, ou máquinas/contêineres/desktops virtuais separados sem área de transferência compartilhada entre eles. O CPYNET nunca toca na área de transferência do sistema operacional - tudo se move como texto simples via curl - por isso pode ser usado com confiança mesmo onde a área de transferência está totalmente desativada.
Recursos
- Leitura única: excluído permanentemente no momento em que é lido
- Exclusão automática quando o tempo acaba, mesmo que ninguém leia
- Compartilhamento protegido por senha: AES-256-GCM + PBKDF2, o servidor mantém o texto simples apenas momentaneamente
- Notificação em tempo real: sua aba sabe no instante em que é lido (SSE)
- Suporte a arquivos pequenos (apenas extensões permitidas, mantidos por no máximo 1 h): 📎 para anexar um, baixado de volta com seu nome de arquivo e tipo de conteúdo originais
- Limitação de taxa por IP: protege contra adivinhação de código e ataques de força bruta
Extensões de arquivo permitidas: .txt, .log, .csv, .json, .md, .pdf, .doc, .docx, .rtf, .xml, .yaml, .yml, .pem, .crt, .key, .conf, .cfg, .env, .ini, .toml
Segurança
O servidor nunca executa, avalia ou encaminha o que você cola para um shell - ele apenas armazena e devolve exatamente como recebido. Sem dependências de terceiros (biblioteca padrão Go pura), sem acesso ao sistema de arquivos com dados do usuário, sem requisições de saída.
Criptografia de conhecimento zero (o servidor nunca consegue ver)
O ícone do escudo (🔒) na aba escrever, ou cpy -e pelo terminal, é uma camada diferente da senha acima: com senha, o servidor descriptografa brevemente o próprio texto para verificá-lo; aqui, a criptografia acontece inteiramente do seu lado - o servidor nunca vê nada além do texto cifrado.
- Seu navegador (ou cpy -e) gera uma chave aleatória - ela nunca sai da sua máquina.
- O texto é criptografado com essa chave, no navegador (WebCrypto AES-256-GCM) ou no terminal (openssl).
- Apenas o texto cifrado é enviado ao servidor, e é tudo o que ele chega a armazenar - ele nunca vê o texto simples.
- A chave viaja na parte #key= do link (navegadores nunca enviam o fragmento ao servidor) ou é passada separadamente com pst -key= no terminal - o link/código sozinho é inútil sem ela.
⚠️ Aviso: isso não elimina o risco de encaminhar algo para um shell (curl ... | bash) sem revisar antes - esse é um risco universal para qualquer ferramenta de compartilhamento, não específico deste. Nunca execute um comando que você não inspecionou de uma fonte não confiável.
Limites
Tamanho máximo: 2 MB · Código: 6 dígitos · Exclusão automática: 2min por padrão, selecionável até 1d · Leituras: 1 por padrão, até 10
CPYNET v1.0 — um único arquivo, um único binário Go — sem banco de dados externo nem dependências.