PicoClaw Automation: Panduan untuk Mengintegrasikan CapSolver API

Ketika asisten AI Anda mengotomasi tugas web, CAPTCHA adalah penghalang utama. Halaman yang dilindungi menolak untuk mengirimkan, alur login macet, dan seluruh pipeline otomasi terhenti menunggu manusia untuk mengklik kotak centang atau mengidentifikasi lampu lalu lintas.

PicoClaw adalah asisten AI pribadi yang sangat ringkas yang ditulis dalam Go yang berjalan pada perangkat keras $10 dengan kurang dari 10MB RAM. Ia terhubung ke platform pesan yang sudah Anda gunakan, dan memiliki alat exec yang memungkinkan agen menulis dan menjalankan skrip secara mandiri.

CapSolver menyediakan API penyelesaian CAPTCHA yang didukung AI. Dengan menggabungkan kemampuan eksekusi skrip PicoClaw dengan API REST CapSolver, agen Anda dapat mendeteksi CAPTCHA, menyelesaikannya, menyisipkan token, dan mengirimkan formulir — tanpa campur tangan manusia.

Bagian terbaiknya? Anda hanya perlu memberi tahu agen apa yang ingin Anda lakukan dalam bahasa biasa. Ia menulis skrip Playwright, mengekstrak sitekey, memanggil CapSolver, menyisipkan token, dan mengirimkan formulir — semuanya secara mandiri. Dan karena PicoClaw adalah Go yang dikompilasi, seluruh lapisan orkestrasi muat dalam 10MB RAM pada papan RISC-V $10.

Apa itu PicoClaw?

PicoClaw adalah asisten AI pribadi yang sangat ringkas yang dibangun dalam Go 1.25.7 melalui proses self-bootstrapping yang luar biasa: agen AI itu sendiri menggerakkan migrasi arsitektur dari Python, menghasilkan 95% kode inti secara mandiri dengan penyesuaian oleh manusia.

Angka

Tagline PicoClaw menggambarkan semuanya: $10 Perangkat Keras. 10MB RAM. 1 Detik Boot.

Fitur Utama

• Sangat ringkas: Jejak memori di bawah 10MB — 99% lebih kecil dari agen TypeScript serupa
• Portabilitas nyata: Binary mandiri tunggal di berbagai arsitektur RISC-V, ARM64, dan x86_64
• Alat yang dibangun: Agen dapat membaca/menulis file, menjalankan perintah shell, mencari web, mengambil halaman, mengirim pesan lintas saluran, menjadwalkan tugas cron, dan bahkan berinteraksi dengan perangkat keras I2C/SPI
• Tidak bergantung penyedia: Bekerja dengan OpenAI, Anthropic, DeepSeek, Gemini, Qwen, Moonshot, Groq, vLLM, Ollama, Cerebras, Mistral, NVIDIA, dan penyedia gateway seperti OpenRouter
• Sistem keterampilan: Perluas kemampuan dengan file SKILL.md menggunakan frontmatter JSON atau YAML
• Sistem memori: Catatan harian dan memori jangka panjang yang tetap di sepanjang percakapan
• Alat perangkat keras: Alat I2C dan SPI untuk interaksi langsung dengan perangkat tersemat — unik untuk PicoClaw

ExecTool

ExecTool PicoClaw (didefinisikan dalam pkg/tools/shell.go) adalah yang membuat otomasi browser mungkin. Ini adalah lingkungan eksekusi shell yang dikarantina dengan 27+ pola penolakan keamanan yang dikompilasi sebagai regex Go, timeout default 60 detik, pembatasan jalur kerja, dan deteksi perjalanan jalur.

Ketika Anda meminta agen untuk berinteraksi dengan halaman web, ia:

1. Menulis skrip Playwright melalui alat write_file
2. Menjalankannya melalui alat exec (yang memanggil sh -c pada Linux)
3. Membaca hasil (stdout + stderr, dipotong hingga 10KB)
4. Melaporkan hasil kembali ke Anda melalui saluran chat

Metode guardCommand() alat ini memeriksa setiap perintah terhadap pola penolakan regex yang dikompilasi sebelum eksekusi, menerapkan pembatasan jalur kerja, dan mendeteksi upaya perjalanan jalur. Bayangkan akses baris perintah yang dikarantina — agen dapat menjalankan skrip Node.js dan instalasi paket lokal, tetapi tidak dapat rm -rf, sudo, atau docker run.

Loop Agen

Logika inti berada di pkg/tools/toolloop.go — siklus ketat: Panggilan LLM -> Ekstrak Pemanggilan Alat -> Jalankan Alat -> Tambahkan Hasil -> ulangi hingga respons teks akhir (atau MaxIterations, default 20). Siklus ini digunakan oleh agen utama (pkg/agent/loop.go) dan subagen latar belakang melalui spawn.

Apa itu CapSolver?

CapSolver adalah layanan penyelesaian CAPTCHA terkemuka yang menyediakan solusi berbasis AI untuk melewati berbagai tantangan CAPTCHA. Dengan dukungan untuk berbagai jenis CAPTCHA dan waktu respons cepat, CapSolver terintegrasi secara mulus ke dalam alur kerja otomatis.

Jenis CAPTCHA yang Didukung

• reCAPTCHA v2 (berbasis gambar & tidak terlihat)
• reCAPTCHA v3 & v3 Enterprise
• Cloudflare Turnstile
• Cloudflare 5-second Challenge
• AWS WAF CAPTCHA

Mengapa Pendekatan PicoClaw Berbeda

Kebanyakan integrasi penyelesaian CAPTCHA terbagi menjadi dua kamp: integrasi API tingkat kode di mana Anda menulis kelas layanan khusus, atau ekstensi browser di mana ekstensi Chrome menangani semuanya secara tidak terlihat. PicoClaw mengambil pendekatan ketiga: integrasi API yang didorong agen di perangkat edge.

Agen AI itu sendiri mengoordinasikan seluruh alur penyelesaian secara mandiri — menulis skrip Playwright, mengekstrak sitekey, memanggil API CapSolver, dan menyisipkan token solusi — semua melalui skrip yang ditulis dan dijalankan secara real-time. Dan secara kritis, pengoordinasi berbasis Go ini yang melakukan semua koordinasi mengonsumsi kurang dari 10MB RAM.

Keuntungan Perangkat Edge

Anda dapat menjalankan otomasi penyelesaian CAPTCHA pada perangkat keras yang harganya kurang dari secangkir kopi. Papan LicheeRV-Nano $9.90 yang menjalankan PicoClaw dapat menerima pesan Telegram, berkoordinasi dengan API cloud CapSolver, menyisipkan token, dan mengirimkan formulir — semua sambil menggunakan sebagian kecil dari 64MB RAM papan. Pekerjaan berat (pengenalan CAPTCHA) dilakukan di server CapSolver; PicoClaw hanya mengoordinasikan. Selalu aktif, 24/7, pada perangkat seukuran perangko.

Kesimpulan kunci: Binary Go PicoClaw begitu ringkas sehingga berjalan pada perangkat keras yang sebagian besar framework tidak bisa bahkan boot — namun dapat mengoordinasikan seluruh pipeline penyelesaian CAPTCHA melalui skrip Playwright dan API REST CapSolver.

Prasyarat

Catatan: Contoh di bawah ini diuji pada Ubuntu 22.04 / 24.04. Perintah menggunakan apt dan bash — sesuaikan untuk distro Anda jika diperlukan. Untuk perangkat edge (RISC-V, ARM), kompilasi silang PicoClaw di mesin build Anda atau unduh binary yang sudah jadi dari halaman rilis.

Sebelum mengatur integrasi, pastikan Anda memiliki:

1. Ubuntu 22.04+ (atau distro Linux apa pun — binary PicoClaw berjalan di mana saja)
2. Go 1.25.7+ terinstal (hanya diperlukan untuk membangun dari sumber)
3. PicoClaw terinstal dan berjalan (binary yang sudah jadi atau make build)
4. Akun CapSolver dengan kunci API (daftar di sini)
5. Node.js 18+ terinstal (untuk menjalankan skrip Playwright melalui alat exec)
6. Playwright terinstal di workspace Anda

Pemutaran Langkah demi Langkah

Langkah 1: Instal PicoClaw

Opsi A: Binary yang Sudah Jadi (Tercepat)

# Unduh rilis terbaru untuk platform Anda
# Ganti v0.1.1 dengan versi terbaru dari halaman Rilis
wget https://github.com/sipeed/picoclaw/releases/download/v0.1.1/picoclaw-linux-amd64
chmod +x picoclaw-linux-amd64
sudo mv picoclaw-linux-amd64 /usr/local/bin/picoclaw

# Jalankan wizard onboarding interaktif
picoclaw onboard

Opsi B: Bangun dari Sumber

git clone https://github.com/sipeed/picoclaw.git
cd picoclaw
make deps
make build
make install

# Inisialisasi konfigurasi dan workspace
picoclaw onboard

Ini menciptakan ~/.picoclaw/config.json, ~/.picoclaw/workspace/ (skrip, keterampilan, dan memori).

Langkah 2: Atur Kunci API CapSolver

Tambahkan kunci API CapSolver sebagai variabel lingkungan:

export CAPSOLVER_API_KEY="CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

Anda dapat mendapatkan kunci API Anda dari dashboard CapSolver.

Untuk konfigurasi yang tetap, tambahkan ke ~/.bashrc atau ~/.zshrc.

Langkah 3: Instal Alat Otomasi Browser

Instal Playwright dan dependensi sistemnya di Ubuntu:

# Instal dependensi browser Playwright (Ubuntu)
sudo apt install -y libnss3 libatk-bridge2.0-0 libdrm2 libxcomposite1 \
  libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libasound2t64

# Instal Playwright di workspace PicoClaw Anda
cd ~/.picoclaw/workspace
npm init -y
npm install playwright
npx playwright install chromium

Catatan perangkat edge: Pada papan yang terbatas sumber daya, Anda mungkin ingin menginstal Chromium di mesin yang lebih kuat dan mengarahkan PicoClaw ke browser jarak jauh melalui browserType.connect() Playwright. Agen PicoClaw sendiri hanya membutuhkan ~10MB RAM; browser adalah bagian beratnya.

Langkah 4: Konfigurasi ExecTool untuk Otomasi Browser

ExecTool PicoClaw memiliki pola penolakan bawaan untuk keamanan. Defaultnya bekerja dengan baik untuk otomasi CAPTCHA: node, npx, dan npm install lokal semuanya diizinkan. Hanya perintah berbahaya seperti npm install -g, sudo, docker run yang diblokir. Tidak ada perubahan konfigurasi yang diperlukan untuk alur kerja standar.

Langkah 5: Mulai Gateway

# Mulai layanan saluran (Telegram, Discord, dll.)
picoclaw gateway

# Atau untuk pengujian interaktif
picoclaw agent

Langkah 6: Verifikasi Pemutaran

Kirim pesan uji ke agen Anda melalui saluran yang terhubung:

Apa alat yang Anda miliki?

Agen harus mendaftar exec di antara alatnya — ini yang digunakannya untuk menjalankan skrip otomasi browser. Anda juga dapat memverifikasi akses Node.js:

Jalankan: node --version

Agen harus mengeksekusi ini melalui alat exec dan mengembalikan versi Node.js.

Keterampilan CapSolver yang Terbawa

PicoClaw menggunakan sistem keterampilan berbasis file SKILL.md dengan metadata frontmatter. Keterampilan dimuat dari tiga lokasi dalam urutan prioritas (didefinisikan di pkg/skills/loader.go):

1. Keterampilan workspace: ~/.picoclaw/workspace/skills/{name}/SKILL.md (tingkat proyek, prioritas tertinggi)
2. Keterampilan global: ~/.picoclaw/skills/{name}/SKILL.md (tingkat pengguna)
3. Keterampilan bawaan: skills/{name}/SKILL.md (dibundel bersama binary)

Keterampilan workspace menggantikan keterampilan global, yang menggantikan keterampilan bawaan. Loader membaca frontmatter sebagai JSON atau YAML dan membangun ringkasan XML untuk prompt sistem.

File Keterampilan (~/.picoclaw/workspace/skills/capsolver/SKILL.md)

---
name: capsolver
description: "Selesaikan CAPTCHA menggunakan API REST CapSolver dengan Playwright. Mendukung reCAPTCHA v2, reCAPTCHA v3, dan Cloudflare Turnstile. Gunakan ketika mengotomasi pengiriman formulir atau interaksi halaman yang menghadapi tantangan CAPTCHA."
metadata: {"picoclaw":{"emoji":"🔓","always":true,"requires":{"bins":["node"],"env":["CAPSOLVER_API_KEY"]}}}
---

# CapSolver

## PENTING: Eksekusi Wajib

Ketika pengguna meminta Anda menyelesaikan CAPTCHA, Anda HARUS segera memanggil alat. Jangan merespons dengan teks seperti "Jalankan..." atau "Saya akan memulai..." atau "Saya telah memulai otomasi...".

Tindakan pertama Anda harus salah satu dari:
1. Panggil `write_file` untuk menyimpan skrip Node.js, lalu panggil `exec` untuk menjalankannya
2. Panggil `spawn` dengan deskripsi tugas yang rinci untuk eksekusi latar belakang

Jika Anda merespons hanya dengan teks dan tidak ada pemanggilan alat, pengguna akan melihat tidak ada yang terjadi. Selalu eksekusi.

## Endpoint API

- **Buat tugas**: `POST https://api.capsolver.com/createTask`
- **Dapatkan hasil**: `POST https://api.capsolver.com/getTaskResult`

## Jenis Tugas

| CAPTCHA | Jenis Tugas | Lokasi Sitekey |
|---|---|---|
| reCAPTCHA v2 | `ReCaptchaV2TaskProxyLess` | atribut `data-sitekey` |
| reCAPTCHA v3 | `ReCaptchaV3TaskProxyLess` | panggilan `grecaptcha.execute` atau sumber halaman |
| Cloudflare Turnstile | `AntiTurnstileTaskProxyLess` | `data-sitekey` pada div Turnstile |

Variasi Enterprise: `ReCaptchaV2EnterpriseTaskProxyLess`, `ReCaptchaV3EnterpriseTaskProxyLess`.

## Alur Kerja

1. Navigasi ke halaman dengan Playwright (Chromium headless)
2. Ekstrak sitekey dari DOM (`[data-sitekey]` attribute)
3. Panggil `createTask` dengan sitekey dan URL halaman
4. Poll `getTaskResult` setiap 2 detik hingga `status: "ready"`
5. Sisipkan token ke halaman (bidang formulir tersembunyi)
6. Kirim formulir

## Pola Kode Inti

```javascript
const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY;

// Langkah 1: Buat tugas
const createRes = await fetch('https://api.capsolver.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',  // atau ReCaptchaV3TaskProxyLess, AntiTurnstileTaskProxyLess
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  })
});
const { taskId } = await createRes.json();

// Langkah 2: Poll hasil
let token;
while (true) {
  await new Promise(r => setTimeout(r, 2000));
  const res = await fetch('https://api.capsolver.com/getTaskResult', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ clientKey: CAPSOLVER_API_KEY, taskId })
  });
  const result = await res.json();
  if (result.status === 'ready') { token = result.solution.gRecaptchaResponse || result.solution.token; break; }
  if (result.status === 'failed') throw new Error('Penyelesaian gagal');
}

// Langkah 3: Sisipkan token (reCAPTCHA)
await page.evaluate((t) => {
  document.querySelectorAll('textarea[name="g-recaptcha-response"]')
    .forEach(el => { el.value = t; el.innerHTML = t; });
}, token);
```

Untuk Turnstile, bidang token biasanya `input[name="cf-turnstile-response"]` dan solusinya ada di `result.solution.token`.

## Referensi API

Semua jenis tugas membutuhkan `type`, `websiteURL`, `websiteKey`. Bidang opsional bervariasi berdasarkan jenis:
- **reCAPTCHA v2**: `isInvisible`, `pageAction`, `enterprisePayload`, `apiDomain`
- **reCAPTCHA v3**: `pageAction` (dari `grecaptcha.execute(key, {action: "..."})`)
- **Cloudflare Turnstile**: `metadata.action`, `metadata.cdata`

Poin penting:

• Frontmatter menggunakan JSON atau YAML (pkg/skills/loader.go mencoba JSON terlebih dahulu, lalu YAML)
• metadata berisi konfigurasi khusus PicoClaw: emoji untuk tampilan, always untuk memuat otomatis, requires untuk pemeriksaan ketergantungan
• SkillsLoader.BuildSkillsSummary() menghasilkan ringkasan XML yang disisipkan ke dalam prompt sistem
• Bagian "Execution Required" memaksa pemanggilan alat alih-alih respons teks saja

Setelah membuat skill, periksa dengan picoclaw skills — Anda seharusnya melihat capsolver terdaftar.

Cara Kerjanya

Ketika Anda meminta PicoClaw untuk berinteraksi dengan halaman yang dilindungi CAPTCHA, berikut alur lengkap dari pesan ke hasil:

  Pesan Anda                     Agent PicoClaw (Go, ~10MB RAM)
  ─────────────────────────────────────────────────────────────
  "Pergi ke halaman itu,           ──► Agent menerima melalui MessageBus
   isi formulir,                  │ (pkg/bus/bus.go)
   selesaikan CAPTCHA,            ▼
   dan kirimkan"             ContextBuilder menyisipkan skill
                                   │ (pkg/agent/context.go)
                                   ▼
                              RunToolLoop dimulai
                                   │ (pkg/tools/toolloop.go)
                                   ▼
                              Agent menulis skrip Node.js
                                   │ melalui tool write_file
                                   ▼
                              ExecTool menjalankan skrip
                              ┌────────────────────────────┐
                              │ pkg/tools/shell.go          │
                              │ guardCommand() → 27+ pengecekan │
                              │ sh -c "node script.js"      │
                              │                             │
                              │  Chromium tanpa antarmuka grafis │
                              │  1. Navigasi ke halaman      │
                              │  2. Ekstrak sitekey         │
                              │  3. POST /createTask ────────── API CapSolver
                              │  4. Poll /getTaskResult ─────── (awan)
                              │  5. Sisipkan token          │
                              │  6. Kirim formulir          │
                              │  7. Screenshot              │
                              └────────────────────────────┘
                                   │
                                   ▼ stdout dikembalikan (maks 10KB)
                              Agent membaca output
                                   │
                                   ▼
                              "Form dikirimkan dengan sukses!
                               Verifikasi Berhasil!"

Alur API CapSolver

Integrasi intinya terdiri dari dua panggilan API:

1. Membuat tugas — Kirim sitekey CAPTCHA dan URL halaman ke CapSolver:

const response = await fetch('https://api.capsolver.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  })
});

2. Memantau hasil — Periksa setiap 2 detik hingga CapSolver mengembalikan token yang terselesaikan:

const result = await fetch('https://api.capsolver.com/getTaskResult', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    taskId: taskId
  })
});
// result.solution.gRecaptchaResponse berisi token

3. Menyisipkan token — Atur token di bidang formulir tersembunyi yang diharapkan reCAPTCHA:

await page.evaluate((token) => {
  const textarea = document.querySelector('textarea[name="g-recaptcha-response"]');
  if (textarea) {
    textarea.value = token;
    textarea.innerHTML = token;
  }
}, captchaToken);

Contoh Kerja Lengkap

Berikut skrip Node.js sebenarnya yang dihasilkan oleh agen PicoClaw dan dijalankan untuk menyelesaikan reCAPTCHA di halaman demo Google. Agen menulisnya melalui write_file, lalu menjalankannya dengan exec — semuanya secara otomatis dari satu pesan Telegram:

const { chromium } = require('playwright');
const https = require('https');

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY;
const PAGE_URL = '';

function httpsPost(url, data) {
  return new Promise((resolve, reject) => {
    const req = https.request(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' }
    }, (res) => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => resolve(JSON.parse(body)));
    });
    req.on('error', reject);
    req.write(JSON.stringify(data));
    req.end();
  });
}

async function solveRecaptcha(siteKey, pageUrl) {
  console.log('Membuat tugas CapSolver...');

  const createRes = await httpsPost('https://api.capsolver.com/createTask', {
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  });

  if (createRes.errorId) {
    throw new Error(`Kesalahan CapSolver: ${createRes.errorDescription}`);
  }

  const { taskId } = createRes;
  console.log(`ID Tugas: ${taskId}`);

  let token;
  while (true) {
    await new Promise(r => setTimeout(r, 2000));

    const res = await httpsPost('https://api.capsolver.com/getTaskResult', {
      clientKey: CAPSOLVER_API_KEY,
      taskId
    });

    if (res.status === 'ready') {
      token = res.solution.gRecaptchaResponse;
      console.log(`Token diterima! Panjang: ${token.length}`);
      break;
    }
    if (res.status === 'failed') {
      throw new Error(`Tugas CapSolver gagal: ${res.errorDescription}`);
    }

    console.log('Memantau... status:', res.status);
  }

  if (!token) throw new Error('Gagal mendapatkan token');
  return token;
}

async function main() {
  const browser = await chromium.launch({
    headless: true,
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  });
  const page = await browser.newPage();

  try {
    await page.goto(PAGE_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });
    const siteKey = await page.locator('[data-sitekey]').getAttribute('data-sitekey');
    console.log(`Sitekey: ${siteKey}`);

    const token = await solveRecaptcha(siteKey, PAGE_URL);

    await page.evaluate((t) => {
      document.querySelectorAll('textarea[name="g-recaptcha-response"]')
        .forEach(el => { el.value = t; el.innerHTML = t; });
    }, token);

    await page.locator('input[type="submit"]').click();
    await page.waitForTimeout(3000);

    const body = await page.textContent('body');
    console.log(body.includes('Success') ? 'SUCCES!' : 'Hasil:', body.slice(0, 200));
    await page.screenshot({ path: 'recaptcha_result.png' });
  } finally {
    await browser.close();
  }
}

main().catch(err => {
  console.error('Error:', err.message);
  process.exit(1);
});

Jalankan langsung:

CAPSOLVER_API_KEY=CAP-XXX node solve_recaptcha.js

Atau biarkan agen PicoClaw menangani semuanya — cukup kirim pesan di Telegram:

Selesaikan reCAPTCHA di https://example.com dan kirim formulir.

Agen membaca skill capsolver, menulis skrip, menjalankannya via exec, membaca output, dan melaporkannya kembali.

Cara Menggunakannya

Setelah setup selesai, menggunakan CapSolver dengan PicoClaw se sederhana mengirim pesan di saluran mana pun yang terhubung.

Contoh 1: Selesaikan Demo reCAPTCHA

Kirim pesan ini ke agen Anda via Telegram, Discord, WhatsApp, atau saluran terhubung lainnya:

Pergi ke https://example.com dan selesaikan reCAPTCHA menggunakan API CapSolver, lalu kirim formulir dan beri tahu saya apakah berhasil.

Apa yang terjadi: Agen membaca skill capsolver, menulis skrip Playwright, menjalankannya via exec (yang melewati pengecekan guardCommand() dan dijalankan dalam batas waktu 60 detik), dan skrip mengakses halaman, mengekstrak sitekey, memanggil CapSolver, menyisipkan token, dan mengirim. Hasil kembali ke Anda melalui MessageBus.

Contoh 2: Masuk ke Situs yang Dilindungi

Pergi ke https://example.com/login, isi email dengan
"[email protected]" dan kata sandi dengan "mypassword", deteksi dan
selesaikan CAPTCHA di halaman, lalu klik Masuk dan beri tahu saya
apa yang terjadi.

Contoh 3: Kirim Form Kontak

Buka https://example.com/contact, isi bidang nama, email, dan
pesan, selesaikan CAPTCHA, kirim formulir, dan beri tahu saya
pesan konfirmasi.

Contoh 4: Otomasi Latar Belakang via Spawn

Untuk tugas yang berjalan lama, gunakan alat spawn (pkg/tools/spawn.go) untuk delegasi ke subagen latar belakang:

Di latar belakang, pergi ke https://example.com/register, buat
akun dengan detail saya, selesaikan CAPTCHA yang Anda temui,
dan beri tahu saya ketika selesai.

Contoh 5: Pemantauan Perangkat Edge (Telegram di Papan $10)

Jika PicoClaw berjalan di perangkat edge seperti LicheeRV-Nano, gabungkan dengan alat cron:

Setiap jam, periksa https://example.com/status — jika ada
penghalang CAPTCHA, selesaikan dan laporkan konten halaman status.

Mengapa Ini Bekerja

Agen PicoClaw memiliki semua alat yang diperlukan untuk menyelesaikan CAPTCHA secara otomatis:

• exec (pkg/tools/shell.go) — eksekusi shell yang dijaga keamanannya dengan 27+ pola penolakan
• write_file / read_file (pkg/tools/filesystem.go) — manajemen skrip di workspace
• spawn (pkg/tools/spawn.go) — delegasi subagen latar belakang untuk tugas lama
• web_fetch (pkg/tools/web.go) — pengambilan konten halaman untuk analisis DOM
• Sistem skill (pkg/skills/loader.go) — skill capsolver menyediakan dokumen API dalam konteks
• Memori (pkg/agent/memory.go) — menyimpan pendekatan sukses di sesi berikutnya

Hasil Kinerja

Kami menguji integrasi ini di halaman demo reCAPTCHA v2 Google melalui bot Discord langsung di Ubuntu 24.04. Agen PicoClaw (menggunakan glm-4.7 via z.ai) menerima pesan Discord, menulis skrip Playwright secara otomatis, menyelesaikan CAPTCHA, dan melaporkan kembali — tanpa intervensi manusia:

Catatan perangkat edge: Pada papan dengan RAM terbatas (misalnya, LicheeRV-Nano $9,90 dengan 64MB), PicoClaw sendiri mudah masuk (~8MB), tetapi Chromium membutuhkan 100-300MB. Gunakan connect() Playwright untuk memindahkan browser ke mesin yang lebih mampu sementara menjaga agen PicoClaw yang ringkas di perangkat edge.

Pemecahan Masalah

"Tidak dapat menemukan modul 'playwright'"

Playwright tidak terinstal di workspace. Jalankan:

cd ~/.picoclaw/workspace && npm install playwright && npx playwright install chromium

Kekurangan perpustakaan browser di Ubuntu

Jika Chromium gagal berjalan dengan pesan tentang perpustakaan bersama yang hilang, instal dependensi sistem:

sudo apt install -y libnss3 libatk-bridge2.0-0 libdrm2 libxcomposite1 \
  libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libasound2t64

Pola penolakan ExecTool menghalangi npm install

PicoClaw's deny patterns menolak npm install -g (instal global), sudo, dan apt install, tetapi mengizinkan instal lokal npm install, node script.js, dan npx playwright install. Jika Anda melihat "Perintah diblokir oleh pengaman", Anda bisa menonaktifkan deny patterns atau menyediakan daftar izin khusus di ~/.picoclaw/config.json:

{ "tools": { "exec": { "enable_deny_patterns": false } } }

Atau gunakan daftar izin khusus yang hanya menolak pola yang ingin Anda blokir.

Waktu habis menyelesaikan CAPTCHA

• Periksa apakah kunci API CapSolver valid
• Periksa saldo akun CapSolver Anda di capsolver.com/dashboard
• Skrip memantau setiap 2 detik hingga CapSolver mengembalikan ready atau failed
• Jika waktu 60 detik dari alat exec terlalu pendek, skrip akan dihentikan. Anda bisa meningkatkannya secara programatik atau menggunakan alat spawn untuk tugas yang lebih lama (subagent memiliki timeout sendiri)

Waktu 60 detik dari ExecTool terlalu pendek

Waktu default di pkg/tools/shell.go adalah 60 detik. Untuk otomasi CAPTCHA, ini bisa ketat. Gunakan alat spawn untuk tugas yang lebih lama (subagent berjalan mandiri), atau ubah waktu timeout di NewExecToolWithConfig() di sumber (timeout: 120 * time.Second).

Sitekey tidak ditemukan

Skrip mengekstrak sitekey dari atribut data-sitekey. Jika tidak ada elemen ditemukan, agen bisa menyesuaikan dan mengekstraknya dari URL iframe atau sumber halaman.

Browser crash di Docker/kontainer

Tambahkan --no-sandbox, --disable-setuid-sandbox, dan --disable-dev-shm-usage ke argumen launch Playwright.

Agen tidak menggunakan CapSolver

Pastikan: (1) variabel lingkungan CAPSOLVER_API_KEY diatur sebelum memulai PicoClaw, (2) file skill ada di ~/.picoclaw/workspace/skills/capsolver/SKILL.md, (3) picoclaw skills menunjukkan daftar itu.

Praktik Terbaik

1. Atur Kunci API sebagai Variabel Lingkungan

Jangan kode kunci secara langsung di skrip. Gunakan process.env.CAPSOLVER_API_KEY sehingga agen bisa mengambilnya secara otomatis. PicoClaw meneruskan lingkungan proses induk ke semua invokasi alat exec.

2. Gunakan Mode Tanpa Antarmuka Grafis di Server

Pendekatan API-based PicoClaw berjalan di lingkungan tanpa antarmuka grafis — tidak perlu Xvfb atau layar virtual. Ini merupakan keuntungan signifikan dibanding pendekatan berbasis ekstensi, terutama di perangkat edge di mana perangkat keras layar tidak ada.

3. Pantau Saldo CapSolver Anda

Setiap penyelesaian CAPTCHA memakan kredit. Periksa saldonya secara berkala di capsolver.com/dashboard.

4. Perbarui Playwright Secara Berkala

Penyedia CAPTCHA berkembang. Perbarui Playwright dan Chromium:

cd ~/.picoclaw/workspace && npm update playwright && npx playwright install chromium

5. Gunakan Alat Spawn untuk Tugas yang Berjalan Lama

Otomasi browser bisa memakan 30-60 detik. Gunakan spawn alih-alih mengandalkan loop utama agen untuk menghindari timeout dan menjaga agen utama responsif terhadap pesan lain.

6. Manfaatkan Sistem Memori PicoClaw

Setelah penyelesaian CAPTCHA yang sukses, agen menyimpan pendekatan ke ~/.picoclaw/workspace/memory/MEMORY.md. Kali berikutnya, ia mengingat pola yang berhasil.

7. Penyebaran Perangkat Edge: Pindahkan Browser ke Mesin Lain

Pada papan $10 dengan RAM terbatas, koneksi ke instansi Chromium jarak jauh melalui chromium.connect('ws://server:9222'). Ini menjaga jejak PicoClaw sekitar 8MB di edge sementara browser berjalan di tempat lain.

8. Konfigurasi Batasan Workspace dengan Cermat

Pengaturan restrict_to_workspace PicoClaw membatasi operasi file dan exec hanya pada direktori workspace. Pastikan skrip dan instalasi Playwright Anda berada dalam ~/.picoclaw/workspace/.

Kesimpulan

Integrasi PicoClaw + CapSolver mewakili pendekatan yang secara fundamental berbeda dalam menyelesaikan CAPTCHA. Daripada ekstensi browser berat di mesin desktop, agen yang dikompilasi dalam Go berjalan di perangkat $10 mengkoordinasi seluruh alur penyelesaian:

1. Navigasi ke halaman target dengan Playwright
2. Ekstrak sitekey dari atribut data-sitekey
3. Selesaikan dengan memanggil API REST CapSolver secara langsung
4. Injeksikan token solusi ke bidang formulir tersembunyi
5. Kirimkan formulir dan verifikasi keberhasilan

Ini memberi Anda:

• Tidak ada ketergantungan ekstensi Chrome — berjalan dengan browser headless apa pun
• Dukungan server headless — tidak memerlukan tampilan atau Xvfb
• Kontrol dalam bahasa alami — cukup beri tahu agen apa yang ingin Anda lakukan melalui Telegram, Discord, atau saluran lainnya
• Penggunaan perangkat edge — berjalan 24/7 pada papan RISC-V $10 dengan RAM di bawah 10MB
• Keamanan bawaan — 27+ pola penolakan di ExecTool mencegah perintah berbahaya

Bonus: Skrip Mulai Cepat

Simpan contoh kerja lengkap dari atas ke ~/.picoclaw/workspace/solve_captcha.js dan jalankan:

CAPSOLVER_API_KEY=CAP-XXX node ~/.picoclaw/workspace/solve_captcha.js

Atau cukup kirim pesan Telegram ke agen PicoClaw Anda dan biarkan ia menangani semuanya secara otomatis.

Siap memulai? Daftar ke CapSolver dan gunakan kode bonus PICOCLAW untuk bonus tambahan 6% pada recharge pertama Anda!

FAQ

Bagaimana PicoClaw menyelesaikan CAPTCHA berbeda dari ekstensi browser?

PicoClaw menggunakan API REST CapSolver secara langsung. Agen menulis dan menjalankan skrip Node.js/Playwright yang memanggil createTask dan getTaskResult untuk mendapatkan token solusi, lalu menyisipkannya ke DOM halaman. Tidak diperlukan ekstensi browser. Seluruh koordinasi terjadi melalui ExecTool PicoClaw (pkg/tools/shell.go), yang menjalankan sh -c "node script.js" dengan 27+ pola penolakan keamanan, pembatasan jalur workspace, dan timeout yang dapat dikonfigurasi.

Apakah saya memerlukan versi Chrome khusus?

Tidak. Berbeda dengan pendekatan berbasis ekstensi yang memerlukan Chrome for Testing (karena Chrome berbranding 137+ melarang pemuatan ekstensi), PicoClaw berjalan dengan setiap build Chromium — termasuk Chromium yang dikemas oleh Playwright, paket Chromium standar, atau Chrome headless. Ini terutama penting pada perangkat edge di mana Anda mungkin hanya memiliki akses ke Chromium yang dikemas oleh distro.

Apakah PicoClaw benar-benar bisa berjalan di papan $10?

Ya. PicoClaw menggunakan RAM di bawah 10MB dan boot dalam waktu kurang dari 1 detik pada inti 0,6GHz. Ia mendukung RISC-V, ARM64, dan x86_64. API cloud CapSolver menangani pekerjaan berat; PicoClaw hanya mengkoordinasikannya. Catatan: Chromium membutuhkan 100-300MB RAM, jadi papan di bawah 256MB harus terhubung ke browser jarak jauh.

Tipe CAPTCHA apa yang didukung oleh CapSolver?

CapSolver mendukung reCAPTCHA v2 (checkbox dan tidak terlihat), reCAPTCHA v3, reCAPTCHA Enterprise, Cloudflare Turnstile, AWS WAF CAPTCHA, dan lainnya. Integrasi PicoClaw menggunakan ReCaptchaV2TaskProxyLess dalam contoh, tetapi file keterampilan mencatat semua jenis tugas. Agen dapat menyesuaikan dengan setiap tipe CAPTCHA yang didukung dengan mengubah parameter jenis tugas.

Bisakah saya menggunakan ini pada server headless?

Ya — dan ini adalah tempat pendekatan PicoClaw bersinar. Karena tidak ada ekstensi browser yang terlibat, Anda tidak perlu Xvfb atau tampilan virtual. Playwright berjalan dalam mode headless penuh secara default. Dengan jejak yang kecil, ini membuatnya ideal untuk penggunaan server yang selalu aktif.

Berapa biaya CapSolver?

CapSolver menawarkan harga kompetitif berdasarkan tipe CAPTCHA dan volume. Kunjungi capsolver.com untuk harga terkini. Gunakan kode bonus PICOCLAW untuk bonus tambahan 6% pada recharge pertama Anda.

Apakah PicoClaw gratis?

PicoClaw open-source (lisensi MIT) dan gratis untuk dijalankan pada perangkat keras Anda sendiri. Anda memerlukan kunci API dari penyedia model AI pilihan Anda, dan untuk menyelesaikan CAPTCHA, akun CapSolver dengan kredit. Binary PicoClaw sendiri tidak memiliki biaya operasional.

Berapa lama waktu penyelesaian CAPTCHA?

Dalam pengujian bot Discord dengan reCAPTCHA v2, skrip Playwright agen (termasuk polling API CapSolver) berjalan dalam 24,2 detik. Waktu end-to-end keseluruhan dari pesan Discord hingga respons adalah ~30 detik, termasuk 5 iterasi LLM untuk generasi skrip, eksekusi, dan verifikasi visual.

Apakah pola penolakan PicoClaw akan memblokir skrip otomatisasi saya?

Tidak. Pola penolakan di pkg/tools/shell.go memblokir perintah sistem berbahaya (rm -rf, sudo, docker run), bukan eksekusi Node.js biasa. Menjalankan node script.js dan npm install lokal sepenuhnya diizinkan. Hanya instalasi global (npm install -g) dan perintah manajemen paket yang diblokir.

Bisakah saya menjalankan penyelesaian CAPTCHA secara paralel?

Ya. Gunakan alat spawn PicoClaw untuk membuat subagent di latar belakang yang berbeda, masing-masing menangani tugas CAPTCHA yang berbeda. SubagentManager (pkg/tools/subagent.go) menjalankan masing-masing secara independen dan melaporkan hasil kembali melalui MessageBus.

Bagaimana PicoClaw dibandingkan Nanobot untuk penyelesaian CAPTCHA?

PicoClaw terinspirasi oleh Nanobot (Python), ditulis ulang dalam Go untuk efisiensi ekstrem. Keduanya menggunakan penyelesaian CAPTCHA berbasis agen — perbedaan utama adalah sumber daya. Nanobot memerlukan RAM 100MB+ dan Python; PicoClaw memerlukan di bawah 10MB dan dikemas sebagai satu binary. Untuk perangkat edge, PicoClaw adalah pilihan yang jelas.