DEV Community: Ketut Dana

hello, I make this new tools call envGo, please check and review at https://envgo.dev

Ketut Dana — Fri, 02 Oct 2026 00:43:32 +0000

envGo — Keep .env values out of the browser | envGo

Zero-dependency Go binary that serves your static HTML and injects .env secrets server-side. No Node, no build — secrets never reach the browser. MIT, no telemetry.

envgo.dev

envGo >> https://envgo.dev

Ketut Dana — Wed, 30 Sep 2026 13:55:47 +0000

envGo — Keep .env values out of the browser | envGo

Zero-dependency Go binary that serves your static HTML and injects .env secrets server-side. No Node, no build — secrets never reach the browser. MIT, no telemetry.

envgo.dev

envgo: a dependency-free .env runtime for static sites — browser hot reload over SSE, envgo cache clear, and self-updates, no Node.js needed. Give it a try 🚀 https://envgo.dev

Ketut Dana — Sat, 26 Sep 2026 06:29:36 +0000

envGo — Keep .env values out of the browser | envGo

Zero-dependency Go binary that serves your static HTML and injects .env secrets server-side. No Node, no build — secrets never reach the browser. MIT, no telemetry.

envgo.dev

Ketut Dana — Thu, 24 Sep 2026 07:43:20 +0000

Hey Dev.to community! I built envGo—a lightweight, zero-dependency Go binary (2–8 MB) that serves your static site and injects .env secrets safely on the server-side, keeping API keys completely invisible to browser DevTools and the Network tab without needing a Node.js runtime. It features hot reload, a built-in proxy/gateway, zero telemetry, and an MIT license. I would love for you to try it out, break it, and share your review or feedback on the codebase. You can check it out at https://envgo.dev and grab the source on GitHub!

Niche Collector — Collection Tracker + Price Intelligence

Ketut Dana — Tue, 22 Sep 2026 05:05:36 +0000

Sanity Challenge — Path 2: Vibe-code something strange

Portfolio tracker for niche hobbies (Hot Wheels, Gunpla, Mechanical Keyboards) that proves why structured content beats keyword search. Every valuation is a GROQ aggregation, outlier-aware.

🔗 Links

Live Demo: https://sanity-challenge.vercel.app
Collection Demo (GROQ live): https://sanity-challenge.vercel.app/collection
Sanity Studio (public, no login): https://sanity-challenge.vercel.app/studio
GitHub (MIT): https://github.com/dnysaz/niche-collector
Sanity Project ID: 71m89sy5
Dataset: production — https://71m89sy5.apicdn.sanity.io/v2024-01-01/data/query/production?query=*[_type=="collectibleItem"]
Organization ID: os9xuj7u1

Submission tag: #sanitychallenge

What I Built

Niche Collector is a collection portfolio for hobbyists who track value — not just items. Think Hot Wheels Treasure Hunts, Gunpla kits, custom keyboards. The app stores your purchase price vs current market, pulls priceHistory from Tokopedia/Shopee listings, and auto-calculates gain/loss. The trick: a scam Rp 5,000,000 listing is flagged isOutlier=true and excluded from the median — so your portfolio stays honest.

It’s deliberately boring in the best way: no AI chat, just structured data doing work keyword search can’t.

Why this only works with structured content: Try answering “total market vs total purchase for owned grails” with full-text search. You can’t. You need math::sum(*[_type=="collectibleItem" && status=="owned"].currentValue) and a filtered priceHistory join on item._ref. That’s 100% schema-dependent.

Demo — What to Click

/ — landing explains schema + shows GROQ example
/collection — live portfolio:
- TOTAL MARKET Rp 3,900,000 vs TOTAL PURCHASE Rp 2,900,000 → +Rp 1,000,000 (34%) (computed via GROQ, not client JS)
- Cards: Hot Wheels Camaro STH (+733%), Nu Gundam (+31%), Keychron Q1 (-14%) with trend Tokopedia → Shopee
- Outlier filtered: Camaro has 3 history docs, but only 2 shown — the 5M scam is excluded
/studio — Sanity Studio (embedded NextStudio, basePath: '/studio', Vision enabled). Try Vision:

   *[_type=="priceHistory" && isOutlier != true] | order(recordedAt desc){price, source, "item": item->title}

SEO goodies: /opengraph-image (1200×630 edge), /icon.svg, /sitemap.xml, /robots.txt, JSON-LD WebApplication

If NEXT_PUBLIC_SANITY_PROJECT_ID is missing, /collection falls back to mock — but on Vercel it’s live against 71m89sy5/production (14 seeded docs).

Schema — Thoughtfulness Behind It

5 types in sanity/schemaTypes/ — designed for portfolio math, not just CMS text:

// sanity/schemaTypes/index.ts
export const schemaTypes = [hobbyCategory, collectibleItem, collection, priceHistory, wishlist]

Type	Why it exists	Key fields
hobbyCategory	Taxonomy + scraping hints	`title`, `slug`, `icon` (🏎️🤖⌨️), `marketplaceKeywords` for future scraper
collectibleItem	Core asset	`title`, `slug`, `category(ref)`, `brand`, `year`, `sku`, `condition(enum: mint_sealed/mint_loose/used_excellent/used_good/damaged)`, `rarity(enum: common/uncommon/rare/grail)`, `images`, `purchasePrice`, `purchaseDate`, `currentValue` (override median), `quantity`, `status(owned/wishlist/sold)`, `tags`, `notes`, `sourceUrl`
collection	Curated showcase	`title`, `owner`, `category(ref)`, `items(ref[])`, `isPublic`, `coverImage`
priceHistory	Market intelligence	`item(ref)`, `source(tokopedia/shopee/bukalapak/ebay/manual)`, `price`, `currency`, `recordedAt`, `conditionAtSource`, `isOutlier` (excluded via `isOutlier != true`), orderings by `recordedAt desc`
wishlist	Hunt + alerts	`title`, `category(ref)`, `targetPrice`, `priority(low/medium/high/grail)`, `alertActive`, `notes`, `referenceUrl`

Relations matter: collectibleItem.category -> hobbyCategory, priceHistory.item -> collectibleItem, collection.items -> collectibleItem[], wishlist.category -> hobbyCategory. Validations (required, min(0)), initialValue, preview, and orderings are set — judges can verify in Studio.

Config in sanity.config.ts:

defineConfig({
  projectId: "71m89sy5",
  dataset: "production",
  basePath: "/studio",
  plugins: [structureTool(), visionTool()],
})

GROQ — Only Works Because It’s Structured

// sanity/lib/queries.ts — Portfolio stats
{
  "totalItems": count(*[_type=="collectibleItem" && status=="owned"]),
  "totalPurchase": math::sum(*[_type=="collectibleItem" && status=="owned"].purchasePrice),
  "totalMarket": math::sum(*[_type=="collectibleItem" && status=="owned"].currentValue),
  "wishlistCount": count(*[_type=="wishlist"]),
  "grails": *[_type=="collectibleItem" && rarity=="grail" && status=="owned"]{title, currentValue}
}

// Items with gain + 5 last prices (outlier-aware)
*[_type=="collectibleItem" && status=="owned"] | order(currentValue desc){
  title, purchasePrice, currentValue,
  "gain": currentValue - purchasePrice,
  "gainPercent": round(((currentValue - purchasePrice)/purchasePrice)*100),
  "priceHistory": *[_type=="priceHistory" && item._ref==^._id && isOutlier != true]
    | order(recordedAt desc)[0..5]{price, recordedAt, source}
}

Try on prod: https://71m89sy5.apicdn.sanity.io/v2024-01-01/data/query/production?query=*[_type=="collectibleItem"]{title,currentValue} — returns 3 docs, not mock.

Build Process — Honest Writeup

Vibe-coded? Yes, but not blindly. Started with npm create sanity@latest / create-next-app prompt from Sanity’s “niche-collector” starter (Project 71m89sy5, production, monorepo studio + web). I kept the Studio embedded in Next.js at app/studio/[[...tool]] (NextStudio) instead of standalone — easier for Vercel single deployment, judged as “custom app on top of content”.

Where Sanity features were used deep:

Custom schemas with references + enums (not a blog template)
Vision for GROQ debugging
basePath: '/studio' + CORS for embedded Studio (had to add localhost:3000 + Vercel domains via npx sanity cors add --credentials)
math::sum not sum — learned via CLI error Undefined function sum
imageUrlBuilder ready for future images[0] thumbnails

Rough edges I hit and fixed:

npm EACCES mkdir ~/.npm/_cacache → used npm_config_cache=/tmp/npm-cache (macOS root-owned cache bug)
Tool not found: studio → missing basePath in sanity.config.ts, fixed + restart dev
Hydration mismatch data-new-gr-c-s-check-loaded (Grammarly) → added suppressHydrationWarning in app/layout.tsx
swr default import error with Sanity + Next 16 Turbopack → wrapped Studio in 'use client' Studio.tsx + pinned swr@2.3.7
No Output Directory dist on Vercel → set vercel.json {framework: "nextjs", outputDirectory: ".next"} (initial vercel link detected no framework)
Canonical mismatch niche-collector.vercel.app vs sanity-challenge.vercel.app → set NEXT_PUBLIC_SITE_URL + redeploy

What I didn’t do (and why): No App SDK custom app (would duplicate Studio for this scope) and no Workflows — portfolio doesn’t need approval flows. A polished blog template would have scored lower on “thoughtfulness of schema”, so I kept the data model niche.

Stack: Next.js 16 (App Router, Turbopack) + Tailwind 4 + Sanity 6 + next-sanity 13, edge OG 1200×630, sitemap/robots, JSON-LD WebApplication, MIT license.

How to Run Locally

git clone https://github.com/dnysaz/niche-collector.git
cd niche-collector

npm_config_cache=/tmp/npm-cache npm install
cp .env.local.example .env.local
# NEXT_PUBLIC_SANITY_PROJECT_ID=71m89sy5
# NEXT_PUBLIC_SANITY_DATASET=production

npm_config_cache=/tmp/npm-cache npx sanity login --provider google
npm_config_cache=/tmp/npm-cache npx sanity dataset import sanity/seed.ndjson production -p 71m89sy5
npm_config_cache=/tmp/npm-cache npx sanity cors add http://localhost:3000 --credentials

npm_config_cache=/tmp/npm-cache npm run dev # http://localhost:3000/studio + /collection
npm run build # Route: / , /collection (1m), /studio, /opengraph-image (ƒ)

Seed has 14 docs — open Studio, edit currentValue of Camaro, watch /collection recompute gain.

Submission Checklist

[x] Sanity Project ID: 71m89sy5 (in post + sanity.config.ts + .env.local)
[x] Dataset: production (public query URL above)
[x] Live demo: https://sanity-challenge.vercel.app
[x] Studio: https://sanity-challenge.vercel.app/studio (no login required for view, CORS enabled)
[x] GitHub: https://github.com/dnysaz/niche-collector (MIT)
[x] Honest writeup above (not 3 sentences)
[x] Tag: #sanitychallenge

If I Had More Time

Scraper cron (Vercel Cron) that hits Tokopedia/Shopee search via marketplaceKeywords → creates priceHistory docs → currentValue = median(last 7 non-outlier)
Wishlist alert email when min(priceHistory.price) <= targetPrice
App SDK custom dashboard for collection showcase (filter by isPublic)

Thanks for reading — happy collecting! 🏎️🤖⌨️

EnvGo: Stop Leaking Your API Keys, Seriously Guys

Ketut Dana — Tue, 22 Sep 2026 00:25:34 +0000

Hey everyone,

Let me be honest with you. I did something stupid before.

I put my OpenAI API key directly inside my JavaScript file. Like this:

const API_KEY = "sk-live-abc123..."

And pushed it. And yeah, anyone who opened DevTools could see it. My $5 credit gone in one night because someone scraped my key and used it. Painful.

If you are a frontend dev, solo learner, or just building a cool landing page with vanilla HTML + JS, you probably faced this same problem. You want to call an API, but you don't want to learn Express, setup Node, deploy a backend, just to hide ONE key. That feels overkill, right?

That's why I made EnvGo.

So, What is EnvGo?

EnvGo is a super simple idea. It's a single Go binary (around 2-8 MB, no Node, no npm install, no node_modules drama) that does two jobs at once:

Serves your static HTML files
Holds your .env secrets safely on the server

The magic is in how it handles secrets. You never write the real key in your JS. You just write a placeholder:

headers: { Authorization: "Bearer {OPENAI_API_KEY}" }

Your browser sends literally {OPENAI_API_KEY} as text. EnvGo, running on the server, swaps it with the real value from your .env and forwards it to OpenAI. The secret never, ever reaches the browser. Not in DevTools, not in Network tab, not in memory. Clean.

Why I Built This?

I see many beginners stuck here. They can make a beautiful site with AI (Cursor, Claude), but once they need an API key, tutorials say "create a backend" and they give up.

EnvGo is the bridge — from index.html to "needs one secret" without learning a framework. Designer, student, or prototyping fast? This is for you. Need a database or auth? Use Next.js. EnvGo solves ONE problem well, intentionally.

How It Works (30 seconds)

mkdir myapp && cd myapp
envgo init      # creates .env, index.html
# put real key in .env
envgo run dev   # http://127.0.0.1:8080

HTML: <div id="MY_SECRET"></div> + <script src="/__env.js"></script> shows ✓ Success (hidden). JS calls /proxy with a token; for production, define fixed routes in envgo.routes.json and call fetch("/api/chat"). Hot-reload, dashboard, and typo detection included.

Where to Download?

It's free, MIT licensed, no telemetry, no account needed. Just grab the binary:

https://envgo.dev/download/

We have builds for macOS (Apple Silicon & Intel), Linux (amd64 & arm64), and Windows. Or get it from GitHub:

https://github.com/dnysaz/envgo/releases/latest

All links there always point to the latest version. Latest is v1.0.1 now with the new MODE_PUBLIC via .env feature.

Full docs are at https://envgo.dev — super honest about limitations too.

I Need Your Feedback!

This is made with love, but I'm sure it's not perfect. If the error message is confusing, or install fails on your laptop, or you have an idea — please tell me!

Bug or idea? Open an issue: github.com/dnysaz/envgo/issues
Security concern? Check SECURITY.md (report privately)
Just want to say hi or ask? Start a discussion on GitHub.

If you try EnvGo and it saves you one hour of backend setup, that's a win for me. Give it a star, try it on your next static project, and let me know what you think in the comments below.

Thanks for reading, guys. Happy coding and keep your keys safe!

— Ketut Dana

I Secured workatbali.com & workinbali.com — Looking for Serious Collaborators to Build a Bali Tech Startup!

Ketut Dana — Tue, 08 Sep 2026 08:48:19 +0000

Hi DEV Community! 👋

I'm Ketut Dana, a software engineer and local developer based directly here in Bali, Indonesia.

I just officially secured two high-potential domains: workatbali.com and workinbali.com.

Given Bali's position as a global hub for remote workers, digital nomads, and tech talent, I am planning to build a platform/startup around these domains. Whether it's a dedicated job board, ecosystem platform, talent network, or remote-work directory for Bali, the possibilities are open to strong execution.

I’m looking for serious collaborators or a co-founder who wants to build this together from the ground up—whether you are a fellow developer, UI/UX designer, marketer, or product strategist.

Requirements:

Serious and committed individuals only.

Passionate about building products for the remote work/tech ecosystem in Bali.

Since I am a native local based in Bali, we can easily coordinate on-site or work asynchronously.

If you are interested in collaborating, let's connect:

Email: workinbali26@gmail.com

WhatsApp: +62 8580 5566344

Let’s build something valuable together!

CloudBanana DE — Your VPS Just Got a Desktop Environment

Ketut Dana — Sat, 18 Jul 2026 08:02:18 +0000

# CloudBanana DE — Your VPS Just Got a Desktop Environment

Written for dev.to • July 2026 • GitHub

Hey everyone! 👋

So I've been working on this open-source project for a while, and I'm really excited to finally share it with everyone. It's called CloudBanana DE — basically, a web-based desktop environment for managing your Linux VPS.

I know what you're thinking: "Another server management panel?" Not this time. This one is different. Not a dashboard with a bunch of buttons — it's a full-blown desktop. Like, you open your browser, and there's a login screen, a taskbar, a dock, windows you can drag around. It feels like using a real computer, but it's all running in your browser, connected to your VPS.

Let me break it down with the classic 5W + 1H so you can see the full picture.

What is CloudBanana DE?

CloudBanana Desktop Environment is a lightweight, web-based desktop environment that runs in your browser and connects to your Linux VPS. It gives you a Windows/macOS-like graphical interface with windows, taskbar, file manager, terminal, dock, and 30+ built-in applications — all without needing SSH or opening a terminal.

Think of it like this: instead of remembering 50 different Linux commands just to manage your server, you get a proper GUI where you can click, drag, and explore. It's built with React 19 + FastAPI and runs on any Debian-based VPS (Ubuntu 22.04/24.04 recommended).

Why CloudBanana DE?

Because managing a VPS through the terminal can be a pain — especially if you're not a Linux power user. Here's the problem most people face:

You need to remember hundreds of CLI commands
Switching between SSH sessions is annoying
Dashboard panels (CyberPanel, aaPanel) are just forms — not real GUIs
Coolify is great but it's Docker-centric and still CLI-heavy

CloudBanana DE solves all of that. You get a real desktop environment where you can open a file manager, drag files around, edit code in VS Code-quality Monaco editor, run terminal commands if you want, install software with one click — all from your browser. No SSH client needed. No command memorization.

The "aha" moment: When you realize you can manage Nginx, databases, Laravel projects, SSL certificates, cron jobs, and even browse the web — all from the same browser tab. And everything survives page reload. Close the tab, open it again, your windows are right where you left them.

Who is it for?

Basically anyone who runs a Linux VPS:

Web developers who deploy and manage Laravel, PHP, or Node.js apps
Sysadmins who want a GUI for server monitoring and file management
DevOps beginners who find the terminal intimidating
Agency owners who manage multiple client websites on a single VPS
Self-hosters who run their own services (Nextcloud, WordPress, etc.)
Students learning Linux server administration

When can you use it?

Right now! CloudBanana DE v0.1.0 is already available and working. It's in beta so there might be some rough edges, but the core features are solid and usable daily.

The installer script takes about 5-10 minutes to set everything up: Python venv, Node.js, Nginx, systemd service, firewall rules — all automated.

Where does it run?

Any Debian-based Linux distribution with:

Python 3.10+
Node.js 18+
Nginx
systemd

Optimized for Ubuntu 22.04/24.04 LTS, but works on Debian, Linux Mint, Pop!_OS, etc. You can install it on a $5 VPS from DigitalOcean, Linode, Vultr, or any provider. After installation, access it through your browser at http://your-server:8888.

How does it work?

Here's the quick install (it's literally 3 commands):

git clone https://github.com/dnysaz/cloudbanana.de.git
cd cloudbanana.de
sudo bash install.sh

The installer will:

Install Python dependencies and Node.js
Build the React frontend
Set up Nginx reverse proxy on port 8888
Create a systemd service (auto-starts on reboot)
Configure UFW firewall
Install the cloudbanana CLI tool
Optionally set up HTTPS via Let's Encrypt

After installation, you can manage the service with simple CLI commands:

cloudbanana start     # Start the service
cloudbanana stop      # Stop the service
cloudbanana status    # Check if it's running
cloudbanana logs      # View real-time logs

Cool Features (a quick tour)

Actual Desktop Environment

Not a boring dashboard — a real desktop with windows, dock, start menu, desktop icons, wallpaper picker (20+ built-in), and even a calendar popup on the taskbar. You can drag windows around, resize them, minimize, maximize. It feels like using macOS or Windows, but in a browser tab.

Monaco Code Editor

Yes, the same editor VS Code uses. Syntax highlighting, minimap, multiple cursors, multiple tabs that survive reload, drag-and-drop tab reordering, file tree sidebar, and an integrated terminal panel. Basically VS Code in your browser, connected to your VPS filesystem.

WebSocket Terminal

Full bash shell with xterm-256color emulation, multi-tab support, resizable panel. You can run any command right from the browser. Perfect for when you still need that CLI power.

Web Server Management

Nginx config editor with syntax testing before saving. PHP version manager. SSL certificate viewer and Let's Encrypt auto-installer. Subdomain manager that generates Nginx configs automatically. Hosts file editor with confirmation modal.

Database Tools

Query MySQL and PostgreSQL directly from the UI. Browse SQLite databases, execute SELECT/PRAGMA queries. No more phpMyAdmin headaches.

Laravel Wizard

Full Laravel project setup wizard — clone from Git or upload ZIP, auto-install Composer, configure .env, run migrations, create Nginx vhost, build assets. All from one interface. Plus a management dashboard to toggle sites online/offline, rollback migrations, change PHP version per project.

49 One-Click Software Packages

Docker, Nginx, Apache, Python, Node.js, PostgreSQL, MongoDB, Redis, Rust, Go, Certbot, Grafana, Prometheus, Portainer, PM2, Fail2ban, Netdata, Composer, Yarn, FFmpeg, and many more.

Banana Browser

A built-in web proxy browser that runs inside your desktop. Cookie persistence, YouTube embed conversion, anti-frame-busting, SPA navigation support. Optional Playwright headless Firefox engine. Browse the web from your server.

System Monitoring

Real-time CPU per-core, RAM, Swap, Disk (multi-partition), Network I/O. Live desktop widgets showing system stats. Process viewer with kill capability. Audit logs tracking login/logout and admin actions.

Bonus: Games & Media

Snake, Ping Pong, BNote (multi-tab text editor with syntax highlighting), BWeb (WebView iframe), Media Viewer for images and videos. Because managing a server shouldn't be boring.

Security

Since this runs on your server, security matters. Here's what's built in:

JWT with httpOnly cookies + CSRF double-submit pattern
Rate limiting on all auth endpoints
Account lockout after 5 failed attempts (15 min cooldown)
PBKDF2 password hashing (100,000 iterations)
Path traversal prevention on all file operations
Private host blocking in proxy and wget
Separate system user with scoped sudo privileges
Read-only SQLite query mode

Important: There's no email-based password recovery yet (it's still beta), so please use a strong password. Your feedback and bug reports are very welcome!

Comparison: CloudBanana vs Other Panels

Here's why CloudBanana DE is different from CyberPanel, aaPanel, and Coolify:

Feature	CloudBanana DE	Others
Desktop UI	✅ Full desktop	❌ Dashboard only
SSH-Free	✅ 100% browser	❌ SSH required
Code Editor	✅ Monaco (VS Code)	❌ Basic / None
WebSocket Terminal	✅ Full PTY bash	⚠️ Basic / None
Built-in Web Browser	✅ Banana Browser	❌ None
Software Install	✅ 49 packages	⚠️ Limited / Docker
Laravel Management	✅ Wizard + Dashboard	❌ Manual
Multi-User Login	✅ GDM-style picker	❌ Single admin
Window Persistence	✅ Survives reload	❌ None
Theme & Wallpapers	✅ 20+ wallpapers	❌ None
License	✅ MIT (100% open)	⚠️ Partial / AGPLv3

Tech Stack

Built with modern, battle-tested technologies:

React 19 • TypeScript + Vite 8 • FastAPI • SQLite + SQLModel • JWT + CSRF • Zustand 5 • xterm.js • Nginx • systemd • Playwright • Lucide Icons • SlowAPI

Project Structure

/etc/cloudbanana/
├── backend/
│   ├── app/
│   │   ├── main.py           # FastAPI app (2500+ lines)
│   │   ├── auth.py           # JWT, hashing, rate limiter
│   │   ├── models.py         # SQLModel models
│   │   ├── database.py       # SQLite + WAL mode
│   │   ├── apps.py           # 49 software definitions
│   │   ├── browser_proxy.py  # BananaBrowser proxy
│   │   ├── playwright_browser.py
│   │   └── utils/system.py
│   └── requirements.txt
├── frontend/
│   ├── src/
│   │   ├── App.tsx            # Main React app
│   │   ├── main.tsx           # Entry point
│   │   ├── api.ts             # HTTP client + auth
│   │   ├── types.ts           # TypeScript types
│   │   ├── style.css          # 2500+ lines of CSS
│   │   ├── store/             # Zustand stores
│   │   └── components/        # 30+ React components
│   └── package.json
├── scripts/                   # 48 install scripts
├── install.sh                 # Master installer
├── cloudbanana.sh             # CLI tool
└── README.md

Final Thoughts

CloudBanana DE is still in beta, but it's already pretty usable. I built it because I was tired of switching between SSH sessions and dashboard panels just to manage my servers. I wanted something that feels like a real operating system.

It's 100% open source (MIT license), so you can self-host it on your own VPS. No SaaS fees, no data leaving your server, no subscriptions.

If you try it, I'd love to hear your feedback! Drop an issue on GitHub, leave a comment here, or contribute a PR. Let's make VPS management less painful for everyone. ✌️

Links:

GitHub: github.com/dnysaz/cloudbanana.de
Landing Page: https://cloudbanana.de
Report Issues: github.com/dnysaz/cloudbanana.de/issues

Made with ❤️ for the VPS community

Just having fun at only4.fun

Ketut Dana — Thu, 07 May 2026 05:53:37 +0000

don't let your country lose on this game, join now at https://only4.fun , TAP to win!!

I Just Launched KeyYap — A Text-Only Social Platform for Introverts

Ketut Dana — Mon, 04 May 2026 05:17:41 +0000

Hey Dev.to! 👋

I just launched something I've been building: KeyYap — a text-only social platform for introverts. It's live right now at keyyap.com and I'd love for you to check it out.

Why I Built This

Honestly? I got tired of social media feeling like a performance.

Every platform wants you on camera. Instagram wants perfect photos. TikTok wants you to film yourself. Even Twitter feels like a constant battle for attention and engagement.

I kept thinking — where do you go when you just want to say something? Not perform. Not film yourself. Just share a thought with people who might actually care?

That gap is why KeyYap exists.

What is KeyYap?

KeyYap is simple.

You write. You post. People read it.

512 characters max — enough to say something real, not enough to write an essay
Text only — no photos, no videos, nothing but words
Emoji avatars — pick an emoji that represents you, no selfies required
No algorithm pressure — just a clean, honest feed
Built for introverts — safe, low-pressure, judgment-free

Think of it like TikTok — but instead of scrolling through videos, you scroll through thoughts. Real, human, unfiltered thoughts.

The Name

KeyYap. Key + Yap.

"Yapping" has a bad reputation. People use it as an insult — "stop yapping," "you yap too much." Like having things to say is a character flaw.

We think that's wrong. Yapping is human. It's how we process the world, find our people, and make sense of what's happening around us.

KeyYap is just a good place to do it.

A good place for yapping. 🌙

Current Status

KeyYap is in public beta right now.

It works. You can sign up, create posts, follow people, like, comment, and explore the feed. It's real and it's live.

Is it perfect? No. It's beta. There are rough edges and things I'm still improving. But I believe in shipping early and iterating based on real feedback from real users — not building in silence forever.

What I'd Love From You

This is where I genuinely need help.

Try it: keyyap.com — sign up, post something, explore. Even just one yap would mean a lot.

Tell me what's broken. If something doesn't work, I want to know. Comment here or reach out directly.

Tell me what's missing. What feature would make you actually use this regularly?

Tell me if the concept resonates. Is "text-only social for introverts" something you'd actually use? Or is it solving a problem that doesn't exist?

I'm building this in public and every piece of honest feedback shapes what KeyYap becomes next.

What's Coming Next

I'm actively working on:

Better trending algorithm
Improved notifications
More profile customization
Performance improvements
Mobile experience polish

And longer term — if there's enough community interest — a proper mobile app.

Final Thought

I built KeyYap because I needed it myself.

A place to share thoughts without performing. Without worrying about how I look. Without fighting an algorithm. Just a clean space to yap freely with people who get it.

If that sounds like something you need too — come join us.

keyyap.com — A good place for yapping. 🌙

Thanks for reading. Would love to hear your honest thoughts — good, bad, or brutally critical. Drop them in the comments below!

Building KeyYap: Crafting a Premium "Yapping" Platform

Ketut Dana — Fri, 17 Apr 2026 09:34:09 +0000

Introduction

In the era of "over-engineered" social media, I wanted to build a place where the focus is simple: quick thoughts, community, and clean aesthetics.

Meet KeyYap, a platform designed for the modern "Yapper." It’s built to feel premium, move fast, and provide a distraction-free space for sharing. Today, I’m diving into the design and tech choices that make KeyYap unique.

The Tech Stack Performance was non-negotiable. Here is the architecture behind the platform:

Framework: Next.js (App Router) - Leveraging server components for speed.

Real-time Database: Supabase - Handling our "Yaps," interactions, and content delivery seamlessly.

Styling: Tailwind CSS - Allowing for precise control over the layout and typography.

Icons: Lucide React - For a minimalist and modern UI.

Design Philosophy: The Art of Spacing Most social platforms feel cluttered. For KeyYap, I went the other way. I believe that white space is a premium feature.

Generous Padding: I implemented a spacious vertical layout (py-8 md:py-10 for posts). This gives every conversation its own space and prevents the "doom-scrolling" fatigue.

Typography First: By focusing on clean fonts and balanced line heights, I ensured that the reading experience is front and center.

Native Integration: Marketing as Content One of the core features of KeyYap is how I handle promotions. Instead of jarring, ugly banners that break the flow, I built a Native Integration System.

Advertisements on KeyYap are designed to look and feel like organic posts. By matching the typography, spacing, and interaction buttons, I ensure that every piece of content—whether organic or promoted—feels like it belongs on the platform. This creates a much higher quality experience for the user.

Overcoming the "Social Media" Load Building a feed isn't just about fetching data; it's about how that data feels when it loads.

Hydration & SEO: By using Next.js, I ensured that the initial "Yaps" are rendered on the server, making the page load feel instant while also being indexed by search engines.

Layout Stability: I spent a lot of time ensuring that the layout doesn't shift during loading (CLS), creating a smooth, stable experience from the first millisecond.

What’s Next?

KeyYap is currently in Public Beta, and the community feedback has been amazing. I am continually refining the "Yap" experience to keep it as the "good place for yapping."

Building a social space is about more than just code; it’s about creating a vibe. With Next.js and Supabase, I was able to turn that vibe into a functional, premium reality.

Check it out here: https://keyyap.vercel.app

Happy Coding! 🚀 Have questions about my native integration or feed layout? Let’s chat in the comments!

XtermChat | A Terminal Chat App With a Built-in Server Monitoring Bot

Ketut Dana — Sun, 15 Mar 2026 13:28:24 +0000

A few months ago I got tired of giving my team's conversations to third-party servers. So I built XtermChat — a self-hosted chat system that runs entirely in the terminal.

Since then, it has grown into something I didn't originally plan: a full client-server chat system with a terminal TUI, a web admin panel, and a bot that monitors your VPS and sends alerts directly into your chat rooms.

This post is about what it became.

What XtermChat Is Now

At its core, XtermChat is still simple: a Python Flask server, a SQLite database, and a CLI client. But it now ships with three ways to use it.

1. Terminal TUI — the original interface. Run xtc start:chat @general and you get a full terminal UI with three panels, dual-focus mode, emoji shortcuts, link detection, and clipboard copy.

2. Web Admin Panel — run xtc start:web and open localhost:5000. Full admin panel with dashboard, room management, chat with link previews (OG image, title, description), and bot management.

3. Bot System — run xtc start:bot and a setup wizard walks you through configuring a monitoring bot that runs as a background process on your VPS.

The Bot System

This is the part I'm most excited about. The idea is simple: instead of setting up a separate alerting tool, XtermChat already has rooms and messaging — so why not use that infrastructure for server monitoring too?

$ xtc start:bot

┌──────────────────────────────────────┐
│   XTERMCHAT  ·  BOT SETUP            │
└──────────────────────────────────────┘

▸ SELECT ROOM
  1. @general    OPEN   by KETUT
  2. @alerts     OPEN   by KETUT

▸ Bot name: MONITOR

▸ SELECT BOT TASKS
  1.  Resource Monitor     CPU, RAM, Disk usage
  2.  Process Monitor      Watch if a service dies
  3.  Uptime Watchdog      Ping a URL every N minutes
  4.  Port Checker         Verify ports are open
  5.  SSL Cert Checker     Alert before cert expires
  6.  Log Watcher          Tail a log for keywords
  ...

▸ Select tasks: 1,3

✓ Config saved  (bot_id: 1)
✓ Bot started on server  (PID: 24891)

The bot runs as a background process on the VPS. It reads its config from the database, checks at the configured interval, and sends alerts as normal messages to any room you choose.

An alert looks like this in your chat:

⚠️ RESOURCE ALERT on srv1260384 [15 Mar 2026 08:30:00]
  CPU   85%  (limit 80%)
  RAM   91%  (limit 85%)

Because it's just a message in a room, you can see it from the terminal TUI, the web admin, or any client connected to the server.

The Architecture

The whole thing is two repos.

xtc-server — lives on your VPS:

xtc-server/
├── server.py       Flask app, all API + bot routes
├── db.py           SQLite init (users, rooms, messages, bots)
├── room.py         Room CRUD, bcrypt passwords
├── connection.py   Message save/retrieval
└── bot_runner.py   Bot background process

xtc-client — lives on your machine:

xtc-client/
├── xtc.py          CLI entry point, command dispatcher
├── utils.py        Hardware UUID identity
├── commands/
│   ├── chat.py     Terminal TUI
│   ├── bot.py      Bot setup wizard
│   ├── bot_stop.py Stop/list bots
│   ├── listBots.py List all registered bots
│   └── deleteBot.py Delete bots
└── web/
    ├── app.py      Flask web server (port 5000)
    └── html/       5 admin pages

The client sends a POST /bot/start to the server, which spawns bot_runner.py as a background process. The bot reads its config from the database and starts monitoring. Stop it with xtc stop:bot 1 which sends POST /bot/kill — the server kills the PID and updates the database.

The Web Admin

The web admin surprised me with how useful it turned out. I built it for team members who don't use the terminal, but I ended up using it myself because the chat bubble UI with link previews is genuinely nicer for long conversations.

The chat page fetches Open Graph metadata for any URL shared in a message — image, title, description, favicon. It's cached per session so the same URL isn't fetched twice.

One thing worth noting: the web admin uses a 5-digit PIN you choose at login, while the CLI uses a hardware UUID auto-generated from your machine. Both work with the same server and the same rooms. The difference is that CLI identity is device-bound (if you reinstall your OS, your PIN changes), while web identity is portable.

What I Learned

SQLite is underrated. The entire server state — users, rooms, messages, bot configs — lives in one file. Backup is cp xtc.db backup.db. For a team of 2–50 people on a $5 VPS, it's more than enough.

REST over WebSocket was the right call. Polling every 2 seconds is fine for this use case and dramatically simpler to implement, debug, and extend. The bot just makes HTTP requests too — same pattern everywhere.

Hardware UUID as identity is surprisingly clean. No passwords to remember. Your machine is your identity. The tradeoff is that switching devices requires an admin to reset your entry, but for a small team that's a non-issue.

Try It

Server: github.com/dnysaz/xtc-server
Client: github.com/dnysaz/xtc-client
Docs: xtermchat.vercel.app

Setup takes about 10 minutes. The docs cover everything from server setup to HTTPS to the full bot task reference.

If you run a small team, manage a homelab, or just want your chat data to stay on your own infrastructure — give it a try. And if you find something broken or have a feature idea, issues and pull requests are very welcome.

Built with Python · Runs on a $5 VPS · MIT License