DEV Community: Furkan Köykıran

freqtrade-mcp: Bota Claude Üzerinden Sor

Furkan Köykıran — Sat, 04 Apr 2026 14:14:52 +0000

Freqtrade botu çalıştırıyorum. Stratejim var, bot işini yapıyor, benim müdahaleye gerek yok. Teorikte.

Pratikte gece 23'te ekrana bakıyorum.

Bir şey kaybetmiş miyim? Yoksa bir fırsat mı kaçtı? Bot kapanmış mıdır? Aynı bakiyeyi görüyorum ama "acaba" duygusu geçmiyor. FreqUI'yı açıyorum, sekmelere tıklıyorum, rakamları görüyorum, kapatıyorum. On beş dakika sonra tekrar açıyorum.

Bu süreci kısaltmak için @furkankoykiran/freqtrade-mcp'yi yazdım — Freqtrade'in REST API'sini Claude'a açan, 15 araçlık bir TypeScript MCP sunucusu. Claude Desktop, Cursor, Cline, Model Context Protocol konuşan her şeyle çalışıyor.

Artık FreqUI açmak yerine Claude'a soruyorum. Cevap geliyor. Geçiyorum.

Freqtrade — artık açmak zorunda kalmadan da bilgi alabilirsin.

Neye Yarıyor

Portföy Durumu

Gece 23'teki sorular genellikle bunlar:

"Bu ay net pozitif miyim, yoksa bakmamak mı lazım?"

"Şu an ne kadar USDT açık pozisyonda, ne kadarı boşta bekliyor?"

"Hangi çiftler iyi gidiyor?"

get_profit_stats, get_balance, get_performance bunları karşılıyor. Claude ham JSON'ı okunaklı hale getiriyor. Sayıları kendin çözmeye çalışmak zorunda kalmıyorsun.

Pozisyonlar

"Açık işlemler ne durumda, zararda olan var mı?"

"42 numaralı işlem — açılış tarihi ne, şu anki K/Z ne?"

"Son 10 kapanan işlemi göster."

Bot aynı anda onlarca pozisyon taşıyabiliyor. Her satırı kendin okumak yerine Claude'a sormak çok daha hızlı. Sonuç doğrudan geliyor.

Piyasa Verisi

"BTC/USDT 4 saatlik, son 50 mum."

"ETH/USDT şu an 1 saatlikte nasıl görünüyor?"

get_market_data canlı OHLCV verisini doğrudan borsadan çekiyor. Claude grafiğe bakıp bir yorum yapabilir. Ne yapacağın sana kalmış.

Freqtrade'in analiz ekranı — MCP sunucusu da aynı veriyi anlık çekiyor.

Liste Yönetimi

"LUNA/USDT'yi kara listeye ekle."

"Beyaz listede ne var? BNB/BTC'yi kara listeden çıkar."

Normalde ya config dosyasını editliyorsun ya da FreqUI'da menüler arasında geziniyorsun. Şimdi tek cümle.

Manuel İşlem

"Şu an 100 USDT ETH al."

"BTC/USDT'de 50 USDT ile short aç."

"7 numaralı işlemi kapat."

execute_trade ve force_exit_trade strateji beklemeden anında çalışıyor.

Önemli: Gerçek borsa, gerçek para, geri alınmıyor. "Dikkatli ol" burada gerçekten önemli. Onay ekranı yok, borsa "test ediyordum" demeyi tanımıyor.

Bot Yönetimi

"Botu durdur, config değiştirecektim."

"Yeniden başlatmadan config'i yenile."

"Bot son ne zaman çalıştı, hâlâ ayakta mı?"

get_bot_info sürüm ve sağlık verisini bir arada veriyor. Botun gerçekten çalışıp çalışmadığını öğrenmek için FreqUI açmana gerek kalmıyor.

Kurulum

Freqtrade config.json içinde REST API'yi etkinleştir (varsayılan olarak kapalı gelir), ardından Claude Desktop config'ine ekle:

{
  "mcpServers": {
    "freqtrade": {
      "command": "npx",
      "args": ["-y", "@furkankoykiran/freqtrade-mcp"],
      "env": {
        "FREQTRADE_API_URL": "http://127.0.0.1:8080",
        "FREQTRADE_USERNAME": "Freqtrader",
        "FREQTRADE_PASSWORD": "YourPassword"
      }
    }
  }
}

Claude Desktop'ı yeniden başlat. 15 araç hazır, build adımı yok.

Araçlar

Kategori	Araçlar
Hesap	`get_profit_stats`, `get_balance`, `get_performance`
İşlemler	`get_open_trades`, `get_trade`, `get_trade_history`
Piyasa Verisi	`get_market_data`
Çift Listeleri	`get_whitelist`, `get_blacklist`, `add_to_blacklist`, `remove_from_blacklist`
İşlem Açma	`execute_trade`, `force_exit_trade`
Bot Yönetimi	`start_bot`, `stop_bot`, `reload_config`, `get_bot_info`, `get_locks`, `delete_lock`

Sonuç

Temelde şunu çözmek istedim: FreqUI'yı açmadan bota bakabileyim. REST API zaten oradaydı, sadece arayüzün arkasına gömülüydü.

Artık Claude'a soruyorum. O söylüyor. Geçiyorum.

Pek tabii "acaba değişmiş mi" duygusu hâlâ geçmiyor, ama en azından sormak kolaylaştı.

Proje açık kaynak ve MIT lisanslı. Freqtrade REST API kurulumu dahil tam kılavuz README'de.

github.com/furkankoykiran/freqtrade-mcp

Bu yazı DevTo-MCP aracılığıyla DEV.to'ya gönderilmiştir.

freqtrade-mcp: Ask Claude to Check Your Trades

Furkan Köykıran — Sat, 04 Apr 2026 14:14:38 +0000

I run a Freqtrade bot. Like most people who run trading bots, I tell myself I'm "not constantly checking it" — and then check it constantly.

The ritual: open browser, log into FreqUI, click through tabs, squint at numbers, close browser, reopen browser 10 minutes later. It adds up.

At some point I thought: I already have Claude open. Why am I switching contexts to a UI when the bot has a perfectly good REST API?

So I built @furkankoykiran/freqtrade-mcp — a TypeScript MCP server with 15 tools that lets you ask Claude what your bot is doing. Works with Claude Desktop, Cursor, Cline, anything that speaks Model Context Protocol. You ask in plain English. The bot answers.

Yes, I built an AI wrapper around my trading bot so I can talk to it through a different AI. I'm at peace with this.

The Freqtrade trading interface — now accessible via natural language through Claude.

What You Can Do

Portfolio & Performance

The questions I actually ask my bot, at various hours of the day:

"How much profit have I made total? Please be honest."

"What's my current balance — how much is deployed vs sitting in USDT doing nothing?"

"Which pairs are performing well? Show me the top 5 so I can feel better about my decisions."

"Am I net positive this month or should I not look?"

get_profit_stats, get_balance, and get_performance handle all of these. Claude gets back structured JSON from the Freqtrade API and gives you a readable summary instead of making you parse numbers yourself at 11pm.

Open Trades & History

"What trades are open right now? Any in the red that I should know about?"

"Show me trade #42 — when did it open, what's the P/L, and should I be worried?"

"Give me the last 10 closed trades."

The bot can have dozens of open positions at once. Scanning a raw JSON blob yourself at midnight is not the move. Claude summarizes it. You move on.

Market Data on Demand

"Fetch the last 50 BTC/USDT candles on the 4h timeframe."

"What does the ETH/USDT 1h chart look like right now?"

The get_market_data tool pulls live OHLCV data directly from the exchange through Freqtrade. Ask Claude what the 4h chart looks like right now. It'll tell you something. Whether you should act on it is your problem.

Freqtrade's strategy analysis interface — the same data the MCP server can fetch on demand.

Pair List Management

"Add LUNA/USDT to the blacklist."

"What's currently on my whitelist? Remove BNB/BTC from the blacklist."

Normally this means editing a JSON config file, reloading, and hoping you didn't break anything. Or navigating FreqUI through three menu levels to find the right panel. With the MCP server it's a sentence. Done.

Manual Trade Execution

"Buy 100 USDT of ETH right now."

"Open a short on BTC/USDT with a 50 USDT stake."

"Exit trade #7 at market price."

execute_trade and force_exit_trade bypass strategy signals entirely — useful when you want to act on something the bot wouldn't otherwise touch.

Note: This executes immediately against the live exchange. "Use with intention" is doing a lot of heavy lifting in that sentence. No confirmation dialog. No undo. The exchange doesn't care that you were just testing the API.

Bot Lifecycle

"Stop the bot — I need to edit the config before it does something."

"Reload the config without restarting, the bot is mid-cycle."

"What version is the bot on? Did it run recently or has it been sitting there silently failing?"

Stopping a live trading bot always feels slightly dramatic. One call handles it. get_bot_info combines version and health data so you know whether the bot is actually running or just pretending to be.

Setup

Enable the REST API in your Freqtrade config.json (it's off by default, for good reason), then add the server to your Claude Desktop config:

{
  "mcpServers": {
    "freqtrade": {
      "command": "npx",
      "args": ["-y", "@furkankoykiran/freqtrade-mcp"],
      "env": {
        "FREQTRADE_API_URL": "http://127.0.0.1:8080",
        "FREQTRADE_USERNAME": "Freqtrader",
        "FREQTRADE_PASSWORD": "YourPassword"
      }
    }
  }
}

Restart Claude Desktop. All 15 tools show up immediately, no build step required.

Available Tools

Category	Tools
Account	`get_profit_stats`, `get_balance`, `get_performance`
Trades	`get_open_trades`, `get_trade`, `get_trade_history`
Market Data	`get_market_data`
Pair Lists	`get_whitelist`, `get_blacklist`, `add_to_blacklist`, `remove_from_blacklist`
Execution	`execute_trade`, `force_exit_trade`
Lifecycle	`start_bot`, `stop_bot`, `reload_config`, `get_bot_info`, `get_locks`, `delete_lock`

Conclusion

The honest version: I was tired of opening FreqUI to check one number. The REST API was already there, just buried behind a browser tab I had to switch to.

Now I ask Claude. It tells me. I close the laptop slightly less anxious than before.

The project is open source and MIT licensed. The README has the full setup guide, including how to configure the Freqtrade REST API if you haven't done that yet.

github.com/furkankoykiran/freqtrade-mcp

This article was published to DEV.to via DevTo-MCP.

awesome-trending-repos: Modern Web Interface for GitHub Trending

Furkan Köykıran — Fri, 27 Mar 2026 20:12:20 +0000

In my previous blog post, I introduced the awesome-trending-repos project. Back then, the project only wrote data to a README.md file. Things have changed. The project is now a fully functional modern web application.

Automated build and deployment process with GitHub Actions

Why a Web Interface?

A README.md file works, but it's static. To track trending projects effectively, I wanted a more interactive experience. Users needed to be able to filter by programming language, search repositories, and see data visualized with charts.

So I built a modern single-page application (SPA) with React + Vite.

Tech Stack

Frontend:

React 19 - Latest version
Vite - Fast dev server and build tool
Tailwind CSS v4 - Utility-first styling
Framer Motion - Animations
Recharts - Data visualization

Backend/Infrastructure:

GitHub Actions - Automation
GitHub Pages - Hosting
Custom Domain - furkankoykiran.com.tr

Project Structure

The core project structure:

awesome-trending-repos/
├── src/
│   ├── App.jsx          # Main React component
│   ├── main.jsx         # Entry point
│   └── index.css        # Tailwind + custom styles
├── scripts/
│   └── update.js        # Trending data scrape script
├── public/
│   ├── data/
│   │   └── trending.json # Frontend data source
│   └── logo.png
├── .github/workflows/
│   └── update-trends.yml # CI/CD pipeline
└── vite.config.js       # GitHub Pages config

GitHub Pages Integration

When using Vite with GitHub Pages, the most important configuration is the base path. If your project runs in a subdirectory (e.g., github.io/repo-name), you must specify this in vite.config.js:

// vite.config.js
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import tailwindcss from '@tailwindcss/vite';

export default defineConfig({
  plugins: [react(), tailwindcss()],
  base: '/awesome-trending-repos/', // GitHub Pages subdirectory
});

Without this setting, asset paths will break in production and you'll get 404 errors.

GitHub Actions Workflow

The workflow runs every day at midnight UTC:

Fetch trending data - Scrape GitHub Trending page
Build frontend - Create dist/ folder with npm run build
Commit data - Commit README and data files if changed
Deploy - Distribute to GitHub Pages

# .github/workflows/update-trends.yml
name: Update and Deploy Trends

on:
  schedule:
    - cron: '0 0 * * *'  # Daily at midnight
  workflow_dispatch:

permissions:
  contents: write
  pages: write
  id-token: write

jobs:
  update-and-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm ci

      - name: Run update script
        run: npm run update
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Build frontend
        run: npm run build

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: './dist'

  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    needs: update-and-build
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

Automated deployment flow

Frontend Features

1. Language Filtering

Users can filter by programming language:

const languages = ['All', ...new Set(repos.map(r => r.language).filter(Boolean))];

const filteredRepos = repos.filter(repo => {
  const matchesLang = filter === 'All' || repo.language === filter;
  const matchesSearch = repo.name.toLowerCase().includes(searchQuery.toLowerCase());
  return matchesLang && matchesSearch;
});

2. Search Function

Real-time search across repo name, owner, and description.

3. Visual Statistics

Recharts library for language distribution bar chart and growth leaders list:

<ResponsiveContainer width="100%" height="100%">
  <BarChart data={data?.insights?.topLanguages || []}>
    <CartesianGrid strokeDasharray="8 8" stroke="#ffffff03" />
    <XAxis dataKey="language" stroke="#475569" />
    <YAxis stroke="#475569" />
    <Tooltip contentStyle={{ backgroundColor: 'rgba(15, 23, 42, 0.9)' }} />
    <Bar dataKey="count" radius={[12, 12, 0, 0]}>
      {data?.insights?.topLanguages?.map((entry, index) => (
        <Cell key={index} fill={getLangColor(entry.language)} />
      ))}
    </Bar>
  </BarChart>
</ResponsiveContainer>

4. Deployment Feed

A feed entry is created for each update. Users can see the deployment history.

Custom Domain Setup

To use a custom domain with GitHub Pages:

Create CNAME file - Add your domain to public/CNAME:

   furkankoykiran.com.tr

DNS setting - At your domain provider:

   CNAME furkankoykiran.github.io

HTTPS - GitHub Pages automatically provides SSL with Let's Encrypt.

Performance Tips

1. Asset Optimization

Vite production build automatically does minification and tree-shaking. For large images, consider using optimized images instead of putting everything in public/.

2. Lazy Loading

For large lists, consider virtual scrolling. Not needed for this project with 25 repos, but good to know if you scale.

3. Caching

GitHub Pages automatically adds cache headers. For index.html, use cache-busting:

// vite.config.js
export default defineConfig({
  build: {
    rollupOptions: {
      output: {
        entryFileNames: `assets/[name].[hash].js`,
        chunkFileNames: `assets/[name].[hash].js`,
        assetFileNames: `assets/[name].[hash].[ext]`
      }
    }
  }
});

Live Demo

The project is currently live at furkankoykiran.com.tr/awesome-trending-repos. It updates automatically every day.

Project logo

Open Graph preview image

Conclusion

Moving from a README.md to a modern web application significantly improved the project's usability. Users now have an interactive experience instead of just a static list.

The GitHub Pages + Vite combination is an excellent solution for static sites. Free, fast, and fully automated with CI/CD.

The project is fully open source. If you want to contribute, send a pull request to the GitHub repo.

Source: blog.furkankoykiran.com.tr

awesome-trending-repos: GitHub Trending için Modern Web Arayüzü

Furkan Köykıran — Fri, 27 Mar 2026 20:12:18 +0000

Önceki blog yazımda awesome-trending-repos projesinden bahsetmiştim. O zamanlar proje sadece README.md dosyasına veri yazıyordu. Artık things changed. Proje artık tam fonksiyonlu bir modern web uygulaması.

GitHub Actions ile otomatik build ve deploy süreci

Neden Web Arayüzü?

README.md dosyası işe yarar ama statiktir. Trending projeleri takip etmek için daha interaktif bir deneyim istedim. Kullanıcıların dil bazlı filtreleme yapabilmesi, arama yapabilmesi ve grafiklerle verileri görebilmesi gerekliydi.

Bu yüzden React + Vite ile modern bir single-page application (SPA) geliştirdim.

Tech Stack

Frontend:

React 19 - Son sürüm
Vite - Hızlı dev server ve build
Tailwind CSS v4 - Utility-first styling
Framer Motion - Animasyonlar
Recharts - Veri görselleştirme

Backend/Infrastructure:

GitHub Actions - Otomasyon
GitHub Pages - Hosting
Custom Domain - furkankoykiran.com.tr

Proje Yapısı

Projenin temel dizini şöyle:

awesome-trending-repos/
├── src/
│   ├── App.jsx          # Ana React bileşeni
│   ├── main.jsx         # Entry point
│   └── index.css        # Tailwind + custom styles
├── scripts/
│   └── update.js        # Trending veri scrape script
├── public/
│   ├── data/
│   │   └── trending.json # Frontend veri kaynağı
│   └── logo.png
├── .github/workflows/
│   └── update-trends.yml # CI/CD pipeline
└── vite.config.js       # GitHub Pages config

GitHub Pages Entegrasyonu

Vite ile GitHub Pages kullanırken en önemli nokta base path konfigürasyonudur. Projeniz bir subdirectory'de çalışacaksa (örn: github.io/repo-name), vite.config.js dosyasında bunu belirtmelisiniz:

// vite.config.js
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import tailwindcss from '@tailwindcss/vite';

export default defineConfig({
  plugins: [react(), tailwindcss()],
  base: '/awesome-trending-repos/', // GitHub Pages subdirectory
});

Bu ayar olmadan, production'da asset path'leri bozulur ve 404 hatası alırsınız.

GitHub Actions Workflow

Her gün gece yarısı UTC'de çalışan workflow:

Trending verisi çek - GitHub Trending sayfasını scrape et
Frontend build - npm run build ile dist/ klasörünü oluştur
Data commit - Değişiklik varsa README ve data dosyalarını commit et
Deploy - GitHub Pages'e dağıt

# .github/workflows/update-trends.yml
name: Update and Deploy Trends

on:
  schedule:
    - cron: '0 0 * * *'  # Her gün gece yarısı
  workflow_dispatch:

permissions:
  contents: write
  pages: write
  id-token: write

jobs:
  update-and-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm ci

      - name: Run update script
        run: npm run update
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Build frontend
        run: npm run build

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: './dist'

  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    needs: update-and-build
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

Otomatik deployment akışı

Frontend Özellikleri

1. Dil Filtreleme

Kullanıcılar programlama diline göre filtreleme yapabilir:

const languages = ['All', ...new Set(repos.map(r => r.language).filter(Boolean))];

const filteredRepos = repos.filter(repo => {
  const matchesLang = filter === 'All' || repo.language === filter;
  const matchesSearch = repo.name.toLowerCase().includes(searchQuery.toLowerCase());
  return matchesLang && matchesSearch;
});

2. Arama Fonksiyonu

Real-time arama ile repo ismi, owner veya description'da arama yapılır.

3. Görsel İstatistikler

Recharts kütüphanesi ile dil dağılımı bar chart ve growth liderleri listesi:

<ResponsiveContainer width="100%" height="100%">
  <BarChart data={data?.insights?.topLanguages || []}>
    <CartesianGrid strokeDasharray="8 8" stroke="#ffffff03" />
    <XAxis dataKey="language" stroke="#475569" />
    <YAxis stroke="#475569" />
    <Tooltip contentStyle={{ backgroundColor: 'rgba(15, 23, 42, 0.9)' }} />
    <Bar dataKey="count" radius={[12, 12, 0, 0]}>
      {data?.insights?.topLanguages?.map((entry, index) => (
        <Cell key={index} fill={getLangColor(entry.language)} />
      ))}
    </Bar>
  </BarChart>
</ResponsiveContainer>

4. Deployment Feed

Her güncelleme için bir feed entry oluşturulur. Kullanıcılar deployment tarihçesini görebilir.

Custom Domain Ayarı

GitHub Pages için custom domain kullanmak istersen:

CNAME dosyası oluştur - public/CNAME içine domain yaz:

   furkankoykiran.com.tr

DNS ayarı - Domain provider'ında:

   CNAME furkankoykiran.github.io

HTTPS - GitHub Pages otomatik olarak Let's Encrypt ile SSL sağlar.

Performans İpuçları

1. Asset Optimization

Vite production build otomatik olarak minification ve tree-shaking yapar. Büyük resimler için public/ klasörü yerine optimized image kullanın.

2. Lazy Loading

Büyük listeler için virtual scrolling kullanmayı düşünün. Bu projede 25 repo olduğu için gerekli değil ama scale ederseniz eklenebilir.

3. Caching

GitHub Pages otomatik olarak cache headers ekler. Ancak index.html için cache-busting kullanın:

// vite.config.js
export default defineConfig({
  build: {
    rollupOptions: {
      output: {
        entryFileNames: `assets/[name].[hash].js`,
        chunkFileNames: `assets/[name].[hash].js`,
        assetFileNames: `assets/[name].[hash].[ext]`
      }
    }
  }
});

Canlı Demo

Proje şu anda furkankoykiran.com.tr/awesome-trending-repos adresinde yayında. Her gün otomatik olarak güncelleniyor.

Proje logosu

Open Graph preview görseli

Sonuç

README.md'den modern web uygulamasına geçiş, projenin kullanılabilirliğini önemli ölçüde artırdı. Kullanıcılar artık sadece statik bir liste yerine interaktif bir deneyim yaşıyor.

GitHub Pages + Vite kombinasyonu, static siteler için harika bir çözüm. Ücretsiz, hızlı ve CI/CD ile tam otomatik.

Proje tamamen açık kaynak. Katkı yapmak isterseniz GitHub repo'ya pull request gönderebilirsiniz.

Kaynak: blog.furkankoykiran.com.tr

Adding Browser Automation to CLI-Anything: First MCP Backend Pattern

Furkan Köykıran — Sun, 22 Mar 2026 22:40:08 +0000

Browser automation is genuinely interesting. AI agents navigating websites, filling forms - it's not just nice to have anymore. I recently contributed browser automation support to CLI-Anything via DOMShell's MCP server. Here's how it went.

From Issue #90 to PR #118

On March 16, @apireno opened #90 with a compelling idea: "CLI wrappers make software agent-native" - and this should work for browsers too.

They mentioned DOMShell, which maps Chrome's Accessibility Tree to a virtual filesystem. Agents control the browser with ls, cd, grep, click - shell commands, not DOM queries. The benchmark was solid: 50% fewer API calls than screenshot-based browsing in Claude tests.

What is the Accessibility Tree?

The Accessibility Tree is what the browser derives from DOM for screen readers. It's simpler, semantic. Elements are classified by role - button, link, textbox. More stable than DOM, more understandable for agents.

DOMShell's insight: filesystem primitives beat DOM queries. ls and grep instead of querySelector and getElementById. Agents explore faster, call fewer APIs.

On March 21, based on @omerarslan0's proposal, I created #118. This became CLI-Anything's first MCP server backend pattern.

# How it looks
cli-anything-browser page open https://example.com
cli-anything-browser fs ls /
cli-anything-browser fs cd /main
cli-anything-browser fs grep "Login"
cli-anything-browser act click /main/button[0]

Architecture

Most CLI-Anything harnesses call backend APIs directly. This one was different: MCP Server integration.

MCP Backend Pattern

No CLI-Anything harness had used an MCP server before. The Python SDK implementation:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server_params = StdioServerParameters(
    command="npx",
    args=["@apireno/domshell"]
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        result = await session.call_tool("domshell_ls", {"path": "/"})

MCP server is stateless. Each command spawns a new subprocess. State (URL, working directory, history) lives on the CLI side.

Commands

Four main groups: page (open, reload, back, forward, info), fs (ls, cd, cat, grep, pwd), act (click, type), and session (status, daemon-start, daemon-stop).

Daemon Mode

Spawning npx for every command costs 1-3 seconds. Daemon mode keeps a persistent connection. The difference is noticeable.

cli-anything-browser session daemon-start
# All commands use the same connection now
cli-anything-browser fs ls /
cli-anything-browser session daemon-stop

Testing

I went with a multi-layered approach. Unit tests (31 total) mocked MCP responses, tested path resolution and state management. No Chrome required.

E2E tests (10 total) needed Chrome + DOMShell extension, tested against real pages. Tests skip when DOMShell isn't installed, so CI/CD doesn't break.

Review Process

After submitting, @omerarslan0 did a thorough review. I got 9 feedback items. The critical ones:

Daemon mode context manager leak - Fixed with _daemon_client_context global
go_back()/go_forward() - Switched from local history to native MCP tools
REPL quoted arguments - Fixed with shlex.split(), quoted arguments parse correctly now
Security - act type no longer echoes typed text, passwords don't leak into terminal scrollback

Merge

The PR merged on March 22. 3,095 additions, 21 files changed, 15 commits. This became CLI-Anything's reference implementation for MCP backend patterns - a template for future integrations.

The browser harness went into CLI-Hub:

{
  "name": "browser",
  "display_name": "Browser",
  "version": "1.0.0",
  "description": "Browser automation via DOMShell MCP server",
  "requires": "Node.js, npx, Chrome + DOMShell extension",
  "homepage": "https://github.com/apireno/DOMShell",
  "install_cmd": "pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=browser/agent-harness",
  "entry_point": "cli-anything-browser",
  "category": "web",
  "contributor": "furkankoykiran"
}

What I Learned

MCP Python SDK: stdio transport with subprocess, async-to-sync wrapper, tool calling patterns.

Accessibility Tree vs DOM: More stable, less fragile, ideal for agents.

Open Source: Issue to implementation, managing review feedback, documentation, test coverage.

Daemon Mode: Context manager lifecycle, state persistence, event loop limitations.

Future

I left out of V1: screenshot capture, wait-for-element, form fill helper, headless mode, multi-browser (Firefox, Safari), concurrent MCP operations.

@apireno suggested eval and js escape hatches for when elements don't have clean AX representations - good additions for a follow-up.

This contribution did more than add browser automation to CLI-Anything. It established a pattern for MCP server integrations. The "MCP Backend Pattern" section I added to cli-anything-plugin/HARNESS.md will guide other developers.

Implementing a new pattern in open source is interesting work. The feedback from @omerarslan0, @yuh-yang, and @apireno during review made this better.

References:

This post was submitted to DEV.to via DevTo-MCP

CLI-Anything'e Tarayıcı Otomasyon Desteği: MCP Backend Pattern İlk Uygulama

Furkan Köykıran — Sun, 22 Mar 2026 22:40:06 +0000

Tarayıcı otomasyonu gerçekten ilginç bir problem. AI ajanlarının web sitelerinde gezinebilmesi, formları doldurabilmesi artık sadece "iyi sahip olmak" değil, zorunluluk. CLI-Anything projesine yaptığım browser support katkısını burada anlatacağım.

Issue #90'dan PR #118'e

Her şey 16 Mart 2026'da @apireno'nin #90 numaralı issue'sını açmasıyla başladı. Ana fikir şuydu: "CLI wrapper'lar yazılımı ajan-native yapıyor" ve bunun tarayıcılar için de geçerli olabileceği.

@apireno, DOMShell projesinden bahsetti. DOMShell, Chrome'un Accessibility Tree'sini sanal bir dosya sistemine çeviriyor. Ajanlar ls, cd, grep, click gibi komutlarla tarayıcıyı kontrol edebiliyor. Benchmark sonuçları ilginçti: screenshot tabanlı yaklaşıma göre %50 daha az API çağrısı.

Accessibility Tree Nedir?

Accessibility Tree, tarayıcının DOM'dan ürettiği ama daha sade bir yapı. Ekran okuyucular için var bu yapı. Öğeleri rollerine göre sınıflandırıyor - button, link, textbox gibi. Ajanlar için de ideal aslında, stabil ve anlaşılır.

DOMShell'in mantığı basitti: Filesystem primitives (ls, cd, grep) DOM query'lerden daha verimli. Ajanlar sayfayı gezerken daha az çağrı yapıyor, daha hızlı ulaşıyor hedefe.

21 Mart'ta @omerarslan0'nın önerdiği modeli temel alarak PR'ı oluşturdum. Bu, CLI-Anything'in ilk MCP server backend pattern'idi.

# Kullanım örneği
cli-anything-browser page open https://example.com
cli-anything-browser fs ls /
cli-anything-browser fs cd /main
cli-anything-browser fs grep "Login"
cli-anything-browser act click /main/button[0]

Mimari

Diğer harness'lar genellikle doğrudan backend API çağrısı yapıyor. Bu sefer durum farklıydı: MCP Server entegrasyonu.

MCP Backend Pattern

Bu CLI-Anything için yeni bir patterndi. Öncesinde hiçbir harness MCP server kullanmamıştı. Python SDK implementasyonu:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server_params = StdioServerParameters(
    command="npx",
    args=["@apireno/domshell"]
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        result = await session.call_tool("domshell_ls", {"path": "/"})

Ana fark şu: MCP server stateless. Her komutta yeni subprocess başlıyor. State (URL, working directory, history) CLI tarafında tutuluyor.

Command Groups

Implementasyon 4 ana group içeriyordu:

page: open, reload, back, forward, info - Sayfa navigasyonu
fs: ls, cd, cat, grep, pwd - Dosya sistemi tarzı gezinme
act: click, type - Etkileşim
session: status, daemon-start, daemon-stop - Oturum yönetimi

Daemon Mode

Her komutta npx subprocess başlatmak 1-3 saniye kaybettiriyor. Daemon mode ile kalıcı bağlantı kuruyorsun. İnteraktif kullanımda fark hissediliyor.

Testler

Üç katmanlı test stratejisi uyguladım. Unit tests 31 taneydi - MCP backend response'ları mock'lanıyor, path resolution ve state management test ediliyordu. Chrome gerekmiyordu.

E2E tests 10 taneydi. Chrome + DOMShell extension gerekiyordu. Gerçek sayfalarda test ediyordu. DOMShell yoksa testler skip oluyordu, böylece CI/CD patlamıyordu.

Review Süreci

PR'ı gönderdikten sonra @omerarslan0 review yaptı. 9 maddelik feedback aldım. En kritikleri:

Daemon mode context manager leak - _daemon_client_context global değişkeni ile düzeltildi
go_back()/go_forward() - Native MCP tool'ları kullanıldı
REPL quoted arguments - shlex.split() ile düzeltildi, tırnaklı argümanlar artık doğru parse ediliyor
Security - act type artık typed text'i echo etmiyor, passwordler terminal scrollback'de kalmıyor

Merge ve Sonuç

22 Mart'ta PR merge edildi. 3,095 satır ekleme, 21 dosya değişti, 15 commit. Bu, CLI-Anything'in ilk MCP backend pattern referans implementasyonu. Gelecekteki MCP entegrasyonları için bir template olacak.

Browser harness CLI-Hub'a eklendi ve artık kullanıma hazır.

Öğrendiklerim

MCP Python SDK

stdio transport ile subprocess communication, async → sync wrapper, tool calling pattern'leri.

Accessibility Tree vs DOM

Accessibility Tree daha stabil. DOM query'lerden daha az kırılgan. Agent navigation için ideal.

Open Source

Issue'dan implementasyona geçiş, review feedback yönetimi, documentation update'leri, test coverage önemi.

Bu katkı sadece bir browser harness değil, aynı zamanda gelecekteki MCP entegrasyonları için bir referans pattern oluşturdu. cli-anything-plugin/HARNESS.md'ye eklenen MCP Backend Pattern bölümü, diğer geliştiricilere rehber olacak.

Referanslar:

Bu yazı DevTo-MCP aracılığıyla DEV.to'ya gönderilmiştir.

My Keploy Contribution: Resource Management in Go and Open Source Journey

Furkan Köykıran — Sat, 21 Mar 2026 00:27:26 +0000

While tracking popular repositories on GitHub trending with my awesome-trending-repos project, I came across Keploy, a modern API testing tool written in Go. While exploring the codebase, I found a couple of resource management bugs that I could fix.

Keploy is a modern tool for automated testing and mock generation for APIs, Integration, and E2E tests.

What is Keploy?

Keploy is an open-source tool for API and integration testing. It provides features like mock creation and test generation, and has over 8k stars on GitHub. It integrates with VSCode through an extension.

The VSCode extension allows Keploy to manage tests and mocks directly from the IDE.

While examining the codebase, I noticed some common resource management mistakes in Go. I fixed these issues with two separate PRs.

PR #3927: The Use-After-Close Bug

Discovering the Problem

While browsing the project's GitHub issues, I came across #3821, which reported a bug in the isGoBinary function in utils/utils.go. The file was being opened and immediately closed, then operations were performed on the closed file.

// BUGGY CODE
f, err := elf.Open(filePath)
if err != nil {
    logger.Debug(fmt.Sprintf("failed to open file %s", filePath), zap.Error(err))
    return false
}
if err := f.Close(); err != nil {  // ❌ Closed immediately
    LogError(logger, err, "failed to close file", zap.String("file", filePath))
}
// Then operating on the closed file
sections := []string{".go.buildinfo", ".gopclntab"}
for _, section := range sections {
    if sect := f.Section(section); sect != nil {  // ❌ Use-after-close
        fmt.Println(section)
        return true
    }
}

This causes what's known as a "use-after-close" error in Go. After the file is closed, the file descriptor is no longer valid.

The Solution: Defer Pattern

In Go, the defer pattern is used to solve this problem. A statement prefixed with defer is executed just before the function returns. This ensures that the resource is cleaned up regardless of how the function exits (early return, panic, or normal return).

// FIXED CODE
f, err := elf.Open(filePath)
if err != nil {
    logger.Debug(fmt.Sprintf("failed to open file %s", filePath), zap.Error(err))
    return false
}
defer func() {
    if err := f.Close(); err != nil {
        LogError(logger, err, "failed to close file", zap.String("file", filePath))
    }
}()
// File is now open, can read sections
sections := []string{".go.buildinfo", ".gopclntab"}
for _, section := range sections {
    if sect := f.Section(section); sect != nil {
        return true
    }
}

Code Review Feedback

I received feedback from the Copilot code reviewer. Using defer f.Close() directly would ignore the error returned by Close(). This didn't match the pattern used elsewhere in the repository.

I addressed the feedback by wrapping the defer in a closure and adding error handling:

defer func() {
    if err := f.Close(); err != nil {
        LogError(logger, err, "failed to close file", zap.String("file", filePath))
    }
}()

PR #3927 was successfully merged.

PR #3932: HTTP Response Body Leak

Discovering the Problem

I found issue #3854 on the project's tracker, which reported that in pkg/platform/http/agent.go, the MockOutgoing and UpdateMockParams functions were not closing HTTP response bodies after making requests.

// BUGGY CODE
res, err := a.client.Do(req)
if err != nil {
    return fmt.Errorf("failed to send request: %s", err.Error())
}
// Body not closed! ❌

var mockResp models.AgentResp
err = json.NewDecoder(res.Body).Decode(&mockResp)

This leads to several problems:

Resource Leak: Unclosed bodies cause memory leaks
Connection Pool Exhaustion: The HTTP client's connection pool gets exhausted
Port Exhaustion: Many open connections can consume system ports

The Solution: Defer Close + Drain Pattern

Go's http package documentation states that the caller is responsible for closing the response body. If the body is not closed, the underlying TCP connection cannot be returned to the connection pool, and a new connection must be created for each request.

// FIXED CODE
res, err := a.client.Do(req)
if err != nil {
    return fmt.Errorf("failed to send request: %s", err.Error())
}
defer func() {
    io.Copy(io.Discard, res.Body)  // Drain body to EOF
    if err := res.Body.Close(); err != nil {
        utils.LogError(a.logger, err, "failed to close response body")
    }
}()

var mockResp models.AgentResp
err = json.NewDecoder(res.Body).Decode(&mockResp)

Here we do two important things:

io.Copy(io.Discard, res.Body): We read and discard the body until EOF. This allows the connection to be reused because the JSON decoder might not have read the entire body.
res.Body.Close(): We close the body and log any errors.

Why Drain the Body?

An important detail I learned from the Copilot reviewer: json.Decoder.Decode() doesn't guarantee reading the entire body. If there are unread bytes in the body and we close it directly, the HTTP client cannot reuse the connection (keep-alive won't work).

By draining the body with io.Copy(io.Discard, res.Body) to EOF, the connection can be returned to the pool for reuse.

PR #3932 was successfully merged.

Go Resource Management Best Practices

These two PRs taught me important lessons about resource management in Go:

1. Using the Defer Pattern

// File operations
file, err := os.Open("file.txt")
if err != nil {
    return err
}
defer file.Close()

// Mutex locking
mu.Lock()
defer mu.Unlock()

// Database transaction
tx, err := db.Begin()
if err != nil {
    return err
}
defer tx.Rollback()  // Rollback if not committed

2. Error Handling in Defer

// ❌ Error is ignored
defer file.Close()

// ✅ Error is handled
defer func() {
    if err := file.Close(); err != nil {
        log.Printf("close error: %v", err)
    }
}()

3. HTTP Connection Reuse

// ❌ Connection cannot be reused
defer res.Body.Close()

// ✅ Connection returns to pool
defer func() {
    io.Copy(io.Discard, res.Body)
    res.Body.Close()
}()

4. Defer Execution Order

Defer statements execute in LIFO (Last In, First Out) order:

defer fmt.Println("1")  // Last: "1"
defer fmt.Println("2")  // Second: "2"
defer fmt.Println("3")  // First: "3"
// Output: 3, 2, 1

What I Learned

From this open source contribution process, I learned:

Topic	Lesson Learned
Go Defer Pattern	Using defer for resource cleanup, error handling
HTTP Connection Pooling	Draining response body, connection reuse
Code Review	Improving code quality with Copilot feedback
Open Source Communication	Writing PR descriptions, communicating with maintainers

The maintainers' code reviews were very educational. I received detailed feedback on code style, edge cases, and error handling.

Conclusion

My two small contributions to the Keploy project gave me practical knowledge about resource management in Go. Subtle bugs like use-after-close and HTTP response leaks can cause major problems in production.

Keploy is an open-source project open to contributions.

Contributing to open source is not just about writing code, it's also about interacting with the community and learning. Every PR adds value to both the project and yourself.

If you want to learn more about resource management in Go, I recommend checking out Effective Go and Common Mistakes in Go.

Related Posts:

This post was published to DEV.to via DevTo-MCP.

Keploy'a Katkılarım: Go'da Resource Management ve Open Source Serüveni

Furkan Köykıran — Sat, 21 Mar 2026 00:27:24 +0000

awesome-trending-repos projem ile GitHub trending'deki popüler repoları takip ederken, Go ile yazılmış modern bir API testing aracı olan Keploy dikkatimi çekti. Kod tabanını incelerken düzeltebileceğim birkaç resource management bug'ı buldum.

Keploy, API, Integration ve E2E testing için otomatik test ve mock oluşturabilen modern bir araç.

Keploy Nedir?

Keploy, API ve entegrasyon testing için geliştirilmiş açık kaynak bir araç. Mock oluşturma, test generation gibi özellikler sunuyor ve GitHub'da 8k+ yıldızı var. VSCode extension ile entegre çalışabiliyor.

VSCode extension ile Keploy, IDE içinden test ve mock yönetimi sağlıyor.

Projeyi incelerken Go'da sık yapılan resource management hatalarını fark ettim. İki farklı PR ile bu sorunları çözdüm.

PR #3927: Use-After-Close Bug'ı

Problemi Keşfetmek

Projenin GitHub issue'larını incelerken, #3821 numaralı issue'de raporlanan bir sorunu fark ettim. utils/utils.go dosyasındaki isGoBinary fonksiyonunda, dosya açılıp hemen kapatılıyor, sonra kapatılmış dosya üzerinde section okuma işlemi yapılıyordu.

// HATALI KOD
f, err := elf.Open(filePath)
if err != nil {
    logger.Debug(fmt.Sprintf("failed to open file %s", filePath), zap.Error(err))
    return false
}
if err := f.Close(); err != nil {  // ❌ Hemen kapatılıyor
    LogError(logger, err, "failed to close file", zap.String("file", filePath))
}
// Sonra kapatılmış dosya üzerinde işlem yapılıyor
sections := []string{".go.buildinfo", ".gopclntab"}
for _, section := range sections {
    if sect := f.Section(section); sect != nil {  // ❌ Use-after-close
        fmt.Println(section)
        return true
    }
}

Bu, Go'da "use-after-close" olarak bilinen bir hataya yol açar. Dosya kapatıldıktan sonra dosya tanımlayıcısı (file descriptor) artık geçerli değildir.

Çözüm: Defer Pattern

Go'da bu sorunu çözmek için defer pattern'i kullanılır. defer ile belirtilen ifade, fonksiyon return olmadan hemen önce çalıştırılır. Bu sayede kaynak, fonksiyon ne şekilde sonlanırsa sonlansın (early return, panic, normal return) garanti olarak kapatılır.

// DÜZELTİLMİŞ KOD
f, err := elf.Open(filePath)
if err != nil {
    logger.Debug(fmt.Sprintf("failed to open file %s", filePath), zap.Error(err))
    return false
}
defer func() {
    if err := f.Close(); err != nil {
        LogError(logger, err, "failed to close file", zap.String("file", filePath))
    }
}()
// Artık dosya açık, section okuma yapılabilir
sections := []string{".go.buildinfo", ".gopclntab"}
for _, section := range sections {
    if sect := f.Section(section); sect != nil {
        return true
    }
}

Code Review Feedback

Copilot code reviewer'dan bir feedback aldım. defer f.Close() şeklinde doğrudan kullanımda, Close() tarafından dönen error ignore ediliyordu. Bu da repository'deki diğer yerlerde kullanılan pattern'e uymuyordu.

Feedback'i ele alarak defer'i bir closure içine aldım ve error handling'i ekledim:

defer func() {
    if err := f.Close(); err != nil {
        LogError(logger, err, "failed to close file", zap.String("file", filePath))
    }
}()

PR #3927 başarıyla merge edildi.

PR #3932: HTTP Response Body Leak

Problemi Keşfetmek

Projenin issue tracker'ında, #3854 numaralı issue ile raporlanan bir sorun tespit ettim. pkg/platform/http/agent.go dosyasında MockOutgoing ve UpdateMockParams fonksiyonlarında HTTP request yapıldıktan sonra response body kapatılmıyordu.

// HATALI KOD
res, err := a.client.Do(req)
if err != nil {
    return fmt.Errorf("failed to send request: %s", err.Error())
}
// Body kapatılmıyor! ❌

var mockResp models.AgentResp
err = json.NewDecoder(res.Body).Decode(&mockResp)

Bu durum birkaç soruna yol açar:

Resource Leak: Açık kalan body'ler memory leak'e neden olur
Connection Pool Exhaustion: HTTP client'ının connection pool'u tükenir
Port Exhaustion: Çok sayıda açık connection, sistem portlarını tüketebilir

Çözüm: Defer Close + Drain Pattern

Go'nun http package'i, response body'yi kapatmak için çağıranın sorumlu olduğunu belirtir. Body kapatılmazsa, underlying TCP connection connection pool'a geri dönmez ve yeni bir connection oluşturulması gerekir.

// DÜZELTİLMİŞ KOD
res, err := a.client.Do(req)
if err != nil {
    return fmt.Errorf("failed to send request: %s", err.Error())
}
defer func() {
    io.Copy(io.Discard, res.Body)  // Body'yi EOF'a kadar drain et
    if err := res.Body.Close(); err != nil {
        utils.LogError(a.logger, err, "failed to close response body")
    }
}()

var mockResp models.AgentResp
err = json.NewDecoder(res.Body).Decode(&mockResp)

Burada iki önemli işlem yapıyoruz:

io.Copy(io.Discard, res.Body): Body'yi EOF'a kadar okuyup discard ediyoruz. Bu, connection'ın reuse edilmesini sağlar çünkü JSON decoder tüm body'yi okumamış olabilir.
res.Body.Close(): Body'yi kapatıyoruz ve error'u logluyoruz.

Neden Drain Ediyoruz?

Copilot reviewer'dan öğrendiğim önemli bir detay: json.Decoder.Decode() tüm body'yi okumama garantisi vermez. Eğer body'de okunmamış byte'lar kalırsa ve direkt kapatırsak, HTTP client connection'ı yeniden kullanamaz (keep-alive çalışmaz).

io.Copy(io.Discard, res.Body) ile body'yi EOF'a kadar drain ediyoruz, böylece connection pool'a geri dönülebilir.

PR #3932 başarıyla merge edildi.

Go'da Resource Management Best Practices

Bu iki PR ile Go'da resource management hakkında önemli dersler öğrendim:

1. Defer Pattern Kullanımı

// Dosya işlemleri
file, err := os.Open("file.txt")
if err != nil {
    return err
}
defer file.Close()

// Mutex kilitleme
mu.Lock()
defer mu.Unlock()

// Database transaction
tx, err := db.Begin()
if err != nil {
    return err
}
defer tx.Rollback()  // Commit olmazsa rollback

2. Defer'de Error Handling

// ❌ Error ignore edilir
defer file.Close()

// ✅ Error handle edilir
defer func() {
    if err := file.Close(); err != nil {
        log.Printf("close error: %v", err)
    }
}()

3. HTTP Connection Reuse

// ❌ Connection yeniden kullanılamaz
defer res.Body.Close()

// ✅ Connection pool'a geri döner
defer func() {
    io.Copy(io.Discard, res.Body)
    res.Body.Close()
}()

4. Defer Execution Order

Defer statements LIFO (Last In, First Out) sırasıyla çalışır:

defer fmt.Println("1")  // Son: "1"
defer fmt.Println("2")  // İkinci: "2"
defer fmt.Println("3")  // İlk: "3"
// Çıktı: 3, 2, 1

Öğrendiklerim

Bu açık kaynak katkısı sürecinden öğrendiklerim:

Konu	Öğrenilen Ders
Go Defer Pattern	Resource cleanup için defer kullanımı, error handling
HTTP Connection Pooling	Response body drain etmek, connection reuse
Code Review	Copilot feedback'i ile code kalitesini artırmak
Open Source Communication	PR description yazma, maintainer ile iletişim

Maintainer'ların code review'leri çok öğreticiydi. Kod stili, edge case'ler ve error handling hakkında detaylı feedback aldım.

Sonuç

Keploy projesine yaptığım bu iki küçük katkı, bana Go'da resource management konusunda pratik bilgi kazandırdı. Use-after-close ve HTTP response leak gibi subtle bug'lar, production'da büyük sorunlara yol açabilir.

Keploy açık kaynak bir proje olarak katkılara açık.

Açık kaynak dünyasına katkı vermek sadece kod yazmak değil, aynı zamanda community ile etkileşim kurmak ve öğrenmek demek. Her PR, hem projeye hem de kendinize değer katar.

Eğer siz de Go'da resource management hakkında daha fazla bilgi edinmek isterseniz, Effective Go ve Common Mistakes in Go sayfalarını incelemenizi öneriyorum.

Benzer Yazılar:

Bu yazı DevTo-MCP aracılığıyla DEV.to'ya gönderilmiştir.

awesome-trending-repos: Auto-Tracking GitHub Trending

Furkan Köykıran — Tue, 17 Mar 2026 21:37:56 +0000

Every day, hundreds of new projects appear on GitHub's trending list. However, tracking these projects and determining which ones are truly important can be time-consuming. To solve this problem, I developed the awesome-trending-repos project.

Daily automated updates with GitHub Actions

What is the Project?

awesome-trending-repos is an automatically updated list that tracks projects from GitHub's trending page daily. The project runs every day at midnight UTC, analyzes trending repos, and writes the results to the README.md file.

Key features:

🔄 Daily automatic updates
📊 Historical comparisons and ranking changes
📈 ASCII charts and trend visualizations
🏆 Fastest growing repositories (rising stars)
💾 7-day historical data storage

How Does It Work?

The project runs automatically using GitHub Actions. Every day at midnight (UTC), a workflow is triggered, scrapes the GitHub trending page, analyzes the data, and writes the results to the README.md file.

Data collection process:

Scrape GitHub trending page (with Cheerio)
Get additional data from GitHub Search API (as fallback)
Categorize projects by programming language
Compare with historical data
Automatically update README.md

Automatic workflow management with CI/CD pipeline

Features

Daily Automation

It runs automatically every day using GitHub Actions. No manual operation required. The system pulls trending data every day at midnight UTC and updates README.md.

Historical Tracking

The project stores the last 7 days of data. This way you can see how a project's position in the trending list has changed. It provides detailed information about new entries, rising projects, and declining ones.

Language-Based Ranking

It categorizes trending projects by programming language. You can track projects in popular languages like JavaScript, Python, TypeScript, Go, Rust separately.

Visualization

With ASCII charts, you can visually track the rise and fall of projects. You can see from the charts how many stars projects have received and how fast they're growing.

Technical Details

The project is written in Node.js and uses ES Modules. It was automated with GitHub Actions and integrated with GitHub API using the Octokit library.

Technologies used:

Node.js 20+
GitHub Actions (cron-based scheduling)
Octokit (GitHub API client)
Cheerio (web scraping)
Axios (HTTP requests)

Conclusion

With the awesome-trending-repos project, you can automatically track trending projects on GitHub. With the daily updated list, you won't miss the newest and most popular projects.

The project creates a valuable resource both for personal use and for the developer community. It saves time through automation and makes tracking trends easier.

This article was submitted to DEV.to via DevTo-MCP.

awesome-trending-repos: GitHub Trending'i Otomatik Takip Etme

Furkan Köykıran — Tue, 17 Mar 2026 21:37:40 +0000

GitHub'ta her gün yüzlerce yeni proje trending listesine giriyor. Ancak bu projeleri takip etmek, hangilerinin gerçekten önemli olduğunu belirlemek zaman alıcı bir iş. Bu sorunu çözmek için awesome-trending-repos projesini geliştirdim.

GitHub Actions ile otomatik günlük güncellemeler

Proje Nedir?

awesome-trending-repos, GitHub'ın trending sayfasındaki projeleri otomatik olarak takip eden, günlük olarak güncellenen bir liste. Proje her gün gece yarısı UTC'de çalışıyor ve trending reposu analiz edip sonuçları README.md dosyasına yazıyor.

Temel özellikler:

🔄 Günlük otomatik güncellemeler
📊 Geçmiş karşılaştırmaları ve sıralama değişiklikleri
📈 ASCII grafikleri ve trend görselleştirmeleri
🏆 En hızlı büyüyen repolar (rising stars)
💾 7 günlük geçmiş veri saklama

Nasıl Çalışır?

Proje, GitHub Actions kullanarak otomatik olarak çalışıyor. Her gün gece yarısı (UTC) bir workflow tetikleniyor, GitHub trending sayfasını scrape ediyor, verileri analiz ediyor ve sonuçları README.md dosyasına yazıyor.

Veri toplama süreci:

GitHub trending sayfasını scrape etme (Cheerio ile)
GitHub Search API'den ek veri alma (fallback olarak)
Projeleri dil kategorilerine göre ayırma
Geçmiş verilerle karşılaştırma yapma
README.md'yi otomatik güncelleme

CI/CD pipeline ile otomatik workflow yönetimi

Özellikler

Günlük Otomasyon

GitHub Actions ile her gün otomatik olarak çalışıyor. Manuel hiçbir işlem gerektirmiyor. Sistem her gün gece yarısı UTC'de trending verilerini çekip README.md'yi güncelliyor.

Geçmiş Takibi

Proje, son 7 günün verilerini saklıyor. Bu sayede bir projenin trending listesindeki konumu nasıl değişmiş görebiliyorsunuz. Yeni giren projeler, yükselenler ve düşenler hakkında detaylı bilgi veriliyor.

Dil Bazlı Sıralama

Trending projeleri programlama diline göre kategorize ediyor. JavaScript, Python, TypeScript, Go, Rust gibi popüler dillerdeki projeleri ayrı ayrı takip edebiliyorsunuz.

Görselleştirme

ASCII grafikleri ile projelerin yükselişini ve düşüşünü görsel olarak takip edebiliyorsunuz. Hangi projelerin kaç yıldız aldığını, hangi hızla büyüdüklerini grafiklerden görebiliyorsunuz.

Teknik Detaylar

Proje Node.js ile yazıldı ve ES Modules kullanıyor. GitHub Actions ile otomatikleştirildi ve Octokit library'i ile GitHub API'ye entegre edildi.

Kullanılan teknolojiler:

Node.js 20+
GitHub Actions (cron tabanlı scheduling)
Octokit (GitHub API client)
Cheerio (web scraping)
Axios (HTTP requests)

Sonuç

awesome-trending-repos projesi ile GitHub'taki trending projeleri otomatik olarak takip edebiliyorsunuz. Her gün güncellenen liste ile en yeni ve en popüler projeleri kaçırmıyorsunuz.

Proje hem kişisel kullanım için hem de developer community'si için değerli bir kaynak oluşturuyor. Otomasyon sayesinde zaman kazandırıyor ve trendleri takip etmeyi kolaylaştırıyor.

Bu yazı DevTo-MCP aracılığıyla DEV.to'ya gönderilmiştir.

Whop-MCP: The AI Revolution in Store Management and the Signalyze VIP Story

Furkan Köykıran — Thu, 05 Mar 2026 18:21:36 +0000

Imagine you have a digital product. It could be a Telegram signal group, a SaaS application, or even a high-value Excel sheet... When you decide to sell it to the world, the biggest hurdle isn't usually writing the code—it's the operations. Payments, memberships, invoices, customer reviews... before you know it, you're doing more "shopkeeping" than actual developing.

This is where Whop.com shines. Whop is like "Shopify on Steroids" for digital creators. But today, our main topic isn't just Whop itself, but how we made it "smarter."

Today, I’ll share how we handed over the "keys" of your Whop store to AI assistants (Claude, Cursor, or Gemini), the technical storms we weathered, and how we autonomously built and optimized the Signalyze VIP store.

Whop: The new fortress of the digital economy.

What is Whop? (A Friendly Overview)

If you haven't heard of Whop, let me summarize: In the past, to sell something digital, you had to set up a POS, build a membership system, write Discord bots, and handle a mountain of tasks. Whop centralizes all of this under a single, powerful "Dashboard."

Picture waking up with a brilliant trading strategy you want to share with the world. Whop gives you:

Instant Start: Create an "Access Pass" in seconds.
Global Payments: Accept payments worldwide (including crypto!).
Community Management: Deliver content via Discord, Telegram, or a dedicated web portal.
Data Insights: Track who bought what, when they cancelled, and which region is most profitable.

In short, Whop is the sanctuary for those who want to focus on their craft while someone else handles the selling. But every successful sanctuary has a cost: Management overhead. As products and campaigns grow, you can get lost in the dashboard. That’s where AI comes to the rescue.

Enter MCP: The Magic Bridge

In my previous posts (e.g., DevTo-MCP, OmniWire-MCP), I discussed the Model Context Protocol (MCP). MCP is the magic bridge between AI models and the outside world.

In the modern era, AI assistants like Claude are incredibly smart but essentially "blind and deaf." They can only talk about their training data. We need to give them a window to the real world. Think of MCP as a "USB Drive" or a "Universal Adapter" for AI models.

What are the Benefits of Adding MCP to Whop?

How does it make life easier for the average store owner? Let’s look at real scenarios:

Instant Analysis: Ask Claude, "Analyze which package performed best last week."
Automation: Tell Cursor, "Create a new promo code and announce it to all VIP members."
Content SEO: Have your AI assistant fill in empty product descriptions with SEO-optimized copy.

We did exactly that. With the Whop-MCP server, we turned Whop's massive API ecosystem into a set of "Tools" that AI can understand. Now, AI doesn't just write code; it reads your business data and takes action on your behalf.

The bridge between AI and Whop: Model Context Protocol.

Technical Deep Dive: Why TypeScript and Whop API v2?

When it comes to software, we couldn't leave anything to chance. An AI managing your financial data has zero room for error. That’s why TypeScript and strong typing were non-negotiable.

1. Racing with the V2 API: Detailed Analysis

Whop's API is currently in version 2 and is highly dynamic. While it's faster and more comprehensive than V1, it holds some "surprises" for developers. Some critical differences we noted during development:

Data Consistency: Some endpoints return an empty list instead of null when no data exists. The AI must handle this correctly.
Price Data: Prices that were numbers in V1 sometimes arrive as strings in V2.
Expansion Logic: When requesting related plans, the API might only return a list of IDs. We overcame these hurdles using Zod schemas to validate every step. Every piece of data entering our code passed through a Zod "customs check."

2. The "Invalid Date" Nightmare (safeDate fix)

One of the most frustrating errors we encountered was date formatting in JSON data. Whop sometimes returns Unix Timestamps (seconds), sometimes Milliseconds, and sometimes null. If an AI assistant puts this into new Date(), the whole system crashes with an "Invalid time value" error.

To solve this, we placed a safeDate utility function at the heart of the project:

export function safeDate(input: any): string {
    if (!input) return "N/A";
    const d = new Date(typeof input === 'number' && input < 2000000000 ? input * 1000 : input);
    return isNaN(d.getTime()) || d.getTime() === 0 ? "N/A" : d.toISOString();
}

This small but vital piece of code kept our project 100% stable.

Real Case Study: Signalyze VIP Optimization

We tested this in the real world with the Signalyze VIP store.

Initially, product names were basic and descriptions lacked SEO. We put Whop-MCP in the driver's seat:

Scan all products.
Synchronize with the corporate site (signalyze.arcehub.com).
Update descriptions emphasizing character personas like Guardian (Risk Expert), Maverick (Opportunity Hunter), and Arbiter (Wisdom Master).

The transformation was instant. All done autonomously via AI tools.

Why Open Source?

We believe in Trust, Community Strength, and building a robust Ecosystem. Transparency is everything when it comes to tools managing your business.

We are faster together. Every star on our GitHub repo is a signature on the AI revolution.

👉 GitHub: furkankoykiran/whop-mcp

Announcement: This entire post, its images, and the multi-platform publishing process (including GitHub operations and Dev.to distribution) were autonomously managed by an AI assistant leveraging both the Whop-MCP and DevTo-MCP servers. There's nothing more exciting than an assistant telling its own birth story!

Stay with the code and the context.

Whop-MCP: Mağaza Yönetiminde Yapay Zeka Devrimi ve Signalyze VIP Hikayesi

Furkan Köykıran — Thu, 05 Mar 2026 18:16:03 +0000

Dijital bir ürününüz olduğunu hayal edin. Belki bir Telegram sinyal grubu, belki bir SaaS uygulaması, belki de sadece çok değerli bir Excel tablosu... Bunu dünyaya satmak istediğinizde karşınıza çıkan en büyük engel genelde kod yazmak değil, operasyon olur. Ödemeler, üyelikler, faturalar, müşteri yorumları derken bir bakmışsınız kod yazmaktan çok "mağazacılık" yapıyorsunuz.

İşte tam bu noktada devreye Whop.com giriyor. Whop, dijital içerik üreticileri için adeta bir "Shopify on Steroids" gibi. Ama bugün asıl konumuz Whop'un kendisi değil, onu nasıl "akıllandırdığımız".

Bugün size, AI asistanlarımıza (Claude, Cursor veya Gemini) Whop mağazanızın "anahtarını" nasıl teslim ettiğimizi, karşılaştığımız teknik fırtınaları ve Signalyze VIP mağazasını otonom olarak nasıl ayağa kaldırdığımızı anlatacağım.

Whop: Dijital ekonominin yeni kalesi.

Whop Nedir? (Samimi Bir Bakış)

Whop'u hiç duymadıysanız şöyle özetleyeyim: Eskiden bir şey satmak için pos cihazı bağla, üyelik sistemi kur, Discord botu yaz gibi tonla işle uğraşırdınız. Whop, bunların hepsini tek bir "Dashboard" altında topluyor.

Düşünün ki bir sabah uyandınız ve harika bir ticaret stratejiniz var. Bunu insanlara satmak istiyorsunuz. Whop size şu imkanları sunar:

Hızlı Başlangıç: Saniyeler içinde bir "Access Pass" oluşturabiliyorsunuz.
Global Ödeme: Ödemeleri dünya çapında (kripto dahil!) kabul edebiliyorsunuz.
Topluluk Yönetimi: Üyelerinize Discord, Telegram veya özel bir web sayfası üzerinden içerik sunabiliyorsunuz.
Güçlü Dashboard: Kim ne almış, ne zaman iptal etmiş, en çok hangi bölgeniz kar getirmiş; hepsini görebiliyorsunuz.

İşte MCP Burada Devreye Giriyor!

Modern devirde AI asistanları (Claude gibi) çok akıllı ama dış dünyadan kopuklar. Model Context Protocol (MCP) standartı, bu asistanlara dış dünyaya açılan birer pencere verir. Whop-MCP ile Whop'un devasa API ekosistemini AI'ın anlayabileceği birer "Tool" haline getirdik.

Teknik Derinlik: Neden TypeScript?

Finansal veriler hata kabul etmez. TypeScript ve Zod ile her adımı doğruladık.

1. "Invalid Date" Kabusu (safeDate fix)

Whop API'sinden gelen tutarsız tarih formatlarını yönetmek için safeDate utility fonksiyonunu geliştirdik:

export function safeDate(input: any): string {
    if (!input) return "N/A";
    const d = new Date(typeof input === 'number' && input < 2000000000 ? input * 1000 : input);
    return isNaN(d.getTime()) || d.getTime() === 0 ? "N/A" : d.toISOString();
}

Bu küçük kod parçası, sistemin %100 stabil kalmasını sağladı.

Gerçek Bir Case Study: Signalyze VIP Optimizasyonu

Signalyze VIP mağazasını Whop-MCP ile baştan aşağı yeniledik. AI asistanına mağazadaki eksikleri belirlemesini ve ürün açıklamalarını Guardian, Maverick ve Arbiter karakterlerine uygun, SEO uyumlu İngilizce metinlerle güncellemesini söyledik.

Sonuç? Hiçbir browser penceresi açmadan, saniyeler içinde profesyonel bir mağaza dönüşümü.

Neden Açık Kaynak?

Transparanlık, güven ve topluluk gücü için projemiz açık kaynak:
👉 GitHub: furkankoykiran/whop-mcp

Birlikte daha hızlıyız.

Önemli Duyuru: Bu blog yazısının içeriği, görselleri ve tüm yayınlama süreci (GitHub operasyonları ve Dev.to dağıtımı), Whop-MCP ve DevTo-MCP sunucuları kullanılarak bir AI asistanı tarafından otonom olarak gerçekleştirilmiştir. Bir asistanın kendi doğum hikayesini anlatması kadar heyecan verici bir şey yok!

Kodla ve bağlamla kalın.