Agents d’automatisation de navigateur sans restrictions avec Node.js
Fournir à un agent de navigation un ensemble d’outils aux limites bien définies, des mécanismes de sécurité et un système d’enregistrement fonctionnel.
Ce guide reconstruit une méthode opérationnelle pour : savoir comment créer un agent d’IA d’automatisation de navigateur sans restrictions à l’aide de Node.js, Playwright, Bright Data et Gemini. L’accent est mis sur les contrats, les vérifications et le code que l’on peut intégrer dans un dépôt sans devoir deviner l’intention derrière lui. Pour une vue d’ensemble, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans avoir à deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse.
Introduction
Pour l’introduction, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Restreignez strictement les schémas des outils ; des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.
await page.goto(url)
await page.click(selector)
await page.type(selector, text)
Ce que nous construisons
Pour ce que nous construisons, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux.
Prérequis
En tant que prérequis, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux. En tant que prérequis, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses.
Construction du projet Sikki
Pour le projet Building Sikki, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Créez un point de contrôle après des appels de modèles coûteux afin qu’un nouvel essai ne fasse pas payer à nouveau le même travail.
Étape 1 : Créer le projet
Pour l’Étape 1 : Créer le projet, définir les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conserver la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Créer un point de contrôle après des appels coûteux au modèle afin qu’un nouvel essai ne fasse pas payer à nouveau pour le même travail.
mkdir sikki-agent
cd sikki-agent
npm init -y
npm pkg set type=module
npm install playwright
npm install @google/genai
npm install dotenv
npm install chalk
npm install ora
sikki-agent
index.js
.env
screenshots/
reports/
package.json
Étape 2 : Obtenir la clé API Gemini
Pour l’Étape 2 : Obtenir la clé API Gemini, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réexécution, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une amélioration ultérieure. Créez un point de contrôle après chaque appel coûteux au modèle afin qu’une tentative de réexécution ne facture pas à nouveau le même travail. Pour l’Étape 2 : Obtenir la clé API Gemini, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les terminations partielles silencieuses.
GEMINI_API_KEY = your_gemini_api_key
BRIGHT_WS_ENDPOINT = //i will show you later
Étape 3 : Mise en place de l’infrastructure du navigateur Bright Data Cloud
Pour l’Étape 3 : Mise en place de l’infrastructure du navigateur Bright Data Cloud, définissez les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Séparez la planification de l’exécution des outils : le planificateur propose, l’exécutant modifie, et le vérificateur contrôle les résultats par rapport à l’objectif.
BRIGHT_WS_ENDPOINT = "your_endpoint"
chromium.launch()
chromium.connectOverCDP()
Étape 4 : Connexion de Playwright à Bright Data
Pour l’étape 4 : Connecter Playwright à Bright Data, il faut définir les entrées, le responsable de l’étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif.
import { chromium }
from "playwright";
const BRIGHT_WS_ENDPOINT = "your_endpoint"
const browser =
await chromium.connectOverCDP(BRIGHT_WS_ENDPOINT
);
const page =
await browser.newPage();
await page.goto(
"https://cnn.com"
);
console.log(
await page.title()
);
Approfondir SIKKI Agent avant l’implémentation
Pour approfondir la connaissance de SIKKI Agent avant sa mise en œuvre, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Séparez la planification de l’exécution par l’outil. Le planificateur propose ; l’exécutant modifie ; le vérificateur compare les résultats à l’objectif fixé. Pour approfondir la connaissance de SIKKI Agent avant sa mise en œuvre, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les résultats partiels non signalés.
Fin de la traduction.SIKKI n’est pas un outil d’extraction
Pour SIKKI n’est pas un outil d’extraction, il faut définir les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrer les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le parcours passe d’un environnement de démonstration à un environnement partagé. Restreindre strictement les schémas des outils. Des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.
ProductPriceAcer Nitro V$899ASUS TUF$949MSI Thin$979
L’architecture derrière SIKKI
Pour l’architecture sous-jacente à SIKKI, il convient de définir les entrées, le responsable de chaque étape ainsi que les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux.
SIKKI
Strategic Intelligence Commerce Kernel
┌──────────────────────────────┐
│ Browser Layer │
│ Playwright + Bright Data │
└──────────────────────────────┘
│
▼
┌──────────────────────────────┐
│ Extraction Layer │
│ Product │
│ Price │
│ Rating │
│ Seller │
│ Availability │
└──────────────────────────────┘
│
▼
┌──────────────────────────────┐
│ AI Layer │
│ Gemini │
└──────────────────────────────┘
│
▼
┌──────────────────────────────┐
│ Analysis Layer │
│ Cheapest Products │
│ Market Average │
│ Competitor Comparison │
│ Trend Analysis │
└──────────────────────────────┘
│
▼
Markdown / CSV
Dashboard Export
Construction de la couche d’extraction
Pour construire la couche d’extraction, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux. Pour construire la couche d’extraction, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse.
const products = await page.evaluate(() => {const items = [];
document.querySelectorAll('[data-component-type="s-search-result"]')
.forEach(card => {
const title =
card.querySelector('h2 span')?.innerText;
const price =
card.querySelector('.a-price .a-offscreen')
?.innerText;
const rating =
card.querySelector('.a-icon-alt')
?.innerText;
const link =
card.querySelector('h2 a')
?.href;
if(title && price){
items.push({
title,
price,
rating,
link
});
}
});
return items;
});
console.log(products);
[
{
title: "Acer Nitro V Gaming Laptop",
price: "$899",
rating: "4.5 out of 5 stars",
link: "https://..."
},
{
title: "ASUS TUF Gaming A15",
price: "$949",
rating: "4.4 out of 5 stars",
link: "https://..."
}
]
Fournir un cerveau à SIKKI
Pour doter SIKKI d’un cerveau, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le parcours passe d’un environnement de démonstration à un environnement partagé. Créez un point de contrôle après des appels de modèles coûteux afin qu’un nouvel essai ne fasse pas payer à nouveau le même travail.
const prompt = `You are an ecommerce analyst.
Analyze the following products.
${JSON.stringify(products)}
Return:
1. Cheapest product
2. Average price
3. Best rated product
4. Summary of the market
5. Recommendation
`;
Construction de l’agent SIKKI final
Pour créer l’agent SIKKI final, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Créez un point de contrôle après chaque appel coûteux au modèle afin qu’un nouvel essai ne fasse pas payer à nouveau le même travail.
Étape 1 : Créer le fichier de l’agent
Pour l’Étape 1 : Créez le fichier de l’agent, définites les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réexécution, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Créez un point de contrôle après chaque appel coûteux au modèle afin qu’une tentative de réexécution ne facture pas à nouveau le même travail. Pour l’Étape 1 : Créez le fichier de l’agent, définites les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses.
import "dotenv/config"; //to use environment variables from .env file
import fs from "fs"; //to read and write files
import { chromium } from "playwright";
import { GoogleGenAI } from "@google/genai";
//api keys and endpoints from environment variables
const BRIGHT_WS_ENDPOINT = process.env.BRIGHT_WS_ENDPOINT;
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
//initialize the GoogleGenAI client with the Gemini API key
const ai = new GoogleGenAI({
apiKey: GEMINI_API_KEY,
});
//the prompt to send to the Gemini API
const prompt = "Write a short introduction to the Gemini API.";
const response = await ai.models.generateContent({
model: "gemini-2.5-flash",
contents: prompt,
});
console.log(response.text);
Étape 2 : Configurer Playwright pour se connecter au WebSocket de Bright Data
Pour l’Étape 2 : Configurer Playwright pour se connecter au WebSocket de Bright Data, définissez les entrées, le responsable de l’étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Séparez la planification de l’exécution par les outils : le planificateur propose, l’exécutant modifie, et le vérificateur contrôle les résultats par rapport à l’objectif.
//setup Playwright to connect to Bright Data's WebSocket endpoint and navigate to Amazon search results for "gaming laptop"
async function main(){
const browser = await chromium.connectOverCDP(BRIGHT_WS_ENDPOINT);
const page = await browser.newPage();
const query = "gaming laptop";
const searchUrl = `https://www.amazon.com/s?k=${encodeURIComponent(query)}`;
console.log("Navigating Bright Data Playwright to:", searchUrl);
await page.goto(searchUrl, { waitUntil: "domcontentloaded" });
const title = await page.title();
console.log("Amazon search page title:", title);
console.log("Bright Data navigation complete for query:", query);
await browser.close();
}
main();
Étape 3 : Extraire les informations sur le produit
Pour l’Étape 3 : Extraire les informations sur le produit, définissez les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Séparez la planification de l’exécution par les outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif.
// Playwright to connect to Bright Data's WebSocket endpoint and navigate to Amazon search results for "gaming laptop"
async function main(){
const browser = await chromium.connectOverCDP(BRIGHT_WS_ENDPOINT);
const page = await browser.newPage();
const query = "gaming laptop";
const searchUrl = `https://www.amazon.com/s?k=${encodeURIComponent(query)}`;
console.log("Navigating Bright Data Playwright to:", searchUrl);
await page.goto(searchUrl, { waitUntil: "domcontentloaded" });
const products = await page.evaluate(() => {
const data = [];
document
.querySelectorAll('[data-component-type="s-search-result"]')
.forEach((card) => {
const title = card.querySelector("h2 span")?.innerText;
const price = card.querySelector(".a-price .a-offscreen")?.innerText;
const rating = card.querySelector(".a-icon-alt")?.innerText;
if (title && price) {
data.push({
title,
price,
rating,
});
}
});
return data;
});
console.log("Step 3: Extract Product Information");
console.log(products);
const title = await page.title();
console.log("Amazon search page title:", title);
console.log("Bright Data navigation complete for query:", query);
await browser.close();
}
main();
Étape 4 : Demander à Gemini d’analyser le marché
Pour l’Étape 4 : Demander à Gemini d’analyser le marché, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours idéal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure. Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif. Pour l’Étape 4 : Demander à Gemini d’analyser le marché, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des contrôles de succès et refusez les terminations partielles silencieuses.
const prompt = `You are an ecommerce analyst.
Analyze these products:
${JSON.stringify(products)}
Return:
1. Cheapest Product
2. Average Market Price
3. Best Rated Product
4. Competitor Comparison
5. Final Recommendation
`;
const result = await model.generateContent(prompt);
const analysis =
result.response.text();
### 3. Best Rated Product
There are three products tied for the highest rating of **5.0 out of 5 stars**:
1. **HP OMEN 16" Gaming Laptop Computer** (Intel Ultra 9 285H, NVIDIA GeForce RTX 5070 8GB, 16GB DDR5, 1TB PCIe SSD, 144Hz IPS WUXGA Display) at **$1,745.99**
2. **HP OMEN 16 Slim RTX 5070 Gaming Laptop** (Intel Ultra 9 285H, NVIDIA RTX 5070, 32GB DDR5, 1TB SSD, 16" FHD+ Anti-Glare) at **$1,929.00**
3. **ASUS ROG Strix G16 Gaming Laptop** (Intel Core i7 14650HX, NVIDIA RTX 5060, 32 GB DDR5 RAM, 1 TB SSD, 16" FHD+ LED Display, & Gaming Accessories) at **$1,999.99**
**Analysis:** It's noteworthy that two HP OMEN laptops achieved perfect ratings, both featuring high-end Ultra 9 CPUs and RTX 5070 GPUs.
This suggests strong customer satisfaction with HP's premium gaming line.
The ASUS ROG Strix G16 also achieved a 5.0 rating,
despite having a slightly lower-tier GPU (RTX 5060) than the
HP OMENs in this bracket, possibly due to the included
"Gaming Accessories" and overall perceived value.
The Alienware product has no rating, so it cannot be considered here.
Étape 5 : Exporter le rapport du marché Sikki
Pour l’Étape 5 : Exporter le rapport du marché Sikki, définissez les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Restreignez strictement les schémas des outils ; des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.
const report = `
# SIKKI Market Report
## Search Query
${query}
## Products
${JSON.stringify(products, null, 2)}
## Gemini Analysis
${analysis}
Generated: ${new Date().toISOString()}
`;
fs.writeFileSync(reportPath, report, "utf8");
import "dotenv/config"; // use environment variables from .env file
import fs from "fs";
import { chromium } from "playwright";
import { GoogleGenAI } from "@google/genai";
const BRIGHT_WS_ENDPOINT = process.env.BRIGHT_WS_ENDPOINT;
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
if (!BRIGHT_WS_ENDPOINT) {
throw new Error("Missing BRIGHT_WS_ENDPOINT environment variable.");
}
if (!GEMINI_API_KEY) {
throw new Error("Missing GEMINI_API_KEY environment variable.");
}
const ai = new GoogleGenAI({
apiKey: GEMINI_API_KEY,
});
async function retryWithBackoff(fn, maxRetries = 5, initialDelayMs = 2000) {
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
return await fn();
} catch (error) {
const errorMsg = error?.message || error?.status || JSON.stringify(error);
if (attempt === maxRetries) {
console.error(`Final attempt failed. Error: ${errorMsg}`);
throw error;
}
const delayMs = initialDelayMs * Math.pow(2, attempt - 1);
console.log(`Attempt ${attempt} failed: ${errorMsg}`);
console.log(`Retrying in ${delayMs}ms... (${attempt}/${maxRetries})`);
await new Promise((resolve) => setTimeout(resolve, delayMs));
}
}
}
async function main() {
let browser;
try {
browser = await chromium.connectOverCDP(BRIGHT_WS_ENDPOINT);
const page = await browser.newPage();
const query = "gaming laptop";
const searchUrl = `https://www.amazon.com/s?k=${encodeURIComponent(query)}`;
console.log("Connecting Playwright to Bright Data...");
console.log("Navigating to:", searchUrl);
await page.goto(searchUrl, { waitUntil: "domcontentloaded" });
const products = await page.evaluate(() => {
const data = [];
document
.querySelectorAll('[data-component-type="s-search-result"]')
.forEach((card) => {
const title = card.querySelector("h2 span")?.innerText;
const price = card.querySelector(".a-price .a-offscreen")?.innerText;
const rating = card.querySelector(".a-icon-alt")?.innerText;
if (title && price) {
data.push({
title,
price,
rating,
});
}
});
return data;
});
console.log(`Extracted ${products.length} products.`);
const analysisPrompt = `You are an ecommerce analyst.
Analyze these products:
${JSON.stringify(products)}
Return:
1. Cheapest Product
2. Average Market Price
3. Best Rated Product
4. Competitor Comparison
5. Final Recommendation
`;
console.log("Sending products to Gemini for analysis (with retry logic)...");
const analysisResult = await retryWithBackoff(async () => {
return await ai.models.generateContent({
model: "gemini-2.5-flash",
contents: analysisPrompt,
});
}, 5, 2000);
const analysis = analysisResult.text || "No analysis text returned.";
const report = `# SIKKI Market Report
## Search Query
${query}
## Products
${JSON.stringify(products, null, 2)}
## Gemini Analysis
${analysis}
Generated: ${new Date().toISOString()}
`;
fs.writeFileSync("sikki-report.md", report, "utf8");
console.log("Step 5: Export the Results");
console.log("Report generated: sikki-report.md");
console.log("Final analysis saved. Open sikki-report.md to review the result.");
await browser.close();
} catch (error) {
console.error("Error:", error.message || error);
if (browser) {
await browser.close().catch(() => {});
}
process.exit(1);
}
}
main();
Étape 6 : Apprendre à SIKKI à collecter des preuves
Pour l’étape 6 : Enseigner à SIKKI à collecter des preuves, il faut définir les entrées, le responsable de l’étape ainsi que les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux.
const searchScreenshot = path.join(screenshotDir, "search-results.png");
await page.screenshot({ path: searchScreenshot, fullPage: true });
const summaryPath = path.join(screenshotDir, "top-product-summary.png");
await cards[0].screenshot({ path: summaryPath });
Étape 7 : Capturer chaque page de produit
Pour l’Étape 7 : Capturer chaque page de produit, il faut définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux. Pour l’Étape 7 : Capturer chaque page de produit, il faut définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses.
const normalized = normalizeAmazonUrl(p.url, p.title);
await retryWithBackoff(async () =>
await page.goto(normalized, { waitUntil: "domcontentloaded", timeout: 120000 }),
3,
1500
);
await page.waitForTimeout(800);
await page.screenshot({ path: outPath, fullPage: true });
Étape 8 : Créer une exportation CSV
Pour l’étape 8 : Créer une exportation CSV, définissez les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Prévoyez un point de contrôle après les appels coûteux au modèle afin qu’un nouvel essai ne génère pas à nouveau des frais pour le même travail.
const csvLines = ["TITLE,PRICE,RATING,URL"];
enriched.forEach((p) => {
const safe = (s) => `"${String(s || "").replace(/"/g, '""')}"`;
csvLines.push([safe(p.title), safe(p.price), safe(p.rating || ""), safe(p.url || "")].join(","));
});
fs.writeFileSync(csvPath, csvLines.join("\n"), "utf8");
Étape 9 : Générer un résumé du tableau de bord
Pour l’Étape 9 : Générer un résumé du tableau de bord, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stocks de secrets et les flags fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Créez un point de contrôle après des appels coûteux au modèle afin qu’un nouvel essai ne facture pas à nouveau le même travail.
const priced = enriched.filter((p) => !isNaN(p.priceValue));
const cheapestObj = priced.length ? priced.reduce((a, b) => (a.priceValue <= b.priceValue ? a : b)) : null;
const avgPriceVal = priced.length ? (priced.reduce((s, p) => s + p.priceValue, 0) / priced.length).toFixed(2) : “N/A”;
const bestRatedObj = enriched.slice().sort((a, b) => {
const ra = parseFloat((a.rating || “”).split(“ “)[0]) || 0;
const rb = parseFloat((b.rating || “”).split(“ “)[0]) || 0;
return rb — ra;
})[0] || null;
const dashboard = [];
dashboard.push(“==================================”);
dashboard.push(“SIKKI MARKET DASHBOARD”);
dashboard.push(“==================================”);
dashboard.push(`Query: ${query}`);
dashboard.push(`Products Extracted: ${enriched.length}`);
dashboard.push(`Cheapest Product: ${cheapestObj ? `${cheapestObj.title} | ${cheapestObj.price}` : “N/A”}`);
dashboard.push(`Average Price: ${avgPriceVal === “N/A” ? “N/A” : `${avgPriceVal}`}`);
dashboard.push(`Best Rated: ${bestRatedObj ? `${bestRatedObj.title} | ${bestRatedObj.rating || “N/A”}` : “N/A”}`);
dashboard.push(“\nTop 5 Products:”);
enriched.slice(0, 5).forEach((p, i) => {
dashboard.push(`${i + 1}. ${p.title} | ${p.price} | ${p.rating || “N/A”} | ${p.url || “N/A”}`);
});
fs.writeFileSync(dashboardPath, dashboard.join(“\n”), “utf8”);
Où aller ensuite
Pour déterminer la prochaine étape, il faut d’abord définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Créez un point de contrôle après chaque appel coûteux au modèle afin qu’une tentative de relance ne fasse pas payer à nouveau le même travail. Pour déterminer la prochaine étape, il faut d’abord définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses.
Conclusion
En conclusion, il convient de définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Il faut enregistrer les temps d’exécution et les coûts aux côtés des résultats fonctionnels. Une visibilité précoce permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Il faut séparer la planification de l’exécution par les outils : le planificateur propose, l’exécutant modifie, et le vérificateur contrôle les résultats par rapport à l’objectif.
Liste de contrôle opérationnelle
Pour la liste de contrôle opérationnelle, il faut définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché.
Préférer des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé.
Point de contrôle après les appels coûteux aux modèles afin qu’une tentative de réexécution ne facture pas à nouveau le même travail.
Comprendre les limites du cycle d’événements : ce qui bloque le thread par rapport à ce qui attend le noyau.
Rédiger un guide de procédures succinct : comment rotationner les clés, vider la file d’attente, annuler la dernière modification.
Garder la configuration en dehors du code de l’application. Les fichiers d’environnement, les stockages de secrets et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système.
Au préalable de promouvoir la pile logicielle, figer les versions, enregistrer une transcription exemplaire pour le chemin critique et confirmer les étapes de réversion. Les environnements partagés nécessitent des limites de débit, des vérifications de location et un responsable clair pour la rotation des secrets. Préférer une fiabilité simple à des démonstrations originales mais peu fiables.