CommunityProgramación y desarrollogithub.com

steipete/one-password

1Password/op: acceso con token de servicio primero, lectura/almacenamiento/inyección de secretos específicos, tmux.

¿Qué es one-password?

Esta habilidad proporciona una integración robusta y segura con la CLI de 1Password (`op`), diseñada para agentes de IA como Claude Code o Codex. Su enfoque principal es utilizar tokens de cuenta de servicio (service-account) para operaciones no interactivas, evitando en lo posible diálogos con el usuario. Cuando el token es insuficiente, recurre automáticamente a la aplicación de escritorio como respaldo, sin pedir permiso en el chat primero. El flujo de trabajo exige el uso de una única sesión persistente de tmux para todos los comandos `op`, asegurando coherencia y evitando problemas de autenticación. La habilidad especifica comandos detallados para leer campos exactos de un ítem conocido (con verificación de forma, longitud y prefijo), buscar ítems de forma limitada y segura, y almacenar secretos sin exponer sus valores. Incluye guardarraíles como la redacción de secretos en logs y la preferencia por `op run`/`op inject`. Soporta la cuenta predeterminada `my.1password.com` y requiere el uso explícito del flag `--account`. La documentación incluye ejemplos de código reales para leer campos exactos, buscar ítems, y depurar, todo dentro de tmux y sin revelar valores sensibles. Es una herramienta esencial para automatizar el acceso a secretos en entornos de desarrollo y CI/CD.

Compatible con~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/steipete/agent-scripts/tree/main/skills/one-password

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

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 de op, incluidos patrones seguros de creación/edición de ítems)

Flujo de trabajo

  1. Verifica el sistema operativo y el shell.
  2. Comprueba que la CLI esté presente dentro de tmux: op --version.
  3. OBLIGATORIO: crea exactamente una sesión de tmux persistente y con nombre para toda la tarea de secretos.
  4. Intenta primero el acceso con token de cuenta de servicio (service-account) cuando exista un token/flujo coincidente; sin diálogos.
  5. 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.
  6. Respaldo de escritorio: dispara la integración/desbloqueo de la aplicación, luego op signin una 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.
  7. Verifica la ruta de acceso elegida dentro de esa misma sesión: op whoami.
  8. Si hay múltiples cuentas: usa --account o OP_ACCOUNT.
  9. 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.com en cada comando op al almacenar o leer secretos. No confíes en la selección de cuenta ambiental.
  • op account list es 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.com puede 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 ~/.profile como OP_SERVICE_ACCOUNT_TOKEN en un bloque gestionado por Codex. Está limitado al vault restringido Molty.
  • 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 vault Molty.
  • 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 op con cuenta de servicio requieren una consulta explícita de vault; omitir --vault Molty falla 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: op solo 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 inject sobre 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 signin dentro 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 op fuera de tmux; detente y pregunta si tmux no está disponible.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

steipete/agent-transcript

GitHub PR/issue agent transcripts: redact, preview, and insert safely.

steipete/beeper

Beeper cache: contact hints, room lookup, WhatsApp/iMessage traces, FTS.

steipete/browser-use

Existing Chrome automation: Chrome plugin first, mcporter fallback.

steipete/clawsweeper-status

ClawSweeper status: URLs, workflow health, active workers, ops snapshot.

steipete/clickclack

ClickClack ops: chat app, Hetzner deploy, DNS/docs/app, Docker rollout.

steipete/cloudflare-registrar

Cloudflare Registrar: domain availability, prices, registration via mcporter.

steipete/codex-debugging

Codex debugging: codex-rs core/tui/exec/cli/app-server/config.

steipete/create-cli

CLI UX/spec: args, flags, help, output, errors, config, dry-run.

steipete/discord-clawd

Discord-backed OpenClaw agent/session relay; not archive search.

steipete/domain-dns-ops

DNS/domain ops: registrars, zones, redirects, DNS/HTTP verify, manager truth.

steipete/frontend-design

Frontend UI: pages, apps, components, polished non-generic design.

steipete/github-author-context

GitHub contributor context: identity, activity, trust, company/team signal.

steipete/github-cache-hygiene

GitHub quota/cache hygiene: gh, ghx, xcache, gitcrawl, mirrors, limits.

steipete/github-deep-review

GitHub deep review: bugs, PRs, best fix, stale-or-real, read code first.

steipete/github-project-triage

GitHub issue/PR triage: queues, CI, blockers, risk, proof, next actions.

steipete/hopper-debugger

Hopper debugging: macOS/iOS binaries, ObjC/Swift symbols, dyld, LLDB.

steipete/instruments-profiling

Instruments/xctrace profiling: macOS/iOS traces, binaries, args, exports.

steipete/mac-maintenance

Mac upkeep: brew update/upgrade, pull clean repos, empty Trash.

steipete/maintainer-orchestrator

Open-source maintainer orchestration: Codex app workers, work recovery, dependencies, vision, releases.

steipete/markdown-converter

Markdown conversion: PDF, Office, HTML, data, OCR, audio, ZIP, YouTube.

Skills relacionados