CLI de 1Password
Sigue los pasos oficiales de inicio rápido de la CLI. No adivines comandos de instalación.
Referencias
- Documentación oficial: https://developer.1password.com/docs/cli/get-started/
references/get-started.md(instalación + integración de aplicación + flujo de inicio de sesión)references/cli-examples.md(ejemplos reales deop, incluidos patrones seguros de creación/edición de ítems)
Flujo de trabajo
- Verifica el sistema operativo y el shell.
- Comprueba que la CLI esté presente dentro de tmux:
op --version. - OBLIGATORIO: crea exactamente una sesión de tmux persistente y con nombre para toda la tarea de secretos.
- Intenta primero el acceso con token de cuenta de servicio (service-account) cuando exista un token/flujo coincidente; sin diálogos.
- Si el acceso con cuenta de servicio no está disponible o le falta el ítem/campo exacto necesario, prueba automáticamente el respaldo de la aplicación de escritorio en la misma sesión. No pidas permiso primero en el chat.
- Respaldo de escritorio: dispara la integración/desbloqueo de la aplicación, luego
op signinuna vez dentro de la misma sesión. El aviso de 1Password es el límite de aprobación del usuario; pregunta en el chat solo si el aviso no se puede mostrar o completar. - Verifica la ruta de acceso elegida dentro de esa misma sesión:
op whoami. - Si hay múltiples cuentas: usa
--accountoOP_ACCOUNT. - Si un comando falla, reutiliza la misma sesión de tmux con
tmux send-keys; no inicies una segunda sesión solo para reintentar.
Cuenta predeterminada
- La cuenta predeterminada para secretos personales/laborales es
my.1password.com. - No uses silenciosamente
my.1password.eu/ Titan a menos que se te pida explícitamente. - Pasa
--account my.1password.comen cada comandoopal almacenar o leer secretos. No confíes en la selección de cuenta ambiental. op account listes solo metadatos, pero igual debe ejecutarse dentro de tmux. Úsalo para confirmar nombres de cuenta cuando el enrutamiento no esté claro.op signin --account my.1password.compuede devolver estado 0 sin salida útil y aun así no dejar un shell posterior autenticado. Prefiere hacer inicio de sesión, creación/edición/lectura y verificación en el mismo shell de tmux.
Tokens de cuenta de servicio
- Prefiere tokens de cuenta de servicio antes que cualquier flujo interactivo de 1Password. Los diálogos de usuario son solo un respaldo.
- Las cuentas de servicio de 1Password son tokens no interactivos para un vault/ámbito específico, útiles para automatización sin desbloquear la aplicación de escritorio.
- El token de cuenta de servicio predeterminado de Peter se exporta desde
~/.profilecomoOP_SERVICE_ACCOUNT_TOKENen un bloque gestionado por Codex. Está limitado al vault restringidoMolty. - Los shells más antiguos pueden exponer el mismo valor como
MOLTY_OP_SERVICE_ACCOUNT_TOKEN; trátalo como un alias de respaldo para ítems conocidos del vaultMolty. - Si el token no está ya exportado, no es aplicable, o no se puede leer el ítem/campo exacto requerido, usa el flujo de 1Password de aplicación de escritorio automáticamente. Pregunta solo cuando un desbloqueo real u otra interacción del usuario permanezca bloqueada.
- Exporta/pasa el token solo para el comando único que lo necesita:
OP_SERVICE_ACCOUNT_TOKEN="$OP_SERVICE_ACCOUNT_TOKEN" op item get "<ítem conocido>" --vault Molty .... - Las lecturas de
opcon cuenta de servicio requieren una consulta explícita de vault; omitir--vault Moltyfalla incluso si el token es válido. - Mantén la regla de tmux: cada comando
op, incluidas las lecturas con cuenta de servicio, se ejecuta dentro de una sesión de tmux con nombre. - No enumeres vaults/ítems con cuentas de servicio por defecto. Si el usuario pide explícitamente buscar, proporciona una captura de pantalla/listado, o solo un nombre de ítem difuso, usa la búsqueda segura de metadatos a continuación antes del respaldo de escritorio.
- Imprime solo presencia/forma, nunca token ni valores secretos.
Sesión persistente de tmux requerida
La herramienta de shell usa un TTY nuevo por comando. Ejecuta op dentro de una sesión de tmux dedicada y sigue usando esa misma sesión hasta que toda la tarea de secretos esté completa. Los comandos de cuenta de servicio también se ejecutan aquí, pero no deben disparar avisos de aplicación.
Ejemplo:
SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}"
mkdir -p "$SOCKET_DIR"
SOCKET="$SOCKET_DIR/clawdbot-op.sock"
SESSION="op-work"
tmux -S "$SOCKET" has-session -t "$SESSION" 2>/dev/null ||
tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
tmux -S "$SOCKET" send-keys -t "$SESSION:" -- "op signin --account my.1password.com" Enter
tmux -S "$SOCKET" send-keys -t "$SESSION:" -- "op whoami" Enter
tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION:" -S -200
No crees una nueva sesión de tmux después de un error de escape, nombre de ítem o comando. Envía un comando corregido en la sesión existente. Apunta a la sesión como $SESSION: en lugar de asumir la ventana 0; las sesiones antiguas pueden tener índices de ventana comenzando en 1.
Flujos de trabajo específicos de servicios
- Mantén los detalles de autenticación específicos del servicio en la habilidad propietaria.
- Para trabajo con registro/paquetes npm, usa
$npm; documenta el ítem de cuenta de servicio de Molty, el envoltorio de autenticación no interactivo y el ayudante de reserva de paquetes. - Esta habilidad solo posee las reglas genéricas de 1Password:
opsolo en tmux, lecturas dirigidas, una sesión persistente, sin enumeración amplia, sin salida de secretos.
Patrón conocido de escritura segura de secretos
Usa la sesión persistente de tmux. Escribe la tarea exacta de secretos en un script temporal, luego envía ese script a op-work; no crees una segunda sesión de tmux para reintentos.
SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}"
SOCKET="$SOCKET_DIR/clawdbot-op.sock"
SESSION="op-work"
tmux -S "$SOCKET" has-session -t "$SESSION" 2>/dev/null ||
tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
cat > /tmp/op-store-secret.sh <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
set +x
ACCOUNT="my.1password.com"
ITEM_TITLE="Service API Tokens"
FIELD_NAME="api_token"
EXPECTED_PREFIX=""
NOTES="Created via tmux-safe op workflow"
TOKEN="$(pbpaste)"
if [ -n "$EXPECTED_PREFIX" ]; then
case "$TOKEN" in "$EXPECTED_PREFIX"*) ;; *) echo "El valor del portapapeles no coincide con el prefijo esperado" >&2; exit 2;; esac
fi
op item create --account "$ACCOUNT" --category "API Credential" --title "$ITEM_TITLE" "$FIELD_NAME[password]=$TOKEN" "notesPlain=$NOTES" >/dev/null
op item get "$ITEM_TITLE" --account "$ACCOUNT" --fields "label=$FIELD_NAME" >/dev/null
echo "almacenado y verificado el campo secreto sin imprimirlo"
SCRIPT
chmod 700 /tmp/op-store-secret.sh
tmux -S "$SOCKET" send-keys -t "$SESSION" -- "bash /tmp/op-store-secret.sh; rm -f /tmp/op-store-secret.sh" C-m
La cadena de categoría de op es legible por humanos y sensible a mayúsculas en esta versión de la CLI; usa "API Credential", no api_credential.
Lectura exacta de campos
Para un ítem conocido, verifica la forma del campo antes de usarlo en vivo: longitud, prefijo esperado, cantidad de saltos de línea, nunca el valor. op --field NAME y --fields label=NAME pueden devolver el campo oculto incorrecto cuando un ítem tiene campos de credencial duplicados/heredados. Si la forma es incorrecta, lee el ítem conocido como JSON y extrae la etiqueta exacta.
cat > /tmp/op-read-field.sh <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
set +x
ITEM_TITLE="Known API Credential Item"
FIELD_LABEL="api_token"
VAULT="Molty"
value="$(
OP_SERVICE_ACCOUNT_TOKEN="$OP_SERVICE_ACCOUNT_TOKEN" \
op item get "$ITEM_TITLE" --vault "$VAULT" --format json |
FIELD_LABEL="$FIELD_LABEL" node -e 'let s=""; process.stdin.on("data",d=>s+=d); process.stdin.on("end",()=>{const item=JSON.parse(s); const f=(item.fields||[]).find(x=>x.label===process.env.FIELD_LABEL); if(!f?.value) process.exit(2); process.stdout.write(f.value);})'
)"
echo "field_len:${#value}"
case "$value" in sk-*) echo "field_prefix:sk" ;; *) echo "field_prefix:other" ;; esac
echo "field_has_newline:$(printf %s "$value" | wc -l | tr -d ' ')"
SCRIPT
chmod 700 /tmp/op-read-field.sh
tmux -S "$SOCKET" send-keys -t "$SESSION:" -- "bash /tmp/op-read-field.sh; rm -f /tmp/op-read-field.sh" C-m
Mantén la extracción JSON limitada al ítem y vault conocidos. No enumeres vaults/ítems para descubrir candidatos.
Búsqueda explícita de ítems
Usa esto solo cuando el usuario pida explícitamente buscar, proporcione una captura de pantalla/listado, o la adivinanza exacta del título haya fallado y el usuario solicite búsqueda por expresión regular/difusa. Mantente dentro del vault y solo metadatos; imprime títulos/IDs/categorías/nombres de vault candidatos, nunca campos ni valores. Prefiere primero cadenas visibles exactas de capturas de pantalla: nombre del vault, título del ítem y etiqueta del campo.
cat > /tmp/op-find-item.sh <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
set +x
VAULT="Molty"
QUERY="minimax"
OP_SERVICE_ACCOUNT_TOKEN="$OP_SERVICE_ACCOUNT_TOKEN" \
op item list --vault "$VAULT" --format json |
QUERY="$QUERY" VAULT="$VAULT" node -e '
let s=""; process.stdin.on("data",d=>s+=d); process.stdin.on("end",()=>{
const q=process.env.QUERY.toLowerCase();
const vault=process.env.VAULT;
const items=JSON.parse(s).filter(x => [
x.title, x.id, x.category, ...(x.tags || [])
].filter(Boolean).join("\n").toLowerCase().includes(q));
for (const item of items.slice(0, 10)) {
console.log(`title:${item.title} id:${item.id} category:${item.category || ""} vault:${vault}`);
}
console.log(`matches:${items.length}`);
})'
SCRIPT
chmod 700 /tmp/op-find-item.sh
tmux -S "$SOCKET" send-keys -t "$SESSION:" -- "bash /tmp/op-find-item.sh; rm -f /tmp/op-find-item.sh" C-m
Después de elegir un candidato, vuelve a la extracción JSON exacta del ítem/campo y validación solo de forma. Un ítem personal conocido exacto puede usar el respaldo de escritorio automáticamente; no enumeres ampliamente vaults personales a menos que el usuario haya pedido buscar.
Depuración con datos redactados
Mantén toda la canalización dentro de la misma sesión de tmux. Inspecciona el estado y la longitud de la salida, nunca los valores secretos.
cat > /tmp/op-debug.sh <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
set +x
SIGNIN_OUTPUT="$(op signin --account my.1password.com 2>&1 || true)"
echo "bytes de salida de signin: ${#SIGNIN_OUTPUT}"
op account list 2>&1 | sed -E "s/(xox[baprs]-)[A-Za-z0-9-]+/\\1REDACTED/g; s/(xapp-)[A-Za-z0-9-]+/\\1REDACTED/g"
SCRIPT
chmod 700 /tmp/op-debug.sh
tmux -S "$SOCKET" send-keys -t "$SESSION" -- "bash /tmp/op-debug.sh; rm -f /tmp/op-debug.sh" C-m
Guardarraíles
- Nunca pegues secretos en registros, chat o código.
- Prefiere
op run/op injectsobre escribir secretos en disco. - Si se necesita inicio de sesión sin integración de aplicación, usa
op account add. - Si un comando devuelve "account is not signed in", vuelve a ejecutar
op signindentro de tmux y autoriza en la aplicación. - Deja que el aviso de desbloqueo de la aplicación de escritorio de 1Password solicite interacción del usuario directamente; no añadas un viaje de ida y vuelta de permiso separado en el chat primero.
- No ejecutes
opfuera de tmux; detente y pregunta si tmux no está disponible.