DEV Community: dixit patel

🚀 Launching My New Project: Web Command Line Control in Server

dixit patel — Mon, 01 Sep 2025 18:02:26 +0000

Hey Devs 👋,

I’m thrilled to share my new project – Web Command Line Control in Server ⚡

🔥 What is this project?

It’s a web-based interface that allows you to execute command-line operations directly on your server using a clean UI.

Think of it as bringing Terminal/CLI to the Browser, powered by Vue.js & Tailwind.

⚡ Why I’m Building This?

To simplify server management from any device
To practice and master Vue.js + TailwindCSS
To make a powerful tool for developers who love the command line

🛠️ Tech Stack

Frontend: Vue.js + TailwindCSS
Backend: Node.js / Express
Realtime: Firebase or Socket.IO
UI Components: DaisyUI / Vuetify

🌱 What’s Next?

Adding authentication for secure command execution
Support for multiple servers
Sharing live progress here on Dev.to & Twitter

👉 Follow along as I build in public. Feedback & suggestions are always welcome 🙌

How to Set Up a Full Machine-Wide Tor Proxy (SOCKS5) on Kali Linux 🚀🧅

dixit patel — Sun, 29 Jun 2025 12:13:41 +0000

Full Tor Proxy Setup (SOCKS5) on Kali Linux

In this post, I’ll show you how to route your entire Kali Linux machine through the Tor network using a SOCKS5 proxy setup. Perfect for ethical hackers, privacy advocates, and anyone curious about how to surf anonymously.

🎥 Watch the video guide here: YouTube Video

🚀 DixitCoder AI Control Panel Browser – Secure, Stylish, and Tor-Ready!

dixit patel — Mon, 09 Jun 2025 02:16:54 +0000

📢 DixitCoder AI Control Panel Browser — releasing publicly in 4–5 days! Stay tuned. 🚀🌐

Welcome to the official release of the DixitCoder AI Control Panel Browser, a minimal, secure, and proxy-powered browser built using Python and PyQt6. This browser is tailor-made for developers, security enthusiasts, and privacy-conscious users.

🔒 Why This Browser?
The goal behind DixitCoder AI Browser is simple:

Combine privacy-first browsing using the Tor network

Provide a developer-friendly UI with dark theming

Support real-time theme control and URL navigation

Built using pure Python + PyQt6

🧠 Features Overview
✅ 1. Tor Proxy Toggle (ON/OFF)
Dynamically enable/disable Tor proxy (socks5://127.0.0.1:9050)

Stores settings locally and restarts to apply changes

🎨 2. Advanced Dark Theme UI
Inspired by modern dev tools like VS Code

Custom rounded buttons, styled input bars, and toolbar

🌐 3. Navigation Tools
Back / Forward / Reload / Home buttons

Live URL bar with auto-update

📦 4. PyQt6 WebEngine View
Uses Chromium under the hood for fast rendering

Loads pages like https://check.torproject.org/ and your own tools

🧩 Tech Stack
Tool Usage
Python 3 Core scripting language
PyQt6 UI Toolkit
QWebEngineView Web page rendering
Tor Proxy SOCKS5 proxy (manual setup)

🖼️ Screenshots
Add your screenshots here — homepage, settings toggle, Tor check success etc.

🔧 How to Run
Install dependencies:

pip install PyQt6 PyQt6-WebEngine
Start the browser:

python app.py
Optional: Make sure the Tor service is running locally on port 9050.

📁 Folder Structure

dixitcoder-app/
├── app.py
├── proxy_setting.conf
├── assets/
│ └── banner.png
├── README.md
└── requirements.txt
🛠️ What's Next?
✨ Add a Light theme toggle

🧭 Bookmark support

⏳ Page loading indicator

🔐 Add basic auth for restricted URLs

🌍 Live Link (if hosted)
https://dixitcoder-tools-ai.web.app/

💬 Feedback & Contributions
Found a bug? Got a feature idea? Drop it on GitHub or message me on Instagram @dixitcoder.

📢 Final Words
This project reflects my passion for web development, UI design, and cybersecurity. It's just the beginning. Stay tuned for more AI tools, dev utilities, and ethical hacking projects from DixitCoder!

🚀 My First YouTube Upload – Introduction to AI Tools | Dixitcoder

dixit patel — Wed, 04 Jun 2025 16:38:50 +0000

🎉 My First YouTube Video is Live!

Hey Devs 👋,

I'm excited to share that I just launched my first YouTube video on my new channel Dixitcoder! 🧠💻

📹 Video Title:

My First Upload | Introduction to AI Tools | Dixitcoder

📺 Watch it here: https://youtu.be/okGcn-0I7zc

🧠 What’s inside?

In this video, I introduce some powerful AI tools that can:

Boost productivity 🔥
Help developers automate tasks
Assist content creators with smart workflows

📌 What’s Next?

This is just the beginning. I’ll be uploading:

AI tutorials
Vue.js and Firebase guides
Productivity hacks for developers

🙌 Let’s connect!

If you find it useful, give it a like 👍, share 💬, and subscribe 🔔.

Your support means the world!

Follow me on:

🌐 Website: https://dixitcodermanageaitools.vercel.app/profile
🐦 Twitter: @dixitcoder
📷 Instagram: @dixitcoder
🧠 GitHub: https://github.com/dixitcoder

Let me know what you think in the comments below 🙏

ai #webdev #youtube #dixitcoder #productivity #tools

✅ Kotlin Code (Jetpack Compose UI):kotlin

dixit patel — Sun, 25 May 2025 08:43:57 +0000

Sure Dixit! Tamne ek full working example apo chhu je tamara Android Compose project ma terminal jevu command interface aapse. Aa example ma basic Linux style commands support chhe: pwd, ls, cd, cat, help, echo, date, mkdir, rm.

Current directory state is tracked with currentDir.

- Commands pwd, ls, cd, cat, echo, date, mkdir, rm, and help are implemented.
- Terminal UI shows history of commands + output.
- User can type commands at bottom input field.
- cd changes directory in app state; ls lists files relative to current directory.

Terminal UI with scrolling

Input TextField to send commands (optional)

Proper keyboard handling with the fixes you asked for

Run shell commands and handle errors gracefully

package com.example.testtinge_andorid

import android.os.Bundle
import android.os.Environment
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalSoftwareKeyboardController

import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.unit.dp
import java.io.File
import java.text.SimpleDateFormat
import java.util.*

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            TerminalScreen()
        }
    }
}

@Composable
fun TerminalScreen() {
    var currentDir by remember { mutableStateOf(Environment.getExternalStorageDirectory().path) }
    val messages = remember { mutableStateListOf<String>() }

    LaunchedEffect(Unit) {
        messages.add("Device Activated Successfully // shell ready")
        messages.add("Type 'help' to see commands.")
    }

    // Function to run commands
    fun runShellCommand(command: String): String {
        val trimmedCmd = command.trim()
        if(trimmedCmd.isEmpty()) return ""

        val args = trimmedCmd.split(" ")

        return when (args[0]) {
            "pwd" -> currentDir
            "ls" -> {
                val path = if (args.size > 1) {
                    if (args[1].startsWith("/")) args[1] else "$currentDir/${args[1]}"
                } else currentDir

                val dir = File(path)
                if (dir.exists() && dir.isDirectory) {
                    val files = dir.listFiles()
                    files?.joinToString("  ") { it.name } ?: "Empty directory"
                } else {
                    "Directory not found: $path"
                }
            }
            "cd" -> {
                if (args.size < 2) return "Usage: cd <directory>"
                val newPath = if (args[1].startsWith("/")) args[1] else "$currentDir/${args[1]}"
                val dir = File(newPath).canonicalFile
                if (dir.exists() && dir.isDirectory) {
                    currentDir = dir.path
                    "Changed directory to: $currentDir"
                } else {
                    "Directory not found: $newPath"
                }
            }
            "cat" -> {
                if (args.size < 2) return "Usage: cat <filename>"
                val filePath = if (args[1].startsWith("/")) args[1] else "$currentDir/${args[1]}"
                val file = File(filePath)
                if (file.exists() && file.isFile) {
                    file.readText()
                } else {
                    "File not found: $filePath"
                }
            }
            "echo" -> {
                args.drop(1).joinToString(" ")
            }
            "date" -> {
                val sdf = SimpleDateFormat("EEE MMM dd HH:mm:ss z yyyy", Locale.getDefault())
                sdf.format(Date())
            }
            "mkdir" -> {
                if (args.size < 2) return "Usage: mkdir <directory>"
                val newDirPath = if (args[1].startsWith("/")) args[1] else "$currentDir/${args[1]}"
                val dir = File(newDirPath)
                if (dir.exists()) {
                    "Directory already exists: $newDirPath"
                } else {
                    if (dir.mkdirs()) "Directory created: $newDirPath"
                    else "Failed to create directory: $newDirPath"
                }
            }
            "rm" -> {
                if (args.size < 2) return "Usage: rm <filename|directory>"
                val targetPath = if (args[1].startsWith("/")) args[1] else "$currentDir/${args[1]}"
                val target = File(targetPath)
                if (!target.exists()) {
                    "File or directory not found: $targetPath"
                } else {
                    if (target.isDirectory) {
                        if (target.deleteRecursively()) "Directory deleted: $targetPath"
                        else "Failed to delete directory: $targetPath"
                    } else {
                        if (target.delete()) "File deleted: $targetPath"
                        else "Failed to delete file: $targetPath"
                    }
                }
            }
            "help" -> {
                """
                Available commands:
                pwd                - Print current directory
                ls [dir]           - List files in directory
                cd <dir>           - Change directory
                cat <file>         - Display file contents
                echo <text>        - Display text
                date               - Show current date and time
                mkdir <dir>        - Create directory
                rm <file|dir>      - Delete file or directory
                help               - Show this help message
                """.trimIndent()
            }
            else -> "Unknown command: ${args[0]}"
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(Color.Black)
            .padding(16.dp)
    ) {
        Terminal(
            messages = messages,
            onCommandEntered = { command ->
                messages.add("└─\$ $command")
                val output = runShellCommand(command)
                messages.add(output)
            }
        )
    }
}


@Composable
fun Terminal(
    messages: List<String>,
    modifier: Modifier = Modifier,
    onCommandEntered: (String) -> Unit
) {
    val scrollState = rememberScrollState()
    var inputText by remember { mutableStateOf("") }
    val keyboardController = LocalSoftwareKeyboardController.current

    Column(
        modifier = modifier
            .fillMaxSize()
            .verticalScroll(scrollState)
    ) {
        Text(
            text = "┌──[dixitcoder@device]─[~]",
            color = Color.Green,
            fontFamily = FontFamily.Monospace
        )
        Spacer(modifier = Modifier.height(8.dp))

        for (message in messages) {
            Text(
                text = message,
                color = Color.White,
                fontFamily = FontFamily.Monospace
            )
            Spacer(modifier = Modifier.height(4.dp))
        }

        Spacer(modifier = Modifier.weight(1f))

        // Input line
        TextField(
            value = inputText,
            onValueChange = { inputText = it },
            modifier = Modifier.fillMaxWidth(),
            singleLine = true,
            textStyle = androidx.compose.ui.text.TextStyle(color = Color.White, fontFamily = FontFamily.Monospace),
            placeholder = { Text("Enter command...", color = Color.Gray) },

            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
            keyboardActions = KeyboardActions(
                onDone = {
                    if (inputText.isNotBlank()) {
                        onCommandEntered(inputText)
                        inputText = ""
                        keyboardController?.hide()
                    }
                }
            )
        )
    }
}

🚀 Discover DixitCoder's AI Tools List: Your Gateway to 256+ Free AI Resources

dixit patel — Tue, 20 May 2025 13:40:09 +0000

As developers, staying updated with the latest AI tools can significantly enhance our productivity and innovation. DixitCoder's AI Tools List offers a curated collection of over 256 free AI resources, ranging from coding assistants to creative generators.
dixitcoder-tools-ai.web.app
+1
Pragmatic Coders
+1

🔍 What is DixitCoder's AI Tools List?
DixitCoder's AI Tools List is a comprehensive directory that categorizes AI tools into various domains, making it easier for developers to find the right tool for their needs. Whether you're looking for tools in machine learning, natural language processing, or creative AI, this list has something for everyone.

🛠️ Key Features
Extensive Collection: Access to over 256 AI tools across different categories.

User-Friendly Interface: Designed with developers in mind for easy navigation.

Regular Updates: The list is continuously updated to include the latest AI tools.

Open Source: Contributions are welcome, allowing the community to grow the list collaboratively.
code-intelligence.com
+6
dixitcoder-tools-ai.web.app
+6
Synthesia
+6

💡 Why Should You Explore This List?
Save Time: Quickly find the right AI tool without sifting through countless websites.

Stay Updated: Keep abreast of the latest developments in AI technology.

Enhance Your Projects: Integrate cutting-edge AI tools into your projects to improve functionality and performance.
dixitcoder-tools-ai.web.app

🌐 Explore the AI Tools List
Dive into the collection and start exploring the tools that can elevate your development projects.
DEV Community
+1
Forem
+1

🔗 Visit DixitCoder's AI Tools List

DixitGuard — Linux Remote Monitoring & Alert Script

dixit patel — Thu, 15 May 2025 15:50:00 +0000

How It Works (High-level)
On startup, the script reads system details (username, hostname, IP, current time).

It checks Firebase Realtime Database to see if this device is registered — if not, it registers itself with initial data.

Every 10 seconds, it queries Firebase for two flags: alert and screenshot.

If alert is set, it sends a Telegram message with login/system info, then resets the flag.

If screenshot is set, it captures the screen, sends the image to Telegram, then resets the flag.

This process repeats indefinitely, allowing remote monitoring and commands through Firebase and Telegram.

DixitGuard

DixitGuard is a remote monitoring script project that allows you to monitor login alerts and take screenshots on a Linux machine. It integrates with Firebase Realtime Database and Telegram Bot API to send alerts and screenshots remotely.

Features

Sends login alerts with user, date, hostname, and IP address.
Stores login info on Firebase Realtime Database.
Takes screenshots remotely based on Firebase flags.
Sends screenshots to Telegram.
Periodically checks Firebase for commands.

Setup Instructions

Prerequisites

Linux machine with bash
curl installed
import tool from ImageMagick installed (sudo apt install imagemagick)
Firebase Realtime Database setup with rules allowing your bot to read/write
Telegram bot token and chat ID

Firebase Setup

Create a Firebase project at https://console.firebase.google.com/
Create a Realtime Database
Set database rules to allow read/write for your bot (for testing only; secure it for production)
Note the database URL (ends with .firebaseio.com or similar)

Telegram Setup

Create a bot via BotFather on Telegram
Get your Bot Token
Find your chat ID by messaging your bot and using tools like userinfobot 4.Full Codes (https://github.com/dixitcoder/DixitGuard/tree/main)

Configure Script

Edit the script to set these variables:


bash
BOT_TOKEN="your_telegram_bot_token_here"
CHAT_ID="your_chat_id_here"
DB_URL="your_firebase_database_url_here"
Running the Script
Make the script executable:


chmod +x DixitGuard.sh
Run it in background or screen:


./DixitGuard.sh &
How It Works
On startup, it registers the host in Firebase if not already present.

Every 10 seconds, it checks Firebase flags for:

alert: sends a login alert to Telegram and resets the flag.

screenshot: takes a screenshot, sends it to Telegram, and resets the flag.

Security Notice
This script is intended for educational and authorized monitoring only. Unauthorized access or surveillance is illegal and unethical.

License
MIT License

> Project Overview
DixitGuard is a Linux shell script project designed for remote monitoring and alerting using Firebase Realtime Database and Telegram Bot API.

It helps you remotely track Linux device usage by:

Sending login alerts with system info (user, hostname, IP address, login time) to a Telegram chat.

Taking screenshots on demand and sending them to Telegram.

Polling Firebase Realtime Database to listen for remote commands (alerts or screenshot requests).

Automatically initializing its Firebase entry on first run to store device info and state.