social-agent-cli 1.0.0 → 1.0.2

package/ai/runner.ts

@@ -0,0 +1,323 @@
+import { BrowserDriver } from "../platforms/browser/driver.js";
+import { loadMap } from "./mapper.js";
+import { createPlan, type ExecutionPlan, type PlanStep } from "./planner.js";
+import { healAndContinue } from "./mapper.js";
+import { saveToHistory } from "../core/history.js";
+import type { Post, PostResult } from "../core/types.js";
+import { join } from "node:path";
+import { PATHS } from "../core/config.js";
+
+const BROWSER_PLATFORMS: Record<string, string> = {
+  x: "https://x.com",
+  linkedin: "https://www.linkedin.com",
+};
+
+/**
+ * Doğal dil komutunu planla ve çalıştır.
+ */
+export async function runCommand(
+  platform: string,
+  command: string
+): Promise<void> {
+  const url = BROWSER_PLATFORMS[platform];
+  if (!url) {
+    console.log(`"${platform}" browser platformu değil.`);
+    return;
+  }
+
+  // 1. Plan oluştur
+  const plan = await createPlan(platform, command);
+
+  // 2. Onay al
+  console.log("");
+  const { createInterface } = await import("node:readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise<string>((resolve) => {
+    rl.question("Bu planı çalıştırayım mı? (E/h): ", (a) => { rl.close(); resolve(a.trim()); });
+  });
+
+  if (answer && answer.toLowerCase() !== "e") {
+    console.log("İptal edildi.");
+    process.exit(0);
+  }
+
+  // 3. Adımları çalıştır
+  console.log("\n[runner] Plan çalıştırılıyor...\n");
+
+  for (const [i, step] of plan.steps.entries()) {
+    console.log(`━━━ Adım ${i + 1}/${plan.steps.length}: ${step.description} ━━━`);
+
+    if (step.type === "learn_new") {
+      console.log(`[runner] Yeni aksiyon öğreniliyor: "${step.learnDescription}"`);
+      const driver = new BrowserDriver(platform, url);
+      await driver.learn(
+        step.learnDescription || step.description,
+        step.learnActionName || "custom"
+      );
+      console.log(`[runner] Öğrenildi!\n`);
+    }
+
+    const mapAction = step.type === "use_map"
+      ? step.mapAction!
+      : step.learnActionName || "custom";
+
+    const map = loadMap(platform, mapAction);
+    if (!map) {
+      console.log(`[runner] HATA: "${mapAction}" map'i bulunamadı, atlanıyor.`);
+      continue;
+    }
+
+    const repeatCount = step.repeat || 1;
+
+    for (let r = 0; r < repeatCount; r++) {
+      if (repeatCount > 1) console.log(`  [${r + 1}/${repeatCount}]`);
+
+      const post: Post = {
+        content: step.parameters["{{CONTENT}}"] || step.parameters["CONTENT"] || "",
+        platform,
+      };
+
+      const driver = new BrowserDriver(platform, url);
+      const page = await driver.launch();
+
+      try {
+        let steps = [...map.steps];
+        let stepIdx = 0;
+        let healAttempt = 0;
+
+        while (stepIdx < steps.length) {
+          const mapStep = steps[stepIdx];
+
+          // Placeholder'ları doldur - boş kalanları akıllıca handle et
+          const resolvedParams = resolveParams(step.parameters, r);
+
+          try {
+            if (mapStep.action === "goto") {
+              let gotoUrl = mapStep.url || url;
+              gotoUrl = replacePlaceholders(gotoUrl, post, resolvedParams);
+
+              // Eğer hâlâ {{...}} placeholder varsa, bu adımı atla ve ana sayfaya git
+              if (gotoUrl.includes("{{")) {
+                console.log(`    Step ${stepIdx + 1}: ${mapStep.description} (ana sayfa kullanılıyor)`);
+                await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+              } else {
+                console.log(`    Step ${stepIdx + 1}: ${mapStep.description}`);
+                await page.goto(gotoUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+              }
+              if (mapStep.waitMs) await page.waitForTimeout(mapStep.waitMs);
+            } else {
+              console.log(`    Step ${stepIdx + 1}: ${mapStep.description}`);
+              await executeMapStep(page, mapStep, post, resolvedParams);
+            }
+
+            stepIdx++;
+            healAttempt = 0; // başarılı, heal sayacını sıfırla
+          } catch (err: any) {
+            healAttempt++;
+            const efforts = ["low", "medium", "medium"];
+            const effort = efforts[Math.min(healAttempt - 1, efforts.length - 1)];
+
+            console.log(`    ✗ Hata: ${err.message}`);
+            console.log(`    [heal] AI devreye giriyor (effort: ${effort}, deneme: ${healAttempt}/3)...`);
+
+            if (healAttempt > 3) {
+              console.log(`    [heal] 3 denemede çözülemedi, atlanıyor.`);
+              break;
+            }
+
+            // Screenshot + DOM al
+            const healScreenshot = join(PATHS.screenshots, `${platform}_heal_${stepIdx}.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 (her denemede effort artar)
+            const newSteps = await healAndContinue(
+              platform,
+              stepIdx,
+              steps,
+              healScreenshot,
+              domSnap as string,
+              err.message,
+              post.content || step.description,
+              effort
+            );
+
+            steps = [...steps.slice(0, stepIdx), ...newSteps];
+            // stepIdx artırma - yeni planı deneyecek
+          }
+        }
+
+        console.log(`  ✓ Tamamlandı`);
+        saveToHistory({
+          platform,
+          content: post.content || step.description,
+          action: mapAction.includes("post") ? "post" : mapAction,
+          success: true,
+        });
+      } catch (err: any) {
+        console.log(`  ✗ Hata: ${err.message}`);
+        saveToHistory({
+          platform,
+          content: post.content || step.description,
+          action: mapAction.includes("post") ? "post" : mapAction,
+          success: false,
+          error: err.message,
+        });
+      } finally {
+        await driver.close();
+      }
+
+      // Tekrarlar arası rastgele bekleme
+      if (r < repeatCount - 1) {
+        const delay = 2000 + Math.random() * 3000;
+        console.log(`  (${(delay / 1000).toFixed(1)}s bekleniyor...)`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+
+    console.log("");
+  }
+
+  console.log("[runner] Plan tamamlandı.");
+  process.exit(0);
+}
+
+/**
+ * Parametreleri çözümle - boş olanları repeat index'e göre doldur
+ */
+function resolveParams(params: Record<string, string>, repeatIndex: number): Record<string, string> {
+  const resolved: Record<string, string> = {};
+  for (const [key, val] of Object.entries(params)) {
+    resolved[key] = val || "";
+  }
+  // Repeat index'i ekle (nth-child selector'ları için)
+  resolved["{{INDEX}}"] = String(repeatIndex + 1);
+  resolved["INDEX"] = String(repeatIndex + 1);
+  return resolved;
+}
+
+/**
+ * Placeholder'ları değiştir
+ */
+function replacePlaceholders(text: string, post: Post, params: Record<string, string>): string {
+  if (!text) return text;
+  let result = text;
+  result = result.replace("{{CONTENT}}", post.content || "");
+  for (const [key, val] of Object.entries(params)) {
+    const placeholder = key.startsWith("{{") ? key : `{{${key}}}`;
+    result = result.replace(placeholder, val);
+  }
+  return result;
+}
+
+/**
+ * Tek bir map step'ini parametrelerle çalıştır
+ */
+async function executeMapStep(
+  page: any,
+  step: any,
+  post: Post,
+  params: Record<string, string>
+): Promise<void> {
+  function rp(text: string): string {
+    return replacePlaceholders(text, post, params);
+  }
+
+  const selectors = [step.selector, ...(step.fallbackSelectors || [])]
+    .filter(Boolean)
+    .map((s: string) => rp(s));
+
+  switch (step.action) {
+    case "goto":
+      await page.goto(rp(step.url), { waitUntil: "domcontentloaded", timeout: 30000 });
+      if (step.waitMs) await page.waitForTimeout(step.waitMs);
+      break;
+
+    case "wait":
+      await page.waitForTimeout(step.waitMs || 1000);
+      break;
+
+    case "click": {
+      let clicked = false;
+
+      // Önce normal selector'ları dene
+      for (const sel of selectors) {
+        // Hâlâ çözümlenmemiş placeholder varsa atla
+        if (sel.includes("{{")) continue;
+        try {
+          await page.waitForSelector(sel, { timeout: 5000 });
+          await page.click(sel);
+          clicked = true;
+          break;
+        } catch {}
+      }
+
+      // Hiçbiri çalışmadıysa hata fırlat → heal mekanizması devreye girecek
+      // AI ekranı görüp doğru butonu bulacak
+      if (!clicked) throw new Error(`Click failed: ${selectors.join(", ")}`);
+      if (step.waitMs) await page.waitForTimeout(step.waitMs);
+      break;
+    }
+
+    case "type": {
+      const text = rp(step.value || "");
+      let typed = false;
+      for (const sel of selectors) {
+        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);
+          }
+          typed = true;
+          break;
+        } catch {}
+      }
+      if (!typed) throw new Error(`Type failed: ${selectors.join(", ")}`);
+      if (step.waitMs) await page.waitForTimeout(step.waitMs);
+      break;
+    }
+
+    case "keypress":
+      await page.keyboard.press(step.key || "Enter");
+      if (step.waitMs) await page.waitForTimeout(step.waitMs);
+      break;
+  }
+}

package/cli.ts

@@ -0,0 +1,233 @@
+import { MastodonDriver } from "./platforms/mastodon.js";
+import { BlueskyDriver } from "./platforms/bluesky.js";
+import { BrowserDriver } from "./platforms/browser/driver.js";
+import { loadConfig } from "./core/config.js";
+import { runCommand } from "./ai/runner.js";
+import { printHistory } from "./core/history.js";
+import type { Post, PostResult, PlatformDriver } from "./core/types.js";
+
+// ── Platform registry ────────────────────────────────────────
+const BROWSER_PLATFORMS: Record<string, string> = {
+  x: "https://x.com",
+  linkedin: "https://www.linkedin.com",
+};
+
+function getAllDrivers(): PlatformDriver[] {
+  const config = loadConfig();
+  const drivers: PlatformDriver[] = [];
+
+  // API-based (ücretsiz)
+  if (config.mastodon) drivers.push(new MastodonDriver());
+  if (config.bluesky) drivers.push(new BlueskyDriver());
+
+  // Browser-based (ücretli platformlar)
+  for (const [name, url] of Object.entries(BROWSER_PLATFORMS)) {
+    drivers.push({
+      name,
+      type: "browser",
+      post: (post: Post) => new BrowserDriver(name, url).post(post),
+    });
+  }
+
+  return drivers;
+}
+
+// ── Komutlar ─────────────────────────────────────────────────
+
+async function cmdLogin(platform: string) {
+  const url = BROWSER_PLATFORMS[platform];
+  if (!url) {
+    console.log(`"${platform}" browser platformu değil. Browser platformları: ${Object.keys(BROWSER_PLATFORMS).join(", ")}`);
+    return;
+  }
+  const driver = new BrowserDriver(platform, url);
+  await driver.login();
+}
+
+async function cmdLearn(taskDescription: string, platform: string) {
+  const url = BROWSER_PLATFORMS[platform];
+  if (!url) {
+    console.log(`"${platform}" browser platformu değil. Platformlar: ${Object.keys(BROWSER_PLATFORMS).join(", ")}`);
+    return;
+  }
+
+  // Görev açıklamasından aksiyon adı türet
+  const actionName = taskDescription
+    .toLowerCase()
+    .replace(/[^a-z0-9çğıöşü\s]/g, "")
+    .trim()
+    .split(/\s+/)
+    .slice(0, 3)
+    .join("_") || "custom";
+
+  const driver = new BrowserDriver(platform, url);
+  const map = await driver.learn(taskDescription, actionName);
+  console.log(`\n"${actionName}" map (${map.steps.length} adım):`);
+  for (const [i, step] of map.steps.entries()) {
+    console.log(`  ${i + 1}. [${step.action}] ${step.description} → ${step.selector || step.url || ""}`);
+  }
+}
+
+async function cmdPost(content: string, platforms?: string[], imagePaths?: string[]) {
+  const drivers = getAllDrivers();
+
+  // Platform filtresi
+  const activeDrivers = platforms?.length
+    ? drivers.filter((d) => platforms.includes(d.name))
+    : drivers;
+
+  if (!activeDrivers.length) {
+    console.log("Aktif platform yok. config.json'u kontrol et veya 'login' yap.");
+    return;
+  }
+
+  const post: Post = {
+    content,
+    images: imagePaths,
+    platform: "all",
+  };
+
+  console.log(`\nPost gönderiliyor (${activeDrivers.length} platform)...\n`);
+
+  const results: PostResult[] = [];
+  for (const driver of activeDrivers) {
+    process.stdout.write(`  [${driver.name}] `);
+    const result = await driver.post(post);
+    results.push(result);
+
+    if (result.success) {
+      console.log(`✓ ${result.url || "gönderildi"}`);
+    } else {
+      console.log(`✗ ${result.error}`);
+    }
+  }
+
+  const successCount = results.filter((r) => r.success).length;
+  console.log(`\n${successCount}/${results.length} platform başarılı.`);
+}
+
+async function cmdTest(platform: string) {
+  console.log(`[${platform}] Test postu gönderiliyor...`);
+  const testContent = `Test post - ${new Date().toLocaleString("tr-TR")} 🧪`;
+
+  const url = BROWSER_PLATFORMS[platform];
+  if (url) {
+    const driver = new BrowserDriver(platform, url);
+    const result = await driver.post({ content: testContent, platform });
+    console.log(result.success ? "✓ Başarılı!" : `✗ Hata: ${result.error}`);
+  } else {
+    const drivers = getAllDrivers();
+    const driver = drivers.find((d) => d.name === platform);
+    if (!driver) {
+      console.log(`"${platform}" platformu bulunamadı.`);
+      return;
+    }
+    const result = await driver.post({ content: testContent, platform });
+    console.log(result.success ? `✓ ${result.url}` : `✗ ${result.error}`);
+  }
+}
+
+function cmdStatus() {
+  const config = loadConfig();
+  const drivers = getAllDrivers();
+
+  console.log("\n  Platform Durumu\n  ───────────────");
+  for (const d of drivers) {
+    const icon = d.type === "api" ? "🔗" : "🌐";
+    console.log(`  ${icon} ${d.name} (${d.type})`);
+  }
+
+  if (!drivers.length) {
+    console.log("  Hiçbir platform yapılandırılmamış.");
+    console.log("  config.json düzenle veya 'login <platform>' çalıştır.");
+  }
+  console.log();
+}
+
+// ── Main ─────────────────────────────────────────────────────
+const [, , command, ...args] = process.argv;
+
+switch (command) {
+  case "login":
+    await cmdLogin(args[0] || "x");
+    break;
+
+  case "learn": {
+    // npx tsx cli.ts learn "kişileri takip etmeyi öğren" x
+    // npx tsx cli.ts learn x  → varsayılan: "post at"
+    const lastArg = args[args.length - 1];
+    const platform = BROWSER_PLATFORMS[lastArg] ? lastArg : "x";
+    const task = args.length > 1
+      ? args.slice(0, -1).join(" ")
+      : (BROWSER_PLATFORMS[args[0]] ? "yeni bir metin postu at" : args[0] || "yeni bir metin postu at");
+    await cmdLearn(task, platform);
+    break;
+  }
+
+  case "post": {
+    const content = args[0];
+    if (!content) {
+      console.log('Kullanım: tsx cli.ts post "Post metni" [--platforms x,mastodon] [--image foto.png]');
+      break;
+    }
+    const platformIdx = args.indexOf("--platforms");
+    const platforms = platformIdx > -1 ? args[platformIdx + 1]?.split(",") : undefined;
+    const imageIdx = args.indexOf("--image");
+    const images = imageIdx > -1 ? [args[imageIdx + 1]] : undefined;
+    await cmdPost(content, platforms, images);
+    break;
+  }
+
+  case "run": {
+    // npx tsx cli.ts run x "son 3 tweeti beğen ve takip et"
+    // npx tsx cli.ts run linkedin "bağlantı isteği gönder"
+    const runPlatform = BROWSER_PLATFORMS[args[0]] ? args[0] : "x";
+    const runCmd = BROWSER_PLATFORMS[args[0]]
+      ? args.slice(1).join(" ")
+      : args.join(" ");
+    if (!runCmd) {
+      console.log('Kullanım: tsx cli.ts run <platform> "doğal dil komutu"');
+      break;
+    }
+    await runCommand(runPlatform, runCmd);
+    break;
+  }
+
+  case "test":
+    await cmdTest(args[0] || "mastodon");
+    break;
+
+  case "history":
+    printHistory(parseInt(args[0]) || 20);
+    break;
+
+  case "status":
+    cmdStatus();
+    break;
+
+  default:
+    console.log(`
+  social-agent - AI destekli sosyal medya otomasyon aracı
+
+  Komutlar:
+    login <platform>                        Chrome profil seç ve giriş yap
+    learn "<görev açıklaması>" <platform>    AI ile herhangi bir aksiyonu öğret
+    run <platform> "doğal dil komutu"       AI planla + çalıştır (map'leri kombine eder)
+    post "metin"                            Post at
+      --platforms x,mastodon                  Belirli platformlara
+      --image foto.png                        Görsel ekle
+    test <platform>                         Test postu gönder
+    status                                  Bağlı platformları göster
+
+  Örnekler:
+    tsx cli.ts login x
+    tsx cli.ts learn x                                             → post atma öğren
+    tsx cli.ts learn "kişileri takip etmeyi öğren" x               → takip akışı
+    tsx cli.ts learn "tweet beğenmeyi öğren" x                     → beğeni akışı
+    tsx cli.ts run x "uiuxgorkem'in son 3 tweetini beğen"          → AI planla + çalıştır
+    tsx cli.ts run x "şu tweeti beğen ve rt yap: https://..."      → kombine aksiyon
+    tsx cli.ts run linkedin "bağlantı isteği gönder: Ahmet Yılmaz" → eksik map'i öğren + çalıştır
+    tsx cli.ts post "Yeni özellik!" --platforms x,mastodon
+    tsx cli.ts test mastodon
+`);
+}

package/core/config.ts

@@ -0,0 +1,44 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// Data dizini: SOCIAL_AGENT_DATA env var'ı veya ~/.social-agent/
+const DATA_DIR = process.env.SOCIAL_AGENT_DATA || join(homedir(), ".social-agent");
+
+export const PATHS = {
+  root: DATA_DIR,
+  maps: join(DATA_DIR, "maps"),
+  profiles: join(DATA_DIR, "profiles"),
+  screenshots: join(DATA_DIR, "screenshots"),
+  knowledge: join(DATA_DIR, "knowledge"),
+};
+
+export interface Config {
+  mastodon?: {
+    instanceUrl: string;
+    accessToken: string;
+  };
+  bluesky?: {
+    identifier: string;
+    password: string;
+  };
+  telegram?: {
+    botToken: string;
+    chatId: string;
+  };
+  browser?: {
+    chromePath?: string;
+    headless?: boolean;
+  };
+  claude?: {
+    model: string;
+  };
+}
+
+export function loadConfig(): Config {
+  const configPath = join(DATA_DIR, "config.json");
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}

package/core/history.ts

@@ -0,0 +1,96 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { PATHS } from "./config.js";
+
+const HISTORY_PATH = join(PATHS.root, "history.json");
+
+export interface PostRecord {
+  id: string;
+  timestamp: string;
+  platform: string;
+  content: string;
+  image?: string;
+  url?: string;
+  success: boolean;
+  error?: string;
+  action: string; // "post", "like", "retweet", "follow", etc.
+}
+
+export function loadHistory(): PostRecord[] {
+  if (!existsSync(HISTORY_PATH)) return [];
+  try {
+    return JSON.parse(readFileSync(HISTORY_PATH, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+export function saveToHistory(record: Omit<PostRecord, "id" | "timestamp">): PostRecord {
+  const history = loadHistory();
+  const entry: PostRecord = {
+    id: `${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+    timestamp: new Date().toISOString(),
+    ...record,
+  };
+  history.push(entry);
+  writeFileSync(HISTORY_PATH, JSON.stringify(history, null, 2));
+  return entry;
+}
+
+/**
+ * Son N postu getir (sadece başarılı olanlar, sadece post aksiyonu)
+ */
+export function getRecentPosts(count = 20): PostRecord[] {
+  return loadHistory()
+    .filter((r) => r.action === "post" && r.success)
+    .slice(-count);
+}
+
+/**
+ * Platform bazlı son postlar
+ */
+export function getRecentPostsByPlatform(platform: string, count = 10): PostRecord[] {
+  return loadHistory()
+    .filter((r) => r.platform === platform && r.action === "post" && r.success)
+    .slice(-count);
+}
+
+/**
+ * Tüm geçmişi insan-okunur formatta döndür (AI'ın üslup analizi için)
+ */
+export function getHistoryForAI(count = 15): string {
+  const posts = getRecentPosts(count);
+  if (!posts.length) return "Henüz post geçmişi yok.";
+
+  return posts
+    .map((p) => `[${p.timestamp.split("T")[0]}] [${p.platform}] ${p.content.substring(0, 200)}`)
+    .join("\n");
+}
+
+/**
+ * Geçmişi konsola yazdır
+ */
+export function printHistory(count = 20): void {
+  const history = loadHistory().slice(-count);
+
+  if (!history.length) {
+    console.log("  Henüz geçmiş yok.");
+    return;
+  }
+
+  console.log(`\n  Son ${Math.min(count, history.length)} işlem:\n  ─────────────────`);
+
+  for (const record of history) {
+    const date = new Date(record.timestamp).toLocaleString("tr-TR", {
+      day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit",
+    });
+    const icon = record.success ? "✓" : "✗";
+    const actionIcon = record.action === "post" ? "📝" : record.action === "like" ? "❤" : "▶";
+    const content = record.content ? record.content.substring(0, 60) + (record.content.length > 60 ? "..." : "") : record.action;
+
+    console.log(`  ${icon} ${actionIcon} [${date}] [${record.platform}] ${content}`);
+    if (record.url) console.log(`    → ${record.url}`);
+    if (record.error) console.log(`    ✗ ${record.error}`);
+  }
+  console.log();
+}