CPYNET — Portapapeles en línea para compartir copiar-pegar vía curl

CPYNET
comparativa casos de uso privacidad estado llms.txt

Al escanearlo se abre y se lee directamente en el navegador del móvil.

En PowerShell de Windows, escribe curl.exe en lugar del alias curl — si no, los textos largos pueden truncarse en la consola.
terminal
$

Instalación

Configura un alias persistente (una vez)

curl -s https://cpynet.com/install.sh -o install.sh && bash -n install.sh && . install.sh

SHA256 de install.sh: 86bd4b2171ea3f0e8e845df8585e69a3d452eb94855bbab7dd097c8af9b96887

Leer install.sh antes de ejecutarlo 
# 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 del script que descarga install.sh (~/.cpy.sh): 8161c889a7240a3958267ffdb1697cff311246b5c4aaf57c02d44aa1d397a17e

Lee también ese script (también sirve como instalación manual - copia la función de abajo directamente) 
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
}

Después solo: comando | cpy — imprime el código de 6 dígitos y un comando curl listo para usar en dos líneas. Para protegerlo con contraseña: comando | cpy -password=xxx. Para leer: pst 123456 — imprime el contenido en stdout y también lo copia al portapapeles si encuentra la forma (pbcopy/wl-copy/xclip/xsel/clip.exe).

Los enlaces se generan en el dominio corto https://llmtag.com; el comando de instalación de arriba se descarga del sitio principal, https://cpynet.com - es el mismo servicio, solo un dominio corto independiente reservado para los enlaces.

Windows / PowerShell

Invoke-RestMethod https://cpynet.com/install.ps1 -OutFile install.ps1; . .\install.ps1

SHA256 de install.ps1: 0ab2333a4ea86b1b8797c2b8251daa368d485dfeaa6dfcaad90c076d0217b43c

Leer install.ps1 antes de ejecutarlo 
# 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 del script que descarga install.ps1 (~/.cpy.ps1): 356ae02c39d58c86d717899969cf961e519eac156105140671c63941b9b5aa17

Lee también ese script (también sirve como instalación manual - copia las funciones de abajo directamente) 
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
	}
}

Esto añade las funciones cpy/pst a $PROFILE una vez - después, "texto" | cpy y pst 123456 funcionan igual que en la versión bash (los parámetros usan el propio estilo de PowerShell: cpy -Ttl 1h -Reads 3 -Password xxx, pst 123456 -Password xxx).

Uso

Usar la interfaz web

1. Escribe tu texto1. Escribe tu texto

1. Escribe tu texto
Pega tu texto o código en la pestaña de escritura y pulsa enviar.

2. Comparte el código, el enlace o el QR2. Comparte el código, el enlace o el QR

2. Comparte el código, el enlace o el QR
Al enviarlo se genera un código de 6 dígitos, un comando curl listo para usar y un código QR escaneable.

3. Introduce el código3. Introduce el código

3. Introduce el código
En la pestaña de lectura, introduce el código — o escanea el código QR con el móvil.

4. Se lee una vez y desaparece4. Se lee una vez y desaparece

4. Se lee una vez y desaparece
El contenido aparece al instante y se elimina permanentemente del servidor — el mismo código no volverá a funcionar.

Enviar desde la terminal

comando | curl --data-binary @- https://llmtag.com/

La respuesta es un enlace listo para usar.

Leer desde la terminal

curl "tu-enlace"

Se lee una vez y luego se elimina permanentemente. ¿Tienes el alias instalado? pst 123456.

Protege con contraseña

Rellena el campo de contraseña de abajo — el enlace incluirá automáticamente ?p=contraseña.

Windows / PowerShell

Invoke-RestMethod -Method Post -Body "texto" -Uri https://llmtag.com/
Invoke-RestMethod "tu-enlace"

También funciona el Invoke-RestMethod integrado, en lugar de curl.exe.

Integración API / CI

Añade Accept: application/json a la petición de creación para recibir {"code","url","expires_at"} en lugar de texto plano - más fácil de procesar en un script. Referencia completa, incluyendo códigos de estado (400/401/404/413/429/503) y un ejemplo de GitHub Actions: /api.

Preguntas frecuentes

¿Cuántas veces se puede usar un código?

Solo una vez. Se elimina permanentemente del servidor en el instante en que se lee.

¿Qué pasa cuando se acaba el tiempo?

Aunque nadie lo lea, el paste se elimina automáticamente - no queda ningún rastro en el servidor.

¿Cómo lo uso si tengo el portapapeles desactivado?

CPYNET nunca toca el portapapeles - todo se mueve mediante curl desde la terminal, así que un portapapeles desactivado no supone ningún problema.

¿El servidor ve o guarda lo que pego?

El texto solo se mantiene en memoria, nunca se escribe en disco - se elimina permanentemente en el momento en que se lee o se agota el tiempo. Si está protegido con contraseña, se guarda cifrado con AES-256-GCM.

¿Funciona en Windows?

Sí - en PowerShell, escribe curl.exe en lugar del alias curl, si no, los textos largos pueden truncarse en la consola. O usa el Invoke-RestMethod integrado, o instala las funciones cpy/pst con la sección de Windows / PowerShell de arriba.

¿Cuál es el tamaño máximo y la longitud del código?

Hasta 2 MB, un código de 6 dígitos, se autoelimina en 2min por defecto - seleccionable hasta 1d (el parámetro ?ttl=, o el selector de TTL en la pestaña de escritura). Se elimina tras 1 lectura por defecto - seleccionable hasta 10 lecturas (el parámetro ?reads=, o el selector de lecturas).

¿Por qué CPYNET?

Creado para entornos donde compartir el portapapeles no es una opción: servidores remotos por SSH, máquinas donde el acceso al portapapeles está bloqueado por política, o máquinas/contenedores/escritorios virtuales independientes sin portapapeles compartido entre ellos. CPYNET nunca toca el portapapeles del sistema operativo - todo se mueve como texto plano a través de curl - así que se puede usar con confianza incluso donde el portapapeles está completamente desactivado.

Características

  • Lectura única: se elimina permanentemente en el momento en que se lee
  • Se autoelimina cuando se acaba el tiempo, aunque nadie lo lea
  • Compartición protegida con contraseña: AES-256-GCM + PBKDF2, el servidor solo mantiene el texto plano de forma momentánea
  • Notificación en vivo: tu pestaña se entera en el instante en que se lee (SSE)
  • Soporte de archivos pequeños (solo extensiones permitidas, se conservan como máximo 1 hora): 📎 para adjuntar uno, se descarga de vuelta con su nombre de archivo y tipo de contenido originales
  • Límite de frecuencia por IP: protege contra la adivinación de códigos y ataques de fuerza bruta

Extensiones de archivo permitidas: .txt, .log, .csv, .json, .md, .pdf, .doc, .docx, .rtf, .xml, .yaml, .yml, .pem, .crt, .key, .conf, .cfg, .env, .ini, .toml

Seguridad

El servidor nunca ejecuta, evalúa ni canaliza lo que pegas hacia un shell - solo lo almacena y lo devuelve exactamente como lo recibió. Sin dependencias de terceros (biblioteca estándar de Go pura), sin acceso al sistema de archivos con datos del usuario, sin peticiones salientes.

Cifrado de conocimiento cero (el servidor nunca puede verlo)

El icono del escudo (🔒) en la pestaña de escritura, o cpy -e desde una terminal, es una capa distinta de la contraseña anterior: con una contraseña, el servidor descifra brevemente el propio texto para comprobarlo; aquí, el cifrado ocurre por completo de tu lado - el servidor nunca ve nada más que texto cifrado.

  1. Tu navegador (o cpy -e) genera una clave aleatoria - nunca sale de tu máquina.
  2. El texto se cifra con esa clave, en el navegador (WebCrypto AES-256-GCM) o en la terminal (openssl).
  3. Solo el texto cifrado se envía al servidor, y eso es todo lo que llega a almacenar - nunca ve el texto plano.
  4. La clave viaja en la parte #key= del enlace (los navegadores nunca envían el fragmento al servidor) o se entrega por separado con pst -key= en una terminal - el enlace/código por sí solo es inútil sin ella.

⚠️ Aviso: esto no elimina el riesgo de canalizar algo hacia un shell (curl ... | bash) sin revisarlo antes - ese es un riesgo universal para cualquier herramienta de compartición, no específico de esta. Nunca ejecutes un comando que no hayas inspeccionado desde una fuente en la que no confíes.

Límites

Tamaño máximo: 2 MB · Código: 6 dígitos · Borrado automático: 2min por defecto, seleccionable hasta 1d · Lecturas: 1 por defecto, hasta 10

CPYNET v1.0 — un solo archivo, un solo binario de Go — sin base de datos externa ni dependencias.

comparativa · casos de uso · privacidad · estado · llms.txt

Hecho por Emin Buyuk