Bitwarden Agent Access: วิธีแชร์รหัสผ่านตู้นิรภัยกับ AI Coding Agents อย่างปลอดภัย

หากคุณใช้ Claude Code, Codex หรือ Cursor กับ API จริง ปัญหาหลักคือ agent ต้องใช้ credential แต่คุณไม่ควรวาง API key ลงใน prompt หรือทิ้งไว้ในไฟล์ .env ที่ agent สามารถอ่านด้วย cat แล้วส่งต่อได้ง่าย แนวทางที่ปลอดภัยกว่าคือให้ agent ได้เฉพาะ secret ที่จำเป็น เฉพาะตอน runtime และเฉพาะ process ที่ต้องใช้เท่านั้น

ลองใช้ Apidog วันนี้

โปรเจกต์โอเพนซอร์สใหม่ของ Bitwarden ชื่อ Agent Access ออกแบบมาเพื่อแก้ปัญหานี้โดยตรง มันประกอบด้วยโปรโตคอลการแชร์ credential, CLI (aac) และ SDK ที่เขียนด้วย Rust + Python เพื่อสร้าง tunnel ที่เข้ารหัสระหว่าง password manager กับ process ปลายทาง เช่น AI agent, CI runner หรือสคริปต์ deploy

บทความนี้สรุปวิธีติดตั้ง Agent Access, ใช้ aac connect, ใช้ aac run เพื่อ inject environment variables, และนำไปผูกกับ workflow ของ Claude Code, Codex และ Cursor โดยไม่ต้องเปิดเผย secret ให้ LLM เห็น แนวคิดนี้สอดคล้องกับแนวทางใน วิธีการรักษาความปลอดภัยข้อมูลรับรอง API ของ AI Agent

Agent Access คืออะไร

Agent Access คือโปรโตคอลแบบเปิดพร้อม reference implementation จาก Bitwarden โดยออกแบบให้ password manager รายอื่นนำไปใช้ได้ CLI ชื่อ aac สร้าง end-to-end encrypted tunnel ด้วย Noise protocol ระหว่างสองฝั่ง:

• Provider: ฝั่งที่เข้าถึง vault หรือ password manager ได้
• Consumer: agent, script, CI job หรือ process ที่ต้องการ credential

Consumer ขอ credential จาก provider ตาม domain หรือ vault item ID จากนั้น provider เป็นผู้ตัดสินใจว่าจะส่งอะไรกลับไป Consumer ไม่เห็น vault ทั้งหมด และ provider ไม่เห็นว่า consumer ใช้ credential อย่างไร

สถานะปัจจุบันยังเป็น ช่วงทดลองใช้งานก่อนเปิดตัว README ของโปรเจกต์ระบุว่า API และโปรโตคอลอาจเปลี่ยนแปลงได้ และไม่แนะนำให้ป้อน credential ที่ละเอียดอ่อนเข้าไปใน LLM หรือ AI agent โดยตรง

รูปแบบที่ควรใช้คือ aac run: ดึง secret แล้ว inject เข้า subprocess เป็น environment variables โดยไม่พิมพ์ออก stdout, ไม่เขียนลงไฟล์ และไม่ใส่ลงใน context window ของโมเดล

ทำไมเรื่องนี้สำคัญ

AI coding agents ไม่ได้แค่ autocomplete โค้ดอีกต่อไป เครื่องมืออย่าง Claude Code, Codex และ Cursor สามารถอ่าน repo, รัน test, เรียก API และสั่ง deploy ได้ ทุกขั้นตอนเหล่านี้มักต้องใช้ credential

เหตุการณ์ API keys ของ Postman ถูกเปิดเผย แสดงให้เห็นว่าการจัดการ credential แบบหลวม ๆ มีความเสี่ยงแค่ไหน เมื่อเพิ่ม agent เข้าไป ความเสี่ยงยิ่งสูงขึ้น เพราะ agent สามารถรันคำสั่ง, อ่านไฟล์ และส่งข้อมูลออกไปได้

แนวทางที่ถูกต้องไม่ใช่ “เชื่อใจ agent มากขึ้น” แต่คือ “ให้ agent น้อยลง”:

• จำกัด credential ตาม domain หรือ vault item
• ดึง secret เฉพาะตอน runtime
• ส่งผ่าน encrypted tunnel
• inject เฉพาะ subprocess ที่ต้องใช้
• ให้ secret หายไปเมื่อ process จบ

สำหรับภาพรวมของเครื่องมือจัดการ key อื่น ๆ ดูเพิ่มได้ที่ เครื่องมือจัดการ API Key

การติดตั้ง

เลือก binary ตามแพลตฟอร์มของคุณ

macOS Apple Silicon

curl -L https://github.com/bitwarden/agent-access/releases/latest/download/aac-macos-aarch64.tar.gz | tar xz
sudo mv aac /usr/local/bin/

macOS Intel

curl -L https://github.com/bitwarden/agent-access/releases/latest/download/aac-macos-x86_64.tar.gz | tar xz
sudo mv aac /usr/local/bin/

Linux x86_64

curl -L https://github.com/bitwarden/agent-access/releases/latest/download/aac-linux-x86_64.tar.gz | tar xz
sudo mv aac /usr/local/bin/

Windows x86_64

ดาวน์โหลด aac-windows-x86_64.zip จาก หน้า releases ล่าสุด แล้วแตกไฟล์ไปยัง directory ที่อยู่ใน PATH

ตรวจสอบการติดตั้ง:

aac --help

หากมี Bitwarden CLI (bw) อยู่ใน PATH ด้วย aac จะใช้เป็น provider เริ่มต้น หากต้องการทดลองโดยยังไม่เชื่อมกับ vault จริง ให้ใช้ provider ตัวอย่าง:

aac --provider example --help

Quick start: จับคู่และดึง credential

รัน listener บนเครื่องที่เข้าถึง vault ได้ เช่น แล็ปท็อปของคุณ:

aac listen

คำสั่งนี้จะพิมพ์ pairing token ออกมา

จากอีก terminal, remote machine หรือ CI runner ให้เชื่อมต่อและขอ credential ตาม domain:

aac connect --token <pairing-token> --domain github.com --output json

ผลลัพธ์จะอยู่ในรูปแบบ JSON:

{
  "credential": {
    "notes": null,
    "password": "alligator5",
    "totp": null,
    "uri": "https://github.com",
    "username": "example"
  },
  "domain": "github.com",
  "success": true
}

หากต้องการดึงตาม vault item ID แทน domain:

aac connect --id <vault-item-id> --output json

ข้อควรจำ:

• ใช้ --domain หรือ --id อย่างใดอย่างหนึ่ง
• ไม่สามารถใช้ --domain และ --id พร้อมกันได้
• หาก item มี TOTP payload จะถูกส่งมาด้วยใน field totp
• สคริปต์ของคุณสามารถ parse JSON นี้เพื่อส่งต่อให้ tool อื่นได้

ใช้ aac run เพื่อ inject environment variables

aac connect เหมาะเมื่อคุณต้องการจัดการ JSON เอง แต่สำหรับ AI agent และ CI workflow ควรใช้ aac run มากกว่า เพราะมันดึง credential แล้วรัน subprocess พร้อม environment variables โดยไม่เปิดเผย secret ให้ caller เห็น

ตัวอย่าง inject เฉพาะ field ที่ต้องใช้:

aac run \
  --domain example.com \
  --env DB_PASSWORD=password \
  --env DB_USER=username \
  -- psql

ตัวอย่าง inject ทุก field พร้อม prefix AAC_:

aac run --domain example.com --env-all -- ./deploy.sh

ตัวอย่างใช้ --env-all ร่วมกับ mapping เพิ่มเติม:

aac run \
  --domain example.com \
  --env-all \
  --env CUSTOM_PW=password \
  -- ./deploy.sh

field ที่ใช้ได้:

• username
• password
• totp
• uri
• notes
• domain
• credential_id

ตัวอย่าง wrapper script สำหรับ deploy:

#!/usr/bin/env bash
set -euo pipefail

aac run \
  --domain api.example.com \
  --env API_TOKEN=password \
  -- ./run-deploy.sh

ในรูปแบบนี้ agent เห็นแค่คำสั่ง:

./deploy.sh

หรืออย่างมากเห็นว่า script เรียก:

aac run --domain api.example.com --env API_TOKEN=password -- ./run-deploy.sh

แต่ agent ไม่เห็นค่าจริงของ API_TOKEN

หาก agent ถามว่า “ค่าของ $API_TOKEN คืออะไร” คำตอบคือ agent ไม่รู้ เพราะ secret ถูกจำกัดอยู่ใน environment ของ subprocess เท่านั้น

แนวคิดนี้ตรงกับหลักการแยก privilege ที่อธิบายไว้ใน วิธีการรักษาความปลอดภัยข้อมูลรับรอง API ของ AI Agent

ใช้กับ Python และ Rust SDK

หาก CLI ไม่พอ เช่น คุณต้องการฝัง Agent Access ในแอปหรือเครื่องมือภายใน สามารถใช้ SDK ได้

Python

from agent_access import RemoteClient

client = RemoteClient("python-remote")
client.connect(token="ABC-DEF-GHI")

cred = client.request_credential("example.com")

print(cred.username, cred.password)

client.close()

Python module ใช้ PyO3 โดยงานหลักยังอยู่ใน Rust และใช้ protocol implementation เดียวกันภายใต้เบื้องหลัง

หมายเหตุ: อย่า print() secret ใน production ตัวอย่างนี้มีไว้เพื่ออธิบาย data flow เท่านั้น

Rust

Rust SDK เปิด RemoteClient เป็น library สำหรับ consumer ที่เขียนด้วย Rust โดยตรง เช่น CLI tool, build runner หรือ service ที่ต้องการ distribute เป็น compiled binary

ตัวอย่าง reference อยู่ใน repo ภายใต้:

examples/rust-remote/

สำหรับทีมที่มี secret management อยู่แล้ว Agent Access สามารถอยู่ข้าง ๆ ระบบอย่าง HashiCorp Vault หรือ Azure Key Vault ได้ โดยไม่ได้แทนที่ enterprise vault แต่เหมาะกับ use case บน developer laptop และ CI runner มากกว่า

ผูกกับ AI coding agents

Claude Code

สร้าง wrapper script ให้ Claude Code เรียกแทนการเรียก deploy script โดยตรง:

# deploy.sh
#!/usr/bin/env bash
set -euo pipefail

aac run \
  --domain prod.example.com \
  --env-all \
  -- ./run-deploy.sh

จากนั้นให้ Claude Code เรียก:

./deploy.sh

ผลลัพธ์คือ Claude Code สามารถ trigger deployment ได้โดยไม่เห็น credential ใน prompt หรือ context

หากใช้ GitHub Actions ร่วมกับ Claude Code รูปแบบเดียวกันนี้ใช้ใน CI ได้: ติดตั้ง aac ใน runner, จับคู่กับ provider ที่ควบคุมโดยทีม และให้ workflow ดึง credential เฉพาะช่วงที่ job ทำงาน ดูบริบทเพิ่มเติมได้ที่ Claude Code GitHub Actions

OpenAI Codex

สำหรับ Codex ให้ใช้ wrapper script เช่นเดียวกัน:

# test-with-secret.sh
#!/usr/bin/env bash
set -euo pipefail

aac run \
  --domain staging.example.com \
  --env API_KEY=password \
  -- npm test

Codex เห็นคำสั่งที่รัน แต่ไม่เห็นค่า API_KEY จริง รายละเอียดด้านการใช้งาน Codex ใน workflow อื่น ๆ ดูเพิ่มได้ที่ Codex จากโทรศัพท์ของคุณ

Cursor

Cursor มักทำงานบนเครื่อง local ดังนั้นรูปแบบที่ง่ายคือรัน aac listen บนเครื่องเดียวกัน แล้วให้ command หรือ Composer workflow เรียก script ที่ห่อด้วย aac run

ตัวอย่าง:

# cursor-run-api-tests.sh
#!/usr/bin/env bash
set -euo pipefail

aac run \
  --domain api.local.example.com \
  --env TEST_API_KEY=password \
  -- npm run test:api

จากนั้นใน Cursor ให้เรียก:

./cursor-run-api-tests.sh

OpenClaw

Agent Access มาพร้อม ทักษะ OpenClaw อย่างเป็นทางการ โดยมีไฟล์ SKILL.md ใน repo สำหรับทีมที่ใช้ skill แบบ OpenClaw การผสานนี้ช่วยให้ skill รู้รูปแบบ protocol, ดึง credential และส่งให้ tool ปลายทางโดยไม่ต้อง hardcode secret

อ่านภาพรวมด้าน credential ของ ecosystem นี้ต่อได้ที่ คู่มือ OpenClaw API keys

Security model แบบเข้าใจง่าย

Agent Access ช่วยใน 3 จุดหลัก

1. เข้ารหัส end-to-end ผ่าน Noise

Traffic ระหว่าง consumer และ provider ถูกเข้ารหัสด้วย Noise protocol framework ซึ่งเป็น protocol framework ที่ใช้ในระบบอย่าง WireGuard และ Signal

2. จำกัดขอบเขต credential

Consumer ขอได้เฉพาะ credential ที่ระบุ เช่น domain เดียวหรือ vault item ID เดียว ไม่ใช่การเปิด vault ทั้งหมดให้ agent

3. ไม่เขียน secret ลง disk โดย default

เมื่อใช้ aac run secret จะถูกส่งผ่าน environment variables ไปยัง subprocess:

aac run --domain example.com --env API_KEY=password -- ./script.sh

ไม่มีการเขียนลง .env, ไม่มี stdout, และไม่เข้า shell history ในรูปแบบค่าจริง

สิ่งที่ Agent Access ไม่ได้ป้องกัน

Agent Access ไม่ใช่ silver bullet มีข้อจำกัดที่ต้องออกแบบ workflow ให้รับมือ:

• หาก consumer process ถูก compromise credential ที่ถูก inject เข้าไปก็ยังรั่วได้
• หาก vault หรือ provider ถูก compromise protocol นี้ช่วยไม่ได้
• หากคุณ copy secret เข้า prompt ของ LLM เอง ไม่มี protocol ใดช่วยได้
• การจำกัด scope ของ credential ยังสำคัญ เช่น ใช้ key แยกสำหรับ staging, production และ read-only task

Pattern ทั่วไป: agent เขียนโค้ด, CI ทดสอบ, Apidog ตรวจ contract

workflow ที่ใช้ได้จริงมีลำดับแบบนี้:

1. Agent เขียนโค้ด
   
   Claude Code, Codex หรือ Cursor สร้าง PR ที่แก้ endpoint หรือ client code

2. CI รัน test
   
   Test runner เรียก aac run เพื่อดึง API key สำหรับ staging

3. Apidog ตรวจ API contract
   
   Apidog รัน OpenAPI contract test เป็น CI step แยก โดยใช้ aac run เช่นกัน

ตัวอย่าง script สำหรับ API test:

#!/usr/bin/env bash
set -euo pipefail

aac run \
  --domain staging-api.example.com \
  --env STAGING_API_KEY=password \
  -- npm run test:api

ผลลัพธ์คือ:

• agent ส่งโค้ดได้
• CI ทดสอบ endpoint ได้
• Apidog ตรวจ contract ได้
• credential ไม่ถูกใส่ใน prompt หรือ commit เข้า repo

อ่าน playbook สำหรับการทดสอบ API ที่ agent เรียกได้ที่ วิธีการทดสอบ AI agents ที่เรียก API ของคุณ

ข้อจำกัดและคำเตือน

• ยังเป็นช่วงทดลองใช้งานก่อนเปิดตัว
  
  API และ protocol อาจเปลี่ยนแปลง อย่ายึด production workflow กับ v0 โดยไม่มีแผนปรับโค้ด

• ค่าเริ่มต้นพึ่ง Bitwarden CLI
  
  provider เริ่มต้นคือ bw ต้องติดตั้ง Bitwarden CLI ก่อน หรือใช้ --provider example เพื่อทดลอง

• ยังไม่มี config file
  
  ปัจจุบัน workflow ส่วนใหญ่ต้องอาศัย flags และ wrapper scripts

• อย่าใส่ secret ลง LLM prompt
  
  แม้มี Agent Access แล้ว ถ้าคุณ copy API key ลง chat เอง secret ก็รั่วอยู่ดี

FAQ

Agent Access ฟรีหรือไม่?

ใช่ CLI, SDK และ protocol เป็นโอเพนซอร์สภายใต้ Bitwarden GitHub organization แต่หากใช้ Bitwarden เป็น vault คุณยังต้องจ่ายตาม plan ของ Bitwarden เอง

ใช้กับ password manager อื่นที่ไม่ใช่ Bitwarden ได้ไหม?

protocol ออกแบบให้ vendor-neutral ปัจจุบัน reference implementation รองรับ Bitwarden และ example provider ผู้จำหน่ายรายอื่นสามารถสร้าง provider ของตนเองได้ในอนาคต

ใช้โดยไม่มี password manager ได้ไหม?

สำหรับการทดสอบ ทำได้โดยใช้ provider ตัวอย่าง:

aac connect --provider example --domain test.com --output json

สำหรับงานจริงควรใช้ provider ที่เชื่อมกับ vault จริง

Consumer ต้องเข้าถึง network ไหม?

ต้องเข้าถึง listener ของ provider ได้ หาก listener และ consumer อยู่บนเครื่องเดียวกัน local-only setup ก็ใช้งานได้

ต่างจากไฟล์ .env อย่างไร?

ไฟล์ .env อยู่บน disk, อาจถูก commit เข้า repo โดยไม่ตั้งใจ และ agent สามารถอ่านได้หากมีสิทธิ์รัน command

aac run เก็บ secret ไว้ใน memory ของ subprocess เท่านั้น และหายไปเมื่อ process สิ้นสุด

Agent Access แทนที่ HashiCorp Vault หรือ AWS Secrets Manager ไหม?

ไม่ใช่ Enterprise vault ยังเหมาะกับ secret แบบ service-to-service ใน production ขนาดใหญ่ Agent Access เติมช่องว่างสำหรับ developer laptop, AI agent workflow และ CI runner ที่ต้องการ scoped credential แบบ runtime

Anthropic, OpenAI หรือ vendor อื่นจะ integrate โดยตรงไหม?

ยังไม่มีประกาศอย่างเป็นทางการ วิธีใช้งานตอนนี้คือห่อ command หรือ script ด้วย aac run

รายงาน bug หรือ contribute ได้ที่ไหน?

ไปที่ GitHub repo เพื่อเปิด issue, ส่ง PR หรือเข้าร่วม discussion เกี่ยวกับ protocol

ลองใช้งานแบบ end-to-end

เริ่มจากวงจรเล็กที่สุด:

aac listen

จาก terminal อีกหน้าต่าง:

aac connect \
  --provider example \
  --domain test.com \
  --output json

เมื่อยืนยันว่า JSON ถูกส่งกลับมาแล้ว ให้เปลี่ยนจาก example provider เป็น Bitwarden provider จริง จากนั้นห่อ script ที่ต้องใช้ secret ด้วย aac run

ตัวอย่างสุดท้าย:

aac run \
  --domain staging-api.example.com \
  --env API_KEY=password \
  -- npm run test:api

จับคู่ Agent Access กับ Apidog สำหรับฝั่ง API testing แล้วคุณจะได้ separation ที่ชัดเจน: vault เก็บ secret, agent เขียนโค้ด, CI รัน test, Apidog ตรวจ contract และ credential ไม่ต้องออกจาก vault ในรูปแบบ plain text.