social-agent-cli 2.3.2 → 3.0.1

package/ai/runner.ts

@@ -37,19 +37,16 @@ export async function runCommand(platform: string, command: string): Promise<voi
       if (repeatCount > 1) console.log(`  [${r + 1}/${repeatCount}]`);
 
       const params = { ...step.parameters };
-      const post: Post = {
-        content: params["{{CONTENT}}"] || params["CONTENT"] || "",
-        images: (params["{{IMAGE}}"] || params["IMAGE"]) ? [params["{{IMAGE}}"] || params["IMAGE"]] : undefined,
-        platform,
-      };
+      const content = params["{{CONTENT}}"] || params["CONTENT"] || "";
+      const image = params["{{IMAGE}}"] || params["IMAGE"] || "";
 
       const driver = new BrowserDriver(platform, url);
-      const page = await driver.launch();
+      await driver.launch();
 
       try {
+        // Ana sayfaya git (ilk step goto değilse)
         if (map.steps[0]?.action !== "goto") {
-          await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
-          await page.waitForTimeout(3000);
+          driver.navigate(url);
         }
 
         let steps = [...map.steps];
@@ -57,19 +54,10 @@ export async function runCommand(platform: string, command: string): Promise<voi
 
         for (let idx = 0; idx < steps.length; idx++) {
           const s = steps[idx];
-          const rp = (t: string) => replacePlaceholders(t, post, params);
 
           try {
             console.log(`    ${idx + 1}. ${s.description}`);
-
-            if (s.action === "goto") {
-              let gotoUrl = rp(s.url || url);
-              if (gotoUrl.includes("{{")) gotoUrl = url;
-              await page.goto(gotoUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
-            } else {
-              await executeStep(page, s, post, params);
-            }
-            if (s.waitMs) await page.waitForTimeout(s.waitMs);
+            driver.executeStep(s, content, image);
           } catch (err: any) {
             if (healCount >= 2) {
               console.log(`    ✗ ${err.message} (atlanıyor)`);
@@ -80,12 +68,12 @@ export async function runCommand(platform: string, command: string): Promise<voi
             console.log(`    → Düzeltiliyor...`);
 
             const ss = join(PATHS.screenshots, `${platform}_heal.png`);
-            await page.screenshot({ path: ss }).catch(() => {});
-            const aria = await page.locator("body").ariaSnapshot().catch(() => "");
+            driver.takeScreenshot(ss);
+            const snap = driver.getSnapshot();
 
             const fixed = await healAndContinue(
-              platform, idx, steps, ss, aria as string,
-              err.message, post.content || step.description, "medium"
+              platform, idx, steps, ss, snap,
+              err.message, content || step.description, "medium"
             );
             steps = [...steps.slice(0, idx), ...fixed];
             idx--;
@@ -93,17 +81,16 @@ export async function runCommand(platform: string, command: string): Promise<voi
         }
 
         console.log(`  ✓ Tamamlandı`);
-        saveToHistory({ platform, content: post.content || step.description, action: mapAction.includes("post") ? "post" : mapAction, success: true });
+        saveToHistory({ platform, content: content || step.description, action: mapAction.includes("post") ? "post" : mapAction, success: true });
       } catch (err: any) {
         console.log(`  ✗ ${err.message}`);
-        saveToHistory({ platform, content: post.content || step.description, action: mapAction, success: false, error: err.message });
+        saveToHistory({ platform, content: content || step.description, action: mapAction, success: false, error: err.message });
       } finally {
         await driver.close();
       }
 
       if (r < repeatCount - 1) {
-        const delay = 2000 + Math.random() * 3000;
-        await new Promise((res) => setTimeout(res, delay));
+        await new Promise((res) => setTimeout(res, 2000 + Math.random() * 3000));
       }
     }
     console.log("");
@@ -112,93 +99,3 @@ export async function runCommand(platform: string, command: string): Promise<voi
   console.log("[runner] Tamamlandı.");
   process.exit(0);
 }
-
-function replacePlaceholders(text: string, post: Post, params: Record<string, string>): string {
-  if (!text) return text;
-  let r = text.replace("{{CONTENT}}", post.content || "");
-  for (const [k, v] of Object.entries(params)) {
-    r = r.replace(k.startsWith("{{") ? k : `{{${k}}}`, v);
-  }
-  return r;
-}
-
-async function executeStep(page: any, step: any, post: Post, params: Record<string, string>): Promise<void> {
-  const rp = (t: string) => replacePlaceholders(t, post, params);
-  const selectors = [step.selector, ...(step.fallbackSelectors || [])].filter(Boolean).map((s: string) => rp(s));
-
-  switch (step.action) {
-    case "wait":
-      await page.waitForTimeout(step.waitMs || 1000);
-      break;
-
-    case "click": {
-      for (const sel of selectors) {
-        if (sel.includes("{{")) continue;
-        try {
-          await page.waitForSelector(sel, { timeout: 5000 });
-          await page.click(sel);
-          return;
-        } catch {}
-      }
-      throw new Error(`Click: ${selectors[0]}`);
-    }
-
-    case "type": {
-      const text = rp(step.value || "");
-      for (const sel of selectors) {
-        if (sel.includes("{{")) continue;
-        try {
-          await page.waitForSelector(sel, { timeout: 5000 });
-          const ce = await page.$eval(sel, (el: Element) =>
-            el.getAttribute("contenteditable") === "true" || el.getAttribute("role") === "textbox"
-          ).catch(() => false);
-          if (ce) {
-            await page.click(sel);
-            await page.evaluate(([s, t]: string[]) => {
-              const el = document.querySelector(s);
-              if (el) { (el as HTMLElement).focus(); document.execCommand("insertText", false, t); }
-            }, [sel, text]);
-          } else {
-            await page.fill(sel, text);
-          }
-          return;
-        } catch {}
-      }
-      throw new Error(`Type: ${selectors[0]}`);
-    }
-
-    case "keypress":
-      await page.keyboard.press(step.key || "Enter");
-      break;
-
-    case "upload": {
-      const filePath = rp(step.value || "{{IMAGE}}");
-      if (!filePath || filePath.includes("{{")) break;
-
-      // 1. input[type=file] direkt (file picker açmaz)
-      try {
-        const inputs = await page.locator('input[type="file"]').all();
-        for (const inp of inputs) {
-          try { await inp.setInputFiles(filePath); return; } catch {}
-        }
-      } catch {}
-
-      // 2. fileChooser event listener ile butona tıkla
-      for (const sel of selectors) {
-        let done = false;
-        const handler = async (fc: any) => { await fc.setFiles(filePath); done = true; };
-        page.on("filechooser", handler);
-        try {
-          await page.click(sel);
-          // fileChooser event'inin tetiklenmesini bekle
-          for (let w = 0; w < 20 && !done; w++) await page.waitForTimeout(250);
-          page.removeListener("filechooser", handler);
-          if (done) return;
-        } catch {
-          page.removeListener("filechooser", handler);
-        }
-      }
-      throw new Error(`Upload: ${filePath}`);
-    }
-  }
-}

package/bin/postinstall.js

@@ -2,18 +2,23 @@
 
 import { execSync } from "node:child_process";
 
+// agent-browser kurulumu
 try {
-  console.log("  Playwright Chromium yükleniyor...");
-  execSync("npx playwright install chromium", { stdio: "pipe" });
-  console.log("  ✓ Playwright Chromium yüklendi");
+  execSync("agent-browser --version", { stdio: "pipe" });
+  console.log("  ✓ agent-browser zaten kurulu");
 } catch {
-  console.log("  ⚠ Playwright Chromium otomatik yüklenemedi.");
-  console.log("    Manuel kur: npx playwright install chromium");
+  try {
+    console.log("  agent-browser kuruluyor...");
+    execSync("npm install -g agent-browser", { stdio: "pipe" });
+    execSync("agent-browser install", { stdio: "pipe" });
+    console.log("  ✓ agent-browser kuruldu");
+  } catch {
+    console.log("  ⚠ agent-browser otomatik kurulamadı.");
+    console.log("    Manuel kur: npm install -g agent-browser && agent-browser install");
+  }
 }
 
 console.log(`
   ✓ social-agent kuruldu!
-
-  Başlamak için:
-    social-agent setup
+  Başlamak için: social-agent setup
 `);

package/core/screenshot.ts

@@ -1,37 +1,22 @@
-import { chromium } from "playwright";
+import { execSync } from "node:child_process";
 
 /**
- * HTML dosyasını JPEG'e çevirir
+ * HTML dosyasını JPEG/PNG'ye çevirir
  * Kullanım: npx tsx core/screenshot.ts /tmp/input.html /tmp/output.jpeg 1200 675
  */
-async function main() {
-  const [, , htmlPath, outputPath, widthStr = "1200", heightStr = "675"] = process.argv;
+const [, , htmlPath, outputPath, widthStr = "1200", heightStr = "675"] = process.argv;
 
-  if (!htmlPath || !outputPath) {
-    console.error("Kullanım: npx tsx core/screenshot.ts <html-path> <output-path> [width] [height]");
-    process.exit(1);
-  }
-
-  const width = parseInt(widthStr);
-  const height = parseInt(heightStr);
-
-  const browser = await chromium.launch({ headless: true });
-  const page = await browser.newPage({ viewport: { width, height } });
-  await page.goto(`file://${htmlPath}`);
-  await page.waitForTimeout(500);
-
-  const isJpeg = outputPath.endsWith(".jpeg") || outputPath.endsWith(".jpg");
-  await page.screenshot({
-    path: outputPath,
-    type: isJpeg ? "jpeg" : "png",
-    quality: isJpeg ? 100 : undefined,
-  });
-
-  await browser.close();
-  console.log(outputPath);
+if (!htmlPath || !outputPath) {
+  console.error("Kullanım: npx tsx core/screenshot.ts <html-path> <output-path> [width] [height]");
+  process.exit(1);
 }
 
-main().catch((err) => {
+try {
+  execSync(`agent-browser --viewport ${widthStr}x${heightStr} open "file://${htmlPath}"`, { stdio: "pipe", timeout: 15000 });
+  execSync(`agent-browser wait 500`, { stdio: "pipe" });
+  execSync(`agent-browser screenshot "${outputPath}"`, { stdio: "pipe", timeout: 10000 });
+  console.log(outputPath);
+} catch (err: any) {
   console.error(err.message);
   process.exit(1);
-});
+}

package/install.ts

@@ -148,7 +148,8 @@ Gönderme komutları (HER ZAMAN bu komutları kullan, asla cd veya npx tsx kulla
   if (!existsSync(join(PKG_DIR, "node_modules"))) {
     execSync("npm install", { cwd: PKG_DIR, stdio: "pipe" });
   }
-  try { execSync("npx playwright install chromium", { cwd: ROOT, stdio: "pipe" }); } catch {}
+  // agent-browser Chrome kurulumu
+  try { execSync("agent-browser install", { stdio: "pipe", timeout: 120000 }); } catch {}
 
   // Claude Code permissions - social-agent komutları otomatik onay
   const claudeSettingsPath = join(homedir(), ".claude", "settings.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-agent-cli",
-  "version": "2.3.2",
+  "version": "3.0.1",
   "description": "AI-powered social media agent - free APIs + browser automation with self-healing selectors",
   "type": "module",
   "bin": {
@@ -24,7 +24,6 @@
     "tsconfig.json"
   ],
   "dependencies": {
-    "playwright": "^1.50.0",
     "tsx": "^4.19.0"
   },
   "devDependencies": {

package/platforms/browser/driver.ts

@@ -1,354 +1,212 @@
-import { chromium, type Browser, type BrowserContext, type Page } from "playwright";
+import { execSync } from "node:child_process";
 import { join } from "node:path";
-import { homedir } from "node:os";
-import { execSync, spawn, type ChildProcess } from "node:child_process";
 import { PATHS } from "../../core/config.js";
-import { loadMap, generateMap, healAndContinue } from "../../ai/mapper.js";
-import { pickChromeProfile, getSavedProfile, closeReadline } from "../../core/profiles.js";
-import type { Post, PostResult, SelectorMap, SelectorStep } from "../../core/types.js";
-
-const MAX_HEAL_ATTEMPTS = 3;
-const CHROME_PATH = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
-const CDP_PORT = 9222;
-
+import { loadMap, generateMap } from "../../ai/mapper.js";
+import { pickChromeProfile, getSavedProfile } from "../../core/profiles.js";
+import type { SelectorMap } from "../../core/types.js";
+
+/**
+ * Browser Driver - agent-browser (Rust) ile browser otomasyonu
+ * Playwright yerine native CDP, çok daha hızlı ve güvenilir
+ */
 export class BrowserDriver {
-  private browser: Browser | null = null;
-  private context: BrowserContext | null = null;
-  private page: Page | null = null;
-  private chromeProcess: ChildProcess | null = null;
-  private weStartedChrome = false;
+  private profilePath: string = "";
 
   constructor(private platform: string, private homeUrl: string) {}
 
-  /**
-   * Çalışan Chrome'un CDP'sine bağlanmayı dene
-   */
-  private async tryConnectCDP(): Promise<boolean> {
+  private cmd(command: string, timeout = 15000): string {
+    const profileFlag = this.profilePath ? `--profile "${this.profilePath}" --headed` : "--auto-connect";
     try {
-      const res = await fetch(`http://127.0.0.1:${CDP_PORT}/json/version`, {
-        signal: AbortSignal.timeout(1000),
-      });
-      if (res.ok) {
-        const data = (await res.json()) as any;
-        this.browser = await chromium.connectOverCDP(`http://127.0.0.1:${CDP_PORT}`);
-        this.context = this.browser.contexts()[0];
-        return true;
-      }
-    } catch {}
-    return false;
-  }
-
-  /**
-   * Chrome'u debug port ile başlat
-   * Chrome kendi default data-dir'iyle CDP kabul etmiyor,
-   * bu yüzden profil dosyalarını ayrı bir dizine kopyalayıp oradan açıyoruz.
-   */
-  private async startChrome(profileDirName: string): Promise<void> {
-    const srcDataDir = join(homedir(), "Library", "Application Support", "Google", "Chrome");
-    const workDir = join(PATHS.profiles, "chrome-cdp");
-    const workProfileDir = join(workDir, profileDirName);
-
-    // Çalışma dizinini oluştur
-    const { mkdirSync, copyFileSync, existsSync: exists } = await import("node:fs");
-    mkdirSync(workProfileDir, { recursive: true });
-
-    // Cookie ve login verilerini kopyala
-    const filesToCopy = [
-      "Cookies", "Cookies-journal",
-      "Login Data", "Login Data-journal",
-      "Web Data", "Web Data-journal",
-      "Preferences", "Secure Preferences",
-    ];
-    const srcProfileDir = join(srcDataDir, profileDirName);
-    for (const f of filesToCopy) {
-      const src = join(srcProfileDir, f);
-      if (exists(src)) {
-        try { copyFileSync(src, join(workProfileDir, f)); } catch {}
-      }
-    }
-    // Local State ana dizinde
-    const localState = join(srcDataDir, "Local State");
-    if (exists(localState)) {
-      try { copyFileSync(localState, join(workDir, "Local State")); } catch {}
-    }
-
-    this.chromeProcess = spawn(CHROME_PATH, [
-      `--remote-debugging-port=${CDP_PORT}`,
-      `--user-data-dir=${workDir}`,
-      `--profile-directory=${profileDirName}`,
-      "--no-first-run",
-      "--no-default-browser-check",
-    ], {
-      detached: true,
-      stdio: "ignore",
-    });
-    this.chromeProcess.unref();
-    this.weStartedChrome = true;
-
-    for (let i = 0; i < 30; i++) {
-      await new Promise((r) => setTimeout(r, 500));
-      if (await this.tryConnectCDP()) return;
+      return execSync(`agent-browser ${profileFlag} ${command}`, {
+        encoding: "utf-8",
+        timeout,
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+    } catch (err: any) {
+      const stderr = err.stderr?.toString() || "";
+      const stdout = err.stdout?.toString() || "";
+      throw new Error(stderr || stdout || err.message);
     }
-    throw new Error("Chrome başlatıldı ama CDP bağlantısı kurulamadı");
   }
 
   /**
-   * Chrome'u aç veya mevcut olana bağlan
+   * Profil seç ve hazırla
    */
-  async launch(askProfile = false): Promise<Page> {
+  private async setupProfile(askProfile = false): Promise<void> {
     const profile = askProfile
       ? await pickChromeProfile(this.platform)
       : getSavedProfile(this.platform);
 
     if (!profile) {
-      throw new Error(
-        `[${this.platform}] profil seçilmemiş. Önce: npx tsx cli.ts login ${this.platform}`
-      );
+      throw new Error(`[${this.platform}] profil seçilmemiş. Önce: social-agent login ${this.platform}`);
     }
 
-    // Önce açık Chrome'a bağlanmayı dene
-    const connected = await this.tryConnectCDP();
+    // agent-browser profil dizini
+    this.profilePath = join(PATHS.profiles, `ab-${this.platform}`);
 
-    if (!connected) {
-      // Chrome kapalı, başlat
-      console.log(`[${this.platform}] Chrome başlatılıyor (${profile.name})...`);
-      await this.startChrome(profile.dirName);
-    } else {
-      console.log(`[${this.platform}] Açık Chrome'a bağlanıldı.`);
-    }
+    // İlk kullanımda Chrome cookie'lerini kopyala
+    const { existsSync, mkdirSync, copyFileSync } = await import("node:fs");
+    mkdirSync(this.profilePath, { recursive: true });
 
-    // Yeni sekme aç
-    this.page = await this.context!.newPage();
-    return this.page;
-  }
-
-  async close(): Promise<void> {
-    // Sadece sekmeyi kapat, Chrome'u kapatma
-    if (this.page) {
-      try { await this.page.close(); } catch {}
+    const cookieFiles = ["Cookies", "Cookies-journal", "Login Data", "Login Data-journal", "Preferences"];
+    for (const f of cookieFiles) {
+      const src = join(profile.fullPath, f);
+      if (existsSync(src)) {
+        try { copyFileSync(src, join(this.profilePath, f)); } catch {}
+      }
     }
   }
 
   /**
-   * Login - profil seç, Chrome'da x.com aç
+   * Login - profil seç, tarayıcı aç
    */
   async login(): Promise<void> {
-    const page = await this.launch(true);
-    await page.goto(this.homeUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+    await this.setupProfile(true);
+    // Login için --profile ile --headed aç
+    const profileFlag = `--profile "${this.profilePath}" --headed`;
+    execSync(`agent-browser ${profileFlag} open "${this.homeUrl}"`, { stdio: "pipe", timeout: 30000 });
 
-    console.log(`\n[${this.platform}] Sekme açıldı: ${this.homeUrl}`);
+    console.log(`\n[${this.platform}] Tarayıcı açıldı: ${this.homeUrl}`);
     const { createInterface } = await import("node:readline");
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     await new Promise<void>((resolve) => {
-      rl.question("Hesabın açıksa Enter'a bas, değilse giriş yap sonra Enter: ", () => {
-        rl.close();
-        resolve();
-      });
+      rl.question("Hesabın açıksa Enter'a bas: ", () => { rl.close(); resolve(); });
     });
-
     console.log(`[${this.platform}] Kayıt tamamlandı.`);
-    closeReadline();
-    await this.close();
+    process.exit(0);
   }
 
   /**
    * Sayfayı öğren - AI ile selector map oluştur
    */
   async learn(taskDescription = "yeni bir metin postu at", actionName = "post"): Promise<SelectorMap> {
-    const page = await this.launch();
-    await page.goto(this.homeUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
-    await page.waitForTimeout(3000);
+    await this.setupProfile();
 
+    // Sayfaya git
+    this.cmd(`open "${this.homeUrl}"`, 30000);
+    this.cmd("wait 3000");
+
+    // Screenshot al
     const screenshotPath = join(PATHS.screenshots, `${this.platform}_learn_${actionName}.png`);
-    await page.screenshot({ path: screenshotPath, fullPage: false });
+    this.cmd(`screenshot "${screenshotPath}"`);
 
-    // ARIA Snapshot - accessibility tree (98x daha küçük, sadece interaktif elementler)
-    const ariaSnapshot = await page.locator('body').ariaSnapshot();
+    // ARIA snapshot al (agent-browser'ın en güçlü özelliği)
+    const snapshot = this.cmd("snapshot", 10000);
 
     console.log(`[${this.platform}] Screenshot: ${screenshotPath}`);
-    console.log(`[${this.platform}] Accessibility tree: ${ariaSnapshot.length} bytes`);
+    console.log(`[${this.platform}] Snapshot: ${snapshot.length} bytes`);
     console.log(`[${this.platform}] Claude analiz ediyor...`);
 
-    const map = await generateMap(this.platform, screenshotPath, ariaSnapshot, taskDescription, actionName);
+    const map = await generateMap(this.platform, screenshotPath, snapshot, taskDescription, actionName);
 
     console.log(`[${this.platform}] "${actionName}" map oluşturuldu (${map.steps.length} adım)`);
-    await this.close();
+    process.exit(0);
     return map;
   }
 
   /**
-   * Post at - map kullanarak adımları uygula, hata olursa heal et
+   * Sayfaya git
    */
-  async post(post: Post): Promise<PostResult> {
-    let map = loadMap(this.platform);
-    if (!map) {
-      console.log(`[${this.platform}] Map yok, öğrenme başlatılıyor...`);
-      map = await this.learn();
-    }
-
-    const page = await this.launch();
-
-    try {
-      await page.goto(this.homeUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
-      await page.waitForTimeout(2000);
-
-      let steps = [...map.steps];
-      let i = 0;
-
-      while (i < steps.length) {
-        const step = steps[i];
-        try {
-          console.log(`[${this.platform}] Step ${i + 1}/${steps.length}: ${step.description}`);
-          await this.executeStep(page, step, post);
-          i++;
-        } catch (err: any) {
-          console.log(`[${this.platform}] Step #${i + 1} başarısız: ${err.message}`);
-
-          // Screenshot + DOM al, AI'a gönder
-          const healScreenshot = join(PATHS.screenshots, `${this.platform}_heal.png`);
-          await page.screenshot({ path: healScreenshot });
-
-          const domSnap = await page.evaluate(`(function() {
-            var SKIP = {"script":1,"style":1,"noscript":1,"link":1,"meta":1};
-            function ser(el, d, b) {
-              if (d > 15 || b.c <= 0) return "";
-              var t = el.tagName.toLowerCase();
-              if (SKIP[t]) return "";
-              if (t === "svg") return "<svg/>";
-              var st = window.getComputedStyle(el);
-              if (st.display === "none" || st.visibility === "hidden") return "";
-              var at = [];
-              for (var i = 0; i < el.attributes.length; i++) {
-                var a = el.attributes[i];
-                if (a.name === "style") continue;
-                at.push(a.name + '="' + (a.value.length > 150 ? a.value.substring(0,150) : a.value).replace(/"/g,"'") + '"');
-              }
-              var as = at.length ? " " + at.join(" ") : "";
-              var dt = "";
-              for (var j = 0; j < el.childNodes.length; j++) {
-                if (el.childNodes[j].nodeType === 3) { var tx = (el.childNodes[j].textContent||"").trim(); if (tx) dt += tx.substring(0,100); }
-              }
-              var ch = "";
-              for (var k = 0; k < el.children.length; k++) ch += ser(el.children[k], d+1, b);
-              if (!as && !dt && !ch) return "";
-              var r = "<"+t+as+">"+dt+ch+"</"+t+">";
-              b.c -= r.length;
-              return r;
-            }
-            return ser(document.body, 0, {c:500000});
-          })()`);
-
-          // AI kaldığı yerden devam etsin
-          const newSteps = await healAndContinue(
-            this.platform,
-            i,
-            steps,
-            healScreenshot,
-            domSnap as string,
-            err.message,
-            post.content
-          );
-
-          // Kalan adımları yeni planla değiştir
-          steps = [...steps.slice(0, i), ...newSteps];
-          // i'yi artırma - yeni ilk adımı deneyecek
-        }
-      }
-
-      await page.waitForTimeout(2000);
-      await this.close();
-      return { success: true, platform: this.platform };
-    } catch (err: any) {
-      await this.close();
-      return { success: false, platform: this.platform, error: err.message };
-    }
+  navigate(url: string): void {
+    this.cmd(`open "${url}"`, 30000);
+    this.cmd("wait 2000");
   }
 
   /**
-   * Tek bir step'i uygula
-   */
-  /**
-   * Parametre map'i - post objesinden + ekstra params'dan placeholder'ları doldurur
+   * Tek bir step çalıştır
    */
-  private replacePlaceholders(text: string, post: Post, params?: Record<string, string>): string {
-    let result = text;
-    result = result.replace("{{CONTENT}}", post.content || "");
-    result = result.replace("{{IMAGE}}", post.images?.[0] || "");
-    if (params) {
-      for (const [key, val] of Object.entries(params)) {
-        result = result.replace(`{{${key}}}`, val);
-      }
-    }
-    return result;
-  }
-
-  private async executeStep(page: Page, step: SelectorStep, post: Post, params?: Record<string, string>): Promise<void> {
-    const selectors = [step.selector, ...(step.fallbackSelectors || [])].filter(Boolean) as string[];
+  executeStep(step: any, content: string, imagePath?: string): void {
+    const value = (step.value || "").replace("{{CONTENT}}", content).replace("{{IMAGE}}", imagePath || "");
 
     switch (step.action) {
-      case "goto": {
-        const url = this.replacePlaceholders(step.url || this.homeUrl, post, params);
-        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
-        if (step.waitMs) await page.waitForTimeout(step.waitMs);
+      case "goto":
+        this.navigate(step.url || this.homeUrl);
         break;
-      }
 
       case "wait":
-        await page.waitForTimeout(step.waitMs || 1000);
+        this.cmd(`wait ${step.waitMs || 1000}`);
         break;
 
       case "click": {
+        const sels = [step.selector, ...(step.fallbackSelectors || [])].filter(Boolean);
         let clicked = false;
-        for (const sel of selectors) {
-          try {
-            await page.waitForSelector(sel, { timeout: 5000 });
-            await page.click(sel);
-            clicked = true;
-            break;
-          } catch { /* next */ }
+        for (const sel of sels) {
+          if (sel.includes("{{")) continue;
+          try { this.cmd(`click "${sel}"`); clicked = true; break; } catch {}
         }
-        if (!clicked) throw new Error(`Click failed: ${selectors.join(", ")}`);
-        if (step.waitMs) await page.waitForTimeout(step.waitMs);
+        if (!clicked) throw new Error(`Click: ${sels[0]}`);
+        if (step.waitMs) this.cmd(`wait ${step.waitMs}`);
         break;
       }
 
       case "type": {
-        const text = this.replacePlaceholders(step.value || "", post, params);
-
+        const sels = [step.selector, ...(step.fallbackSelectors || [])].filter(Boolean);
         let typed = false;
-        for (const sel of selectors) {
+        for (const sel of sels) {
+          if (sel.includes("{{")) continue;
           try {
-            await page.waitForSelector(sel, { timeout: 5000 });
-            const isContentEditable = await page.$eval(sel, (el: Element) =>
-              el.getAttribute("contenteditable") === "true" ||
-              el.getAttribute("role") === "textbox"
-            ).catch(() => false);
-
-            if (isContentEditable) {
-              await page.click(sel);
-              await page.keyboard.type(text, { delay: 30 });
-            } else {
-              await page.fill(sel, text);
-            }
+            this.cmd(`fill "${sel}" "${value.replace(/"/g, '\\"')}"`);
             typed = true;
             break;
-          } catch { /* next */ }
+          } catch {
+            try {
+              this.cmd(`click "${sel}"`);
+              this.cmd(`keyboard inserttext "${value.replace(/"/g, '\\"')}"`);
+              typed = true;
+              break;
+            } catch {}
+          }
         }
-        if (!typed) throw new Error(`Type failed: ${selectors.join(", ")}`);
-        if (step.waitMs) await page.waitForTimeout(step.waitMs);
+        if (!typed) throw new Error(`Type: ${sels[0]}`);
+        if (step.waitMs) this.cmd(`wait ${step.waitMs}`);
         break;
       }
 
       case "keypress":
-        await page.keyboard.press(step.key || "Enter");
-        if (step.waitMs) await page.waitForTimeout(step.waitMs);
+        this.cmd(`press ${step.key || "Enter"}`);
+        if (step.waitMs) this.cmd(`wait ${step.waitMs}`);
         break;
 
-      case "screenshot": {
-        const p = join(PATHS.screenshots, `${this.platform}_step.png`);
-        await page.screenshot({ path: p });
+      case "upload": {
+        const filePath = value || imagePath || "";
+        if (!filePath || filePath.includes("{{")) break;
+
+        const sels = [step.selector, ...(step.fallbackSelectors || [])].filter(Boolean);
+        let uploaded = false;
+        for (const sel of sels) {
+          try {
+            this.cmd(`upload "${sel}" "${filePath}"`);
+            uploaded = true;
+            break;
+          } catch {}
+        }
+        if (!uploaded) throw new Error(`Upload: ${filePath}`);
+        if (step.waitMs) this.cmd(`wait ${step.waitMs}`);
         break;
       }
     }
   }
+
+  /**
+   * Snapshot al (heal için)
+   */
+  getSnapshot(): string {
+    try { return this.cmd("snapshot", 10000); } catch { return ""; }
+  }
+
+  /**
+   * Screenshot al
+   */
+  takeScreenshot(path: string): void {
+    try { this.cmd(`screenshot "${path}"`); } catch {}
+  }
+
+  async close(): Promise<void> {
+    // agent-browser daemon otomatik yönetir
+  }
+
+  async launch(): Promise<any> {
+    await this.setupProfile();
+    return null; // agent-browser'da page objesi yok, cmd ile çalışıyor
+  }
 }