steipete/one-password

1Password/op: acesso via service-account primeiro, leitura/armazenamento/injeção direcionada de segredos, tmux.

O que é one-password?

Esta skill estabelece regras rigorosas para agentes de IA (como Claude Code, Cursor ou Codex) interagirem com o 1Password CLI (`op`). Seu principal objetivo é garantir que todas as operações de segredos sejam seguras, não interativas quando possível e confinadas a uma única sessão tmux persistente. A skill prioriza o uso de tokens de service-account, que permitem automação sem depender do aplicativo desktop ou de ações do usuário, recorrendo ao fluxo interativo do 1Password desktop apenas como fallback para itens que não estão no vault restrito do service-account. O fluxo de trabalho é otimizado para ferramentas de shell que abrem um novo TTY para cada comando, utilizando uma sessão tmux nomeada e um socket específico para manter o estado de autenticação, evitando múltiplos prompts ou quebras de sessão. A skill também fornece padrões para leitura exata de campos, escrita segura de segredos e busca explícita de itens, sempre com fortes guardrails que proíbem a saída de valores secretos em logs, depuração ou mensagens do chat.

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

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

1Password CLI

Siga os passos oficiais de início rápido da CLI. Não adivinhe comandos de instalação.

Referências

  • Documentação oficial: https://developer.1password.com/docs/cli/get-started/
  • references/get-started.md (instalação + integração com aplicativo + fluxo de login)
  • references/cli-examples.md (exemplos reais de op, incluindo padrões seguros de criação/edição de itens)

Fluxo de Trabalho

  1. Verifique o SO + shell.
  2. Confirme a presença da CLI dentro do tmux: op --version.
  3. OBRIGATÓRIO: crie exatamente uma sessão tmux nomeada persistente para toda a tarefa de segredo.
  4. Tente primeiro acesso via service-account com escopo quando existir um token/workflow correspondente; sem diálogos.
  5. Se o acesso por service-account estiver ausente ou não tiver o item/campo exato necessário, tente automaticamente o fallback para o aplicativo desktop na mesma sessão. Não peça permissão no chat primeiro.
  6. Fallback para desktop: acione a integração/desbloqueio do aplicativo, depois execute op signin na mesma sessão. O prompt do 1Password é o limite de aprovação do usuário; pergunte no chat apenas se o prompt não puder ser exibido ou concluído.
  7. Verifique o caminho de acesso escolhido dentro da mesma sessão: op whoami.
  8. Se houver múltiplas contas, use --account ou OP_ACCOUNT.
  9. Se um comando falhar, reutilize a mesma sessão tmux com tmux send-keys; não inicie uma segunda sessão apenas para tentar novamente.

Conta Padrão

  • A conta padrão para segredos pessoais/profissionais é my.1password.com.
  • Não use silenciosamente my.1password.eu / Titan a menos que explicitamente solicitado.
  • Passe --account my.1password.com em todo comando op ao armazenar ou ler segredos. Não confie na seleção de conta ambiente.
  • op account list é apenas metadados, mas ainda deve ser executado dentro do tmux. Use-o para confirmar nomes de conta quando o roteamento não estiver claro.
  • op signin --account my.1password.com pode retornar status 0 sem saída útil e ainda assim não fazer um shell posterior estar autenticado. Prefira fazer login, criar/editar/obter e verificar no mesmo shell tmux.

Tokens de Service Account

  • Prefira tokens de service-account antes de qualquer fluxo interativo do 1Password. Diálogos do usuário são apenas fallback.
  • Service accounts do 1Password são tokens não interativos para um vault/escopo específico, úteis para automação sem precisar desbloquear o aplicativo desktop.
  • O token de service-account padrão de Peter é exportado de ~/.profile como OP_SERVICE_ACCOUNT_TOKEN em um bloco gerenciado pelo Codex. Ele tem escopo para o vault restrito Molty.
  • Shells mais antigos podem expor o mesmo valor como MOLTY_OP_SERVICE_ACCOUNT_TOKEN; trate isso como um alias de fallback para itens conhecidos do vault Molty.
  • Se o token não estiver exportado, não for aplicável ou não puder ler o item/campo exato conhecido necessário, use automaticamente o fluxo do 1Password desktop abaixo. Pergunte apenas quando um desbloqueio real ou outra interação do usuário permanecer bloqueada.
  • Exporte/passe o token apenas para o único comando que precisa dele: OP_SERVICE_ACCOUNT_TOKEN="$OP_SERVICE_ACCOUNT_TOKEN" op item get "<item conhecido>" --vault Molty ....
  • Leituras op por service-account exigem uma consulta explícita de vault; omitir --vault Molty falha mesmo quando o token é válido.
  • Mantenha a regra do tmux: todo comando op, incluindo leituras de service-account, ainda é executado dentro de uma sessão tmux nomeada.
  • Não enumere vaults/itens com service accounts por padrão. Se o usuário pedir explicitamente para pesquisar, fornecer uma captura de tela/lista, ou der apenas um nome de item vago, use a busca segura de metadados abaixo antes do fallback desktop.
  • Mostre apenas a presença/forma, nunca o token ou valores secretos.

Sessão Tmux Persistente Obrigatória

A ferramenta de shell usa um novo TTY por comando. Execute op dentro de uma sessão tmux dedicada e continue usando essa mesma sessão até que toda a tarefa de segredo seja concluída. Comandos de service-account ainda executam aqui, mas não devem acionar prompts do aplicativo.

Exemplo:

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

Não crie uma nova sessão tmux após uma falha de citação, nome de item ou comando. Envie um comando corrigido para a sessão existente. Aponte para a sessão como $SESSION: em vez de assumir a janela 0; sessões mais antigas podem ter índices de janela começando em 1.

Fluxos de Trabalho Específicos de Serviço

  • Mantenha detalhes de autenticação específicos de serviço na skill proprietária.
  • Para trabalho com registro/ pacotes npm, use $npm; ele documenta o item de service-account Molty, wrapper de autenticação não interativo e auxiliar de reserva de pacote.
  • Esta skill possui apenas as regras genéricas do 1Password: op apenas em tmux, leituras direcionadas, uma sessão persistente, sem enumeração ampla, sem saída de segredos.

Padrão de Escrita de Segredo Funcional

Use a sessão tmux persistente. Escreva a tarefa exata de segredo em um script temporário e envie esse script para op-work; não crie uma segunda sessão tmux para tentativas.

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="Criado via fluxo de trabalho seguro tmux op"
TOKEN="$(pbpaste)"
if [ -n "$EXPECTED_PREFIX" ]; then
  case "$TOKEN" in "$EXPECTED_PREFIX"*) ;; *) echo "o valor da área de transferência não corresponde ao prefixo 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 "segredo armazenado e verificado sem imprimi-lo"
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

A string de categoria op é legível por humanos e sensível a maiúsculas/minúsculas nesta versão da CLI; use "API Credential", não api_credential.

Leitura Exata de Campos

Para um item conhecido, verifique a forma do campo antes de usá-lo ao vivo: comprimento, prefixo esperado, contagem de novas linhas, nunca o valor. op --field NAME e --fields label=NAME podem retornar o campo oculto errado quando um item tem campos de credencial duplicados/legados. Se a forma estiver errada, leia o item conhecido como JSON e extraia o rótulo exato.

cat > /tmp/op-read-field.sh <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
set +x
ITEM_TITLE="Item de Credencial de API Conhecido"
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

Mantenha a extração JSON limitada ao item e vault conhecidos. Não enumere vaults/itens para descobrir candidatos.

Busca Explícita de Itens

Use isso apenas quando o usuário pedir explicitamente para pesquisar, fornecer uma captura de tela/lista, ou a adivinhação exata do título falhou e o usuário pede uma pesquisa por regex/ aproximada. Permaneça com escopo no vault e apenas metadados; imprima títulos/ IDs/categorias/nomes de vault candidatos, nunca campos ou valores. Prefira strings visíveis exatas de capturas de tela primeiro: nome do vault, título do item e rótulo do 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

Após escolher um candidato, volte à extração JSON exata do item/campo e validação apenas da forma. Um item pessoal conhecido exato pode usar fallback para desktop automaticamente; não enumere amplamente vaults pessoais a menos que o usuário tenha pedido para pesquisar.

Depuração com Redação

Mantenha todo o pipeline dentro da mesma sessão tmux. Inspecione o status e o comprimento da saída, nunca 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 "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

Guardrails

  • Nunca cole segredos em logs, chat ou código.
  • Prefira op run / op inject em vez de escrever segredos no disco.
  • Se for necessário fazer login sem integração com aplicativo, use op account add.
  • Se um comando retornar "account is not signed in", execute novamente op signin dentro do tmux e autorize no aplicativo.
  • Deixe o prompt de desbloqueio do 1Password desktop solicitar interação do usuário diretamente; não adicione uma viagem de ida e volta separada de permissão no chat primeiro.
  • Não execute op fora do tmux; pare e pergunte se o tmux não estiver disponível.

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.

Habilidades Relacionadas