chore(i18n): refresh th translations

This commit is contained in:
openclaw-docs-i18n[bot] 2026-04-23 06:22:23 +00:00
parent 49a6c1eae2
commit f3967b0121
57 changed files with 10082 additions and 0 deletions

324
docs/th/cli/acp.md Normal file
View File

@ -0,0 +1,324 @@
---
read_when:
- การตั้งค่าการผสานรวมกับ IDE ที่ใช้ ACP
- การดีบักการกำหนดเส้นทางเซสชัน ACP ไปยัง Gateway
summary: เรียกใช้สะพาน ACP สำหรับการผสานรวมกับ IDE
title: ACP
x-i18n:
generated_at: "2026-04-23T06:17:05Z"
model: gpt-5.4
provider: openai
source_hash: b098c59e24cac23d533ea3b3828c95bd43d85ebf6e1361377122018777678720
source_path: cli/acp.md
workflow: 15
---
# acp
เรียกใช้สะพาน [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) ที่สื่อสารกับ OpenClaw Gateway
คำสั่งนี้สื่อสาร ACP ผ่าน stdio สำหรับ IDE และส่งต่อพรอมป์ไปยัง Gateway
ผ่าน WebSocket โดยจะคงการแมปเซสชัน ACP กับคีย์เซสชันของ Gateway
`openclaw acp` เป็นสะพาน ACP ที่ทำงานผ่าน Gateway ไม่ใช่รันไทม์เอดิเตอร์แบบ ACP-native เต็มรูปแบบ
โดยเน้นที่การกำหนดเส้นทางเซสชัน การส่งพรอมป์ และการอัปเดตการสตรีมพื้นฐาน
หากคุณต้องการให้ไคลเอนต์ MCP ภายนอกสื่อสารกับการสนทนาผ่านแชนแนลของ OpenClaw โดยตรง
แทนการโฮสต์เซสชัน ACP harness ให้ใช้
[`openclaw mcp serve`](/th/cli/mcp) แทน
## สิ่งที่นี่ไม่ใช่
หน้านี้มักถูกสับสนกับเซสชัน ACP harness
`openclaw acp` หมายถึง:
- OpenClaw ทำหน้าที่เป็นเซิร์ฟเวอร์ ACP
- IDE หรือไคลเอนต์ ACP เชื่อมต่อกับ OpenClaw
- OpenClaw ส่งต่องานนั้นเข้าไปยังเซสชัน Gateway
ซึ่งแตกต่างจาก [ACP Agents](/th/tools/acp-agents) ที่ OpenClaw เรียกใช้
harness ภายนอก เช่น Codex หรือ Claude Code ผ่าน `acpx`
กฎสั้นๆ:
- ถ้าเอดิเตอร์/ไคลเอนต์ต้องการสื่อสาร ACP กับ OpenClaw: ใช้ `openclaw acp`
- ถ้า OpenClaw ควรเรียกใช้ Codex/Claude/Gemini เป็น ACP harness: ใช้ `/acp spawn` และ [ACP Agents](/th/tools/acp-agents)
## ตารางความเข้ากันได้
| ส่วนของ ACP | สถานะ | หมายเหตุ |
| ---------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `initialize`, `newSession`, `prompt`, `cancel` | รองรับแล้ว | โฟลว์สะพานหลักผ่าน stdio ไปยัง Gateway chat/send + abort |
| `listSessions`, slash commands | รองรับแล้ว | รายการเซสชันทำงานกับสถานะเซสชันของ Gateway; คำสั่งจะถูกประกาศผ่าน `available_commands_update` |
| `loadSession` | รองรับบางส่วน | รีไบน์เซสชัน ACP กับคีย์เซสชันของ Gateway และเล่นประวัติข้อความ user/assistant ที่เก็บไว้ซ้ำ ระบบยังไม่สร้างประวัติ tool/system กลับขึ้นมาใหม่ |
| เนื้อหาพรอมป์ (`text`, `resource` แบบฝัง, รูปภาพ) | รองรับบางส่วน | ข้อความ/ทรัพยากรถูก flatten ลงในอินพุตแชต; รูปภาพจะกลายเป็นไฟล์แนบของ Gateway |
| โหมดเซสชัน | รองรับบางส่วน | รองรับ `session/set_mode` และสะพานเปิดเผยตัวควบคุมเซสชันเริ่มต้นที่ทำงานผ่าน Gateway สำหรับระดับความคิด ความละเอียดของเครื่องมือ การให้เหตุผล รายละเอียดการใช้งาน และการดำเนินการแบบยกระดับ ส่วนพื้นผิวโหมด/คอนฟิกแบบ ACP-native ที่กว้างกว่ายังอยู่นอกขอบเขต |
| ข้อมูลเซสชันและการอัปเดตการใช้งาน | รองรับบางส่วน | สะพานส่งการแจ้งเตือน `session_info_update` และ `usage_update` แบบ best-effort จาก snapshot เซสชัน Gateway ที่แคชไว้ การใช้งานเป็นค่าโดยประมาณและจะส่งเฉพาะเมื่อยอดโทเคนของ Gateway ถูกทำเครื่องหมายว่าสดใหม่เท่านั้น |
| การสตรีมเครื่องมือ | รองรับบางส่วน | อีเวนต์ `tool_call` / `tool_call_update` รวม raw I/O เนื้อหาข้อความ และตำแหน่งไฟล์แบบ best-effort เมื่ออาร์กิวเมนต์/ผลลัพธ์ของเครื่องมือ Gateway เปิดเผยข้อมูลเหล่านั้น เทอร์มินัลแบบฝังและเอาต์พุตแบบ diff-native ที่สมบูรณ์กว่ายังไม่ถูกเปิดเผย |
| เซิร์ฟเวอร์ MCP ต่อเซสชัน (`mcpServers`) | ไม่รองรับ | โหมดสะพานปฏิเสธคำขอเซิร์ฟเวอร์ MCP ต่อเซสชัน ให้กำหนดค่า MCP บน OpenClaw gateway หรือ agent แทน |
| เมทอด filesystem ของไคลเอนต์ (`fs/read_text_file`, `fs/write_text_file`) | ไม่รองรับ | สะพานจะไม่เรียกใช้เมทอด filesystem ของไคลเอนต์ ACP |
| เมทอด terminal ของไคลเอนต์ (`terminal/*`) | ไม่รองรับ | สะพานจะไม่สร้างเทอร์มินัลของไคลเอนต์ ACP หรือสตรีม terminal id ผ่านการเรียกเครื่องมือ |
| แผนเซสชัน / การสตรีมความคิด | ไม่รองรับ | ปัจจุบันสะพานส่งข้อความเอาต์พุตและสถานะของเครื่องมือ ไม่ใช่การอัปเดตแผนหรือความคิดแบบ ACP |
## ข้อจำกัดที่ทราบ
- `loadSession` เล่นประวัติข้อความ user และ assistant ที่เก็บไว้ซ้ำ แต่จะไม่
สร้างการเรียกเครื่องมือในอดีต การแจ้งเตือนของระบบ หรือประเภทอีเวนต์แบบ ACP-native
ที่สมบูรณ์กว่านั้นกลับขึ้นมาใหม่
- หากไคลเอนต์ ACP หลายตัวใช้คีย์เซสชัน Gateway เดียวกันร่วมกัน การกำหนดเส้นทางอีเวนต์และการยกเลิก
จะเป็นแบบ best-effort แทนที่จะถูกแยกอย่างเคร่งครัดต่อไคลเอนต์แต่ละตัว ให้ใช้
เซสชัน `acp:<uuid>` แบบแยกตามค่าเริ่มต้นเมื่อคุณต้องการ
เทิร์นที่สะอาดแยกเฉพาะในเอดิเตอร์
- สถานะหยุดของ Gateway จะถูกแปลงเป็นเหตุผลการหยุดของ ACP แต่การแมปนั้น
แสดงรายละเอียดได้น้อยกว่ารันไทม์แบบ ACP-native เต็มรูปแบบ
- ตัวควบคุมเซสชันเริ่มต้นในปัจจุบันแสดงเพียงชุดย่อยที่เน้นเฉพาะของตัวปรับ Gateway:
ระดับความคิด ความละเอียดของเครื่องมือ การให้เหตุผล รายละเอียดการใช้งาน และการดำเนินการแบบยกระดับ
การเลือกโมเดลและตัวควบคุม exec-host ยังไม่ถูกเปิดเผยเป็นตัวเลือกคอนฟิกของ ACP
- `session_info_update` และ `usage_update` ถูกคำนวณมาจาก snapshot เซสชันของ Gateway
ไม่ใช่การคิดบัญชีรันไทม์แบบ ACP-native สด การใช้งานเป็นค่าโดยประมาณ
ไม่มีข้อมูลต้นทุน และจะส่งออกเฉพาะเมื่อ Gateway ทำเครื่องหมายข้อมูลโทเคนรวม
ว่าสดใหม่
- ข้อมูลการติดตามเครื่องมือเป็นแบบ best-effort สะพานสามารถแสดงพาธไฟล์ที่
ปรากฏในอาร์กิวเมนต์/ผลลัพธ์ของเครื่องมือที่รู้จักได้ แต่ยังไม่ส่ง ACP terminals หรือ
file diff แบบมีโครงสร้าง
## การใช้งาน
```bash
openclaw acp
# Gateway ระยะไกล
openclaw acp --url wss://gateway-host:18789 --token <token>
# Gateway ระยะไกล (อ่าน token จากไฟล์)
openclaw acp --url wss://gateway-host:18789 --token-file ~/.openclaw/gateway.token
# แนบกับคีย์เซสชันที่มีอยู่แล้ว
openclaw acp --session agent:main:main
# แนบตาม label (ต้องมีอยู่แล้ว)
openclaw acp --session-label "support inbox"
# รีเซ็ตคีย์เซสชันก่อนพรอมป์แรก
openclaw acp --session agent:main:main --reset-session
```
## ไคลเอนต์ ACP (ดีบัก)
ใช้ไคลเอนต์ ACP ที่มีมาให้ในตัวเพื่อตรวจสอบความถูกต้องพื้นฐานของสะพานโดยไม่ต้องใช้ IDE
มันจะเรียกสะพาน ACP ขึ้นมาและให้คุณพิมพ์พรอมป์แบบโต้ตอบได้
```bash
openclaw acp client
# ชี้สะพานที่ถูกเรียกขึ้นไปยัง Gateway ระยะไกล
openclaw acp client --server-args --url wss://gateway-host:18789 --token-file ~/.openclaw/gateway.token
# แทนที่คำสั่งเซิร์ฟเวอร์ (ค่าเริ่มต้น: openclaw)
openclaw acp client --server "node" --server-args openclaw.mjs acp --url ws://127.0.0.1:19001
```
โมเดลสิทธิ์ (โหมดดีบักไคลเอนต์):
- การอนุมัติอัตโนมัติใช้ allowlist และใช้กับเฉพาะ tool ID แกนหลักที่เชื่อถือได้เท่านั้น
- การอนุมัติอัตโนมัติของ `read` ถูกจำกัดขอบเขตไว้ที่ไดเรกทอรีทำงานปัจจุบัน (`--cwd` เมื่อกำหนด)
- ACP อนุมัติอัตโนมัติเฉพาะคลาสแบบอ่านอย่างเดียวที่แคบเท่านั้น: การเรียก `read` ที่อยู่ภายใต้ cwd ที่ใช้งานอยู่บวกกับเครื่องมือค้นหาแบบอ่านอย่างเดียว (`search`, `web_search`, `memory_search`) เครื่องมือที่ไม่รู้จัก/ไม่ใช่แกนหลัก การอ่านนอกขอบเขต เครื่องมือที่รันคำสั่งได้ เครื่องมือ control-plane เครื่องมือที่แก้ไขข้อมูล และโฟลว์แบบโต้ตอบ ต้องได้รับการอนุมัติผ่านพรอมป์อย่างชัดเจนเสมอ
- `toolCall.kind` ที่เซิร์ฟเวอร์ให้มาจะถูกถือเป็นเมทาดาทาที่ไม่น่าเชื่อถือ (ไม่ใช่แหล่งสำหรับการอนุญาต)
- นโยบายของสะพาน ACP นี้แยกจากสิทธิ์ของ ACPX harness หากคุณรัน OpenClaw ผ่านแบ็กเอนด์ `acpx`, `plugins.entries.acpx.config.permissionMode=approve-all` คือสวิตช์ break-glass แบบ “yolo” สำหรับเซสชัน harness นั้น
## วิธีใช้งาน
ใช้ ACP เมื่อ IDE (หรือไคลเอนต์อื่น) สื่อสารด้วย Agent Client Protocol และคุณต้องการ
ให้มันขับเคลื่อนเซสชัน OpenClaw Gateway
1. ตรวจสอบให้แน่ใจว่า Gateway กำลังทำงานอยู่ (ในเครื่องหรือระยะไกล)
2. กำหนดค่าเป้าหมาย Gateway (ผ่านคอนฟิกหรือแฟล็ก)
3. ชี้ IDE ของคุณให้รัน `openclaw acp` ผ่าน stdio
ตัวอย่างคอนฟิก (บันทึกถาวร):
```bash
openclaw config set gateway.remote.url wss://gateway-host:18789
openclaw config set gateway.remote.token <token>
```
ตัวอย่างการรันโดยตรง (ไม่เขียนคอนฟิก):
```bash
openclaw acp --url wss://gateway-host:18789 --token <token>
# แนะนำเพื่อความปลอดภัยของโปรเซสในเครื่อง
openclaw acp --url wss://gateway-host:18789 --token-file ~/.openclaw/gateway.token
```
## การเลือก agent
ACP จะไม่เลือก agent โดยตรง แต่จะกำหนดเส้นทางผ่านคีย์เซสชันของ Gateway
ใช้คีย์เซสชันที่ผูกกับ agent เพื่อกำหนดเป้าหมายไปยัง agent ที่ต้องการ:
```bash
openclaw acp --session agent:main:main
openclaw acp --session agent:design:main
openclaw acp --session agent:qa:bug-123
```
แต่ละเซสชัน ACP จะถูกแมปกับคีย์เซสชัน Gateway เดียว หนึ่ง agent สามารถมีได้หลาย
เซสชัน; โดยค่าเริ่มต้น ACP จะใช้เซสชัน `acp:<uuid>` แบบแยกต่างหาก เว้นแต่คุณจะระบุแทนที่
คีย์หรือ label
ไม่รองรับ `mcpServers` ต่อเซสชันในโหมดสะพาน หากไคลเอนต์ ACP
ส่งมาระหว่าง `newSession` หรือ `loadSession` สะพานจะส่งข้อผิดพลาดที่ชัดเจนกลับไป
แทนที่จะเพิกเฉยแบบเงียบๆ
หากคุณต้องการให้เซสชันที่ทำงานผ่าน ACPX มองเห็นเครื่องมือ Plugin ของ OpenClaw หรือเครื่องมือ
ในตัวบางตัวที่เลือกไว้ เช่น `cron` ให้เปิดใช้สะพาน ACPX MCP ฝั่ง gateway
แทนการพยายามส่ง `mcpServers` ต่อเซสชัน ดู
[ACP Agents](/th/tools/acp-agents#plugin-tools-mcp-bridge) และ
[สะพาน MCP ของเครื่องมือ OpenClaw](/th/tools/acp-agents#openclaw-tools-mcp-bridge)
## ใช้จาก `acpx` (Codex, Claude, ไคลเอนต์ ACP อื่นๆ)
หากคุณต้องการให้ coding agent เช่น Codex หรือ Claude Code สื่อสารกับ
บอต OpenClaw ของคุณผ่าน ACP ให้ใช้ `acpx` พร้อม target `openclaw`
ที่มีมาให้ในตัว
โฟลว์ทั่วไป:
1. รัน Gateway และตรวจสอบให้แน่ใจว่าสะพาน ACP เข้าถึงได้
2. ชี้ `acpx openclaw` ไปที่ `openclaw acp`
3. กำหนดเป้าหมายคีย์เซสชัน OpenClaw ที่คุณต้องการให้ coding agent ใช้
ตัวอย่าง:
```bash
# คำขอแบบ one-shot ไปยังเซสชัน OpenClaw ACP เริ่มต้นของคุณ
acpx openclaw exec "สรุปสถานะเซสชัน OpenClaw ที่กำลังใช้งานอยู่"
# เซสชันแบบมีชื่อถาวรสำหรับเทิร์นติดตามผล
acpx openclaw sessions ensure --name codex-bridge
acpx openclaw -s codex-bridge --cwd /path/to/repo \
"ถาม work agent ของ OpenClaw ของฉันเกี่ยวกับบริบทล่าสุดที่เกี่ยวข้องกับ repo นี้"
```
หากคุณต้องการให้ `acpx openclaw` กำหนดเป้าหมายไปยัง Gateway และคีย์เซสชันเฉพาะทุกครั้ง
ให้แทนที่คำสั่ง agent `openclaw` ใน `~/.acpx/config.json`:
```json
{
"agents": {
"openclaw": {
"command": "env OPENCLAW_HIDE_BANNER=1 OPENCLAW_SUPPRESS_NOTES=1 openclaw acp --url ws://127.0.0.1:18789 --token-file ~/.openclaw/gateway.token --session agent:main:main"
}
}
}
```
สำหรับ checkout ของ OpenClaw ภายใน repo ในเครื่อง ให้ใช้ CLI entrypoint โดยตรงแทน
dev runner เพื่อให้สตรีม ACP สะอาด ตัวอย่างเช่น:
```bash
env OPENCLAW_HIDE_BANNER=1 OPENCLAW_SUPPRESS_NOTES=1 node openclaw.mjs acp ...
```
นี่คือวิธีที่ง่ายที่สุดในการให้ Codex, Claude Code หรือไคลเอนต์ที่รองรับ ACP อื่น
ดึงข้อมูลบริบทจาก OpenClaw agent โดยไม่ต้องสแครปจากเทอร์มินัล
## การตั้งค่า Zed editor
เพิ่ม ACP agent แบบกำหนดเองใน `~/.config/zed/settings.json` (หรือใช้ UI การตั้งค่าของ Zed):
```json
{
"agent_servers": {
"OpenClaw ACP": {
"type": "custom",
"command": "openclaw",
"args": ["acp"],
"env": {}
}
}
}
```
หากต้องการกำหนดเป้าหมาย Gateway หรือ agent เฉพาะ:
```json
{
"agent_servers": {
"OpenClaw ACP": {
"type": "custom",
"command": "openclaw",
"args": [
"acp",
"--url",
"wss://gateway-host:18789",
"--token",
"<token>",
"--session",
"agent:design:main"
],
"env": {}
}
}
}
```
ใน Zed ให้เปิดแผง Agent แล้วเลือก “OpenClaw ACP” เพื่อเริ่มเธรด
## การแมปเซสชัน
โดยค่าเริ่มต้น เซสชัน ACP จะได้รับคีย์เซสชัน Gateway แบบแยกต่างหากโดยมีคำนำหน้า `acp:`
หากต้องการใช้เซสชันที่ทราบอยู่แล้วซ้ำ ให้ส่งคีย์เซสชันหรือ label:
- `--session <key>`: ใช้คีย์เซสชัน Gateway ที่ระบุ
- `--session-label <label>`: resolve เซสชันที่มีอยู่แล้วตาม label
- `--reset-session`: สร้าง session id ใหม่สำหรับคีย์นั้น (คีย์เดิม แต่ transcript ใหม่)
หากไคลเอนต์ ACP ของคุณรองรับ metadata คุณสามารถแทนที่ต่อเซสชันได้:
```json
{
"_meta": {
"sessionKey": "agent:main:main",
"sessionLabel": "support inbox",
"resetSession": true
}
}
```
ดูข้อมูลเพิ่มเติมเกี่ยวกับคีย์เซสชันได้ที่ [/concepts/session](/th/concepts/session)
## ตัวเลือก
- `--url <url>`: URL WebSocket ของ Gateway (ค่าเริ่มต้นคือ gateway.remote.url เมื่อมีการกำหนดค่าไว้)
- `--token <token>`: โทเค็นยืนยันตัวตนของ Gateway
- `--token-file <path>`: อ่านโทเค็นยืนยันตัวตนของ Gateway จากไฟล์
- `--password <password>`: รหัสผ่านยืนยันตัวตนของ Gateway
- `--password-file <path>`: อ่านรหัสผ่านยืนยันตัวตนของ Gateway จากไฟล์
- `--session <key>`: คีย์เซสชันเริ่มต้น
- `--session-label <label>`: label เซสชันเริ่มต้นที่จะ resolve
- `--require-existing`: ล้มเหลวหากไม่มีคีย์เซสชัน/label ดังกล่าว
- `--reset-session`: รีเซ็ตคีย์เซสชันก่อนใช้งานครั้งแรก
- `--no-prefix-cwd`: ไม่เติมไดเรกทอรีทำงานไว้หน้าพรอมป์
- `--provenance <off|meta|meta+receipt>`: รวม metadata หรือ receipt ของ provenance ของ ACP
- `--verbose, -v`: บันทึกแบบละเอียดไปยัง stderr
หมายเหตุด้านความปลอดภัย:
- `--token` และ `--password` อาจมองเห็นได้ในรายการโปรเซสภายในเครื่องบนบางระบบ
- แนะนำให้ใช้ `--token-file`/`--password-file` หรือตัวแปรสภาพแวดล้อม (`OPENCLAW_GATEWAY_TOKEN`, `OPENCLAW_GATEWAY_PASSWORD`)
- การ resolve การยืนยันตัวตนของ Gateway เป็นไปตามสัญญาร่วมที่ใช้โดยไคลเอนต์ Gateway อื่น:
- โหมด local: env (`OPENCLAW_GATEWAY_*`) -> `gateway.auth.*` -> fallback ไป `gateway.remote.*` เฉพาะเมื่อ `gateway.auth.*` ยังไม่ถูกตั้งค่า (SecretRefs ภายในเครื่องที่ถูกตั้งค่าไว้แต่ resolve ไม่ได้จะ fail closed)
- โหมด remote: `gateway.remote.*` พร้อม env/config fallback ตามกฎลำดับความสำคัญของ remote
- `--url` สามารถแทนที่ได้อย่างปลอดภัย และจะไม่ใช้ข้อมูลรับรองจาก config/env แบบ implicit ซ้ำ; ให้ส่ง `--token`/`--password` แบบ explicit (หรือแบบไฟล์)
- โปรเซสลูกของรันไทม์แบ็กเอนด์ ACP จะได้รับ `OPENCLAW_SHELL=acp` ซึ่งสามารถใช้สำหรับกฎ shell/profile ตามบริบทเฉพาะได้
- `openclaw acp client` จะตั้งค่า `OPENCLAW_SHELL=acp-client` ให้กับโปรเซสสะพานที่ถูกเรียกขึ้นมา
### ตัวเลือก `acp client`
- `--cwd <dir>`: ไดเรกทอรีทำงานสำหรับเซสชัน ACP
- `--server <command>`: คำสั่งเซิร์ฟเวอร์ ACP (ค่าเริ่มต้น: `openclaw`)
- `--server-args <args...>`: อาร์กิวเมนต์เพิ่มเติมที่ส่งให้เซิร์ฟเวอร์ ACP
- `--server-verbose`: เปิดใช้การบันทึกแบบละเอียดบนเซิร์ฟเวอร์ ACP
- `--verbose, -v`: การบันทึกแบบละเอียดของไคลเอนต์

64
docs/th/cli/agent.md Normal file
View File

@ -0,0 +1,64 @@
---
read_when:
- คุณต้องการรันหนึ่งเทิร์นของเอเจนต์จากสคริปต์ (เลือกได้ว่าจะส่งคำตอบกลับหรือไม่)
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw agent` (ส่งหนึ่งเทิร์นของเอเจนต์ผ่าน Gateway)
title: เอเจนต์
x-i18n:
generated_at: "2026-04-23T06:17:02Z"
model: gpt-5.4
provider: openai
source_hash: 4ba3181d74e9a8d6d607ee62b18e1e6fd693e64e7789e6b29b7f7b1ccb7b69d0
source_path: cli/agent.md
workflow: 15
---
# `openclaw agent`
รันหนึ่งเทิร์นของเอเจนต์ผ่าน Gateway (ใช้ `--local` สำหรับแบบฝังในตัว)
ใช้ `--agent <id>` เพื่อระบุเอเจนต์ที่ตั้งค่าไว้โดยตรง
ส่งตัวเลือกระบุเซสชันอย่างน้อยหนึ่งรายการ:
- `--to <dest>`
- `--session-id <id>`
- `--agent <id>`
ที่เกี่ยวข้อง:
- เครื่องมือส่งเอเจนต์: [Agent send](/th/tools/agent-send)
## ตัวเลือก
- `-m, --message <text>`: เนื้อหาข้อความที่ต้องระบุ
- `-t, --to <dest>`: ผู้รับที่ใช้ในการสร้างคีย์เซสชัน
- `--session-id <id>`: รหัสเซสชันที่ระบุโดยตรง
- `--agent <id>`: รหัสเอเจนต์; ใช้แทนการผูกเส้นทาง
- `--thinking <level>`: ระดับการคิดของเอเจนต์ (`off`, `minimal`, `low`, `medium`, `high` รวมถึงระดับกำหนดเองที่ผู้ให้บริการรองรับ เช่น `xhigh`, `adaptive` หรือ `max`)
- `--verbose <on|off>`: คงค่าระดับ verbose ไว้สำหรับเซสชัน
- `--channel <channel>`: ช่องทางการส่ง; เว้นไว้เพื่อใช้ช่องทางหลักของเซสชัน
- `--reply-to <target>`: ระบุเป้าหมายการส่งกลับแทนค่าเดิม
- `--reply-channel <channel>`: ระบุช่องทางการส่งกลับแทนค่าเดิม
- `--reply-account <id>`: ระบุบัญชีการส่งกลับแทนค่าเดิม
- `--local`: รันเอเจนต์แบบฝังในตัวโดยตรง (หลังจากพรีโหลดรีจิสทรี Plugin)
- `--deliver`: ส่งคำตอบกลับไปยังช่องทาง/เป้าหมายที่เลือก
- `--timeout <seconds>`: กำหนดเวลา timeout ของเอเจนต์ใหม่ (ค่าเริ่มต้น 600 หรือค่าจาก config)
- `--json`: แสดงผลเป็น JSON
## ตัวอย่าง
```bash
openclaw agent --to +15555550123 --message "status update" --deliver
openclaw agent --agent ops --message "Summarize logs"
openclaw agent --session-id 1234 --message "Summarize inbox" --thinking medium
openclaw agent --to +15555550123 --message "Trace logs" --verbose on --json
openclaw agent --agent ops --message "Generate report" --deliver --reply-channel slack --reply-to "#reports"
openclaw agent --agent ops --message "Run locally" --local
```
## หมายเหตุ
- โหมด Gateway จะ fallback ไปใช้เอเจนต์แบบฝังในตัวเมื่อคำขอไปยัง Gateway ล้มเหลว ใช้ `--local` เพื่อบังคับให้รันแบบฝังในตัวตั้งแต่ต้น
- `--local` จะยังพรีโหลดรีจิสทรี Plugin ก่อน ดังนั้น provider, tools และ channels ที่มาจาก Plugin จะยังใช้งานได้ระหว่างการรันแบบฝังในตัว
- `--channel`, `--reply-channel` และ `--reply-account` มีผลต่อการส่งคำตอบกลับ ไม่ใช่การกำหนดเส้นทางของเซสชัน
- เมื่อคำสั่งนี้ทริกเกอร์การสร้าง `models.json` ใหม่ ข้อมูลรับรอง provider ที่จัดการด้วย SecretRef จะถูกบันทึกเป็นตัวบ่งชี้แบบไม่เป็นความลับ (เช่น ชื่อ env var, `secretref-env:ENV_VAR_NAME` หรือ `secretref-managed`) ไม่ใช่ข้อความลับจริงที่ถูก resolve แล้ว
- การเขียนตัวบ่งชี้ใช้ต้นทางเป็นข้อมูลอ้างอิงหลัก: OpenClaw จะบันทึกตัวบ่งชี้จาก snapshot config ของต้นทางที่กำลังใช้งาน ไม่ใช่จากค่าความลับขณะรันที่ถูก resolve แล้ว

227
docs/th/cli/agents.md Normal file
View File

@ -0,0 +1,227 @@
---
read_when:
- คุณต้องการ agents หลายชุดที่แยกจากกัน (เวิร์กสเปซ + การกำหนดเส้นทาง + การยืนยันตัวตน)
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw agents` (list/add/delete/bindings/bind/unbind/set identity)
title: agents
x-i18n:
generated_at: "2026-04-23T06:17:04Z"
model: gpt-5.4
provider: openai
source_hash: f328d9f4ce636ce27defdcbcc48b1ca041bc25d0888c3e4df0dd79840f44ca8f
source_path: cli/agents.md
workflow: 15
---
# `openclaw agents`
จัดการ agents ที่แยกจากกัน (เวิร์กสเปซ + การยืนยันตัวตน + การกำหนดเส้นทาง)
ที่เกี่ยวข้อง:
- การกำหนดเส้นทางแบบหลาย agent: [การกำหนดเส้นทางแบบหลาย Agent](/th/concepts/multi-agent)
- เวิร์กสเปซของ agent: [เวิร์กสเปซของ Agent](/th/concepts/agent-workspace)
- การตั้งค่าการมองเห็น Skills: [การตั้งค่า Skills](/th/tools/skills-config)
## ตัวอย่าง
```bash
openclaw agents list
openclaw agents list --bindings
openclaw agents add work --workspace ~/.openclaw/workspace-work
openclaw agents add ops --workspace ~/.openclaw/workspace-ops --bind telegram:ops --non-interactive
openclaw agents bindings
openclaw agents bind --agent work --bind telegram:ops
openclaw agents unbind --agent work --bind telegram:ops
openclaw agents set-identity --workspace ~/.openclaw/workspace --from-identity
openclaw agents set-identity --agent main --avatar avatars/openclaw.png
openclaw agents delete work
```
## การผูกการกำหนดเส้นทาง
ใช้การผูกการกำหนดเส้นทางเพื่อตรึงทราฟฟิกขาเข้าของช่องทางให้ไปยัง agent ที่ระบุ
หากคุณต้องการให้แต่ละ agent มองเห็น Skills ต่างกันด้วย ให้กำหนดค่า
`agents.defaults.skills` และ `agents.list[].skills` ใน `openclaw.json` ดู
[การตั้งค่า Skills](/th/tools/skills-config) และ
[เอกสารอ้างอิงการกำหนดค่า](/th/gateway/configuration-reference#agents-defaults-skills)
แสดงรายการการผูก:
```bash
openclaw agents bindings
openclaw agents bindings --agent work
openclaw agents bindings --json
```
เพิ่มการผูก:
```bash
openclaw agents bind --agent work --bind telegram:ops --bind discord:guild-a
```
หากคุณละเว้น `accountId` (`--bind <channel>`), OpenClaw จะกำหนดค่าให้จากค่าเริ่มต้นของช่องทางและ hook การตั้งค่า plugin เมื่อมีให้ใช้งาน
หากคุณละเว้น `--agent` สำหรับ `bind` หรือ `unbind`, OpenClaw จะใช้ default agent ปัจจุบันเป็นเป้าหมาย
### พฤติกรรมขอบเขตการผูก
- การผูกที่ไม่มี `accountId` จะตรงกับบัญชีเริ่มต้นของช่องทางเท่านั้น
- `accountId: "*"` คือค่าตกสำรองระดับทั้งช่องทาง (ทุกบัญชี) และมีความเฉพาะเจาะจงน้อยกว่าการผูกกับบัญชีแบบชัดเจน
- หาก agent เดิมมีการผูกช่องทางที่ตรงกันอยู่แล้วโดยไม่มี `accountId` และภายหลังคุณผูกด้วย `accountId` แบบชัดเจนหรือที่ระบบกำหนดให้ OpenClaw จะอัปเกรดการผูกเดิมนั้นในตำแหน่งเดิมแทนการเพิ่มรายการซ้ำ
ตัวอย่าง:
```bash
# การผูกแบบเฉพาะช่องทางเริ่มต้น
openclaw agents bind --agent work --bind telegram
# ภายหลังอัปเกรดเป็นการผูกที่อยู่ในขอบเขตของบัญชี
openclaw agents bind --agent work --bind telegram:ops
```
หลังการอัปเกรด การกำหนดเส้นทางสำหรับการผูกนั้นจะอยู่ในขอบเขต `telegram:ops` หากคุณต้องการการกำหนดเส้นทางสำหรับบัญชีเริ่มต้นด้วย ให้เพิ่มอย่างชัดเจน (เช่น `--bind telegram:default`)
ลบการผูก:
```bash
openclaw agents unbind --agent work --bind telegram:ops
openclaw agents unbind --agent work --all
```
`unbind` รับได้อย่างใดอย่างหนึ่งระหว่าง `--all` หรือค่า `--bind` ตั้งแต่หนึ่งค่าขึ้นไป แต่ไม่สามารถใช้ทั้งสองอย่างพร้อมกันได้
## พื้นผิวคำสั่ง
### `agents`
การรัน `openclaw agents` โดยไม่มีคำสั่งย่อย เทียบเท่ากับ `openclaw agents list`
### `agents list`
ตัวเลือก:
- `--json`
- `--bindings`: รวมกฎการกำหนดเส้นทางทั้งหมด ไม่ใช่เพียงจำนวน/สรุปต่อ agent
### `agents add [name]`
ตัวเลือก:
- `--workspace <dir>`
- `--model <id>`
- `--agent-dir <dir>`
- `--bind <channel[:accountId]>` (ระบุซ้ำได้)
- `--non-interactive`
- `--json`
หมายเหตุ:
- การส่งแฟล็ก add แบบชัดเจนใดๆ จะสลับคำสั่งไปใช้เส้นทางแบบไม่โต้ตอบ
- โหมดไม่โต้ตอบต้องมีทั้งชื่อ agent และ `--workspace`
- `main` เป็นคำสงวนและไม่สามารถใช้เป็น id ของ agent ใหม่ได้
### `agents bindings`
ตัวเลือก:
- `--agent <id>`
- `--json`
### `agents bind`
ตัวเลือก:
- `--agent <id>` (ค่าเริ่มต้นคือ default agent ปัจจุบัน)
- `--bind <channel[:accountId]>` (ระบุซ้ำได้)
- `--json`
### `agents unbind`
ตัวเลือก:
- `--agent <id>` (ค่าเริ่มต้นคือ default agent ปัจจุบัน)
- `--bind <channel[:accountId]>` (ระบุซ้ำได้)
- `--all`
- `--json`
### `agents delete <id>`
ตัวเลือก:
- `--force`
- `--json`
หมายเหตุ:
- ไม่สามารถลบ `main` ได้
- หากไม่มี `--force` จะต้องมีการยืนยันแบบโต้ตอบ
- ไดเรกทอรีเวิร์กสเปซ สถานะ agent และทรานสคริปต์เซสชันจะถูกย้ายไปยังถังขยะ ไม่ได้ลบถาวร
## ไฟล์ Identity
แต่ละเวิร์กสเปซของ agent สามารถมี `IDENTITY.md` ที่รากของเวิร์กสเปซได้:
- ตัวอย่างพาธ: `~/.openclaw/workspace/IDENTITY.md`
- `set-identity --from-identity` จะอ่านจากรากของเวิร์กสเปซ (หรือจาก `--identity-file` ที่ระบุโดยชัดเจน)
พาธของ avatar จะอ้างอิงแบบสัมพัทธ์จากรากของเวิร์กสเปซ
## ตั้งค่า identity
`set-identity` จะเขียนฟิลด์ลงใน `agents.list[].identity`:
- `name`
- `theme`
- `emoji`
- `avatar` (พาธสัมพัทธ์กับเวิร์กสเปซ, URL แบบ http(s), หรือ data URI)
ตัวเลือก:
- `--agent <id>`
- `--workspace <dir>`
- `--identity-file <path>`
- `--from-identity`
- `--name <name>`
- `--theme <theme>`
- `--emoji <emoji>`
- `--avatar <value>`
- `--json`
หมายเหตุ:
- สามารถใช้ `--agent` หรือ `--workspace` เพื่อเลือก agent เป้าหมายได้
- หากคุณใช้ `--workspace` และมีหลาย agent ใช้เวิร์กสเปซเดียวกัน คำสั่งจะล้มเหลวและขอให้คุณส่ง `--agent`
- เมื่อไม่มีการระบุฟิลด์ identity แบบชัดเจน คำสั่งจะอ่านข้อมูล identity จาก `IDENTITY.md`
โหลดจาก `IDENTITY.md`:
```bash
openclaw agents set-identity --workspace ~/.openclaw/workspace --from-identity
```
แทนที่ฟิลด์แบบชัดเจน:
```bash
openclaw agents set-identity --agent main --name "OpenClaw" --emoji "🦞" --avatar avatars/openclaw.png
```
ตัวอย่างการกำหนดค่า:
```json5
{
agents: {
list: [
{
id: "main",
identity: {
name: "OpenClaw",
theme: "space lobster",
emoji: "🦞",
avatar: "avatars/openclaw.png",
},
},
],
},
}
```

190
docs/th/cli/approvals.md Normal file
View File

@ -0,0 +1,190 @@
---
read_when:
- คุณต้องการแก้ไขการอนุมัติ exec จาก CLI
- คุณต้องจัดการ allowlists บนโฮสต์ Gateway หรือ Node
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw approvals` และ `openclaw exec-policy`
title: การอนุมัติ
x-i18n:
generated_at: "2026-04-23T06:17:03Z"
model: gpt-5.4
provider: openai
source_hash: 4e4e031df737e3bdde97ece81fe50eafbb4384557b40c6d52cf2395cf30721a3
source_path: cli/approvals.md
workflow: 15
---
# `openclaw approvals`
จัดการการอนุมัติ exec สำหรับ **โฮสต์ local**, **โฮสต์ Gateway** หรือ **โฮสต์ Node**
โดยค่าเริ่มต้น คำสั่งจะกำหนดเป้าหมายไปที่ไฟล์การอนุมัติ local บนดิสก์ ใช้ `--gateway` เพื่อกำหนดเป้าหมายไปที่ gateway หรือใช้ `--node` เพื่อกำหนดเป้าหมายไปที่ node ที่ระบุ
ชื่อเรียกแทน: `openclaw exec-approvals`
ที่เกี่ยวข้อง:
- การอนุมัติ exec: [การอนุมัติ exec](/th/tools/exec-approvals)
- Nodes: [Nodes](/th/nodes)
## `openclaw exec-policy`
`openclaw exec-policy` คือคำสั่งอำนวยความสะดวกแบบ local สำหรับทำให้การตั้งค่า `tools.exec.*` ที่ร้องขอและไฟล์การอนุมัติของโฮสต์ local สอดคล้องกันในขั้นตอนเดียว
ใช้คำสั่งนี้เมื่อคุณต้องการ:
- ตรวจสอบนโยบาย local ที่ร้องขอ ไฟล์การอนุมัติของโฮสต์ และผลลัพธ์ที่มีผลจริงหลังการรวม
- ใช้ preset แบบ local เช่น YOLO หรือ deny-all
- ซิงโครไนซ์ `tools.exec.*` แบบ local และ `~/.openclaw/exec-approvals.json` แบบ local
ตัวอย่าง:
```bash
openclaw exec-policy show
openclaw exec-policy show --json
openclaw exec-policy preset yolo
openclaw exec-policy preset cautious --json
openclaw exec-policy set --host gateway --security full --ask off --ask-fallback full
```
โหมดเอาต์พุต:
- ไม่มี `--json`: พิมพ์มุมมองตารางที่มนุษย์อ่านได้
- `--json`: พิมพ์เอาต์พุตแบบมีโครงสร้างที่เครื่องอ่านได้
ขอบเขตปัจจุบัน:
- `exec-policy` เป็น **local-only**
- คำสั่งนี้อัปเดตไฟล์ config local และไฟล์การอนุมัติ local พร้อมกัน
- คำสั่งนี้จะ **ไม่** push นโยบายไปยังโฮสต์ Gateway หรือโฮสต์ Node
- `--host node` จะถูกปฏิเสธในคำสั่งนี้ เพราะการอนุมัติ exec ของ node จะถูกดึงจาก node ระหว่างรันไทม์ และต้องจัดการผ่านคำสั่ง approvals ที่กำหนดเป้าหมายไปยัง node แทน
- `openclaw exec-policy show` จะทำเครื่องหมายขอบเขต `host=node` ว่าถูกจัดการโดย node ระหว่างรันไทม์ แทนการอนุมานนโยบายที่มีผลจริงจากไฟล์การอนุมัติ local
หากคุณต้องการแก้ไขการอนุมัติของโฮสต์ระยะไกลโดยตรง ให้ใช้ `openclaw approvals set --gateway`
หรือ `openclaw approvals set --node <id|name|ip>` ต่อไป
## คำสั่งทั่วไป
```bash
openclaw approvals get
openclaw approvals get --node <id|name|ip>
openclaw approvals get --gateway
```
ขณะนี้ `openclaw approvals get` จะแสดงนโยบาย exec ที่มีผลจริงสำหรับเป้าหมาย local, gateway และ node:
- นโยบาย `tools.exec` ที่ร้องขอ
- นโยบายจากไฟล์การอนุมัติของโฮสต์
- ผลลัพธ์ที่มีผลจริงหลังใช้กฎลำดับความสำคัญ
ลำดับความสำคัญนี้ตั้งใจออกแบบไว้เช่นนั้น:
- ไฟล์การอนุมัติของโฮสต์คือแหล่งข้อมูลจริงที่ใช้บังคับ
- นโยบาย `tools.exec` ที่ร้องขอสามารถทำให้เจตนาแคบลงหรือกว้างขึ้นได้ แต่ผลลัพธ์ที่มีผลจริงยังคงได้มาจากกฎของโฮสต์
- `--node` จะรวมไฟล์การอนุมัติของโฮสต์ node เข้ากับนโยบาย `tools.exec` ของ gateway เพราะทั้งสองอย่างยังคงมีผลในระหว่างรันไทม์
- หาก config ของ gateway ไม่พร้อมใช้งาน CLI จะย้อนกลับไปใช้ snapshot การอนุมัติของ node และระบุว่าไม่สามารถคำนวณนโยบายสุดท้ายระหว่างรันไทม์ได้
## แทนที่การอนุมัติจากไฟล์
```bash
openclaw approvals set --file ./exec-approvals.json
openclaw approvals set --stdin <<'EOF'
{ version: 1, defaults: { security: "full", ask: "off" } }
EOF
openclaw approvals set --node <id|name|ip> --file ./exec-approvals.json
openclaw approvals set --gateway --file ./exec-approvals.json
```
`set` รองรับ JSON5 ไม่ใช่เฉพาะ JSON แบบ strict เท่านั้น ใช้ `--file` หรือ `--stdin` อย่างใดอย่างหนึ่ง ห้ามใช้ทั้งสองพร้อมกัน
## ตัวอย่าง "Never prompt" / YOLO
สำหรับโฮสต์ที่ไม่ควรหยุดเพื่อขอการอนุมัติ exec เลย ให้ตั้งค่า defaults ของการอนุมัติของโฮสต์เป็น `full` + `off`:
```bash
openclaw approvals set --stdin <<'EOF'
{
version: 1,
defaults: {
security: "full",
ask: "off",
askFallback: "full"
}
}
EOF
```
ตัวแปรสำหรับ node:
```bash
openclaw approvals set --node <id|name|ip> --stdin <<'EOF'
{
version: 1,
defaults: {
security: "full",
ask: "off",
askFallback: "full"
}
}
EOF
```
การดำเนินการนี้จะเปลี่ยนเฉพาะ **ไฟล์การอนุมัติของโฮสต์** เท่านั้น เพื่อให้สอดคล้องกับนโยบาย OpenClaw ที่ร้องขอ ให้ตั้งค่าดังนี้ด้วย:
```bash
openclaw config set tools.exec.host gateway
openclaw config set tools.exec.security full
openclaw config set tools.exec.ask off
```
เหตุผลที่ใช้ `tools.exec.host=gateway` ในตัวอย่างนี้:
- `host=auto` ยังคงหมายถึง "ใช้ sandbox หากมี มิฉะนั้นใช้ gateway"
- YOLO เกี่ยวข้องกับการอนุมัติ ไม่ใช่การกำหนดเส้นทาง
- หากคุณต้องการให้ใช้ host exec แม้มีการตั้งค่า sandbox ไว้ ให้ระบุการเลือกโฮสต์อย่างชัดเจนด้วย `gateway` หรือ `/exec host=gateway`
สิ่งนี้สอดคล้องกับพฤติกรรม YOLO แบบค่าเริ่มต้นของโฮสต์ในปัจจุบัน หากคุณต้องการให้เข้มงวดขึ้น ให้ปรับการอนุมัติให้รัดกุมขึ้น
ทางลัดแบบ local:
```bash
openclaw exec-policy preset yolo
```
ทางลัดแบบ local นี้จะอัปเดตทั้ง config `tools.exec.*` local ที่ร้องขอและ
defaults ของการอนุมัติ local พร้อมกัน โดยมีเจตนาเทียบเท่ากับการตั้งค่าด้วยตนเองสองขั้นตอนข้างต้น แต่ใช้ได้เฉพาะกับเครื่อง local เท่านั้น
## ตัวช่วย allowlist
```bash
openclaw approvals allowlist add "~/Projects/**/bin/rg"
openclaw approvals allowlist add --agent main --node <id|name|ip> "/usr/bin/uptime"
openclaw approvals allowlist add --agent "*" "/usr/bin/uname"
openclaw approvals allowlist remove "~/Projects/**/bin/rg"
```
## ตัวเลือกทั่วไป
`get`, `set` และ `allowlist add|remove` ทั้งหมดรองรับ:
- `--node <id|name|ip>`
- `--gateway`
- ตัวเลือก node RPC ที่ใช้ร่วมกัน: `--url`, `--token`, `--timeout`, `--json`
หมายเหตุเกี่ยวกับการกำหนดเป้าหมาย:
- หากไม่มี target flags จะหมายถึงไฟล์การอนุมัติ local บนดิสก์
- `--gateway` กำหนดเป้าหมายไปที่ไฟล์การอนุมัติของโฮสต์ Gateway
- `--node` กำหนดเป้าหมายไปที่โฮสต์ node หนึ่งตัว หลังจาก resolve id, name, IP หรือคำนำหน้า id แล้ว
`allowlist add|remove` ยังรองรับ:
- `--agent <id>` (ค่าเริ่มต้นคือ `*`)
## หมายเหตุ
- `--node` ใช้ตัว resolve เดียวกับ `openclaw nodes` (id, name, ip หรือคำนำหน้า id)
- `--agent` มีค่าเริ่มต้นเป็น `"*"` ซึ่งใช้กับ agents ทั้งหมด
- โฮสต์ node ต้องประกาศรองรับ `system.execApprovals.get/set` (แอป macOS หรือโฮสต์ node แบบ headless)
- ไฟล์การอนุมัติจะถูกจัดเก็บแยกตามโฮสต์ที่ `~/.openclaw/exec-approvals.json`

91
docs/th/cli/backup.md Normal file
View File

@ -0,0 +1,91 @@
---
read_when:
- คุณต้องการไฟล์เก็บถาวรสำรองข้อมูลชั้นหนึ่งสำหรับสถานะ OpenClaw ในเครื่อง
- คุณต้องการดูตัวอย่างว่าเส้นทางใดบ้างที่จะถูกรวมไว้ก่อนการรีเซ็ตหรือถอนการติดตั้ง
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw backup` (สร้างไฟล์เก็บถาวรสำรองข้อมูลในเครื่อง)
title: สำรองข้อมูล
x-i18n:
generated_at: "2026-04-23T06:17:04Z"
model: gpt-5.4
provider: openai
source_hash: 700eda8f9eac1cc93a854fa579f128e5e97d4e6dfc0da75b437c0fb2a898a37d
source_path: cli/backup.md
workflow: 15
---
# `openclaw backup`
สร้างไฟล์เก็บถาวรสำรองข้อมูลในเครื่องสำหรับสถานะ การกำหนดค่า โปรไฟล์การยืนยันตัวตน ข้อมูลรับรองของช่องทาง/ผู้ให้บริการ เซสชัน และเวิร์กสเปซของ OpenClaw ตามตัวเลือก
```bash
openclaw backup create
openclaw backup create --output ~/Backups
openclaw backup create --dry-run --json
openclaw backup create --verify
openclaw backup create --no-include-workspace
openclaw backup create --only-config
openclaw backup verify ./2026-03-09T00-00-00.000Z-openclaw-backup.tar.gz
```
## หมายเหตุ
- ไฟล์เก็บถาวรประกอบด้วยไฟล์ `manifest.json` ที่มีเส้นทางต้นทางที่ resolve แล้วและโครงร่างภายในไฟล์เก็บถาวร
- เอาต์พุตเริ่มต้นคือไฟล์เก็บถาวร `.tar.gz` ที่มีการประทับเวลาในไดเรกทอรีทำงานปัจจุบัน
- หากไดเรกทอรีทำงานปัจจุบันอยู่ภายในต้นไม้ต้นทางที่มีการสำรองข้อมูล OpenClaw จะย้อนกลับไปใช้ไดเรกทอรีโฮมของคุณเป็นตำแหน่งเริ่มต้นสำหรับไฟล์เก็บถาวร
- จะไม่มีการเขียนทับไฟล์เก็บถาวรที่มีอยู่แล้ว
- ระบบจะปฏิเสธเส้นทางเอาต์พุตที่อยู่ภายในต้นไม้สถานะ/เวิร์กสเปซต้นทางเพื่อหลีกเลี่ยงการรวมตัวเองเข้าไป
- `openclaw backup verify <archive>` จะตรวจสอบว่าไฟล์เก็บถาวรมีรูท manifest เพียงหนึ่งรายการ ปฏิเสธเส้นทางภายในไฟล์เก็บถาวรแบบ traversal และตรวจสอบว่าเพย์โหลดทุกชิ้นที่ประกาศไว้ใน manifest มีอยู่ใน tarball
- `openclaw backup create --verify` จะรันการตรวจสอบนั้นทันทีหลังจากเขียนไฟล์เก็บถาวรเสร็จ
- `openclaw backup create --only-config` จะสำรองข้อมูลเฉพาะไฟล์ config JSON ที่ใช้งานอยู่
## สิ่งที่ถูกสำรองข้อมูล
`openclaw backup create` จะวางแผนแหล่งต้นทางสำหรับการสำรองข้อมูลจากการติดตั้ง OpenClaw ในเครื่องของคุณ:
- ไดเรกทอรีสถานะที่คืนค่ามาโดยตัว resolver สถานะในเครื่องของ OpenClaw ซึ่งโดยทั่วไปคือ `~/.openclaw`
- เส้นทางของไฟล์ config ที่ใช้งานอยู่
- ไดเรกทอรี `credentials/` ที่ resolve แล้ว เมื่อมีอยู่ภายนอกไดเรกทอรีสถานะ
- ไดเรกทอรีเวิร์กสเปซที่ค้นพบจาก config ปัจจุบัน เว้นแต่คุณจะส่ง `--no-include-workspace`
โปรไฟล์การยืนยันตัวตนของโมเดลเป็นส่วนหนึ่งของไดเรกทอรีสถานะอยู่แล้วภายใต้
`agents/<agentId>/agent/auth-profiles.json` ดังนั้นโดยปกติจึงถูกรวมอยู่ในการสำรองข้อมูล
ของสถานะ
หากคุณใช้ `--only-config` OpenClaw จะข้ามการค้นหาสถานะ ไดเรกทอรีข้อมูลรับรอง และเวิร์กสเปซ แล้วจัดเก็บเฉพาะเส้นทางของไฟล์ config ที่ใช้งานอยู่เท่านั้น
OpenClaw จะทำให้เส้นทางเป็น canonical ก่อนสร้างไฟล์เก็บถาวร หาก config,
ไดเรกทอรีข้อมูลรับรอง หรือเวิร์กสเปซมีอยู่ภายในไดเรกทอรีสถานะอยู่แล้ว
จะไม่ถูกทำซ้ำเป็นแหล่งต้นทางระดับบนสุดแยกต่างหากสำหรับการสำรองข้อมูล เส้นทางที่ไม่มีอยู่จะ
ถูกข้าม
เพย์โหลดในไฟล์เก็บถาวรจะเก็บเนื้อหาไฟล์จากต้นไม้ต้นทางเหล่านั้น และ `manifest.json` ที่ฝังอยู่จะบันทึกเส้นทางต้นทางสัมบูรณ์ที่ resolve แล้ว พร้อมทั้งโครงร่างภายในไฟล์เก็บถาวรที่ใช้สำหรับแต่ละรายการ
## พฤติกรรมเมื่อ config ไม่ถูกต้อง
`openclaw backup` ตั้งใจข้ามการตรวจสอบ config ล่วงหน้าตามปกติเพื่อให้ยังช่วยในระหว่างการกู้คืนได้ เนื่องจากการค้นหาเวิร์กสเปซขึ้นอยู่กับ config ที่ถูกต้อง `openclaw backup create` จึงจะล้มเหลวทันทีเมื่อไฟล์ config มีอยู่แต่ไม่ถูกต้อง และยังคงเปิดใช้การสำรองข้อมูลเวิร์กสเปซอยู่
หากคุณยังต้องการการสำรองข้อมูลบางส่วนในสถานการณ์นั้น ให้รันใหม่:
```bash
openclaw backup create --no-include-workspace
```
ซึ่งจะยังคงรวมสถานะ config และไดเรกทอรีข้อมูลรับรองภายนอกไว้ในขอบเขต
ขณะเดียวกันก็ข้ามการค้นหาเวิร์กสเปซทั้งหมด
หากคุณต้องการเพียงสำเนาของไฟล์ config เอง `--only-config` ก็ใช้ได้เมื่อ config มีรูปแบบไม่ถูกต้องเช่นกัน เพราะไม่ต้องพึ่งการแยกวิเคราะห์ config เพื่อค้นหาเวิร์กสเปซ
## ขนาดและประสิทธิภาพ
OpenClaw ไม่ได้กำหนดขนาดสำรองข้อมูลสูงสุดหรือขนาดไฟล์ต่อไฟล์สูงสุดไว้ในตัว
ข้อจำกัดในทางปฏิบัติมาจากเครื่องภายในและระบบไฟล์ปลายทาง:
- พื้นที่ว่างที่มีสำหรับการเขียนไฟล์เก็บถาวรชั่วคราวและไฟล์เก็บถาวรสุดท้าย
- เวลาที่ใช้ในการไล่ดูต้นไม้เวิร์กสเปซขนาดใหญ่และบีบอัดเป็น `.tar.gz`
- เวลาที่ใช้สแกนไฟล์เก็บถาวรอีกครั้ง หากคุณใช้ `openclaw backup create --verify` หรือรัน `openclaw backup verify`
- พฤติกรรมของระบบไฟล์ที่เส้นทางปลายทาง OpenClaw จะพยายามใช้ขั้นตอนเผยแพร่แบบ hard-link ที่ไม่เขียนทับก่อน และจะย้อนกลับไปใช้การคัดลอกแบบ exclusive เมื่อไม่รองรับ hard link
เวิร์กสเปซขนาดใหญ่มักเป็นปัจจัยหลักที่ทำให้ไฟล์เก็บถาวรมีขนาดใหญ่ หากคุณต้องการการสำรองข้อมูลที่เล็กลงหรือเร็วขึ้น ให้ใช้ `--no-include-workspace`
สำหรับไฟล์เก็บถาวรที่เล็กที่สุด ให้ใช้ `--only-config`

243
docs/th/cli/browser.md Normal file
View File

@ -0,0 +1,243 @@
---
read_when:
- คุณใช้ `openclaw browser` และต้องการตัวอย่างสำหรับงานทั่วไป
- คุณต้องการควบคุมเบราว์เซอร์ที่ทำงานอยู่บนเครื่องอื่นผ่านโฮสต์ Node
- คุณต้องการเชื่อมต่อกับ Chrome ในเครื่องของคุณที่ลงชื่อเข้าใช้อยู่ผ่าน Chrome MCP
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw browser` (วงจรชีวิต, โปรไฟล์, แท็บ, การดำเนินการ, สถานะ และการดีบัก)
title: เบราว์เซอร์
x-i18n:
generated_at: "2026-04-23T06:17:07Z"
model: gpt-5.4
provider: openai
source_hash: 0cf1a5168e690121d4fc4eac984580c89bc50844f15558413ba6d8a635da2ed6
source_path: cli/browser.md
workflow: 15
---
# `openclaw browser`
จัดการพื้นผิวการควบคุมเบราว์เซอร์ของ OpenClaw และเรียกใช้การดำเนินการของเบราว์เซอร์ (วงจรชีวิต, โปรไฟล์, แท็บ, snapshot, screenshot, การนำทาง, การป้อนข้อมูล, การจำลองสถานะ และการดีบัก)
ที่เกี่ยวข้อง:
- เครื่องมือเบราว์เซอร์ + API: [เครื่องมือเบราว์เซอร์](/th/tools/browser)
## แฟล็กทั่วไป
- `--url <gatewayWsUrl>`: URL WebSocket ของ Gateway (ค่าเริ่มต้นจาก config)
- `--token <token>`: โทเค็นของ Gateway (หากจำเป็น)
- `--timeout <ms>`: หมดเวลาคำขอ (มิลลิวินาที)
- `--expect-final`: รอการตอบกลับสุดท้ายจาก Gateway
- `--browser-profile <name>`: เลือกโปรไฟล์เบราว์เซอร์ (ค่าเริ่มต้นจาก config)
- `--json`: เอาต์พุตที่เครื่องอ่านได้ (ในจุดที่รองรับ)
## เริ่มต้นใช้งานอย่างรวดเร็ว (ในเครื่อง)
```bash
openclaw browser profiles
openclaw browser --browser-profile openclaw start
openclaw browser --browser-profile openclaw open https://example.com
openclaw browser --browser-profile openclaw snapshot
```
## การแก้ปัญหาอย่างรวดเร็ว
หาก `start` ล้มเหลวพร้อม `not reachable after start` ให้แก้ปัญหาความพร้อมของ CDP ก่อน หาก `start` และ `tabs` สำเร็จ แต่ `open` หรือ `navigate` ล้มเหลว แสดงว่าระนาบควบคุมเบราว์เซอร์ทำงานปกติ และปัญหามักเป็นนโยบาย SSRF ของการนำทาง
ลำดับขั้นต่ำ:
```bash
openclaw browser --browser-profile openclaw start
openclaw browser --browser-profile openclaw tabs
openclaw browser --browser-profile openclaw open https://example.com
```
คำแนะนำโดยละเอียด: [การแก้ปัญหาเบราว์เซอร์](/th/tools/browser#cdp-startup-failure-vs-navigation-ssrf-block)
## วงจรชีวิต
```bash
openclaw browser status
openclaw browser start
openclaw browser stop
openclaw browser --browser-profile openclaw reset-profile
```
หมายเหตุ:
- สำหรับโปรไฟล์ `attachOnly` และ CDP ระยะไกล คำสั่ง `openclaw browser stop` จะปิดเซสชันควบคุมที่ใช้งานอยู่และล้างการแทนที่การจำลองชั่วคราว แม้ว่า OpenClaw จะไม่ได้เป็นผู้เปิดโปรเซสเบราว์เซอร์เองก็ตาม
- สำหรับโปรไฟล์ที่จัดการในเครื่อง `openclaw browser stop` จะหยุดโปรเซสเบราว์เซอร์ที่ถูกสร้างขึ้น
## หากไม่มีคำสั่งนี้
หาก `openclaw browser` เป็นคำสั่งที่ไม่รู้จัก ให้ตรวจสอบ `plugins.allow` ใน `~/.openclaw/openclaw.json`
เมื่อมี `plugins.allow` อยู่ ต้องระบุ browser Plugin ที่มากับระบบไว้อย่างชัดเจน:
```json5
{
plugins: {
allow: ["telegram", "browser"],
},
}
```
`browser.enabled=true` จะไม่กู้คืนคำสั่งย่อย CLI หาก allowlist ของ plugin ตัด `browser` ออก
ที่เกี่ยวข้อง: [เครื่องมือเบราว์เซอร์](/th/tools/browser#missing-browser-command-or-tool)
## โปรไฟล์
โปรไฟล์คือการกำหนดค่าการกำหนดเส้นทางเบราว์เซอร์ตามชื่อ ในทางปฏิบัติ:
- `openclaw`: เปิดหรือเชื่อมต่อกับอินสแตนซ์ Chrome ที่ OpenClaw จัดการโดยเฉพาะ (ไดเรกทอรีข้อมูลผู้ใช้แบบแยก)
- `user`: ควบคุมเซสชัน Chrome ที่ลงชื่อเข้าใช้อยู่ของคุณผ่าน Chrome DevTools MCP
- โปรไฟล์ CDP แบบกำหนดเอง: ชี้ไปยังปลายทาง CDP ในเครื่องหรือระยะไกล
```bash
openclaw browser profiles
openclaw browser create-profile --name work --color "#FF5A36"
openclaw browser create-profile --name chrome-live --driver existing-session
openclaw browser create-profile --name remote --cdp-url https://browser-host.example.com
openclaw browser delete-profile --name work
```
ใช้โปรไฟล์เฉพาะ:
```bash
openclaw browser --browser-profile work tabs
```
## แท็บ
```bash
openclaw browser tabs
openclaw browser tab new
openclaw browser tab select 2
openclaw browser tab close 2
openclaw browser open https://docs.openclaw.ai
openclaw browser focus <targetId>
openclaw browser close <targetId>
```
## Snapshot / screenshot / การดำเนินการ
Snapshot:
```bash
openclaw browser snapshot
```
Screenshot:
```bash
openclaw browser screenshot
openclaw browser screenshot --full-page
openclaw browser screenshot --ref e12
```
หมายเหตุ:
- `--full-page` ใช้ได้เฉพาะกับการจับภาพทั้งหน้าเท่านั้น ไม่สามารถใช้ร่วมกับ `--ref` หรือ `--element`
- โปรไฟล์ `existing-session` / `user` รองรับ screenshot ของหน้าและ screenshot แบบ `--ref` จากเอาต์พุต snapshot แต่ไม่รองรับ screenshot แบบ CSS `--element`
นำทาง/คลิก/พิมพ์ (ระบบอัตโนมัติ UI แบบอ้างอิง ref):
```bash
openclaw browser navigate https://example.com
openclaw browser click <ref>
openclaw browser type <ref> "hello"
openclaw browser press Enter
openclaw browser hover <ref>
openclaw browser scrollintoview <ref>
openclaw browser drag <startRef> <endRef>
openclaw browser select <ref> OptionA OptionB
openclaw browser fill --fields '[{"ref":"1","value":"Ada"}]'
openclaw browser wait --text "Done"
openclaw browser evaluate --fn '(el) => el.textContent' --ref <ref>
```
ตัวช่วยไฟล์ + กล่องโต้ตอบ:
```bash
openclaw browser upload /tmp/openclaw/uploads/file.pdf --ref <ref>
openclaw browser waitfordownload
openclaw browser download <ref> report.pdf
openclaw browser dialog --accept
```
## สถานะและที่เก็บข้อมูล
Viewport + การจำลอง:
```bash
openclaw browser resize 1280 720
openclaw browser set viewport 1280 720
openclaw browser set offline on
openclaw browser set media dark
openclaw browser set timezone Europe/London
openclaw browser set locale en-GB
openclaw browser set geo 51.5074 -0.1278 --accuracy 25
openclaw browser set device "iPhone 14"
openclaw browser set headers '{"x-test":"1"}'
openclaw browser set credentials myuser mypass
```
คุกกี้ + ที่เก็บข้อมูล:
```bash
openclaw browser cookies
openclaw browser cookies set session abc123 --url https://example.com
openclaw browser cookies clear
openclaw browser storage local get
openclaw browser storage local set token abc123
openclaw browser storage session clear
```
## การดีบัก
```bash
openclaw browser console --level error
openclaw browser pdf
openclaw browser responsebody "**/api"
openclaw browser highlight <ref>
openclaw browser errors --clear
openclaw browser requests --filter api
openclaw browser trace start
openclaw browser trace stop --out trace.zip
```
## Chrome ที่มีอยู่แล้วผ่าน MCP
ใช้โปรไฟล์ `user` ที่มีมาให้ หรือสร้างโปรไฟล์ `existing-session` ของคุณเอง:
```bash
openclaw browser --browser-profile user tabs
openclaw browser create-profile --name chrome-live --driver existing-session
openclaw browser create-profile --name brave-live --driver existing-session --user-data-dir "~/Library/Application Support/BraveSoftware/Brave-Browser"
openclaw browser --browser-profile chrome-live tabs
```
เส้นทางนี้ใช้ได้เฉพาะบนโฮสต์เท่านั้น สำหรับ Docker, เซิร์ฟเวอร์แบบ headless, Browserless หรือการตั้งค่าระยะไกลอื่น ๆ ให้ใช้โปรไฟล์ CDP แทน
ข้อจำกัดปัจจุบันของ existing-session:
- การดำเนินการที่ขับเคลื่อนด้วย snapshot ใช้ ref ไม่ใช่ตัวเลือก CSS
- `click` รองรับเฉพาะคลิกซ้าย
- `type` ไม่รองรับ `slowly=true`
- `press` ไม่รองรับ `delayMs`
- `hover`, `scrollintoview`, `drag`, `select`, `fill` และ `evaluate` จะปฏิเสธการแทนที่ timeout รายคำสั่ง
- `select` รองรับค่าเดียวเท่านั้น
- ไม่รองรับ `wait --load networkidle`
- การอัปโหลดไฟล์ต้องใช้ `--ref` / `--input-ref`, ไม่รองรับ CSS `--element` และปัจจุบันรองรับครั้งละหนึ่งไฟล์
- hook ของกล่องโต้ตอบไม่รองรับ `--timeout`
- screenshot รองรับการจับภาพทั้งหน้าและ `--ref` แต่ไม่รองรับ CSS `--element`
- `responsebody`, การดักจับการดาวน์โหลด, การส่งออก PDF และการดำเนินการแบบแบตช์ ยังคงต้องใช้เบราว์เซอร์ที่มีการจัดการหรือโปรไฟล์ CDP ดิบ
## การควบคุมเบราว์เซอร์ระยะไกล (พร็อกซีโฮสต์ node)
หาก Gateway ทำงานอยู่คนละเครื่องกับเบราว์เซอร์ ให้รัน **node host** บนเครื่องที่มี Chrome/Brave/Edge/Chromium จากนั้น Gateway จะพร็อกซีการดำเนินการของเบราว์เซอร์ไปยัง node นั้น (ไม่ต้องใช้เซิร์ฟเวอร์ควบคุมเบราว์เซอร์แยกต่างหาก)
ใช้ `gateway.nodes.browser.mode` เพื่อควบคุมการกำหนดเส้นทางอัตโนมัติ และใช้ `gateway.nodes.browser.node` เพื่อปักหมุด node ที่ต้องการหากมีหลาย node เชื่อมต่ออยู่
ความปลอดภัย + การตั้งค่าระยะไกล: [เครื่องมือเบราว์เซอร์](/th/tools/browser), [การเข้าถึงระยะไกล](/th/gateway/remote), [Tailscale](/th/gateway/tailscale), [ความปลอดภัย](/th/gateway/security)

135
docs/th/cli/channels.md Normal file
View File

@ -0,0 +1,135 @@
---
read_when:
- คุณต้องการเพิ่ม/ลบบัญชีช่องทาง (WhatsApp/Telegram/Discord/Google Chat/Slack/Mattermost (Plugin)/Signal/iMessage/Matrix)
- คุณต้องการตรวจสอบสถานะช่องทาง หรือดูบันทึกช่องทางแบบต่อเนื่อง
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw channels` (บัญชี, สถานะ, เข้าสู่ระบบ/ออกจากระบบ, บันทึก)
title: ช่องทาง
x-i18n:
generated_at: "2026-04-23T06:17:05Z"
model: gpt-5.4
provider: openai
source_hash: d0f558fdb5f6ec54e7fdb7a88e5c24c9d2567174341bd3ea87848bce4cba5d29
source_path: cli/channels.md
workflow: 15
---
# `openclaw channels`
จัดการบัญชีช่องทางแชตและสถานะรันไทม์ของบัญชีเหล่านั้นบน Gateway
เอกสารที่เกี่ยวข้อง:
- คู่มือช่องทาง: [Channels](/th/channels/index)
- การกำหนดค่า Gateway: [Configuration](/th/gateway/configuration)
## คำสั่งที่ใช้บ่อย
```bash
openclaw channels list
openclaw channels status
openclaw channels capabilities
openclaw channels capabilities --channel discord --target channel:123
openclaw channels resolve --channel slack "#general" "@jane"
openclaw channels logs --channel all
```
## สถานะ / ความสามารถ / การแก้ชื่อเป็นรหัส / บันทึก
- `channels status`: `--probe`, `--timeout <ms>`, `--json`
- `channels capabilities`: `--channel <name>`, `--account <id>` (ใช้ได้เฉพาะกับ `--channel`), `--target <dest>`, `--timeout <ms>`, `--json`
- `channels resolve`: `<entries...>`, `--channel <name>`, `--account <id>`, `--kind <auto|user|group>`, `--json`
- `channels logs`: `--channel <name|all>`, `--lines <n>`, `--json`
`channels status --probe` เป็นเส้นทางแบบสด: เมื่อเข้าถึง gateway ได้ คำสั่งนี้จะรันการตรวจสอบ `probeAccount` และ `auditAccount` แบบไม่บังคับสำหรับแต่ละบัญชี ดังนั้นผลลัพธ์อาจมีทั้งสถานะของการขนส่งข้อมูลและผลการตรวจสอบ เช่น `works`, `probe failed`, `audit ok` หรือ `audit failed`
หากไม่สามารถเข้าถึง gateway ได้ `channels status` จะถอยกลับไปใช้สรุปจากการกำหนดค่าเท่านั้น แทนการแสดงผลการตรวจสอบแบบสด
## เพิ่ม / ลบบัญชี
```bash
openclaw channels add --channel telegram --token <bot-token>
openclaw channels add --channel nostr --private-key "$NOSTR_PRIVATE_KEY"
openclaw channels remove --channel telegram --delete
```
เคล็ดลับ: `openclaw channels add --help` จะแสดงแฟล็กเฉพาะของแต่ละช่องทาง (token, private key, app token, signal-cli paths ฯลฯ)
พื้นผิวการเพิ่มแบบไม่โต้ตอบที่พบบ่อยประกอบด้วย:
- ช่องทาง bot-token: `--token`, `--bot-token`, `--app-token`, `--token-file`
- ฟิลด์การขนส่งของ Signal/iMessage: `--signal-number`, `--cli-path`, `--http-url`, `--http-host`, `--http-port`, `--db-path`, `--service`, `--region`
- ฟิลด์ของ Google Chat: `--webhook-path`, `--webhook-url`, `--audience-type`, `--audience`
- ฟิลด์ของ Matrix: `--homeserver`, `--user-id`, `--access-token`, `--password`, `--device-name`, `--initial-sync-limit`
- ฟิลด์ของ Nostr: `--private-key`, `--relay-urls`
- ฟิลด์ของ Tlon: `--ship`, `--url`, `--code`, `--group-channels`, `--dm-allowlist`, `--auto-discover-channels`
- `--use-env` สำหรับการยืนยันตัวตนแบบอิง env ของบัญชีเริ่มต้นในกรณีที่รองรับ
เมื่อคุณรัน `openclaw channels add` โดยไม่ระบุแฟล็ก วิซาร์ดแบบโต้ตอบอาจถามเกี่ยวกับ:
- รหัสบัญชีสำหรับแต่ละช่องทางที่เลือก
- ชื่อที่แสดงผลแบบไม่บังคับสำหรับบัญชีเหล่านั้น
- `Bind configured channel accounts to agents now?`
หากคุณยืนยันให้ bind ทันที วิซาร์ดจะถามว่า agent ใดควรเป็นเจ้าของบัญชีช่องทางที่กำหนดค่าไว้แต่ละบัญชี และจะเขียนการ bind เส้นทางแบบกำหนดขอบเขตตามบัญชี
คุณยังสามารถจัดการกฎการกำหนดเส้นทางเดียวกันนี้ภายหลังได้ด้วย `openclaw agents bindings`, `openclaw agents bind` และ `openclaw agents unbind` (ดู [agents](/th/cli/agents))
เมื่อคุณเพิ่มบัญชีที่ไม่ใช่บัญชีเริ่มต้นให้กับช่องทางที่ยังใช้การตั้งค่าระดับบนสุดแบบบัญชีเดียว OpenClaw จะเลื่อนค่าระดับบนสุดที่กำหนดขอบเขตตามบัญชีเข้าไปในแผนที่บัญชีของช่องทางนั้นก่อน แล้วจึงเขียนบัญชีใหม่ ช่องทางส่วนใหญ่จะวางค่าเหล่านั้นไว้ใน `channels.<channel>.accounts.default` แต่ช่องทางที่มากับระบบสามารถคงบัญชีที่เลื่อนขึ้นมาซึ่งตรงกันและมีอยู่แล้วไว้แทนได้ Matrix เป็นตัวอย่างในปัจจุบัน: หากมีบัญชีที่มีชื่ออยู่แล้วหนึ่งบัญชี หรือ `defaultAccount` ชี้ไปยังบัญชีที่มีชื่ออยู่แล้ว การเลื่อนค่าขึ้นจะคงบัญชีนั้นไว้แทนที่จะสร้าง `accounts.default` ใหม่
พฤติกรรมการกำหนดเส้นทางยังคงสอดคล้องกัน:
- การ bind แบบอิงเฉพาะช่องทางที่มีอยู่เดิม (ไม่มี `accountId`) จะยังคงจับคู่กับบัญชีเริ่มต้น
- `channels add` จะไม่สร้างหรือเขียนทับการ bind โดยอัตโนมัติในโหมดไม่โต้ตอบ
- การตั้งค่าแบบโต้ตอบสามารถเพิ่มการ bind แบบกำหนดขอบเขตตามบัญชีได้ตามตัวเลือก
หากการกำหนดค่าของคุณอยู่ในสถานะแบบผสมอยู่แล้ว (มีบัญชีที่มีชื่ออยู่ และยังตั้งค่าระดับบนสุดแบบบัญชีเดียวไว้อยู่) ให้รัน `openclaw doctor --fix` เพื่อย้ายค่าที่กำหนดขอบเขตตามบัญชีไปยังบัญชีที่ถูกเลื่อนขึ้นซึ่งเลือกไว้สำหรับช่องทางนั้น ช่องทางส่วนใหญ่จะเลื่อนเข้าไปใน `accounts.default`; Matrix อาจคงเป้าหมายที่มีชื่ออยู่แล้ว/ค่าเริ่มต้นไว้แทน
## เข้าสู่ระบบ / ออกจากระบบ (แบบโต้ตอบ)
```bash
openclaw channels login --channel whatsapp
openclaw channels logout --channel whatsapp
```
หมายเหตุ:
- `channels login` รองรับ `--verbose`
- `channels login` / `logout` สามารถอนุมานช่องทางได้เมื่อมีการกำหนดค่าเป้าหมายการเข้าสู่ระบบที่รองรับไว้เพียงรายการเดียว
## การแก้ปัญหา
- รัน `openclaw status --deep` เพื่อทำการตรวจสอบแบบกว้าง
- ใช้ `openclaw doctor` สำหรับการแก้ไขแบบมีคำแนะนำ
- `openclaw channels list` แสดง `Claude: HTTP 403 ... user:profile` → สแนปช็อตการใช้งานต้องการ scope `user:profile` ใช้ `--no-usage` หรือระบุคีย์เซสชัน claude.ai (`CLAUDE_WEB_SESSION_KEY` / `CLAUDE_WEB_COOKIE`) หรือยืนยันตัวตนใหม่ผ่าน Claude CLI
- `openclaw channels status` จะถอยกลับไปใช้สรุปจากการกำหนดค่าเท่านั้นเมื่อไม่สามารถเข้าถึง gateway ได้ หากมีการกำหนดค่าข้อมูลรับรองของช่องทางที่รองรับผ่าน SecretRef แต่ไม่พร้อมใช้งานในเส้นทางคำสั่งปัจจุบัน ระบบจะรายงานบัญชีนั้นว่าได้รับการกำหนดค่าแล้วพร้อมหมายเหตุเกี่ยวกับสภาวะ degraded แทนที่จะแสดงว่าไม่ได้กำหนดค่า
## การตรวจสอบความสามารถ
ดึงคำใบ้เกี่ยวกับความสามารถของผู้ให้บริการ (intents/scopes หากมี) พร้อมกับการรองรับฟีเจอร์แบบคงที่:
```bash
openclaw channels capabilities
openclaw channels capabilities --channel discord --target channel:123
```
หมายเหตุ:
- `--channel` เป็นตัวเลือกเสริม; หากไม่ระบุ ระบบจะแสดงทุกช่องทาง (รวมถึง extensions)
- `--account` ใช้ได้เฉพาะร่วมกับ `--channel`
- `--target` รับค่าเป็น `channel:<id>` หรือรหัส channel แบบตัวเลขล้วน และใช้ได้กับ Discord เท่านั้น
- การตรวจสอบขึ้นอยู่กับผู้ให้บริการ: Discord intents + สิทธิ์ของช่องทางแบบไม่บังคับ; Slack bot + user scopes; Telegram bot flags + webhook; Signal daemon version; Microsoft Teams app token + Graph roles/scopes (มีคำอธิบายประกอบเมื่อทราบข้อมูล) ช่องทางที่ไม่มีการตรวจสอบจะแสดง `Probe: unavailable`
## แก้ชื่อเป็นรหัส ID
แก้ชื่อช่องทาง/ผู้ใช้ให้เป็นรหัส ID โดยใช้ไดเรกทอรีของผู้ให้บริการ:
```bash
openclaw channels resolve --channel slack "#general" "@jane"
openclaw channels resolve --channel discord "My Server/#support" "@someone"
openclaw channels resolve --channel matrix "Project Room"
```
หมายเหตุ:
- ใช้ `--kind user|group|auto` เพื่อบังคับชนิดของเป้าหมาย
- การแก้ชื่อจะให้ความสำคัญกับรายการที่ใช้งานอยู่เมื่อมีหลายรายการใช้ชื่อเดียวกัน
- `channels resolve` เป็นแบบอ่านอย่างเดียว หากบัญชีที่เลือกได้รับการกำหนดค่าผ่าน SecretRef แต่ข้อมูลรับรองนั้นไม่พร้อมใช้งานในเส้นทางคำสั่งปัจจุบัน คำสั่งจะส่งคืนผลลัพธ์ที่ยังแก้ชื่อไม่ได้แบบ degraded พร้อมหมายเหตุ แทนที่จะยกเลิกการทำงานทั้งหมด

28
docs/th/cli/clawbot.md Normal file
View File

@ -0,0 +1,28 @@
---
read_when:
- คุณดูแลสคริปต์รุ่นเก่าที่ใช้ `openclaw clawbot ...`
- คุณต้องการคำแนะนำในการย้ายไปใช้คำสั่งปัจจุบัน
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw clawbot` (เนมสเปซนามแฝงแบบเดิม)
title: clawbot
x-i18n:
generated_at: "2026-04-23T06:17:04Z"
model: gpt-5.4
provider: openai
source_hash: 1db82065ecb0107d1ab1a2c6ddaee9df1dd02b983ca1f759974c9d73f0ee3bde
source_path: cli/clawbot.md
workflow: 15
---
# `openclaw clawbot`
เนมสเปซนามแฝงแบบเดิมที่คงไว้เพื่อความเข้ากันได้ย้อนหลัง
นามแฝงที่รองรับในปัจจุบัน:
- `openclaw clawbot qr` (พฤติกรรมเดียวกันกับ [`openclaw qr`](/th/cli/qr))
## การย้าย
ควรใช้คำสั่งระดับบนสุดแบบสมัยใหม่โดยตรง:
- `openclaw clawbot qr` -> `openclaw qr`

42
docs/th/cli/completion.md Normal file
View File

@ -0,0 +1,42 @@
---
read_when:
- คุณต้องการ shell completion สำหรับ zsh/bash/fish/PowerShell
- คุณต้องการแคชสคริปต์ completion ไว้ภายใต้สถานะของ OpenClaw
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw completion` (สร้าง/ติดตั้งสคริปต์ shell completion)
title: completion
x-i18n:
generated_at: "2026-04-23T06:17:09Z"
model: gpt-5.4
provider: openai
source_hash: 7bbf140a880bafdb7140149f85465d66d0d46e5a3da6a1e41fb78be2fd2bd4d0
source_path: cli/completion.md
workflow: 15
---
# `openclaw completion`
สร้างสคริปต์ shell completion และเลือกติดตั้งลงในโปรไฟล์เชลล์ของคุณได้
## การใช้งาน
```bash
openclaw completion
openclaw completion --shell zsh
openclaw completion --install
openclaw completion --shell fish --install
openclaw completion --write-state
openclaw completion --shell bash --write-state
```
## ตัวเลือก
- `-s, --shell <shell>`: shell เป้าหมาย (`zsh`, `bash`, `powershell`, `fish`; ค่าเริ่มต้น: `zsh`)
- `-i, --install`: ติดตั้ง completion โดยเพิ่มบรรทัด source ลงในโปรไฟล์เชลล์ของคุณ
- `--write-state`: เขียนสคริปต์ completion ไปที่ `$OPENCLAW_STATE_DIR/completions` โดยไม่พิมพ์ไปยัง stdout
- `-y, --yes`: ข้ามพรอมต์ยืนยันการติดตั้ง
## หมายเหตุ
- `--install` จะเขียนบล็อก "OpenClaw Completion" ขนาดเล็กลงในโปรไฟล์เชลล์ของคุณ และชี้ไปยังสคริปต์ที่แคชไว้
- หากไม่ใช้ `--install` หรือ `--write-state` คำสั่งจะพิมพ์สคริปต์ไปยัง stdout
- การสร้าง completion จะโหลดโครงสร้างคำสั่งทั้งหมดล่วงหน้า เพื่อให้รวมคำสั่งย่อยที่ซ้อนกันอยู่ด้วย

436
docs/th/cli/config.md Normal file
View File

@ -0,0 +1,436 @@
---
read_when:
- คุณต้องการอ่านหรือแก้ไข config แบบไม่โต้ตอบ
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw config` (get/set/unset/file/schema/validate)
title: config
x-i18n:
generated_at: "2026-04-23T06:17:25Z"
model: gpt-5.4
provider: openai
source_hash: 2b496b6c02eeb144bfe800b801ea48a178b02bc7a87197dbf189b27d6fcf41c9
source_path: cli/config.md
workflow: 15
---
# `openclaw config`
ตัวช่วยสำหรับ config เพื่อแก้ไขแบบไม่โต้ตอบใน `openclaw.json`: get/set/unset/file/schema/validate
ค่าตามพาธ และพิมพ์ไฟล์ config ที่กำลังใช้งานอยู่ เรียกใช้โดยไม่ระบุคำสั่งย่อยเพื่อ
เปิดวิซาร์ดการตั้งค่า (เช่นเดียวกับ `openclaw configure`)
ตัวเลือกระดับราก:
- `--section <section>`: ตัวกรองส่วนของการตั้งค่าแบบมีคำแนะนำที่ใช้ซ้ำได้ เมื่อคุณเรียก `openclaw config` โดยไม่ระบุคำสั่งย่อย
ส่วนที่รองรับในการตั้งค่าแบบมีคำแนะนำ:
- `workspace`
- `model`
- `web`
- `gateway`
- `daemon`
- `channels`
- `plugins`
- `skills`
- `health`
## ตัวอย่าง
```bash
openclaw config file
openclaw config --section model
openclaw config --section gateway --section daemon
openclaw config schema
openclaw config get browser.executablePath
openclaw config set browser.executablePath "/usr/bin/google-chrome"
openclaw config set agents.defaults.heartbeat.every "2h"
openclaw config set agents.list[0].tools.exec.node "node-id-or-name"
openclaw config set agents.defaults.models '{"openai-codex/gpt-5.4":{}}' --strict-json --merge
openclaw config set channels.discord.token --ref-provider default --ref-source env --ref-id DISCORD_BOT_TOKEN
openclaw config set secrets.providers.vaultfile --provider-source file --provider-path /etc/openclaw/secrets.json --provider-mode json
openclaw config unset plugins.entries.brave.config.webSearch.apiKey
openclaw config set channels.discord.token --ref-provider default --ref-source env --ref-id DISCORD_BOT_TOKEN --dry-run
openclaw config validate
openclaw config validate --json
```
### `config schema`
พิมพ์ JSON schema ที่สร้างขึ้นสำหรับ `openclaw.json` ไปยัง stdout ในรูปแบบ JSON
สิ่งที่รวมอยู่:
- root config schema ปัจจุบัน พร้อมฟิลด์สตริง root `$schema` สำหรับเครื่องมือของตัวแก้ไข
- เมทาดาต้าเอกสารของฟิลด์ `title` และ `description` ที่ใช้โดย Control UI
- โหนดอ็อบเจ็กต์ที่ซ้อนกัน, wildcard (`*`) และรายการอาร์เรย์ (`[]`) จะสืบทอดเมทาดาต้า `title` / `description` เดียวกันเมื่อมีเอกสารของฟิลด์ที่ตรงกันอยู่
- กิ่ง `anyOf` / `oneOf` / `allOf` ก็จะสืบทอดเมทาดาต้าเอกสารเดียวกันเช่นกันเมื่อมีเอกสารของฟิลด์ที่ตรงกันอยู่
- เมทาดาต้า schema ของ Plugin + channel แบบสดตามความสามารถ เมื่อสามารถโหลด runtime manifest ได้
- schema สำรองที่สะอาด แม้ว่า config ปัจจุบันจะไม่ถูกต้อง
runtime RPC ที่เกี่ยวข้อง:
- `config.schema.lookup` ส่งคืนหนึ่งพาธ config ที่ทำให้เป็นมาตรฐานแล้ว พร้อม
โหนด schema แบบตื้น (`title`, `description`, `type`, `enum`, `const`, ขอบเขตทั่วไป),
เมทาดาต้า UI hint ที่จับคู่แล้ว และสรุปลูกโดยตรง ใช้สิ่งนี้สำหรับ
การเจาะลึกแบบจำกัดตามพาธใน Control UI หรือไคลเอนต์แบบกำหนดเอง
```bash
openclaw config schema
```
ส่งต่อไปยังไฟล์เมื่อคุณต้องการตรวจสอบหรือตรวจสอบความถูกต้องด้วยเครื่องมืออื่น:
```bash
openclaw config schema > openclaw.schema.json
```
### พาธ
พาธใช้รูปแบบ dot หรือ bracket:
```bash
openclaw config get agents.defaults.workspace
openclaw config get agents.list[0].id
```
ใช้ดัชนีของรายการ agent เพื่อกำหนดเป้าหมาย agent ที่ต้องการ:
```bash
openclaw config get agents.list
openclaw config set agents.list[1].tools.exec.node "node-id-or-name"
```
## ค่า
ค่าจะถูกแยกวิเคราะห์เป็น JSON5 เมื่อทำได้ มิฉะนั้นจะถือว่าเป็นสตริง
ใช้ `--strict-json` เพื่อบังคับให้แยกวิเคราะห์เป็น JSON5 `--json` ยังคงรองรับเป็นนามแฝงแบบเดิม
```bash
openclaw config set agents.defaults.heartbeat.every "0m"
openclaw config set gateway.port 19001 --strict-json
openclaw config set channels.whatsapp.groups '["*"]' --strict-json
```
`config get <path> --json` จะพิมพ์ค่าดิบเป็น JSON แทนข้อความที่จัดรูปแบบสำหรับเทอร์มินัล
การกำหนดค่าให้กับอ็อบเจ็กต์จะเขียนทับพาธเป้าหมายโดยค่าเริ่มต้น พาธ map/list ที่ได้รับการปกป้อง
ซึ่งมักเก็บรายการที่ผู้ใช้เพิ่มเข้าไป เช่น `agents.defaults.models`,
`models.providers`, `models.providers.<id>.models`, `plugins.entries` และ
`auth.profiles` จะปฏิเสธการแทนที่ที่อาจลบรายการเดิม เว้นแต่
คุณจะส่ง `--replace`
ใช้ `--merge` เมื่อเพิ่มรายการลงใน map เหล่านั้น:
```bash
openclaw config set agents.defaults.models '{"openai-codex/gpt-5.4":{}}' --strict-json --merge
openclaw config set models.providers.ollama.models '[{"id":"llama3.2","name":"Llama 3.2"}]' --strict-json --merge
```
ใช้ `--replace` เฉพาะเมื่อคุณตั้งใจให้ค่าที่ระบุมากลายเป็น
ค่าเป้าหมายทั้งหมดเท่านั้น
## โหมดของ `config set`
`openclaw config set` รองรับรูปแบบการกำหนดค่า 4 แบบ:
1. โหมดค่า: `openclaw config set <path> <value>`
2. โหมดตัวสร้าง SecretRef:
```bash
openclaw config set channels.discord.token \
--ref-provider default \
--ref-source env \
--ref-id DISCORD_BOT_TOKEN
```
3. โหมดตัวสร้าง provider (เฉพาะพาธ `secrets.providers.<alias>`):
```bash
openclaw config set secrets.providers.vault \
--provider-source exec \
--provider-command /usr/local/bin/openclaw-vault \
--provider-arg read \
--provider-arg openai/api-key \
--provider-timeout-ms 5000
```
4. โหมดแบตช์ (`--batch-json` หรือ `--batch-file`):
```bash
openclaw config set --batch-json '[
{
"path": "secrets.providers.default",
"provider": { "source": "env" }
},
{
"path": "channels.discord.token",
"ref": { "source": "env", "provider": "default", "id": "DISCORD_BOT_TOKEN" }
}
]'
```
```bash
openclaw config set --batch-file ./config-set.batch.json --dry-run
```
หมายเหตุนโยบาย:
- การกำหนดค่า SecretRef จะถูกปฏิเสธบนพื้นผิวที่ runtime เปลี่ยนค่าได้ซึ่งไม่รองรับ (ตัวอย่างเช่น `hooks.token`, `commands.ownerDisplaySecret`, โทเค็น Webhook สำหรับการ bind thread ของ Discord และ WhatsApp creds JSON) ดู [SecretRef Credential Surface](/th/reference/secretref-credential-surface)
การแยกวิเคราะห์แบบแบตช์จะใช้เพย์โหลดแบตช์ (`--batch-json`/`--batch-file`) เป็นแหล่งความจริงเสมอ
`--strict-json` / `--json` ไม่เปลี่ยนพฤติกรรมการแยกวิเคราะห์แบบแบตช์
โหมดพาธ/ค่าแบบ JSON ยังคงรองรับทั้งสำหรับ SecretRef และ provider:
```bash
openclaw config set channels.discord.token \
'{"source":"env","provider":"default","id":"DISCORD_BOT_TOKEN"}' \
--strict-json
openclaw config set secrets.providers.vaultfile \
'{"source":"file","path":"/etc/openclaw/secrets.json","mode":"json"}' \
--strict-json
```
## แฟล็กตัวสร้าง Provider
เป้าหมายของตัวสร้าง provider ต้องใช้ `secrets.providers.<alias>` เป็นพาธ
แฟล็กทั่วไป:
- `--provider-source <env|file|exec>`
- `--provider-timeout-ms <ms>` (`file`, `exec`)
Env provider (`--provider-source env`):
- `--provider-allowlist <ENV_VAR>` (ใช้ซ้ำได้)
File provider (`--provider-source file`):
- `--provider-path <path>` (จำเป็น)
- `--provider-mode <singleValue|json>`
- `--provider-max-bytes <bytes>`
Exec provider (`--provider-source exec`):
- `--provider-command <path>` (จำเป็น)
- `--provider-arg <arg>` (ใช้ซ้ำได้)
- `--provider-no-output-timeout-ms <ms>`
- `--provider-max-output-bytes <bytes>`
- `--provider-json-only`
- `--provider-env <KEY=VALUE>` (ใช้ซ้ำได้)
- `--provider-pass-env <ENV_VAR>` (ใช้ซ้ำได้)
- `--provider-trusted-dir <path>` (ใช้ซ้ำได้)
- `--provider-allow-insecure-path`
- `--provider-allow-symlink-command`
ตัวอย่าง exec provider แบบเสริมความปลอดภัย:
```bash
openclaw config set secrets.providers.vault \
--provider-source exec \
--provider-command /usr/local/bin/openclaw-vault \
--provider-arg read \
--provider-arg openai/api-key \
--provider-json-only \
--provider-pass-env VAULT_TOKEN \
--provider-trusted-dir /usr/local/bin \
--provider-timeout-ms 5000
```
## Dry run
ใช้ `--dry-run` เพื่อตรวจสอบความถูกต้องของการเปลี่ยนแปลงโดยไม่เขียน `openclaw.json`
```bash
openclaw config set channels.discord.token \
--ref-provider default \
--ref-source env \
--ref-id DISCORD_BOT_TOKEN \
--dry-run
openclaw config set channels.discord.token \
--ref-provider default \
--ref-source env \
--ref-id DISCORD_BOT_TOKEN \
--dry-run \
--json
openclaw config set channels.discord.token \
--ref-provider vault \
--ref-source exec \
--ref-id discord/token \
--dry-run \
--allow-exec
```
พฤติกรรมของ dry-run:
- โหมดตัวสร้าง: รันการตรวจสอบความสามารถในการ resolve ของ SecretRef สำหรับ ref/provider ที่เปลี่ยนแปลง
- โหมด JSON (`--strict-json`, `--json` หรือโหมดแบตช์): รันการตรวจสอบ schema พร้อมการตรวจสอบความสามารถในการ resolve ของ SecretRef
- การตรวจสอบนโยบายจะทำงานด้วยสำหรับพื้นผิวเป้าหมาย SecretRef ที่ไม่รองรับซึ่งรู้จักอยู่แล้ว
- การตรวจสอบนโยบายจะประเมิน config ทั้งหมดหลังการเปลี่ยนแปลง ดังนั้นการเขียน parent-object (เช่น การตั้งค่า `hooks` เป็นอ็อบเจ็กต์) จึงไม่สามารถข้ามการตรวจสอบพื้นผิวที่ไม่รองรับได้
- การตรวจสอบ SecretRef แบบ exec จะถูกข้ามโดยค่าเริ่มต้นระหว่าง dry-run เพื่อหลีกเลี่ยงผลข้างเคียงจากคำสั่ง
- ใช้ `--allow-exec` ร่วมกับ `--dry-run` เพื่อเลือกเปิดใช้การตรวจสอบ SecretRef แบบ exec (การทำเช่นนี้อาจรันคำสั่งของ provider)
- `--allow-exec` ใช้ได้เฉพาะกับ dry-run และจะเกิดข้อผิดพลาดหากใช้โดยไม่มี `--dry-run`
`--dry-run --json` จะพิมพ์รายงานที่เครื่องอ่านได้:
- `ok`: dry-run ผ่านหรือไม่
- `operations`: จำนวนการกำหนดค่าที่ถูกประเมิน
- `checks`: การตรวจสอบ schema/ความสามารถในการ resolve ได้รันหรือไม่
- `checks.resolvabilityComplete`: การตรวจสอบความสามารถในการ resolve รันจนเสร็จสมบูรณ์หรือไม่ (`false` เมื่อมีการข้าม exec refs)
- `refsChecked`: จำนวน ref ที่ถูก resolve จริงระหว่าง dry-run
- `skippedExecRefs`: จำนวน exec ref ที่ถูกข้ามเพราะไม่ได้ตั้ง `--allow-exec`
- `errors`: ความล้มเหลวของ schema/ความสามารถในการ resolve แบบมีโครงสร้างเมื่อ `ok=false`
### รูปร่างเอาต์พุต JSON
```json5
{
ok: boolean,
operations: number,
configPath: string,
inputModes: ["value" | "json" | "builder", ...],
checks: {
schema: boolean,
resolvability: boolean,
resolvabilityComplete: boolean,
},
refsChecked: number,
skippedExecRefs: number,
errors?: [
{
kind: "schema" | "resolvability",
message: string,
ref?: string, // มีอยู่สำหรับข้อผิดพลาดด้านความสามารถในการ resolve
},
],
}
```
ตัวอย่างความสำเร็จ:
```json
{
"ok": true,
"operations": 1,
"configPath": "~/.openclaw/openclaw.json",
"inputModes": ["builder"],
"checks": {
"schema": false,
"resolvability": true,
"resolvabilityComplete": true
},
"refsChecked": 1,
"skippedExecRefs": 0
}
```
ตัวอย่างความล้มเหลว:
```json
{
"ok": false,
"operations": 1,
"configPath": "~/.openclaw/openclaw.json",
"inputModes": ["builder"],
"checks": {
"schema": false,
"resolvability": true,
"resolvabilityComplete": true
},
"refsChecked": 1,
"skippedExecRefs": 0,
"errors": [
{
"kind": "resolvability",
"message": "Error: Environment variable \"MISSING_TEST_SECRET\" is not set.",
"ref": "env:default:MISSING_TEST_SECRET"
}
]
}
```
หาก dry-run ล้มเหลว:
- `config schema validation failed`: รูปร่าง config หลังการเปลี่ยนแปลงของคุณไม่ถูกต้อง; แก้ไขพาธ/ค่าหรือรูปร่างของอ็อบเจ็กต์ provider/ref
- `Config policy validation failed: unsupported SecretRef usage`: ย้าย credential นั้นกลับไปใช้ข้อมูลนำเข้าแบบ plaintext/string และเก็บ SecretRef ไว้เฉพาะบนพื้นผิวที่รองรับเท่านั้น
- `SecretRef assignment(s) could not be resolved`: provider/ref ที่อ้างอิงอยู่ไม่สามารถ resolve ได้ในขณะนี้ (ไม่มีตัวแปร env, file pointer ไม่ถูกต้อง, exec provider ล้มเหลว หรือ provider/source ไม่ตรงกัน)
- `Dry run note: skipped <n> exec SecretRef resolvability check(s)`: dry-run ข้าม exec ref; เรียกใหม่ด้วย `--allow-exec` หากคุณต้องการตรวจสอบความสามารถในการ resolve ของ exec
- สำหรับโหมดแบตช์ ให้แก้ไขรายการที่ล้มเหลวแล้วรัน `--dry-run` ใหม่ก่อนเขียน
## ความปลอดภัยในการเขียน
`openclaw config set` และตัวเขียน config อื่นที่ OpenClaw เป็นเจ้าของ จะตรวจสอบ config ทั้งหมด
หลังการเปลี่ยนแปลงก่อนยืนยันเขียนลงดิสก์ หากเพย์โหลดใหม่ไม่ผ่านการตรวจสอบ schema
หรือดูเหมือนเป็นการเขียนทับแบบทำลายข้อมูล config ที่ใช้งานอยู่จะคงเดิม
และเพย์โหลดที่ถูกปฏิเสธจะถูกบันทึกไว้ข้างกันเป็น `openclaw.json.rejected.*`
พาธ config ที่ใช้งานอยู่ต้องเป็นไฟล์ปกติ เลย์เอาต์ `openclaw.json`
แบบ symlink ไม่รองรับสำหรับการเขียน; ให้ใช้ `OPENCLAW_CONFIG_PATH` เพื่อชี้ตรง
ไปยังไฟล์จริงแทน
ควรใช้การเขียนผ่าน CLI สำหรับการแก้ไขเล็กน้อย:
```bash
openclaw config set gateway.reload.mode hybrid --dry-run
openclaw config set gateway.reload.mode hybrid
openclaw config validate
```
หากการเขียนถูกปฏิเสธ ให้ตรวจสอบเพย์โหลดที่บันทึกไว้และแก้ไขรูปร่าง config ทั้งหมด:
```bash
CONFIG="$(openclaw config file)"
ls -lt "$CONFIG".rejected.* 2>/dev/null | head
openclaw config validate
```
การเขียนโดยตรงผ่านตัวแก้ไขยังคงทำได้ แต่ Gateway ที่กำลังรันอยู่จะถือว่า
การเปลี่ยนแปลงเหล่านั้นไม่น่าเชื่อถือจนกว่าจะผ่านการตรวจสอบ การแก้ไขโดยตรงที่ไม่ถูกต้องสามารถกู้คืนได้จาก
ข้อมูลสำรองสถานะล่าสุดที่ถูกต้องระหว่างการเริ่มต้นหรือ hot reload ดู
[การแก้ไขปัญหา Gateway](/th/gateway/troubleshooting#gateway-restored-last-known-good-config)
## คำสั่งย่อย
- `config file`: พิมพ์พาธไฟล์ config ที่กำลังใช้งานอยู่ (resolve จาก `OPENCLAW_CONFIG_PATH` หรือตำแหน่งค่าเริ่มต้น) พาธควรระบุเป็นไฟล์ปกติ ไม่ใช่ symlink
รีสตาร์ต gateway หลังจากแก้ไข
## ตรวจสอบความถูกต้อง
ตรวจสอบ config ปัจจุบันกับ schema ที่กำลังใช้งานอยู่โดยไม่ต้องเริ่ม
gateway
```bash
openclaw config validate
openclaw config validate --json
```
หลังจาก `openclaw config validate` ผ่านแล้ว คุณสามารถใช้ TUI ในเครื่องเพื่อให้
agent แบบฝังตัวเปรียบเทียบ config ที่กำลังใช้งานอยู่กับเอกสาร ขณะที่คุณตรวจสอบ
แต่ละการเปลี่ยนแปลงจากเทอร์มินัลเดียวกันได้:
หากการตรวจสอบล้มเหลวอยู่แล้ว ให้เริ่มด้วย `openclaw configure` หรือ
`openclaw doctor --fix` `openclaw chat` ไม่ได้ข้าม
ตัวป้องกัน config ที่ไม่ถูกต้อง
```bash
openclaw chat
```
จากนั้นภายใน TUI:
```text
!openclaw config file
!openclaw docs gateway auth token secretref
!openclaw config validate
!openclaw doctor
```
ลูปการซ่อมแซมทั่วไป:
- ขอให้ agent เปรียบเทียบ config ปัจจุบันของคุณกับหน้าเอกสารที่เกี่ยวข้อง และแนะนำวิธีแก้ไขที่เล็กที่สุด
- ใช้การแก้ไขแบบเจาะจงด้วย `openclaw config set` หรือ `openclaw configure`
- เรียก `openclaw config validate` ใหม่หลังการเปลี่ยนแปลงแต่ละครั้ง
- หากการตรวจสอบผ่านแล้วแต่ runtime ยังไม่สมบูรณ์ ให้รัน `openclaw doctor` หรือ `openclaw doctor --fix` เพื่อขอความช่วยเหลือด้านการย้ายและการซ่อมแซม

79
docs/th/cli/configure.md Normal file
View File

@ -0,0 +1,79 @@
---
read_when:
- คุณต้องการปรับข้อมูลรับรอง อุปกรณ์ หรือค่าเริ่มต้นของเอเจนต์แบบโต้ตอบ
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw configure` (พร้อมท์การกำหนดค่าแบบโต้ตอบ)
title: กำหนดค่า
x-i18n:
generated_at: "2026-04-23T06:17:18Z"
model: gpt-5.4
provider: openai
source_hash: 7fedaf1bc5e5c793ed354ff01294808f9b4a266219f8e07799a2545fe5652cf2
source_path: cli/configure.md
workflow: 15
---
# `openclaw configure`
พร้อมท์แบบโต้ตอบสำหรับตั้งค่าข้อมูลรับรอง อุปกรณ์ และค่าเริ่มต้นของเอเจนต์
หมายเหตุ: ส่วน **Model** ตอนนี้มีการเลือกได้หลายรายการสำหรับ allowlist ของ
`agents.defaults.models` (สิ่งที่จะแสดงใน `/model` และตัวเลือกโมเดล)
ตัวเลือกการตั้งค่าระดับ provider จะรวมโมเดลที่เลือกเข้าไปใน
allowlist ที่มีอยู่แทนที่จะไปแทนที่ provider อื่นที่ไม่เกี่ยวข้องซึ่งมีอยู่แล้วใน config
เมื่อเริ่ม configure จากตัวเลือกการยืนยันตัวตนของ provider ตัวเลือกโมเดลเริ่มต้นและ
allowlist จะให้ความสำคัญกับ provider นั้นโดยอัตโนมัติ สำหรับ provider แบบจับคู่
เช่น Volcengine/BytePlus การให้ความสำคัญแบบเดียวกันนี้จะตรงกับ
รูปแบบ coding-plan ของพวกเขาด้วย (`volcengine-plan/*`, `byteplus-plan/*`) หากตัวกรอง
preferred-provider ทำให้รายการว่าง configure จะ fallback ไปใช้แค็ตตาล็อก
ที่ไม่กรองแทนที่จะแสดงตัวเลือกว่างเปล่า
เคล็ดลับ: `openclaw config` โดยไม่มีคำสั่งย่อยจะเปิดวิซาร์ดเดียวกัน ใช้
`openclaw config get|set|unset` สำหรับการแก้ไขแบบไม่โต้ตอบ
สำหรับการค้นหาบนเว็บ `openclaw configure --section web` ให้คุณเลือก provider
และกำหนดค่าข้อมูลรับรองของมันได้ บาง provider ยังแสดงพร้อมท์ติดตามผล
เฉพาะของ provider ด้วย:
- **Grok** สามารถเสนอการตั้งค่า `x_search` แบบเลือกได้โดยใช้ `XAI_API_KEY` เดียวกัน และ
ให้คุณเลือกโมเดล `x_search`
- **Kimi** อาจถามหารีเจียน API ของ Moonshot (`api.moonshot.ai` เทียบกับ
`api.moonshot.cn`) และโมเดลค้นหาเว็บ Kimi เริ่มต้น
ที่เกี่ยวข้อง:
- ข้อมูลอ้างอิงการกำหนดค่า Gateway: [Configuration](/th/gateway/configuration)
- Config CLI: [Config](/th/cli/config)
## ตัวเลือก
- `--section <section>`: ตัวกรอง section ที่ระบุซ้ำได้
sections ที่มีให้ใช้:
- `workspace`
- `model`
- `web`
- `gateway`
- `daemon`
- `channels`
- `plugins`
- `skills`
- `health`
หมายเหตุ:
- การเลือกว่าจะให้ Gateway รันที่ไหนจะอัปเดต `gateway.mode` เสมอ คุณสามารถเลือก "Continue" โดยไม่ต้องเลือกส่วนอื่นได้ หากคุณต้องการเพียงเท่านั้น
- บริการที่เน้นช่องทาง (Slack/Discord/Matrix/Microsoft Teams) จะมีพร้อมท์สำหรับ allowlist ของ channel/room ระหว่างการตั้งค่า คุณสามารถป้อนชื่อหรือ ID ได้; วิซาร์ดจะ resolve ชื่อเป็น ID เมื่อทำได้
- หากคุณรันขั้นตอนติดตั้ง daemon การยืนยันตัวตนด้วย token จำเป็นต้องมี token และเมื่อ `gateway.auth.token` ถูกจัดการด้วย SecretRef configure จะตรวจสอบ SecretRef แต่จะไม่บันทึกค่า token plaintext ที่ resolve แล้วลงใน metadata environment ของบริการ supervisor
- หากการยืนยันตัวตนด้วย token ต้องใช้ token และ token SecretRef ที่ตั้งค่าไว้ยัง resolve ไม่ได้ configure จะบล็อกการติดตั้ง daemon พร้อมคำแนะนำการแก้ไขที่นำไปใช้ได้
- หากมีการตั้งค่าทั้ง `gateway.auth.token` และ `gateway.auth.password` และ `gateway.auth.mode` ยังไม่ได้ตั้งค่า configure จะบล็อกการติดตั้ง daemon จนกว่าจะตั้งค่าโหมดอย่างชัดเจน
## ตัวอย่าง
```bash
openclaw configure
openclaw configure --section web
openclaw configure --section model --section channels
openclaw configure --section gateway --section daemon
```

181
docs/th/cli/cron.md Normal file
View File

@ -0,0 +1,181 @@
---
read_when:
- คุณต้องการงานที่กำหนดเวลาไว้และการปลุกการทำงาน
- คุณกำลังดีบักการทำงานและบันทึกของ Cron
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw cron` (กำหนดเวลาและเรียกใช้งานงานเบื้องหลัง)
title: Cron
x-i18n:
generated_at: "2026-04-23T06:17:44Z"
model: gpt-5.4
provider: openai
source_hash: f5216f220748b05df5202af778878b37148d6abe235be9fe82ddcf976d51532a
source_path: cli/cron.md
workflow: 15
---
# `openclaw cron`
จัดการงาน Cron สำหรับตัวจัดตารางเวลาของ Gateway
ที่เกี่ยวข้อง:
- งาน Cron: [งาน Cron](/th/automation/cron-jobs)
เคล็ดลับ: รัน `openclaw cron --help` เพื่อดูชุดคำสั่งทั้งหมด
หมายเหตุ: `openclaw cron list` และ `openclaw cron show <job-id>` จะแสดงตัวอย่าง
เส้นทางการส่งที่ resolve แล้ว สำหรับ `channel: "last"` ตัวอย่างจะแสดงว่า
เส้นทางนั้น resolve จากเซสชัน main/current หรือจะล้มเหลวแบบปิด
หมายเหตุ: งาน `cron add` แบบ isolated จะใช้การส่งแบบ `--announce` เป็นค่าเริ่มต้น ใช้ `--no-deliver` เพื่อเก็บ
เอาต์พุตไว้ภายใน `--deliver` ยังคงมีอยู่ในฐานะ alias ที่เลิกใช้งานแล้วสำหรับ `--announce`
หมายเหตุ: การส่งแชตของ cron แบบ isolated ใช้ร่วมกัน `--announce` คือการส่งสำรองของตัวรัน
สำหรับคำตอบสุดท้าย ส่วน `--no-deliver` จะปิดการส่งสำรองนั้น แต่
ไม่ได้ลบเครื่องมือ `message` ของเอเจนต์เมื่อมีเส้นทางแชตพร้อมใช้งาน
หมายเหตุ: งานแบบครั้งเดียว (`--at`) จะถูกลบหลังจากสำเร็จตามค่าเริ่มต้น ใช้ `--keep-after-run` เพื่อเก็บไว้
หมายเหตุ: `--session` รองรับ `main`, `isolated`, `current` และ `session:<id>`
ใช้ `current` เพื่อผูกกับเซสชันที่ใช้งานอยู่ ณ เวลาสร้าง หรือใช้ `session:<id>` สำหรับ
คีย์เซสชันถาวรแบบระบุชัดเจน
หมายเหตุ: สำหรับงาน CLI แบบครั้งเดียว ค่าวันที่เวลา `--at` ที่ไม่มี offset จะถือเป็น UTC เว้นแต่คุณจะส่ง
`--tz <iana>` ด้วย ซึ่งจะตีความเวลาท้องถิ่นนั้นตามเขตเวลาที่ระบุ
หมายเหตุ: งานที่เกิดซ้ำตอนนี้ใช้การหน่วงเวลาก่อนลองใหม่แบบเอ็กซ์โปเนนเชียลหลังเกิดข้อผิดพลาดต่อเนื่อง (30 วินาที → 1 นาที → 5 นาที → 15 นาที → 60 นาที) แล้วจึงกลับสู่ตารางเวลาปกติหลังจากรันสำเร็จครั้งถัดไป
หมายเหตุ: ตอนนี้ `openclaw cron run` จะคืนค่าทันทีที่จัดคิวการรันด้วยตนเองเพื่อดำเนินการแล้ว การตอบกลับที่สำเร็จจะมี `{ ok: true, enqueued: true, runId }`; ใช้ `openclaw cron runs --id <job-id>` เพื่อติดตามผลลัพธ์ในภายหลัง
หมายเหตุ: `openclaw cron run <job-id>` จะบังคับรันตามค่าเริ่มต้น ใช้ `--due` เพื่อคง
พฤติกรรมเดิมแบบ "รันเฉพาะเมื่อถึงกำหนด"
หมายเหตุ: การรัน cron แบบ isolated จะระงับการตอบกลับแบบยืนยันอย่างเดียวที่ล้าสมัย หาก
ผลลัพธ์แรกเป็นเพียงการอัปเดตสถานะชั่วคราว และไม่มีการรัน subagent ลูกหลานใด
รับผิดชอบต่อคำตอบสุดท้าย cron จะ prompt ใหม่หนึ่งครั้งสำหรับผลลัพธ์จริงก่อนส่ง
หมายเหตุ: หากการรัน cron แบบ isolated ส่งกลับมาเพียงโทเค็นแบบเงียบ (`NO_REPLY` /
`no_reply`) cron จะระงับทั้งการส่งออกโดยตรงและเส้นทางสรุปแบบเข้าคิวสำรอง
ดังนั้นจะไม่มีการโพสต์อะไรกลับไปยังแชต
หมายเหตุ: `cron add|edit --model ...` จะใช้โมเดลที่อนุญาตที่เลือกนั้นสำหรับงาน
หากโมเดลไม่ได้รับอนุญาต cron จะเตือนและย้อนกลับไปใช้การเลือกโมเดล
ของเอเจนต์/ค่าเริ่มต้นของงานแทน ห่วงโซ่ fallback ที่กำหนดค่าไว้ยังคงมีผล แต่การ override
โมเดลแบบธรรมดาโดยไม่มีรายการ fallback ต่อหนึ่งงานแบบระบุชัดเจน จะไม่ต่อท้าย
โมเดลหลักของเอเจนต์เป็นเป้าหมายลองใหม่แบบซ่อนอยู่อีกตัวหนึ่งอีกต่อไป
หมายเหตุ: ลำดับความสำคัญของโมเดล cron แบบ isolated คือ override ของ Gmail-hook ก่อน จากนั้นเป็น
`--model` ต่อหนึ่งงาน จากนั้นเป็น override โมเดลของ cron-session ที่จัดเก็บไว้ แล้วจึงเป็นการเลือก
เอเจนต์/ค่าเริ่มต้นตามปกติ
หมายเหตุ: โหมดเร็วของ cron แบบ isolated จะทำตามการเลือกโมเดล live ที่ resolve แล้ว
`params.fastMode` ใน config ของโมเดลจะมีผลตามค่าเริ่มต้น แต่ override `fastMode`
ของเซสชันที่จัดเก็บไว้จะยังมีความสำคัญเหนือกว่า config
หมายเหตุ: หากการรันแบบ isolated โยน `LiveSessionModelSwitchError` cron จะคงค่า
provider/model ที่สลับแล้วไว้ (รวมถึง override โปรไฟล์การยืนยันตัวตนที่สลับแล้วเมื่อมี) ก่อน
ลองใหม่ ลูปการลองใหม่ชั้นนอกถูกจำกัดไว้ที่การลองใหม่จากการสลับ 2 ครั้งหลังความพยายาม
ครั้งแรก จากนั้นจะยุติแทนที่จะวนลูปไม่สิ้นสุด
หมายเหตุ: การแจ้งเตือนความล้มเหลวจะใช้ `delivery.failureDestination` ก่อน จากนั้น
`cron.failureDestination` แบบ global และสุดท้ายจะย้อนกลับไปใช้เป้าหมาย announce หลัก
ของงานเมื่อไม่ได้กำหนดปลายทางสำหรับความล้มเหลวไว้อย่างชัดเจน
หมายเหตุ: การเก็บรักษา/การล้างข้อมูลส่วนเกินควบคุมใน config:
- `cron.sessionRetention` (ค่าเริ่มต้น `24h`) จะล้างเซสชันการรัน isolated ที่เสร็จสมบูรณ์
- `cron.runLog.maxBytes` + `cron.runLog.keepLines` จะล้าง `~/.openclaw/cron/runs/<jobId>.jsonl`
หมายเหตุการอัปเกรด: หากคุณมีงาน cron เก่าจากก่อนรูปแบบการส่ง/การจัดเก็บปัจจุบัน ให้รัน
`openclaw doctor --fix` ตอนนี้ Doctor จะปรับฟิลด์ cron แบบ legacy (`jobId`, `schedule.cron`,
ฟิลด์การส่งระดับบนสุดรวมถึง `threadId` แบบ legacy, alias การส่ง `provider` ใน payload) ให้เป็นมาตรฐาน และย้ายงาน fallback ของ webhook แบบง่ายที่ใช้
`notify: true` ไปเป็นการส่งผ่าน webhook แบบชัดเจนเมื่อมีการกำหนดค่า `cron.webhook`
## การแก้ไขทั่วไป
อัปเดตการตั้งค่าการส่งโดยไม่เปลี่ยนข้อความ:
```bash
openclaw cron edit <job-id> --announce --channel telegram --to "123456789"
```
ปิดการส่งสำหรับงานแบบ isolated:
```bash
openclaw cron edit <job-id> --no-deliver
```
เปิดใช้บริบท bootstrap แบบน้ำหนักเบาสำหรับงานแบบ isolated:
```bash
openclaw cron edit <job-id> --light-context
```
ประกาศไปยังช่องทางที่ระบุ:
```bash
openclaw cron edit <job-id> --announce --channel slack --to "channel:C1234567890"
```
สร้างงานแบบ isolated พร้อมบริบท bootstrap แบบน้ำหนักเบา:
```bash
openclaw cron add \
--name "Lightweight morning brief" \
--cron "0 7 * * *" \
--session isolated \
--message "Summarize overnight updates." \
--light-context \
--no-deliver
```
`--light-context` ใช้กับงาน agent-turn แบบ isolated เท่านั้น สำหรับการรัน cron โหมดน้ำหนักเบาจะคงบริบท bootstrap ให้เป็นค่าว่างแทนการ inject ชุด bootstrap ของเวิร์กสเปซแบบเต็ม
หมายเหตุเรื่องความเป็นเจ้าของการส่ง:
- การส่งแชตของ cron แบบ isolated ใช้ร่วมกัน เอเจนต์สามารถส่งโดยตรงด้วย
เครื่องมือ `message` เมื่อมีเส้นทางแชตพร้อมใช้งาน
- `announce` จะส่งคำตอบสุดท้ายแบบสำรองเฉพาะเมื่อเอเจนต์ไม่ได้ส่ง
ตรงไปยังเป้าหมายที่ resolve แล้ว `webhook` จะโพสต์เพย์โหลดที่เสร็จแล้วไปยัง URL
ส่วน `none` จะปิดการส่งสำรองของตัวรัน
## คำสั่งผู้ดูแลระบบทั่วไป
การรันด้วยตนเอง:
```bash
openclaw cron list
openclaw cron show <job-id>
openclaw cron run <job-id>
openclaw cron run <job-id> --due
openclaw cron runs --id <job-id> --limit 50
```
รายการ `cron runs` จะรวมข้อมูลวินิจฉัยการส่ง โดยมีเป้าหมาย cron ที่ตั้งใจไว้
เป้าหมายที่ resolve แล้ว การส่งผ่านเครื่องมือข้อความ การใช้ fallback และสถานะการส่งสำเร็จ
การเปลี่ยนเป้าหมายเอเจนต์/เซสชัน:
```bash
openclaw cron edit <job-id> --agent ops
openclaw cron edit <job-id> --clear-agent
openclaw cron edit <job-id> --session current
openclaw cron edit <job-id> --session "session:daily-brief"
```
การปรับแต่งการส่ง:
```bash
openclaw cron edit <job-id> --announce --channel slack --to "channel:C1234567890"
openclaw cron edit <job-id> --best-effort-deliver
openclaw cron edit <job-id> --no-best-effort-deliver
openclaw cron edit <job-id> --no-deliver
```
หมายเหตุเกี่ยวกับการส่งเมื่อเกิดความล้มเหลว:
- รองรับ `delivery.failureDestination` สำหรับงานแบบ isolated
- งานเซสชัน main สามารถใช้ `delivery.failureDestination` ได้เฉพาะเมื่อ
โหมดการส่งหลักคือ `webhook`
- หากคุณไม่ได้ตั้งค่าปลายทางความล้มเหลวไว้เลย และงานนั้นประกาศไปยัง
ช่องทางอยู่แล้ว การแจ้งเตือนความล้มเหลวจะใช้เป้าหมาย announce เดิมนั้นซ้ำ

64
docs/th/cli/daemon.md Normal file
View File

@ -0,0 +1,64 @@
---
read_when:
- คุณยังคงใช้ `openclaw daemon ...` ในสคริปต์อยู่
- คุณต้องใช้คำสั่งวงจรชีวิตของบริการ (install/start/stop/restart/status)
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw daemon` (ชื่อเรียกแทนแบบดั้งเดิมสำหรับการจัดการบริการ Gateway)
title: ดีมอน
x-i18n:
generated_at: "2026-04-23T06:17:34Z"
model: gpt-5.4
provider: openai
source_hash: 91fdaf3c4f3e7dd4dff86f9b74a653dcba2674573698cf51efc4890077994169
source_path: cli/daemon.md
workflow: 15
---
# `openclaw daemon`
ชื่อเรียกแทนแบบดั้งเดิมสำหรับคำสั่งจัดการบริการ Gateway
`openclaw daemon ...` จะจับคู่ไปยังพื้นผิวการควบคุมบริการเดียวกันกับคำสั่งบริการ `openclaw gateway ...`
## การใช้งาน
```bash
openclaw daemon status
openclaw daemon install
openclaw daemon start
openclaw daemon stop
openclaw daemon restart
openclaw daemon uninstall
```
## คำสั่งย่อย
- `status`: แสดงสถานะการติดตั้งบริการและตรวจสอบสถานะสุขภาพของ Gateway
- `install`: ติดตั้งบริการ (`launchd`/`systemd`/`schtasks`)
- `uninstall`: ลบบริการ
- `start`: เริ่มบริการ
- `stop`: หยุดบริการ
- `restart`: เริ่มบริการใหม่
## ตัวเลือกทั่วไป
- `status`: `--url`, `--token`, `--password`, `--timeout`, `--no-probe`, `--require-rpc`, `--deep`, `--json`
- `install`: `--port`, `--runtime <node|bun>`, `--token`, `--force`, `--json`
- วงจรชีวิต (`uninstall|start|stop|restart`): `--json`
หมายเหตุ:
- `status` จะ resolve auth SecretRefs ที่ตั้งค่าไว้สำหรับการยืนยันตัวตนของ probe เมื่อทำได้
- หาก SecretRef สำหรับการยืนยันตัวตนที่จำเป็นยังไม่ถูก resolve ในเส้นทางคำสั่งนี้ `daemon status --json` จะรายงาน `rpc.authWarning` เมื่อ probe เชื่อมต่อไม่ได้หรือการยืนยันตัวตนล้มเหลว ให้ส่ง `--token`/`--password` โดยตรงหรือ resolve แหล่งที่มาของ secret ก่อน
- หาก probe สำเร็จ คำเตือน unresolved auth-ref จะถูกระงับเพื่อหลีกเลี่ยง false positives
- `status --deep` จะเพิ่มการสแกนบริการระดับระบบแบบ best-effort เมื่อพบบริการอื่นที่คล้าย gateway เอาต์พุตสำหรับมนุษย์จะพิมพ์คำแนะนำในการ cleanup และเตือนว่าการมี gateway หนึ่งตัวต่อเครื่องยังคงเป็นคำแนะนำตามปกติ
- ในการติดตั้ง Linux systemd การตรวจสอบ token drift ของ `status` จะรวมทั้งแหล่ง unit แบบ `Environment=` และ `EnvironmentFile=`
- การตรวจสอบ drift จะ resolve SecretRefs ของ `gateway.auth.token` โดยใช้ merged runtime env (env ของคำสั่งบริการก่อน แล้วจึง fallback ไปยัง process env)
- หาก token auth ไม่ได้เปิดใช้งานอย่างมีผลจริง (มีการตั้งค่า `gateway.auth.mode` เป็น `password`/`none`/`trusted-proxy` อย่างชัดเจน หรือไม่ได้ตั้งค่า mode ไว้ในกรณีที่ password อาจมีผล และไม่มี token candidate ที่ใช้ได้) การตรวจสอบ token drift จะข้ามการ resolve token จาก config
- เมื่อ token auth ต้องใช้ token และ `gateway.auth.token` ถูกจัดการด้วย SecretRef, `install` จะตรวจสอบว่า SecretRef สามารถ resolve ได้ แต่จะไม่บันทึก token ที่ resolve แล้วลงใน metadata ของ environment ของบริการ
- หาก token auth ต้องใช้ token และ token SecretRef ที่ตั้งค่าไว้ยังไม่สามารถ resolve ได้ การติดตั้งจะล้มเหลวแบบ fail closed
- หากมีการตั้งค่าทั้ง `gateway.auth.token` และ `gateway.auth.password` และไม่ได้ตั้งค่า `gateway.auth.mode` ไว้ `install` จะถูกบล็อกจนกว่าจะตั้งค่า mode อย่างชัดเจน
- หากคุณตั้งใจรันหลาย gateway บนโฮสต์เดียวกัน ให้แยกพอร์ต, config/state และ workspaces ออกจากกัน ดู [/gateway#multiple-gateways-same-host](/th/gateway#multiple-gateways-same-host)
## ควรใช้
ใช้ [`openclaw gateway`](/th/cli/gateway) สำหรับเอกสารและตัวอย่างปัจจุบัน

29
docs/th/cli/dashboard.md Normal file
View File

@ -0,0 +1,29 @@
---
read_when:
- คุณต้องการเปิด Control UI ด้วยโทเค็นปัจจุบันของคุณ
- คุณต้องการพิมพ์ URL โดยไม่เปิดเบราว์เซอร์
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw dashboard` (เปิด Control UI)
title: แดชบอร์ด
x-i18n:
generated_at: "2026-04-23T06:17:34Z"
model: gpt-5.4
provider: openai
source_hash: a34cd109a3803e2910fcb4d32f2588aa205a4933819829ef5598f0780f586c94
source_path: cli/dashboard.md
workflow: 15
---
# `openclaw dashboard`
เปิด Control UI โดยใช้การยืนยันตัวตนปัจจุบันของคุณ
```bash
openclaw dashboard
openclaw dashboard --no-open
```
หมายเหตุ:
- `dashboard` จะ resolve SecretRef ของ `gateway.auth.token` ที่ตั้งค่าไว้เมื่อทำได้
- สำหรับโทเค็นที่จัดการด้วย SecretRef (ทั้งที่ resolve ได้หรือยังไม่ได้) `dashboard` จะพิมพ์/คัดลอก/เปิด URL ที่ไม่มีโทเค็นเพื่อหลีกเลี่ยงการเปิดเผยความลับภายนอกในเอาต์พุตเทอร์มินัล ประวัติคลิปบอร์ด หรืออาร์กิวเมนต์ที่ใช้เปิดเบราว์เซอร์
- หาก `gateway.auth.token` ถูกจัดการด้วย SecretRef แต่ยัง resolve ไม่ได้ในเส้นทางคำสั่งนี้ คำสั่งจะพิมพ์ URL ที่ไม่มีโทเค็นและคำแนะนำการแก้ไขที่ชัดเจน แทนการฝังค่า placeholder ของโทเค็นที่ไม่ถูกต้อง

164
docs/th/cli/devices.md Normal file
View File

@ -0,0 +1,164 @@
---
read_when:
- คุณกำลังอนุมัติคำขอจับคู่อุปกรณ์
- คุณต้องหมุนเวียนหรือเพิกถอนโทเค็นอุปกรณ์
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw devices` (การจับคู่อุปกรณ์ + การหมุนเวียน/เพิกถอนโทเค็น)
title: devices
x-i18n:
generated_at: "2026-04-23T06:17:40Z"
model: gpt-5.4
provider: openai
source_hash: 8e58d2dff7fc22a11ff372f4937907977dab0ffa9f971b9c0bffeb3e347caf66
source_path: cli/devices.md
workflow: 15
---
# `openclaw devices`
จัดการคำขอจับคู่อุปกรณ์และโทเค็นที่มีขอบเขตระดับอุปกรณ์
## คำสั่ง
### `openclaw devices list`
แสดงรายการคำขอจับคู่ที่รอดำเนินการและอุปกรณ์ที่จับคู่แล้ว
```
openclaw devices list
openclaw devices list --json
```
ผลลัพธ์ของคำขอที่รอดำเนินการจะแสดงสิทธิ์การเข้าถึงที่ร้องขอถัดจากสิทธิ์การเข้าถึงปัจจุบันที่อนุมัติแล้วของอุปกรณ์ เมื่ออุปกรณ์นั้นถูกจับคู่อยู่แล้ว ซึ่งทำให้การอัปเกรด scope/role ชัดเจน แทนที่จะดูเหมือนว่าการจับคู่หายไป
### `openclaw devices remove <deviceId>`
ลบรายการอุปกรณ์ที่จับคู่แล้วหนึ่งรายการ
เมื่อคุณยืนยันตัวตนด้วยโทเค็นอุปกรณ์ที่จับคู่แล้ว ผู้เรียกที่ไม่ใช่แอดมินจะลบได้เฉพาะรายการอุปกรณ์ของ **ตนเอง** เท่านั้น การลบอุปกรณ์อื่นต้องใช้ `operator.admin`
```
openclaw devices remove <deviceId>
openclaw devices remove <deviceId> --json
```
### `openclaw devices clear --yes [--pending]`
ล้างอุปกรณ์ที่จับคู่แล้วแบบเป็นกลุ่ม
```
openclaw devices clear --yes
openclaw devices clear --yes --pending
openclaw devices clear --yes --pending --json
```
### `openclaw devices approve [requestId] [--latest]`
อนุมัติคำขอจับคู่อุปกรณ์ที่รอดำเนินการด้วย `requestId` ที่ตรงกันแบบเป๊ะ หากละเว้น `requestId` หรือส่ง `--latest`, OpenClaw จะพิมพ์เฉพาะคำขอที่รอดำเนินการซึ่งถูกเลือกแล้วออกมาและออกจากโปรแกรม; ให้รันคำสั่งอนุมัติอีกครั้งด้วย request ID ที่ถูกต้องหลังจากตรวจสอบรายละเอียดแล้ว
หมายเหตุ: หากอุปกรณ์ลองจับคู่อีกครั้งโดยมีรายละเอียดการยืนยันตัวตนที่เปลี่ยนไป (role/scopes/public key), OpenClaw จะใช้รายการที่รอดำเนินการใหม่แทนรายการก่อนหน้าและออก `requestId` ใหม่ ให้รัน `openclaw devices list` ทันทีก่อนอนุมัติเพื่อใช้ ID ปัจจุบัน
หากอุปกรณ์ถูกจับคู่อยู่แล้วและขอ scopes ที่กว้างขึ้นหรือ role ที่กว้างขึ้น OpenClaw จะคงการอนุมัติเดิมไว้และสร้างคำขออัปเกรดที่รอดำเนินการใหม่ ให้ตรวจสอบคอลัมน์ `Requested` เทียบกับ `Approved` ใน `openclaw devices list` หรือใช้ `openclaw devices approve --latest` เพื่อดูตัวอย่างการอัปเกรดที่แน่นอนก่อนอนุมัติ
```
openclaw devices approve
openclaw devices approve <requestId>
openclaw devices approve --latest
```
### `openclaw devices reject <requestId>`
ปฏิเสธคำขอจับคู่อุปกรณ์ที่รอดำเนินการ
```
openclaw devices reject <requestId>
```
### `openclaw devices rotate --device <id> --role <role> [--scope <scope...>]`
หมุนเวียนโทเค็นอุปกรณ์สำหรับ role ที่ระบุ (พร้อมอัปเดต scopes ได้หากต้องการ)
role เป้าหมายต้องมีอยู่แล้วในสัญญาการจับคู่ที่อนุมัติของอุปกรณ์นั้น; การหมุนเวียนไม่สามารถสร้าง role ใหม่ที่ยังไม่ได้รับการอนุมัติได้
หากคุณละเว้น `--scope`, การเชื่อมต่อใหม่ภายหลังด้วยโทเค็นที่หมุนเวียนและจัดเก็บไว้นั้นจะใช้ scopes ที่อนุมัติแล้วที่แคชไว้ของโทเค็นนั้นซ้ำ หากคุณส่งค่า `--scope` แบบชัดเจน ค่าเหล่านั้นจะกลายเป็นชุด scope ที่จัดเก็บไว้สำหรับการเชื่อมต่อใหม่ด้วยโทเค็นที่แคชไว้ในอนาคต
ผู้เรียกจาก paired-device ที่ไม่ใช่แอดมินสามารถหมุนเวียนได้เฉพาะโทเค็นอุปกรณ์ของ **ตนเอง** เท่านั้น
นอกจากนี้ ค่า `--scope` แบบชัดเจนใดๆ ต้องอยู่ภายใน operator scopes ของเซสชันผู้เรียกเองด้วย; การหมุนเวียนไม่สามารถสร้างโทเค็น operator ที่กว้างกว่าที่ผู้เรียกมีอยู่แล้วได้
```
openclaw devices rotate --device <deviceId> --role operator --scope operator.read --scope operator.write
```
ส่งคืน payload ของโทเค็นใหม่ในรูปแบบ JSON
### `openclaw devices revoke --device <id> --role <role>`
เพิกถอนโทเค็นอุปกรณ์สำหรับ role ที่ระบุ
ผู้เรียกจาก paired-device ที่ไม่ใช่แอดมินสามารถเพิกถอนได้เฉพาะโทเค็นอุปกรณ์ของ **ตนเอง** เท่านั้น
การเพิกถอนโทเค็นของอุปกรณ์อื่นต้องใช้ `operator.admin`
```
openclaw devices revoke --device <deviceId> --role node
```
ส่งคืนผลลัพธ์การเพิกถอนในรูปแบบ JSON
## ตัวเลือกที่ใช้ร่วมกัน
- `--url <url>`: URL ของ Gateway WebSocket (ค่าเริ่มต้นคือ `gateway.remote.url` เมื่อตั้งค่าไว้)
- `--token <token>`: โทเค็น Gateway (หากจำเป็น)
- `--password <password>`: รหัสผ่าน Gateway (การยืนยันตัวตนด้วยรหัสผ่าน)
- `--timeout <ms>`: หมดเวลา RPC
- `--json`: เอาต์พุต JSON (แนะนำสำหรับการทำสคริปต์)
หมายเหตุ: เมื่อคุณตั้งค่า `--url`, CLI จะไม่ย้อนกลับไปใช้ข้อมูลรับรองจาก config หรือ environment
ให้ส่ง `--token` หรือ `--password` อย่างชัดเจน การไม่มีข้อมูลรับรองที่ระบุอย่างชัดเจนถือเป็นข้อผิดพลาด
## หมายเหตุ
- การหมุนเวียนโทเค็นจะส่งคืนโทเค็นใหม่ (เป็นข้อมูลสำคัญ) ให้ปฏิบัติต่อมันเสมือนเป็นความลับ
- คำสั่งเหล่านี้ต้องใช้ scope `operator.pairing` (หรือ `operator.admin`)
- การหมุนเวียนโทเค็นจะอยู่ภายในชุด role ที่ได้รับอนุมัติจากการจับคู่และค่าพื้นฐาน scope ที่ได้รับอนุมัติสำหรับอุปกรณ์นั้น รายการโทเค็นที่แคชไว้ที่หลงเหลืออยู่จะไม่ให้สิทธิ์เป้าหมายการหมุนเวียนใหม่
- สำหรับเซสชันโทเค็นของ paired-device การจัดการข้ามอุปกรณ์เป็นแอดมินเท่านั้น: `remove`, `rotate`, และ `revoke` ใช้ได้กับตัวเองเท่านั้น เว้นแต่ผู้เรียกจะมี `operator.admin`
- `devices clear` ถูกป้องกันไว้โดยเจตนาด้วย `--yes`
- หาก scope การจับคู่ไม่พร้อมใช้งานบน local loopback (และไม่มีการส่ง `--url` แบบชัดเจน), list/approve สามารถใช้ fallback การจับคู่แบบ local ได้
- `devices approve` ต้องใช้ request ID แบบชัดเจนก่อนสร้างโทเค็น; การละเว้น `requestId` หรือส่ง `--latest` จะเป็นเพียงการแสดงตัวอย่างคำขอที่รอดำเนินการล่าสุดเท่านั้น
## เช็กลิสต์การกู้คืนเมื่อโทเค็นไม่ตรงกัน
ใช้ส่วนนี้เมื่อ Control UI หรือไคลเอนต์อื่นๆ ยังคงล้มเหลวด้วย `AUTH_TOKEN_MISMATCH` หรือ `AUTH_DEVICE_TOKEN_MISMATCH`
1. ยืนยันแหล่งที่มาของโทเค็น gateway ปัจจุบัน:
```bash
openclaw config get gateway.auth.token
```
2. แสดงรายการอุปกรณ์ที่จับคู่แล้วและระบุ device id ที่ได้รับผลกระทบ:
```bash
openclaw devices list
```
3. หมุนเวียนโทเค็น operator สำหรับอุปกรณ์ที่ได้รับผลกระทบ:
```bash
openclaw devices rotate --device <deviceId> --role operator
```
4. หากการหมุนเวียนยังไม่เพียงพอ ให้ลบการจับคู่เก่าที่ค้างอยู่แล้วอนุมัติอีกครั้ง:
```bash
openclaw devices remove <deviceId>
openclaw devices list
openclaw devices approve <requestId>
```
5. ลองเชื่อมต่อไคลเอนต์อีกครั้งด้วย shared token/password ปัจจุบัน
หมายเหตุ:
- ลำดับความสำคัญของการยืนยันตัวตนในการเชื่อมต่อใหม่ตามปกติคือ shared token/password ที่ระบุอย่างชัดเจนก่อน จากนั้น `deviceToken` ที่ระบุอย่างชัดเจน จากนั้นโทเค็นอุปกรณ์ที่จัดเก็บไว้ แล้วจึงเป็น bootstrap token
- การกู้คืน `AUTH_TOKEN_MISMATCH` ที่เชื่อถือได้สามารถส่งทั้ง shared token และโทเค็นอุปกรณ์ที่จัดเก็บไว้พร้อมกันได้ชั่วคราวสำหรับการลองใหม่แบบมีขอบเขตเพียงครั้งเดียว
ที่เกี่ยวข้อง:
- [การแก้ปัญหาการยืนยันตัวตนของแดชบอร์ด](/th/web/dashboard#if-you-see-unauthorized-1008)
- [การแก้ปัญหา Gateway](/th/gateway/troubleshooting#dashboard-control-ui-connectivity)

70
docs/th/cli/directory.md Normal file
View File

@ -0,0 +1,70 @@
---
read_when:
- คุณต้องการค้นหารหัสผู้ติดต่อ/กลุ่ม/ตัวเองสำหรับช่องทางหนึ่ง
- คุณกำลังพัฒนาอะแดปเตอร์ไดเรกทอรีของช่องทาง
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw directory` (ตัวเอง, peers, groups)
title: ไดเรกทอรี
x-i18n:
generated_at: "2026-04-23T06:17:42Z"
model: gpt-5.4
provider: openai
source_hash: 6a81a037e0a33f77c24b1adabbc4be16ed4d03c419873f3cbdd63f2ce84a1064
source_path: cli/directory.md
workflow: 15
---
# `openclaw directory`
การค้นหาไดเรกทอรีสำหรับ channels ที่รองรับ (ผู้ติดต่อ/peers, groups และ “me”)
## แฟลกทั่วไป
- `--channel <name>`: id/นามแฝงของ channel (จำเป็นเมื่อมีการตั้งค่าหลาย channels; ระบุอัตโนมัติเมื่อมีการตั้งค่าไว้เพียงหนึ่งเดียว)
- `--account <id>`: id ของบัญชี (ค่าเริ่มต้น: ค่าเริ่มต้นของ channel)
- `--json`: แสดงผลเป็น JSON
## หมายเหตุ
- `directory` มีไว้เพื่อช่วยคุณค้นหา ID ที่สามารถนำไปวางในคำสั่งอื่นได้ (โดยเฉพาะ `openclaw message send --target ...`)
- สำหรับหลาย channels ผลลัพธ์จะอิงตาม config (allowlists / groups ที่ตั้งค่าไว้) มากกว่าจะเป็นไดเรกทอรีสดจาก provider
- เอาต์พุตเริ่มต้นคือ `id` (และบางครั้งมี `name`) คั่นด้วยแท็บ; ใช้ `--json` สำหรับการเขียนสคริปต์
## การใช้ผลลัพธ์กับ `message send`
```bash
openclaw directory peers list --channel slack --query "U0"
openclaw message send --channel slack --target user:U012ABCDEF --message "hello"
```
## รูปแบบ ID (ตาม channel)
- WhatsApp: `+15551234567` (DM), `1234567890-1234567890@g.us` (group)
- Telegram: `@username` หรือ chat id แบบตัวเลข; groups ใช้ id แบบตัวเลข
- Slack: `user:U…` และ `channel:C…`
- Discord: `user:<id>` และ `channel:<id>`
- Matrix (Plugin): `user:@user:server`, `room:!roomId:server` หรือ `#alias:server`
- Microsoft Teams (Plugin): `user:<id>` และ `conversation:<id>`
- Zalo (Plugin): user id (Bot API)
- Zalo Personal / `zalouser` (Plugin): thread id (DM/group) จาก `zca` (`me`, `friend list`, `group list`)
## ตัวเอง ("me")
```bash
openclaw directory self --channel zalouser
```
## Peers (ผู้ติดต่อ/ผู้ใช้)
```bash
openclaw directory peers list --channel zalouser
openclaw directory peers list --channel zalouser --query "name"
openclaw directory peers list --channel zalouser --limit 50
```
## Groups
```bash
openclaw directory groups list --channel zalouser
openclaw directory groups list --channel zalouser --query "work"
openclaw directory groups members --channel zalouser --group-id <id>
```

55
docs/th/cli/dns.md Normal file
View File

@ -0,0 +1,55 @@
---
read_when:
- คุณต้องการการค้นหาในวงกว้าง (DNS-SD) ผ่าน Tailscale + CoreDNS
- Youre setting up split DNS for a custom discovery domain (example: openclaw.internal)
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw dns` (ตัวช่วยการค้นหาในวงกว้าง)
title: DNS
x-i18n:
generated_at: "2026-04-23T06:17:42Z"
model: gpt-5.4
provider: openai
source_hash: 4831fbb7791adfed5195bc4ba36bb248d2bc8830958334211d3c96f824617927
source_path: cli/dns.md
workflow: 15
---
# `openclaw dns`
ตัวช่วย DNS สำหรับการค้นหาในวงกว้าง (Tailscale + CoreDNS) ปัจจุบันมุ่งเน้นที่ macOS + Homebrew CoreDNS
ที่เกี่ยวข้อง:
- การค้นหา Gateway: [Discovery](/th/gateway/discovery)
- การกำหนดค่าการค้นหาในวงกว้าง: [Configuration](/th/gateway/configuration)
## การตั้งค่า
```bash
openclaw dns setup
openclaw dns setup --domain openclaw.internal
openclaw dns setup --apply
```
## `dns setup`
วางแผนหรือนำการตั้งค่า CoreDNS ไปใช้สำหรับการค้นหา unicast DNS-SD
ตัวเลือก:
- `--domain <domain>`: โดเมนการค้นหาในวงกว้าง (ตัวอย่างเช่น `openclaw.internal`)
- `--apply`: ติดตั้งหรืออัปเดตการกำหนดค่า CoreDNS และรีสตาร์ตบริการ (ต้องใช้ sudo; macOS เท่านั้น)
สิ่งที่จะแสดง:
- โดเมนการค้นหาที่ resolve แล้ว
- พาธไฟล์โซน
- IP tailnet ปัจจุบัน
- การกำหนดค่า `openclaw.json` ที่แนะนำสำหรับการค้นหา
- ค่า nameserver/domain ของ Tailscale Split DNS ที่ต้องตั้งค่า
หมายเหตุ:
- หากไม่ระบุ `--apply` คำสั่งนี้จะเป็นเพียงตัวช่วยสำหรับการวางแผนและพิมพ์การตั้งค่าที่แนะนำ
- หากไม่ระบุ `--domain` OpenClaw จะใช้ `discovery.wideArea.domain` จากการกำหนดค่า
- ปัจจุบัน `--apply` รองรับเฉพาะ macOS และคาดว่าจะใช้ Homebrew CoreDNS
- `--apply` จะบูตสแตรปไฟล์โซนหากจำเป็น ตรวจสอบให้แน่ใจว่ามี CoreDNS import stanza อยู่ และรีสตาร์ตบริการ brew `coredns`

35
docs/th/cli/docs.md Normal file
View File

@ -0,0 +1,35 @@
---
read_when:
- คุณต้องการค้นหาเอกสาร OpenClaw แบบสดจากเทอร์มินัล
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw docs` (ค้นหาในดัชนีเอกสารสด)
title: เอกสาร
x-i18n:
generated_at: "2026-04-23T06:17:45Z"
model: gpt-5.4
provider: openai
source_hash: cfcceed872d7509b9843af3fae733a136bc5e26ded55c2ac47a16489a1636989
source_path: cli/docs.md
workflow: 15
---
# `openclaw docs`
ค้นหาในดัชนีเอกสารสด
อาร์กิวเมนต์:
- `[query...]`: คำค้นหาที่จะส่งไปยังดัชนีเอกสารสด
ตัวอย่าง:
```bash
openclaw docs
openclaw docs browser existing-session
openclaw docs sandbox allowHostControl
openclaw docs gateway token secretref
```
หมายเหตุ:
- หากไม่มีคำค้นหา `openclaw docs` จะเปิดจุดเริ่มต้นการค้นหาเอกสารสด
- คำค้นหาหลายคำจะถูกส่งต่อเป็นคำขอค้นหาเดียว

71
docs/th/cli/doctor.md Normal file
View File

@ -0,0 +1,71 @@
---
read_when:
- คุณมีปัญหาด้านการเชื่อมต่อ/การยืนยันตัวตน และต้องการแนวทางแก้ไขแบบมีคำแนะนำ
- คุณเพิ่งอัปเดตและต้องการตรวจสอบความถูกต้องเบื้องต้น
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw doctor` (การตรวจสอบสุขภาพ + การซ่อมแซมแบบมีคำแนะนำ)
title: doctor
x-i18n:
generated_at: "2026-04-23T06:17:50Z"
model: gpt-5.4
provider: openai
source_hash: ad44619b427b938b2f6d4f904fcdc2d9862ff33c569008590f25e17d12e03530
source_path: cli/doctor.md
workflow: 15
---
# `openclaw doctor`
การตรวจสอบสุขภาพ + การแก้ไขด่วนสำหรับ gateway และ channels
ที่เกี่ยวข้อง:
- การแก้ไขปัญหา: [การแก้ไขปัญหา](/th/gateway/troubleshooting)
- การตรวจสอบความปลอดภัย: [ความปลอดภัย](/th/gateway/security)
## ตัวอย่าง
```bash
openclaw doctor
openclaw doctor --repair
openclaw doctor --deep
openclaw doctor --repair --non-interactive
openclaw doctor --generate-gateway-token
```
## ตัวเลือก
- `--no-workspace-suggestions`: ปิดคำแนะนำเกี่ยวกับหน่วยความจำ/การค้นหาของ workspace
- `--yes`: ยอมรับค่าเริ่มต้นโดยไม่ต้องถาม
- `--repair`: ใช้การซ่อมแซมที่แนะนำโดยไม่ต้องถาม
- `--fix`: ชื่อเรียกแทนของ `--repair`
- `--force`: ใช้การซ่อมแซมแบบเข้มข้น รวมถึงเขียนทับ config บริการแบบกำหนดเองเมื่อจำเป็น
- `--non-interactive`: ทำงานโดยไม่มีพรอมป์ต์; เฉพาะการย้ายข้อมูลที่ปลอดภัย
- `--generate-gateway-token`: สร้างและกำหนดค่า gateway token
- `--deep`: สแกนบริการของระบบเพื่อค้นหาการติดตั้ง gateway เพิ่มเติม
หมายเหตุ:
- พรอมป์ต์แบบโต้ตอบ (เช่น การแก้ไข keychain/OAuth) จะทำงานเฉพาะเมื่อ stdin เป็น TTY และ **ไม่ได้** ตั้งค่า `--non-interactive` การรันแบบ headless (Cron, Telegram, ไม่มีเทอร์มินัล) จะข้ามพรอมป์ต์
- `--fix` (ชื่อเรียกแทนของ `--repair`) จะเขียนไฟล์สำรองไปที่ `~/.openclaw/openclaw.json.bak` และลบ config keys ที่ไม่รู้จัก โดยแสดงรายการแต่ละรายการที่ถูกลบ
- การตรวจสอบความสมบูรณ์ของ state ตอนนี้สามารถตรวจจับไฟล์ transcript ที่ไม่มีเจ้าของในไดเรกทอรี sessions และสามารถเก็บถาวรเป็น `.deleted.<timestamp>` เพื่อคืนพื้นที่อย่างปลอดภัย
- Doctor ยังสแกน `~/.openclaw/cron/jobs.json` (หรือ `cron.store`) เพื่อหารูปแบบงาน Cron แบบดั้งเดิม และสามารถเขียนใหม่แทนที่ในที่เดิมก่อนที่ scheduler จะต้องปรับให้อยู่ในรูปแบบปกติอัตโนมัติระหว่างรันไทม์
- Doctor ซ่อมแซม runtime dependencies ของ Plugin แบบ bundled ที่หายไปได้ โดยไม่ต้องใช้สิทธิ์เขียนไปยังแพ็กเกจ OpenClaw ที่ติดตั้งไว้ สำหรับการติดตั้ง npm ที่เป็นของ root หรือ systemd units ที่มีการ harden ให้ตั้งค่า `OPENCLAW_PLUGIN_STAGE_DIR` ไปยังไดเรกทอรีที่เขียนได้ เช่น `/var/lib/openclaw/plugin-runtime-deps`
- Doctor จะย้าย Talk config แบบแบนรุ่นเก่า (`talk.voiceId`, `talk.modelId` และรายการที่เกี่ยวข้อง) ไปเป็น `talk.provider` + `talk.providers.<provider>` โดยอัตโนมัติ
- การรัน `doctor --fix` ซ้ำจะไม่รายงาน/ใช้ Talk normalization อีกต่อไป หากความแตกต่างมีเพียงลำดับของ object keys
- Doctor มีการตรวจสอบความพร้อมของ memory-search และสามารถแนะนำ `openclaw configure --section model` เมื่อไม่มี credentials สำหรับ embedding
- หากเปิดใช้งานโหมด sandbox แต่ Docker ไม่พร้อมใช้งาน doctor จะรายงานคำเตือนที่ชัดเจนพร้อมแนวทางแก้ไข (`ติดตั้ง Docker` หรือ `openclaw config set agents.defaults.sandbox.mode off`)
- หาก `gateway.auth.token`/`gateway.auth.password` ถูกจัดการด้วย SecretRef และไม่พร้อมใช้งานในเส้นทางคำสั่งปัจจุบัน doctor จะรายงานคำเตือนแบบอ่านอย่างเดียว และจะไม่เขียน credentials แบบ plaintext สำรอง
- หากการตรวจสอบ SecretRef ของ channel ล้มเหลวในเส้นทางการแก้ไข doctor จะทำงานต่อและรายงานคำเตือนแทนการออกจากโปรแกรมก่อนเวลา
- การ resolve ชื่อผู้ใช้แบบอัตโนมัติสำหรับ `allowFrom` ของ Telegram (`doctor --fix`) ต้องใช้ Telegram token ที่สามารถ resolve ได้ในเส้นทางคำสั่งปัจจุบัน หากไม่สามารถตรวจสอบ token ได้ doctor จะรายงานคำเตือนและข้ามการ resolve อัตโนมัติในรอบนั้น
## macOS: การ override env ของ `launchctl`
หากคุณเคยรัน `launchctl setenv OPENCLAW_GATEWAY_TOKEN ...` (หรือ `...PASSWORD`) มาก่อน ค่านั้นจะ override ไฟล์ config ของคุณ และอาจทำให้เกิดข้อผิดพลาด “unauthorized” อย่างต่อเนื่อง
```bash
launchctl getenv OPENCLAW_GATEWAY_TOKEN
launchctl getenv OPENCLAW_GATEWAY_PASSWORD
launchctl unsetenv OPENCLAW_GATEWAY_TOKEN
launchctl unsetenv OPENCLAW_GATEWAY_PASSWORD
```

25
docs/th/cli/flows.md Normal file
View File

@ -0,0 +1,25 @@
---
read_when:
- คุณพบ openclaw flows ในเอกสารหรือบันทึกประจำรุ่นเวอร์ชันเก่า
summary: 'เปลี่ยนเส้นทาง: คำสั่ง flow อยู่ภายใต้ `openclaw tasks flow`'
title: flows (เปลี่ยนเส้นทาง)
x-i18n:
generated_at: "2026-04-23T06:17:57Z"
model: gpt-5.4
provider: openai
source_hash: 99377cf58ae17262291218639c4425abcec4efbd0405cf05b6df0d2e5b7f20bb
source_path: cli/flows.md
workflow: 15
---
# `openclaw tasks flow`
คำสั่ง Flow เป็นคำสั่งย่อยของ `openclaw tasks` ไม่ใช่คำสั่ง `flows` แบบแยกต่างหาก
```bash
openclaw tasks flow list [--json]
openclaw tasks flow show <lookup>
openclaw tasks flow cancel <lookup>
```
ดูเอกสารฉบับเต็มได้ที่ [TaskFlow](/th/automation/taskflow) และ [ข้อมูลอ้างอิง CLI ของ tasks](/th/cli/tasks)

374
docs/th/cli/gateway.md Normal file
View File

@ -0,0 +1,374 @@
---
read_when:
- การรัน Gateway จาก CLI (สำหรับการพัฒนาหรือเซิร์ฟเวอร์)
- การดีบักการยืนยันตัวตนของ Gateway โหมด bind และการเชื่อมต่อ
- การค้นหา gateway ผ่าน Bonjour (ภายในเครื่อง + DNS-SD แบบวงกว้าง)
summary: CLI ของ OpenClaw Gateway (`openclaw gateway`) — รัน สืบค้น และค้นหา gateway
title: Gateway
x-i18n:
generated_at: "2026-04-23T06:17:55Z"
model: gpt-5.4
provider: openai
source_hash: 60706df4d3c49271c4b53029eaae16672dde534c7f6f4ce68e04b58fb0cfa467
source_path: cli/gateway.md
workflow: 15
---
# CLI ของ Gateway
Gateway คือเซิร์ฟเวอร์ WebSocket ของ OpenClaw (channels, nodes, sessions, hooks)
คำสั่งย่อยในหน้านี้อยู่ภายใต้ `openclaw gateway …`
เอกสารที่เกี่ยวข้อง:
- [/gateway/bonjour](/th/gateway/bonjour)
- [/gateway/discovery](/th/gateway/discovery)
- [/gateway/configuration](/th/gateway/configuration)
## รัน Gateway
รัน process ของ Gateway ในเครื่อง:
```bash
openclaw gateway
```
นามแฝงสำหรับรันแบบ foreground:
```bash
openclaw gateway run
```
หมายเหตุ:
- โดยค่าเริ่มต้น Gateway จะปฏิเสธการเริ่มทำงาน เว้นแต่จะตั้งค่า `gateway.mode=local` ไว้ใน `~/.openclaw/openclaw.json` ใช้ `--allow-unconfigured` สำหรับการรันแบบเฉพาะกิจ/เพื่อการพัฒนา
- `openclaw onboard --mode local` และ `openclaw setup` ควรเป็นผู้เขียน `gateway.mode=local` หากไฟล์มีอยู่แต่ไม่มี `gateway.mode` ให้ถือว่านี่คือการกำหนดค่าที่เสียหายหรือถูกเขียนทับ และซ่อมแซมแทนที่จะสมมติว่าเป็น local mode โดยปริยาย
- หากไฟล์มีอยู่และไม่มี `gateway.mode` Gateway จะถือว่านี่เป็นความเสียหายของการกำหนดค่าที่น่าสงสัย และจะปฏิเสธที่จะ “เดา local” ให้คุณ
- ระบบจะบล็อกการ bind นอกเหนือจาก loopback โดยไม่มี auth (ราวป้องกันด้านความปลอดภัย)
- `SIGUSR1` จะทริกเกอร์การรีสตาร์ตภายใน process เมื่อได้รับอนุญาต (`commands.restart` เปิดใช้งานโดยค่าเริ่มต้น; ตั้งค่า `commands.restart: false` เพื่อบล็อกการรีสตาร์ตด้วยตนเอง แต่ยังอนุญาตให้ใช้เครื่องมือ/config ของ gateway เพื่อ apply/update ได้)
- ตัวจัดการ `SIGINT`/`SIGTERM` จะหยุด process ของ gateway แต่จะไม่กู้คืนสถานะ terminal แบบกำหนดเองใด ๆ หากคุณครอบ CLI ด้วย TUI หรืออินพุตแบบ raw-mode ให้กู้คืน terminal ก่อนออก
### ตัวเลือก
- `--port <port>`: พอร์ต WebSocket (ค่าเริ่มต้นมาจาก config/env; โดยปกติคือ `18789`)
- `--bind <loopback|lan|tailnet|auto|custom>`: โหมด bind ของ listener
- `--auth <token|password>`: แทนที่โหมด auth
- `--token <token>`: แทนที่ token (และตั้งค่า `OPENCLAW_GATEWAY_TOKEN` สำหรับ process ด้วย)
- `--password <password>`: แทนที่รหัสผ่าน คำเตือน: รหัสผ่านที่ใส่ไว้ตรง ๆ อาจถูกเปิดเผยในรายการ process ภายในเครื่อง
- `--password-file <path>`: อ่านรหัสผ่าน gateway จากไฟล์
- `--tailscale <off|serve|funnel>`: เปิดเผย Gateway ผ่าน Tailscale
- `--tailscale-reset-on-exit`: รีเซ็ตการกำหนดค่า Tailscale serve/funnel เมื่อปิดการทำงาน
- `--allow-unconfigured`: อนุญาตให้เริ่ม gateway โดยไม่มี `gateway.mode=local` ใน config ตัวเลือกนี้ข้ามราวป้องกันตอนเริ่มต้นสำหรับการบูตสแตรปแบบเฉพาะกิจ/เพื่อการพัฒนาเท่านั้น และจะไม่เขียนหรือซ่อมแซมไฟล์ config
- `--dev`: สร้าง config + workspace สำหรับการพัฒนาหากยังไม่มี (ข้าม BOOTSTRAP.md)
- `--reset`: รีเซ็ต config + credentials + sessions + workspace สำหรับการพัฒนา (ต้องใช้ร่วมกับ `--dev`)
- `--force`: ฆ่า listener ที่มีอยู่บนพอร์ตที่เลือกก่อนเริ่มทำงาน
- `--verbose`: บันทึกแบบละเอียด
- `--cli-backend-logs`: แสดงเฉพาะบันทึก backend ของ CLI ในคอนโซล (และเปิดใช้งาน stdout/stderr)
- `--ws-log <auto|full|compact>`: รูปแบบบันทึก websocket (ค่าเริ่มต้นคือ `auto`)
- `--compact`: นามแฝงของ `--ws-log compact`
- `--raw-stream`: บันทึก event ของ model stream แบบดิบลงใน jsonl
- `--raw-stream-path <path>`: พาธ jsonl ของ raw stream
การทำโปรไฟล์ตอนเริ่มต้น:
- ตั้งค่า `OPENCLAW_GATEWAY_STARTUP_TRACE=1` เพื่อบันทึกเวลาในแต่ละช่วงระหว่างการเริ่มต้น Gateway
- รัน `pnpm test:startup:gateway -- --runs 5 --warmup 1` เพื่อวัดประสิทธิภาพการเริ่มต้น Gateway การวัดจะบันทึกเอาต์พุตแรกของ process, `/healthz`, `/readyz` และเวลา startup trace
## สืบค้น Gateway ที่กำลังรันอยู่
คำสั่งสืบค้นทั้งหมดใช้ WebSocket RPC
โหมดเอาต์พุต:
- ค่าเริ่มต้น: อ่านได้โดยมนุษย์ (มีสีใน TTY)
- `--json`: JSON ที่เครื่องอ่านได้ (ไม่มีการจัดรูปแบบ/spinner)
- `--no-color` (หรือ `NO_COLOR=1`): ปิด ANSI แต่คงเลย์เอาต์แบบมนุษย์อ่านได้
ตัวเลือกร่วม (ในคำสั่งที่รองรับ):
- `--url <url>`: URL WebSocket ของ Gateway
- `--token <token>`: token ของ Gateway
- `--password <password>`: รหัสผ่านของ Gateway
- `--timeout <ms>`: timeout/budget (แตกต่างกันไปตามคำสั่ง)
- `--expect-final`: รอการตอบกลับแบบ “final” (การเรียก agent)
หมายเหตุ: เมื่อคุณตั้งค่า `--url` แล้ว CLI จะไม่ถอยกลับไปใช้ credentials จาก config หรือ environment
ให้ส่ง `--token` หรือ `--password` อย่างชัดเจน การไม่มี credentials แบบชัดเจนถือเป็นข้อผิดพลาด
### `gateway health`
```bash
openclaw gateway health --url ws://127.0.0.1:18789
```
endpoint HTTP `/healthz` เป็น liveness probe: จะตอบกลับเมื่อเซิร์ฟเวอร์สามารถตอบ HTTP ได้ ส่วน endpoint HTTP `/readyz` เข้มงวดกว่า และจะยังคงเป็นสีแดงในขณะที่ sidecars, channels หรือ hooks ที่กำหนดค่าไว้ระหว่างการเริ่มต้นยังคงอยู่ระหว่างการตั้งตัว
### `gateway usage-cost`
ดึงสรุป usage-cost จากบันทึกเซสชัน
```bash
openclaw gateway usage-cost
openclaw gateway usage-cost --days 7
openclaw gateway usage-cost --json
```
ตัวเลือก:
- `--days <days>`: จำนวนวันที่จะรวม (ค่าเริ่มต้น `30`)
### `gateway stability`
ดึงตัวบันทึกเสถียรภาพสำหรับการวินิจฉัยล่าสุดจาก Gateway ที่กำลังรันอยู่
```bash
openclaw gateway stability
openclaw gateway stability --type payload.large
openclaw gateway stability --bundle latest
openclaw gateway stability --bundle latest --export
openclaw gateway stability --json
```
ตัวเลือก:
- `--limit <limit>`: จำนวน event ล่าสุดสูงสุดที่จะรวม (ค่าเริ่มต้น `25`, สูงสุด `1000`)
- `--type <type>`: กรองตามชนิด event สำหรับการวินิจฉัย เช่น `payload.large` หรือ `diagnostic.memory.pressure`
- `--since-seq <seq>`: รวมเฉพาะ event หลังหมายเลขลำดับการวินิจฉัยนี้
- `--bundle [path]`: อ่าน stability bundle ที่บันทึกไว้ แทนการเรียก Gateway ที่กำลังรัน ใช้ `--bundle latest` (หรือเพียง `--bundle`) สำหรับ bundle ล่าสุดใต้ state directory หรือระบุพาธ JSON ของ bundle โดยตรง
- `--export`: เขียนไฟล์ zip การวินิจฉัยเพื่อการสนับสนุนที่สามารถแชร์ได้ แทนการพิมพ์รายละเอียดเสถียรภาพ
- `--output <path>`: พาธเอาต์พุตสำหรับ `--export`
หมายเหตุ:
- ตัวบันทึกทำงานอยู่โดยค่าเริ่มต้น ตั้งค่า `diagnostics.enabled: false` เฉพาะเมื่อคุณจำเป็นต้องปิดการเก็บ diagnostic heartbeat ของ Gateway
- บันทึกจะเก็บ metadata ด้านปฏิบัติการ: ชื่อ event, จำนวนครั้ง, ขนาดไบต์, ค่าหน่วยความจำ, สถานะคิว/เซสชัน, ชื่อ channel/plugin และสรุปเซสชันที่ปกปิดข้อมูลแล้ว จะไม่เก็บข้อความแชต, เนื้อหา webhook, เอาต์พุตเครื่องมือ, เนื้อหา request หรือ response แบบดิบ, tokens, cookies, ค่าความลับ, hostnames หรือ session id แบบดิบ
- เมื่อ Gateway ออกจากการทำงานแบบร้ายแรง, timeout ตอนปิดระบบ และการเริ่มต้นใหม่ล้มเหลว OpenClaw จะเขียนสแนปช็อตการวินิจฉัยเดียวกันไปยัง `~/.openclaw/logs/stability/openclaw-stability-*.json` เมื่อมี event ในตัวบันทึก ตรวจสอบ bundle ล่าสุดได้ด้วย `openclaw gateway stability --bundle latest`; `--limit`, `--type` และ `--since-seq` ใช้กับเอาต์พุตของ bundle ได้เช่นกัน
### `gateway diagnostics export`
เขียนไฟล์ zip การวินิจฉัยในเครื่องที่ออกแบบมาให้แนบไปกับรายงานบั๊ก
```bash
openclaw gateway diagnostics export
openclaw gateway diagnostics export --output openclaw-diagnostics.zip
openclaw gateway diagnostics export --json
```
ตัวเลือก:
- `--output <path>`: พาธ zip ปลายทาง ค่าเริ่มต้นคือ support export ใต้ state directory
- `--log-lines <count>`: จำนวนบรรทัดบันทึกที่ผ่านการทำความสะอาดสูงสุดที่จะรวม (ค่าเริ่มต้น `5000`)
- `--log-bytes <bytes>`: จำนวนไบต์สูงสุดของบันทึกที่จะตรวจสอบ (ค่าเริ่มต้น `1000000`)
- `--url <url>`: URL WebSocket ของ Gateway สำหรับสแนปช็อต health
- `--token <token>`: token ของ Gateway สำหรับสแนปช็อต health
- `--password <password>`: รหัสผ่านของ Gateway สำหรับสแนปช็อต health
- `--timeout <ms>`: timeout ของสแนปช็อต status/health (ค่าเริ่มต้น `3000`)
- `--no-stability-bundle`: ข้ามการค้นหา stability bundle ที่บันทึกไว้
- `--json`: พิมพ์พาธที่เขียนแล้ว ขนาด และ manifest เป็น JSON
ไฟล์ export จะมี manifest, สรุป Markdown, รูปร่างของ config, รายละเอียด config ที่ผ่านการทำความสะอาด, สรุปบันทึกที่ผ่านการทำความสะอาด, สแนปช็อตสถานะ/health ของ Gateway ที่ผ่านการทำความสะอาด และ stability bundle ล่าสุดเมื่อมีอยู่
ไฟล์นี้ออกแบบมาให้แชร์ได้ โดยจะเก็บรายละเอียดด้านปฏิบัติการที่ช่วยในการดีบัก เช่น ฟิลด์บันทึก OpenClaw ที่ปลอดภัย, ชื่อ subsystem, status codes, ระยะเวลา, โหมดที่กำหนดค่าไว้, พอร์ต, plugin ids, provider ids, การตั้งค่าฟีเจอร์ที่ไม่เป็นความลับ และข้อความบันทึกด้านปฏิบัติการที่ปกปิดข้อมูลแล้ว โดยจะละเว้นหรือปกปิดข้อความแชต, เนื้อหา webhook, เอาต์พุตเครื่องมือ, credentials, cookies, ตัวระบุบัญชี/ข้อความ, ข้อความ prompt/instruction, hostnames และค่าความลับ เมื่อข้อความแบบ LogTape ดูเหมือนเป็นข้อความ payload ของผู้ใช้/แชต/เครื่องมือ export จะเก็บเพียงว่ามีข้อความที่ถูกละเว้น พร้อมจำนวนไบต์ของข้อความนั้น
### `gateway status`
`gateway status` แสดงบริการ Gateway (launchd/systemd/schtasks) พร้อมการตรวจสอบการเชื่อมต่อ/ความสามารถด้าน auth แบบไม่บังคับ
```bash
openclaw gateway status
openclaw gateway status --json
openclaw gateway status --require-rpc
```
ตัวเลือก:
- `--url <url>`: เพิ่มเป้าหมาย probe แบบชัดเจน จะยังคง probe ทั้ง remote ที่กำหนดค่าไว้ + localhost
- `--token <token>`: token auth สำหรับ probe
- `--password <password>`: password auth สำหรับ probe
- `--timeout <ms>`: timeout ของ probe (ค่าเริ่มต้น `10000`)
- `--no-probe`: ข้ามการ probe การเชื่อมต่อ (มุมมองเฉพาะบริการ)
- `--deep`: สแกนบริการระดับระบบด้วย
- `--require-rpc`: ยกระดับ probe การเชื่อมต่อค่าเริ่มต้นให้เป็น read probe และคืนค่าออกไม่เป็นศูนย์เมื่อ read probe ล้มเหลว ใช้ร่วมกับ `--no-probe` ไม่ได้
หมายเหตุ:
- `gateway status` ยังใช้งานได้สำหรับการวินิจฉัย แม้ local CLI config จะหายไปหรือไม่ถูกต้อง
- `gateway status` ตามค่าเริ่มต้นพิสูจน์สถานะของบริการ, การเชื่อมต่อ WebSocket และความสามารถด้าน auth ที่มองเห็นได้ในช่วง handshake โดยไม่ได้พิสูจน์การดำเนินการแบบ read/write/admin
- `gateway status` จะแก้ SecretRef ของ auth ที่กำหนดค่าไว้สำหรับ probe auth เมื่อทำได้
- หาก SecretRef ของ auth ที่จำเป็นไม่สามารถแก้ได้ในเส้นทางคำสั่งนี้ `gateway status --json` จะรายงาน `rpc.authWarning` เมื่อ probe การเชื่อมต่อ/auth ล้มเหลว; ให้ส่ง `--token`/`--password` อย่างชัดเจน หรือแก้แหล่ง secret ก่อน
- หาก probe สำเร็จ คำเตือนเกี่ยวกับ auth-ref ที่แก้ไม่ได้จะถูกซ่อนเพื่อหลีกเลี่ยง false positives
- ใช้ `--require-rpc` ในสคริปต์และระบบอัตโนมัติ เมื่อการมีบริการที่รับฟังอยู่ยังไม่เพียงพอ และคุณต้องการให้การเรียก RPC ระดับ read ใช้งานได้ปกติด้วย
- `--deep` จะเพิ่มการสแกนแบบ best-effort สำหรับการติดตั้ง launchd/systemd/schtasks เพิ่มเติม เมื่อพบบริการลักษณะ gateway หลายตัว เอาต์พุตสำหรับมนุษย์จะพิมพ์คำแนะนำในการเก็บกวาด และเตือนว่าการตั้งค่าส่วนใหญ่ควรรัน gateway หนึ่งตัวต่อหนึ่งเครื่อง
- เอาต์พุตสำหรับมนุษย์จะรวมพาธบันทึกไฟล์ที่ resolve แล้ว พร้อมสแนปช็อตพาธ config/ความถูกต้องของ CLI เทียบกับบริการ เพื่อช่วยวินิจฉัยความคลาดเคลื่อนของ profile หรือ state-dir
- ในการติดตั้ง Linux systemd การตรวจสอบ auth drift ของบริการจะอ่านค่าทั้ง `Environment=` และ `EnvironmentFile=` จาก unit (รวม `%h`, พาธที่มีเครื่องหมายอัญประกาศ, หลายไฟล์ และไฟล์แบบมี `-` เป็นตัวเลือก)
- การตรวจสอบ drift จะแก้ SecretRefs ของ `gateway.auth.token` โดยใช้ env ของ runtime ที่ผสานกัน (env ของคำสั่งบริการก่อน แล้วจึง fallback ไปยัง env ของ process)
- หาก token auth ไม่ได้มีผลใช้งานจริง (ตั้งค่า `gateway.auth.mode` เป็น `password`/`none`/`trusted-proxy` อย่างชัดเจน หรือไม่ได้ตั้งโหมดไว้ในกรณีที่ password อาจชนะและไม่มี candidate ของ token ที่สามารถชนะได้) การตรวจสอบ token-drift จะข้ามการ resolve token จาก config
### `gateway probe`
`gateway probe` คือคำสั่ง “ดีบักทุกอย่าง” โดยจะ probe เสมอ:
- remote gateway ที่คุณกำหนดค่าไว้ (หากมี) และ
- localhost (local loopback) **แม้จะมีการกำหนด remote อยู่แล้วก็ตาม**
หากคุณส่ง `--url` เป้าหมายแบบชัดเจนนั้นจะถูกเพิ่มมาก่อนทั้งสองรายการ เอาต์พุตสำหรับมนุษย์จะติดป้ายกำกับเป้าหมายดังนี้:
- `URL (explicit)`
- `Remote (configured)` หรือ `Remote (configured, inactive)`
- `Local loopback`
หากเข้าถึง gateway ได้หลายตัว ระบบจะแสดงทั้งหมด รองรับหลาย gateway เมื่อคุณใช้ profiles/ports แบบแยกจากกัน (เช่น rescue bot) แต่การติดตั้งส่วนใหญ่ยังคงรัน gateway ตัวเดียว
```bash
openclaw gateway probe
openclaw gateway probe --json
```
การตีความ:
- `Reachable: yes` หมายความว่าอย่างน้อยหนึ่งเป้าหมายยอมรับการเชื่อมต่อ WebSocket
- `Capability: read-only|write-capable|admin-capable|pairing-pending|connect-only` รายงานสิ่งที่ probe สามารถพิสูจน์ได้เกี่ยวกับ auth ซึ่งแยกจากการเข้าถึงได้
- `Read probe: ok` หมายความว่าการเรียก RPC รายละเอียดในขอบเขตการอ่าน (`health`/`status`/`system-presence`/`config.get`) ก็สำเร็จด้วย
- `Read probe: limited - missing scope: operator.read` หมายความว่าการเชื่อมต่อสำเร็จ แต่ RPC ในขอบเขตการอ่านถูกจำกัด สถานะนี้จะถูกรายงานเป็นการเข้าถึงได้แบบ **degraded** ไม่ใช่ความล้มเหลวทั้งหมด
- exit code จะไม่เป็นศูนย์ก็ต่อเมื่อไม่มีเป้าหมายใดที่ถูก probe แล้วเข้าถึงได้
หมายเหตุสำหรับ JSON (`--json`):
- ระดับบนสุด:
- `ok`: มีอย่างน้อยหนึ่งเป้าหมายที่เข้าถึงได้
- `degraded`: มีอย่างน้อยหนึ่งเป้าหมายที่มี detail RPC ถูกจำกัดด้วย scope
- `capability`: ความสามารถที่ดีที่สุดที่พบในบรรดาเป้าหมายที่เข้าถึงได้ (`read_only`, `write_capable`, `admin_capable`, `pairing_pending`, `connected_no_operator_scope` หรือ `unknown`)
- `primaryTargetId`: เป้าหมายที่ดีที่สุดที่จะถือเป็นตัวชนะหลักที่กำลังใช้งานอยู่ ตามลำดับนี้: URL แบบชัดเจน, SSH tunnel, remote ที่กำหนดค่าไว้ แล้วจึงเป็น local loopback
- `warnings[]`: รายการคำเตือนแบบ best-effort ที่มี `code`, `message` และ `targetIds` แบบไม่บังคับ
- `network`: คำใบ้ URL ของ local loopback/tailnet ที่ได้มาจาก config ปัจจุบันและเครือข่ายของโฮสต์
- `discovery.timeoutMs` และ `discovery.count`: budget/จำนวนผลลัพธ์ของการค้นหาที่ใช้จริงสำหรับรอบ probe นี้
- ต่อเป้าหมาย (`targets[].connect`):
- `ok`: ความสามารถในการเข้าถึงหลังจาก connect + การจัดประเภท degraded
- `rpcOk`: ความสำเร็จเต็มรูปแบบของ detail RPC
- `scopeLimited`: detail RPC ล้มเหลวเนื่องจากไม่มี operator scope
- ต่อเป้าหมาย (`targets[].auth`):
- `role`: บทบาท auth ที่รายงานใน `hello-ok` เมื่อมี
- `scopes`: scopes ที่ได้รับอนุญาตซึ่งรายงานใน `hello-ok` เมื่อมี
- `capability`: การจัดประเภทความสามารถด้าน auth ที่แสดงออกมาสำหรับเป้าหมายนั้น
รหัสคำเตือนที่พบบ่อย:
- `ssh_tunnel_failed`: การตั้งค่า SSH tunnel ล้มเหลว; คำสั่งจึงถอยกลับไปใช้ direct probes
- `multiple_gateways`: มีเป้าหมายที่เข้าถึงได้มากกว่าหนึ่งรายการ; สถานการณ์นี้ไม่ปกติ เว้นแต่คุณตั้งใจรัน profiles แบบแยก เช่น rescue bot
- `auth_secretref_unresolved`: ไม่สามารถ resolve auth SecretRef ที่กำหนดค่าไว้สำหรับเป้าหมายที่ล้มเหลวได้
- `probe_scope_limited`: การเชื่อมต่อ WebSocket สำเร็จ แต่ read probe ถูกจำกัดเพราะไม่มี `operator.read`
#### Remote ผ่าน SSH (เทียบเท่าแอป Mac)
โหมด “Remote over SSH” ของแอป macOS ใช้การส่งต่อพอร์ตในเครื่องเพื่อให้ remote gateway (ซึ่งอาจ bind อยู่กับ loopback เท่านั้น) สามารถเข้าถึงได้ที่ `ws://127.0.0.1:<port>`
CLI ที่เทียบเท่า:
```bash
openclaw gateway probe --ssh user@gateway-host
```
ตัวเลือก:
- `--ssh <target>`: `user@host` หรือ `user@host:port` (พอร์ตค่าเริ่มต้นคือ `22`)
- `--ssh-identity <path>`: ไฟล์ identity
- `--ssh-auto`: เลือกโฮสต์ gateway ตัวแรกที่ค้นพบเป็นเป้าหมาย SSH จาก endpoint การค้นหาที่ resolve แล้ว (`local.` รวมถึงโดเมนแบบวงกว้างที่กำหนดค่าไว้ หากมี) ระบบจะไม่สนใจคำใบ้ที่มีเฉพาะ TXT
Config (ไม่บังคับ ใช้เป็นค่าเริ่มต้น):
- `gateway.remote.sshTarget`
- `gateway.remote.sshIdentity`
### `gateway call <method>`
ตัวช่วย RPC ระดับต่ำ
```bash
openclaw gateway call status
openclaw gateway call logs.tail --params '{"sinceMs": 60000}'
```
ตัวเลือก:
- `--params <json>`: สตริง JSON object สำหรับ params (ค่าเริ่มต้น `{}`)
- `--url <url>`
- `--token <token>`
- `--password <password>`
- `--timeout <ms>`
- `--expect-final`
- `--json`
หมายเหตุ:
- `--params` ต้องเป็น JSON ที่ถูกต้อง
- `--expect-final` ใช้หลัก ๆ สำหรับ RPC แบบ agent ที่สตรีม event ขั้นกลางก่อนส่ง payload สุดท้าย
## จัดการบริการ Gateway
```bash
openclaw gateway install
openclaw gateway start
openclaw gateway stop
openclaw gateway restart
openclaw gateway uninstall
```
ตัวเลือกของคำสั่ง:
- `gateway status`: `--url`, `--token`, `--password`, `--timeout`, `--no-probe`, `--require-rpc`, `--deep`, `--json`
- `gateway install`: `--port`, `--runtime <node|bun>`, `--token`, `--force`, `--json`
- `gateway uninstall|start|stop|restart`: `--json`
หมายเหตุ:
- `gateway install` รองรับ `--port`, `--runtime`, `--token`, `--force`, `--json`
- เมื่อ token auth ต้องใช้ token และ `gateway.auth.token` ถูกจัดการด้วย SecretRef, `gateway install` จะตรวจสอบว่า SecretRef นั้น resolve ได้ แต่จะไม่คง token ที่ resolve แล้วไว้ใน metadata ของ environment สำหรับบริการ
- หาก token auth ต้องใช้ token และ token SecretRef ที่กำหนดค่าไว้ไม่สามารถ resolve ได้ การติดตั้งจะล้มเหลวแบบปิดไว้ก่อน แทนที่จะคง fallback plaintext
- สำหรับ password auth บน `gateway run` ให้ใช้ `OPENCLAW_GATEWAY_PASSWORD`, `--password-file` หรือ `gateway.auth.password` ที่อิง SecretRef แทนการใช้ `--password` แบบใส่ตรง ๆ
- ในโหมด auth ที่อนุมานได้ `OPENCLAW_GATEWAY_PASSWORD` ที่มีเฉพาะใน shell จะไม่ผ่อนคลายข้อกำหนด token สำหรับการติดตั้ง; ให้ใช้ config แบบคงทน (`gateway.auth.password` หรือ config `env`) เมื่อติดตั้งบริการที่มีการจัดการ
- หากมีการกำหนดค่าทั้ง `gateway.auth.token` และ `gateway.auth.password` แต่ไม่ได้ตั้งค่า `gateway.auth.mode` การติดตั้งจะถูกบล็อกจนกว่าจะตั้งค่าโหมดอย่างชัดเจน
- คำสั่งวงจรชีวิตรองรับ `--json` สำหรับการเขียนสคริปต์
## ค้นหา gateways (Bonjour)
`gateway discover` สแกนหา beacon ของ Gateway (`_openclaw-gw._tcp`)
- Multicast DNS-SD: `local.`
- Unicast DNS-SD (Wide-Area Bonjour): เลือกโดเมนหนึ่งโดเมน (ตัวอย่าง: `openclaw.internal.`) และตั้งค่า split DNS + เซิร์ฟเวอร์ DNS; ดู [/gateway/bonjour](/th/gateway/bonjour)
มีเฉพาะ gateways ที่เปิดใช้งานการค้นหา Bonjour เท่านั้น (ค่าเริ่มต้นคือเปิด) ที่จะโฆษณา beacon
ระเบียนการค้นหาแบบ Wide-Area ประกอบด้วย (TXT):
- `role` (คำใบ้เกี่ยวกับบทบาทของ gateway)
- `transport` (คำใบ้เกี่ยวกับการขนส่ง เช่น `gateway`)
- `gatewayPort` (พอร์ต WebSocket โดยปกติคือ `18789`)
- `sshPort` (ไม่บังคับ; ไคลเอนต์จะใช้ค่าเริ่มต้นของเป้าหมาย SSH เป็น `22` เมื่อไม่มีค่านี้)
- `tailnetDns` (ชื่อโฮสต์ MagicDNS เมื่อมี)
- `gatewayTls` / `gatewayTlsSha256` (เปิดใช้ TLS + ลายนิ้วมือใบรับรอง)
- `cliPath` (คำใบ้สำหรับการติดตั้งระยะไกลที่เขียนลงในโซนแบบ wide-area)
### `gateway discover`
```bash
openclaw gateway discover
```
ตัวเลือก:
- `--timeout <ms>`: timeout ต่อคำสั่ง (browse/resolve); ค่าเริ่มต้น `2000`
- `--json`: เอาต์พุตที่เครื่องอ่านได้ (และปิด styling/spinner ด้วย)
ตัวอย่าง:
```bash
openclaw gateway discover --timeout 4000
openclaw gateway discover --json | jq '.beacons[].wsUrl'
```
หมายเหตุ:
- CLI จะสแกน `local.` รวมถึงโดเมนแบบวงกว้างที่กำหนดค่าไว้เมื่อมีการเปิดใช้งาน
- `wsUrl` ในเอาต์พุต JSON ได้มาจาก endpoint ของบริการที่ resolve แล้ว ไม่ได้มาจากคำใบ้ที่มีเฉพาะ TXT เช่น `lanHost` หรือ `tailnetDns`
- บน `local.` mDNS, `sshPort` และ `cliPath` จะถูกประกาศเฉพาะเมื่อ `discovery.mdns.mode` เป็น `full` เท่านั้น ส่วน Wide-Area DNS-SD จะยังคงเขียน `cliPath`; และ `sshPort` ก็ยังคงเป็นค่าที่ไม่บังคับเช่นกัน

40
docs/th/cli/health.md Normal file
View File

@ -0,0 +1,40 @@
---
read_when:
- คุณต้องการตรวจสอบสถานะสุขภาพของ Gateway ที่กำลังทำงานอยู่ได้อย่างรวดเร็ว
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw health` (สแนปช็อตสถานะสุขภาพของ Gateway ผ่าน RPC)
title: สุขภาพ
x-i18n:
generated_at: "2026-04-23T06:17:53Z"
model: gpt-5.4
provider: openai
source_hash: 4ed2b9ceefee6159cabaae9172d2d88174626456e7503d5d2bcd142634188ff0
source_path: cli/health.md
workflow: 15
---
# `openclaw health`
ดึงสถานะสุขภาพจาก Gateway ที่กำลังทำงานอยู่
ตัวเลือก:
- `--json`: เอาต์พุตที่เครื่องอ่านได้
- `--timeout <ms>`: เวลา timeout ของการเชื่อมต่อเป็นมิลลิวินาที (ค่าเริ่มต้น `10000`)
- `--verbose`: การบันทึกแบบ verbose
- `--debug`: นามแฝงของ `--verbose`
ตัวอย่าง:
```bash
openclaw health
openclaw health --json
openclaw health --timeout 2500
openclaw health --verbose
openclaw health --debug
```
หมายเหตุ:
- `openclaw health` ตามค่าเริ่มต้นจะขอให้ gateway ที่กำลังทำงานอยู่ส่งสแนปช็อตสถานะสุขภาพของมันมา เมื่อ gateway มีสแนปช็อตแคชใหม่อยู่แล้ว มันสามารถส่งเพย์โหลดที่แคชไว้นั้นกลับมาและรีเฟรชในเบื้องหลังได้
- `--verbose` จะบังคับให้ตรวจสอบแบบสด พิมพ์รายละเอียดการเชื่อมต่อของ gateway และขยายเอาต์พุตที่มนุษย์อ่านได้ให้ครอบคลุมทุกบัญชีและเอเจนต์ที่ตั้งค่าไว้
- เอาต์พุตจะรวม session stores รายเอเจนต์เมื่อมีการตั้งค่าหลายเอเจนต์

345
docs/th/cli/hooks.md Normal file
View File

@ -0,0 +1,345 @@
---
read_when:
- คุณต้องการจัดการ hooks ของเอเจนต์
- คุณต้องการตรวจสอบความพร้อมใช้งานของ hook หรือเปิดใช้งาน workspace hooks
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw hooks` (hooks ของเอเจนต์)
title: Hooks
x-i18n:
generated_at: "2026-04-23T06:18:09Z"
model: gpt-5.4
provider: openai
source_hash: a09978267783734aaf9bd8bf36aa365ca680a3652afb904db2e5b55dfa64dcd1
source_path: cli/hooks.md
workflow: 15
---
# `openclaw hooks`
จัดการ hooks ของเอเจนต์ (ระบบอัตโนมัติแบบขับเคลื่อนด้วยเหตุการณ์สำหรับคำสั่งอย่าง `/new`, `/reset` และการเริ่มต้น Gateway)
การรัน `openclaw hooks` โดยไม่ระบุคำสั่งย่อยจะเทียบเท่ากับ `openclaw hooks list`
ที่เกี่ยวข้อง:
- Hooks: [Hooks](/th/automation/hooks)
- Plugin hooks: [Plugin hooks](/th/plugins/architecture#provider-runtime-hooks)
## แสดง Hooks ทั้งหมด
```bash
openclaw hooks list
```
แสดง hooks ที่ค้นพบทั้งหมดจากไดเรกทอรี workspace, managed, extra และ bundled
การเริ่มต้น Gateway จะไม่โหลดตัวจัดการ hook ภายในจนกว่าจะมีการกำหนดค่า internal hook อย่างน้อยหนึ่งรายการ
**ตัวเลือก:**
- `--eligible`: แสดงเฉพาะ hooks ที่พร้อมใช้งาน (ตรงตามข้อกำหนด)
- `--json`: แสดงผลเป็น JSON
- `-v, --verbose`: แสดงข้อมูลโดยละเอียดรวมถึงข้อกำหนดที่ขาดหายไป
**ตัวอย่างเอาต์พุต:**
```
Hooks (4/4 ready)
Ready:
🚀 boot-md ✓ - Run BOOT.md on gateway startup
📎 bootstrap-extra-files ✓ - Inject extra workspace bootstrap files during agent bootstrap
📝 command-logger ✓ - Log all command events to a centralized audit file
💾 session-memory ✓ - Save session context to memory when /new or /reset command is issued
```
**ตัวอย่าง (verbose):**
```bash
openclaw hooks list --verbose
```
แสดงข้อกำหนดที่ขาดหายไปสำหรับ hooks ที่ยังไม่พร้อมใช้งาน
**ตัวอย่าง (JSON):**
```bash
openclaw hooks list --json
```
ส่งคืน JSON แบบมีโครงสร้างสำหรับการใช้งานเชิงโปรแกรม
## ดูข้อมูล Hook
```bash
openclaw hooks info <name>
```
แสดงข้อมูลโดยละเอียดของ hook ที่ระบุ
**อาร์กิวเมนต์:**
- `<name>`: ชื่อ hook หรือคีย์ของ hook (เช่น `session-memory`)
**ตัวเลือก:**
- `--json`: แสดงผลเป็น JSON
**ตัวอย่าง:**
```bash
openclaw hooks info session-memory
```
**เอาต์พุต:**
```
💾 session-memory ✓ Ready
Save session context to memory when /new or /reset command is issued
Details:
Source: openclaw-bundled
Path: /path/to/openclaw/hooks/bundled/session-memory/HOOK.md
Handler: /path/to/openclaw/hooks/bundled/session-memory/handler.ts
Homepage: https://docs.openclaw.ai/automation/hooks#session-memory
Events: command:new, command:reset
Requirements:
Config: ✓ workspace.dir
```
## ตรวจสอบความพร้อมของ Hooks
```bash
openclaw hooks check
```
แสดงสรุปสถานะความพร้อมของ hook (พร้อมใช้งานกี่รายการ เทียบกับยังไม่พร้อมกี่รายการ)
**ตัวเลือก:**
- `--json`: แสดงผลเป็น JSON
**ตัวอย่างเอาต์พุต:**
```
Hooks Status
Total hooks: 4
Ready: 4
Not ready: 0
```
## เปิดใช้งาน Hook
```bash
openclaw hooks enable <name>
```
เปิดใช้งาน hook ที่ระบุโดยเพิ่มเข้าไปใน config ของคุณ (ค่าเริ่มต้นคือ `~/.openclaw/openclaw.json`)
**หมายเหตุ:** workspace hooks จะถูกปิดใช้งานเป็นค่าเริ่มต้นจนกว่าจะเปิดใช้งานที่นี่หรือใน config hooks ที่จัดการโดย Plugin จะแสดง `plugin:<id>` ใน `openclaw hooks list` และไม่สามารถเปิด/ปิดใช้งานได้จากที่นี่ ให้เปิด/ปิดใช้งาน Plugin นั้นแทน
**อาร์กิวเมนต์:**
- `<name>`: ชื่อ hook (เช่น `session-memory`)
**ตัวอย่าง:**
```bash
openclaw hooks enable session-memory
```
**เอาต์พุต:**
```
✓ Enabled hook: 💾 session-memory
```
**สิ่งที่ทำ:**
- ตรวจสอบว่า hook มีอยู่และพร้อมใช้งาน
- อัปเดต `hooks.internal.entries.<name>.enabled = true` ใน config ของคุณ
- บันทึก config ลงดิสก์
หาก hook มาจาก `<workspace>/hooks/` ต้องมีขั้นตอน opt-in นี้ก่อน
Gateway จึงจะโหลดมันได้
**หลังจากเปิดใช้งาน:**
- รีสตาร์ท gateway เพื่อให้ hooks โหลดใหม่ (รีสตาร์ทแอปเมนูบาร์บน macOS หรือรีสตาร์ทโปรเซส gateway ของคุณในโหมด dev)
## ปิดใช้งาน Hook
```bash
openclaw hooks disable <name>
```
ปิดใช้งาน hook ที่ระบุโดยอัปเดต config ของคุณ
**อาร์กิวเมนต์:**
- `<name>`: ชื่อ hook (เช่น `command-logger`)
**ตัวอย่าง:**
```bash
openclaw hooks disable command-logger
```
**เอาต์พุต:**
```
⏸ Disabled hook: 📝 command-logger
```
**หลังจากปิดใช้งาน:**
- รีสตาร์ท gateway เพื่อให้ hooks โหลดใหม่
## หมายเหตุ
- `openclaw hooks list --json`, `info --json` และ `check --json` จะเขียน JSON แบบมีโครงสร้างลง stdout โดยตรง
- hooks ที่จัดการโดย Plugin ไม่สามารถเปิดหรือปิดใช้งานได้จากที่นี่; ให้เปิดหรือปิดใช้งาน Plugin เจ้าของแทน
## ติดตั้ง Hook Packs
```bash
openclaw plugins install <package> # ClawHub ก่อน แล้วจึง npm
openclaw plugins install <package> --pin # ตรึงเวอร์ชัน
openclaw plugins install <path> # พาธในเครื่อง
```
ติดตั้ง hook packs ผ่านตัวติดตั้ง plugins แบบรวมศูนย์
`openclaw hooks install` ยังใช้ได้ในฐานะนามแฝงเพื่อความเข้ากันได้ แต่จะพิมพ์
คำเตือนการเลิกใช้งานและส่งต่อไปยัง `openclaw plugins install`
สเปก npm เป็นแบบ **registry-only** (ชื่อแพ็กเกจ + **เวอร์ชันแบบตรงตัว** หรือ
**dist-tag** แบบไม่บังคับ) ระบบจะปฏิเสธสเปกแบบ Git/URL/file และช่วง semver
การติดตั้ง dependency จะรันพร้อม `--ignore-scripts` เพื่อความปลอดภัย
สเปกเปล่าและ `@latest` จะอยู่ในสายเสถียร หาก npm resolve อย่างใดอย่างหนึ่ง
เหล่านั้นไปเป็นรุ่น prerelease, OpenClaw จะหยุดและขอให้คุณ opt in อย่างชัดเจนด้วย
แท็ก prerelease เช่น `@beta`/`@rc` หรือเวอร์ชัน prerelease แบบตรงตัว
**สิ่งที่ทำ:**
- คัดลอก hook pack ไปยัง `~/.openclaw/hooks/<id>`
- เปิดใช้งาน hooks ที่ติดตั้งใน `hooks.internal.entries.*`
- บันทึกการติดตั้งไว้ภายใต้ `hooks.internal.installs`
**ตัวเลือก:**
- `-l, --link`: ลิงก์ไดเรกทอรีในเครื่องแทนการคัดลอก (เพิ่มเข้าไปใน `hooks.internal.load.extraDirs`)
- `--pin`: บันทึกการติดตั้ง npm เป็น `name@version` ที่ resolve แล้วแบบตรงตัวใน `hooks.internal.installs`
**ไฟล์บีบอัดที่รองรับ:** `.zip`, `.tgz`, `.tar.gz`, `.tar`
**ตัวอย่าง:**
```bash
# ไดเรกทอรีในเครื่อง
openclaw plugins install ./my-hook-pack
# ไฟล์บีบอัดในเครื่อง
openclaw plugins install ./my-hook-pack.zip
# แพ็กเกจ NPM
openclaw plugins install @openclaw/my-hook-pack
# ลิงก์ไดเรกทอรีในเครื่องโดยไม่คัดลอก
openclaw plugins install -l ./my-hook-pack
```
hook packs ที่ลิงก์ไว้จะถือเป็น managed hooks จากไดเรกทอรี
ที่ผู้ดูแลระบบกำหนดค่าไว้ ไม่ใช่ workspace hooks
## อัปเดต Hook Packs
```bash
openclaw plugins update <id>
openclaw plugins update --all
```
อัปเดต hook packs แบบ npm ที่ติดตามไว้ผ่านตัวอัปเดต plugins แบบรวมศูนย์
`openclaw hooks update` ยังใช้ได้ในฐานะนามแฝงเพื่อความเข้ากันได้ แต่จะพิมพ์
คำเตือนการเลิกใช้งานและส่งต่อไปยัง `openclaw plugins update`
**ตัวเลือก:**
- `--all`: อัปเดต hook packs ที่ติดตามไว้ทั้งหมด
- `--dry-run`: แสดงสิ่งที่จะเปลี่ยนโดยไม่เขียนข้อมูล
เมื่อมีแฮชความถูกต้องที่บันทึกไว้และแฮชของอาร์ติแฟกต์ที่ดึงมาเปลี่ยนไป
OpenClaw จะพิมพ์คำเตือนและขอการยืนยันก่อนดำเนินการต่อ ใช้
`--yes` แบบ global เพื่อข้ามพร้อมท์ใน CI/การรันแบบไม่โต้ตอบ
## Bundled Hooks
### session-memory
บันทึกบริบทของเซสชันลงหน่วยความจำเมื่อคุณใช้ `/new` หรือ `/reset`
**เปิดใช้งาน:**
```bash
openclaw hooks enable session-memory
```
**เอาต์พุต:** `~/.openclaw/workspace/memory/YYYY-MM-DD-slug.md`
**ดูเพิ่มเติม:** [เอกสาร session-memory](/th/automation/hooks#session-memory)
### bootstrap-extra-files
แทรกไฟล์ bootstrap เพิ่มเติม (เช่น `AGENTS.md` / `TOOLS.md` ภายใน monorepo) ระหว่าง `agent:bootstrap`
**เปิดใช้งาน:**
```bash
openclaw hooks enable bootstrap-extra-files
```
**ดูเพิ่มเติม:** [เอกสาร bootstrap-extra-files](/th/automation/hooks#bootstrap-extra-files)
### command-logger
บันทึกเหตุการณ์คำสั่งทั้งหมดลงในไฟล์ audit ส่วนกลาง
**เปิดใช้งาน:**
```bash
openclaw hooks enable command-logger
```
**เอาต์พุต:** `~/.openclaw/logs/commands.log`
**ดูบันทึก:**
```bash
# คำสั่งล่าสุด
tail -n 20 ~/.openclaw/logs/commands.log
# แสดงผลให้อ่านง่าย
cat ~/.openclaw/logs/commands.log | jq .
# กรองตาม action
grep '"action":"new"' ~/.openclaw/logs/commands.log | jq .
```
**ดูเพิ่มเติม:** [เอกสาร command-logger](/th/automation/hooks#command-logger)
### boot-md
รัน `BOOT.md` เมื่อ gateway เริ่มต้น (หลังจาก channels เริ่มทำงานแล้ว)
**เหตุการณ์**: `gateway:startup`
**เปิดใช้งาน**:
```bash
openclaw hooks enable boot-md
```
**ดูเพิ่มเติม:** [เอกสาร boot-md](/th/automation/hooks#boot-md)

1845
docs/th/cli/index.md Normal file

File diff suppressed because it is too large Load Diff

290
docs/th/cli/infer.md Normal file
View File

@ -0,0 +1,290 @@
---
read_when:
- การเพิ่มหรือแก้ไขคำสั่ง `openclaw infer`
- การออกแบบระบบอัตโนมัติด้านความสามารถแบบ headless ที่เสถียร
summary: CLI แบบ infer-first สำหรับเวิร์กโฟลว์ model, image, audio, TTS, video, web และ embedding ที่ขับเคลื่อนด้วย provider
title: Inference CLI
x-i18n:
generated_at: "2026-04-23T06:18:13Z"
model: gpt-5.4
provider: openai
source_hash: e57d2438d0da24e1ed880bbacd244ede4af56beba4ac1baa3f2a1e393e641c9c
source_path: cli/infer.md
workflow: 15
---
# Inference CLI
`openclaw infer` คือพื้นผิวแบบ headless มาตรฐานสำหรับเวิร์กโฟลว์ inference ที่ขับเคลื่อนด้วย provider
โดยเจตนาแล้ว คำสั่งนี้จะเปิดเผยเป็นตระกูลความสามารถ ไม่ใช่ชื่อ gateway RPC แบบดิบ และไม่ใช่ raw agent tool ids
## เปลี่ยน infer ให้เป็น skill
คัดลอกและวางสิ่งนี้ให้กับ agent:
```text
Read https://docs.openclaw.ai/cli/infer, then create a skill that routes my common workflows to `openclaw infer`.
Focus on model runs, image generation, video generation, audio transcription, TTS, web search, and embeddings.
```
skill ที่อิง infer ที่ดีควร:
- แมปเจตนาทั่วไปของผู้ใช้ไปยังคำสั่งย่อย infer ที่ถูกต้อง
- มีตัวอย่าง infer มาตรฐานไม่กี่ตัวอย่างสำหรับเวิร์กโฟลว์ที่ครอบคลุม
- ใช้ `openclaw infer ...` ในตัวอย่างและคำแนะนำเป็นหลัก
- หลีกเลี่ยงการทำเอกสารพื้นผิว infer ทั้งหมดซ้ำอีกครั้งภายในเนื้อหา skill
ขอบเขตของ skill ที่มุ่งเน้น infer โดยทั่วไป:
- `openclaw infer model run`
- `openclaw infer image generate`
- `openclaw infer audio transcribe`
- `openclaw infer tts convert`
- `openclaw infer web search`
- `openclaw infer embedding create`
## เหตุผลที่ควรใช้ infer
`openclaw infer` มอบ CLI แบบสอดคล้องกันหนึ่งเดียวสำหรับงาน inference ที่ขับเคลื่อนด้วย provider ภายใน OpenClaw
ข้อดี:
- ใช้ providers และ models ที่ตั้งค่าไว้แล้วใน OpenClaw แทนการต่อ wrapper แบบใช้ครั้งเดียวสำหรับแต่ละ backend
- จัดเวิร์กโฟลว์ model, image, audio transcription, TTS, video, web และ embedding ไว้ภายใต้โครงคำสั่งเดียว
- ใช้รูปแบบเอาต์พุต `--json` ที่เสถียรสำหรับสคริปต์ ระบบอัตโนมัติ และเวิร์กโฟลว์ที่ขับเคลื่อนด้วย agent
- ใช้พื้นผิวของ OpenClaw ที่เป็น first-party เมื่อภารกิจนั้นโดยพื้นฐานคือ "รัน inference"
- ใช้เส้นทาง local ตามปกติได้โดยไม่ต้องใช้ Gateway สำหรับคำสั่ง infer ส่วนใหญ่
## โครงคำสั่ง
```text
openclaw infer
list
inspect
model
run
list
inspect
providers
auth login
auth logout
auth status
image
generate
edit
describe
describe-many
providers
audio
transcribe
providers
tts
convert
voices
providers
status
enable
disable
set-provider
video
generate
describe
providers
web
search
fetch
providers
embedding
create
providers
```
## งานที่พบบ่อย
ตารางนี้แมปงาน inference ที่พบบ่อยไปยังคำสั่ง infer ที่เกี่ยวข้อง
| งาน | คำสั่ง | หมายเหตุ |
| ----------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------- |
| รันพรอมป์ต์ข้อความ/โมเดล | `openclaw infer model run --prompt "..." --json` | ใช้เส้นทาง local ตามปกติโดยค่าเริ่มต้น |
| สร้างภาพ | `openclaw infer image generate --prompt "..." --json` | ใช้ `image edit` เมื่อต้องเริ่มจากไฟล์ที่มีอยู่ |
| อธิบายไฟล์ภาพ | `openclaw infer image describe --file ./image.png --json` | `--model` ต้องเป็น `<provider/model>` ที่รองรับภาพ |
| ถอดเสียงเสียง | `openclaw infer audio transcribe --file ./memo.m4a --json` | `--model` ต้องเป็น `<provider/model>` |
| สังเคราะห์เสียงพูด | `openclaw infer tts convert --text "..." --output ./speech.mp3 --json` | `tts status` มุ่งเน้นไปที่ gateway |
| สร้างวิดีโอ | `openclaw infer video generate --prompt "..." --json` | |
| อธิบายไฟล์วิดีโอ | `openclaw infer video describe --file ./clip.mp4 --json` | `--model` ต้องเป็น `<provider/model>` |
| ค้นหาเว็บ | `openclaw infer web search --query "..." --json` | |
| ดึงหน้าเว็บ | `openclaw infer web fetch --url https://example.com --json` | |
| สร้าง embeddings | `openclaw infer embedding create --text "..." --json` | |
## พฤติกรรม
- `openclaw infer ...` เป็นพื้นผิว CLI หลักสำหรับเวิร์กโฟลว์เหล่านี้
- ใช้ `--json` เมื่อเอาต์พุตจะถูกนำไปใช้โดยคำสั่งหรือสคริปต์อื่น
- ใช้ `--provider` หรือ `--model provider/model` เมื่อต้องใช้ backend เฉพาะ
- สำหรับ `image describe`, `audio transcribe` และ `video describe`, `--model` ต้องอยู่ในรูปแบบ `<provider/model>`
- สำหรับ `image describe`, การระบุ `--model` อย่างชัดเจนจะรัน provider/model นั้นโดยตรง โมเดลต้องรองรับภาพใน model catalog หรือ config ของ provider
- คำสั่ง execution แบบไร้ state ใช้ local โดยค่าเริ่มต้น
- คำสั่ง state ที่จัดการโดย Gateway ใช้ gateway โดยค่าเริ่มต้น
- เส้นทาง local ตามปกติไม่จำเป็นต้องให้ gateway กำลังรันอยู่
## Model
ใช้ `model` สำหรับ text inference ที่ขับเคลื่อนด้วย provider และการตรวจสอบ model/provider
```bash
openclaw infer model run --prompt "Reply with exactly: smoke-ok" --json
openclaw infer model run --prompt "Summarize this changelog entry" --provider openai --json
openclaw infer model providers --json
openclaw infer model inspect --name gpt-5.4 --json
```
หมายเหตุ:
- `model run` ใช้ runtime ของ agent ซ้ำ ดังนั้นการ override provider/model จะทำงานเหมือนการรัน agent ตามปกติ
- `model auth login`, `model auth logout` และ `model auth status` ใช้จัดการสถานะ auth ของ provider ที่บันทึกไว้
## Image
ใช้ `image` สำหรับการสร้าง การแก้ไข และการอธิบาย
```bash
openclaw infer image generate --prompt "friendly lobster illustration" --json
openclaw infer image generate --prompt "cinematic product photo of headphones" --json
openclaw infer image describe --file ./photo.jpg --json
openclaw infer image describe --file ./ui-screenshot.png --model openai/gpt-4.1-mini --json
openclaw infer image describe --file ./photo.jpg --model ollama/qwen2.5vl:7b --json
```
หมายเหตุ:
- ใช้ `image edit` เมื่อต้องเริ่มจากไฟล์อินพุตที่มีอยู่
- สำหรับ `image describe`, `--model` ต้องเป็น `<provider/model>` ที่รองรับภาพ
- สำหรับโมเดล vision ของ Ollama แบบ local ให้ดึงโมเดลก่อน แล้วตั้งค่า `OLLAMA_API_KEY` เป็นค่า placeholder ใดก็ได้ เช่น `ollama-local` ดู [Ollama](/th/providers/ollama#vision-and-image-description)
## Audio
ใช้ `audio` สำหรับการถอดเสียงจากไฟล์
```bash
openclaw infer audio transcribe --file ./memo.m4a --json
openclaw infer audio transcribe --file ./team-sync.m4a --language en --prompt "Focus on names and action items" --json
openclaw infer audio transcribe --file ./memo.m4a --model openai/whisper-1 --json
```
หมายเหตุ:
- `audio transcribe` ใช้สำหรับการถอดเสียงจากไฟล์ ไม่ใช่การจัดการเซสชันแบบเรียลไทม์
- `--model` ต้องเป็น `<provider/model>`
## TTS
ใช้ `tts` สำหรับการสังเคราะห์เสียงพูดและสถานะ provider ของ TTS
```bash
openclaw infer tts convert --text "hello from openclaw" --output ./hello.mp3 --json
openclaw infer tts convert --text "Your build is complete" --output ./build-complete.mp3 --json
openclaw infer tts providers --json
openclaw infer tts status --json
```
หมายเหตุ:
- `tts status` ใช้ gateway โดยค่าเริ่มต้น เพราะสะท้อนสถานะ TTS ที่จัดการโดย gateway
- ใช้ `tts providers`, `tts voices` และ `tts set-provider` เพื่อตรวจสอบและกำหนดค่าพฤติกรรมของ TTS
## Video
ใช้ `video` สำหรับการสร้างและการอธิบาย
```bash
openclaw infer video generate --prompt "cinematic sunset over the ocean" --json
openclaw infer video generate --prompt "slow drone shot over a forest lake" --json
openclaw infer video describe --file ./clip.mp4 --json
openclaw infer video describe --file ./clip.mp4 --model openai/gpt-4.1-mini --json
```
หมายเหตุ:
- `--model` ต้องเป็น `<provider/model>` สำหรับ `video describe`
## Web
ใช้ `web` สำหรับเวิร์กโฟลว์การค้นหาและการดึงข้อมูล
```bash
openclaw infer web search --query "OpenClaw docs" --json
openclaw infer web search --query "OpenClaw infer web providers" --json
openclaw infer web fetch --url https://docs.openclaw.ai/cli/infer --json
openclaw infer web providers --json
```
หมายเหตุ:
- ใช้ `web providers` เพื่อตรวจสอบ providers ที่พร้อมใช้งาน ที่ตั้งค่าไว้ และที่ถูกเลือก
## Embedding
ใช้ `embedding` สำหรับการสร้างเวกเตอร์และการตรวจสอบ embedding provider
```bash
openclaw infer embedding create --text "friendly lobster" --json
openclaw infer embedding create --text "customer support ticket: delayed shipment" --model openai/text-embedding-3-large --json
openclaw infer embedding providers --json
```
## เอาต์พุต JSON
คำสั่ง infer จะปรับเอาต์พุต JSON ให้อยู่ภายใต้ envelope ที่ใช้ร่วมกัน:
```json
{
"ok": true,
"capability": "image.generate",
"transport": "local",
"provider": "openai",
"model": "gpt-image-2",
"attempts": [],
"outputs": []
}
```
ฟิลด์ระดับบนสุดมีความเสถียร:
- `ok`
- `capability`
- `transport`
- `provider`
- `model`
- `attempts`
- `outputs`
- `error`
## จุดพลาดที่พบบ่อย
```bash
# Bad
openclaw infer media image generate --prompt "friendly lobster"
# Good
openclaw infer image generate --prompt "friendly lobster"
```
```bash
# Bad
openclaw infer audio transcribe --file ./memo.m4a --model whisper-1 --json
# Good
openclaw infer audio transcribe --file ./memo.m4a --model openai/whisper-1 --json
```
## หมายเหตุ
- `openclaw capability ...` เป็นชื่อเรียกแทนของ `openclaw infer ...`

66
docs/th/cli/logs.md Normal file
View File

@ -0,0 +1,66 @@
---
read_when:
- คุณต้องติดตามล็อกของ Gateway จากระยะไกล (โดยไม่ใช้ SSH)
- คุณต้องการบรรทัดล็อกแบบ JSON สำหรับเครื่องมือ
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw logs` (ติดตามล็อก Gateway แบบต่อท้ายผ่าน RPC)
title: บันทึก日志
x-i18n:
generated_at: "2026-04-23T06:18:16Z"
model: gpt-5.4
provider: openai
source_hash: 238a52e31a9a332cab513ced049e92d032b03c50376895ce57dffa2ee7d1e4b4
source_path: cli/logs.md
workflow: 15
---
# `openclaw logs`
ติดตามล็อกไฟล์ของ Gateway แบบต่อท้ายผ่าน RPC (ทำงานได้ในโหมด remote)
ที่เกี่ยวข้อง:
- ภาพรวมการบันทึกล็อก: [การบันทึกล็อก](/th/logging)
- Gateway CLI: [gateway](/th/cli/gateway)
## ตัวเลือก
- `--limit <n>`: จำนวนบรรทัดล็อกสูงสุดที่จะส่งกลับ (ค่าเริ่มต้น `200`)
- `--max-bytes <n>`: จำนวนไบต์สูงสุดที่จะอ่านจากไฟล์ล็อก (ค่าเริ่มต้น `250000`)
- `--follow`: ติดตามสตรีมล็อกต่อเนื่อง
- `--interval <ms>`: ช่วงเวลา polling ขณะติดตาม (ค่าเริ่มต้น `1000`)
- `--json`: ส่งอีเวนต์ JSON แบบหนึ่งบรรทัดต่อหนึ่งรายการ
- `--plain`: เอาต์พุตข้อความธรรมดาโดยไม่มีการจัดรูปแบบสไตล์
- `--no-color`: ปิดใช้งานสี ANSI
- `--local-time`: แสดงผลการประทับเวลาในเขตเวลาท้องถิ่นของคุณ
## ตัวเลือก Gateway RPC ที่ใช้ร่วมกัน
`openclaw logs` รองรับแฟล็กไคลเอนต์ Gateway มาตรฐานด้วย:
- `--url <url>`: URL WebSocket ของ Gateway
- `--token <token>`: โทเค็นของ Gateway
- `--timeout <ms>`: หมดเวลาเป็นมิลลิวินาที (ค่าเริ่มต้น `30000`)
- `--expect-final`: รอการตอบกลับสุดท้ายเมื่อการเรียก Gateway ทำงานผ่าน agent
เมื่อคุณส่ง `--url` CLI จะไม่ใช้ข้อมูลรับรองจากคอนฟิกหรือสภาพแวดล้อมโดยอัตโนมัติ หาก Gateway เป้าหมายต้องใช้การยืนยันตัวตน ให้ระบุ `--token` อย่างชัดเจน
## ตัวอย่าง
```bash
openclaw logs
openclaw logs --follow
openclaw logs --follow --interval 2000
openclaw logs --limit 500 --max-bytes 500000
openclaw logs --json
openclaw logs --plain
openclaw logs --no-color
openclaw logs --limit 500
openclaw logs --local-time
openclaw logs --follow --local-time
openclaw logs --url ws://127.0.0.1:18789 --token "$OPENCLAW_GATEWAY_TOKEN"
```
## หมายเหตุ
- ใช้ `--local-time` เพื่อแสดงผลการประทับเวลาในเขตเวลาท้องถิ่นของคุณ
- หาก local loopback Gateway ขอการจับคู่ `openclaw logs` จะกลับไปใช้ไฟล์ล็อกในเครื่องที่ตั้งค่าไว้โดยอัตโนมัติ เป้าหมาย `--url` แบบระบุชัดเจนจะไม่ใช้ fallback นี้

513
docs/th/cli/mcp.md Normal file
View File

@ -0,0 +1,513 @@
---
read_when:
- กำลังเชื่อมต่อ Codex, Claude Code หรือไคลเอนต์ MCP อื่นกับช่องทางที่ขับเคลื่อนโดย OpenClaw
- กำลังรัน `openclaw mcp serve`
- กำลังจัดการคำจำกัดความเซิร์ฟเวอร์ MCP ที่ OpenClaw บันทึกไว้
summary: เปิดเผยการสนทนาของช่องทาง OpenClaw ผ่าน MCP และจัดการคำจำกัดความเซิร์ฟเวอร์ MCP ที่บันทึกไว้
title: mcp
x-i18n:
generated_at: "2026-04-23T06:18:23Z"
model: gpt-5.4
provider: openai
source_hash: bbc528a7490132f4b505f62bdc4556602243a5e27557c4965c2e1d4f80ad00bd
source_path: cli/mcp.md
workflow: 15
---
# mcp
`openclaw mcp` มี 2 หน้าที่:
- รัน OpenClaw เป็นเซิร์ฟเวอร์ MCP ด้วย `openclaw mcp serve`
- จัดการคำจำกัดความเซิร์ฟเวอร์ MCP ขาออกที่ OpenClaw เป็นเจ้าของด้วย `list`, `show`,
`set` และ `unset`
กล่าวอีกนัยหนึ่ง:
- `serve` คือ OpenClaw ทำหน้าที่เป็นเซิร์ฟเวอร์ MCP
- `list` / `show` / `set` / `unset` คือ OpenClaw ทำหน้าที่เป็นรีจิสทรีฝั่งไคลเอนต์ MCP
สำหรับเซิร์ฟเวอร์ MCP อื่นที่ runtime ของมันอาจนำไปใช้ภายหลัง
ใช้ [`openclaw acp`](/th/cli/acp) เมื่อ OpenClaw ควรโฮสต์
เซสชัน coding harness เองและกำหนดเส้นทาง runtime นั้นผ่าน ACP
## OpenClaw ในฐานะเซิร์ฟเวอร์ MCP
นี่คือเส้นทาง `openclaw mcp serve`
## เมื่อใดควรใช้ `serve`
ใช้ `openclaw mcp serve` เมื่อ:
- Codex, Claude Code หรือไคลเอนต์ MCP อื่นควรสื่อสารโดยตรงกับ
การสนทนาของช่องทางที่ขับเคลื่อนโดย OpenClaw
- คุณมี OpenClaw Gateway แบบ local หรือ remote พร้อมเซสชันที่กำหนดเส้นทางไว้แล้ว
- คุณต้องการเซิร์ฟเวอร์ MCP หนึ่งตัวที่ทำงานได้กับแบ็กเอนด์ช่องทางของ OpenClaw
แทนการรันบริดจ์แยกตามแต่ละช่องทาง
ให้ใช้ [`openclaw acp`](/th/cli/acp) แทนเมื่อ OpenClaw ควรโฮสต์ coding
runtime เองและเก็บเซสชัน agent ไว้ภายใน OpenClaw
## วิธีการทำงาน
`openclaw mcp serve` จะเริ่มเซิร์ฟเวอร์ MCP แบบ stdio โดยไคลเอนต์ MCP เป็นผู้ถือครอง
process นั้น ระหว่างที่ไคลเอนต์เปิดเซสชัน stdio ไว้ บริดจ์จะเชื่อมต่อกับ
OpenClaw Gateway แบบ local หรือ remote ผ่าน WebSocket และเปิดเผย
การสนทนาของช่องทางที่กำหนดเส้นทางไว้ผ่าน MCP
วงจรการทำงาน:
1. ไคลเอนต์ MCP สร้าง process `openclaw mcp serve`
2. บริดจ์เชื่อมต่อกับ Gateway
3. เซสชันที่กำหนดเส้นทางไว้จะกลายเป็นการสนทนา MCP และเครื่องมือ transcript/history
4. อีเวนต์แบบสดจะถูกคิวไว้ในหน่วยความจำขณะที่บริดจ์ยังเชื่อมต่ออยู่
5. หากเปิดโหมดช่องทาง Claude เซสชันเดียวกันนี้ยังสามารถรับ
การแจ้งเตือนแบบ push ที่เฉพาะกับ Claude ได้ด้วย
พฤติกรรมสำคัญ:
- สถานะคิวแบบสดจะเริ่มต้นเมื่อบริดจ์เชื่อมต่อ
- ประวัติ transcript เก่าจะอ่านด้วย `messages_read`
- การแจ้งเตือนแบบ push ของ Claude จะมีอยู่เฉพาะขณะที่เซสชัน MCP ยังทำงานอยู่
- เมื่อไคลเอนต์ตัดการเชื่อมต่อ บริดจ์จะออกจากโปรแกรมและคิวแบบสดจะหายไป
## เลือกโหมดไคลเอนต์
ใช้บริดจ์ตัวเดียวกันได้ 2 วิธี:
- ไคลเอนต์ MCP ทั่วไป: ใช้เฉพาะเครื่องมือ MCP มาตรฐาน ใช้ `conversations_list`,
`messages_read`, `events_poll`, `events_wait`, `messages_send` และ
เครื่องมืออนุมัติ
- Claude Code: ใช้เครื่องมือ MCP มาตรฐานร่วมกับตัวเชื่อมต่อช่องทางที่เฉพาะกับ Claude
เปิดใช้ `--claude-channel-mode on` หรือใช้ค่าเริ่มต้น `auto`
ปัจจุบัน `auto` ทำงานเหมือนกับ `on` ยังไม่มีการตรวจจับความสามารถของไคลเอนต์
## สิ่งที่ `serve` เปิดเผย
บริดจ์ใช้เมทาดาทาการกำหนดเส้นทางของเซสชันใน Gateway ที่มีอยู่แล้วเพื่อเปิดเผย
การสนทนาที่มีแบ็กเอนด์เป็นช่องทาง การสนทนาจะปรากฏเมื่อ OpenClaw มีสถานะเซสชัน
พร้อมเส้นทางที่ทราบแล้ว เช่น:
- `channel`
- เมทาดาทาผู้รับหรือปลายทาง
- `accountId` แบบไม่บังคับ
- `threadId` แบบไม่บังคับ
สิ่งนี้ทำให้ไคลเอนต์ MCP มีจุดเดียวสำหรับ:
- แสดงรายการการสนทนาที่กำหนดเส้นทางไว้ล่าสุด
- อ่านประวัติ transcript ล่าสุด
- รออีเวนต์ขาเข้าใหม่
- ส่งคำตอบกลับผ่านเส้นทางเดิม
- ดูคำขออนุมัติที่เข้ามาขณะที่บริดจ์เชื่อมต่ออยู่
## การใช้งาน
```bash
# Gateway แบบ local
openclaw mcp serve
# Gateway แบบ remote
openclaw mcp serve --url wss://gateway-host:18789 --token-file ~/.openclaw/gateway.token
# Gateway แบบ remote พร้อมการยืนยันตัวตนด้วยรหัสผ่าน
openclaw mcp serve --url wss://gateway-host:18789 --password-file ~/.openclaw/gateway.password
# เปิดใช้ log ของบริดจ์แบบละเอียด
openclaw mcp serve --verbose
# ปิดการแจ้งเตือนแบบ push ที่เฉพาะกับ Claude
openclaw mcp serve --claude-channel-mode off
```
## เครื่องมือของบริดจ์
ปัจจุบันบริดจ์เปิดเผยเครื่องมือ MCP เหล่านี้:
- `conversations_list`
- `conversation_get`
- `messages_read`
- `attachments_fetch`
- `events_poll`
- `events_wait`
- `messages_send`
- `permissions_list_open`
- `permissions_respond`
### `conversations_list`
แสดงรายการการสนทนาล่าสุดที่มีแบ็กเอนด์เป็นเซสชันและมีเมทาดาทาเส้นทางอยู่แล้วใน
สถานะเซสชันของ Gateway
ตัวกรองที่มีประโยชน์:
- `limit`
- `search`
- `channel`
- `includeDerivedTitles`
- `includeLastMessage`
### `conversation_get`
ส่งคืนการสนทนาหนึ่งรายการตาม `session_key`
### `messages_read`
อ่านข้อความ transcript ล่าสุดสำหรับการสนทนาหนึ่งรายการที่มีแบ็กเอนด์เป็นเซสชัน
### `attachments_fetch`
แยกบล็อกเนื้อหาข้อความที่ไม่ใช่ข้อความล้วนออกจากข้อความ transcript หนึ่งรายการ นี่เป็น
มุมมองเมทาดาทาเหนือเนื้อหา transcript ไม่ใช่ที่เก็บ attachment blob แบบถาวรแยกต่างหาก
### `events_poll`
อ่านอีเวนต์แบบสดที่อยู่ในคิวนับจาก cursor แบบตัวเลข
### `events_wait`
ทำ long-poll จนกว่าอีเวนต์ที่ตรงเงื่อนไขรายการถัดไปในคิวจะมาถึงหรือจนหมดเวลา
ใช้สิ่งนี้เมื่อไคลเอนต์ MCP ทั่วไปต้องการการส่งแบบเกือบเรียลไทม์โดยไม่ใช้
โปรโตคอล push ที่เฉพาะกับ Claude
### `messages_send`
ส่งข้อความกลับผ่านเส้นทางเดิมที่บันทึกไว้แล้วบนเซสชัน
พฤติกรรมปัจจุบัน:
- ต้องมีเส้นทางการสนทนาที่มีอยู่แล้ว
- ใช้ channel, recipient, account id และ thread id ของเซสชัน
- ส่งได้เฉพาะข้อความเท่านั้น
### `permissions_list_open`
แสดงรายการคำขออนุมัติ exec/plugin ที่รอดำเนินการซึ่งบริดจ์สังเกตพบตั้งแต่เชื่อมต่อกับ Gateway
### `permissions_respond`
จัดการคำขออนุมัติ exec/plugin ที่รอดำเนินการหนึ่งรายการด้วยค่า:
- `allow-once`
- `allow-always`
- `deny`
## โมเดลอีเวนต์
บริดจ์จะเก็บคิวอีเวนต์ไว้ในหน่วยความจำขณะที่ยังเชื่อมต่ออยู่
ประเภทอีเวนต์ปัจจุบัน:
- `message`
- `exec_approval_requested`
- `exec_approval_resolved`
- `plugin_approval_requested`
- `plugin_approval_resolved`
- `claude_permission_request`
ข้อจำกัดสำคัญ:
- คิวเป็นแบบสดเท่านั้น; จะเริ่มเมื่อบริดจ์ MCP เริ่มทำงาน
- `events_poll` และ `events_wait` จะไม่เล่นประวัติ Gateway เก่าย้อนหลัง
ด้วยตัวเอง
- backlog แบบถาวรควรอ่านด้วย `messages_read`
## การแจ้งเตือนช่องทาง Claude
บริดจ์ยังสามารถเปิดเผยการแจ้งเตือนช่องทางที่เฉพาะกับ Claude ได้ด้วย นี่คือ
สิ่งที่เทียบเท่ากับตัวเชื่อมต่อช่องทางของ Claude Code ใน OpenClaw: เครื่องมือ MCP มาตรฐานยังคงใช้ได้
แต่ข้อความขาเข้าแบบสดยังสามารถเข้ามาเป็นการแจ้งเตือน MCP ที่เฉพาะกับ Claude ได้ด้วย
แฟล็ก:
- `--claude-channel-mode off`: ใช้เฉพาะเครื่องมือ MCP มาตรฐาน
- `--claude-channel-mode on`: เปิดใช้การแจ้งเตือนช่องทาง Claude
- `--claude-channel-mode auto`: ค่าเริ่มต้นปัจจุบัน; พฤติกรรมบริดจ์เหมือน `on`
เมื่อเปิดโหมดช่องทาง Claude เซิร์ฟเวอร์จะประกาศความสามารถแบบทดลองของ Claude
และสามารถปล่อย:
- `notifications/claude/channel`
- `notifications/claude/channel/permission`
พฤติกรรมบริดจ์ปัจจุบัน:
- ข้อความ transcript ขาเข้าแบบ `user` จะถูกส่งต่อเป็น
`notifications/claude/channel`
- คำขอสิทธิ์ของ Claude ที่ได้รับผ่าน MCP จะถูกติดตามไว้ในหน่วยความจำ
- หากการสนทนาที่เชื่อมโยงกันส่ง `yes abcde` หรือ `no abcde` ในภายหลัง บริดจ์
จะแปลงเป็น `notifications/claude/channel/permission`
- การแจ้งเตือนเหล่านี้มีเฉพาะในเซสชันแบบสดเท่านั้น; หากไคลเอนต์ MCP ตัดการเชื่อมต่อ
จะไม่มีปลายทางสำหรับ push
สิ่งนี้ตั้งใจให้เฉพาะกับไคลเอนต์ ไคลเอนต์ MCP ทั่วไปควรพึ่งพาเครื่องมือ polling มาตรฐาน
## การตั้งค่าไคลเอนต์ MCP
ตัวอย่างการตั้งค่าไคลเอนต์ stdio:
```json
{
"mcpServers": {
"openclaw": {
"command": "openclaw",
"args": [
"mcp",
"serve",
"--url",
"wss://gateway-host:18789",
"--token-file",
"/path/to/gateway.token"
]
}
}
}
```
สำหรับไคลเอนต์ MCP ทั่วไปส่วนใหญ่ ให้เริ่มจากพื้นผิวเครื่องมือมาตรฐานและไม่ต้องสนใจ
โหมด Claude เปิดโหมด Claude เฉพาะสำหรับไคลเอนต์ที่เข้าใจ
เมธอดการแจ้งเตือนที่เฉพาะกับ Claude จริงๆ เท่านั้น
## ตัวเลือก
`openclaw mcp serve` รองรับ:
- `--url <url>`: URL ของ Gateway WebSocket
- `--token <token>`: โทเค็น Gateway
- `--token-file <path>`: อ่านโทเค็นจากไฟล์
- `--password <password>`: รหัสผ่าน Gateway
- `--password-file <path>`: อ่านรหัสผ่านจากไฟล์
- `--claude-channel-mode <auto|on|off>`: โหมดการแจ้งเตือน Claude
- `-v`, `--verbose`: log แบบละเอียดไปยัง stderr
หากเป็นไปได้ ให้ใช้ `--token-file` หรือ `--password-file` แทนการใส่ความลับแบบ inline
## ความปลอดภัยและขอบเขตความเชื่อถือ
บริดจ์ไม่ได้สร้างการกำหนดเส้นทางขึ้นเอง มันเพียงเปิดเผยการสนทนาที่ Gateway
รู้วิธีกำหนดเส้นทางอยู่แล้ว
นั่นหมายความว่า:
- allowlist ผู้ส่ง การจับคู่ และความเชื่อถือระดับช่องทาง ยังคงเป็นหน้าที่ของ
การกำหนดค่าช่องทาง OpenClaw พื้นฐาน
- `messages_send` สามารถตอบกลับได้ผ่านเส้นทางที่จัดเก็บไว้เดิมเท่านั้น
- สถานะการอนุมัติเป็นแบบสด/อยู่ในหน่วยความจำเท่านั้นสำหรับเซสชันบริดจ์ปัจจุบัน
- การยืนยันตัวตนของบริดจ์ควรใช้การควบคุมโทเค็นหรือรหัสผ่าน Gateway แบบเดียวกับที่คุณจะเชื่อถือสำหรับไคลเอนต์ Gateway แบบ remote อื่นๆ
หากการสนทนาไม่ปรากฏใน `conversations_list` โดยทั่วไปสาเหตุไม่ใช่การตั้งค่า MCP
แต่เป็นเมทาดาทาเส้นทางที่ขาดหายหรือไม่สมบูรณ์ในเซสชัน Gateway พื้นฐาน
## การทดสอบ
OpenClaw มาพร้อม Docker smoke แบบกำหนดแน่นอนสำหรับบริดจ์นี้:
```bash
pnpm test:docker:mcp-channels
```
smoke นี้จะ:
- เริ่มคอนเทนเนอร์ Gateway ที่มีข้อมูลตั้งต้น
- เริ่มคอนเทนเนอร์ตัวที่สองที่สร้าง process `openclaw mcp serve`
- ตรวจสอบการค้นพบการสนทนา การอ่านข้อความ transcript การอ่านเมทาดาทา attachment
พฤติกรรมคิวอีเวนต์แบบสด และการกำหนดเส้นทางการส่งขาออก
- ตรวจสอบการแจ้งเตือนช่องทางและสิทธิ์แบบ Claude ผ่านบริดจ์ MCP แบบ stdio จริง
นี่เป็นวิธีที่เร็วที่สุดในการพิสูจน์ว่าบริดจ์ทำงานได้โดยไม่ต้องผูกบัญชี
Telegram, Discord หรือ iMessage จริงเข้ากับการรันทดสอบ
สำหรับบริบทการทดสอบที่กว้างขึ้น ดู [การทดสอบ](/th/help/testing)
## การแก้ปัญหา
### ไม่มีการสนทนาถูกส่งคืน
โดยทั่วไปหมายความว่าเซสชัน Gateway ยังไม่สามารถกำหนดเส้นทางได้ ยืนยันว่า
เซสชันพื้นฐานมีเมทาดาทาเส้นทาง channel/provider, recipient และ account/thread ที่เป็นตัวเลือก
ถูกจัดเก็บไว้แล้ว
### `events_poll` หรือ `events_wait` พลาดข้อความเก่า
เป็นพฤติกรรมที่คาดไว้ คิวแบบสดเริ่มเมื่อบริดจ์เชื่อมต่อ ให้อ่านประวัติ transcript
ที่เก่ากว่าด้วย `messages_read`
### การแจ้งเตือน Claude ไม่แสดงขึ้นมา
ตรวจสอบทั้งหมดนี้:
- ไคลเอนต์ยังคงเปิดเซสชัน stdio MCP ไว้
- `--claude-channel-mode` เป็น `on` หรือ `auto`
- ไคลเอนต์เข้าใจเมธอดการแจ้งเตือนที่เฉพาะกับ Claude จริง
- ข้อความขาเข้าเกิดขึ้นหลังจากบริดจ์เชื่อมต่อแล้ว
### ไม่มีการอนุมัติ
`permissions_list_open` จะแสดงเฉพาะคำขออนุมัติที่พบบริดจ์
ขณะเชื่อมต่ออยู่เท่านั้น มันไม่ใช่ API ประวัติการอนุมัติแบบถาวร
## OpenClaw ในฐานะรีจิสทรีไคลเอนต์ MCP
นี่คือเส้นทาง `openclaw mcp list`, `show`, `set` และ `unset`
คำสั่งเหล่านี้ไม่ได้เปิดเผย OpenClaw ผ่าน MCP แต่จัดการคำจำกัดความเซิร์ฟเวอร์ MCP
ที่ OpenClaw เป็นเจ้าของภายใต้ `mcp.servers` ใน config ของ OpenClaw
คำจำกัดความที่บันทึกไว้นั้นมีไว้สำหรับ runtime ที่ OpenClaw เปิดใช้หรือกำหนดค่าในภายหลัง
เช่น Pi แบบฝังตัว และตัวเชื่อมต่อ runtime อื่นๆ OpenClaw จัดเก็บ
คำจำกัดความเหล่านี้ไว้ส่วนกลางเพื่อให้ runtime เหล่านั้นไม่ต้องเก็บรายการ
เซิร์ฟเวอร์ MCP ที่ซ้ำกันของตนเอง
พฤติกรรมสำคัญ:
- คำสั่งเหล่านี้อ่านหรือเขียนเฉพาะ config ของ OpenClaw
- คำสั่งเหล่านี้ไม่เชื่อมต่อกับเซิร์ฟเวอร์ MCP เป้าหมาย
- คำสั่งเหล่านี้ไม่ตรวจสอบว่าคำสั่ง URL หรือ remote transport
เข้าถึงได้จริงในขณะนี้หรือไม่
- ตัวเชื่อมต่อ runtime เป็นผู้ตัดสินว่ารองรับรูปแบบ transport ใดจริง
ในเวลารัน
- Pi แบบฝังตัวจะเปิดเผยเครื่องมือ MCP ที่กำหนดค่าไว้ในโปรไฟล์เครื่องมือ `coding` และ `messaging`
ตามปกติ; `minimal` ยังคงซ่อนไว้ และ `tools.deny: ["bundle-mcp"]`
จะปิดใช้งานอย่างชัดเจน
## คำจำกัดความเซิร์ฟเวอร์ MCP ที่บันทึกไว้
OpenClaw ยังจัดเก็บรีจิสทรีเซิร์ฟเวอร์ MCP แบบเบาไว้ใน config สำหรับพื้นผิว
ที่ต้องการคำจำกัดความ MCP ที่ OpenClaw จัดการ
คำสั่ง:
- `openclaw mcp list`
- `openclaw mcp show [name]`
- `openclaw mcp set <name> <json>`
- `openclaw mcp unset <name>`
หมายเหตุ:
- `list` จะเรียงลำดับชื่อเซิร์ฟเวอร์
- `show` โดยไม่ระบุชื่อจะพิมพ์ออบเจ็กต์เซิร์ฟเวอร์ MCP ที่กำหนดค่าไว้ทั้งหมด
- `set` คาดหวังค่าออบเจ็กต์ JSON หนึ่งรายการบนบรรทัดคำสั่ง
- `unset` จะล้มเหลวหากไม่มีเซิร์ฟเวอร์ตามชื่อที่ระบุ
ตัวอย่าง:
```bash
openclaw mcp list
openclaw mcp show context7 --json
openclaw mcp set context7 '{"command":"uvx","args":["context7-mcp"]}'
openclaw mcp set docs '{"url":"https://mcp.example.com"}'
openclaw mcp unset context7
```
ตัวอย่างโครงสร้าง config:
```json
{
"mcp": {
"servers": {
"context7": {
"command": "uvx",
"args": ["context7-mcp"]
},
"docs": {
"url": "https://mcp.example.com"
}
}
}
}
```
### Stdio transport
เปิด process ลูกแบบ local และสื่อสารผ่าน stdin/stdout
| ฟิลด์ | คำอธิบาย |
| ------------------------- | ----------------------------------- |
| `command` | ไฟล์ปฏิบัติการที่จะสร้าง process (จำเป็น) |
| `args` | อาร์เรย์ของอาร์กิวเมนต์บรรทัดคำสั่ง |
| `env` | ตัวแปร environment เพิ่มเติม |
| `cwd` / `workingDirectory` | ไดเรกทอรีทำงานสำหรับ process |
#### ตัวกรองความปลอดภัยของ env สำหรับ Stdio
OpenClaw จะปฏิเสธคีย์ env สำหรับการเริ่มต้น interpreter ที่สามารถเปลี่ยนวิธีเริ่มต้นของเซิร์ฟเวอร์ MCP แบบ stdio ก่อน RPC แรกได้ แม้ว่าคีย์เหล่านั้นจะอยู่ในบล็อก `env` ของเซิร์ฟเวอร์ก็ตาม คีย์ที่ถูกบล็อกได้แก่ `NODE_OPTIONS`, `PYTHONSTARTUP`, `PYTHONPATH`, `PERL5OPT`, `RUBYOPT`, `SHELLOPTS`, `PS4` และตัวแปรควบคุม runtime ที่คล้ายกัน การเริ่มต้นจะปฏิเสธคีย์เหล่านี้ด้วยข้อผิดพลาดด้านการกำหนดค่า เพื่อไม่ให้คีย์เหล่านี้แทรก prelude โดยปริยาย สลับ interpreter หรือเปิดใช้ดีบักเกอร์กับ process stdio ได้ ตัวแปร env ทั่วไปสำหรับข้อมูลรับรอง พร็อกซี และตัวแปรเฉพาะเซิร์ฟเวอร์ (`GITHUB_TOKEN`, `HTTP_PROXY`, `*_API_KEY` แบบกำหนดเอง เป็นต้น) จะไม่ได้รับผลกระทบ
หากเซิร์ฟเวอร์ MCP ของคุณจำเป็นต้องใช้ตัวแปรที่ถูกบล็อกจริงๆ ให้ตั้งค่าตัวแปรนั้นบน process โฮสต์ของ Gateway แทนการตั้งไว้ใต้ `env` ของเซิร์ฟเวอร์ stdio
### การขนส่ง SSE / HTTP
เชื่อมต่อกับเซิร์ฟเวอร์ MCP แบบ remote ผ่าน HTTP Server-Sent Events
| ฟิลด์ | คำอธิบาย |
| -------------------- | ---------------------------------------------------------------- |
| `url` | URL แบบ HTTP หรือ HTTPS ของเซิร์ฟเวอร์ remote (จำเป็น) |
| `headers` | แมปคีย์-ค่าของ HTTP headers แบบไม่บังคับ (เช่น โทเค็นการยืนยันตัวตน) |
| `connectionTimeoutMs` | ระยะหมดเวลาการเชื่อมต่อรายเซิร์ฟเวอร์ในหน่วย ms (ไม่บังคับ) |
ตัวอย่าง:
```json
{
"mcp": {
"servers": {
"remote-tools": {
"url": "https://mcp.example.com",
"headers": {
"Authorization": "Bearer <token>"
}
}
}
}
}
```
ค่าที่มีความละเอียดอ่อนใน `url` (userinfo) และ `headers` จะถูกปกปิดใน log และ
เอาต์พุตสถานะ
### การขนส่ง Streamable HTTP
`streamable-http` เป็นตัวเลือก transport เพิ่มเติมควบคู่กับ `sse` และ `stdio` โดยใช้ HTTP streaming สำหรับการสื่อสารแบบสองทิศทางกับเซิร์ฟเวอร์ MCP แบบ remote
| ฟิลด์ | คำอธิบาย |
| -------------------- | ----------------------------------------------------------------------------------------- |
| `url` | URL แบบ HTTP หรือ HTTPS ของเซิร์ฟเวอร์ remote (จำเป็น) |
| `transport` | ตั้งเป็น `"streamable-http"` เพื่อเลือก transport นี้; หากละเว้น OpenClaw จะใช้ `sse` |
| `headers` | แมปคีย์-ค่าของ HTTP headers แบบไม่บังคับ (เช่น โทเค็นการยืนยันตัวตน) |
| `connectionTimeoutMs` | ระยะหมดเวลาการเชื่อมต่อรายเซิร์ฟเวอร์ในหน่วย ms (ไม่บังคับ) |
ตัวอย่าง:
```json
{
"mcp": {
"servers": {
"streaming-tools": {
"url": "https://mcp.example.com/stream",
"transport": "streamable-http",
"connectionTimeoutMs": 10000,
"headers": {
"Authorization": "Bearer <token>"
}
}
}
}
}
```
คำสั่งเหล่านี้จัดการเฉพาะ config ที่บันทึกไว้เท่านั้น คำสั่งเหล่านี้จะไม่เริ่มบริดจ์ของช่องทาง
ไม่เปิดเซสชันไคลเอนต์ MCP แบบสด และไม่พิสูจน์ว่าเซิร์ฟเวอร์เป้าหมายเข้าถึงได้
## ข้อจำกัดปัจจุบัน
หน้านี้อธิบายบริดจ์ตามที่จัดส่งอยู่ในปัจจุบัน
ข้อจำกัดปัจจุบัน:
- การค้นพบการสนทนาขึ้นอยู่กับเมทาดาทาเส้นทางของเซสชัน Gateway ที่มีอยู่
- ยังไม่มีโปรโตคอล push แบบทั่วไปนอกเหนือจากตัวเชื่อมต่อที่เฉพาะกับ Claude
- ยังไม่มีเครื่องมือแก้ไขข้อความหรือ react
- transport แบบ HTTP/SSE/streamable-http เชื่อมต่อกับเซิร์ฟเวอร์ remote ได้เพียงตัวเดียว; ยังไม่มี upstream แบบ multiplex
- `permissions_list_open` รวมเฉพาะการอนุมัติที่พบขณะบริดจ์
เชื่อมต่ออยู่เท่านั้น

181
docs/th/cli/memory.md Normal file
View File

@ -0,0 +1,181 @@
---
read_when:
- คุณต้องการทำดัชนีหรือค้นหา semantic memory
- คุณกำลังดีบักความพร้อมใช้งานของหน่วยความจำหรือการทำดัชนี
- คุณต้องการเลื่อนระดับหน่วยความจำระยะสั้นที่เรียกคืนได้ไปยัง `MEMORY.md`
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw memory` (status/index/search/promote/promote-explain/rem-harness)
title: หน่วยความจำ
x-i18n:
generated_at: "2026-04-23T06:18:34Z"
model: gpt-5.4
provider: openai
source_hash: c9ea7aa2858b18cc6daa6531c45c9e838015b84de1c7a1b88716f2b1323e419c
source_path: cli/memory.md
workflow: 15
---
# `openclaw memory`
จัดการการทำดัชนีและการค้นหา semantic memory
ให้บริการโดย Plugin หน่วยความจำที่ใช้งานอยู่ (ค่าเริ่มต้น: `memory-core`; ตั้งค่า `plugins.slots.memory = "none"` เพื่อปิดใช้งาน)
ที่เกี่ยวข้อง:
- แนวคิดเรื่องหน่วยความจำ: [หน่วยความจำ](/th/concepts/memory)
- วิกิหน่วยความจำ: [วิกิหน่วยความจำ](/th/plugins/memory-wiki)
- Wiki CLI: [wiki](/th/cli/wiki)
- Plugins: [Plugins](/th/tools/plugin)
## ตัวอย่าง
```bash
openclaw memory status
openclaw memory status --deep
openclaw memory status --fix
openclaw memory index --force
openclaw memory search "meeting notes"
openclaw memory search --query "deployment" --max-results 20
openclaw memory promote --limit 10 --min-score 0.75
openclaw memory promote --apply
openclaw memory promote --json --min-recall-count 0 --min-unique-queries 0
openclaw memory promote-explain "router vlan"
openclaw memory promote-explain "router vlan" --json
openclaw memory rem-harness
openclaw memory rem-harness --json
openclaw memory status --json
openclaw memory status --deep --index
openclaw memory status --deep --index --verbose
openclaw memory status --agent main
openclaw memory index --agent main --verbose
```
## ตัวเลือก
`memory status` และ `memory index`:
- `--agent <id>`: จำกัดขอบเขตไปยังเอเจนต์เดียว หากไม่ระบุ คำสั่งเหล่านี้จะรันสำหรับเอเจนต์ที่กำหนดค่าไว้แต่ละตัว; หากไม่มีการกำหนดค่ารายการเอเจนต์ จะย้อนกลับไปใช้เอเจนต์เริ่มต้น
- `--verbose`: แสดงบันทึกโดยละเอียดระหว่างการ probe และการทำดัชนี
`memory status`:
- `--deep`: probe ความพร้อมใช้งานของเวกเตอร์ + embedding
- `--index`: รันการทำดัชนีใหม่หาก store อยู่ในสถานะ dirty (รวม `--deep`)
- `--fix`: ซ่อมแซม recall lock ที่ค้างอยู่และทำให้ข้อมูลเมตาการเลื่อนระดับเป็นมาตรฐาน
- `--json`: พิมพ์เอาต์พุต JSON
`memory index`:
- `--force`: บังคับให้ทำดัชนีใหม่ทั้งหมด
`memory search`:
- อินพุตคำค้นหา: ส่งได้ทั้ง `[query]` แบบตามตำแหน่งหรือ `--query <text>`
- หากระบุทั้งสองแบบ `--query` จะมีผลเหนือกว่า
- หากไม่ระบุทั้งคู่ คำสั่งจะออกพร้อมข้อผิดพลาด
- `--agent <id>`: จำกัดขอบเขตไปยังเอเจนต์เดียว (ค่าเริ่มต้น: เอเจนต์เริ่มต้น)
- `--max-results <n>`: จำกัดจำนวนผลลัพธ์ที่ส่งกลับ
- `--min-score <n>`: กรองรายการที่มีคะแนนต่ำออก
- `--json`: พิมพ์ผลลัพธ์ JSON
`memory promote`:
ดูตัวอย่างและปรับใช้การเลื่อนระดับหน่วยความจำระยะสั้น
```bash
openclaw memory promote [--apply] [--limit <n>] [--include-promoted]
```
- `--apply` -- เขียนการเลื่อนระดับลงใน `MEMORY.md` (ค่าเริ่มต้น: แสดงตัวอย่างเท่านั้น)
- `--limit <n>` -- จำกัดจำนวนผู้สมัครที่แสดง
- `--include-promoted` -- รวมรายการที่ถูกเลื่อนระดับไปแล้วในรอบก่อนหน้า
ตัวเลือกทั้งหมด:
- จัดอันดับผู้สมัครระยะสั้นจาก `memory/YYYY-MM-DD.md` โดยใช้สัญญาณการเลื่อนระดับแบบถ่วงน้ำหนัก (`frequency`, `relevance`, `query diversity`, `recency`, `consolidation`, `conceptual richness`)
- ใช้สัญญาณระยะสั้นจากทั้งการเรียกคืนหน่วยความจำและการส่งผ่าน ingestion รายวัน รวมถึงสัญญาณ reinforcement จากระยะ light/REM
- เมื่อเปิดใช้ Dreaming, `memory-core` จะจัดการงาน cron หนึ่งงานโดยอัตโนมัติซึ่งรันการกวาดแบบเต็ม (`light -> REM -> deep`) ในเบื้องหลัง (ไม่ต้องใช้ `openclaw cron add` ด้วยตนเอง)
- `--agent <id>`: จำกัดขอบเขตไปยังเอเจนต์เดียว (ค่าเริ่มต้น: เอเจนต์เริ่มต้น)
- `--limit <n>`: จำนวนผู้สมัครสูงสุดที่จะส่งกลับ/ปรับใช้
- `--min-score <n>`: คะแนนการเลื่อนระดับแบบถ่วงน้ำหนักขั้นต่ำ
- `--min-recall-count <n>`: จำนวนการเรียกคืนขั้นต่ำที่ผู้สมัครต้องมี
- `--min-unique-queries <n>`: จำนวนคำค้นหาที่แตกต่างกันขั้นต่ำที่ผู้สมัครต้องมี
- `--apply`: ผนวกรายการผู้สมัครที่เลือกลงใน `MEMORY.md` และทำเครื่องหมายว่าเลื่อนระดับแล้ว
- `--include-promoted`: รวมผู้สมัครที่ถูกเลื่อนระดับไปแล้วในเอาต์พุต
- `--json`: พิมพ์เอาต์พุต JSON
`memory promote-explain`:
อธิบายผู้สมัครสำหรับการเลื่อนระดับที่ระบุ และรายละเอียดการแบ่งคะแนนของผู้สมัครนั้น
```bash
openclaw memory promote-explain <selector> [--agent <id>] [--include-promoted] [--json]
```
- `<selector>`: คีย์ผู้สมัคร ชิ้นส่วนของพาธ หรือชิ้นส่วนของสไนปเพ็ตที่ใช้ค้นหา
- `--agent <id>`: จำกัดขอบเขตไปยังเอเจนต์เดียว (ค่าเริ่มต้น: เอเจนต์เริ่มต้น)
- `--include-promoted`: รวมผู้สมัครที่ถูกเลื่อนระดับไปแล้ว
- `--json`: พิมพ์เอาต์พุต JSON
`memory rem-harness`:
แสดงตัวอย่างการสะท้อน REM ข้อเท็จจริงผู้สมัคร และเอาต์พุตการเลื่อนระดับแบบ deep โดยไม่เขียนอะไรเลย
```bash
openclaw memory rem-harness [--agent <id>] [--include-promoted] [--json]
```
- `--agent <id>`: จำกัดขอบเขตไปยังเอเจนต์เดียว (ค่าเริ่มต้น: เอเจนต์เริ่มต้น)
- `--include-promoted`: รวมผู้สมัครแบบ deep ที่ถูกเลื่อนระดับไปแล้ว
- `--json`: พิมพ์เอาต์พุต JSON
## Dreaming
Dreaming คือระบบรวมหน่วยความจำเบื้องหลังที่มีสามระยะซึ่งทำงานร่วมกัน:
**light** (จัดเรียง/เตรียมเนื้อหาระยะสั้น), **deep** (เลื่อนระดับข้อเท็จจริงที่คงทน
ไปยัง `MEMORY.md`) และ **REM** (สะท้อนและดึงธีมสำคัญขึ้นมา)
- เปิดใช้งานด้วย `plugins.entries.memory-core.config.dreaming.enabled: true`
- สลับจากแชตด้วย `/dreaming on|off` (หรือตรวจสอบด้วย `/dreaming status`)
- Dreaming ทำงานตามตารางการกวาดที่มีการจัดการหนึ่งรายการ (`dreaming.frequency`) และดำเนินการตามลำดับ: light, REM, deep
- มีเพียงระยะ deep เท่านั้นที่เขียนหน่วยความจำแบบคงทนลงใน `MEMORY.md`
- เอาต์พุตระยะที่มนุษย์อ่านได้และรายการบันทึกประจำวันจะถูกเขียนลงใน `DREAMS.md` (หรือ `dreams.md` ที่มีอยู่) พร้อมรายงานแยกตามระยะตามตัวเลือกใน `memory/dreaming/<phase>/YYYY-MM-DD.md`
- การจัดอันดับใช้สัญญาณแบบถ่วงน้ำหนัก: ความถี่ในการเรียกคืน ความเกี่ยวข้องของการดึงคืน ความหลากหลายของคำค้นหา ความใหม่ตามเวลา การรวมข้ามวัน และความสมบูรณ์ของแนวคิดที่อนุมานได้
- การเลื่อนระดับจะอ่านบันทึกรายวันที่ใช้งานจริงซ้ำก่อนเขียนลง `MEMORY.md` ดังนั้นสไนปเพ็ตระยะสั้นที่ถูกแก้ไขหรือลบแล้วจะไม่ถูกเลื่อนระดับจากสแนปชอต recall-store ที่ล้าสมัย
- การรัน `memory promote` ทั้งแบบกำหนดเวลาและแบบแมนนวลใช้ค่าเริ่มต้นของระยะ deep เดียวกัน เว้นแต่คุณจะส่ง override เกณฑ์ผ่าน CLI
- การรันอัตโนมัติจะแยกทำงานไปยังเวิร์กสเปซหน่วยความจำที่กำหนดค่าไว้
การจัดตารางเวลาเริ่มต้น:
- **รอบการกวาด**: `dreaming.frequency = 0 3 * * *`
- **เกณฑ์ deep**: `minScore=0.8`, `minRecallCount=3`, `minUniqueQueries=3`, `recencyHalfLifeDays=14`, `maxAgeDays=30`
ตัวอย่าง:
```json
{
"plugins": {
"entries": {
"memory-core": {
"config": {
"dreaming": {
"enabled": true
}
}
}
}
}
}
```
หมายเหตุ:
- `memory index --verbose` จะแสดงรายละเอียดแยกตามระยะ (provider, model, แหล่งข้อมูล, กิจกรรมแบบ batch)
- `memory status` จะรวมพาธเพิ่มเติมที่กำหนดค่าไว้ผ่าน `memorySearch.extraPaths`
- หากฟิลด์คีย์ API ระยะไกลของหน่วยความจำที่ใช้งานจริงถูกกำหนดค่าเป็น SecretRefs คำสั่งจะ resolve ค่าเหล่านั้นจาก snapshot Gateway ที่ใช้งานอยู่ หาก Gateway ไม่พร้อมใช้งาน คำสั่งจะล้มเหลวทันที
- หมายเหตุเรื่องเวอร์ชัน Gateway ไม่ตรงกัน: เส้นทางคำสั่งนี้ต้องใช้ Gateway ที่รองรับ `secrets.resolve`; Gateway รุ่นเก่าจะส่งกลับข้อผิดพลาด unknown-method
- ปรับรอบการกวาดตามกำหนดเวลาด้วย `dreaming.frequency` ส่วนนโยบายการเลื่อนระดับแบบ deep เป็นเรื่องภายในตามปกติ; ใช้แฟล็ก CLI บน `memory promote` เมื่อคุณต้องการ override แบบแมนนวลเป็นครั้งคราว
- `memory rem-harness --path <file-or-dir> --grounded` จะแสดงตัวอย่าง `What Happened`, `Reflections` และ `Possible Lasting Updates` แบบ grounded จากบันทึกรายวันย้อนหลังโดยไม่เขียนอะไรเลย
- `memory rem-backfill --path <file-or-dir>` จะเขียนรายการบันทึกแบบ grounded ที่ย้อนกลับได้ลงใน `DREAMS.md` เพื่อให้ UI ตรวจสอบ
- `memory rem-backfill --path <file-or-dir> --stage-short-term` จะ seed ผู้สมัครแบบคงทน grounded ลงใน store การเลื่อนระดับระยะสั้นที่ใช้งานอยู่ด้วย เพื่อให้ระยะ deep ปกติสามารถจัดอันดับได้
- `memory rem-backfill --rollback` จะลบรายการบันทึกแบบ grounded ที่เขียนไว้ก่อนหน้านี้ และ `memory rem-backfill --rollback-short-term` จะลบผู้สมัครระยะสั้นแบบ grounded ที่จัดเตรียมไว้ก่อนหน้านี้
- ดู [Dreaming](/th/concepts/dreaming) สำหรับคำอธิบายแต่ละระยะและข้อมูลอ้างอิงการกำหนดค่าแบบเต็ม

305
docs/th/cli/message.md Normal file
View File

@ -0,0 +1,305 @@
---
read_when:
- การเพิ่มหรือแก้ไขการดำเนินการ CLI ของข้อความ
- การเปลี่ยนพฤติกรรมของแชนแนลขาออก
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw message` (ส่ง + การดำเนินการของแชนแนล)
title: ข้อความ
x-i18n:
generated_at: "2026-04-23T06:18:30Z"
model: gpt-5.4
provider: openai
source_hash: 37b6f40b435326aee186dad1e6e060c24f2ef6d44b07fd85d4ce5cfd7f350b91
source_path: cli/message.md
workflow: 15
---
# `openclaw message`
คำสั่งขาออกแบบรวมสำหรับการส่งข้อความและการดำเนินการของแชนแนล
(Discord/Google Chat/iMessage/Matrix/Mattermost (Plugin)/Microsoft Teams/Signal/Slack/Telegram/WhatsApp)
## การใช้งาน
```
openclaw message <subcommand> [flags]
```
การเลือกแชนแนล:
- ต้องระบุ `--channel` หากมีการกำหนดค่ามากกว่าหนึ่งแชนแนล
- หากมีการกำหนดค่าไว้เพียงแชนแนลเดียว แชนแนลนั้นจะกลายเป็นค่าเริ่มต้น
- ค่า: `discord|googlechat|imessage|matrix|mattermost|msteams|signal|slack|telegram|whatsapp` (Mattermost ต้องใช้ Plugin)
รูปแบบเป้าหมาย (`--target`):
- WhatsApp: E.164 หรือ group JID
- Telegram: chat id หรือ `@username`
- Discord: `channel:<id>` หรือ `user:<id>` (หรือ mention แบบ `<@id>`; id ตัวเลขล้วนจะถูกตีความเป็นแชนแนล)
- Google Chat: `spaces/<spaceId>` หรือ `users/<userId>`
- Slack: `channel:<id>` หรือ `user:<id>` (ยอมรับ channel id แบบดิบ)
- Mattermost (Plugin): `channel:<id>`, `user:<id>`, หรือ `@username` (id แบบล้วนจะถูกตีความเป็นแชนแนล)
- Signal: `+E.164`, `group:<id>`, `signal:+E.164`, `signal:group:<id>`, หรือ `username:<name>`/`u:<name>`
- iMessage: handle, `chat_id:<id>`, `chat_guid:<guid>`, หรือ `chat_identifier:<id>`
- Matrix: `@user:server`, `!room:server`, หรือ `#alias:server`
- Microsoft Teams: conversation id (`19:...@thread.tacv2`) หรือ `conversation:<id>` หรือ `user:<aad-object-id>`
การค้นหาชื่อ:
- สำหรับผู้ให้บริการที่รองรับ (Discord/Slack/อื่นๆ) ชื่อแชนแนล เช่น `Help` หรือ `#help` จะถูก resolve ผ่านแคชไดเรกทอรี
- หากไม่พบในแคช OpenClaw จะพยายามค้นหาไดเรกทอรีแบบสดเมื่อผู้ให้บริการรองรับ
## แฟล็กร่วม
- `--channel <name>`
- `--account <id>`
- `--target <dest>` (แชนแนลหรือผู้ใช้เป้าหมายสำหรับ send/poll/read/อื่นๆ)
- `--targets <name>` (ระบุซ้ำได้; ใช้กับ broadcast เท่านั้น)
- `--json`
- `--dry-run`
- `--verbose`
## พฤติกรรมของ SecretRef
- `openclaw message` จะ resolve SecretRefs ของแชนแนลที่รองรับก่อนรันการดำเนินการที่เลือก
- การ resolve จะถูกจำกัดขอบเขตตามเป้าหมายของการดำเนินการที่ใช้งานอยู่เมื่อทำได้:
- ระดับแชนแนลเมื่อมีการตั้ง `--channel` (หรืออนุมานได้จาก target ที่มีคำนำหน้า เช่น `discord:...`)
- ระดับบัญชีเมื่อมีการตั้ง `--account` (global ของแชนแนล + พื้นผิวของบัญชีที่เลือก)
- เมื่อไม่ระบุ `--account` OpenClaw จะไม่บังคับขอบเขต SecretRef ของบัญชี `default`
- SecretRefs ที่ resolve ไม่ได้ในแชนแนลที่ไม่เกี่ยวข้องจะไม่บล็อกการดำเนินการข้อความแบบเจาะจงเป้าหมาย
- หาก SecretRef ของแชนแนล/บัญชีที่เลือก resolve ไม่ได้ คำสั่งจะ fail closed สำหรับการดำเนินการนั้น
## การดำเนินการ
### Core
- `send`
- แชนแนล: WhatsApp/Telegram/Discord/Google Chat/Slack/Mattermost (Plugin)/Signal/iMessage/Matrix/Microsoft Teams
- ต้องระบุ: `--target` และ `--message`, `--media`, หรือ `--presentation`
- ไม่บังคับ: `--media`, `--presentation`, `--delivery`, `--pin`, `--reply-to`, `--thread-id`, `--gif-playback`, `--force-document`, `--silent`
- payload `presentation` ที่ใช้ร่วมกัน: `--presentation` จะส่งบล็อกเชิงความหมาย (`text`, `context`, `divider`, `buttons`, `select`) ที่ core เรนเดอร์ผ่านความสามารถที่ประกาศไว้ของแชนแนลที่เลือก ดู [Message Presentation](/th/plugins/message-presentation)
- ค่ากำหนดการส่งแบบทั่วไป: `--delivery` รับคำใบ้การส่ง เช่น `{ "pin": true }`; `--pin` เป็นรูปแบบย่อสำหรับการส่งแบบปักหมุดเมื่อแชนแนลรองรับ
- เฉพาะ Telegram: `--force-document` (ส่งรูปภาพและ GIF เป็นเอกสารเพื่อหลีกเลี่ยงการบีบอัดของ Telegram)
- เฉพาะ Telegram: `--thread-id` (forum topic id)
- เฉพาะ Slack: `--thread-id` (thread timestamp; `--reply-to` ใช้ฟิลด์เดียวกัน)
- Telegram + Discord: `--silent`
- เฉพาะ WhatsApp: `--gif-playback`
- `poll`
- แชนแนล: WhatsApp/Telegram/Discord/Matrix/Microsoft Teams
- ต้องระบุ: `--target`, `--poll-question`, `--poll-option` (ระบุซ้ำได้)
- ไม่บังคับ: `--poll-multi`
- เฉพาะ Discord: `--poll-duration-hours`, `--silent`, `--message`
- เฉพาะ Telegram: `--poll-duration-seconds` (5-600), `--silent`, `--poll-anonymous` / `--poll-public`, `--thread-id`
- `react`
- แชนแนล: Discord/Google Chat/Slack/Telegram/WhatsApp/Signal/Matrix
- ต้องระบุ: `--message-id`, `--target`
- ไม่บังคับ: `--emoji`, `--remove`, `--participant`, `--from-me`, `--target-author`, `--target-author-uuid`
- หมายเหตุ: `--remove` ต้องใช้ร่วมกับ `--emoji` (หากไม่ระบุ `--emoji` จะเป็นการล้าง reaction ของตัวเองในแชนแนลที่รองรับ; ดู /tools/reactions)
- เฉพาะ WhatsApp: `--participant`, `--from-me`
- reaction ในกลุ่ม Signal: ต้องระบุ `--target-author` หรือ `--target-author-uuid`
- `reactions`
- แชนแนล: Discord/Google Chat/Slack/Matrix
- ต้องระบุ: `--message-id`, `--target`
- ไม่บังคับ: `--limit`
- `read`
- แชนแนล: Discord/Slack/Matrix
- ต้องระบุ: `--target`
- ไม่บังคับ: `--limit`, `--before`, `--after`
- เฉพาะ Discord: `--around`
- `edit`
- แชนแนล: Discord/Slack/Matrix
- ต้องระบุ: `--message-id`, `--message`, `--target`
- `delete`
- แชนแนล: Discord/Slack/Telegram/Matrix
- ต้องระบุ: `--message-id`, `--target`
- `pin` / `unpin`
- แชนแนล: Discord/Slack/Matrix
- ต้องระบุ: `--message-id`, `--target`
- `pins` (แสดงรายการ)
- แชนแนล: Discord/Slack/Matrix
- ต้องระบุ: `--target`
- `permissions`
- แชนแนล: Discord/Matrix
- ต้องระบุ: `--target`
- เฉพาะ Matrix: ใช้งานได้เมื่อเปิดใช้การเข้ารหัสของ Matrix และอนุญาตการดำเนินการตรวจสอบยืนยัน
- `search`
- แชนแนล: Discord
- ต้องระบุ: `--guild-id`, `--query`
- ไม่บังคับ: `--channel-id`, `--channel-ids` (ระบุซ้ำได้), `--author-id`, `--author-ids` (ระบุซ้ำได้), `--limit`
### เธรด
- `thread create`
- แชนแนล: Discord
- ต้องระบุ: `--thread-name`, `--target` (channel id)
- ไม่บังคับ: `--message-id`, `--message`, `--auto-archive-min`
- `thread list`
- แชนแนล: Discord
- ต้องระบุ: `--guild-id`
- ไม่บังคับ: `--channel-id`, `--include-archived`, `--before`, `--limit`
- `thread reply`
- แชนแนล: Discord
- ต้องระบุ: `--target` (thread id), `--message`
- ไม่บังคับ: `--media`, `--reply-to`
### อีโมจิ
- `emoji list`
- Discord: `--guild-id`
- Slack: ไม่มีแฟล็กเพิ่มเติม
- `emoji upload`
- แชนแนล: Discord
- ต้องระบุ: `--guild-id`, `--emoji-name`, `--media`
- ไม่บังคับ: `--role-ids` (ระบุซ้ำได้)
### สติกเกอร์
- `sticker send`
- แชนแนล: Discord
- ต้องระบุ: `--target`, `--sticker-id` (ระบุซ้ำได้)
- ไม่บังคับ: `--message`
- `sticker upload`
- แชนแนล: Discord
- ต้องระบุ: `--guild-id`, `--sticker-name`, `--sticker-desc`, `--sticker-tags`, `--media`
### บทบาท / แชนแนล / สมาชิก / เสียง
- `role info` (Discord): `--guild-id`
- `role add` / `role remove` (Discord): `--guild-id`, `--user-id`, `--role-id`
- `channel info` (Discord): `--target`
- `channel list` (Discord): `--guild-id`
- `member info` (Discord/Slack): `--user-id` (+ `--guild-id` สำหรับ Discord)
- `voice status` (Discord): `--guild-id`, `--user-id`
### กิจกรรม
- `event list` (Discord): `--guild-id`
- `event create` (Discord): `--guild-id`, `--event-name`, `--start-time`
- ไม่บังคับ: `--end-time`, `--desc`, `--channel-id`, `--location`, `--event-type`
### การดูแลจัดการ (Discord)
- `timeout`: `--guild-id`, `--user-id` (ไม่บังคับ `--duration-min` หรือ `--until`; หากไม่ระบุทั้งคู่จะเป็นการล้าง timeout)
- `kick`: `--guild-id`, `--user-id` (+ `--reason`)
- `ban`: `--guild-id`, `--user-id` (+ `--delete-days`, `--reason`)
- `timeout` รองรับ `--reason` เช่นกัน
### Broadcast
- `broadcast`
- แชนแนล: แชนแนลใดก็ได้ที่กำหนดค่าไว้; ใช้ `--channel all` เพื่อกำหนดเป้าหมายผู้ให้บริการทั้งหมด
- ต้องระบุ: `--targets <target...>`
- ไม่บังคับ: `--message`, `--media`, `--dry-run`
## ตัวอย่าง
ส่งการตอบกลับใน Discord:
```
openclaw message send --channel discord \
--target channel:123 --message "hi" --reply-to 456
```
ส่งข้อความพร้อมปุ่มเชิงความหมาย:
```
openclaw message send --channel discord \
--target channel:123 --message "เลือก:" \
--presentation '{"blocks":[{"type":"buttons","buttons":[{"label":"อนุมัติ","value":"approve","style":"success"},{"label":"ปฏิเสธ","value":"decline","style":"danger"}]}]}'
```
Core จะเรนเดอร์ payload `presentation` เดียวกันไปเป็นคอมโพเนนต์ของ Discord, blocks ของ Slack, ปุ่ม inline ของ Telegram, props ของ Mattermost หรือการ์ดของ Teams/Feishu ตามความสามารถของแชนแนล ดู [Message Presentation](/th/plugins/message-presentation) สำหรับสัญญาฉบับเต็มและกฎ fallback
ส่ง payload `presentation` ที่สมบูรณ์ยิ่งขึ้น:
```bash
openclaw message send --channel googlechat --target spaces/AAA... \
--message "เลือก:" \
--presentation '{"title":"อนุมัติการ deploy","tone":"warning","blocks":[{"type":"text","text":"เลือกเส้นทาง"},{"type":"buttons","buttons":[{"label":"อนุมัติ","value":"approve"},{"label":"ปฏิเสธ","value":"decline"}]}]}'
```
สร้าง poll ใน Discord:
```
openclaw message poll --channel discord \
--target channel:123 \
--poll-question "ของว่าง?" \
--poll-option Pizza --poll-option Sushi \
--poll-multi --poll-duration-hours 48
```
สร้าง poll ใน Telegram (ปิดอัตโนมัติใน 2 นาที):
```
openclaw message poll --channel telegram \
--target @mychat \
--poll-question "มื้อกลางวัน?" \
--poll-option Pizza --poll-option Sushi \
--poll-duration-seconds 120 --silent
```
ส่งข้อความแบบ proactive ใน Teams:
```
openclaw message send --channel msteams \
--target conversation:19:abc@thread.tacv2 --message "hi"
```
สร้าง poll ใน Teams:
```
openclaw message poll --channel msteams \
--target conversation:19:abc@thread.tacv2 \
--poll-question "มื้อกลางวัน?" \
--poll-option Pizza --poll-option Sushi
```
ใส่ reaction ใน Slack:
```
openclaw message react --channel slack \
--target C123 --message-id 456 --emoji "✅"
```
ใส่ reaction ในกลุ่ม Signal:
```
openclaw message react --channel signal \
--target signal:group:abc123 --message-id 1737630212345 \
--emoji "✅" --target-author-uuid 123e4567-e89b-12d3-a456-426614174000
```
ส่งปุ่ม inline ของ Telegram ผ่าน presentation แบบทั่วไป:
```
openclaw message send --channel telegram --target @mychat --message "เลือก:" \
--presentation '{"blocks":[{"type":"buttons","buttons":[{"label":"ใช่","value":"cmd:yes"},{"label":"ไม่","value":"cmd:no"}]}]}'
```
ส่งการ์ดของ Teams ผ่าน presentation แบบทั่วไป:
```bash
openclaw message send --channel msteams \
--target conversation:19:abc@thread.tacv2 \
--presentation '{"title":"อัปเดตสถานะ","blocks":[{"type":"text","text":"การ build เสร็จสมบูรณ์"}]}'
```
ส่งรูปภาพใน Telegram เป็นเอกสารเพื่อหลีกเลี่ยงการบีบอัด:
```bash
openclaw message send --channel telegram --target @mychat \
--media ./diagram.png --force-document
```

143
docs/th/cli/models.md Normal file
View File

@ -0,0 +1,143 @@
---
read_when:
- คุณต้องการเปลี่ยนโมเดลเริ่มต้นหรือดูสถานะ auth ของ provider
- คุณต้องการสแกนโมเดล/provider ที่พร้อมใช้งานและดีบักโปรไฟล์ auth
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw models` (status/list/set/scan, นามแฝง, ทางเลือกสำรอง, auth)
title: models
x-i18n:
generated_at: "2026-04-23T06:18:37Z"
model: gpt-5.4
provider: openai
source_hash: 5b057688266bcb72fc9719837ae6a026bed9849ff04577949467363d83b6d069
source_path: cli/models.md
workflow: 15
---
# `openclaw models`
การค้นหา การสแกน และการกำหนดค่าโมเดล (โมเดลเริ่มต้น ทางเลือกสำรอง โปรไฟล์ auth)
ที่เกี่ยวข้อง:
- Providers + models: [Models](/th/providers/models)
- การตั้งค่า auth ของ provider: [เริ่มต้นใช้งาน](/th/start/getting-started)
## คำสั่งที่ใช้บ่อย
```bash
openclaw models status
openclaw models list
openclaw models set <model-or-alias>
openclaw models scan
```
`openclaw models status` แสดงค่าเริ่มต้น/ทางเลือกสำรองที่ resolve แล้วพร้อมภาพรวม auth
เมื่อมี snapshot การใช้งาน provider พร้อมใช้งาน ส่วนสถานะ OAuth/API key จะรวม
ช่วงหน้าต่างการใช้งานของ provider และ snapshot โควตา
provider ที่รองรับหน้าต่างการใช้งานในปัจจุบัน: Anthropic, GitHub Copilot, Gemini CLI, OpenAI
Codex, MiniMax, Xiaomi และ z.ai auth การใช้งานมาจาก hook เฉพาะของ provider
เมื่อมีให้ใช้; มิฉะนั้น OpenClaw จะใช้ทางเลือกสำรองโดยจับคู่ข้อมูลรับรอง OAuth/API-key
จากโปรไฟล์ auth, env หรือ config
ในเอาต์พุต `--json`, `auth.providers` คือภาพรวม provider
ที่รับรู้ env/config/store ขณะที่ `auth.oauth` คือสถานะความสมบูรณ์ของโปรไฟล์ auth-store เท่านั้น
เพิ่ม `--probe` เพื่อรันการ probe auth แบบสดกับแต่ละโปรไฟล์ provider ที่ตั้งค่าไว้
การ probe เป็นคำขอจริง (อาจใช้โทเค็นและทำให้ติด rate limit)
ใช้ `--agent <id>` เพื่อตรวจสอบสถานะ model/auth ของ agent ที่ตั้งค่าไว้ เมื่อไม่ระบุ
คำสั่งจะใช้ `OPENCLAW_AGENT_DIR`/`PI_CODING_AGENT_DIR` หากมีการตั้งค่าไว้ มิฉะนั้นจะใช้
agent เริ่มต้นที่ตั้งค่าไว้
แถว probe อาจมาจากโปรไฟล์ auth, ข้อมูลรับรอง env หรือ `models.json`
หมายเหตุ:
- `models set <model-or-alias>` รองรับ `provider/model` หรือ alias
- `models list --all` รวมแถวแค็ตตาล็อกแบบคงที่ที่เป็นของ provider ที่มาพร้อมระบบด้วย แม้ว่า
คุณจะยังไม่ได้ยืนยันตัวตนกับ provider นั้นก็ตาม แถวเหล่านั้นยังคงแสดง
ว่าไม่พร้อมใช้งานจนกว่าจะตั้งค่า auth ที่ตรงกัน
- การแยกวิเคราะห์ model ref ทำโดยแบ่งที่ `/` **ตัวแรก** หาก model ID มี `/` อยู่ด้วย (สไตล์ OpenRouter) ให้ใส่คำนำหน้า provider ด้วย (ตัวอย่าง: `openrouter/moonshotai/kimi-k2`)
- หากคุณไม่ระบุ provider, OpenClaw จะ resolve อินพุตเป็น alias ก่อน จากนั้น
เป็นการจับคู่ configured-provider แบบไม่ซ้ำสำหรับ model id ที่ตรงกันแบบเป๊ะ และหลังจากนั้นเท่านั้น
จึงจะใช้ provider เริ่มต้นที่ตั้งค่าไว้เป็นทางเลือกสำรองพร้อมคำเตือนการเลิกใช้
หาก provider นั้นไม่ได้เปิดเผยโมเดลเริ่มต้นที่ตั้งค่าไว้อีกต่อไป OpenClaw
จะใช้ provider/model ตัวแรกที่ตั้งค่าไว้เป็นทางเลือกสำรองแทนที่จะคงค่าเริ่มต้นของ provider ที่ถูกลบออกไปแล้ว
- `models status` อาจแสดง `marker(<value>)` ในเอาต์พุต auth สำหรับ placeholder ที่ไม่ใช่ความลับ (ตัวอย่างเช่น `OPENAI_API_KEY`, `secretref-managed`, `minimax-oauth`, `oauth:chutes`, `ollama-local`) แทนการปิดบังเป็นข้อมูลลับ
### `models status`
ตัวเลือก:
- `--json`
- `--plain`
- `--check` (รหัสออก 1=หมดอายุ/ไม่มี, 2=ใกล้หมดอายุ)
- `--probe` (probe แบบสดของโปรไฟล์ auth ที่ตั้งค่าไว้)
- `--probe-provider <name>` (probe หนึ่ง provider)
- `--probe-profile <id>` (ใช้ซ้ำได้หรือคั่นด้วยจุลภาค)
- `--probe-timeout <ms>`
- `--probe-concurrency <n>`
- `--probe-max-tokens <n>`
- `--agent <id>` (ID ของ agent ที่ตั้งค่าไว้; แทนที่ `OPENCLAW_AGENT_DIR`/`PI_CODING_AGENT_DIR`)
กลุ่มสถานะ probe:
- `ok`
- `auth`
- `rate_limit`
- `billing`
- `timeout`
- `format`
- `unknown`
- `no_model`
กรณีรายละเอียด/รหัสเหตุผลของ probe ที่ควรคาดว่าจะพบ:
- `excluded_by_auth_order`: มีโปรไฟล์ที่จัดเก็บไว้ แต่
`auth.order.<provider>` ที่กำหนดอย่างชัดเจนไม่ได้รวมโปรไฟล์นั้นไว้ ดังนั้น probe จึงรายงานการยกเว้นแทน
การลองใช้
- `missing_credential`, `invalid_expires`, `expired`, `unresolved_ref`:
มีโปรไฟล์อยู่ แต่ไม่มีสิทธิ์/ไม่สามารถ resolve ได้
- `no_model`: มี auth ของ provider อยู่ แต่ OpenClaw ไม่สามารถ resolve
ตัวเลือกโมเดลที่ probe ได้สำหรับ provider นั้น
## Alias + ทางเลือกสำรอง
```bash
openclaw models aliases list
openclaw models fallbacks list
```
## โปรไฟล์ auth
```bash
openclaw models auth add
openclaw models auth login --provider <id>
openclaw models auth setup-token --provider <id>
openclaw models auth paste-token
```
`models auth add` เป็นตัวช่วย auth แบบโต้ตอบ สามารถเปิดโฟลว์ auth ของ provider
(OAuth/API key) หรือแนะนำให้คุณวางโทเค็นด้วยตนเอง ขึ้นอยู่กับ
provider ที่คุณเลือก
`models auth login` รันโฟลว์ auth ของ Plugin provider (OAuth/API key) ใช้
`openclaw plugins list` เพื่อดูว่ามี provider ใดติดตั้งอยู่บ้าง
ตัวอย่าง:
```bash
openclaw models auth login --provider openai-codex --set-default
```
หมายเหตุ:
- `setup-token` และ `paste-token` ยังคงเป็นคำสั่งโทเค็นทั่วไปสำหรับ provider
ที่เปิดเผยวิธี auth แบบโทเค็น
- `setup-token` ต้องใช้ TTY แบบโต้ตอบ และจะรันวิธี token-auth ของ provider
(โดยค่าเริ่มต้นจะใช้เมธอด `setup-token` ของ provider นั้นเมื่อมี
เมธอดดังกล่าว)
- `paste-token` รับสตริงโทเค็นที่สร้างจากที่อื่นหรือจากระบบอัตโนมัติ
- `paste-token` ต้องระบุ `--provider`, จะถามค่าของโทเค็น และเขียน
ไปยัง ID โปรไฟล์เริ่มต้น `<provider>:manual` เว้นแต่คุณจะระบุ
`--profile-id`
- `paste-token --expires-in <duration>` จะจัดเก็บเวลาหมดอายุสัมบูรณ์ของโทเค็นจาก
ระยะเวลาแบบสัมพัทธ์ เช่น `365d` หรือ `12h`
- หมายเหตุเกี่ยวกับ Anthropic: ทีมงาน Anthropic แจ้งกับเราว่าการใช้งาน Claude CLI แบบ OpenClaw ได้รับอนุญาตอีกครั้ง ดังนั้น OpenClaw จึงถือว่าการใช้ Claude CLI ซ้ำและการใช้ `claude -p` ได้รับการรับรองสำหรับการผสานรวมนี้ เว้นแต่ Anthropic จะเผยแพร่นโยบายใหม่
- `setup-token` / `paste-token` ของ Anthropic ยังคงพร้อมใช้งานในฐานะเส้นทางโทเค็น OpenClaw ที่รองรับ แต่ตอนนี้ OpenClaw ให้ความสำคัญกับการใช้ Claude CLI ซ้ำและ `claude -p` เมื่อพร้อมใช้งาน

144
docs/th/cli/node.md Normal file
View File

@ -0,0 +1,144 @@
---
read_when:
- การรันโฮสต์ Node แบบไม่มีส่วนติดต่อ
- การจับคู่ Node ที่ไม่ใช่ macOS สำหรับ `system.run`
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw node` (โฮสต์ Node แบบไม่มีส่วนติดต่อ)
title: Node
x-i18n:
generated_at: "2026-04-23T06:18:44Z"
model: gpt-5.4
provider: openai
source_hash: 6123b33ec46f2b85f2c815947435ac91bbe84456165ff0e504453356da55b46d
source_path: cli/node.md
workflow: 15
---
# `openclaw node`
รัน **โฮสต์ Node แบบไม่มีส่วนติดต่อ** ที่เชื่อมต่อกับ Gateway WebSocket และเปิดให้ใช้
`system.run` / `system.which` บนเครื่องนี้
## ทำไมต้องใช้โฮสต์ node?
ใช้โฮสต์ node เมื่อต้องการให้เอเจนต์ **รันคำสั่งบนเครื่องอื่น** ในเครือข่ายของคุณ
โดยไม่ต้องติดตั้งแอปคู่หู macOS แบบเต็มบนเครื่องนั้น
กรณีใช้งานทั่วไป:
- รันคำสั่งบนเครื่อง Linux/Windows ระยะไกล (เซิร์ฟเวอร์บิลด์ เครื่องในแล็บ NAS)
- คงการทำงานของ exec ให้ **sandboxed** บน gateway แต่ส่งต่องานที่อนุมัติแล้วไปยังโฮสต์อื่น
- จัดเตรียมเป้าหมายการรันแบบเบาและไม่มีส่วนติดต่อสำหรับงานอัตโนมัติหรือ Node ของ CI
การรันยังคงถูกควบคุมด้วย **การอนุมัติ exec** และ allowlists รายเอเจนต์บน
โฮสต์ node ดังนั้นคุณจึงสามารถจำกัดขอบเขตการเข้าถึงคำสั่งให้ชัดเจนได้
## Browser proxy (ไม่ต้องตั้งค่า)
โฮสต์ node จะประกาศ browser proxy โดยอัตโนมัติหาก `browser.enabled` ไม่ได้
ถูกปิดใช้งานบน node ซึ่งช่วยให้เอเจนต์ใช้ browser automation บน node นั้นได้
โดยไม่ต้องกำหนดค่าเพิ่มเติม
โดยค่าเริ่มต้น proxy จะเปิดให้ใช้พื้นผิวโปรไฟล์เบราว์เซอร์ปกติของ node หากคุณ
ตั้งค่า `nodeHost.browserProxy.allowProfiles` proxy จะกลายเป็นแบบจำกัด:
การระบุโปรไฟล์ที่ไม่อยู่ใน allowlist จะถูกปฏิเสธ และเส้นทางสร้าง/ลบ
persistent profile จะถูกบล็อกผ่าน proxy
ปิดใช้งานบน node ได้หากจำเป็น:
```json5
{
nodeHost: {
browserProxy: {
enabled: false,
},
},
}
```
## รัน (เบื้องหน้า)
```bash
openclaw node run --host <gateway-host> --port 18789
```
ตัวเลือก:
- `--host <host>`: โฮสต์ Gateway WebSocket (ค่าเริ่มต้น: `127.0.0.1`)
- `--port <port>`: พอร์ต Gateway WebSocket (ค่าเริ่มต้น: `18789`)
- `--tls`: ใช้ TLS สำหรับการเชื่อมต่อ gateway
- `--tls-fingerprint <sha256>`: fingerprint ของใบรับรอง TLS ที่คาดหวัง (sha256)
- `--node-id <id>`: แทนที่ node id (ล้าง pairing token)
- `--display-name <name>`: แทนที่ชื่อแสดงผลของ node
## การยืนยันตัวตนกับ Gateway สำหรับโฮสต์ node
`openclaw node run` และ `openclaw node install` จะ resolve การยืนยันตัวตนของ gateway จาก config/env (ไม่มีแฟลก `--token`/`--password` บนคำสั่ง node):
- จะตรวจสอบ `OPENCLAW_GATEWAY_TOKEN` / `OPENCLAW_GATEWAY_PASSWORD` ก่อน
- จากนั้นจึง fallback ไปยัง config ภายในเครื่อง: `gateway.auth.token` / `gateway.auth.password`
- ในโหมด local โฮสต์ node จะไม่สืบทอด `gateway.remote.token` / `gateway.remote.password` โดยตั้งใจ
- หาก `gateway.auth.token` / `gateway.auth.password` ถูกตั้งค่าอย่างชัดเจนผ่าน SecretRef และยัง resolve ไม่ได้ การ resolve การยืนยันตัวตนของ node จะล้มเหลวแบบปิดไว้ก่อน (ไม่มี remote fallback มาปิดบัง)
- ใน `gateway.mode=remote` ฟิลด์ของ remote client (`gateway.remote.token` / `gateway.remote.password`) ก็มีสิทธิ์ถูกใช้ตามกฎลำดับความสำคัญของ remote
- การ resolve การยืนยันตัวตนของโฮสต์ node จะใช้เฉพาะตัวแปรแวดล้อม `OPENCLAW_GATEWAY_*` เท่านั้น
## บริการ (เบื้องหลัง)
ติดตั้งโฮสต์ node แบบไม่มีส่วนติดต่อเป็นบริการระดับผู้ใช้
```bash
openclaw node install --host <gateway-host> --port 18789
```
ตัวเลือก:
- `--host <host>`: โฮสต์ Gateway WebSocket (ค่าเริ่มต้น: `127.0.0.1`)
- `--port <port>`: พอร์ต Gateway WebSocket (ค่าเริ่มต้น: `18789`)
- `--tls`: ใช้ TLS สำหรับการเชื่อมต่อ gateway
- `--tls-fingerprint <sha256>`: fingerprint ของใบรับรอง TLS ที่คาดหวัง (sha256)
- `--node-id <id>`: แทนที่ node id (ล้าง pairing token)
- `--display-name <name>`: แทนที่ชื่อแสดงผลของ node
- `--runtime <runtime>`: runtime ของบริการ (`node` หรือ `bun`)
- `--force`: ติดตั้งใหม่/เขียนทับหากติดตั้งไว้แล้ว
จัดการบริการ:
```bash
openclaw node status
openclaw node stop
openclaw node restart
openclaw node uninstall
```
ใช้ `openclaw node run` สำหรับโฮสต์ node แบบเบื้องหน้า (ไม่มีบริการ)
คำสั่งบริการรองรับ `--json` สำหรับเอาต์พุตที่เครื่องอ่านได้
## การจับคู่
การเชื่อมต่อครั้งแรกจะสร้างคำขอจับคู่อุปกรณ์ที่รออนุมัติ (`role: node`) บน Gateway
อนุมัติได้ผ่าน:
```bash
openclaw devices list
openclaw devices approve <requestId>
```
หาก node ลองจับคู่อีกครั้งโดยมีรายละเอียดการยืนยันตัวตนที่เปลี่ยนไป (role/scopes/public key)
คำขอที่รออยู่ก่อนหน้าจะถูกแทนที่ และจะมี `requestId` ใหม่ถูกสร้างขึ้น
ให้รัน `openclaw devices list` อีกครั้งก่อนอนุมัติ
โฮสต์ node จะจัดเก็บ node id, token, display name และข้อมูลการเชื่อมต่อ gateway ไว้ใน
`~/.openclaw/node.json`
## การอนุมัติ exec
`system.run` ถูกควบคุมด้วยการอนุมัติ exec ภายในเครื่อง:
- `~/.openclaw/exec-approvals.json`
- [Exec approvals](/th/tools/exec-approvals)
- `openclaw approvals --node <id|name|ip>` (แก้ไขจาก Gateway)
สำหรับ async node exec ที่ได้รับอนุมัติ OpenClaw จะเตรียม `systemRunPlan`
แบบ canonical ก่อนแสดงพร้อมท์ การส่งต่อ `system.run` ที่ได้รับอนุมัติในภายหลังจะใช้
plan ที่จัดเก็บไว้นั้นซ้ำ ดังนั้นการแก้ไขฟิลด์ command/cwd/session หลังจากสร้าง
คำขออนุมัติแล้วจะถูกปฏิเสธ แทนที่จะเปลี่ยนสิ่งที่ node จะรัน

73
docs/th/cli/nodes.md Normal file
View File

@ -0,0 +1,73 @@
---
read_when:
- คุณกำลังจัดการ Nodes ที่จับคู่ไว้แล้ว (cameras, screen, canvas)
- คุณต้องอนุมัติคำขอหรือเรียกใช้คำสั่งของ node
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw nodes` (สถานะ, การจับคู่, invoke, camera/canvas/screen)
title: Nodes
x-i18n:
generated_at: "2026-04-23T06:18:48Z"
model: gpt-5.4
provider: openai
source_hash: 1ce3095591c4623ad18e3eca8d8083e5c10266fbf94afea2d025f0ba8093a175
source_path: cli/nodes.md
workflow: 15
---
# `openclaw nodes`
จัดการ Nodes (อุปกรณ์) ที่จับคู่ไว้แล้ว และเรียกใช้ความสามารถของ node
ที่เกี่ยวข้อง:
- ภาพรวมของ Nodes: [Nodes](/th/nodes)
- กล้อง: [Camera nodes](/th/nodes/camera)
- รูปภาพ: [Image nodes](/th/nodes/images)
ตัวเลือกทั่วไป:
- `--url`, `--token`, `--timeout`, `--json`
## คำสั่งทั่วไป
```bash
openclaw nodes list
openclaw nodes list --connected
openclaw nodes list --last-connected 24h
openclaw nodes pending
openclaw nodes approve <requestId>
openclaw nodes reject <requestId>
openclaw nodes rename --node <id|name|ip> --name <displayName>
openclaw nodes status
openclaw nodes status --connected
openclaw nodes status --last-connected 24h
```
`nodes list` จะแสดงตาราง pending/paired แถวที่จับคู่แล้วจะรวมอายุการเชื่อมต่อล่าสุด (Last Connect)
ใช้ `--connected` เพื่อแสดงเฉพาะ nodes ที่เชื่อมต่ออยู่ในขณะนี้ ใช้ `--last-connected <duration>` เพื่อ
กรองให้เหลือเฉพาะ nodes ที่เชื่อมต่อภายในช่วงเวลาที่กำหนด (เช่น `24h`, `7d`)
หมายเหตุเกี่ยวกับการอนุมัติ:
- `openclaw nodes pending` ต้องใช้เฉพาะขอบเขต pairing เท่านั้น
- `openclaw nodes approve <requestId>` จะสืบทอดข้อกำหนดด้านขอบเขตเพิ่มเติมจาก
คำขอที่รออยู่:
- คำขอที่ไม่มีคำสั่ง: pairing เท่านั้น
- คำสั่ง node ที่ไม่ใช่ exec: pairing + write
- `system.run` / `system.run.prepare` / `system.which`: pairing + admin
## Invoke
```bash
openclaw nodes invoke --node <id|name|ip> --command <command> --params <json>
```
แฟล็กของ invoke:
- `--params <json>`: สตริงออบเจ็กต์ JSON (ค่าเริ่มต้น `{}`).
- `--invoke-timeout <ms>`: ระยะหมดเวลาของ node invoke (ค่าเริ่มต้น `15000`).
- `--idempotency-key <key>`: คีย์ idempotency แบบไม่บังคับ
- `system.run` และ `system.run.prepare` ถูกบล็อกที่นี่; ให้ใช้เครื่องมือ `exec` กับ `host=node` สำหรับการรัน shell
สำหรับการรัน shell บน node ให้ใช้เครื่องมือ `exec` กับ `host=node` แทน `openclaw nodes run`
ขณะนี้ CLI `nodes` มุ่งเน้นที่ความสามารถ: direct RPC ผ่าน `nodes invoke` รวมถึง pairing, camera,
screen, location, canvas และ notifications

185
docs/th/cli/onboard.md Normal file
View File

@ -0,0 +1,185 @@
---
read_when:
- คุณต้องการการตั้งค่าแบบมีคำแนะนำสำหรับ gateway, workspace, auth, channels และ Skills
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw onboard` (การเริ่มต้นใช้งานแบบโต้ตอบ)
title: onboard
x-i18n:
generated_at: "2026-04-23T06:19:01Z"
model: gpt-5.4
provider: openai
source_hash: 348ee9cbc14ff78b588f10297e728473668a72f9f16be385f25022bf5108340c
source_path: cli/onboard.md
workflow: 15
---
# `openclaw onboard`
การเริ่มต้นใช้งานแบบโต้ตอบสำหรับการตั้งค่า Gateway แบบ local หรือระยะไกล
## คู่มือที่เกี่ยวข้อง
- ศูนย์รวมการเริ่มต้นใช้งาน CLI: [การเริ่มต้นใช้งาน (CLI)](/th/start/wizard)
- ภาพรวมการเริ่มต้นใช้งาน: [ภาพรวมการเริ่มต้นใช้งาน](/th/start/onboarding-overview)
- ข้อมูลอ้างอิงการเริ่มต้นใช้งาน CLI: [ข้อมูลอ้างอิงการตั้งค่า CLI](/th/start/wizard-cli-reference)
- ระบบอัตโนมัติของ CLI: [ระบบอัตโนมัติของ CLI](/th/start/wizard-cli-automation)
- การเริ่มต้นใช้งานบน macOS: [การเริ่มต้นใช้งาน (แอป macOS)](/th/start/onboarding)
## ตัวอย่าง
```bash
openclaw onboard
openclaw onboard --flow quickstart
openclaw onboard --flow manual
openclaw onboard --mode remote --remote-url wss://gateway-host:18789
```
สำหรับเป้าหมาย `ws://` แบบ plaintext บนเครือข่ายส่วนตัว (เฉพาะเครือข่ายที่เชื่อถือได้เท่านั้น) ให้ตั้งค่า
`OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1` ในสภาพแวดล้อมของกระบวนการ onboarding
provider แบบกำหนดเองในโหมด non-interactive:
```bash
openclaw onboard --non-interactive \
--auth-choice custom-api-key \
--custom-base-url "https://llm.example.com/v1" \
--custom-model-id "foo-large" \
--custom-api-key "$CUSTOM_API_KEY" \
--secret-input-mode plaintext \
--custom-compatibility openai
```
`--custom-api-key` เป็นตัวเลือกเสริมในโหมด non-interactive หากไม่ระบุ onboarding จะตรวจสอบ `CUSTOM_API_KEY`
LM Studio ยังรองรับแฟล็กคีย์เฉพาะ provider ในโหมด non-interactive:
```bash
openclaw onboard --non-interactive \
--auth-choice lmstudio \
--custom-base-url "http://localhost:1234/v1" \
--custom-model-id "qwen/qwen3.5-9b" \
--lmstudio-api-key "$LM_API_TOKEN" \
--accept-risk
```
Ollama ในโหมด non-interactive:
```bash
openclaw onboard --non-interactive \
--auth-choice ollama \
--custom-base-url "http://ollama-host:11434" \
--custom-model-id "qwen3.5:27b" \
--accept-risk
```
`--custom-base-url` มีค่าเริ่มต้นเป็น `http://127.0.0.1:11434` `--custom-model-id` เป็นตัวเลือกเสริม; หากไม่ระบุ onboarding จะใช้ค่าเริ่มต้นที่ Ollama แนะนำ model IDs บน cloud เช่น `kimi-k2.5:cloud` ก็ใช้ได้ที่นี่เช่นกัน
จัดเก็บคีย์ของ provider เป็น refs แทน plaintext:
```bash
openclaw onboard --non-interactive \
--auth-choice openai-api-key \
--secret-input-mode ref \
--accept-risk
```
เมื่อใช้ `--secret-input-mode ref` onboarding จะเขียน refs ที่อิง env แทนค่าคีย์แบบ plaintext
สำหรับ providers ที่อิง auth-profile การดำเนินการนี้จะเขียนรายการ `keyRef`; สำหรับ providers แบบกำหนดเอง การดำเนินการนี้จะเขียน `models.providers.<id>.apiKey` เป็น env ref (ตัวอย่างเช่น `{ source: "env", provider: "default", id: "CUSTOM_API_KEY" }`)
สัญญาของโหมด `ref` แบบ non-interactive:
- ตั้งค่า env var ของ provider ในสภาพแวดล้อมของกระบวนการ onboarding (เช่น `OPENAI_API_KEY`)
- อย่าส่งแฟล็กคีย์แบบ inline (เช่น `--openai-api-key`) เว้นแต่ env var นั้นจะถูกตั้งค่าไว้ด้วย
- หากส่งแฟล็กคีย์แบบ inline โดยไม่มี env var ที่จำเป็น onboarding จะล้มเหลวทันทีพร้อมคำแนะนำ
ตัวเลือก gateway token ในโหมด non-interactive:
- `--gateway-auth token --gateway-token <token>` จัดเก็บ token แบบ plaintext
- `--gateway-auth token --gateway-token-ref-env <name>` จัดเก็บ `gateway.auth.token` เป็น env SecretRef
- `--gateway-token` และ `--gateway-token-ref-env` ใช้ร่วมกันไม่ได้
- `--gateway-token-ref-env` ต้องมี env var ที่ไม่ว่างอยู่ในสภาพแวดล้อมของกระบวนการ onboarding
- เมื่อใช้ `--install-daemon` หาก token auth ต้องใช้ token, gateway tokens ที่จัดการด้วย SecretRef จะถูกตรวจสอบ แต่จะไม่ถูกบันทึกเป็น plaintext ที่ resolve แล้วใน metadata ของ environment ของบริการ supervisor
- เมื่อใช้ `--install-daemon` หากโหมด token ต้องใช้ token และ token SecretRef ที่กำหนดค่าไว้ยัง resolve ไม่ได้ onboarding จะล้มเหลวแบบ fail closed พร้อมคำแนะนำในการแก้ไข
- เมื่อใช้ `--install-daemon` หากมีการกำหนดค่าทั้ง `gateway.auth.token` และ `gateway.auth.password` และไม่ได้ตั้งค่า `gateway.auth.mode` onboarding จะบล็อกการติดตั้งจนกว่าจะตั้งค่า mode อย่างชัดเจน
- การเริ่มต้นใช้งานแบบ local จะเขียน `gateway.mode="local"` ลงใน config หากภายหลังไฟล์ config ไม่มี `gateway.mode` ให้ถือว่าเป็นความเสียหายของ config หรือการแก้ไขด้วยตนเองที่ไม่สมบูรณ์ ไม่ใช่ทางลัดของ local mode ที่ถูกต้อง
- `--allow-unconfigured` เป็น escape hatch ของ runtime ของ gateway แยกต่างหาก ไม่ได้หมายความว่า onboarding สามารถละเว้น `gateway.mode` ได้
ตัวอย่าง:
```bash
export OPENCLAW_GATEWAY_TOKEN="your-token"
openclaw onboard --non-interactive \
--mode local \
--auth-choice skip \
--gateway-auth token \
--gateway-token-ref-env OPENCLAW_GATEWAY_TOKEN \
--accept-risk
```
สถานะสุขภาพของ local gateway ในโหมด non-interactive:
- เว้นแต่คุณจะส่ง `--skip-health` onboarding จะรอให้ local gateway เข้าถึงได้ก่อนจึงจะออกสำเร็จ
- `--install-daemon` จะเริ่มเส้นทางการติดตั้ง gateway แบบจัดการให้ก่อน หากไม่ใช้ คุณต้องมี local gateway ที่กำลังรันอยู่แล้ว เช่น `openclaw gateway run`
- หากคุณต้องการเพียงการเขียน config/workspace/bootstrap ในระบบอัตโนมัติ ให้ใช้ `--skip-health`
- บน Windows แบบ native, `--install-daemon` จะพยายามใช้ Scheduled Tasks ก่อน และจะ fallback ไปยัง login item ต่อผู้ใช้ในโฟลเดอร์ Startup หากการสร้าง task ถูกปฏิเสธ
พฤติกรรมการเริ่มต้นใช้งานแบบโต้ตอบในโหมด reference:
- เลือก **Use secret reference** เมื่อมีพรอมป์ต์
- จากนั้นเลือกอย่างใดอย่างหนึ่ง:
- ตัวแปรสภาพแวดล้อม
- provider ของ secret ที่ตั้งค่าไว้ (`file` หรือ `exec`)
- Onboarding จะทำการตรวจสอบ preflight แบบรวดเร็วก่อนบันทึก ref
- หากการตรวจสอบล้มเหลว onboarding จะแสดงข้อผิดพลาดและให้คุณลองใหม่ได้
ตัวเลือก endpoint ของ Z.AI ในโหมด non-interactive:
หมายเหตุ: ขณะนี้ `--auth-choice zai-api-key` จะตรวจจับ endpoint ของ Z.AI ที่เหมาะสมที่สุดสำหรับคีย์ของคุณโดยอัตโนมัติ (ให้ความสำคัญกับ general API ที่ใช้ `zai/glm-5.1`)
หากคุณต้องการ GLM Coding Plan endpoints โดยเฉพาะ ให้เลือก `zai-coding-global` หรือ `zai-coding-cn`
```bash
# การเลือก endpoint โดยไม่มีพรอมป์ต์
openclaw onboard --non-interactive \
--auth-choice zai-coding-global \
--zai-api-key "$ZAI_API_KEY"
# ตัวเลือก endpoint ของ Z.AI อื่น ๆ:
# --auth-choice zai-coding-cn
# --auth-choice zai-global
# --auth-choice zai-cn
```
ตัวอย่าง Mistral แบบ non-interactive:
```bash
openclaw onboard --non-interactive \
--auth-choice mistral-api-key \
--mistral-api-key "$MISTRAL_API_KEY"
```
หมายเหตุเกี่ยวกับ flow:
- `quickstart`: พรอมป์ต์น้อยที่สุด สร้าง gateway token โดยอัตโนมัติ
- `manual`: พรอมป์ต์แบบเต็มสำหรับ port/bind/auth (ชื่อเรียกแทนของ `advanced`)
- เมื่อ auth choice บ่งชี้ถึง provider ที่ควรใช้เป็นพิเศษ onboarding จะ prefilter ตัวเลือก default-model และ allowlist ไปยัง provider นั้น สำหรับ Volcengine และ BytePlus จะรวมถึงรุ่น coding-plan ด้วย
(`volcengine-plan/*`, `byteplus-plan/*`)
- หากตัวกรอง preferred-provider ยังไม่พบ models ที่โหลดไว้ onboarding จะ fallback ไปใช้ catalog ที่ไม่กรอง แทนที่จะปล่อยให้ตัวเลือกว่าง
- ในขั้นตอน web-search บาง providers อาจทำให้เกิดพรอมป์ต์ติดตามผลเฉพาะ provider:
- **Grok** อาจเสนอการตั้งค่า `x_search` แบบไม่บังคับด้วย `XAI_API_KEY` เดียวกัน
และตัวเลือกโมเดล `x_search`
- **Kimi** อาจถาม region ของ Moonshot API (`api.moonshot.ai` เทียบกับ
`api.moonshot.cn`) และโมเดล web-search เริ่มต้นของ Kimi
- พฤติกรรมขอบเขต DM ของการเริ่มต้นใช้งานแบบ local: [ข้อมูลอ้างอิงการตั้งค่า CLI](/th/start/wizard-cli-reference#outputs-and-internals)
- แชตแรกที่เร็วที่สุด: `openclaw dashboard` (Control UI โดยไม่ต้องตั้งค่า channel)
- Custom Provider: เชื่อมต่อ endpoint ที่เข้ากันได้กับ OpenAI หรือ Anthropic ใดก็ได้
รวมถึง providers แบบ hosted ที่ไม่ได้ระบุไว้ ใช้ Unknown เพื่อตรวจจับอัตโนมัติ
## คำสั่งติดตามผลที่พบบ่อย
```bash
openclaw configure
openclaw agents add <name>
```
<Note>
`--json` ไม่ได้หมายความว่าเป็นโหมด non-interactive ใช้ `--non-interactive` สำหรับสคริปต์
</Note>

72
docs/th/cli/pairing.md Normal file
View File

@ -0,0 +1,72 @@
---
read_when:
- คุณกำลังใช้ข้อความส่วนตัวใน pairing-mode และต้องอนุมัติผู้ส่ง
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw pairing` (อนุมัติ/แสดงรายการคำขอจับคู่)
title: pairing
x-i18n:
generated_at: "2026-04-23T06:19:08Z"
model: gpt-5.4
provider: openai
source_hash: 122a608ef83ec2b1011fdfd1b59b94950a4dcc8b598335b0956e2eedece4958f
source_path: cli/pairing.md
workflow: 15
---
# `openclaw pairing`
อนุมัติหรือตรวจสอบคำขอจับคู่ DM (สำหรับ channel ที่รองรับการจับคู่)
ที่เกี่ยวข้อง:
- โฟลว์การจับคู่: [Pairing](/th/channels/pairing)
## คำสั่ง
```bash
openclaw pairing list telegram
openclaw pairing list --channel telegram --account work
openclaw pairing list telegram --json
openclaw pairing approve <code>
openclaw pairing approve telegram <code>
openclaw pairing approve --channel telegram --account work <code> --notify
```
## `pairing list`
แสดงรายการคำขอจับคู่ที่รอดำเนินการสำหรับหนึ่ง channel
ตัวเลือก:
- `[channel]`: ID ของ channel แบบ positional
- `--channel <channel>`: ID ของ channel แบบระบุชัดเจน
- `--account <accountId>`: ID ของบัญชีสำหรับ channel แบบหลายบัญชี
- `--json`: เอาต์พุตที่เครื่องอ่านได้
หมายเหตุ:
- หากมีการตั้งค่า channel ที่รองรับการจับคู่หลายรายการ คุณต้องระบุ channel ไม่ว่าจะในรูปแบบ positional หรือด้วย `--channel`
- อนุญาตให้ใช้ channel ของ extension ได้ ตราบใดที่ ID ของ channel ถูกต้อง
## `pairing approve`
อนุมัติรหัสจับคู่ที่รอดำเนินการและอนุญาตผู้ส่งนั้น
การใช้งาน:
- `openclaw pairing approve <channel> <code>`
- `openclaw pairing approve --channel <channel> <code>`
- `openclaw pairing approve <code>` เมื่อมีการตั้งค่า channel ที่รองรับการจับคู่ไว้เพียงหนึ่งรายการเท่านั้น
ตัวเลือก:
- `--channel <channel>`: ID ของ channel แบบระบุชัดเจน
- `--account <accountId>`: ID ของบัญชีสำหรับ channel แบบหลายบัญชี
- `--notify`: ส่งการยืนยันกลับไปยังผู้ร้องขอบน channel เดียวกัน
## หมายเหตุ
- อินพุต channel: ส่งแบบ positional (`pairing list telegram`) หรือด้วย `--channel <channel>`
- `pairing list` รองรับ `--account <accountId>` สำหรับ channel แบบหลายบัญชี
- `pairing approve` รองรับ `--account <accountId>` และ `--notify`
- หากมีการตั้งค่า channel ที่รองรับการจับคู่เพียงหนึ่งรายการ อนุญาตให้ใช้ `pairing approve <code>` ได้

324
docs/th/cli/plugins.md Normal file
View File

@ -0,0 +1,324 @@
---
read_when:
- คุณต้องการติดตั้งหรือจัดการ plugins ของ Gateway หรือ bundles ที่เข้ากันได้
- คุณต้องการดีบักความล้มเหลวในการโหลด Plugin
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw plugins` (แสดงรายการ, ติดตั้ง, มาร์เก็ตเพลส, ถอนการติดตั้ง, เปิด/ปิดใช้งาน, doctor)
title: plugins
x-i18n:
generated_at: "2026-04-23T06:19:12Z"
model: gpt-5.4
provider: openai
source_hash: ad76a8068054d145db578ed01f1fb0726fff884c48d256ad8c0b708a516cd727
source_path: cli/plugins.md
workflow: 15
---
# `openclaw plugins`
จัดการ plugins ของ Gateway, hook packs และ bundles ที่เข้ากันได้
ที่เกี่ยวข้อง:
- ระบบ Plugin: [Plugins](/th/tools/plugin)
- ความเข้ากันได้ของ bundle: [Plugin bundles](/th/plugins/bundles)
- manifest และ schema ของ Plugin: [Plugin manifest](/th/plugins/manifest)
- การเสริมความแข็งแกร่งด้านความปลอดภัย: [Security](/th/gateway/security)
## คำสั่ง
```bash
openclaw plugins list
openclaw plugins list --enabled
openclaw plugins list --verbose
openclaw plugins list --json
openclaw plugins install <path-or-spec>
openclaw plugins inspect <id>
openclaw plugins inspect <id> --json
openclaw plugins inspect --all
openclaw plugins info <id>
openclaw plugins enable <id>
openclaw plugins disable <id>
openclaw plugins uninstall <id>
openclaw plugins doctor
openclaw plugins update <id-or-npm-spec>
openclaw plugins update --all
openclaw plugins marketplace list <marketplace>
openclaw plugins marketplace list <marketplace> --json
```
plugins ที่มาพร้อมกับ OpenClaw จะถูกรวมมากับตัวโปรแกรม บางตัวเปิดใช้งานโดยค่าเริ่มต้น (เช่น
providers ของโมเดลที่มาพร้อมกัน providers ของเสียงพูดที่มาพร้อมกัน และ browser
Plugin ที่มาพร้อมกัน); ส่วนตัวอื่นต้องใช้ `plugins enable`
plugins ของ OpenClaw แบบ native ต้องมี `openclaw.plugin.json` พร้อม JSON
Schema แบบ inline (`configSchema` แม้จะว่างก็ตาม) ส่วน bundles ที่เข้ากันได้จะใช้
bundle manifests ของตัวเองแทน
`plugins list` จะแสดง `Format: openclaw` หรือ `Format: bundle` เอาต์พุต list/info
แบบ verbose จะแสดง subtype ของ bundle (`codex`, `claude` หรือ `cursor`) พร้อมทั้งความสามารถของ bundle
ที่ตรวจพบด้วย
### ติดตั้ง
```bash
openclaw plugins install <package> # ClawHub ก่อน แล้วจึง npm
openclaw plugins install clawhub:<package> # ClawHub เท่านั้น
openclaw plugins install <package> --force # เขียนทับการติดตั้งที่มีอยู่
openclaw plugins install <package> --pin # ตรึงเวอร์ชัน
openclaw plugins install <package> --dangerously-force-unsafe-install
openclaw plugins install <path> # พาธในเครื่อง
openclaw plugins install <plugin>@<marketplace> # marketplace
openclaw plugins install <plugin> --marketplace <name> # marketplace (ระบุชัดเจน)
openclaw plugins install <plugin> --marketplace https://github.com/<owner>/<repo>
```
ชื่อแพ็กเกจแบบเปล่าจะถูกตรวจสอบกับ ClawHub ก่อน แล้วจึง npm หมายเหตุด้านความปลอดภัย:
ให้มองการติดตั้ง Plugin เหมือนการรันโค้ด ควรใช้เวอร์ชันที่ตรึงไว้
หาก config ไม่ถูกต้อง โดยปกติ `plugins install` จะล้มเหลวแบบปิดไว้ก่อน และบอกให้คุณ
รัน `openclaw doctor --fix` ก่อน ข้อยกเว้นเดียวที่มีเอกสารระบุไว้คือเส้นทางกู้คืน
bundled-plugin แบบจำกัดสำหรับ plugins ที่ opt in อย่างชัดเจนกับ
`openclaw.install.allowInvalidConfigRecovery`
`--force` จะใช้เป้าหมายการติดตั้งเดิมซ้ำและเขียนทับ Plugin หรือ hook pack
ที่ติดตั้งไว้แล้วในตำแหน่งเดิม ใช้เมื่อต้องการติดตั้ง id เดิมซ้ำอย่างตั้งใจ
จากพาธในเครื่องใหม่ ไฟล์บีบอัด แพ็กเกจ ClawHub หรืออาร์ติแฟกต์ npm
สำหรับการอัปเกรดตามปกติของ npm Plugin ที่มีการติดตามอยู่แล้ว ให้ใช้
`openclaw plugins update <id-or-npm-spec>`
`--pin` ใช้ได้กับการติดตั้ง npm เท่านั้น ไม่รองรับร่วมกับ `--marketplace`
เพราะการติดตั้งจาก marketplace จะบันทึกข้อมูลเมทาดาทาต้นทางของ marketplace แทน
npm spec
`--dangerously-force-unsafe-install` เป็นตัวเลือกใช้ในกรณีฉุกเฉินสำหรับ false positive
จากตัวสแกนโค้ดอันตรายในตัว มันอนุญาตให้การติดตั้งดำเนินต่อได้แม้ตัวสแกนในตัว
จะรายงานผลการตรวจพบระดับ `critical` แต่ **ไม่** ข้ามการบล็อกตามนโยบายของ hook
`before_install` ของ Plugin และ **ไม่** ข้ามการบล็อกจาก scan failure
แฟลก CLI นี้ใช้กับโฟลว์การติดตั้ง/อัปเดต Plugin ส่วนการติดตั้ง dependency ของ Skills
ที่อาศัย Gateway จะใช้ request override ที่ตรงกันคือ `dangerouslyForceUnsafeInstall` ขณะที่
`openclaw skills install` ยังคงเป็นโฟลว์ดาวน์โหลด/ติดตั้ง Skills จาก ClawHub แยกต่างหาก
`plugins install` ยังเป็นพื้นผิวการติดตั้งสำหรับ hook packs ที่เปิดให้ใช้
`openclaw.hooks` ใน `package.json` ด้วย ให้ใช้ `openclaw hooks` สำหรับการดู hook
แบบกรองและการเปิดใช้งานราย hook ไม่ใช่สำหรับการติดตั้งแพ็กเกจ
สเปก npm เป็นแบบ **registry-only** (ชื่อแพ็กเกจ + **เวอร์ชันแบบตรงตัว** หรือ
**dist-tag** แบบไม่บังคับ) ระบบจะปฏิเสธสเปกแบบ Git/URL/file และช่วง semver
การติดตั้ง dependency จะรันพร้อม `--ignore-scripts` เพื่อความปลอดภัย
สเปกเปล่าและ `@latest` จะอยู่ในสายเสถียร หาก npm resolve อย่างใดอย่างหนึ่ง
เหล่านั้นไปเป็นรุ่น prerelease, OpenClaw จะหยุดและขอให้คุณ opt in อย่างชัดเจนด้วย
แท็ก prerelease เช่น `@beta`/`@rc` หรือเวอร์ชัน prerelease แบบตรงตัว เช่น
`@1.2.3-beta.4`
หากสเปกการติดตั้งแบบเปล่าตรงกับ id ของ bundled Plugin (เช่น `diffs`), OpenClaw
จะติดตั้ง bundled Plugin นั้นโดยตรง หากต้องการติดตั้งแพ็กเกจ npm ที่ชื่อเดียวกัน
ให้ใช้สเปกแบบมี scope อย่างชัดเจน (เช่น `@scope/diffs`)
ไฟล์บีบอัดที่รองรับ: `.zip`, `.tgz`, `.tar.gz`, `.tar`
รองรับการติดตั้งจาก Claude marketplace ด้วย
การติดตั้งจาก ClawHub ใช้ตัวระบุตำแหน่ง `clawhub:<package>` อย่างชัดเจน:
```bash
openclaw plugins install clawhub:openclaw-codex-app-server
openclaw plugins install clawhub:openclaw-codex-app-server@1.2.3
```
ตอนนี้ OpenClaw ยังให้ความสำคัญกับ ClawHub ก่อนสำหรับสเปก Plugin แบบ bare ที่ปลอดภัยกับ npm ด้วย
มันจะ fallback ไปยัง npm ก็ต่อเมื่อ ClawHub ไม่มีแพ็กเกจหรือเวอร์ชันนั้น:
```bash
openclaw plugins install openclaw-codex-app-server
```
OpenClaw จะดาวน์โหลดไฟล์บีบอัดของแพ็กเกจจาก ClawHub ตรวจสอบ
ความเข้ากันได้ของ plugin API / minimum gateway ตามที่ประกาศ แล้วจึงติดตั้งผ่าน
เส้นทางไฟล์บีบอัดตามปกติ การติดตั้งที่บันทึกไว้จะเก็บเมทาดาต้าต้นทางของ ClawHub ไว้สำหรับการอัปเดตภายหลัง
ใช้รูปแบบย่อ `plugin@marketplace` เมื่อมีชื่อ marketplace อยู่ในแคช local registry
ของ Claude ที่ `~/.claude/plugins/known_marketplaces.json`:
```bash
openclaw plugins marketplace list <marketplace-name>
openclaw plugins install <plugin-name>@<marketplace-name>
```
ใช้ `--marketplace` เมื่อคุณต้องการส่งต้นทางของ marketplace อย่างชัดเจน:
```bash
openclaw plugins install <plugin-name> --marketplace <marketplace-name>
openclaw plugins install <plugin-name> --marketplace <owner/repo>
openclaw plugins install <plugin-name> --marketplace https://github.com/<owner>/<repo>
openclaw plugins install <plugin-name> --marketplace ./my-marketplace
```
ต้นทางของ marketplace สามารถเป็น:
- ชื่อ known-marketplace ของ Claude จาก `~/.claude/plugins/known_marketplaces.json`
- root ของ marketplace ในเครื่องหรือพาธ `marketplace.json`
- รูปแบบย่อ repo ของ GitHub เช่น `owner/repo`
- URL ของ repo บน GitHub เช่น `https://github.com/owner/repo`
- git URL
สำหรับ marketplace ระยะไกลที่โหลดจาก GitHub หรือ git รายการ Plugin ต้องยังอยู่
ภายใน repo ของ marketplace ที่ถูก clone มา OpenClaw ยอมรับแหล่งที่มาที่เป็นพาธแบบ relative จาก
repo นั้น และจะปฏิเสธแหล่งที่มาของ Plugin จาก manifest ระยะไกลที่เป็น HTTP(S), absolute-path,
git, GitHub และแบบอื่นที่ไม่ใช่พาธ
สำหรับพาธในเครื่องและไฟล์บีบอัด OpenClaw จะตรวจจับอัตโนมัติ:
- plugins ของ OpenClaw แบบ native (`openclaw.plugin.json`)
- bundles ที่เข้ากันได้กับ Codex (`.codex-plugin/plugin.json`)
- bundles ที่เข้ากันได้กับ Claude (`.claude-plugin/plugin.json` หรือเลย์เอาต์
component เริ่มต้นของ Claude)
- bundles ที่เข้ากันได้กับ Cursor (`.cursor-plugin/plugin.json`)
bundles ที่เข้ากันได้จะถูกติดตั้งลงใน root ของ extensions ตามปกติและเข้าร่วมในโฟลว์
list/info/enable/disable เดียวกัน ปัจจุบันรองรับ Skills ใน bundle,
command-skills ของ Claude, ค่าเริ่มต้น `settings.json` ของ Claude, ค่าเริ่มต้น
`.lsp.json` / `lspServers` ที่ประกาศใน manifest ของ Claude, command-skills ของ Cursor
และไดเรกทอรี hook ของ Codex ที่เข้ากันได้ ส่วนความสามารถของ bundle อื่นที่ตรวจพบ
จะแสดงใน diagnostics/info แต่ยังไม่เชื่อมเข้ากับการทำงานขณะรันในตอนนี้
### แสดงรายการ
```bash
openclaw plugins list
openclaw plugins list --enabled
openclaw plugins list --verbose
openclaw plugins list --json
```
ใช้ `--enabled` เพื่อแสดงเฉพาะ plugins ที่โหลดอยู่ ใช้ `--verbose` เพื่อสลับจาก
มุมมองแบบตารางไปเป็นบรรทัดรายละเอียดราย Plugin พร้อมเมทาดาต้า
เกี่ยวกับ source/origin/version/activation ใช้ `--json` สำหรับ inventory
ที่เครื่องอ่านได้พร้อม diagnostics ของ registry
ใช้ `--link` เพื่อหลีกเลี่ยงการคัดลอกไดเรกทอรีในเครื่อง (เพิ่มเข้า `plugins.load.paths`):
```bash
openclaw plugins install -l ./my-plugin
```
`--force` ไม่รองรับร่วมกับ `--link` เพราะการติดตั้งแบบลิงก์จะใช้พาธต้นทาง
แทนการคัดลอกทับเป้าหมายการติดตั้งที่ถูกจัดการ
ใช้ `--pin` กับการติดตั้ง npm เพื่อบันทึกสเปก exact ที่ resolve แล้ว (`name@version`) ลงใน
`plugins.installs` ขณะที่พฤติกรรมค่าเริ่มต้นยังคงไม่ตรึงเวอร์ชัน
### ถอนการติดตั้ง
```bash
openclaw plugins uninstall <id>
openclaw plugins uninstall <id> --dry-run
openclaw plugins uninstall <id> --keep-files
```
`uninstall` จะลบบันทึกของ Plugin ออกจาก `plugins.entries`, `plugins.installs`,
allowlist ของ Plugin และรายการ `plugins.load.paths` แบบลิงก์เมื่อเกี่ยวข้อง
สำหรับ Active Memory plugins ช่องหน่วยความจำจะรีเซ็ตเป็น `memory-core`
โดยค่าเริ่มต้น การถอนการติดตั้งจะลบไดเรกทอรีติดตั้งของ Plugin ใต้
root ของ Plugin ใน state-dir ที่กำลังใช้งานด้วย ใช้
`--keep-files` เพื่อเก็บไฟล์ไว้บนดิสก์
รองรับ `--keep-config` เป็นนามแฝงที่เลิกใช้แล้วของ `--keep-files`
### อัปเดต
```bash
openclaw plugins update <id-or-npm-spec>
openclaw plugins update --all
openclaw plugins update <id-or-npm-spec> --dry-run
openclaw plugins update @openclaw/voice-call@beta
openclaw plugins update openclaw-codex-app-server --dangerously-force-unsafe-install
```
การอัปเดตจะใช้กับการติดตั้งที่ติดตามไว้ใน `plugins.installs` และการติดตั้ง
hook-pack ที่ติดตามไว้ใน `hooks.internal.installs`
เมื่อคุณส่ง id ของ Plugin OpenClaw จะใช้สเปกการติดตั้งที่บันทึกไว้สำหรับ
Plugin นั้นซ้ำ หมายความว่า dist-tag ที่เก็บไว้ก่อนหน้า เช่น `@beta` และ
เวอร์ชัน exact ที่ตรึงไว้ จะยังคงถูกใช้ต่อในการรัน `update <id>` ภายหลัง
สำหรับการติดตั้ง npm คุณยังสามารถส่ง npm package spec แบบชัดเจนพร้อม dist-tag
หรือเวอร์ชัน exact ได้ OpenClaw จะ resolve ชื่อแพ็กเกจนั้นกลับไปยังระเบียน Plugin ที่ติดตามไว้
อัปเดต Plugin ที่ติดตั้งนั้น และบันทึก npm spec ใหม่ไว้สำหรับการอัปเดตตาม id ในอนาคต
การส่งชื่อแพ็กเกจ npm โดยไม่มีเวอร์ชันหรือแท็ก ก็จะ resolve กลับไปยัง
ระเบียน Plugin ที่ติดตามไว้เช่นกัน ใช้ในกรณีที่ Plugin ถูกตรึงไว้ที่เวอร์ชัน exact และ
คุณต้องการย้ายกลับไปยังสายรีลีสค่าเริ่มต้นของ registry
ก่อนการอัปเดต npm แบบสด OpenClaw จะตรวจสอบเวอร์ชันของแพ็กเกจที่ติดตั้งเทียบกับ
เมทาดาต้าของ npm registry หากเวอร์ชันที่ติดตั้งและตัวตนอาร์ติแฟกต์
ที่บันทึกไว้ตรงกับเป้าหมายที่ resolve แล้วอยู่ก่อนแล้ว การอัปเดตจะถูกข้ามไปโดยไม่
ดาวน์โหลด ติดตั้งซ้ำ หรือเขียน `openclaw.json` ใหม่
เมื่อมีแฮชความถูกต้องที่บันทึกไว้และแฮชของอาร์ติแฟกต์ที่ดึงมาเปลี่ยนไป
OpenClaw จะถือว่านี่คือ npm artifact drift คำสั่ง
`openclaw plugins update` แบบโต้ตอบจะพิมพ์แฮชที่คาดหวังและแฮชจริง พร้อมถาม
การยืนยันก่อนดำเนินการต่อ ส่วนตัวช่วยอัปเดตแบบไม่โต้ตอบจะล้มเหลวแบบปิดไว้ก่อน
เว้นแต่ผู้เรียกจะส่งนโยบายให้ดำเนินการต่ออย่างชัดเจน
`--dangerously-force-unsafe-install` ยังใช้ได้กับ `plugins update` ในฐานะ
ตัวเลือกฉุกเฉินสำหรับ false positive ของการสแกนโค้ดอันตรายในตัวระหว่าง
การอัปเดต Plugin แต่มันก็ยังไม่ข้ามการบล็อกตามนโยบาย `before_install` ของ Plugin
หรือการบล็อกจาก scan-failure และใช้ได้เฉพาะกับการอัปเดต Plugin ไม่ใช่การอัปเดต hook-pack
### Inspect
```bash
openclaw plugins inspect <id>
openclaw plugins inspect <id> --json
```
การตรวจสอบเชิงลึกสำหรับ Plugin เดียว แสดงตัวตน สถานะการโหลด แหล่งที่มา
ความสามารถที่ลงทะเบียนไว้ hooks, tools, commands, services, เมธอดของ Gateway,
เส้นทาง HTTP, แฟล็กนโยบาย, diagnostics, เมทาดาต้าการติดตั้ง, ความสามารถของ bundle
และการรองรับ MCP หรือ LSP server ที่ตรวจพบ
แต่ละ Plugin จะถูกจัดประเภทตามสิ่งที่มันลงทะเบียนจริงขณะรัน:
- **plain-capability** — มีความสามารถเพียงประเภทเดียว (เช่น Plugin ที่เป็น provider อย่างเดียว)
- **hybrid-capability** — มีหลายประเภทความสามารถ (เช่น text + speech + images)
- **hook-only** — มีเฉพาะ hooks ไม่มี capabilities หรือ surfaces
- **non-capability** — มี tools/commands/services แต่ไม่มี capabilities
ดู [รูปร่างของ Plugin](/th/plugins/architecture#plugin-shapes) สำหรับข้อมูลเพิ่มเติมเกี่ยวกับโมเดลความสามารถ
แฟลก `--json` จะส่งออกรายงานที่เครื่องอ่านได้ เหมาะสำหรับการเขียนสคริปต์และ
การตรวจสอบ
`inspect --all` จะแสดงตารางทั้งชุด พร้อมคอลัมน์ shape, ชนิดของ capability,
ประกาศความเข้ากันได้, ความสามารถของ bundle และสรุป hook
`info` เป็นนามแฝงของ `inspect`
### Doctor
```bash
openclaw plugins doctor
```
`doctor` จะรายงานข้อผิดพลาดในการโหลด Plugin, diagnostics ของ manifest/discovery และ
ประกาศความเข้ากันได้ เมื่อทุกอย่างเรียบร้อยดีแล้ว มันจะแสดง `No plugin issues
detected.`
สำหรับความล้มเหลวเกี่ยวกับรูปร่างของโมดูล เช่น ไม่มี export `register`/`activate` ให้รันใหม่
พร้อม `OPENCLAW_PLUGIN_LOAD_DEBUG=1` เพื่อรวมสรุปรูปร่าง export แบบย่อไว้ใน
เอาต์พุตการวินิจฉัย
### Marketplace
```bash
openclaw plugins marketplace list <source>
openclaw plugins marketplace list <source> --json
```
รายการ marketplace รับได้ทั้งพาธ marketplace ในเครื่อง พาธ `marketplace.json`
รูปแบบย่อของ GitHub อย่าง `owner/repo`, URL ของ GitHub repo หรือ git URL `--json`
จะพิมพ์ป้ายกำกับต้นทางที่ resolve แล้ว พร้อม manifest ของ marketplace และ
รายการ Plugin ที่แยกวิเคราะห์แล้ว

59
docs/th/cli/qr.md Normal file
View File

@ -0,0 +1,59 @@
---
read_when:
- คุณต้องการจับคู่แอป Node บนมือถือกับ Gateway อย่างรวดเร็ว
- คุณต้องการเอาต์พุต setup-code สำหรับการแชร์จากระยะไกล/ด้วยตนเอง
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw qr` (สร้าง QR สำหรับการจับคู่บนมือถือ + รหัสตั้งค่า)
title: QR
x-i18n:
generated_at: "2026-04-23T06:19:19Z"
model: gpt-5.4
provider: openai
source_hash: ee6469334ad09037318f938c7ac609b7d5e3385c0988562501bb02a1bfa411ff
source_path: cli/qr.md
workflow: 15
---
# `openclaw qr`
สร้าง QR สำหรับการจับคู่บนมือถือและ setup code จากการกำหนดค่า Gateway ปัจจุบันของคุณ
## การใช้งาน
```bash
openclaw qr
openclaw qr --setup-code-only
openclaw qr --json
openclaw qr --remote
openclaw qr --url wss://gateway.example/ws
```
## ตัวเลือก
- `--remote`: ให้ใช้ `gateway.remote.url` ก่อน; หากยังไม่ได้ตั้งค่า `gateway.tailscale.mode=serve|funnel` ก็ยังสามารถให้ URL สาธารณะระยะไกลได้
- `--url <url>`: แทนที่ URL ของ gateway ที่ใช้ใน payload
- `--public-url <url>`: แทนที่ URL สาธารณะที่ใช้ใน payload
- `--token <token>`: แทนที่ว่าจะใช้โทเค็น gateway ใดในการยืนยันตัวตนของโฟลว์ bootstrap
- `--password <password>`: แทนที่ว่าจะใช้รหัสผ่าน gateway ใดในการยืนยันตัวตนของโฟลว์ bootstrap
- `--setup-code-only`: พิมพ์เฉพาะ setup code
- `--no-ascii`: ข้ามการเรนเดอร์ QR แบบ ASCII
- `--json`: ส่งออก JSON (`setupCode`, `gatewayUrl`, `auth`, `urlSource`)
## หมายเหตุ
- `--token` และ `--password` ใช้ร่วมกันไม่ได้
- ตอนนี้ setup code เองจะมี `bootstrapToken` แบบทึบที่มีอายุสั้น ไม่ใช่โทเค็น/รหัสผ่าน gateway ที่ใช้ร่วมกัน
- ในโฟลว์ bootstrap แบบ node/operator ที่มีมาในตัว โทเค็น node หลักยังคงถูกสร้างด้วย `scopes: []`
- หากการส่งต่อ bootstrap ออกโทเค็น operator ด้วย โทเค็นนั้นจะยังคงถูกจำกัดอยู่ใน allowlist ของ bootstrap: `operator.approvals`, `operator.read`, `operator.talk.secrets`, `operator.write`
- การตรวจสอบขอบเขตของ bootstrap ใช้คำนำหน้าตาม role allowlist ของ operator ดังกล่าวจะตอบสนองได้เฉพาะคำขอของ operator; role ที่ไม่ใช่ operator ยังต้องมี scopes ภายใต้คำนำหน้าของ role ของตนเอง
- การจับคู่บนมือถือจะ fail closed สำหรับ URL gateway แบบ `ws://` ที่เป็น Tailscale/สาธารณะ ส่วน `ws://` บน private LAN ยังรองรับอยู่ แต่เส้นทางมือถือผ่าน Tailscale/สาธารณะควรใช้ Tailscale Serve/Funnel หรือ URL gateway แบบ `wss://`
- เมื่อใช้ `--remote`, OpenClaw ต้องการอย่างใดอย่างหนึ่งระหว่าง `gateway.remote.url` หรือ
`gateway.tailscale.mode=serve|funnel`
- เมื่อใช้ `--remote` หากข้อมูลรับรอง remote ที่มีผลใช้งานจริงถูกกำหนดเป็น SecretRefs และคุณไม่ได้ส่ง `--token` หรือ `--password` คำสั่งจะ resolve ข้อมูลเหล่านั้นจาก snapshot ของ gateway ที่กำลังใช้งานอยู่ หาก gateway ไม่พร้อมใช้งาน คำสั่งจะล้มเหลวทันที
- หากไม่ใช้ `--remote`, SecretRefs สำหรับการยืนยันตัวตนของ local gateway จะถูก resolve เมื่อไม่มีการแทนที่ auth ผ่าน CLI:
- `gateway.auth.token` จะถูก resolve เมื่อการยืนยันตัวตนด้วยโทเค็นสามารถชนะได้ (ตั้ง `gateway.auth.mode="token"` อย่างชัดเจน หรือเป็นโหมดที่อนุมานได้เมื่อไม่มีแหล่งรหัสผ่านใดชนะ)
- `gateway.auth.password` จะถูก resolve เมื่อการยืนยันตัวตนด้วยรหัสผ่านสามารถชนะได้ (ตั้ง `gateway.auth.mode="password"` อย่างชัดเจน หรือเป็นโหมดที่อนุมานได้โดยไม่มีโทเค็นที่ชนะจาก auth/env)
- หากมีการกำหนดทั้ง `gateway.auth.token` และ `gateway.auth.password` (รวมถึง SecretRefs) และไม่ได้ตั้ง `gateway.auth.mode` ไว้ การ resolve setup code จะล้มเหลวจนกว่าจะตั้งโหมดอย่างชัดเจน
- หมายเหตุเรื่องเวอร์ชัน Gateway ไม่ตรงกัน: เส้นทางคำสั่งนี้ต้องใช้ gateway ที่รองรับ `secrets.resolve`; gateway รุ่นเก่าจะส่งข้อผิดพลาด unknown-method กลับมา
- หลังจากสแกนแล้ว ให้อนุมัติการจับคู่อุปกรณ์ด้วย:
- `openclaw devices list`
- `openclaw devices approve <requestId>`

42
docs/th/cli/reset.md Normal file
View File

@ -0,0 +1,42 @@
---
read_when:
- คุณต้องการล้างสถานะในเครื่องโดยยังคงติดตั้ง CLI ไว้ต่อไป
- คุณต้องการดูตัวอย่างล่วงหน้าว่าอะไรจะถูกลบออกบ้าง
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw reset` (รีเซ็ตสถานะ/การกำหนดค่าในเครื่อง)
title: รีเซ็ต
x-i18n:
generated_at: "2026-04-23T06:19:19Z"
model: gpt-5.4
provider: openai
source_hash: ad464700f948bebe741ec309f25150714f0b280834084d4f531327418a42c79b
source_path: cli/reset.md
workflow: 15
---
# `openclaw reset`
รีเซ็ต config/สถานะในเครื่อง (ยังคงติดตั้ง CLI ไว้)
ตัวเลือก:
- `--scope <scope>`: `config`, `config+creds+sessions` หรือ `full`
- `--yes`: ข้ามข้อความยืนยัน
- `--non-interactive`: ปิดใช้งานข้อความถาม; ต้องใช้ร่วมกับ `--scope` และ `--yes`
- `--dry-run`: พิมพ์การดำเนินการโดยไม่ลบไฟล์
ตัวอย่าง:
```bash
openclaw backup create
openclaw reset
openclaw reset --dry-run
openclaw reset --scope config --yes --non-interactive
openclaw reset --scope config+creds+sessions --yes --non-interactive
openclaw reset --scope full --yes --non-interactive
```
หมายเหตุ:
- รัน `openclaw backup create` ก่อน หากคุณต้องการสแนปชอตที่กู้คืนได้ก่อนลบสถานะในเครื่อง
- หากคุณไม่ระบุ `--scope`, `openclaw reset` จะใช้ข้อความถามแบบโต้ตอบเพื่อเลือกสิ่งที่จะลบ
- `--non-interactive` ใช้ได้ก็ต่อเมื่อตั้งค่าทั้ง `--scope` และ `--yes` แล้ว

204
docs/th/cli/sandbox.md Normal file
View File

@ -0,0 +1,204 @@
---
read_when: You are managing sandbox runtimes or debugging sandbox/tool-policy behavior.
status: active
summary: จัดการ runtime ของ sandbox และตรวจสอบนโยบาย sandbox ที่มีผลใช้งานจริง
title: CLI ของ Sandbox
x-i18n:
generated_at: "2026-04-23T06:19:18Z"
model: gpt-5.4
provider: openai
source_hash: fa2783037da2901316108d35e04bb319d5d57963c2764b9146786b3c6474b48a
source_path: cli/sandbox.md
workflow: 15
---
# CLI ของ Sandbox
จัดการ runtime ของ sandbox สำหรับการรัน agent แบบแยกส่วน
## ภาพรวม
OpenClaw สามารถรัน agent ใน runtime ของ sandbox แบบแยกส่วนเพื่อความปลอดภัย คำสั่ง `sandbox` ช่วยให้คุณตรวจสอบและสร้าง runtime เหล่านั้นใหม่หลังการอัปเดตหรือการเปลี่ยนแปลงการตั้งค่า
ปัจจุบันโดยทั่วไปหมายถึง:
- คอนเทนเนอร์ Docker sandbox
- runtime ของ SSH sandbox เมื่อ `agents.defaults.sandbox.backend = "ssh"`
- runtime ของ OpenShell sandbox เมื่อ `agents.defaults.sandbox.backend = "openshell"`
สำหรับ `ssh` และ OpenShell `remote` การสร้างใหม่มีความสำคัญมากกว่า Docker:
- เวิร์กสเปซระยะไกลเป็นแหล่งอ้างอิงหลักหลังจากการ seed ครั้งแรก
- `openclaw sandbox recreate` จะลบเวิร์กสเปซระยะไกลหลักนั้นสำหรับขอบเขตที่เลือก
- การใช้งานครั้งถัดไปจะ seed ใหม่อีกครั้งจากเวิร์กสเปซในเครื่องปัจจุบัน
## คำสั่ง
### `openclaw sandbox explain`
ตรวจสอบโหมด/ขอบเขต/การเข้าถึงเวิร์กสเปซของ sandbox ที่ **มีผลใช้งานจริง**, นโยบายเครื่องมือ sandbox และ gate การยกระดับสิทธิ์ (พร้อมพาธคีย์ config สำหรับการแก้ไข)
```bash
openclaw sandbox explain
openclaw sandbox explain --session agent:main:main
openclaw sandbox explain --agent work
openclaw sandbox explain --json
```
### `openclaw sandbox list`
แสดง runtime ของ sandbox ทั้งหมดพร้อมสถานะและการตั้งค่า
```bash
openclaw sandbox list
openclaw sandbox list --browser # แสดงเฉพาะคอนเทนเนอร์เบราว์เซอร์
openclaw sandbox list --json # เอาต์พุต JSON
```
**เอาต์พุตประกอบด้วย:**
- ชื่อและสถานะของ runtime
- Backend (`docker`, `openshell` ฯลฯ)
- ป้ายกำกับ config และตรงกับ config ปัจจุบันหรือไม่
- อายุ (เวลาตั้งแต่สร้าง)
- เวลาว่าง (เวลาตั้งแต่ใช้งานครั้งล่าสุด)
- session/agent ที่เกี่ยวข้อง
### `openclaw sandbox recreate`
ลบ runtime ของ sandbox เพื่อบังคับให้สร้างใหม่ด้วย config ที่อัปเดตแล้ว
```bash
openclaw sandbox recreate --all # สร้างคอนเทนเนอร์ทั้งหมดใหม่
openclaw sandbox recreate --session main # session ที่ระบุ
openclaw sandbox recreate --agent mybot # agent ที่ระบุ
openclaw sandbox recreate --browser # เฉพาะคอนเทนเนอร์เบราว์เซอร์
openclaw sandbox recreate --all --force # ข้ามการยืนยัน
```
**ตัวเลือก:**
- `--all`: สร้างคอนเทนเนอร์ sandbox ทั้งหมดใหม่
- `--session <key>`: สร้างคอนเทนเนอร์สำหรับ session ที่ระบุใหม่
- `--agent <id>`: สร้างคอนเทนเนอร์สำหรับ agent ที่ระบุใหม่
- `--browser`: สร้างใหม่เฉพาะคอนเทนเนอร์เบราว์เซอร์
- `--force`: ข้ามพรอมต์ยืนยัน
**สำคัญ:** runtime จะถูกสร้างใหม่โดยอัตโนมัติเมื่อมีการใช้งาน agent ครั้งถัดไป
## กรณีการใช้งาน
### หลังจากอัปเดตอิมเมจ Docker
```bash
# ดึงอิมเมจใหม่
docker pull openclaw-sandbox:latest
docker tag openclaw-sandbox:latest openclaw-sandbox:bookworm-slim
# อัปเดต config เพื่อใช้อิมเมจใหม่
# แก้ไข config: agents.defaults.sandbox.docker.image (หรือ agents.list[].sandbox.docker.image)
# สร้างคอนเทนเนอร์ใหม่
openclaw sandbox recreate --all
```
### หลังจากเปลี่ยนการตั้งค่า sandbox
```bash
# แก้ไข config: agents.defaults.sandbox.* (หรือ agents.list[].sandbox.*)
# สร้างใหม่เพื่อใช้ config ใหม่
openclaw sandbox recreate --all
```
### หลังจากเปลี่ยนเป้าหมาย SSH หรือข้อมูล auth ของ SSH
```bash
# แก้ไข config:
# - agents.defaults.sandbox.backend
# - agents.defaults.sandbox.ssh.target
# - agents.defaults.sandbox.ssh.workspaceRoot
# - agents.defaults.sandbox.ssh.identityFile / certificateFile / knownHostsFile
# - agents.defaults.sandbox.ssh.identityData / certificateData / knownHostsData
openclaw sandbox recreate --all
```
สำหรับ backend `ssh` หลัก การสร้างใหม่จะลบรูทเวิร์กสเปซระยะไกลต่อขอบเขต
บนเป้าหมาย SSH การรันครั้งถัดไปจะ seed ใหม่อีกครั้งจากเวิร์กสเปซในเครื่อง
### หลังจากเปลี่ยนแหล่งที่มา นโยบาย หรือโหมดของ OpenShell
```bash
# แก้ไข config:
# - agents.defaults.sandbox.backend
# - plugins.entries.openshell.config.from
# - plugins.entries.openshell.config.mode
# - plugins.entries.openshell.config.policy
openclaw sandbox recreate --all
```
สำหรับโหมด OpenShell `remote` การสร้างใหม่จะลบเวิร์กสเปซระยะไกลหลัก
สำหรับขอบเขตนั้น การรันครั้งถัดไปจะ seed ใหม่อีกครั้งจากเวิร์กสเปซในเครื่อง
### หลังจากเปลี่ยน setupCommand
```bash
openclaw sandbox recreate --all
# หรือเฉพาะ agent เดียว:
openclaw sandbox recreate --agent family
```
### สำหรับ agent ที่ระบุเท่านั้น
```bash
# อัปเดตเฉพาะคอนเทนเนอร์ของ agent เดียว
openclaw sandbox recreate --agent alfred
```
## ทำไมจึงจำเป็น?
**ปัญหา:** เมื่อคุณอัปเดตการตั้งค่า sandbox:
- runtime ที่มีอยู่จะยังคงทำงานด้วยการตั้งค่าเดิม
- runtime จะถูกล้างทิ้งก็ต่อเมื่อไม่มีการใช้งานเป็นเวลา 24 ชม.
- agent ที่ใช้งานเป็นประจำจะทำให้ runtime เดิมคงอยู่ต่อไปอย่างไม่มีกำหนด
**วิธีแก้:** ใช้ `openclaw sandbox recreate` เพื่อบังคับลบ runtime เดิม runtime เหล่านั้นจะถูกสร้างใหม่โดยอัตโนมัติด้วยการตั้งค่าปัจจุบันเมื่อจำเป็นในครั้งถัดไป
เคล็ดลับ: ควรใช้ `openclaw sandbox recreate` แทนการล้างข้อมูลด้วยตนเองแบบเจาะจง backend
คำสั่งนี้ใช้รีจิสทรี runtime ของ Gateway และช่วยหลีกเลี่ยงความไม่ตรงกันเมื่อคีย์ขอบเขต/session เปลี่ยนไป
## การตั้งค่า
การตั้งค่า sandbox อยู่ใน `~/.openclaw/openclaw.json` ภายใต้ `agents.defaults.sandbox` (การ override ราย agent อยู่ใน `agents.list[].sandbox`):
```jsonc
{
"agents": {
"defaults": {
"sandbox": {
"mode": "all", // off, non-main, all
"backend": "docker", // docker, ssh, openshell
"scope": "agent", // session, agent, shared
"docker": {
"image": "openclaw-sandbox:bookworm-slim",
"containerPrefix": "openclaw-sbx-",
// ... more Docker options
},
"prune": {
"idleHours": 24, // Auto-prune after 24h idle
"maxAgeDays": 7, // Auto-prune after 7 days
},
},
},
},
}
```
## ดูเพิ่มเติม
- [เอกสาร Sandbox](/th/gateway/sandboxing)
- [การตั้งค่า Agent](/th/concepts/agent-workspace)
- [คำสั่ง Doctor](/th/gateway/doctor) - ตรวจสอบการตั้งค่า sandbox

204
docs/th/cli/secrets.md Normal file
View File

@ -0,0 +1,204 @@
---
read_when:
- การ resolve secret refs ใหม่ขณะรันไทม์
- การตรวจสอบร่องรอย plaintext และ refs ที่ยัง resolve ไม่ได้
- การกำหนดค่า SecretRefs และใช้การเปลี่ยนแปลงการล้างข้อมูลแบบทางเดียว
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw secrets` (โหลดใหม่ ตรวจสอบ กำหนดค่า ใช้การเปลี่ยนแปลง)
title: ความลับ
x-i18n:
generated_at: "2026-04-23T06:19:27Z"
model: gpt-5.4
provider: openai
source_hash: f436ba089d752edb766c0a3ce746ee6bca1097b22c9b30e3d9715cb0bb50bf47
source_path: cli/secrets.md
workflow: 15
---
# `openclaw secrets`
ใช้ `openclaw secrets` เพื่อจัดการ SecretRefs และทำให้สแนปช็อตรันไทม์ที่ใช้งานอยู่มีสภาพสมบูรณ์
บทบาทของคำสั่ง:
- `reload`: gateway RPC (`secrets.reload`) ที่ resolve refs ใหม่และสลับสแนปช็อตรันไทม์เฉพาะเมื่อสำเร็จทั้งหมดเท่านั้น (ไม่มีการเขียน config)
- `audit`: สแกนแบบอ่านอย่างเดียวสำหรับ configuration/auth/generated-model stores และร่องรอยตกค้างแบบ legacy เพื่อหา plaintext, refs ที่ resolve ไม่ได้ และ precedence drift (ระบบจะข้าม exec refs เว้นแต่จะตั้ง `--allow-exec`)
- `configure`: ตัววางแผนแบบโต้ตอบสำหรับการตั้งค่า provider, การแมปเป้าหมาย และ preflight (ต้องใช้ TTY)
- `apply`: ดำเนินการตามแผนที่บันทึกไว้ (`--dry-run` สำหรับตรวจสอบความถูกต้องเท่านั้น; dry-run จะข้ามการตรวจสอบ exec โดยค่าเริ่มต้น และโหมดเขียนจะปฏิเสธแผนที่มี exec เว้นแต่จะตั้ง `--allow-exec`) จากนั้นล้างร่องรอย plaintext ที่ระบุเป้าหมาย
ลูปการทำงานที่แนะนำสำหรับผู้ปฏิบัติงาน:
```bash
openclaw secrets audit --check
openclaw secrets configure
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json --dry-run
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json
openclaw secrets audit --check
openclaw secrets reload
```
หากแผนของคุณมี `exec` SecretRefs/providers ให้ส่ง `--allow-exec` ทั้งในคำสั่ง apply แบบ dry-run และแบบเขียนจริง
หมายเหตุเรื่อง exit code สำหรับ CI/gates:
- `audit --check` จะคืนค่า `1` เมื่อพบรายการผิดปกติ
- refs ที่ resolve ไม่ได้จะคืนค่า `2`
ที่เกี่ยวข้อง:
- คู่มือ Secrets: [Secrets Management](/th/gateway/secrets)
- พื้นผิวข้อมูลรับรอง: [SecretRef Credential Surface](/th/reference/secretref-credential-surface)
- คู่มือความปลอดภัย: [Security](/th/gateway/security)
## โหลดสแนปช็อตรันไทม์ใหม่
resolve secret refs ใหม่และสลับสแนปช็อตรันไทม์แบบอะตอมมิก
```bash
openclaw secrets reload
openclaw secrets reload --json
openclaw secrets reload --url ws://127.0.0.1:18789 --token <token>
```
หมายเหตุ:
- ใช้ gateway RPC method `secrets.reload`
- หากการ resolve ล้มเหลว gateway จะคงสแนปช็อตล่าสุดที่ใช้งานได้ไว้และส่งคืนข้อผิดพลาด (ไม่มีการเปิดใช้งานบางส่วน)
- การตอบกลับแบบ JSON มี `warningCount`
ตัวเลือก:
- `--url <url>`
- `--token <token>`
- `--timeout <ms>`
- `--json`
## ตรวจสอบ
สแกนสถานะของ OpenClaw เพื่อหา:
- การจัดเก็บความลับแบบ plaintext
- refs ที่ resolve ไม่ได้
- precedence drift (`auth-profiles.json` credentials ที่บัง `openclaw.json` refs)
- ร่องรอยใน `agents/*/agent/models.json` ที่สร้างขึ้น (`apiKey` ของ provider และ provider headers ที่ละเอียดอ่อน)
- ร่องรอยแบบ legacy (รายการใน legacy auth store, การเตือน OAuth)
หมายเหตุเรื่องร่องรอยของ header:
- การตรวจจับ provider header ที่ละเอียดอ่อนอิงตาม heuristic ของชื่อ (ชื่อ header และชิ้นส่วนชื่อที่พบบ่อยเกี่ยวกับ auth/credentials เช่น `authorization`, `x-api-key`, `token`, `secret`, `password` และ `credential`)
```bash
openclaw secrets audit
openclaw secrets audit --check
openclaw secrets audit --json
openclaw secrets audit --allow-exec
```
พฤติกรรมการออก:
- `--check` จะออกด้วยค่าที่ไม่เป็นศูนย์เมื่อพบรายการผิดปกติ
- refs ที่ resolve ไม่ได้จะออกด้วยรหัสที่ไม่เป็นศูนย์ซึ่งมีลำดับความสำคัญสูงกว่า
จุดเด่นของรูปแบบรายงาน:
- `status`: `clean | findings | unresolved`
- `resolution`: `refsChecked`, `skippedExecRefs`, `resolvabilityComplete`
- `summary`: `plaintextCount`, `unresolvedRefCount`, `shadowedRefCount`, `legacyResidueCount`
- รหัสรายการผิดปกติ:
- `PLAINTEXT_FOUND`
- `REF_UNRESOLVED`
- `REF_SHADOWED`
- `LEGACY_RESIDUE`
## กำหนดค่า (ตัวช่วยแบบโต้ตอบ)
สร้างการเปลี่ยนแปลง provider และ SecretRef แบบโต้ตอบ รัน preflight และเลือก apply ได้:
```bash
openclaw secrets configure
openclaw secrets configure --plan-out /tmp/openclaw-secrets-plan.json
openclaw secrets configure --apply --yes
openclaw secrets configure --providers-only
openclaw secrets configure --skip-provider-setup
openclaw secrets configure --agent ops
openclaw secrets configure --json
```
ลำดับการทำงาน:
- ตั้งค่า Provider ก่อน (`add/edit/remove` สำหรับ aliases ใน `secrets.providers`)
- แมปข้อมูลรับรองเป็นลำดับถัดไป (เลือกฟิลด์และกำหนด refs แบบ `{source, provider, id}`)
- Preflight และ apply แบบไม่บังคับเป็นลำดับสุดท้าย
แฟล็ก:
- `--providers-only`: กำหนดค่าเฉพาะ `secrets.providers` ข้ามการแมปข้อมูลรับรอง
- `--skip-provider-setup`: ข้ามการตั้งค่า provider และแมปข้อมูลรับรองไปยัง providers ที่มีอยู่
- `--agent <id>`: กำหนดขอบเขตการค้นหาเป้าหมายและการเขียนใน `auth-profiles.json` ไปยัง store ของ agent เดียว
- `--allow-exec`: อนุญาตการตรวจสอบ exec SecretRef ระหว่าง preflight/apply (อาจมีการรันคำสั่งของ provider)
หมายเหตุ:
- ต้องใช้ TTY แบบโต้ตอบ
- คุณไม่สามารถใช้ `--providers-only` ร่วมกับ `--skip-provider-setup`
- `configure` กำหนดเป้าหมายไปยังฟิลด์ที่มีความลับใน `openclaw.json` รวมถึง `auth-profiles.json` สำหรับขอบเขต agent ที่เลือก
- `configure` รองรับการสร้างการแมป `auth-profiles.json` ใหม่โดยตรงภายในขั้นตอนตัวเลือก
- พื้นผิวที่รองรับตามมาตรฐาน: [SecretRef Credential Surface](/th/reference/secretref-credential-surface)
- ระบบจะทำ preflight resolve ก่อน apply
- หาก preflight/apply มี exec refs ให้คง `--allow-exec` ไว้ทั้งสองขั้นตอน
- แผนที่สร้างขึ้นจะใช้ตัวเลือก scrub โดยค่าเริ่มต้น (`scrubEnv`, `scrubAuthProfilesForProviderTargets`, `scrubLegacyAuthJson` เปิดทั้งหมด)
- เส้นทาง apply เป็นแบบทางเดียวสำหรับค่า plaintext ที่ถูก scrub
- หากไม่ใช้ `--apply` CLI จะยังถาม `Apply this plan now?` หลัง preflight
- เมื่อใช้ `--apply` (และไม่มี `--yes`) CLI จะถามการยืนยันเพิ่มเติมที่ไม่สามารถย้อนกลับได้
- `--json` จะพิมพ์แผน + รายงาน preflight แต่คำสั่งยังคงต้องใช้ TTY แบบโต้ตอบ
หมายเหตุด้านความปลอดภัยของ exec provider:
- การติดตั้งผ่าน Homebrew มักเปิดเผยไบนารีแบบ symlink ภายใต้ `/opt/homebrew/bin/*`
- ตั้งค่า `allowSymlinkCommand: true` เฉพาะเมื่อจำเป็นสำหรับพาธของ package manager ที่เชื่อถือได้ และใช้ร่วมกับ `trustedDirs` (ตัวอย่างเช่น `["/opt/homebrew"]`)
- บน Windows หากไม่สามารถยืนยัน ACL สำหรับพาธของ provider ได้ OpenClaw จะล้มเหลวแบบปิดไว้ก่อน สำหรับพาธที่เชื่อถือได้เท่านั้น ให้ตั้ง `allowInsecurePath: true` บน provider นั้นเพื่อข้ามการตรวจสอบความปลอดภัยของพาธ
## ใช้แผนที่บันทึกไว้
apply หรือ preflight แผนที่สร้างไว้ก่อนหน้านี้:
```bash
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json --allow-exec
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json --dry-run
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json --dry-run --allow-exec
openclaw secrets apply --from /tmp/openclaw-secrets-plan.json --json
```
พฤติกรรมของ exec:
- `--dry-run` ตรวจสอบ preflight โดยไม่เขียนไฟล์
- การตรวจสอบ exec SecretRef จะถูกข้ามโดยค่าเริ่มต้นใน dry-run
- โหมดเขียนจะปฏิเสธแผนที่มี exec SecretRefs/providers เว้นแต่จะตั้ง `--allow-exec`
- ใช้ `--allow-exec` เพื่อเลือกเข้าร่วมการตรวจสอบ/การรัน exec provider ในทั้งสองโหมด
รายละเอียดของสัญญาแผน (พาธเป้าหมายที่อนุญาต กฎการตรวจสอบ และความหมายของความล้มเหลว):
- [Secrets Apply Plan Contract](/th/gateway/secrets-plan-contract)
สิ่งที่ `apply` อาจอัปเดต:
- `openclaw.json` (เป้าหมาย SecretRef + การ upsert/delete ของ provider)
- `auth-profiles.json` (การ scrub เป้าหมายของ provider)
- ร่องรอยใน `auth.json` แบบ legacy
- คีย์ความลับที่รู้จักใน `~/.openclaw/.env` ซึ่งมีค่าถูกย้ายแล้ว
## เหตุใดจึงไม่มีแบ็กอัปสำหรับ rollback
`secrets apply` ตั้งใจไม่เขียนแบ็กอัปสำหรับ rollback ที่มีค่า plaintext เดิม
ความปลอดภัยมาจาก preflight ที่เข้มงวด + apply แบบกึ่งอะตอมมิก พร้อมการกู้คืนในหน่วยความจำแบบ best-effort เมื่อเกิดความล้มเหลว
## ตัวอย่าง
```bash
openclaw secrets audit --check
openclaw secrets configure
openclaw secrets audit --check
```
หาก `audit --check` ยังคงรายงานการพบ plaintext ให้ปรับปรุงพาธเป้าหมายที่ยังถูกรายงานอยู่ แล้วรัน audit อีกครั้ง

93
docs/th/cli/security.md Normal file
View File

@ -0,0 +1,93 @@
---
read_when:
- คุณต้องการรันการตรวจสอบความปลอดภัยอย่างรวดเร็วกับ config/สถานะ
- คุณต้องการปรับใช้คำแนะนำ “แก้ไข” ที่ปลอดภัย (สิทธิ์, ทำให้ค่าเริ่มต้นเข้มงวดยิ่งขึ้น)
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw security` (ตรวจสอบและแก้ไขข้อผิดพลาดด้านความปลอดภัยที่พบบ่อย)
title: ความปลอดภัย
x-i18n:
generated_at: "2026-04-23T06:19:29Z"
model: gpt-5.4
provider: openai
source_hash: e5a3e4ab8e0dfb6c10763097cb4483be2431985f16de877523eb53e2122239ae
source_path: cli/security.md
workflow: 15
---
# `openclaw security`
เครื่องมือด้านความปลอดภัย (ตรวจสอบ + แก้ไขเพิ่มเติมตามตัวเลือก)
ที่เกี่ยวข้อง:
- คู่มือความปลอดภัย: [ความปลอดภัย](/th/gateway/security)
## การตรวจสอบ
```bash
openclaw security audit
openclaw security audit --deep
openclaw security audit --deep --password <password>
openclaw security audit --deep --token <token>
openclaw security audit --fix
openclaw security audit --json
```
การตรวจสอบจะเตือนเมื่อมีผู้ส่ง DM หลายรายใช้เซสชันหลักร่วมกัน และแนะนำให้ใช้ **โหมด DM ที่ปลอดภัย**: `session.dmScope="per-channel-peer"` (หรือ `per-account-channel-peer` สำหรับช่องทางหลายบัญชี) สำหรับกล่องข้อความที่ใช้ร่วมกัน
สิ่งนี้มีไว้เพื่อเสริมความปลอดภัยให้กับกล่องข้อความแบบร่วมมือกัน/ใช้ร่วมกัน การใช้ Gateway เดียวร่วมกันโดยผู้ปฏิบัติงานหลายคนที่ไม่ไว้วางใจกันหรือเป็นปฏิปักษ์กันไม่ใช่การตั้งค่าที่แนะนำ; ควรแยกขอบเขตความไว้วางใจด้วย gateway แยกกัน (หรือแยกผู้ใช้ระบบปฏิบัติการ/โฮสต์กัน)
นอกจากนี้ยังแสดง `security.trust_model.multi_user_heuristic` เมื่อ config บ่งชี้ว่ามี ingress แบบผู้ใช้ร่วมกันที่น่าจะเป็นไปได้ (เช่น นโยบาย DM/กลุ่มแบบเปิด เป้าหมายกลุ่มที่กำหนดค่าไว้ หรือกฎผู้ส่งแบบ wildcard) และเตือนว่าโดยค่าเริ่มต้น OpenClaw ใช้โมเดลความไว้วางใจแบบผู้ช่วยส่วนบุคคล
สำหรับการตั้งค่าแบบผู้ใช้ร่วมกันที่ตั้งใจไว้ แนวทางจากการตรวจสอบคือให้ sandbox ทุกเซสชัน จำกัดการเข้าถึงระบบไฟล์ให้อยู่ในขอบเขตเวิร์กสเปซ และอย่าเก็บตัวตนหรือข้อมูลรับรองส่วนตัว/ส่วนบุคคลไว้ในรันไทม์นั้น
นอกจากนี้ยังเตือนเมื่อมีการใช้โมเดลขนาดเล็ก (`<=300B`) โดยไม่มี sandbox และเปิดใช้เครื่องมือเว็บ/เบราว์เซอร์อยู่
สำหรับ webhook ingress จะเตือนเมื่อ `hooks.token` ใช้ซ้ำกับ Gateway token, เมื่อ `hooks.token` สั้น, เมื่อ `hooks.path="/"`, เมื่อไม่ได้ตั้งค่า `hooks.defaultSessionKey`, เมื่อ `hooks.allowedAgentIds` ไม่ได้จำกัด, เมื่อเปิดใช้การ override `sessionKey` ของคำขอ, และเมื่อเปิดใช้ override โดยไม่มี `hooks.allowedSessionKeyPrefixes`
นอกจากนี้ยังเตือนเมื่อมีการกำหนดค่า sandbox Docker ขณะที่โหมด sandbox ปิดอยู่, เมื่อ `gateway.nodes.denyCommands` ใช้รายการแบบคล้ายแพตเทิร์น/ไม่รู้จักที่ไม่มีผล (จับคู่เฉพาะชื่อคำสั่งของ Node แบบตรงตัวเท่านั้น ไม่ใช่การกรองข้อความเชลล์), เมื่อ `gateway.nodes.allowCommands` เปิดใช้คำสั่ง Node ที่อันตรายอย่างชัดเจน, เมื่อ `tools.profile="minimal"` แบบ global ถูก override โดยโปรไฟล์เครื่องมือของเอเจนต์, เมื่อกลุ่มแบบเปิดเปิดเผยเครื่องมือรันไทม์/ระบบไฟล์โดยไม่มีตัวป้องกัน sandbox/เวิร์กสเปซ, และเมื่อเครื่องมือ Plugin ส่วนขยายที่ติดตั้งไว้สามารถเข้าถึงได้ภายใต้นโยบายเครื่องมือแบบผ่อนปรน
นอกจากนี้ยังแจ้งเตือน `gateway.allowRealIpFallback=true` (ความเสี่ยงจากการปลอมแปลง header หากกำหนดค่า proxy ผิด) และ `discovery.mdns.mode="full"` (การรั่วไหลของข้อมูลเมตาผ่านระเบียน mDNS TXT)
นอกจากนี้ยังเตือนเมื่อเบราว์เซอร์ sandbox ใช้เครือข่าย Docker แบบ `bridge` โดยไม่มี `sandbox.browser.cdpSourceRange`
นอกจากนี้ยังแจ้งเตือนโหมดเครือข่าย Docker ของ sandbox ที่อันตราย (รวมถึง `host` และการเข้าร่วม namespace แบบ `container:*`)
นอกจากนี้ยังเตือนเมื่อคอนเทนเนอร์ Docker ของเบราว์เซอร์ sandbox ที่มีอยู่มีป้ายกำกับแฮชหายไป/ล้าสมัย (เช่น คอนเทนเนอร์ก่อนการย้ายข้อมูลที่ไม่มี `openclaw.browserConfigEpoch`) และแนะนำให้ใช้ `openclaw sandbox recreate --browser --all`
นอกจากนี้ยังเตือนเมื่อบันทึกการติดตั้ง Plugin/hook แบบอิง npm ไม่ได้ pin เวอร์ชัน ไม่มีข้อมูลเมตา integrity หรือคลาดเคลื่อนจากเวอร์ชันแพ็กเกจที่ติดตั้งอยู่ในปัจจุบัน
จะเตือนเมื่อ allowlist ของช่องทางอาศัยชื่อ/อีเมล/แท็กที่เปลี่ยนแปลงได้แทน ID แบบคงที่ (Discord, Slack, Google Chat, Microsoft Teams, Mattermost, ขอบเขต IRC ตามที่ใช้ได้)
จะเตือนเมื่อ `gateway.auth.mode="none"` ทำให้ API HTTP ของ Gateway เข้าถึงได้โดยไม่มี shared secret (`/tools/invoke` รวมถึงปลายทาง `/v1/*` ใดๆ ที่เปิดใช้งาน)
การตั้งค่าที่ขึ้นต้นด้วย `dangerous`/`dangerously` เป็นการ override แบบ break-glass ที่ผู้ปฏิบัติงานเปิดใช้โดยชัดแจ้ง; การเปิดใช้สิ่งเหล่านี้เพียงอย่างเดียวไม่ถือเป็นรายงานช่องโหว่ด้านความปลอดภัย
สำหรับรายการพารามิเตอร์อันตรายทั้งหมด โปรดดูส่วน "Insecure or dangerous flags summary" ใน [ความปลอดภัย](/th/gateway/security)
พฤติกรรมของ SecretRef:
- `security audit` จะ resolve SecretRef ที่รองรับในโหมดอ่านอย่างเดียวสำหรับพาธเป้าหมายของมัน
- หาก SecretRef ไม่พร้อมใช้งานในเส้นทางคำสั่งปัจจุบัน การตรวจสอบจะดำเนินต่อไปและรายงาน `secretDiagnostics` (แทนที่จะล่ม)
- `--token` และ `--password` จะ override การยืนยันตัวตนสำหรับ deep-probe เฉพาะการเรียกคำสั่งครั้งนั้นเท่านั้น; จะไม่เขียนทับ config หรือการแมป SecretRef
## เอาต์พุต JSON
ใช้ `--json` สำหรับการตรวจสอบ CI/นโยบาย:
```bash
openclaw security audit --json | jq '.summary'
openclaw security audit --deep --json | jq '.findings[] | select(.severity=="critical") | .checkId'
```
หากใช้ `--fix` ร่วมกับ `--json` เอาต์พุตจะรวมทั้งการดำเนินการแก้ไขและรายงานสุดท้าย:
```bash
openclaw security audit --fix --json | jq '{fix: .fix.ok, summary: .report.summary}'
```
## สิ่งที่ `--fix` เปลี่ยนแปลง
`--fix` จะปรับใช้การแก้ไขที่ปลอดภัยและกำหนดผลลัพธ์ได้แน่นอน:
- เปลี่ยน `groupPolicy="open"` ทั่วไปให้เป็น `groupPolicy="allowlist"` (รวมถึงรูปแบบตามบัญชีในช่องทางที่รองรับ)
- เมื่อ WhatsApp เปลี่ยนนโยบายกลุ่มเป็น `allowlist` จะ seed `groupAllowFrom` จาก
ไฟล์ `allowFrom` ที่จัดเก็บไว้เมื่อมีรายการนั้นอยู่ และ config ยังไม่ได้
กำหนด `allowFrom`
- ตั้งค่า `logging.redactSensitive` จาก `"off"` เป็น `"tools"`
- ทำให้สิทธิ์ของ state/config และไฟล์สำคัญทั่วไปเข้มงวดยิ่งขึ้น
(`credentials/*.json`, `auth-profiles.json`, `sessions.json`, session
`*.jsonl`)
- รวมถึงทำให้ไฟล์ include ของ config ที่อ้างอิงจาก `openclaw.json` เข้มงวดยิ่งขึ้นด้วย
- ใช้ `chmod` บนโฮสต์ POSIX และใช้การรีเซ็ต `icacls` บน Windows
สิ่งที่ `--fix` **ไม่** ทำ:
- หมุนเวียน token/password/API key
- ปิดใช้งานเครื่องมือ (`gateway`, `cron`, `exec` เป็นต้น)
- เปลี่ยนตัวเลือกการ bind/auth/network exposure ของ gateway
- ลบหรือเขียนทับ Plugins/Skills

119
docs/th/cli/sessions.md Normal file
View File

@ -0,0 +1,119 @@
---
read_when:
- คุณต้องการแสดงรายการเซสชันที่จัดเก็บไว้และดูความเคลื่อนไหวล่าสุด
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw sessions` (แสดงรายการเซสชันที่จัดเก็บไว้ + การใช้งาน)
title: sessions
x-i18n:
generated_at: "2026-04-23T06:19:31Z"
model: gpt-5.4
provider: openai
source_hash: 47eb55d90bd0681676283310cfa50dcacc95dff7d9a39bf2bb188788c6e5e5ba
source_path: cli/sessions.md
workflow: 15
---
# `openclaw sessions`
แสดงรายการเซสชันการสนทนาที่จัดเก็บไว้
```bash
openclaw sessions
openclaw sessions --agent work
openclaw sessions --all-agents
openclaw sessions --active 120
openclaw sessions --verbose
openclaw sessions --json
```
การเลือกขอบเขต:
- ค่าเริ่มต้น: ที่เก็บของ agent เริ่มต้นที่ตั้งค่าไว้
- `--verbose`: บันทึกแบบละเอียด
- `--agent <id>`: ที่เก็บของ agent ที่ตั้งค่าไว้หนึ่งรายการ
- `--all-agents`: รวมทุกที่เก็บของ agent ที่ตั้งค่าไว้
- `--store <path>`: เส้นทางที่เก็บแบบระบุชัดเจน (ใช้ร่วมกับ `--agent` หรือ `--all-agents` ไม่ได้)
`openclaw sessions --all-agents` จะอ่านที่เก็บของ agent ที่ตั้งค่าไว้ การค้นหาเซสชันของ Gateway และ ACP
มีขอบเขตกว้างกว่า: รวมถึงที่เก็บที่พบบนดิสก์อย่างเดียวภายใต้ราก `agents/` เริ่มต้นหรือราก `session.store` แบบเทมเพลตด้วย
ที่เก็บที่ค้นพบเหล่านี้ต้อง resolve ไปยังไฟล์ `sessions.json` ปกติภายในรากของ agent;
symlinks และเส้นทางที่อยู่นอกรากจะถูกข้าม
ตัวอย่าง JSON:
`openclaw sessions --all-agents --json`:
```json
{
"path": null,
"stores": [
{ "agentId": "main", "path": "/home/user/.openclaw/agents/main/sessions/sessions.json" },
{ "agentId": "work", "path": "/home/user/.openclaw/agents/work/sessions/sessions.json" }
],
"allAgents": true,
"count": 2,
"activeMinutes": null,
"sessions": [
{ "agentId": "main", "key": "agent:main:main", "model": "gpt-5" },
{ "agentId": "work", "key": "agent:work:main", "model": "claude-opus-4-6" }
]
}
```
## การบำรุงรักษาการล้างข้อมูล
รันการบำรุงรักษาทันที (แทนที่จะรอรอบการเขียนครั้งถัดไป):
```bash
openclaw sessions cleanup --dry-run
openclaw sessions cleanup --agent work --dry-run
openclaw sessions cleanup --all-agents --dry-run
openclaw sessions cleanup --enforce
openclaw sessions cleanup --enforce --active-key "agent:main:telegram:direct:123"
openclaw sessions cleanup --json
```
`openclaw sessions cleanup` ใช้การตั้งค่า `session.maintenance` จาก config:
- หมายเหตุด้านขอบเขต: `openclaw sessions cleanup` จะบำรุงรักษาเฉพาะที่เก็บเซสชัน/ทรานสคริปต์เท่านั้น จะไม่ล้าง cron run logs (`cron/runs/<jobId>.jsonl`) ซึ่งถูกจัดการโดย `cron.runLog.maxBytes` และ `cron.runLog.keepLines` ใน [การกำหนดค่า Cron](/th/automation/cron-jobs#configuration) และอธิบายไว้ใน [การบำรุงรักษา Cron](/th/automation/cron-jobs#maintenance)
- `--dry-run`: แสดงตัวอย่างว่าจะมีการลบ/จำกัดจำนวนรายการเท่าใดโดยไม่เขียนจริง
- ในโหมดข้อความ dry-run จะแสดงตารางการดำเนินการต่อเซสชัน (`Action`, `Key`, `Age`, `Model`, `Flags`) เพื่อให้คุณเห็นว่าจะเก็บหรือจะลบอะไรบ้าง
- `--enforce`: ใช้การบำรุงรักษาแม้ว่า `session.maintenance.mode` จะเป็น `warn`
- `--fix-missing`: ลบรายการที่ไม่มีไฟล์ transcript อยู่ แม้ว่าปกติแล้วรายการนั้นจะยังไม่ถึงเกณฑ์อายุ/จำนวนที่ต้องถูกลบก็ตาม
- `--active-key <key>`: ปกป้อง active key ที่ระบุจากการถูกนำออกเพราะข้อจำกัดงบประมาณดิสก์
- `--agent <id>`: รันการล้างข้อมูลสำหรับที่เก็บของ agent ที่ตั้งค่าไว้หนึ่งรายการ
- `--all-agents`: รันการล้างข้อมูลสำหรับทุกที่เก็บของ agent ที่ตั้งค่าไว้
- `--store <path>`: รันกับไฟล์ `sessions.json` ที่ระบุเฉพาะ
- `--json`: พิมพ์สรุปแบบ JSON เมื่อใช้กับ `--all-agents` เอาต์พุตจะมีหนึ่งสรุปต่อหนึ่งที่เก็บ
`openclaw sessions cleanup --all-agents --dry-run --json`:
```json
{
"allAgents": true,
"mode": "warn",
"dryRun": true,
"stores": [
{
"agentId": "main",
"storePath": "/home/user/.openclaw/agents/main/sessions/sessions.json",
"beforeCount": 120,
"afterCount": 80,
"pruned": 40,
"capped": 0
},
{
"agentId": "work",
"storePath": "/home/user/.openclaw/agents/work/sessions/sessions.json",
"beforeCount": 18,
"afterCount": 18,
"pruned": 0,
"capped": 0
}
]
}
```
ที่เกี่ยวข้อง:
- การตั้งค่าเซสชัน: [ข้อมูลอ้างอิงการกำหนดค่า](/th/gateway/configuration-reference#session)

52
docs/th/cli/setup.md Normal file
View File

@ -0,0 +1,52 @@
---
read_when:
- คุณกำลังทำการตั้งค่าครั้งแรกโดยไม่ใช้กระบวนการ onboarding แบบเต็มของ CLI
- คุณต้องการตั้งค่าพาธเวิร์กสเปซเริ่มต้น
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw setup` (เริ่มต้นคอนฟิก + เวิร์กสเปซ)
title: ตั้งค่า
x-i18n:
generated_at: "2026-04-23T06:19:40Z"
model: gpt-5.4
provider: openai
source_hash: f538aac341c749043ad959e35f2ed99c844ab8c3500ff59aa159d940bd301792
source_path: cli/setup.md
workflow: 15
---
# `openclaw setup`
เริ่มต้น `~/.openclaw/openclaw.json` และเวิร์กสเปซของ agent
ที่เกี่ยวข้อง:
- เริ่มต้นใช้งาน: [เริ่มต้นใช้งาน](/th/start/getting-started)
- การ onboarding ผ่าน CLI: [Onboarding (CLI)](/th/start/wizard)
## ตัวอย่าง
```bash
openclaw setup
openclaw setup --workspace ~/.openclaw/workspace
openclaw setup --wizard
openclaw setup --non-interactive --mode remote --remote-url wss://gateway-host:18789 --remote-token <token>
```
## ตัวเลือก
- `--workspace <dir>`: ไดเรกทอรีเวิร์กสเปซของ agent (บันทึกเป็น `agents.defaults.workspace`)
- `--wizard`: เรียกใช้ onboarding
- `--non-interactive`: เรียกใช้ onboarding โดยไม่มีพรอมป์
- `--mode <local|remote>`: โหมด onboarding
- `--remote-url <url>`: URL WebSocket ของ Gateway ระยะไกล
- `--remote-token <token>`: โทเค็นของ Gateway ระยะไกล
หากต้องการเรียกใช้ onboarding ผ่าน setup:
```bash
openclaw setup --wizard
```
หมายเหตุ:
- `openclaw setup` แบบธรรมดาจะเริ่มต้นคอนฟิก + เวิร์กสเปซ โดยไม่มีโฟลว์ onboarding เต็มรูปแบบ
- ระบบจะเรียกใช้ onboarding อัตโนมัติเมื่อมีแฟล็ก onboarding ใดๆ (`--wizard`, `--non-interactive`, `--mode`, `--remote-url`, `--remote-token`)

65
docs/th/cli/skills.md Normal file
View File

@ -0,0 +1,65 @@
---
read_when:
- คุณต้องการดูว่า Skills ใดพร้อมใช้งานและพร้อมรันบ้าง
- คุณต้องการค้นหา ติดตั้ง หรืออัปเดต Skills จาก ClawHub
- คุณต้องการดีบักไบนารี/env/config ที่ขาดหายไปสำหรับ Skills
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw skills` (search/install/update/list/info/check)
title: skills
x-i18n:
generated_at: "2026-04-23T06:19:47Z"
model: gpt-5.4
provider: openai
source_hash: 11af59b1b6bff19cc043acd8d67bdd4303201d3f75f23c948b83bf14882c7bb1
source_path: cli/skills.md
workflow: 15
---
# `openclaw skills`
ตรวจสอบ Skills ในเครื่อง และติดตั้ง/อัปเดต Skills จาก ClawHub
ที่เกี่ยวข้อง:
- ระบบ Skills: [Skills](/th/tools/skills)
- config ของ Skills: [Skills config](/th/tools/skills-config)
- การติดตั้ง ClawHub: [ClawHub](/th/tools/clawhub)
## คำสั่ง
```bash
openclaw skills search "calendar"
openclaw skills search --limit 20 --json
openclaw skills install <slug>
openclaw skills install <slug> --version <version>
openclaw skills install <slug> --force
openclaw skills update <slug>
openclaw skills update --all
openclaw skills list
openclaw skills list --eligible
openclaw skills list --json
openclaw skills list --verbose
openclaw skills info <name>
openclaw skills info <name> --json
openclaw skills check
openclaw skills check --json
```
`search`/`install`/`update` ใช้ ClawHub โดยตรงและติดตั้งลงในไดเรกทอรี `skills/`
ของ workspace ที่กำลังใช้งานอยู่ ขณะที่ `list`/`info`/`check` ยังคงตรวจสอบ
Skills ในเครื่องที่มองเห็นได้จาก workspace และ config ปัจจุบัน
คำสั่ง CLI `install` นี้จะดาวน์โหลดโฟลเดอร์ skill จาก ClawHub ส่วนการติดตั้ง dependency
ของ skill ที่ถูกทริกเกอร์จาก onboarding หรือการตั้งค่า Skills ซึ่งทำงานผ่าน Gateway จะใช้
เส้นทางคำขอ `skills.install` แยกต่างหากแทน
หมายเหตุ:
- `search [query...]` รองรับ query แบบไม่บังคับ; หากไม่ระบุ จะเป็นการเรียกดูฟีดค้นหา ClawHub เริ่มต้น
- `search --limit <n>` จำกัดจำนวนผลลัพธ์ที่ส่งคืน
- `install --force` เขียนทับโฟลเดอร์ skill ใน workspace ที่มีอยู่แล้วสำหรับ
slug เดียวกัน
- `update --all` จะอัปเดตเฉพาะการติดตั้ง ClawHub ที่ติดตามอยู่ใน workspace ที่กำลังใช้งาน
- `list` เป็นการทำงานเริ่มต้นเมื่อไม่ได้ระบุคำสั่งย่อย
- `list`, `info` และ `check` จะเขียนเอาต์พุตที่เรนเดอร์แล้วไปยัง stdout เมื่อใช้
`--json` หมายความว่าเพย์โหลดที่เครื่องอ่านได้จะยังคงอยู่บน stdout สำหรับ pipe
และสคริปต์

42
docs/th/cli/status.md Normal file
View File

@ -0,0 +1,42 @@
---
read_when:
- คุณต้องการการวินิจฉัยอย่างรวดเร็วเกี่ยวกับสถานะสุขภาพของแชนแนลและผู้รับของเซสชันล่าสุด
- คุณต้องการสถานะ “all” ที่คัดลอกไปวางได้สำหรับการดีบัก
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw status` (การวินิจฉัย การตรวจสอบ และ snapshot การใช้งาน)
title: สถานะ
x-i18n:
generated_at: "2026-04-23T06:19:53Z"
model: gpt-5.4
provider: openai
source_hash: fbe9d94fbe9938cd946ee6f293b5bd3b464b75e1ade2eacdd851788c3bffe94e
source_path: cli/status.md
workflow: 15
---
# `openclaw status`
การวินิจฉัยสำหรับแชนแนล + เซสชัน
```bash
openclaw status
openclaw status --all
openclaw status --deep
openclaw status --usage
```
หมายเหตุ:
- `--deep` จะเรียกใช้การตรวจสอบแบบสด (WhatsApp Web + Telegram + Discord + Slack + Signal)
- `--usage` จะแสดงหน้าต่างการใช้งานของผู้ให้บริการที่ถูกทำให้เป็นมาตรฐานในรูปแบบ `เหลือ X%`
- ฟิลด์ดิบ `usage_percent` / `usagePercent` ของ MiniMax เป็นโควตาที่เหลืออยู่ ดังนั้น OpenClaw จะกลับค่าก่อนแสดงผล; ฟิลด์แบบนับจำนวนจะมีลำดับความสำคัญมากกว่าเมื่อมีอยู่ การตอบกลับ `model_remains` จะให้ความสำคัญกับรายการ chat-model อนุมานป้ายหน้าต่างจากการประทับเวลาเมื่อจำเป็น และรวมชื่อโมเดลไว้ในป้ายแผน
- เมื่อ snapshot ของเซสชันปัจจุบันมีข้อมูลน้อย `/status` สามารถเติมค่าตัวนับโทเค็นและแคชกลับจากบันทึกการใช้งาน transcript ล่าสุดได้ ค่าที่เป็น nonzero จากการทำงานสดที่มีอยู่แล้วจะยังมีลำดับความสำคัญเหนือกว่าค่าที่เติมกลับจาก transcript
- การเติมกลับจาก transcript ยังสามารถกู้คืนป้ายโมเดลรันไทม์ที่ใช้งานอยู่ได้เมื่อรายการเซสชันแบบสดไม่มีข้อมูลดังกล่าว หากโมเดลจาก transcript นั้นแตกต่างจากโมเดลที่เลือก status จะ resolve context window เทียบกับโมเดลรันไทม์ที่กู้คืนมา แทนที่จะใช้โมเดลที่เลือก
- สำหรับการคำนวณขนาดพรอมป์ การเติมกลับจาก transcript จะเลือกยอดรวมที่เกี่ยวกับพรอมป์ซึ่งมีค่ามากกว่าเมื่อ metadata ของเซสชันไม่มีหรือมีค่าน้อยกว่า เพื่อไม่ให้เซสชัน custom-provider แสดงโทเค็นเป็น `0`
- เอาต์พุตรวมถึงที่เก็บเซสชันต่อ agent เมื่อมีการกำหนดค่า agent หลายตัว
- ภาพรวมรวมถึงสถานะการติดตั้ง/รันไทม์ของบริการ Gateway + Node host เมื่อมีข้อมูล
- ภาพรวมรวมถึงช่องทางอัปเดต + git SHA (สำหรับ source checkout)
- ข้อมูลอัปเดตจะแสดงใน Overview; หากมีอัปเดตพร้อมใช้งาน status จะแสดงคำแนะนำให้รัน `openclaw update` (ดู [การอัปเดต](/th/install/updating))
- พื้นผิว status แบบอ่านอย่างเดียว (`status`, `status --json`, `status --all`) จะ resolve SecretRefs ที่รองรับสำหรับพาธคอนฟิกเป้าหมายเมื่อทำได้
- หากมีการกำหนดค่า SecretRef ของแชนแนลที่รองรับไว้แต่ไม่พร้อมใช้งานในเส้นทางคำสั่งปัจจุบัน status จะยังคงเป็นแบบอ่านอย่างเดียวและรายงานเอาต์พุตแบบ degraded แทนการล้มเหลว เอาต์พุตสำหรับมนุษย์จะแสดงคำเตือน เช่น “configured token unavailable in this command path” และเอาต์พุต JSON จะมี `secretDiagnostics`
- เมื่อการ resolve SecretRef ในระดับคำสั่งสำเร็จ status จะให้ความสำคัญกับ snapshot ที่ resolve แล้วและล้างเครื่องหมายชั่วคราวของแชนแนลประเภท “secret unavailable” ออกจากเอาต์พุตสุดท้าย
- `status --all` รวมแถวภาพรวม Secrets และส่วนการวินิจฉัยที่สรุปการวินิจฉัย secret (ตัดทอนเพื่อให้อ่านง่าย) โดยไม่หยุดการสร้างรายงาน

78
docs/th/cli/system.md Normal file
View File

@ -0,0 +1,78 @@
---
read_when:
- คุณต้องการเพิ่มเหตุการณ์ของระบบเข้าคิวโดยไม่ต้องสร้างงาน Cron【อ่านข้อความเต็มanalysis to=final code sorry
- คุณต้องเปิดหรือปิด Heartbeat
- คุณต้องการตรวจสอบรายการการแสดงสถานะของระบบ
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw system` (เหตุการณ์ของระบบ, Heartbeat, การแสดงสถานะ)
title: system
x-i18n:
generated_at: "2026-04-23T06:19:56Z"
model: gpt-5.4
provider: openai
source_hash: a7d19afde9d9cde8a79b0bb8cec6e5673466f4cb9b575fb40111fc32f4eee5d7
source_path: cli/system.md
workflow: 15
---
# `openclaw system`
ตัวช่วยระดับระบบสำหรับ Gateway: เพิ่มเหตุการณ์ของระบบเข้าคิว ควบคุม Heartbeat
และดูการแสดงสถานะ
คำสั่งย่อย `system` ทั้งหมดใช้ Gateway RPC และรองรับแฟล็กไคลเอนต์ที่ใช้ร่วมกันดังนี้:
- `--url <url>`
- `--token <token>`
- `--timeout <ms>`
- `--expect-final`
## คำสั่งทั่วไป
```bash
openclaw system event --text "Check for urgent follow-ups" --mode now
openclaw system event --text "Check for urgent follow-ups" --url ws://127.0.0.1:18789 --token "$OPENCLAW_GATEWAY_TOKEN"
openclaw system heartbeat enable
openclaw system heartbeat last
openclaw system presence
```
## `system event`
เพิ่มเหตุการณ์ของระบบเข้าคิวในเซสชัน **main** Heartbeat ครั้งถัดไปจะฉีด
เหตุการณ์นั้นเข้าไปเป็นบรรทัด `System:` ในพรอมป์ต์ ใช้ `--mode now` เพื่อทริกเกอร์ Heartbeat
ทันที; `next-heartbeat` จะรอรอบ tick ที่กำหนดไว้ถัดไป
แฟล็ก:
- `--text <text>`: ข้อความเหตุการณ์ของระบบที่จำเป็นต้องระบุ
- `--mode <mode>`: `now` หรือ `next-heartbeat` (ค่าเริ่มต้น)
- `--json`: เอาต์พุตที่เครื่องอ่านได้
- `--url`, `--token`, `--timeout`, `--expect-final`: แฟล็ก Gateway RPC ที่ใช้ร่วมกัน
## `system heartbeat last|enable|disable`
การควบคุม Heartbeat:
- `last`: แสดงเหตุการณ์ Heartbeat ล่าสุด
- `enable`: เปิด Heartbeat กลับมาอีกครั้ง (ใช้เมื่อตอนก่อนหน้านี้ถูกปิดไว้)
- `disable`: หยุด Heartbeat ชั่วคราว
แฟล็ก:
- `--json`: เอาต์พุตที่เครื่องอ่านได้
- `--url`, `--token`, `--timeout`, `--expect-final`: แฟล็ก Gateway RPC ที่ใช้ร่วมกัน
## `system presence`
แสดงรายการการแสดงสถานะของระบบปัจจุบันที่ Gateway รับรู้ (nodes,
instances และบรรทัดสถานะที่คล้ายกัน)
แฟล็ก:
- `--json`: เอาต์พุตที่เครื่องอ่านได้
- `--url`, `--token`, `--timeout`, `--expect-final`: แฟล็ก Gateway RPC ที่ใช้ร่วมกัน
## หมายเหตุ
- ต้องมี Gateway ที่กำลังทำงานและเข้าถึงได้ผ่าน config ปัจจุบันของคุณ (local หรือ remote)
- เหตุการณ์ของระบบเป็นข้อมูลชั่วคราวและจะไม่ถูกเก็บคงไว้ข้ามการรีสตาร์ต

105
docs/th/cli/tasks.md Normal file
View File

@ -0,0 +1,105 @@
---
read_when:
- คุณต้องการตรวจสอบ ตรวจประเมิน หรือยกเลิกรายการงานเบื้องหลัง
- คุณกำลังจัดทำเอกสารคำสั่ง TaskFlow ภายใต้ `openclaw tasks flow`
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw tasks` (บัญชีงานเบื้องหลังและสถานะ TaskFlow)
title: '`openclaw tasks`'
x-i18n:
generated_at: "2026-04-23T06:19:53Z"
model: gpt-5.4
provider: openai
source_hash: 549e07c8a576cb4c5bd48874f16b0daa4a34facb53b102e12d358bdad2191628
source_path: cli/tasks.md
workflow: 15
---
# `openclaw tasks`
ตรวจสอบงานเบื้องหลังแบบคงทนและสถานะ TaskFlow เมื่อไม่มีคำสั่งย่อย
`openclaw tasks` จะเทียบเท่ากับ `openclaw tasks list`
ดู [งานเบื้องหลัง](/th/automation/tasks) สำหรับวงจรชีวิตและโมเดลการส่งมอบ
## การใช้งาน
```bash
openclaw tasks
openclaw tasks list
openclaw tasks list --runtime acp
openclaw tasks list --status running
openclaw tasks show <lookup>
openclaw tasks notify <lookup> state_changes
openclaw tasks cancel <lookup>
openclaw tasks audit
openclaw tasks maintenance
openclaw tasks maintenance --apply
openclaw tasks flow list
openclaw tasks flow show <lookup>
openclaw tasks flow cancel <lookup>
```
## ตัวเลือกระดับราก
- `--json`: แสดงผลเป็น JSON
- `--runtime <name>`: กรองตามชนิด: `subagent`, `acp`, `cron` หรือ `cli`
- `--status <name>`: กรองตามสถานะ: `queued`, `running`, `succeeded`, `failed`, `timed_out`, `cancelled` หรือ `lost`
## คำสั่งย่อย
### `list`
```bash
openclaw tasks list [--runtime <name>] [--status <name>] [--json]
```
แสดงรายการงานเบื้องหลังที่ติดตามไว้ โดยเรียงจากใหม่สุดก่อน
### `show`
```bash
openclaw tasks show <lookup> [--json]
```
แสดงงานหนึ่งรายการตาม task ID, run ID หรือ session key
### `notify`
```bash
openclaw tasks notify <lookup> <done_only|state_changes|silent>
```
เปลี่ยนนโยบายการแจ้งเตือนสำหรับงานที่กำลังทำงานอยู่
### `cancel`
```bash
openclaw tasks cancel <lookup>
```
ยกเลิกงานเบื้องหลังที่กำลังทำงานอยู่
### `audit`
```bash
openclaw tasks audit [--severity <warn|error>] [--code <name>] [--limit <n>] [--json]
```
แสดงรายการงานและระเบียน TaskFlow ที่เก่า สูญหาย ส่งมอบล้มเหลว หรือไม่สอดคล้องกันในลักษณะอื่น
### `maintenance`
```bash
openclaw tasks maintenance [--apply] [--json]
```
แสดงตัวอย่างหรือปรับใช้การกระทบยอด การประทับตราการล้างข้อมูล และการตัดทอนของงานและ TaskFlow
### `flow`
```bash
openclaw tasks flow list [--status <name>] [--json]
openclaw tasks flow show <lookup> [--json]
openclaw tasks flow cancel <lookup>
```
ตรวจสอบหรือยกเลิกสถานะ TaskFlow แบบคงทนภายใต้บัญชีงาน

73
docs/th/cli/tui.md Normal file
View File

@ -0,0 +1,73 @@
---
read_when:
- คุณต้องการ UI บนเทอร์มินัลสำหรับ Gateway (เหมาะกับการใช้งานระยะไกล)
- คุณต้องการส่ง url/token/session จากสคริปต์
- คุณต้องการรัน TUI ในโหมดฝังในเครื่องโดยไม่ใช้ Gateway
- คุณต้องการใช้ `openclaw chat` หรือ `openclaw tui --local`
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw tui` (TUI แบบฝังในเครื่องหรือแบบอิง Gateway)
title: TUI
x-i18n:
generated_at: "2026-04-23T06:20:05Z"
model: gpt-5.4
provider: openai
source_hash: 5f4b7cf2468779e0711f38a2cc304d783bb115fd5c5e573c9d1bc982da6e2905
source_path: cli/tui.md
workflow: 15
---
# `openclaw tui`
เปิด UI บนเทอร์มินัลที่เชื่อมต่อกับ Gateway หรือรันใน
โหมดฝังในเครื่อง
ที่เกี่ยวข้อง:
- คู่มือ TUI: [TUI](/th/web/tui)
หมายเหตุ:
- `chat` และ `terminal` เป็นนามแฝงของ `openclaw tui --local`
- `--local` ไม่สามารถใช้ร่วมกับ `--url`, `--token` หรือ `--password`
- `tui` จะ resolve auth SecretRefs ของ gateway ที่กำหนดค่าไว้สำหรับ token/password auth เมื่อทำได้ (`env`/`file`/`exec` providers)
- เมื่อเปิดจากภายในไดเรกทอรี workspace ของ agent ที่กำหนดค่าไว้ TUI จะเลือก agent นั้นโดยอัตโนมัติสำหรับค่าเริ่มต้นของ session key (เว้นแต่ `--session` จะเป็น `agent:<id>:...` อย่างชัดเจน)
- โหมดในเครื่องใช้รันไทม์ agent แบบฝังโดยตรง เครื่องมือในเครื่องส่วนใหญ่ใช้งานได้ แต่ฟีเจอร์ที่มีเฉพาะ Gateway จะไม่พร้อมใช้งาน
- โหมดในเครื่องเพิ่ม `/auth [provider]` ภายในพื้นผิวคำสั่งของ TUI
## ตัวอย่าง
```bash
openclaw chat
openclaw tui --local
openclaw tui
openclaw tui --url ws://127.0.0.1:18789 --token <token>
openclaw tui --session main --deliver
openclaw chat --message "Compare my config to the docs and tell me what to fix"
# when run inside an agent workspace, infers that agent automatically
openclaw tui --session bugfix
```
## ลูปการซ่อมแซม config
ใช้โหมดในเครื่องเมื่อ config ปัจจุบันผ่านการตรวจสอบอยู่แล้ว และคุณต้องการให้
agent แบบฝังตรวจสอบ config นั้น เปรียบเทียบกับเอกสาร และช่วยซ่อมแซมให้
จากเทอร์มินัลเดียวกัน:
หาก `openclaw config validate` ล้มเหลวอยู่แล้ว ให้ใช้ `openclaw configure` หรือ
`openclaw doctor --fix` ก่อน `openclaw chat` จะไม่ข้ามตัวป้องกัน
config ไม่ถูกต้อง
```bash
openclaw chat
```
จากนั้นภายใน TUI:
```text
!openclaw config file
!openclaw docs gateway auth token secretref
!openclaw config validate
!openclaw doctor
```
ใช้ `openclaw config set` หรือ `openclaw configure` เพื่อปรับแก้แบบเจาะจง จากนั้น
รัน `openclaw config validate` อีกครั้ง ดู [TUI](/th/web/tui) และ [Config](/th/cli/config)

46
docs/th/cli/uninstall.md Normal file
View File

@ -0,0 +1,46 @@
---
read_when:
- คุณต้องการลบบริการ Gateway และ/หรือสถานะในเครื่อง
- คุณต้องการดูตัวอย่างล่วงหน้าก่อน
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw uninstall` (ลบบริการ Gateway และข้อมูลในเครื่อง)
title: ถอนการติดตั้ง
x-i18n:
generated_at: "2026-04-23T06:20:02Z"
model: gpt-5.4
provider: openai
source_hash: 2123a4f9c7a070ef7e13c60dafc189053ef61ce189fa4f29449dd50987c1894c
source_path: cli/uninstall.md
workflow: 15
---
# `openclaw uninstall`
ถอนการติดตั้งบริการ Gateway + ข้อมูลในเครื่อง (CLI ยังคงอยู่)
ตัวเลือก:
- `--service`: ลบบริการ Gateway
- `--state`: ลบสถานะและ config
- `--workspace`: ลบไดเรกทอรีเวิร์กสเปซ
- `--app`: ลบแอป macOS
- `--all`: ลบบริการ สถานะ เวิร์กสเปซ และแอปรวมกัน
- `--yes`: ข้ามข้อความยืนยัน
- `--non-interactive`: ปิดใช้งานข้อความถาม; ต้องใช้ `--yes`
- `--dry-run`: พิมพ์การดำเนินการโดยไม่ลบไฟล์
ตัวอย่าง:
```bash
openclaw backup create
openclaw uninstall
openclaw uninstall --service --yes --non-interactive
openclaw uninstall --state --workspace --yes --non-interactive
openclaw uninstall --all --yes
openclaw uninstall --dry-run
```
หมายเหตุ:
- รัน `openclaw backup create` ก่อน หากคุณต้องการสแนปชอตที่กู้คืนได้ก่อนลบสถานะหรือเวิร์กสเปซ
- `--all` เป็นรูปแบบย่อสำหรับการลบบริการ สถานะ เวิร์กสเปซ และแอปร่วมกัน
- `--non-interactive` ต้องใช้ร่วมกับ `--yes`

136
docs/th/cli/update.md Normal file
View File

@ -0,0 +1,136 @@
---
read_when:
- คุณต้องการอัปเดต source checkout อย่างปลอดภัย
- คุณต้องเข้าใจพฤติกรรมแบบย่อของ `--update`
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw update` (อัปเดตซอร์สแบบปลอดภัยพอสมควร + รีสตาร์ต Gateway อัตโนมัติ)
title: update
x-i18n:
generated_at: "2026-04-23T06:20:02Z"
model: gpt-5.4
provider: openai
source_hash: dc049ecf3d35fe276a1e5962bb8e5316dbbc3219ef0b91ee64d41cbbea20f9ae
source_path: cli/update.md
workflow: 15
---
# `openclaw update`
อัปเดต OpenClaw อย่างปลอดภัยและสลับระหว่างช่องทาง stable/beta/dev
หากคุณติดตั้งผ่าน **npm/pnpm/bun** (ติดตั้งแบบ global และไม่มีข้อมูลเมตา git)
การอัปเดตจะเกิดขึ้นผ่านโฟลว์ของตัวจัดการแพ็กเกจใน [การอัปเดต](/th/install/updating)
## การใช้งาน
```bash
openclaw update
openclaw update status
openclaw update wizard
openclaw update --channel beta
openclaw update --channel dev
openclaw update --tag beta
openclaw update --tag main
openclaw update --dry-run
openclaw update --no-restart
openclaw update --yes
openclaw update --json
openclaw --update
```
## ตัวเลือก
- `--no-restart`: ข้ามการรีสตาร์ตบริการ Gateway หลังจากอัปเดตสำเร็จ
- `--channel <stable|beta|dev>`: ตั้งค่าช่องทางการอัปเดต (git + npm; บันทึกไว้ใน config)
- `--tag <dist-tag|version|spec>`: แทนที่เป้าหมายแพ็กเกจสำหรับการอัปเดตครั้งนี้เท่านั้น สำหรับการติดตั้งแบบแพ็กเกจ `main` จะจับคู่เป็น `github:openclaw/openclaw#main`
- `--dry-run`: แสดงตัวอย่างการดำเนินการอัปเดตที่วางแผนไว้ (ช่องทาง/tag/เป้าหมาย/โฟลว์รีสตาร์ต) โดยไม่เขียน config, ติดตั้ง, ซิงก์ Plugin หรือรีสตาร์ต
- `--json`: พิมพ์ JSON `UpdateRunResult` ที่เครื่องอ่านได้ ซึ่งรวมถึง
`postUpdate.plugins.integrityDrifts` เมื่อพบความคลาดเคลื่อนของอาร์ติแฟกต์ Plugin npm
ระหว่างการซิงก์ Plugin หลังอัปเดต
- `--timeout <seconds>`: หมดเวลาต่อหนึ่งขั้นตอน (ค่าเริ่มต้นคือ 1200 วินาที)
- `--yes`: ข้ามพรอมต์ยืนยัน (เช่น การยืนยันการดาวน์เกรด)
หมายเหตุ: การดาวน์เกรดต้องมีการยืนยัน เพราะเวอร์ชันเก่าอาจทำให้การตั้งค่าใช้งานไม่ได้
## `update status`
แสดงช่องทางการอัปเดตที่ใช้งานอยู่ + tag/branch/SHA ของ git (สำหรับ source checkout) พร้อมสถานะความพร้อมของการอัปเดต
```bash
openclaw update status
openclaw update status --json
openclaw update status --timeout 10
```
ตัวเลือก:
- `--json`: พิมพ์ JSON สถานะที่เครื่องอ่านได้
- `--timeout <seconds>`: หมดเวลาสำหรับการตรวจสอบ (ค่าเริ่มต้นคือ 3 วินาที)
## `update wizard`
โฟลว์แบบโต้ตอบเพื่อเลือกช่องทางการอัปเดตและยืนยันว่าจะรีสตาร์ต Gateway
หลังอัปเดตหรือไม่ (ค่าเริ่มต้นคือรีสตาร์ต) หากคุณเลือก `dev` โดยไม่มี git checkout
ระบบจะเสนอให้สร้าง checkout ขึ้นมา
ตัวเลือก:
- `--timeout <seconds>`: หมดเวลาสำหรับแต่ละขั้นตอนของการอัปเดต (ค่าเริ่มต้น `1200`)
## สิ่งที่คำสั่งนี้ทำ
เมื่อคุณสลับช่องทางอย่างชัดเจน (`--channel ...`) OpenClaw จะรักษา
วิธีติดตั้งให้สอดคล้องกันด้วย:
- `dev` → ตรวจสอบให้มี git checkout (ค่าเริ่มต้น: `~/openclaw`, แทนที่ได้ด้วย `OPENCLAW_GIT_DIR`),
อัปเดต checkout นั้น และติดตั้ง CLI แบบ global จาก checkout นั้น
- `stable` → ติดตั้งจาก npm โดยใช้ `latest`
- `beta` → ใช้ npm dist-tag `beta` ก่อน แต่จะ fallback ไปใช้ `latest` เมื่อ beta
ไม่มีอยู่หรือเก่ากว่า stable release ปัจจุบัน
ตัวอัปเดตอัตโนมัติของแกน Gateway (เมื่อเปิดใช้งานผ่าน config) จะใช้เส้นทางการอัปเดตเดียวกันนี้ซ้ำ
สำหรับการติดตั้งผ่านตัวจัดการแพ็กเกจ `openclaw update` จะ resolve เวอร์ชันแพ็กเกจเป้าหมาย
ก่อนเรียกตัวจัดการแพ็กเกจ หากเวอร์ชันที่ติดตั้งอยู่
ตรงกับเป้าหมายพอดี และไม่มีการเปลี่ยนช่องทางการอัปเดตที่ต้องบันทึก
คำสั่งจะออกโดยระบุว่าข้ามแล้วก่อนถึงขั้นติดตั้งแพ็กเกจ, ซิงก์ Plugin, รีเฟรช completion
หรือรีสตาร์ต gateway
## โฟลว์ของ git checkout
ช่องทาง:
- `stable`: checkout tag ล่าสุดที่ไม่ใช่ beta จากนั้น build + doctor
- `beta`: ใช้ tag `-beta` ล่าสุดก่อน แต่จะ fallback ไปใช้ tag stable ล่าสุด
เมื่อไม่มี beta หรือเก่ากว่า
- `dev`: checkout `main` จากนั้น fetch + rebase
ภาพรวมระดับสูง:
1. ต้องใช้ worktree ที่สะอาด (ไม่มีการเปลี่ยนแปลงที่ยังไม่ commit)
2. สลับไปยังช่องทางที่เลือก (tag หรือ branch)
3. ดึงจาก upstream (เฉพาะ dev)
4. เฉพาะ dev: ตรวจสอบล่วงหน้าด้วย lint + TypeScript build ใน worktree ชั่วคราว; หากปลายล่าสุดล้มเหลว จะย้อนกลับได้สูงสุด 10 commit เพื่อหา build ที่สะอาดล่าสุด
5. Rebase ไปยัง commit ที่เลือก (เฉพาะ dev)
6. ติดตั้ง dependency ด้วยตัวจัดการแพ็กเกจของ repo สำหรับ checkout แบบ pnpm ตัวอัปเดตจะบูตสแตรป `pnpm` ตามต้องการ (ผ่าน `corepack` ก่อน แล้วค่อย fallback เป็น `npm install pnpm@10` ชั่วคราว) แทนการรัน `npm run build` ภายใน pnpm workspace
7. Build และ build Control UI
8. รัน `openclaw doctor` เป็นการตรวจสอบ “การอัปเดตอย่างปลอดภัย” ขั้นสุดท้าย
9. ซิงก์ Plugin ไปยังช่องทางที่ใช้งานอยู่ (dev ใช้ extension ที่มาพร้อมระบบ; stable/beta ใช้ npm) และอัปเดต Plugin ที่ติดตั้งผ่าน npm
หากการอัปเดต Plugin npm แบบ pin ตรง resolve ไปยังอาร์ติแฟกต์ที่มีค่า integrity
ต่างจากบันทึกการติดตั้งที่เก็บไว้ `openclaw update` จะยกเลิกการอัปเดตอาร์ติแฟกต์ Plugin นั้น
แทนการติดตั้ง ให้ติดตั้งหรืออัปเดต Plugin นั้นใหม่อย่างชัดเจน
หลังจากตรวจสอบแล้วเท่านั้นว่าคุณเชื่อถืออาร์ติแฟกต์ใหม่
หากการบูตสแตรป pnpm ยังล้มเหลว ตัวอัปเดตจะหยุดก่อนตั้งแต่เนิ่น ๆ พร้อมข้อผิดพลาด
เฉพาะของตัวจัดการแพ็กเกจ แทนการพยายามรัน `npm run build` ภายใน checkout
## รูปแบบย่อ `--update`
`openclaw --update` จะถูกเขียนใหม่เป็น `openclaw update` (มีประโยชน์สำหรับ shell และ launcher script)
## ดูเพิ่มเติม
- `openclaw doctor` (เสนอให้รันการอัปเดตก่อนบน git checkout)
- [ช่องทางการพัฒนา](/th/install/development-channels)
- [การอัปเดต](/th/install/updating)
- [ข้อมูลอ้างอิง CLI](/th/cli)

41
docs/th/cli/voicecall.md Normal file
View File

@ -0,0 +1,41 @@
---
read_when:
- คุณใช้ Plugin voice-call และต้องการจุดเริ่มต้นของ CLI
- คุณต้องการตัวอย่างแบบรวดเร็วสำหรับ `voicecall call|continue|status|tail|expose`
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw voicecall` (พื้นผิวคำสั่งของ Plugin สำหรับการโทรด้วยเสียง)
title: voicecall
x-i18n:
generated_at: "2026-04-23T06:20:08Z"
model: gpt-5.4
provider: openai
source_hash: 2c99e7a3d256e1c74a0f07faba9675cc5a88b1eb2fc6e22993caf3874d4f340a
source_path: cli/voicecall.md
workflow: 15
---
# `openclaw voicecall`
`voicecall` เป็นคำสั่งที่ Plugin เป็นผู้จัดเตรียมไว้ คำสั่งนี้จะแสดงขึ้นก็ต่อเมื่อติดตั้งและเปิดใช้งาน Plugin voice-call แล้วเท่านั้น
เอกสารหลัก:
- Plugin voice-call: [Voice Call](/th/plugins/voice-call)
## คำสั่งทั่วไป
```bash
openclaw voicecall status --call-id <id>
openclaw voicecall call --to "+15555550123" --message "Hello" --mode notify
openclaw voicecall continue --call-id <id> --message "Any questions?"
openclaw voicecall end --call-id <id>
```
## การเปิดเผย webhooks (Tailscale)
```bash
openclaw voicecall expose --mode serve
openclaw voicecall expose --mode funnel
openclaw voicecall expose --mode off
```
หมายเหตุด้านความปลอดภัย: เปิดเผย endpoint ของ Webhook เฉพาะกับเครือข่ายที่คุณเชื่อถือเท่านั้น หากเป็นไปได้ ให้ใช้ Tailscale Serve แทน Funnel

98
docs/th/cli/webhooks.md Normal file
View File

@ -0,0 +1,98 @@
---
read_when:
- คุณต้องการเชื่อมต่ออีเวนต์ Gmail Pub/Sub เข้ากับ OpenClaw
- คุณต้องการคำสั่งตัวช่วย Webhook
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw webhooks` (ตัวช่วย Webhook + Gmail Pub/Sub)
title: webhooks
x-i18n:
generated_at: "2026-04-23T06:20:10Z"
model: gpt-5.4
provider: openai
source_hash: 2b22ce879c3a94557be57919b4d2b3e92ff4d41fbae7bc88d2ab07cd4bbeac83
source_path: cli/webhooks.md
workflow: 15
---
# `openclaw webhooks`
ตัวช่วย Webhook และการผสานรวม (Gmail Pub/Sub, ตัวช่วย Webhook)
ที่เกี่ยวข้อง:
- Webhooks: [Webhooks](/th/automation/cron-jobs#webhooks)
- Gmail Pub/Sub: [Gmail Pub/Sub](/th/automation/cron-jobs#gmail-pubsub-integration)
## Gmail
```bash
openclaw webhooks gmail setup --account you@example.com
openclaw webhooks gmail run
```
### `webhooks gmail setup`
กำหนดค่า Gmail watch, Pub/Sub และการส่งมอบ Webhook ของ OpenClaw
จำเป็น:
- `--account <email>`
ตัวเลือก:
- `--project <id>`
- `--topic <name>`
- `--subscription <name>`
- `--label <label>`
- `--hook-url <url>`
- `--hook-token <token>`
- `--push-token <token>`
- `--bind <host>`
- `--port <port>`
- `--path <path>`
- `--include-body`
- `--max-bytes <n>`
- `--renew-minutes <n>`
- `--tailscale <funnel|serve|off>`
- `--tailscale-path <path>`
- `--tailscale-target <target>`
- `--push-endpoint <url>`
- `--json`
ตัวอย่าง:
```bash
openclaw webhooks gmail setup --account you@example.com
openclaw webhooks gmail setup --account you@example.com --project my-gcp-project --json
openclaw webhooks gmail setup --account you@example.com --hook-url https://gateway.example.com/hooks/gmail
```
### `webhooks gmail run`
รัน `gog watch serve` พร้อมลูปต่ออายุ watch อัตโนมัติ
ตัวเลือก:
- `--account <email>`
- `--topic <topic>`
- `--subscription <name>`
- `--label <label>`
- `--hook-url <url>`
- `--hook-token <token>`
- `--push-token <token>`
- `--bind <host>`
- `--port <port>`
- `--path <path>`
- `--include-body`
- `--max-bytes <n>`
- `--renew-minutes <n>`
- `--tailscale <funnel|serve|off>`
- `--tailscale-path <path>`
- `--tailscale-target <target>`
ตัวอย่าง:
```bash
openclaw webhooks gmail run --account you@example.com
```
ดู [เอกสาร Gmail Pub/Sub](/th/automation/cron-jobs#gmail-pubsub-integration) สำหรับขั้นตอนการตั้งค่าแบบครบวงจรและรายละเอียดการปฏิบัติงาน

221
docs/th/cli/wiki.md Normal file
View File

@ -0,0 +1,221 @@
---
read_when:
- คุณต้องการใช้ CLI ของ memory-wiki
- คุณกำลังจัดทำเอกสารหรือเปลี่ยนแปลง `openclaw wiki`
summary: ข้อมูลอ้างอิง CLI สำหรับ `openclaw wiki` (สถานะคลัง memory-wiki, การค้นหา, การคอมไพล์, การ lint, การ apply, สะพาน และตัวช่วยสำหรับ Obsidian)
title: วิกิ
x-i18n:
generated_at: "2026-04-23T06:20:11Z"
model: gpt-5.4
provider: openai
source_hash: e94908532c35da4edf488266ddc6eee06e8f7833eeba5f2b5c0c7d5d45b65eef
source_path: cli/wiki.md
workflow: 15
---
# `openclaw wiki`
ตรวจสอบและดูแลคลัง `memory-wiki`
จัดเตรียมโดย Plugin `memory-wiki` ที่มาพร้อมในชุด
ที่เกี่ยวข้อง:
- [Plugin Memory Wiki](/th/plugins/memory-wiki)
- [ภาพรวม Memory](/th/concepts/memory)
- [CLI: memory](/th/cli/memory)
## ใช้สำหรับอะไร
ใช้ `openclaw wiki` เมื่อต้องการคลังความรู้ที่คอมไพล์แล้วพร้อมคุณสมบัติดังนี้:
- การค้นหาและการอ่านหน้าแบบ native ของวิกิ
- การสังเคราะห์ที่มี provenance ครบถ้วน
- รายงานความขัดแย้งและความสดใหม่
- การนำเข้าผ่านสะพานจาก Plugin memory ที่ใช้งานอยู่
- ตัวช่วย CLI สำหรับ Obsidian แบบไม่บังคับ
## คำสั่งที่ใช้บ่อย
```bash
openclaw wiki status
openclaw wiki doctor
openclaw wiki init
openclaw wiki ingest ./notes/alpha.md
openclaw wiki compile
openclaw wiki lint
openclaw wiki search "alpha"
openclaw wiki get entity.alpha --from 1 --lines 80
openclaw wiki apply synthesis "Alpha Summary" \
--body "Short synthesis body" \
--source-id source.alpha
openclaw wiki apply metadata entity.alpha \
--source-id source.alpha \
--status review \
--question "Still active?"
openclaw wiki bridge import
openclaw wiki unsafe-local import
openclaw wiki obsidian status
openclaw wiki obsidian search "alpha"
openclaw wiki obsidian open syntheses/alpha-summary.md
openclaw wiki obsidian command workspace:quick-switcher
openclaw wiki obsidian daily
```
## คำสั่ง
### `wiki status`
ตรวจสอบโหมดคลังปัจจุบัน สถานะสุขภาพ และความพร้อมใช้งานของ Obsidian CLI
ใช้คำสั่งนี้ก่อนเมื่อคุณยังไม่แน่ใจว่าคลังถูกเริ่มต้นแล้วหรือยัง โหมดสะพาน
มีสถานะดีหรือไม่ หรือมีการผสานรวมกับ Obsidian พร้อมใช้งานหรือไม่
### `wiki doctor`
เรียกใช้การตรวจสอบสุขภาพของวิกิและแสดงปัญหาคอนฟิกหรือปัญหาคลัง
ปัญหาที่พบบ่อยได้แก่:
- เปิดใช้โหมดสะพานโดยไม่มีอาร์ติแฟกต์ memory แบบสาธารณะ
- โครงร่างคลังไม่ถูกต้องหรือไม่มีอยู่
- ไม่มี Obsidian CLI ภายนอก ทั้งที่คาดว่าจะใช้โหมด Obsidian
### `wiki init`
สร้างโครงร่างคลังวิกิและหน้าเริ่มต้น
คำสั่งนี้จะเริ่มต้นโครงสร้างราก รวมถึงดัชนีระดับบนสุดและไดเรกทอรี
แคช
### `wiki ingest <path-or-url>`
นำเข้าเนื้อหาเข้าสู่ชั้น source ของวิกิ
หมายเหตุ:
- การนำเข้าจาก URL ถูกควบคุมโดย `ingest.allowUrlIngest`
- หน้า source ที่นำเข้าจะเก็บ provenance ไว้ใน frontmatter
- สามารถรันการคอมไพล์อัตโนมัติหลังการนำเข้าได้เมื่อเปิดใช้งาน
### `wiki compile`
สร้างดัชนี บล็อกที่เกี่ยวข้อง แดชบอร์ด และ digest ที่คอมไพล์แล้วขึ้นใหม่
คำสั่งนี้จะเขียนอาร์ติแฟกต์แบบคงที่สำหรับเครื่องไว้ที่:
- `.openclaw-wiki/cache/agent-digest.json`
- `.openclaw-wiki/cache/claims.jsonl`
หากเปิดใช้ `render.createDashboards` การคอมไพล์จะรีเฟรชหน้ารายงานด้วย
### `wiki lint`
lint คลังและรายงาน:
- ปัญหาเชิงโครงสร้าง
- ช่องว่างของ provenance
- ความขัดแย้ง
- คำถามที่ยังเปิดอยู่
- หน้า/claims ที่มีความเชื่อมั่นต่ำ
- หน้า/claims ที่ล้าสมัย
ให้รันหลังจากมีการอัปเดตวิกิที่มีนัยสำคัญ
### `wiki search <query>`
ค้นหาเนื้อหาในวิกิ
พฤติกรรมขึ้นอยู่กับคอนฟิก:
- `search.backend`: `shared` หรือ `local`
- `search.corpus`: `wiki`, `memory`, หรือ `all`
ใช้ `wiki search` เมื่อต้องการการจัดอันดับหรือรายละเอียด provenance
เฉพาะของวิกิ สำหรับการเรียกคืนแบบแชร์กว้างๆ เพียงครั้งเดียว ให้ใช้
`openclaw memory search` เมื่อ Plugin memory ที่ใช้งานอยู่เปิดเผยการค้นหาแบบแชร์
### `wiki get <lookup>`
อ่านหน้าวิกิตาม id หรือพาธสัมพัทธ์
ตัวอย่าง:
```bash
openclaw wiki get entity.alpha
openclaw wiki get syntheses/alpha-summary.md --from 1 --lines 80
```
### `wiki apply`
ใช้การเปลี่ยนแปลงแบบจำกัดขอบเขตโดยไม่ต้องผ่าตัดหน้าแบบ freeform
โฟลว์ที่รองรับ ได้แก่:
- สร้าง/อัปเดตหน้าสังเคราะห์
- อัปเดต metadata ของหน้า
- แนบ source id
- เพิ่มคำถาม
- เพิ่มความขัดแย้ง
- อัปเดตความเชื่อมั่น/สถานะ
- เขียน claims แบบมีโครงสร้าง
คำสั่งนี้มีไว้เพื่อให้วิกิพัฒนาได้อย่างปลอดภัยโดยไม่ต้องแก้ไข
บล็อกที่ระบบจัดการด้วยตนเองโดยตรง
### `wiki bridge import`
นำเข้าอาร์ติแฟกต์ memory แบบสาธารณะจาก Plugin memory ที่ใช้งานอยู่เข้าสู่หน้า source
ที่รองรับโดยสะพาน
ใช้คำสั่งนี้ในโหมด `bridge` เมื่อต้องการดึงอาร์ติแฟกต์ memory ที่ส่งออกล่าสุด
เข้าสู่คลังวิกิ
### `wiki unsafe-local import`
นำเข้าจากพาธภายในเครื่องที่กำหนดไว้อย่างชัดเจนในโหมด `unsafe-local`
นี่เป็นฟีเจอร์เชิงทดลองโดยตั้งใจและใช้ได้เฉพาะบนเครื่องเดียวกันเท่านั้น
### `wiki obsidian ...`
คำสั่งตัวช่วย Obsidian สำหรับคลังที่ทำงานในโหมดที่เป็นมิตรกับ Obsidian
คำสั่งย่อย:
- `status`
- `search`
- `open`
- `command`
- `daily`
คำสั่งเหล่านี้ต้องใช้ `obsidian` CLI อย่างเป็นทางการใน `PATH` เมื่อ
เปิดใช้ `obsidian.useOfficialCli`
## แนวทางการใช้งานจริง
- ใช้ `wiki search` + `wiki get` เมื่อ provenance และตัวตนของหน้ามีความสำคัญ
- ใช้ `wiki apply` แทนการแก้ไขส่วนที่ระบบสร้างและจัดการเองด้วยมือ
- ใช้ `wiki lint` ก่อนเชื่อถือเนื้อหาที่มีความขัดแย้งหรือมีความเชื่อมั่นต่ำ
- ใช้ `wiki compile` หลังการนำเข้าจำนวนมากหรือหลังเปลี่ยน source เมื่อคุณต้องการ
แดชบอร์ดและ digest ที่คอมไพล์แล้วใหม่ทันที
- ใช้ `wiki bridge import` เมื่อโหมดสะพานขึ้นอยู่กับอาร์ติแฟกต์ memory
ที่เพิ่งส่งออกใหม่
## ส่วนที่เชื่อมโยงกับคอนฟิก
พฤติกรรมของ `openclaw wiki` ถูกกำหนดโดย:
- `plugins.entries.memory-wiki.config.vaultMode`
- `plugins.entries.memory-wiki.config.search.backend`
- `plugins.entries.memory-wiki.config.search.corpus`
- `plugins.entries.memory-wiki.config.bridge.*`
- `plugins.entries.memory-wiki.config.obsidian.*`
- `plugins.entries.memory-wiki.config.render.*`
- `plugins.entries.memory-wiki.config.context.includeCompiledDigestPrompt`
ดู [Plugin Memory Wiki](/th/plugins/memory-wiki) สำหรับโมเดลคอนฟิกทั้งหมด

381
docs/th/web/control-ui.md Normal file
View File

@ -0,0 +1,381 @@
---
read_when:
- คุณต้องการใช้งาน Gateway จากเบราว์เซอร์
- คุณต้องการเข้าถึงผ่าน Tailnet โดยไม่ต้องใช้ SSH tunnels
summary: Control UI สำหรับ Gateway บนเบราว์เซอร์ (แชต, nodes, config)
title: Control UI
x-i18n:
generated_at: "2026-04-23T06:20:10Z"
model: gpt-5.4
provider: openai
source_hash: 63e3dbba6b05a5e00499fbe75e6a66a89e0b6b3d9d66e69143068e087f517b8a
source_path: web/control-ui.md
workflow: 15
---
# Control UI (เบราว์เซอร์)
Control UI คือแอปหน้าเดียวขนาดเล็กแบบ **Vite + Lit** ที่ Gateway ให้บริการ:
- ค่าเริ่มต้น: `http://<host>:18789/`
- คำนำหน้าแบบไม่บังคับ: ตั้งค่า `gateway.controlUi.basePath` (เช่น `/openclaw`)
มันสื่อสาร **โดยตรงกับ Gateway WebSocket** บนพอร์ตเดียวกัน
## เปิดใช้งานอย่างรวดเร็ว (ภายในเครื่อง)
หาก Gateway กำลังทำงานอยู่บนคอมพิวเตอร์เครื่องเดียวกัน ให้เปิด:
- [http://127.0.0.1:18789/](http://127.0.0.1:18789/) (หรือ [http://localhost:18789/](http://localhost:18789/))
หากหน้าไม่โหลด ให้เริ่ม Gateway ก่อน: `openclaw gateway`
การยืนยันตัวตนจะถูกส่งระหว่างการจับมือของ WebSocket ผ่าน:
- `connect.params.auth.token`
- `connect.params.auth.password`
- ส่วนหัวข้อมูลตัวตนของ Tailscale Serve เมื่อ `gateway.auth.allowTailscale: true`
- ส่วนหัวข้อมูลตัวตนของ trusted-proxy เมื่อ `gateway.auth.mode: "trusted-proxy"`
แผงการตั้งค่าแดชบอร์ดจะเก็บโทเค็นไว้สำหรับเซสชันแท็บเบราว์เซอร์ปัจจุบัน
และ URL ของ gateway ที่เลือก; รหัสผ่านจะไม่ถูกเก็บไว้
โดยทั่วไปการเริ่มต้นใช้งานครั้งแรกจะสร้างโทเค็น gateway สำหรับการยืนยันตัวตนแบบ shared-secret ในการเชื่อมต่อครั้งแรก แต่การยืนยันตัวตนด้วยรหัสผ่านก็ใช้ได้เช่นกันเมื่อ `gateway.auth.mode` เป็น `"password"`
## การจับคู่อุปกรณ์ (การเชื่อมต่อครั้งแรก)
เมื่อคุณเชื่อมต่อกับ Control UI จากเบราว์เซอร์หรืออุปกรณ์ใหม่ Gateway
จะต้องมี **การอนุมัติการจับคู่แบบครั้งเดียว** — แม้ว่าคุณจะอยู่ใน Tailnet เดียวกัน
โดยมี `gateway.auth.allowTailscale: true` ก็ตาม นี่เป็นมาตรการด้านความปลอดภัยเพื่อป้องกัน
การเข้าถึงโดยไม่ได้รับอนุญาต
**สิ่งที่คุณจะเห็น:** "disconnected (1008): pairing required"
**วิธีอนุมัติอุปกรณ์:**
```bash
# แสดงรายการคำขอที่รอดำเนินการ
openclaw devices list
# อนุมัติตาม request ID
openclaw devices approve <requestId>
```
หากเบราว์เซอร์ลองจับคู่อีกครั้งโดยมีรายละเอียดการยืนยันตัวตนที่เปลี่ยนไป (role/scopes/public
key) คำขอที่รออยู่ก่อนหน้าจะถูกแทนที่ และจะมี `requestId` ใหม่
ถูกสร้างขึ้น ให้รัน `openclaw devices list` อีกครั้งก่อนอนุมัติ
หากเบราว์เซอร์ถูกจับคู่ไว้แล้วและคุณเปลี่ยนจากสิทธิ์อ่านเป็น
สิทธิ์เขียน/ผู้ดูแลระบบ สิ่งนี้จะถูกถือเป็นการอัปเกรดการอนุมัติ ไม่ใช่การเชื่อมต่อใหม่แบบเงียบ
OpenClaw จะคงการอนุมัติเดิมไว้ บล็อกการเชื่อมต่อใหม่ที่มีสิทธิ์กว้างขึ้น
และขอให้คุณอนุมัติชุดสิทธิ์ใหม่อย่างชัดเจน
เมื่ออนุมัติแล้ว อุปกรณ์จะถูกจดจำและจะไม่ต้องอนุมัติซ้ำอีก
เว้นแต่คุณจะเพิกถอนด้วย `openclaw devices revoke --device <id> --role <role>` ดู
[Devices CLI](/th/cli/devices) สำหรับการหมุนเวียนโทเค็นและการเพิกถอน
**หมายเหตุ:**
- การเชื่อมต่อเบราว์เซอร์ผ่าน local loopback โดยตรง (`127.0.0.1` / `localhost`) จะได้รับการอนุมัติอัตโนมัติ
- การเชื่อมต่อเบราว์เซอร์ผ่าน Tailnet และ LAN ยังคงต้องได้รับการอนุมัติอย่างชัดเจน แม้ว่า
จะมาจากเครื่องเดียวกันก็ตาม
- แต่ละโปรไฟล์เบราว์เซอร์จะสร้าง device ID ที่ไม่ซ้ำกัน ดังนั้นการสลับเบราว์เซอร์หรือ
การล้างข้อมูลเบราว์เซอร์จะต้องจับคู่ใหม่
## การรองรับภาษา
Control UI สามารถแปลภาษาตัวเองได้ในการโหลดครั้งแรกตาม locale ของเบราว์เซอร์คุณ
หากต้องการเปลี่ยนในภายหลัง ให้เปิด **Overview -> Gateway Access -> Language** ตัวเลือก
locale จะอยู่ในการ์ด Gateway Access ไม่ได้อยู่ใต้ Appearance
- locales ที่รองรับ: `en`, `zh-CN`, `zh-TW`, `pt-BR`, `de`, `es`, `ja-JP`, `ko`, `fr`, `tr`, `uk`, `id`, `pl`
- คำแปลที่ไม่ใช่ภาษาอังกฤษจะถูกโหลดแบบ lazy ในเบราว์เซอร์
- locale ที่เลือกจะถูกบันทึกไว้ในที่เก็บข้อมูลของเบราว์เซอร์และนำกลับมาใช้ในการเข้าชมครั้งต่อไป
- คีย์คำแปลที่ไม่มีจะ fallback กลับเป็นภาษาอังกฤษ
## สิ่งที่ทำได้ (ตอนนี้)
- แชตกับโมเดลผ่าน Gateway WS (`chat.history`, `chat.send`, `chat.abort`, `chat.inject`)
- สตรีมการเรียกใช้เครื่องมือ + การ์ดเอาต์พุตเครื่องมือสดใน Chat (เหตุการณ์ของเอเจนต์)
- Channels: สถานะของ channel ที่มีมาให้ในตัวรวมถึง channel จาก bundled/external Plugin, การล็อกอินด้วย QR และ config ราย channel (`channels.status`, `web.login.*`, `config.patch`)
- Instances: รายการสถานะออนไลน์ + รีเฟรช (`system-presence`)
- Sessions: แสดงรายการ + การ override รายเซสชันสำหรับ model/thinking/fast/verbose/trace/reasoning (`sessions.list`, `sessions.patch`)
- Dreams: สถานะ Dreaming, สวิตช์เปิด/ปิดใช้งาน และตัวอ่าน Dream Diary (`doctor.memory.status`, `doctor.memory.dreamDiary`, `config.patch`)
- งาน Cron: แสดงรายการ/เพิ่ม/แก้ไข/รัน/เปิดใช้งาน/ปิดใช้งาน + ประวัติการรัน (`cron.*`)
- Skills: สถานะ, เปิด/ปิดใช้งาน, ติดตั้ง, อัปเดต API key (`skills.*`)
- Nodes: แสดงรายการ + caps (`node.list`)
- การอนุมัติ exec: แก้ไข allowlists ของ gateway หรือ node + ถามนโยบายสำหรับ `exec host=gateway/node` (`exec.approvals.*`)
- Config: ดู/แก้ไข `~/.openclaw/openclaw.json` (`config.get`, `config.set`)
- Config: ใช้การตั้งค่า + รีสตาร์ทพร้อมการตรวจสอบความถูกต้อง (`config.apply`) และปลุกเซสชันที่ใช้งานล่าสุด
- การเขียน config มีตัวป้องกัน base-hash เพื่อไม่ให้เขียนทับการแก้ไขพร้อมกัน
- การเขียน config (`config.set`/`config.apply`/`config.patch`) ยังตรวจสอบล่วงหน้าการ resolve SecretRef ที่กำลังใช้งานสำหรับ refs ใน payload config ที่ส่งมา; refs ที่ส่งมาซึ่งยัง resolve ไม่ได้และกำลังใช้งานอยู่จะถูกปฏิเสธก่อนการเขียน
- Config schema + การเรนเดอร์ฟอร์ม (`config.schema` / `config.schema.lookup`,
รวมถึง `title` / `description` ของฟิลด์, UI hints ที่จับคู่กัน, สรุปลูกโดยตรงทันที,
เมทาดาต้า docs บนโหนด object/wildcard/array/composition ที่ซ้อนกัน,
พร้อมทั้ง schemas ของ Plugin + channel เมื่อมี); ตัวแก้ไข Raw JSON
จะใช้งานได้เฉพาะเมื่อ snapshot นั้นมีการ round-trip raw ที่ปลอดภัย
- หาก snapshot ไม่สามารถ round-trip ข้อความ raw ได้อย่างปลอดภัย Control UI จะบังคับใช้โหมด Form และปิดใช้งานโหมด Raw สำหรับ snapshot นั้น
- ค่า SecretRef object แบบมีโครงสร้างจะแสดงแบบอ่านอย่างเดียวในอินพุตข้อความของฟอร์มเพื่อป้องกันความเสียหายจากการแปลง object เป็น string โดยไม่ตั้งใจ
- ดีบัก: snapshots ของ status/health/models + บันทึกเหตุการณ์ + การเรียก RPC ด้วยตนเอง (`status`, `health`, `models.list`)
- Logs: live tail ของไฟล์บันทึกของ gateway พร้อมการกรอง/ส่งออก (`logs.tail`)
- อัปเดต: รันการอัปเดต package/git + รีสตาร์ท (`update.run`) พร้อมรายงานการรีสตาร์ท
หมายเหตุสำหรับแผงงาน Cron:
- สำหรับงานแบบ isolated การส่งจะตั้งค่าเริ่มต้นเป็นประกาศสรุป คุณสามารถสลับเป็นไม่มีได้หากต้องการให้รันภายในเท่านั้น
- ฟิลด์ channel/target จะแสดงเมื่อเลือก announce
- โหมด Webhook ใช้ `delivery.mode = "webhook"` โดยตั้งค่า `delivery.to` เป็น URL Webhook HTTP(S) ที่ถูกต้อง
- สำหรับงาน main-session จะมีโหมดการส่งแบบ webhook และ none ให้ใช้
- ตัวควบคุมการแก้ไขขั้นสูงรวมถึง delete-after-run, การล้าง agent override, ตัวเลือก cron แบบ exact/stagger,
การ override model/thinking ของเอเจนต์ และสวิตช์ best-effort delivery
- การตรวจสอบฟอร์มจะทำแบบ inline พร้อมข้อผิดพลาดระดับฟิลด์; ค่าที่ไม่ถูกต้องจะปิดปุ่มบันทึกจนกว่าจะแก้ไข
- ตั้งค่า `cron.webhookToken` เพื่อส่ง bearer token เฉพาะได้ หากไม่ระบุ Webhook จะถูกส่งโดยไม่มีส่วนหัว auth
- fallback ที่เลิกใช้แล้ว: งานแบบเก่าที่เก็บไว้ด้วย `notify: true` ยังสามารถใช้ `cron.webhook` ได้จนกว่าจะย้ายข้อมูลเสร็จ
## พฤติกรรมของ Chat
- `chat.send` เป็นแบบ **ไม่บล็อก**: จะตอบรับทันทีด้วย `{ runId, status: "started" }` และคำตอบจะสตรีมผ่านเหตุการณ์ `chat`
- การส่งซ้ำด้วย `idempotencyKey` เดิมจะคืนค่า `{ status: "in_flight" }` ระหว่างที่กำลังรัน และ `{ status: "ok" }` หลังจากเสร็จสิ้น
- การตอบกลับของ `chat.history` มีการจำกัดขนาดเพื่อความปลอดภัยของ UI เมื่อรายการในทรานสคริปต์มีขนาดใหญ่เกินไป Gateway อาจตัดทอนฟิลด์ข้อความยาว ละบล็อกเมทาดาต้าหนัก ๆ และแทนข้อความที่ใหญ่เกินไปด้วย placeholder (`[chat.history omitted: message too large]`)
- `chat.history` ยังลบแท็ก directive แบบ inline ที่ใช้เพื่อการแสดงผลเท่านั้นออกจากข้อความผู้ช่วยที่มองเห็นได้ (เช่น `[[reply_to_*]]` และ `[[audio_as_voice]]`), เพย์โหลด XML ของการเรียกใช้เครื่องมือแบบข้อความล้วน (รวมถึง `<tool_call>...</tool_call>`, `<function_call>...</function_call>`, `<tool_calls>...</tool_calls>`, `<function_calls>...</function_calls>` และบล็อกการเรียกใช้เครื่องมือที่ถูกตัดทอน), รวมถึง token ควบคุมโมเดลแบบ ASCII/เต็มความกว้างที่รั่วออกมา และจะละรายการของผู้ช่วยที่ข้อความที่มองเห็นได้ทั้งหมดมีเพียง token เงียบตรงตัว `NO_REPLY` / `no_reply`
- `chat.inject` จะต่อท้ายหมายเหตุของผู้ช่วยลงในทรานสคริปต์ของเซสชันและกระจายเหตุการณ์ `chat` สำหรับการอัปเดตเฉพาะ UI (ไม่มีการรันเอเจนต์ ไม่มีการส่งไปยัง channel)
- ตัวเลือก model และ thinking ในส่วนหัวของแชตจะ patch เซสชันที่ใช้งานอยู่ทันทีผ่าน `sessions.patch`; สิ่งเหล่านี้เป็นการ override ถาวรของเซสชัน ไม่ใช่ตัวเลือกส่งแบบใช้แค่หนึ่งเทิร์น
- หยุด:
- คลิก **Stop** (เรียก `chat.abort`)
- พิมพ์ `/stop` (หรือวลีหยุดแบบสแตนด์อโลน เช่น `stop`, `stop action`, `stop run`, `stop openclaw`, `please stop`) เพื่อยกเลิกแบบ out-of-band
- `chat.abort` รองรับ `{ sessionKey }` (ไม่มี `runId`) เพื่อยกเลิกการรันที่ใช้งานอยู่ทั้งหมดสำหรับเซสชันนั้น
- การเก็บบางส่วนเมื่อยกเลิก:
- เมื่อการรันถูกยกเลิก ข้อความผู้ช่วยบางส่วนยังอาจแสดงใน UI
- Gateway จะคงข้อความผู้ช่วยบางส่วนที่ถูกยกเลิกไว้ในประวัติทรานสคริปต์เมื่อมีเอาต์พุตที่บัฟเฟอร์ไว้
- รายการที่คงไว้จะมีเมทาดาต้าการยกเลิกเพื่อให้ตัวใช้ทรานสคริปต์แยกแยะข้อความบางส่วนจากการยกเลิกกับเอาต์พุตที่เสร็จสมบูรณ์ตามปกติได้
## Hosted embeds
ข้อความของผู้ช่วยสามารถเรนเดอร์เว็บคอนเทนต์ที่โฮสต์ไว้แบบ inline ได้ด้วย shortcode `[embed ...]`
นโยบาย sandbox ของ iframe ถูกควบคุมโดย
`gateway.controlUi.embedSandbox`:
- `strict`: ปิดการทำงานของสคริปต์ภายใน hosted embeds
- `scripts`: อนุญาตให้มี embeds แบบโต้ตอบได้โดยยังคงการแยก origin; นี่คือ
ค่าเริ่มต้น และโดยทั่วไปก็เพียงพอสำหรับเกม/วิดเจ็ตบนเบราว์เซอร์ที่มีองค์ประกอบในตัว
- `trusted`: เพิ่ม `allow-same-origin` บน `allow-scripts` สำหรับเอกสารไซต์เดียวกัน
ที่ตั้งใจให้ต้องใช้สิทธิ์ที่มากกว่า
ตัวอย่าง:
```json5
{
gateway: {
controlUi: {
embedSandbox: "scripts",
},
},
}
```
ใช้ `trusted` เฉพาะเมื่อเอกสารที่ฝังไว้ต้องการพฤติกรรมแบบ same-origin จริง ๆ
สำหรับเกมและแคนวาสแบบโต้ตอบที่เอเจนต์สร้างขึ้นส่วนใหญ่ `scripts` เป็น
ตัวเลือกที่ปลอดภัยกว่า
URL embed ภายนอกแบบ absolute `http(s)` จะยังถูกบล็อกเป็นค่าเริ่มต้น หากคุณ
ตั้งใจให้ `[embed url="https://..."]` โหลดหน้าเว็บของบุคคลที่สาม ให้ตั้งค่า
`gateway.controlUi.allowExternalEmbedUrls: true`
## การเข้าถึงผ่าน Tailnet (แนะนำ)
### Tailscale Serve แบบรวมในตัว (แนะนำ)
ให้ Gateway อยู่บน loopback และให้ Tailscale Serve ทำหน้าที่พร็อกซีให้ผ่าน HTTPS:
```bash
openclaw gateway --tailscale serve
```
เปิด:
- `https://<magicdns>/` (หรือ `gateway.controlUi.basePath` ที่คุณตั้งค่าไว้)
โดยค่าเริ่มต้น คำขอ Serve ของ Control UI/WebSocket สามารถยืนยันตัวตนผ่านส่วนหัวข้อมูลตัวตนของ Tailscale
(`tailscale-user-login`) ได้เมื่อ `gateway.auth.allowTailscale` เป็น `true` OpenClaw
จะตรวจสอบตัวตนโดย resolve ที่อยู่ `x-forwarded-for` ด้วย
`tailscale whois` และจับคู่กับส่วนหัว และจะยอมรับเฉพาะเมื่อ
คำขอมาถึง loopback พร้อมส่วนหัว `x-forwarded-*` ของ Tailscale เท่านั้น ตั้งค่า
`gateway.auth.allowTailscale: false` หากคุณต้องการบังคับให้ใช้ข้อมูลรับรอง shared-secret อย่างชัดเจน
แม้กับทราฟฟิกของ Serve จากนั้นใช้ `gateway.auth.mode: "token"` หรือ
`"password"`
สำหรับเส้นทางตัวตนของ Serve แบบ async นั้น ความพยายามยืนยันตัวตนที่ล้มเหลวจาก IP ไคลเอนต์เดียวกัน
และขอบเขต auth เดียวกันจะถูกจัดลำดับก่อนการเขียน rate-limit ดังนั้นการลองผิดพร้อมกัน
จากเบราว์เซอร์เดียวกันอาจแสดง `retry later` ในคำขอที่สอง แทนที่จะเป็นความไม่ตรงกันปกติสองครั้งที่แข่งกันแบบขนาน
การยืนยันตัวตนแบบ Serve ที่ไม่มีโทเค็นตั้งอยู่บนสมมติฐานว่าโฮสต์ gateway เชื่อถือได้ หากมีโค้ดภายในเครื่องที่ไม่น่าเชื่อถืออาจรันบนโฮสต์นั้น ให้บังคับใช้การยืนยันตัวตนด้วย token/password
### bind กับ tailnet + token
```bash
openclaw gateway --bind tailnet --token "$(openssl rand -hex 32)"
```
จากนั้นเปิด:
- `http://<tailscale-ip>:18789/` (หรือ `gateway.controlUi.basePath` ที่คุณตั้งค่าไว้)
วาง shared secret ที่ตรงกันลงใน UI settings (ส่งเป็น
`connect.params.auth.token` หรือ `connect.params.auth.password`)
## HTTP ที่ไม่ปลอดภัย
หากคุณเปิดแดชบอร์ดผ่าน HTTP แบบไม่เข้ารหัส (`http://<lan-ip>` หรือ `http://<tailscale-ip>`),
เบราว์เซอร์จะทำงานใน **บริบทที่ไม่ปลอดภัย** และบล็อก WebCrypto โดยค่าเริ่มต้น
OpenClaw จะ **บล็อก** การเชื่อมต่อของ Control UI ที่ไม่มีตัวตนอุปกรณ์
ข้อยกเว้นที่มีเอกสารระบุไว้:
- ความเข้ากันได้ของ HTTP แบบไม่ปลอดภัยสำหรับ localhost เท่านั้นด้วย `gateway.controlUi.allowInsecureAuth=true`
- การยืนยันตัวตนของผู้ปฏิบัติงาน Control UI ที่สำเร็จผ่าน `gateway.auth.mode: "trusted-proxy"`
- ตัวเลือกฉุกเฉิน `gateway.controlUi.dangerouslyDisableDeviceAuth=true`
**วิธีแก้ที่แนะนำ:** ใช้ HTTPS (Tailscale Serve) หรือเปิด UI ภายในเครื่อง:
- `https://<magicdns>/` (Serve)
- `http://127.0.0.1:18789/` (บนโฮสต์ gateway)
**พฤติกรรมของสวิตช์ insecure-auth:**
```json5
{
gateway: {
controlUi: { allowInsecureAuth: true },
bind: "tailnet",
auth: { mode: "token", token: "replace-me" },
},
}
```
`allowInsecureAuth` เป็นสวิตช์ความเข้ากันได้ภายในเครื่องเท่านั้น:
- อนุญาตให้เซสชัน Control UI บน localhost ดำเนินการต่อได้โดยไม่มีตัวตนอุปกรณ์ใน
บริบท HTTP ที่ไม่ปลอดภัย
- ไม่ข้ามการตรวจสอบการจับคู่
- ไม่ผ่อนคลายข้อกำหนดตัวตนอุปกรณ์สำหรับการเชื่อมต่อระยะไกล (ที่ไม่ใช่ localhost)
**ใช้เฉพาะกรณีฉุกเฉินเท่านั้น:**
```json5
{
gateway: {
controlUi: { dangerouslyDisableDeviceAuth: true },
bind: "tailnet",
auth: { mode: "token", token: "replace-me" },
},
}
```
`dangerouslyDisableDeviceAuth` จะปิดการตรวจสอบตัวตนอุปกรณ์ของ Control UI และเป็นการลดระดับความปลอดภัยอย่างรุนแรง ควรย้อนกลับโดยเร็วหลังใช้ในกรณีฉุกเฉิน
หมายเหตุเกี่ยวกับ trusted-proxy:
- การยืนยันตัวตนผ่าน trusted-proxy ที่สำเร็จสามารถอนุญาตเซสชัน Control UI ของ **operator** ได้โดยไม่มีตัวตนอุปกรณ์
- แต่สิ่งนี้ **ไม่** ครอบคลุมถึงเซสชัน Control UI ที่มีบทบาทเป็น node
- reverse proxy แบบ loopback บนโฮสต์เดียวกันก็ยังไม่ผ่านการยืนยันตัวตนแบบ trusted-proxy; ดู
[Trusted Proxy Auth](/th/gateway/trusted-proxy-auth)
ดู [Tailscale](/th/gateway/tailscale) สำหรับคำแนะนำในการตั้งค่า HTTPS
## นโยบาย Content Security Policy
Control UI มาพร้อมนโยบาย `img-src` ที่เข้มงวด: อนุญาตเฉพาะแอสเซ็ตแบบ **same-origin** และ URL `data:` เท่านั้น URL รูปภาพระยะไกลแบบ `http(s)` และแบบ protocol-relative จะถูกเบราว์เซอร์ปฏิเสธและจะไม่เกิดการดึงข้อมูลเครือข่าย
ในทางปฏิบัติหมายความว่า:
- รูปประจำตัวและรูปภาพที่ให้บริการภายใต้พาธแบบ relative (เช่น `/avatars/<id>`) ยังคงแสดงผลได้
- URL แบบ inline `data:image/...` ยังคงแสดงผลได้ (มีประโยชน์สำหรับเพย์โหลดภายในโปรโตคอล)
- URL รูปประจำตัวระยะไกลที่ส่งมาจากเมทาดาต้าของ channel จะถูกตัดออกโดยตัวช่วยจัดการรูปประจำตัวของ Control UI และแทนที่ด้วยโลโก้/ป้ายในตัว ดังนั้น channel ที่ถูกเจาะหรือเป็นอันตรายจะไม่สามารถบังคับให้เบราว์เซอร์ของ operator ดึงรูปภาพระยะไกลตามอำเภอใจได้
คุณไม่ต้องเปลี่ยนแปลงอะไรเพื่อให้ได้พฤติกรรมนี้ — มันเปิดใช้งานอยู่เสมอและไม่สามารถกำหนดค่าได้
## การยืนยันตัวตนของเส้นทาง avatar
เมื่อมีการตั้งค่า gateway auth ปลายทาง avatar ของ Control UI จะต้องใช้โทเค็น gateway เดียวกันกับ API ส่วนที่เหลือ:
- `GET /avatar/<agentId>` จะส่งคืนรูป avatar ให้เฉพาะผู้เรียกที่ยืนยันตัวตนแล้วเท่านั้น `GET /avatar/<agentId>?meta=1` จะส่งคืนเมทาดาต้าของ avatar ภายใต้กฎเดียวกัน
- คำขอที่ไม่ได้ยืนยันตัวตนไปยังทั้งสองเส้นทางจะถูกปฏิเสธ (สอดคล้องกับเส้นทาง assistant-media ที่เป็นคู่กัน) เพื่อป้องกันไม่ให้เส้นทาง avatar รั่วไหลข้อมูลตัวตนของเอเจนต์บนโฮสต์ที่มีการป้องกันในส่วนอื่นอยู่แล้ว
- ตัว Control UI เองจะส่งต่อโทเค็น gateway เป็น bearer header เมื่อดึง avatars และใช้ blob URL ที่ยืนยันตัวตนแล้วเพื่อให้รูปภาพยังคงแสดงในแดชบอร์ดได้
หากคุณปิด gateway auth (ไม่แนะนำบนโฮสต์ที่ใช้ร่วมกัน) เส้นทาง avatar ก็จะกลายเป็นแบบไม่ต้องยืนยันตัวตนเช่นกัน สอดคล้องกับส่วนอื่นของ gateway
## การ build UI
Gateway ให้บริการไฟล์สแตติกจาก `dist/control-ui` สร้างไฟล์เหล่านี้ด้วย:
```bash
pnpm ui:build
```
base แบบ absolute ที่ไม่บังคับ (เมื่อต้องการ URL แอสเซ็ตแบบคงที่):
```bash
OPENCLAW_CONTROL_UI_BASE_PATH=/openclaw/ pnpm ui:build
```
สำหรับการพัฒนาในเครื่อง (dev server แยกต่างหาก):
```bash
pnpm ui:dev
```
จากนั้นชี้ UI ไปที่ URL ของ Gateway WS ของคุณ (เช่น `ws://127.0.0.1:18789`)
## การดีบัก/ทดสอบ: dev server + Gateway ระยะไกล
Control UI เป็นไฟล์สแตติก; เป้าหมาย WebSocket สามารถกำหนดค่าได้และอาจ
ต่างจากต้นทาง HTTP ก็ได้ สิ่งนี้มีประโยชน์เมื่อคุณต้องการใช้ Vite dev server
ในเครื่อง แต่ Gateway รันอยู่ที่อื่น
1. เริ่ม UI dev server: `pnpm ui:dev`
2. เปิด URL ลักษณะนี้:
```text
http://localhost:5173/?gatewayUrl=ws://<gateway-host>:18789
```
การยืนยันตัวตนแบบใช้ครั้งเดียวที่ไม่บังคับ (หากจำเป็น):
```text
http://localhost:5173/?gatewayUrl=wss://<gateway-host>:18789#token=<gateway-token>
```
หมายเหตุ:
- `gatewayUrl` จะถูกเก็บไว้ใน localStorage หลังโหลดเสร็จและถูกลบออกจาก URL
- ควรส่ง `token` ผ่าน URL fragment (`#token=...`) เมื่อเป็นไปได้ Fragments จะไม่ถูกส่งไปยังเซิร์ฟเวอร์ ซึ่งช่วยหลีกเลี่ยงการรั่วไหลใน request log และ Referer พารามิเตอร์ query แบบเดิม `?token=` ยังคงถูกนำเข้าได้หนึ่งครั้งเพื่อความเข้ากันได้ แต่ใช้เป็น fallback เท่านั้น และจะถูกลบทันทีหลัง bootstrap
- `password` จะถูกเก็บไว้ในหน่วยความจำเท่านั้น
- เมื่อมีการตั้งค่า `gatewayUrl` UI จะไม่ fallback ไปใช้ข้อมูลรับรองจาก config หรือ environment
ให้ระบุ `token` (หรือ `password`) อย่างชัดเจน การไม่มีข้อมูลรับรองที่ระบุชัดเจนถือเป็นข้อผิดพลาด
- ใช้ `wss://` เมื่อ Gateway อยู่หลัง TLS (Tailscale Serve, HTTPS proxy เป็นต้น)
- `gatewayUrl` จะยอมรับได้เฉพาะในหน้าต่างระดับบนสุดเท่านั้น (ไม่ใช่แบบฝัง) เพื่อป้องกัน clickjacking
- การ deploy Control UI ที่ไม่ใช่ loopback ต้องตั้งค่า `gateway.controlUi.allowedOrigins`
อย่างชัดเจน (เป็น origin แบบเต็ม) ซึ่งรวมถึงการตั้งค่า dev ระยะไกลด้วย
- อย่าใช้ `gateway.controlUi.allowedOrigins: ["*"]` ยกเว้นสำหรับการทดสอบภายในเครื่อง
ที่ควบคุมอย่างเข้มงวด เพราะมันหมายถึงอนุญาต browser origin ใดก็ได้ ไม่ใช่ “ให้ตรงกับโฮสต์ใดก็ตามที่ฉัน
ใช้อยู่”
- `gateway.controlUi.dangerouslyAllowHostHeaderOriginFallback=true` จะเปิดใช้
โหมด Host-header origin fallback แต่เป็นโหมดความปลอดภัยที่อันตราย
ตัวอย่าง:
```json5
{
gateway: {
controlUi: {
allowedOrigins: ["http://localhost:5173"],
},
},
}
```
รายละเอียดการตั้งค่าการเข้าถึงระยะไกล: [การเข้าถึงระยะไกล](/th/gateway/remote)
## ที่เกี่ยวข้อง
- [Dashboard](/th/web/dashboard) — แดชบอร์ดของ gateway
- [WebChat](/th/web/webchat) — อินเทอร์เฟซแชตบนเบราว์เซอร์
- [TUI](/th/web/tui) — อินเทอร์เฟซผู้ใช้แบบเทอร์มินัล
- [Health Checks](/th/gateway/health) — การตรวจสอบสถานะสุขภาพของ gateway

101
docs/th/web/dashboard.md Normal file
View File

@ -0,0 +1,101 @@
---
read_when:
- การเปลี่ยนโหมดการยืนยันตัวตนหรือการเปิดเผยการเข้าถึงของแดชบอร์ด
summary: การเข้าถึงและการยืนยันตัวตนของแดชบอร์ด Gateway (Control UI)
title: แดชบอร์ด
x-i18n:
generated_at: "2026-04-23T06:20:14Z"
model: gpt-5.4
provider: openai
source_hash: d5b50d711711f70c51d65f3908b7a8c1e0e978ed46a853f0ab48c13dfe0348ff
source_path: web/dashboard.md
workflow: 15
---
# แดชบอร์ด (Control UI)
แดชบอร์ด Gateway คือ Control UI บนเบราว์เซอร์ที่ให้บริการที่ `/` โดยค่าเริ่มต้น
(เปลี่ยนได้ด้วย `gateway.controlUi.basePath`)
เปิดอย่างรวดเร็ว (Gateway ในเครื่อง):
- [http://127.0.0.1:18789/](http://127.0.0.1:18789/) (หรือ [http://localhost:18789/](http://localhost:18789/))
ข้อมูลอ้างอิงสำคัญ:
- [Control UI](/th/web/control-ui) สำหรับการใช้งานและความสามารถของ UI
- [Tailscale](/th/gateway/tailscale) สำหรับระบบอัตโนมัติของ Serve/Funnel
- [พื้นผิวเว็บ](/th/web) สำหรับโหมด bind และหมายเหตุด้านความปลอดภัย
การยืนยันตัวตนถูกบังคับใช้ที่ขั้นตอน WebSocket handshake ผ่านเส้นทางการยืนยันตัวตน
ของ gateway ที่กำหนดค่าไว้:
- `connect.params.auth.token`
- `connect.params.auth.password`
- ส่วนหัวตัวตนของ Tailscale Serve เมื่อ `gateway.auth.allowTailscale: true`
- ส่วนหัวตัวตนของ trusted-proxy เมื่อ `gateway.auth.mode: "trusted-proxy"`
ดู `gateway.auth` ใน [การกำหนดค่า Gateway](/th/gateway/configuration)
หมายเหตุด้านความปลอดภัย: Control UI เป็น **พื้นผิวสำหรับผู้ดูแลระบบ** (แชต, config, การอนุมัติ exec)
อย่าเปิดให้เข้าถึงแบบสาธารณะ UI จะเก็บโทเค็น URL ของแดชบอร์ดไว้ใน sessionStorage
สำหรับเซสชันแท็บเบราว์เซอร์ปัจจุบันและ URL gateway ที่เลือก และจะลบโทเค็นเหล่านั้นออกจาก URL หลังโหลดเสร็จ
ควรใช้ localhost, Tailscale Serve หรือ SSH tunnel
## เส้นทางลัด (แนะนำ)
- หลังการตั้งค่าเริ่มต้น CLI จะเปิดแดชบอร์ดอัตโนมัติและพิมพ์ลิงก์แบบสะอาด (ไม่มีโทเค็น)
- เปิดอีกครั้งได้ทุกเมื่อ: `openclaw dashboard` (คัดลอกลิงก์, เปิดเบราว์เซอร์หากทำได้, แสดงคำแนะนำ SSH หากเป็นแบบ headless)
- หาก UI ขอการยืนยันตัวตนด้วย shared secret ให้วางโทเค็นหรือ
รหัสผ่านที่กำหนดค่าไว้ลงในการตั้งค่า Control UI
## พื้นฐานการยืนยันตัวตน (ในเครื่องเทียบกับระยะไกล)
- **Localhost**: เปิด `http://127.0.0.1:18789/`
- **แหล่งที่มาของโทเค็น shared secret**: `gateway.auth.token` (หรือ
`OPENCLAW_GATEWAY_TOKEN`); `openclaw dashboard` สามารถส่งผ่าน fragment ของ URL
สำหรับการบูตสแตรปครั้งเดียว และ Control UI จะเก็บไว้ใน sessionStorage สำหรับ
เซสชันแท็บเบราว์เซอร์ปัจจุบันและ URL gateway ที่เลือก แทน localStorage
- หาก `gateway.auth.token` ถูกจัดการด้วย SecretRef, `openclaw dashboard`
จะพิมพ์/คัดลอก/เปิด URL ที่ไม่มีโทเค็นตามการออกแบบ วิธีนี้ช่วยหลีกเลี่ยงการเปิดเผย
โทเค็นที่จัดการจากภายนอกในบันทึกเชลล์ ประวัติคลิปบอร์ด หรืออาร์กิวเมนต์
ที่ใช้เปิดเบราว์เซอร์
- หาก `gateway.auth.token` ถูกกำหนดค่าเป็น SecretRef และยัง resolve ไม่ได้ใน
เชลล์ปัจจุบันของคุณ `openclaw dashboard` ก็ยังจะพิมพ์ URL ที่ไม่มีโทเค็นพร้อม
คำแนะนำการตั้งค่าการยืนยันตัวตนที่นำไปใช้ได้จริง
- **รหัสผ่าน shared secret**: ใช้ `gateway.auth.password` ที่กำหนดค่าไว้ (หรือ
`OPENCLAW_GATEWAY_PASSWORD`) แดชบอร์ดจะไม่เก็บรหัสผ่านไว้ข้ามการรีโหลด
- **โหมดที่มีตัวตนกำกับ**: Tailscale Serve สามารถทำให้การยืนยันตัวตนของ Control UI/WebSocket ผ่านได้
ด้วยส่วนหัวตัวตนเมื่อ `gateway.auth.allowTailscale: true` และ reverse proxy
แบบรับรู้ตัวตนที่ไม่ใช่ loopback สามารถทำให้ผ่านได้ด้วย
`gateway.auth.mode: "trusted-proxy"` ในโหมดเหล่านั้น แดชบอร์ด
ไม่จำเป็นต้องวาง shared secret สำหรับ WebSocket
- **ไม่ใช่ localhost**: ใช้ Tailscale Serve, bind แบบ shared secret ที่ไม่ใช่ loopback,
reverse proxy แบบรับรู้ตัวตนที่ไม่ใช่ loopback พร้อม
`gateway.auth.mode: "trusted-proxy"` หรือ SSH tunnel ส่วน HTTP API ยังคงใช้
การยืนยันตัวตนแบบ shared secret เว้นแต่คุณจะตั้งใจใช้ private-ingress
`gateway.auth.mode: "none"` หรือการยืนยันตัวตน HTTP แบบ trusted-proxy ดู
[พื้นผิวเว็บ](/th/web)
<a id="if-you-see-unauthorized-1008"></a>
## หากคุณเห็น "unauthorized" / 1008
- ตรวจสอบให้แน่ใจว่าสามารถเข้าถึง gateway ได้ (ในเครื่อง: `openclaw status`; ระยะไกล: SSH tunnel `ssh -N -L 18789:127.0.0.1:18789 user@host` แล้วเปิด `http://127.0.0.1:18789/`)
- สำหรับ `AUTH_TOKEN_MISMATCH` ไคลเอนต์อาจลองใหม่แบบเชื่อถือได้หนึ่งครั้งด้วยโทเค็นอุปกรณ์ที่แคชไว้เมื่อ gateway ส่งคำแนะนำสำหรับการลองใหม่กลับมา การลองใหม่ด้วยโทเค็นที่แคชไว้นั้นจะใช้ขอบเขตที่อนุมัติไว้ในแคชของโทเค็นนั้นซ้ำ; ผู้เรียกที่ใช้ `deviceToken` แบบชัดเจน / `scopes` แบบชัดเจนจะคงชุดขอบเขตที่ร้องขอไว้ หากการยืนยันตัวตนยังล้มเหลวหลังจากลองใหม่นั้น ให้แก้ปัญหา token drift ด้วยตนเอง
- นอกเหนือจากเส้นทางการลองใหม่นั้น ลำดับความสำคัญของการยืนยันตัวตนสำหรับการเชื่อมต่อคือ shared token/password แบบชัดเจนก่อน จากนั้น `deviceToken` แบบชัดเจน จากนั้นโทเค็นอุปกรณ์ที่จัดเก็บไว้ แล้วค่อยเป็น bootstrap token
- บนเส้นทาง Control UI แบบ async ของ Tailscale Serve ความพยายามที่ล้มเหลวสำหรับ
`{scope, ip}` เดียวกันจะถูกทำให้เป็นลำดับก่อนที่ตัวจำกัดการยืนยันตัวตนล้มเหลวจะบันทึกไว้ ดังนั้น
การลองใหม่ที่ไม่ถูกต้องพร้อมกันครั้งที่สองอาจแสดง `retry later` ได้แล้ว
- สำหรับขั้นตอนการซ่อมแซม token drift ให้ทำตาม [รายการตรวจสอบการกู้คืน token drift](/th/cli/devices#token-drift-recovery-checklist)
- ดึงหรือระบุ shared secret จากโฮสต์ gateway:
- โทเค็น: `openclaw config get gateway.auth.token`
- รหัสผ่าน: resolve `gateway.auth.password` ที่กำหนดค่าไว้ หรือ
`OPENCLAW_GATEWAY_PASSWORD`
- โทเค็นที่จัดการด้วย SecretRef: resolve ผู้ให้บริการ secret ภายนอก หรือ export
`OPENCLAW_GATEWAY_TOKEN` ในเชลล์นี้ แล้วรัน `openclaw dashboard` ใหม่
- ไม่มีการกำหนดค่า shared secret: `openclaw doctor --generate-gateway-token`
- ในการตั้งค่าแดชบอร์ด ให้วางโทเค็นหรือรหัสผ่านลงในช่องการยืนยันตัวตน
จากนั้นเชื่อมต่อ
- ตัวเลือกภาษาของ UI อยู่ที่ **Overview -> Gateway Access -> Language**
เป็นส่วนหนึ่งของการ์ดการเข้าถึง ไม่ใช่ส่วน Appearance

133
docs/th/web/index.md Normal file
View File

@ -0,0 +1,133 @@
---
read_when:
- คุณต้องการเข้าถึง Gateway ผ่าน Tailscale
- คุณต้องการ Control UI บนเบราว์เซอร์และการแก้ไข config
summary: 'พื้นผิวเว็บของ Gateway: Control UI, โหมด bind และความปลอดภัย'
title: เว็บ
x-i18n:
generated_at: "2026-04-23T06:20:16Z"
model: gpt-5.4
provider: openai
source_hash: cf1a173143782557ecd2e79b28694308709dc945700a509148856255d5cef773
source_path: web/index.md
workflow: 15
---
# เว็บ (Gateway)
Gateway ให้บริการ **Control UI บนเบราว์เซอร์** ขนาดเล็ก (Vite + Lit) จากพอร์ตเดียวกันกับ Gateway WebSocket:
- ค่าเริ่มต้น: `http://<host>:18789/`
- คำนำหน้าแบบไม่บังคับ: ตั้งค่า `gateway.controlUi.basePath` (เช่น `/openclaw`)
ความสามารถต่าง ๆ อยู่ใน [Control UI](/th/web/control-ui)
หน้านี้เน้นที่โหมด bind, ความปลอดภัย และพื้นผิวที่เปิดออกสู่เว็บ
## Webhooks
เมื่อ `hooks.enabled=true` Gateway จะเปิดเผย endpoint ของ Webhook ขนาดเล็กบนเซิร์ฟเวอร์ HTTP เดียวกันด้วย
ดู [การกำหนดค่า Gateway](/th/gateway/configuration) → `hooks` สำหรับ auth + payloads
## Config (เปิดใช้โดยค่าเริ่มต้น)
Control UI จะ **เปิดใช้โดยค่าเริ่มต้น** เมื่อมี assets อยู่ (`dist/control-ui`)
คุณสามารถควบคุมได้ผ่าน config:
```json5
{
gateway: {
controlUi: { enabled: true, basePath: "/openclaw" }, // basePath เป็นตัวเลือก
},
}
```
## การเข้าถึงผ่าน Tailscale
### Serve แบบผสานรวม (แนะนำ)
ให้ Gateway อยู่บน loopback และให้ Tailscale Serve ทำหน้าที่ proxy:
```json5
{
gateway: {
bind: "loopback",
tailscale: { mode: "serve" },
},
}
```
จากนั้นเริ่ม gateway:
```bash
openclaw gateway
```
เปิด:
- `https://<magicdns>/` (หรือ `gateway.controlUi.basePath` ที่คุณตั้งค่าไว้)
### bind กับ tailnet + token
```json5
{
gateway: {
bind: "tailnet",
controlUi: { enabled: true },
auth: { mode: "token", token: "your-token" },
},
}
```
จากนั้นเริ่ม gateway (ตัวอย่างแบบ non-loopback นี้ใช้ token auth
แบบ shared-secret):
```bash
openclaw gateway
```
เปิด:
- `http://<tailscale-ip>:18789/` (หรือ `gateway.controlUi.basePath` ที่คุณตั้งค่าไว้)
### อินเทอร์เน็ตสาธารณะ (Funnel)
```json5
{
gateway: {
bind: "loopback",
tailscale: { mode: "funnel" },
auth: { mode: "password" }, // หรือ OPENCLAW_GATEWAY_PASSWORD
},
}
```
## หมายเหตุด้านความปลอดภัย
- โดยค่าเริ่มต้น จำเป็นต้องมี gateway auth (token, password, trusted-proxy หรือ headers ระบุตัวตนจาก Tailscale Serve เมื่อเปิดใช้งาน)
- bind แบบ non-loopback ยังคง **ต้องใช้** gateway auth ในทางปฏิบัติหมายถึง token/password auth หรือ reverse proxy ที่รับรู้ตัวตนพร้อม `gateway.auth.mode: "trusted-proxy"`
- wizard จะสร้าง auth แบบ shared-secret โดยค่าเริ่มต้น และมักจะสร้าง
gateway token ให้ด้วย (แม้จะเป็น loopback)
- ในโหมด shared-secret UI จะส่ง `connect.params.auth.token` หรือ
`connect.params.auth.password`
- ในโหมดที่มีข้อมูลระบุตัวตน เช่น Tailscale Serve หรือ `trusted-proxy` การตรวจสอบ auth
ของ WebSocket จะผ่านจาก request headers แทน
- สำหรับการปรับใช้ Control UI แบบ non-loopback ให้ตั้งค่า `gateway.controlUi.allowedOrigins`
อย่างชัดเจน (origin แบบเต็ม) หากไม่ตั้งค่า การเริ่มต้น gateway จะถูกปฏิเสธโดยค่าเริ่มต้น
- `gateway.controlUi.dangerouslyAllowHostHeaderOriginFallback=true` จะเปิดใช้
โหมด Host-header origin fallback แต่เป็นการลดระดับความปลอดภัยที่อันตราย
- เมื่อใช้ Serve, headers ระบุตัวตนของ Tailscale สามารถทำให้ Control UI/WebSocket
ผ่าน auth ได้เมื่อ `gateway.auth.allowTailscale` เป็น `true` (ไม่ต้องใช้ token/password)
ส่วน endpoints ของ HTTP API จะไม่ใช้ headers ระบุตัวตนของ Tailscale เหล่านั้น แต่จะทำตาม
โหมด HTTP auth ปกติของ gateway แทน ตั้งค่า
`gateway.auth.allowTailscale: false` หากต้องการบังคับใช้ credentials แบบชัดเจน ดู
[Tailscale](/th/gateway/tailscale) และ [ความปลอดภัย](/th/gateway/security)
โฟลว์แบบไม่ใช้ token นี้ตั้งอยู่บนสมมติฐานว่าโฮสต์ gateway เป็นโฮสต์ที่เชื่อถือได้
- `gateway.tailscale.mode: "funnel"` ต้องใช้ `gateway.auth.mode: "password"` (shared password)
## การ build UI
Gateway ให้บริการไฟล์สแตติกจาก `dist/control-ui` ให้ build ได้ด้วย:
```bash
pnpm ui:build
```

252
docs/th/web/tui.md Normal file
View File

@ -0,0 +1,252 @@
---
read_when:
- คุณต้องการคำแนะนำการใช้งาน TUI แบบเป็นมิตรกับผู้เริ่มต้น
- คุณต้องการรายการฟีเจอร์ คำสั่ง และคีย์ลัดทั้งหมดของ TUI อย่างครบถ้วน
summary: 'UI บนเทอร์มินัล (TUI): เชื่อมต่อกับ Gateway หรือรันในเครื่องในโหมดฝังตัว'
title: TUI
x-i18n:
generated_at: "2026-04-23T06:20:25Z"
model: gpt-5.4
provider: openai
source_hash: df3ddbe41cb7d92b9cde09a4d1443d26579b4e1cfc92dce6bbc37eed4d8af8fa
source_path: web/tui.md
workflow: 15
---
# TUI (UI บนเทอร์มินัล)
## เริ่มต้นอย่างรวดเร็ว
### โหมด Gateway
1. เริ่มต้น Gateway
```bash
openclaw gateway
```
2. เปิด TUI
```bash
openclaw tui
```
3. พิมพ์ข้อความแล้วกด Enter
Remote Gateway:
```bash
openclaw tui --url ws://<host>:<port> --token <gateway-token>
```
ใช้ `--password` หาก Gateway ของคุณใช้ password auth
### โหมดในเครื่อง
รัน TUI โดยไม่ใช้ Gateway:
```bash
openclaw chat
# or
openclaw tui --local
```
หมายเหตุ:
- `openclaw chat` และ `openclaw terminal` เป็นนามแฝงของ `openclaw tui --local`
- `--local` ไม่สามารถใช้ร่วมกับ `--url`, `--token` หรือ `--password`
- โหมดในเครื่องใช้รันไทม์ agent แบบฝังโดยตรง เครื่องมือในเครื่องส่วนใหญ่ใช้งานได้ แต่ฟีเจอร์ที่มีเฉพาะ Gateway จะไม่พร้อมใช้งาน
## สิ่งที่คุณจะเห็น
- ส่วนหัว: URL การเชื่อมต่อ, agent ปัจจุบัน, session ปัจจุบัน
- บันทึกแชต: ข้อความของผู้ใช้, คำตอบของผู้ช่วย, ประกาศของระบบ, การ์ดเครื่องมือ
- บรรทัดสถานะ: สถานะการเชื่อมต่อ/การรัน (connecting, running, streaming, idle, error)
- ส่วนท้าย: สถานะการเชื่อมต่อ + agent + session + model + think/fast/verbose/trace/reasoning + จำนวน token + deliver
- อินพุต: ตัวแก้ไขข้อความพร้อม autocomplete
## แนวคิดหลัก: agents + sessions
- Agents คือ slug ที่ไม่ซ้ำกัน (เช่น `main`, `research`) Gateway จะแสดงรายการเหล่านี้
- Sessions เป็นของ agent ปัจจุบัน
- คีย์ session จะถูกเก็บในรูปแบบ `agent:<agentId>:<sessionKey>`
- หากคุณพิมพ์ `/session main` TUI จะขยายเป็น `agent:<currentAgent>:main`
- หากคุณพิมพ์ `/session agent:other:main` คุณจะสลับไปยัง session ของ agent นั้นโดยตรง
- ขอบเขตของ session:
- `per-sender` (ค่าเริ่มต้น): แต่ละ agent มีได้หลาย session
- `global`: TUI จะใช้ session `global` เสมอ (ตัวเลือกอาจว่างเปล่า)
- agent + session ปัจจุบันจะแสดงอยู่เสมอในส่วนท้าย
## การส่ง + การส่งต่อ
- ข้อความจะถูกส่งไปยัง Gateway; การส่งต่อไปยัง providers ปิดอยู่โดยค่าเริ่มต้น
- เปิดการส่งต่อได้โดย:
- `/deliver on`
- หรือในแผง Settings
- หรือเริ่มด้วย `openclaw tui --deliver`
## ตัวเลือก + โอเวอร์เลย์
- ตัวเลือก Model: แสดงรายการ models ที่ใช้ได้และตั้งค่าการแทนที่สำหรับ session
- ตัวเลือก Agent: เลือก agent อื่น
- ตัวเลือก Session: แสดงเฉพาะ sessions สำหรับ agent ปัจจุบัน
- Settings: สลับการส่งต่อ การขยายเอาต์พุตเครื่องมือ และการแสดงผลความคิด
## คีย์ลัด
- Enter: ส่งข้อความ
- Esc: ยกเลิกการรันที่กำลังทำงานอยู่
- Ctrl+C: ล้างอินพุต (กดสองครั้งเพื่อออก)
- Ctrl+D: ออก
- Ctrl+L: ตัวเลือก model
- Ctrl+G: ตัวเลือก agent
- Ctrl+P: ตัวเลือก session
- Ctrl+O: สลับการขยายเอาต์พุตเครื่องมือ
- Ctrl+T: สลับการแสดงผลความคิด (จะโหลดประวัติใหม่)
## คำสั่งแบบสแลช
หลัก:
- `/help`
- `/status`
- `/agent <id>` (หรือ `/agents`)
- `/session <key>` (หรือ `/sessions`)
- `/model <provider/model>` (หรือ `/models`)
การควบคุม session:
- `/think <off|minimal|low|medium|high>`
- `/fast <status|on|off>`
- `/verbose <on|full|off>`
- `/trace <on|off>`
- `/reasoning <on|off|stream>`
- `/usage <off|tokens|full>`
- `/elevated <on|off|ask|full>` (นามแฝง: `/elev`)
- `/activation <mention|always>`
- `/deliver <on|off>`
วงจรชีวิตของ session:
- `/new` หรือ `/reset` (รีเซ็ต session)
- `/abort` (ยกเลิกการรันที่กำลังทำงานอยู่)
- `/settings`
- `/exit`
เฉพาะโหมดในเครื่อง:
- `/auth [provider]` เปิดขั้นตอน auth/login ของ provider ภายใน TUI
คำสั่งสแลชอื่น ๆ ของ Gateway (ตัวอย่างเช่น `/context`) จะถูกส่งต่อไปยัง Gateway และแสดงเป็นเอาต์พุตของระบบ ดู [Slash commands](/th/tools/slash-commands)
## คำสั่ง shell ภายในเครื่อง
- เติม `!` นำหน้าบรรทัดเพื่อรันคำสั่ง shell ภายในเครื่องบนโฮสต์ของ TUI
- TUI จะถามครั้งเดียวต่อ session เพื่ออนุญาตการรันในเครื่อง; หากปฏิเสธ `!` จะถูกปิดใช้งานสำหรับ session นั้น
- คำสั่งจะรันใน shell ใหม่แบบไม่โต้ตอบภายในไดเรกทอรีทำงานของ TUI (`cd`/env จะไม่คงอยู่ต่อเนื่อง)
- คำสั่ง shell ภายในเครื่องจะได้รับ `OPENCLAW_SHELL=tui-local` ใน environment
- `!` เพียงตัวเดียวจะถูกส่งเป็นข้อความปกติ; การเว้นวรรคด้านหน้าจะไม่ทริกเกอร์การรันในเครื่อง
## ซ่อมแซม configs จาก TUI ในเครื่อง
ใช้โหมดในเครื่องเมื่อ config ปัจจุบันผ่านการตรวจสอบอยู่แล้ว และคุณต้องการให้
agent แบบฝังตรวจสอบบนเครื่องเดียวกัน เปรียบเทียบกับเอกสาร
และช่วยซ่อมความคลาดเคลื่อนโดยไม่ต้องพึ่ง Gateway ที่กำลังรันอยู่
หาก `openclaw config validate` ล้มเหลวอยู่แล้ว ให้เริ่มด้วย `openclaw configure`
หรือ `openclaw doctor --fix` ก่อน `openclaw chat` จะไม่ข้ามตัวป้องกัน
config ไม่ถูกต้อง
ลูปการทำงานทั่วไป:
1. เริ่มโหมดในเครื่อง:
```bash
openclaw chat
```
2. ถาม agent ว่าคุณต้องการให้ตรวจสอบอะไร ตัวอย่างเช่น:
```text
Compare my gateway auth config with the docs and suggest the smallest fix.
```
3. ใช้คำสั่ง shell ภายในเครื่องเพื่อดูหลักฐานที่ชัดเจนและตรวจสอบความถูกต้อง:
```text
!openclaw config file
!openclaw docs gateway auth token secretref
!openclaw config validate
!openclaw doctor
```
4. ใช้ `openclaw config set` หรือ `openclaw configure` เพื่อเปลี่ยนแปลงแบบเจาะจง แล้วรัน `!openclaw config validate` อีกครั้ง
5. หาก Doctor แนะนำการย้ายหรือซ่อมแซมแบบอัตโนมัติ ให้ตรวจสอบก่อนแล้วรัน `!openclaw doctor --fix`
เคล็ดลับ:
- ควรใช้ `openclaw config set` หรือ `openclaw configure` แทนการแก้ไข `openclaw.json` ด้วยมือ
- `openclaw docs "<query>"` จะค้นหาดัชนีเอกสารสดจากเครื่องเดียวกัน
- `openclaw config validate --json` มีประโยชน์เมื่อคุณต้องการข้อผิดพลาดของ schema และ SecretRef/resolvability แบบมีโครงสร้าง
## เอาต์พุตเครื่องมือ
- การเรียกเครื่องมือจะแสดงเป็นการ์ดพร้อม args + results
- Ctrl+O ใช้สลับระหว่างมุมมองแบบย่อ/แบบขยาย
- ระหว่างที่เครื่องมือกำลังทำงาน การอัปเดตบางส่วนจะสตรีมเข้าไปในการ์ดใบเดิม
## สีของเทอร์มินัล
- TUI จะคงข้อความเนื้อหาของผู้ช่วยไว้ในสี foreground เริ่มต้นของเทอร์มินัล เพื่อให้ทั้งเทอร์มินัลธีมมืดและธีมสว่างยังอ่านได้ง่าย
- หากเทอร์มินัลของคุณใช้พื้นหลังสว่างและการตรวจจับอัตโนมัติผิดพลาด ให้ตั้งค่า `OPENCLAW_THEME=light` ก่อนเปิด `openclaw tui`
- หากต้องการบังคับใช้พาเลตต์มืดแบบเดิมแทน ให้ตั้งค่า `OPENCLAW_THEME=dark`
## ประวัติ + การสตรีม
- เมื่อเชื่อมต่อ TUI จะโหลดประวัติล่าสุด (ค่าเริ่มต้น 200 ข้อความ)
- คำตอบแบบสตรีมจะอัปเดตในตำแหน่งเดิมจนกว่าจะเสร็จสมบูรณ์
- TUI ยังฟัง agent tool events เพื่อแสดงการ์ดเครื่องมือที่สมบูรณ์ยิ่งขึ้น
## รายละเอียดการเชื่อมต่อ
- TUI ลงทะเบียนกับ Gateway เป็น `mode: "tui"`
- เมื่อเชื่อมต่อใหม่จะมีข้อความของระบบแสดงขึ้น; ช่องว่างของ event จะถูกแสดงในบันทึก
## ตัวเลือก
- `--local`: รันกับรันไทม์ agent แบบฝังในเครื่อง
- `--url <url>`: URL WebSocket ของ Gateway (ค่าเริ่มต้นมาจาก config หรือ `ws://127.0.0.1:<port>`)
- `--token <token>`: token ของ Gateway (หากจำเป็น)
- `--password <password>`: รหัสผ่านของ Gateway (หากจำเป็น)
- `--session <key>`: คีย์ session (ค่าเริ่มต้น: `main` หรือ `global` เมื่อขอบเขตเป็น global)
- `--deliver`: ส่งต่อคำตอบของผู้ช่วยไปยัง provider (ค่าเริ่มต้นปิดอยู่)
- `--thinking <level>`: แทนที่ระดับความคิดสำหรับการส่ง
- `--message <text>`: ส่งข้อความเริ่มต้นหลังจากเชื่อมต่อ
- `--timeout-ms <ms>`: timeout ของ agent หน่วยเป็นมิลลิวินาที (ค่าเริ่มต้นมาจาก `agents.defaults.timeoutSeconds`)
- `--history-limit <n>`: จำนวนรายการประวัติที่จะโหลด (ค่าเริ่มต้น `200`)
หมายเหตุ: เมื่อคุณตั้งค่า `--url` แล้ว TUI จะไม่ถอยกลับไปใช้ credentials จาก config หรือ environment
ให้ส่ง `--token` หรือ `--password` อย่างชัดเจน การไม่มี credentials แบบชัดเจนถือเป็นข้อผิดพลาด
ในโหมดในเครื่อง ห้ามส่ง `--url`, `--token` หรือ `--password`
## การแก้ปัญหา
ไม่มีเอาต์พุตหลังส่งข้อความ:
- รัน `/status` ใน TUI เพื่อยืนยันว่า Gateway เชื่อมต่ออยู่และอยู่ในสถานะ idle/busy
- ตรวจสอบบันทึกของ Gateway: `openclaw logs --follow`
- ยืนยันว่า agent สามารถรันได้: `openclaw status` และ `openclaw models status`
- หากคุณคาดว่าจะมีข้อความในช่องทางแชต ให้เปิดการส่งต่อ (`/deliver on` หรือ `--deliver`)
## การแก้ปัญหาการเชื่อมต่อ
- `disconnected`: ตรวจสอบให้แน่ใจว่า Gateway กำลังรันอยู่ และ `--url/--token/--password` ของคุณถูกต้อง
- ไม่มี agents ในตัวเลือก: ตรวจสอบ `openclaw agents list` และการกำหนดค่า routing ของคุณ
- ตัวเลือก session ว่างเปล่า: คุณอาจอยู่ในขอบเขต global หรือยังไม่มี sessions
## ที่เกี่ยวข้อง
- [Control UI](/th/web/control-ui) — อินเทอร์เฟซควบคุมแบบเว็บ
- [Config](/th/cli/config) — ตรวจสอบ ตรวจสอบความถูกต้อง และแก้ไข `openclaw.json`
- [Doctor](/th/cli/doctor) — การตรวจสอบการซ่อมแซมและการย้ายแบบมีคำแนะนำ
- [CLI Reference](/th/cli) — เอกสารอ้างอิงคำสั่ง CLI แบบเต็ม

84
docs/th/web/webchat.md Normal file
View File

@ -0,0 +1,84 @@
---
read_when:
- การดีบักหรือกำหนดค่าการเข้าถึง WebChat
summary: โฮสต์แบบสแตติกของ WebChat บน loopback และการใช้งาน Gateway WS สำหรับ UI แชต
title: WebChat
x-i18n:
generated_at: "2026-04-23T06:20:22Z"
model: gpt-5.4
provider: openai
source_hash: 2588be04e9ae38149bdf284bf4d75b6784d63899026d2351c4e0e7efdf05ff39
source_path: web/webchat.md
workflow: 15
---
# WebChat (UI ของ Gateway WebSocket)
สถานะ: UI แชต SwiftUI บน macOS/iOS สื่อสารกับ Gateway WebSocket โดยตรง
## คืออะไร
- UI แชตแบบ native สำหรับ gateway (ไม่มีเบราว์เซอร์ฝังตัวและไม่มีเซิร์ฟเวอร์สแตติกแบบ local)
- ใช้เซสชันและกฎการกำหนดเส้นทางเดียวกันกับช่องทางอื่น
- การกำหนดเส้นทางแบบกำหนดแน่นอน: การตอบกลับจะย้อนกลับไปที่ WebChat เสมอ
## เริ่มต้นอย่างรวดเร็ว
1. เริ่ม gateway
2. เปิด UI WebChat (แอป macOS/iOS) หรือแท็บแชตใน Control UI
3. ตรวจสอบให้แน่ใจว่าได้กำหนดค่าเส้นทางการยืนยันตัวตนของ gateway ที่ถูกต้องแล้ว (ค่าเริ่มต้นคือ shared-secret
แม้บน loopback)
## วิธีการทำงาน (พฤติกรรม)
- UI เชื่อมต่อกับ Gateway WebSocket และใช้ `chat.history`, `chat.send` และ `chat.inject`
- `chat.history` มีขอบเขตเพื่อความเสถียร: Gateway อาจตัดข้อความที่ยาวเกินไป ละเว้น metadata ที่มีขนาดใหญ่ และแทนที่รายการที่มีขนาดเกินด้วย `[chat.history omitted: message too large]`
- `chat.history` ยังถูกปรับให้เป็นมาตรฐานสำหรับการแสดงผลด้วย: แท็กคำสั่งการส่งแบบ inline
เช่น `[[reply_to_*]]` และ `[[audio_as_voice]]`, payload XML ของการเรียกเครื่องมือในข้อความล้วน
(รวมถึง `<tool_call>...</tool_call>`,
`<function_call>...</function_call>`, `<tool_calls>...</tool_calls>`,
`<function_calls>...</function_calls>`,
และบล็อกการเรียกเครื่องมือที่ถูกตัดทอน), รวมถึงโทเค็นควบคุมโมเดลแบบ ASCII/เต็มความกว้างที่รั่วออกมา จะถูกลบออกจากข้อความที่มองเห็นได้
และรายการของ assistant ที่ข้อความที่มองเห็นได้ทั้งหมดมีเพียง
โทเค็นเงียบที่ตรงกันเป๊ะ `NO_REPLY` / `no_reply` จะถูกละเว้น
- `chat.inject` จะต่อท้ายบันทึกของ assistant ลงใน transcript โดยตรงและกระจายไปยัง UI (ไม่มีการรัน agent)
- การรันที่ถูกยกเลิกอาจยังคงแสดงผลลัพธ์บางส่วนของ assistant ใน UI
- Gateway จะคงข้อความ assistant บางส่วนจากการยกเลิกลงในประวัติ transcript เมื่อมีเอาต์พุตที่บัฟเฟอร์ไว้ และทำเครื่องหมายรายการเหล่านั้นด้วย metadata ของการยกเลิก
- ประวัติจะถูกดึงจาก gateway เสมอ (ไม่มีการเฝ้าดูไฟล์แบบ local)
- หากไม่สามารถเข้าถึง gateway ได้ WebChat จะเป็นแบบอ่านอย่างเดียว
## แผงเครื่องมือ agents ใน Control UI
- แผง Tools ของ `/agents` ใน Control UI มี 2 มุมมองแยกกัน:
- **ใช้งานได้ในขณะนี้** ใช้ `tools.effective(sessionKey=...)` และแสดงสิ่งที่เซสชันปัจจุบัน
ใช้งานได้จริงขณะรัน รวมถึงเครื่องมือที่เป็นของ core, Plugin และช่องทาง
- **การกำหนดค่าเครื่องมือ** ใช้ `tools.catalog` และยังคงมุ่งเน้นไปที่โปรไฟล์ การแทนที่ และ
ความหมายของแคตตาล็อก
- ความพร้อมใช้งานขณะรันมีขอบเขตระดับเซสชัน การสลับเซสชันบน agent เดียวกันอาจเปลี่ยน
รายการ **ใช้งานได้ในขณะนี้**
- ตัวแก้ไข config ไม่ได้บอกเป็นนัยว่าพร้อมใช้งานขณะรัน; การเข้าถึงที่มีผลจริงยังคงเป็นไปตามลำดับความสำคัญของนโยบาย
(`allow`/`deny`, การแทนที่ต่อ agent และต่อ provider/channel)
## การใช้งานแบบ remote
- โหมด remote จะทำ tunnel ให้ Gateway WebSocket ผ่าน SSH/Tailscale
- คุณไม่จำเป็นต้องรันเซิร์ฟเวอร์ WebChat แยกต่างหาก
## เอกสารอ้างอิงการกำหนดค่า (WebChat)
การกำหนดค่าแบบเต็ม: [การกำหนดค่า](/th/gateway/configuration)
ตัวเลือกของ WebChat:
- `gateway.webchat.chatHistoryMaxChars`: จำนวนอักขระสูงสุดสำหรับฟิลด์ข้อความในการตอบกลับ `chat.history` เมื่อรายการ transcript เกินขีดจำกัดนี้ Gateway จะตัดข้อความที่ยาวเกินไป และอาจแทนที่ข้อความที่มีขนาดเกินด้วย placeholder โดยไคลเอนต์ยังสามารถส่ง `maxChars` ต่อคำขอเพื่อแทนที่ค่าเริ่มต้นนี้สำหรับการเรียก `chat.history` เพียงครั้งเดียวได้
ตัวเลือกระดับ global ที่เกี่ยวข้อง:
- `gateway.port`, `gateway.bind`: โฮสต์/พอร์ตของ WebSocket
- `gateway.auth.mode`, `gateway.auth.token`, `gateway.auth.password`:
การยืนยันตัวตน WebSocket แบบ shared-secret
- `gateway.auth.allowTailscale`: แท็บแชตของ Control UI บนเบราว์เซอร์สามารถใช้ส่วนหัว identity ของ Tailscale
Serve ได้เมื่อเปิดใช้งาน
- `gateway.auth.mode: "trusted-proxy"`: การยืนยันตัวตนผ่าน reverse-proxy สำหรับไคลเอนต์เบราว์เซอร์ที่อยู่หลังแหล่งพร็อกซี **ที่ไม่ใช่ loopback** ซึ่งรับรู้ตัวตน (ดู [การยืนยันตัวตน Trusted Proxy](/th/gateway/trusted-proxy-auth))
- `gateway.remote.url`, `gateway.remote.token`, `gateway.remote.password`: เป้าหมาย gateway แบบ remote
- `session.*`: ที่เก็บเซสชันและค่าเริ่มต้นของคีย์หลัก