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 concretsop, incluant les patrons sécurisés de création/édition d'éléments)
Workflow
- Vérifier le système d'exploitation et le shell.
- Vérifier la présence du CLI dans tmux :
op --version. - OBLIGATOIRE : créer une seule session tmux persistante et nommée pour toute la tâche de secret.
- Essayer d'abord l'accès via service-account lorsque un token ou workflow correspondant existe ; pas de dialogues.
- 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.
- Fallback desktop : déclencher l'intégration/déverrouillage de l'application, puis
op signinune 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. - Vérifier le chemin d'accès choisi dans cette même session :
op whoami. - En cas de plusieurs comptes : utiliser
--accountouOP_ACCOUNT. - 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.comsur chaque commandeoplors du stockage ou de la lecture de secrets. Ne pas se fier à la sélection de compte ambiante. op account listest 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.compeut 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
~/.profilesousOP_SERVICE_ACCOUNT_TOKENdans un bloc géré par Codex. Il est limité au coffre restreintMolty. - 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 coffreMolty. - 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
opvia 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 :
opdans 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 injectplutô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 signindans 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
open dehors de tmux ; s'arrêter et demander si tmux n'est pas disponible.