DEV Community: Dmitry

Your Mac Has 80GB of Hidden Junk. Here's How to Find It.

Dmitry — Thu, 11 Jun 2026 07:44:54 +0000

After years of using CleanMyMac and watching it beg me for a paid upgrade every time I clicked something useful, I decided to build my own. Meet Trashly — a macOS disk cleaner written in Rust with a React frontend, open-source (AGPL-3), and with zero upsells.

This post is about why I built it, the interesting technical choices I made, and the one thing most cleaners get completely wrong.

The Problem: Cleaners Don't Know About Developers

Mainstream Mac cleaners do a decent job on browser caches and basic junk. But if you're a developer? They leave gigabytes on the table.

On my MacBook after about a year of development, I had:

~40 GB of Xcode DerivedData
~15 GB of iOS DeviceSupport (archived device frameworks for debugging)
~20 GB across node_modules folders in abandoned projects
~8 GB of Android emulator images
~6 GB of JetBrains caches
Docker volumes I forgot existed

Generic cleaners found maybe 2 GB of browser cache and called it a day.

The Stack

I wanted something that felt native and was actually fast. The choice was easy:

Rust for the backend — memory safety, real parallelism, direct OS access
Tauri 2 as the bridge — gives you a native window with WebView, IPC, tray icon, and auto-updates with no Electron overhead (~8 MB app bundle vs ~200 MB)
React 19 + TypeScript for the UI — familiar tooling, great ecosystem, and Tauri's WebView means I don't have to learn SwiftUI

The Interesting Parts

Safety-First Deletion

The thing that terrifies me about disk cleaners is "what if it deletes the wrong thing." So the first thing I built was a strict allowlist guard in Rust:

fn is_safe_path(path: &Path) -> bool {
    let allowed_roots = [
        home_dir().join("Library/Caches"),
        home_dir().join("Library/Logs"),
        home_dir().join(".Trash"),
        // developer paths...
    ];

    allowed_roots.iter().any(|root| {
        path.starts_with(root) && path != root.as_path()
    })
}

The key detail: path != root — you can't delete the root itself, only things inside it. And .. escapes are rejected before this check even runs. This guard lives in Rust, not JavaScript. Even if a malicious path somehow came from the UI layer, the backend would refuse it.

By default, everything goes to the Trash via NSFileManager — permanent deletion is opt-in.

Streaming Scan Results

Nobody wants to stare at a spinner for 30 seconds before seeing results. The scan fans out across all categories in parallel using rayon, and results stream to the UI as they're found:

pub async fn scan_caches() -> impl Stream<Item = ScanResult> {
    let (tx, rx) = tokio::sync::mpsc::channel(256);

    tokio::spawn(async move {
        rayon::scope(|s| {
            for scanner in SCANNERS.iter() {
                let tx = tx.clone();
                s.spawn(move |_| {
                    if let Ok(results) = scanner.scan() {
                        for r in results {
                            let _ = tx.blocking_send(r);
                        }
                    }
                });
            }
        });
    });

    ReceiverStream::new(rx)
}

The UI renders file entries the moment they arrive. A 40 GB DerivedData scan starts showing results within 200ms.

Finding Dead `node_modules`

This is where Trashly gets opinionated. Rather than scanning for node_modules anywhere on the disk, it looks for project manifests first:

fn find_project_artifacts(root: &Path) -> Vec<ArtifactResult> {
    WalkDir::new(root)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| is_manifest(e.path())) // package.json, Cargo.toml, etc.
        .flat_map(|manifest| {
            let project_dir = manifest.path().parent().unwrap();
            ARTIFACT_DIRS.iter()
                .map(|name| project_dir.join(name))
                .filter(|p| p.exists())
                .map(|p| ArtifactResult { path: p, .. })
                .collect::<Vec<_>>()
        })
        .collect()
}

It finds node_modules, target, dist, .next — but only when they sit next to a real package.json, Cargo.toml, build.gradle, etc. No false positives from unrelated folders with the same name.

Perceptual Photo Deduplication

Exact duplicate detection (BLAKE3 hash matching) is table stakes. The interesting problem is similar photos — the same screenshot at two export sizes, the same photo edited in Lightroom, burst shots that are 95% identical.

I implemented dHash clustering:

Decode image to 9×8 grayscale (via the image crate; HEIC files go through system sips)
For each row, compute whether each pixel is brighter than its right neighbor → 64-bit hash
Group images where Hamming distance < threshold into clusters
Within each cluster, keep the largest file (assumed best quality) and offer the rest for deletion

fn dhash(img: &DynamicImage) -> u64 {
    let small = img.resize_exact(9, 8, FilterType::Lanczos3)
                   .grayscale();
    let pixels = small.to_luma8();
    let mut hash = 0u64;
    for y in 0..8 {
        for x in 0..8 {
            if pixels[(x, y)].0[0] > pixels[(x + 1, y)].0[0] {
                hash |= 1 << (y * 8 + x);
            }
        }
    }
    hash
}

On a photo library of 12,000 images, this runs in about 8 seconds on an M1.

System Metrics That Actually Work on Recent macOS

The sysinfo crate — which most Rust system monitor tools reach for — reports zero memory pressure on macOS 14+. The kernel API it uses was deprecated.

I ended up parsing top -l 1 -n 0 and netstat -i -b directly:

fn memory_pressure() -> Option<MemPressure> {
    let output = Command::new("memory_pressure").output().ok()?;
    // parses "System-wide memory free percentage: 42%"
    // and "The system memory pressure is: CRITICAL"
    parse_memory_pressure_output(&output.stdout)
}

Ugly? A little. But it returns the same values macOS shows in Activity Monitor, which is what users expect.

The App Uninstaller

This is the feature I'm most proud of. When you drag an app to Trash on macOS, you leave behind:

~/Library/Application Support/<AppName>
~/Library/Caches/com.example.app
~/Library/Containers/com.example.app
~/Library/Preferences/com.example.app.plist
Launch Agents
Browser extensions and profiles
Crash reports

Trashly hunts all of these down by bundle ID and developer name, lets you preview them, and optionally keep the app binary while wiping just its data (great for resetting an app to factory state).

For developer tools (Xcode, Android Studio, JetBrains, Docker), there are dedicated cleanup routines that know exactly where each tool stores its caches and how much space each component takes.

What I Learned

Tauri is genuinely great. The IPC ergonomics are excellent — you define a Rust function with #[tauri::command], and the TypeScript side gets a typed async function. Hot reload works. The app bundle is tiny.

Rust's safety guarantees matter for this use case. There are code paths in Trashly that walk the entire home directory and make deletion decisions. Having the compiler verify that I'm not accidentally aliasing mutable state across threads, and that every error is handled, is worth the learning curve.

Most disk usage surprises people. The feedback I consistently get is: "I had no idea DerivedData was this big." Xcode will accumulate build artifacts for every simulator OS version and every version of your app it's ever compiled. 50 GB is not unusual for active iOS developers.

Where to Find It

Trashly is open-source under AGPL-3 on GitHub. No telemetry, no accounts, no upsells. The cleanup history is a local-only audit log so you can always see what was removed and when.

If you're macOS user and you're regularly running out of disk space, give it a try. The first scan usually finds 30–80 GB on a machine that's been used for a year or more.

GitHub: github.com/AppsGanin/trashly

Built with Rust, Tauri 2, React 19. Feedback welcome — especially if you know a cache directory I haven't found yet.

Вечер на автоматизацию GitHub-ачивок

Dmitry — Fri, 29 May 2026 15:20:58 +0000

Началось всё банально: хотел собрать ачивки на GitHub-профиле.

Процесс оказался несложным по сути, но раздражающим по исполнению — куча однотипных ручных шагов, ожидание ревьюеров, непрозрачные условия засчитывания. Типичная задача на «автоматизировать и забыть».

Я взял её как мини-проект на вечер. Вечер растянулся.

Что хотелось получить

Публичный репозиторий, куда любой может открыть PR, и он автоматически мёрджится — без мейнтейнера, без ожидания, без магии.

Звучит просто. Но сразу встал вопрос: как сделать это безопасно?

Открытый авто-мёрдж без ограничений — это либо спам, либо кто-то пропушит что-то лишнее. Нужна была система проверок.

Первое нетривиальное решение: `pull_request_target`

Для авто-мёрджа форков нужен доступ к секретам репозитория. Обычный pull_request такого доступа не даёт — он намеренно изолирован для безопасности.

Правильный ответ — pull_request_target. Он запускается в контексте целевого репозитория, а не форка, поэтому имеет доступ к токенам. Но это же делает его опасным, если не выстроить валидацию до любых действий.

on:
  pull_request_target:
    types: [opened, synchronize, reopened]
    paths:
      - "contributors/**"

Вся логика валидации идёт первой, до мёрджа — иначе это дыра.

Валидация: динамический regex из логина автора

Я хотел, чтобы каждый пользователь мог добавить только свой файл. Не чужой, не случайный — именно username.md.

Жёсткий список заранее не составишь. Поэтому имя файла проверяется динамически: regex строится прямо из логина автора PR.

const author = context.payload.pull_request.user.login.toLowerCase();
const validPattern = new RegExp(`^contributors/${author}(-\\d+)?\\.md$`, 'i');

const invalidFiles = files.filter(f => !validPattern.test(f.filename));

Паттерн допускает username.md, username-2.md, username-3.md — для случаев, когда нужно несколько PR от одного пользователя. Всё остальное — отказ с понятным сообщением прямо в комментарии к PR.

Galaxy Brain: правильный ответ спрятан в HTML-комментарии

Для ачивки Galaxy Brain нужно, чтобы кто-то ответил на вопрос в Discussions и ответ был помечен как правильный.

Автоматизировать проверку ответа — задача нетривиальная. Хранить правильные ответы в отдельном файле/базе? Лишние сущности. Сравнивать с внешним API в момент ответа? Медленно и ненадёжно.

Элегантное решение: правильный ответ прячется прямо в теле discussion в HTML-комментарии, который пользователь не видит, а workflow читает.

<!-- ANSWER: JavaScript -->

Когда кто-то отвечает в треде, workflow проверяет, содержит ли комментарий нужную строку:

const answerMatch = discussion.body.match(/<!--\s*ANSWER:\s*(.+?)\s*-->/i);
const correctAnswer = answerMatch[1].trim().toLowerCase();
const commentBody = context.payload.comment.body.toLowerCase();

if (!commentBody.includes(correctAnswer)) {
  // неправильный ответ — ничего не делаем
  return;
}

Никакой внешней базы. Данные живут там, где они нужны.

Discussions API: только GraphQL

GitHub REST API не поддерживает принятие ответа в Discussions. Это доступно только через GraphQL — markDiscussionCommentAsAnswer.

const mutation = `
  mutation($commentId: ID!) {
    markDiscussionCommentAsAnswer(input: { id: $commentId }) {
      discussion { number url }
    }
  }
`;
await github.graphql(mutation, { commentId });

Аналогично для создания самих вопросов и добавления реакций — всё через GraphQL. REST здесь просто не работает.

Идемпотентность: не создавать вопросы, пока есть неотвеченные

Workflow создания вопросов запускается три раза в день. Но создавать новые вопросы, пока старые висят без ответа — бессмысленно и засоряет Discussions.

Перед созданием — проверка:

const unanswered = result.repository.discussions.totalCount;

if (unanswered > 0) {
  // пропускаем этот запуск
  return;
}

Запуск идемпотентен: повторный прогон не ломает состояние.

Схема всего

PR pipeline:

User opens PR
  → pull_request_target
  → Validation
      ✅ pass → Squash merge
      ❌ fail → Comment with reason

Galaxy Brain pipeline:

Cron 3x/day
  → Unanswered questions exist?
      yes → skip
      no  → fetch from OpenTDB
           → create discussions with hidden ANSWER tag

New discussion comment
  → correct answer? → markDiscussionCommentAsAnswer
  → wrong answer?   → ignore

Что получилось в итоге

Репозиторий, где:

🦈 Pull Shark — PR в contributors/ → авто-мёрдж
👥 Pair Extraordinaire — PR в pairs/ → авто-мёрдж с Co-authored-by
🧠 Galaxy Brain — отвечай на вопросы в Discussions → бот принимает правильные
⚡ Quickdraw и 🤠 YOLO — инструкции за 2 клика

Без ожидания, без мейнтейнера, без магии.

Дисклеймер

Проект создан в образовательных и развлекательных целях.
Ачивки — косметика профиля, не метрика уровня инженера.

Используй в рамках GitHub Terms of Service.

Если идея понравилась — посмотри GitHub Achievement Farm и поставь ⭐, если зашло.

Если есть вопросы по деталям реализации или нашёл edge-case — welcome в issues.

Ultimate 1-Minute Xray/3x-ui Setup: VLESS, Hysteria2, Caddy Self-Steal & Smart Outbounds in One Script

Dmitry — Wed, 27 May 2026 20:51:45 +0000

Setting up a secure internet circumvention gateway using Xray usually turns into a tedious chore. You have to install Docker, configure the 3x-ui web panel, generate TLS certificates, tweak Reality settings against active probing, and manually set up routing tables.

If you frequently cycle your VPS providers or manage servers for friends, doing this manually every time is a massive waste of time.

That’s why I created 3xui-fast-install — a lightweight, automated bash script that deploys a fully production-ready, security-hardened Xray node in under a minute.

What’s Under the Hood? 🛠️

This is NOT just a blank panel installation. The script sets up an optimized, batteries-included network ecosystem wrapped in Docker. Here is exactly what gets deployed and configured out of the box:

Component	Description
3x-ui Panel	Xray web management interface running on custom non-standard ports.
VLESS + Reality	Industry-standard transport layer mimicking legitimate TLS handshakes (Port 443).
Hysteria 2	High-performance UDP-based protocol (Port 63000) optimized for unstable or mobile networks.
Caddy (Self-Steal)	Acts as a TLS terminator on port 443, handling automated, legitimate Let's Encrypt certificates.
Cloudflare WARP	Configured as a local SOCKS5 outbound proxy for specific fallback routing.
Opera Proxy & Tor	Additional local SOCKS5 outbounds ready for geo-blocked services and `.onion` routing.
BBR & Security	Automated TCP BBR congestion control activation, UFW firewall configuration, and Fail2ban protection.

Smart Server-Side Routing Architecture 🗺️

One of the highlights of this setup is how it handles outbound traffic directly inside Xray on the server. Instead of just passing everything blindly (direct), the backend follows strict routing rules:

Adblock & Malware: Automatically dropped (blocked) at the server level.
Domestic/RU Domains & GeoIP: Routed via Cloudflare WARP. Ideally, your clients should use local routing rules (like roscomvpn-routing) so domestic traffic never leaves their device. However, if a domestic packet does leak to your VPS, WARP intercepts it and routes it out, masking your actual VPS server IP address from domestic logs.
Streaming & Privacy: Popular global services (like Disney+ or Reddit) are routed via Opera Proxy, while .onion addresses go directly through the Tor outbound network.

⚠️ Note on Customization: The outbound routing rules listed above (such as Opera Proxy, Tor, or specific domain rules) are configured as examples to showcase the full capabilities of the script. You can easily modify, remove, or add your own custom routing parameters in the 3x-ui panel settings anytime after the installation is complete.

Prerequisites & Installation 🚀

The deployment process requires minimal preparation.

Requirements:

A clean Ubuntu/Debian VPS.
A registered domain name with an A-record already pointed to your VPS IP address.

The 1-Command Deployment:

Run the following command on your clean server root terminal:

git clone https://github.com/AppsGanin/3xui-fast-install 3xui-personal
cd 3xui-personal

DOMAIN=vpn.example.com bash deploy.sh 1.2.3.4

What happens next?

The script detects and installs Docker/Compose if missing.
It automatically generates unique, high-entropy credentials and secure ports for your 3x-ui panel dashboard.
It configures your firewall, opens only the necessary ports (22, 80, 443, 63000 UDP), and locks down the rest.

Once finished, the console will print your ready-to-use admin panel URL, username, and password.

Conclusion & Open Source

This setup cuts down deployment time from an hour of manual configuration to literally 60 seconds, while maintaining best-practice security baselines out-of-the-box.

The project is completely open-source. Feel free to review the bash script logic, submit issues, or contribute improvements.

⭐️ Check out the repository on GitHub: 👉 https://github.com/AppsGanin/3xui-fast-install

Zero-Cost AI in VS Code

Dmitry — Sat, 23 May 2026 17:02:39 +0000

Zero-Cost AI: Accessing Premium Models in VS Code Without API Keys

How I built a VS Code extension that gives you free access to Qwen-Max and DeepSeek models using only your existing web account — no billing, no tokens, no limits.

🎯 The Problem with Modern AI Tools

The state of AI development has become expensive:

API keys needed for every provider
Per-token pricing that adds up quickly
Rate limits blocking your workflow
Multiple subscriptions to different services

Premium AI services charge significant monthly fees:

ChatGPT Plus: $20/month
Claude Pro: $20/month
Gemini Advanced: $20/month

That's over $600/year for basic access! And you still need separate accounts for each service.

What if there was another way?

💡 The Solution: Browser-Based Authentication

I developed AI Free VSCode — an open-source extension that leverages your existing free tier accounts from AI providers through browser automation.

Key Innovation

Instead of requiring API keys (which often have strict rate limits), the extension:

Uses Playwright to automate a real Chromium browser session
Stores authentication cookies locally
Makes requests through the official web APIs
Gives you full access to the same free tier available on their websites

Result?

✅ Zero cost - uses existing free accounts

✅ No API keys - just sign in once

✅ Higher limits - same as browsing the website

✅ Native integration - works directly in Copilot Chat

✅ Agent mode - full tool calling support

🏗 Architecture Overview

Extension Structure

ai-free-vscode/
├── src/
│   ├── extension.mjs          # Entry point & commands
│   ├── lmProvider.mjs         # Unified LM provider interface
│   ├── deepseek/
│   │   ├── auth.mjs           # Browser login with Playwright
│   │   ├── client.mjs         # API client implementation
│   │   ├── provider.mjs       # Model logic & session management
│   │   └── config.mjs         # Configuration constants
│   ├── qwen/
│   │   ├── auth.mjs           # Qwen authentication
│   │   ├── client.mjs         # Qwen API client
│   │   └── provider.mjs       # Qwen model implementation
│   ├── utils/
│   │   ├── logger.mjs         # Debug logging
│   │   ├── rateLimiter.mjs    # Rate limiting protection
│   │   ├── responseValidator.mjs
│   │   └── tokenValidator.mjs
│   └── promptUtils.mjs        # Message formatting
├── package.json               # Extension manifest
└── README.md                  # Documentation

Core Components

1. Authentication Flow

The extension registers commands for users to authenticate:

context.subscriptions.push(
  vscode.commands.registerCommand("deepseek.login", async () => {
    await clearProfileSession(); // Clear old session
    const result = await loginAndSaveAuth(); // New login via Playwright
    auth.cookieHeader = result.cookieHeader;
    auth.token = result.token;
  }),
);

Process:

Opens Chromium browser via Playwright
User signs into provider normally
Session cookies captured and stored locally
Cookies used for subsequent API requests

2. Unified Provider Interface

All models are unified under a single vendor namespace:

class AiFreeVscodeChatModelProvider {
  async provideLanguageModelChatResponse(
    model,
    messages,
    options,
    progress,
    token,
  ) {
    // Convert VS Code messages to API format
    const convertedMessages = convertMessages(messages);
    const tools = convertToolSchemas(options?.tools);
    const prompt = messagesToPrompt(convertedMessages, tools);

    // Route to appropriate provider
    switch (model.family) {
      case "deepseek":
        await deepseekComplete({ modelId, prompt, auth, onText, signal });
        break;
      case "qwen":
        await qwenComplete({
          modelId,
          prompt,
          auth,
          onText,
          onThinking,
          signal,
        });
        break;
    }
  }
}

Process:

Routes VS Code chat requests to appropriate provider
Handles both DeepSeek and Qwen models
Converts messages to API format
Manages streaming responses

3. Smart Session Management

Maintains conversation continuity with session caching:

const sessionIdCache = new Map();

async function runComplete({
  modelId,
  prompt,
  auth,
  threadKey,
  messagesCount,
}) {
  // Start fresh session for first message in thread
  if (messagesCount === 1) {
    sessionIdCache.delete(threadKey);
  }

  // Try cached session first (for conversation continuity)
  const cachedSessionId = sessionIdCache.get(threadKey);
  if (cachedSessionId) {
    const ok = await attempt(cachedSessionId);
    if (ok) return; // Success!
  }

  // Retry with new session
  const sessionId = await client.createSession({ signal });
  sessionIdCache.set(threadKey, sessionId);
  await attempt(sessionId);
}

🔧 Installation & Setup

Step 1: Install the Extension

Download the latest .vsix file from Releases and install via VS Code Extensions panel.

Or develop locally:

git clone https://github.com/AppsGanin/ai-free-vscode
cd ai-free-vscode
npm install  # installs dependencies + Playwright Chromium

Press F5 to launch in Extension Development Host.

Step 2: Sign In to Provider

Open Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
Run "AI Free VSCode: DeepSeek: Sign In (Playwright)"
A browser window opens automatically
Log in to your account normally
Window closes when session is saved

Repeat for Qwen or other supported providers.

Step 3: Start Chatting

Open Copilot Chat panel (⌘+L)
Select your preferred model from dropdown
Start asking questions!

🚀 Supported Models

Model	ID	Use Case
DeepSeek V4	`deepseek-default`	General purpose
DeepSeek V4 Expert	`deepseek-expert`	Complex reasoning
Qwen2.5-Max	`qwen-max`	Powerful tasks
Qwen3.6-Plus	`qwen-plus`	Long documents
Qwen3-Max	`qwen3-max`	Flagship quality
Qwen3-Coder	`qwen-coder`	Code generation
Qwen3.5-Flash	`qwen-flash`	Fastest responses

All models support tool calling for Agent mode operations like:

File reading/writing
Terminal execution
Multi-step debugging
Code refactoring

🛠 Technical Deep Dive

How Messages Are Processed

1. Message Conversion

VS Code messages are converted to API-compatible format:

function convertMessages(messages) {
  return messages
    .map((msg) => {
      const role = msg.role === "assistant" ? "assistant" : "user";

      // Handle text content
      const content = msg.content
        .map((part) =>
          part instanceof LanguageModelTextPart ? part.value : "",
        )
        .join("");

      // Extract tool calls from assistant
      const toolCalls = msg.content
        .filter((p) => p instanceof LanguageModelToolCallPart)
        .map((p) => ({
          id: p.callId,
          type: "function",
          function: { name: p.name, arguments: JSON.stringify(p.input) },
        }));

      // Generate separate "tool" messages for results
      const toolResults = msg.content
        .filter((p) => p instanceof LanguageModelToolResultPart)
        .map((p) => ({
          role: "tool",
          tool_call_id: p.callId,
          content: p.content.value,
        }));

      return [
        ...toolResults,
        { role, content, tool_calls: toolCalls.length ? toolCalls : undefined },
      ];
    })
    .flat();
}

2. Tool Call Detection

The system detects markdown fences indicating tool calls:

const TOOL_FENCES = ["`\`\`tool_call", "\ntool_call\n{", "tool_call\n{"];

function findFence(str) {
  let best = -1;
  for (const fence of TOOL_FENCES) {
    const idx = str.indexOf(fence);
    if (idx !== -1 && (best === -1 || idx < best)) best = idx;
  }
  return best;
}

// Stream processing
streamBuf += text;
const idx = findFence(streamBuf);
if (idx !== -1) {
  // Emit text before fence, suppress tool call block
  flushStream(streamBuf.slice(0, idx));
  streamBuf = "";
  inToolCall = true;
}

This prevents raw tool call blocks from appearing in the chat UI while still executing them properly.

3. Thinking Mode Support

For models with explicit reasoning phases:

let thinkingStarted = false;
let thinkingText = "";

const onThinking = async (text) => {
  thinkingText += text;
  thinkingStarted = true;
};

// When content starts, emit thinking as collapsible block
if (thinkingStarted) {
  progress.report(new LanguageModelThinkingPart(thinkingText, "thinking-0"));
}

VS Code displays this as a native collapsible "💭 Thinking" section above responses.

🔐 Security & Privacy

What Happens to Your Data?

✅ Cookies stored locally - Only your machine, encrypted by OS
✅ No cloud storage - We never transmit your credentials
✅ Session isolation - Each provider maintains separate sessions
✅ No telemetry - No usage statistics sent anywhere

Error Handling

try {
  await client.complete({ ... });
} catch (e) {
  // Graceful handling of various errors
  if (e.isNotSignedIn) {
    showErrorMessage("Please sign in first");
  } else if (e.isAuthError) {
    // Cookie expired - force re-login
    clearProfileSession();
    throw e;
  } else if (isBizError(e)) {
    // Business logic error with formatted message
    progress.report(new TextPart(formatBizError(e.bizCode, e.bizMsg)));
  }
}

⚠️ Limitations & Caveats

Important Considerations

Terms of Service - Automating browser sessions may violate provider ToS
Account Risk - Your account could be restricted (use at your own risk)
Stability - Providers can change APIs without notice
Single Session - Only one active user session at a time
No Enterprise Support - Not suitable for corporate compliance requirements

Mitigation Strategies

Use separate accounts from main email
Don't abuse the service (reasonable usage only)
Keep extension updated for API changes
Maintain backups of important code/settings

🚀 Real-World Use Cases

Scenario 1: Code Review Assistant

# Ask about potential bugs
User: "Review this Python function for memory leaks:"
[User pastes code]

Assistant: Analyzes code structure, identifies resource leaks,
suggests fixes with explanations

Scenario 2: Database Query Optimization

-- Paste slow query
EXPLAIN SELECT * FROM users WHERE created_at > NOW() - INTERVAL '7 days';

Assistant: Suggests indexing strategies, query rewriting,
and alternative approaches

Scenario 3: Full Stack Debugging

Identify error in terminal
Ask assistant to analyze stack trace
Get root cause explanation
Receive fix suggestion with code example
Apply fix directly in editor

🤝 Contributing

This is an open-source hobby project built by enthusiasts, for enthusiasts.

Ways to contribute:

Fix bugs - See open issues
Add new models - Implement additional AI providers
Improve docs - Clarify setup instructions
Enhance UX - Better error messages, UI improvements
Write tests - Increase coverage for edge cases

Getting started:

git clone https://github.com/AppsGanin/ai-free-vscode
cd ai-free-vscode
npm install
# Edit code, press F5 to test

Contributions welcome! PRs are always appreciated.

📝 Legal Disclaimer

This extension is unofficial and not affiliated with any AI provider.

Use at your own risk - Automating web sessions may violate ToS

No guarantees - May stop working if providers change APIs

No liability - Authors not responsible for consequences

Always review Terms of Service before use.

🎯 Conclusion

AI Free VSCode demonstrates that you don't need expensive API keys or multiple subscriptions to access premium AI capabilities. By leveraging browser automation and existing free tiers, we've created a solution that:

💰 Costs nothing - literally $0 monthly subscription
🚀 Works instantly - one-time sign-in, perpetual access
🔒 Respects privacy - all data stays local
🛠️ Integrates seamlessly - native VS Code experience

Whether you're a student learning to code, a indie developer building your startup, or just someone who wants powerful AI tools without breaking the bank - this extension removes financial barriers and puts cutting-edge technology in your hands.

Ready to try it?

👉 Download the extension

⭐ Star the repo if it helps your workflow

📣 Share with fellow developers

Let's democratize AI access together! 🚀