steipete/one-password

Accès ciblé en lecture/stockage/injection de secrets 1Password via service-account en priorité, avec fallback applicatif desktop, le tout orchestré dans une session tmux persistante.

Qu'est-ce que one-password ?

Cette compétence permet d'interagir avec l'interface en ligne de commande (CLI) de 1Password (`op`) de manière fiable et sécurisée dans un environnement de développement piloté par IA (Codex, Cursor, Claude Code). Elle privilégie l'utilisation d'un token de service-account (non interactif, limité à un coffre spécifique) pour la récupération de secrets, évitant ainsi les dialogues intempestifs. Si le token n'est pas applicable ou si le secret visé n'est pas accessible, la compétence bascule automatiquement sur l'application de bureau 1Password, en orchestrant l'authentification via une session tmux persistante dédiée. Toutes les commandes `op` sont exécutées dans cette session tmux unique, ce qui garantit que l'état d'authentification (sign-in) est maintenu et que les échecs de quoting ou de nom d'élément peuvent être corrigés sans créer de nouvelles sessions. La compétence fournit des patrons shell éprouvés pour la création, la lecture exacte (avec validation de forme, jamais de valeur brute) et la recherche explicite d'éléments, le tout sans jamais exposer les secrets dans les logs, la session de chat ou le code. Elle gère aussi le routage multi-comptes (par défaut `my.1password.com`), le debugging avec valeurs masquées, et impose des garde-fous stricts comme l'interdiction d'exécuter `op` en dehors de tmux.

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

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

CLI 1Password

Suivez les étapes officielles de démarrage du CLI. Ne devinez pas les commandes d'installation.

Références

  • Documentation officielle : https://developer.1password.com/docs/cli/get-started/
  • references/get-started.md (installation + intégration applicative + flux de connexion)
  • references/cli-examples.md (exemples concrets op, incluant les patrons sécurisés de création/édition d'éléments)

Workflow

  1. Vérifier le système d'exploitation et le shell.
  2. Vérifier la présence du CLI dans tmux : op --version.
  3. OBLIGATOIRE : créer une seule session tmux persistante et nommée pour toute la tâche de secret.
  4. Essayer d'abord l'accès via service-account lorsque un token ou workflow correspondant existe ; pas de dialogues.
  5. Si l'accès service-account est absent ou ne possède pas l'élément/champ exact nécessaire, basculer automatiquement vers le fallback applicatif desktop dans la même session. Ne pas demander d'abord la permission dans le chat.
  6. Fallback desktop : déclencher l'intégration/déverrouillage de l'application, puis op signin une fois dans la même session. La demande 1Password est la limite d'approbation utilisateur ; ne demander dans le chat que si la demande ne peut pas être affichée ou complétée.
  7. Vérifier le chemin d'accès choisi dans cette même session : op whoami.
  8. En cas de plusieurs comptes : utiliser --account ou OP_ACCOUNT.
  9. Si une commande échoue, réutiliser la même session tmux avec tmux send-keys ; ne pas démarrer une seconde session juste pour réessayer.

Compte par défaut

  • Le compte par défaut pour les secrets personnels/professionnels est my.1password.com.
  • Ne pas utiliser my.1password.eu / Titan silencieusement, sauf demande explicite.
  • Passer --account my.1password.com sur chaque commande op lors du stockage ou de la lecture de secrets. Ne pas se fier à la sélection de compte ambiante.
  • op account list est uniquement méta-données, mais doit quand même s'exécuter dans tmux. L'utiliser pour confirmer les noms de compte lorsque le routage n'est pas clair.
  • op signin --account my.1password.com peut retourner un statut 0 sans sortie utile et ne pas rendre un shell ultérieur connecté. Privilégier la connexion, la création/édition/récupération et la vérification dans le même shell tmux.

Tokens de service-account

  • Privilégier les tokens de service-account avant tout flux interactif 1Password. Les dialogues utilisateur ne sont qu'un fallback.
  • Les service-accounts 1Password sont des tokens non interactifs pour un coffre/périmètre spécifique, utiles pour l'automatisation sans déverrouiller l'application desktop.
  • Le token de service-account par défaut de Peter est exporté depuis ~/.profile sous OP_SERVICE_ACCOUNT_TOKEN dans un bloc géré par Codex. Il est limité au coffre restreint Molty.
  • Les shells plus anciens peuvent exposer la même valeur sous MOLTY_OP_SERVICE_ACCOUNT_TOKEN ; le traiter comme un alias de fallback pour les éléments connus du coffre Molty.
  • Si le token n'est pas déjà exporté, n'est pas applicable, ou ne peut pas lire l'élément/champ exact demandé, utiliser le flux 1Password applicatif desktop ci-dessous automatiquement. Ne demander que lorsqu'une opération réelle de déverrouillage ou une autre interaction utilisateur reste bloquée.
  • Exporter/passer le token uniquement pour la commande unique qui en a besoin : OP_SERVICE_ACCOUNT_TOKEN="$OP_SERVICE_ACCOUNT_TOKEN" op item get "<élément connu>" --vault Molty ....
  • Les lectures op via service-account nécessitent une requête de coffre explicite ; omettre --vault Molty échoue même si le token est valide.
  • Respecter la règle tmux : chaque commande op, y compris les lectures service-account, s'exécute toujours dans une session tmux nommée.
  • Ne pas énumérer les coffres/éléments avec les service-accounts par défaut. Si l'utilisateur demande explicitement une recherche, fournit une capture d'écran/un listing, ou donne uniquement un nom d'élément flou, utiliser la recherche sécurisée de méta-données ci-dessous avant le fallback desktop.
  • N'afficher que la présence/forme, jamais la valeur du token ou du secret.

Session Tmux Persistante Obligatoire

L'outil shell utilise un TTY frais par commande. Exécuter op dans une session tmux dédiée et continuer à utiliser cette même session jusqu'à ce que toute la tâche de secret soit terminée. Les commandes service-account s'exécutent également ici, mais ne doivent pas déclencher d'invites applicatives.

Exemple :

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

Ne pas créer une nouvelle session tmux après un échec de quoting, de nom d'élément ou de commande. Envoyer une commande corrigée dans la session existante. Cibler la session avec $SESSION: au lieu de supposer la fenêtre 0 ; les sessions plus anciennes peuvent avoir des index de fenêtre commençant à 1.

Workflows Spécifiques aux Services

  • Conserver les détails d'authentification spécifiques au service dans la compétence propriétaire.
  • Pour le travail avec le registre npm/package, utiliser $npm ; il documente l'élément service-account Molty, le wrapper d'authentification non interactif et l'assistant de réservation de package.
  • Cette compétence ne possède que les règles génériques 1Password : op dans tmux uniquement, lectures ciblées, une session persistante, pas d'énumération large, pas de sortie de secret.

Patron connu d'écriture de secret

Utiliser la session tmux persistante. Écrire la tâche de secret exacte dans un script temporaire, puis envoyer ce script dans op-work ; ne pas créer une seconde session tmux pour les réessais.

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 "clipboard value does not match expected prefix" >&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 "stored and verified secret field without printing it"
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 chaîne de catégorie op est lisible et sensible à la casse dans ce build CLI ; utiliser "API Credential", pas api_credential.

Lectures exactes de champ

Pour un élément connu, vérifier la forme du champ avant de l'utiliser en direct : longueur, préfixe attendu, nombre de sauts de ligne, jamais la valeur. op --field NAME et --fields label=NAME peuvent retourner le mauvais champ masqué lorsqu'un élément a des champs d'identification en double/anciens. Si la forme est incorrecte, lire l'élément connu en JSON et extraire l'étiquette exacte.

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

Limiter l'extraction JSON à l'élément et au coffre connus. Ne pas énumérer les coffres/éléments pour découvrir des candidats.

Recherche explicite d'élément

Utiliser ceci uniquement lorsque l'utilisateur demande explicitement une recherche, fournit une capture d'écran/un listing, ou que la supposition du titre exact a échoué et que l'utilisateur demande une recherche par expression régulière/floue. Rester dans le coffre et ne renvoyer que des méta-données ; afficher les titres/ids/catégories/noms de coffre candidats, jamais les champs ou valeurs. Privilégier d'abord les chaînes visibles exactes des captures d'écran : nom du coffre, titre de l'élément et étiquette du champ.

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

Après avoir choisi un candidat, revenir à l'extraction JSON exacte de l'élément/champ et à la validation de forme uniquement. Un élément personnel connu exact peut utiliser le fallback desktop automatiquement ; ne pas énumérer largement les coffres personnels sauf si l'utilisateur a demandé une recherche.

Débogage avec données masquées

Maintenir tout le pipeline dans la même session tmux. Inspecter le statut et la longueur de la sortie, jamais les valeurs secrètes.

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 "signin output bytes: ${#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

Garde-fous

  • Ne jamais coller de secrets dans les logs, le chat ou le code.
  • Privilégier op run / op inject plutôt que d'écrire des secrets sur le disque.
  • Si une connexion sans intégration applicative est nécessaire, utiliser op account add.
  • Si une commande retourne "account is not signed in", réexécuter op signin dans tmux et autoriser dans l'application.
  • Laisser l'invite de déverrouillage 1Password desktop demander l'interaction utilisateur directement ; ne pas ajouter un aller-retour de permission supplémentaire dans le chat au préalable.
  • Ne pas exécuter op en dehors de tmux ; s'arrêter et demander si tmux n'est pas 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 associés