DEV Community: Naveen Gopalakrishna

cordless: Managing Remote Terminals & Coding Agents From My Phone, Like Browser Tabs

Naveen Gopalakrishna — Fri, 10 Jul 2026 18:45:34 +0000

TL;DR — cordless is a tiny Node daemon on your dev box that owns real terminal sessions (a shell, or claude / codex), plus a phone app that attaches to them like browser tabs. Close the app, switch networks, come back later — your sessions are still running and replay exactly where you left off. I designed it in a running conversation with GPT-5.6 Sol on Azure, built it with GitHub Copilot CLI, and verified it in a real browser and a real Android emulator. Live: naveenneog.github.io/cordless.

I keep leaving long-running coding-agent sessions on my dev box — a claude chewing through a refactor, a build, a shell mid-task — and then walking away from the keyboard. I wanted to check on them and steer them from my phone, the way I flip between browser tabs. Not SSH-in-a-box; something that treats each agent session as a first-class tab that keeps living when my phone sleeps. So I built cordless.

What it is

Persistent sessions. The PTYs live in the daemon. Your phone disconnecting, backgrounding, or hopping from Wi‑Fi to cellular doesn't kill anything. Reconnecting replays from your last-seen byte — or a full-screen snapshot if you were away a while.
Tabs for terminals. Run several Claude Code / Codex / shell sessions at once and switch instantly, with an unread dot when a background session produces output.
Touch-first. A real terminal is unusable with thumbs without help, so there's an on-screen key bar: Esc, Tab, Ctrl/Alt (one-shot latches), arrows, Ctrl‑C/D, pipes, and paste.
Reach it from anywhere. Tailscale is the recommended path; same‑Wi‑Fi LAN also works. No ports exposed to the internet.
Web or native. Install the PWA straight from your phone browser, or grab the Android APK.

How it was built

Designed in tandem with GPT‑5.6 Sol

The interesting part of this build is that I didn't architect it alone. I kept a stateful conversation with GPT‑5.6 Sol (deployed on my Azure AI Foundry) open the entire time — not one-off prompts, but a running transcript so it stayed consistent with every prior decision. Sol produced the initial architecture, and then, crucially, reviewed my actual code. That review earned its keep.

The agent: node-pty, not tmux

Each session is a real pseudo-terminal spawned with node-pty (ConPTY on Windows — which, pleasingly, built on Node 26 first try; a Unix PTY on macOS/Linux). I deliberately did not use tmux: the daemon is already the multiplexer, and tmux adds nested-terminal state, sizing quirks, and a Windows install problem. Every session is a PTY plus a headless @xterm/headless mirror (for snapshots) plus an 8 MiB replay ring.

The subtle bug Sol caught here: @xterm/headless's write() is asynchronous, and reset() is not ordered behind queued writes. So I route every terminal write and every snapshot through one per-session op queue, and assign a batch's sequence number inside the write callback — which keeps the replay ring, the sequence counter, and serialize() perfectly consistent. Output is coalesced into ~16 ms / 32 KiB batches, one sequence number per batch.

// one op queue per session; seq assigned only after the bytes are parsed
this._queueOp(() => new Promise((resolve) => {
  this.term.write(batch, () => {
    const seq = this._nextSeq++;
    this._pushRing(seq, batch);   // ring, counter and headless mirror advance together
    this._broadcast(seq, batch);
    resolve();
  });
}));

That consistency is what makes reconnect-with-replay honest: attach with your last seq, and the server either replays the ring from there or, if it's rolled past, serializes the headless terminal into a single reset snapshot. tmux-style survival, without tmux.

The client, and the 12 bugs the review caught

The app is Vite + React + xterm.js, served by the daemon itself so the PWA is same-origin. I wrote the connection layer, thought it was solid… and handed the whole file to Sol for review. It came back with twelve real issues — not style nits, actual races:

stale-epoch writes duplicating output after a reconnect,
the duplicate-frame check gating on the wrong counter (applied vs received seq),
duplicate-attach and detach-during-attach races,
an ack timer that leaked across reconnects and cleared a fresh ack,
Ctrl/Alt latches that could get stuck,
"close tab" silently undone by the next session-list poll.

The fix pattern throughout: give every socket a connection epoch that every handler, timer, and promise verifies; serialize each tab's writes through an apply-chain; and use generation counters for attach/detach and resize. Boring, correct, and exactly the kind of thing a fresh reviewer spots that the author's brain has already glossed over.

Security, baked in from the start

Because a paired device gets shell access to my machine, security couldn't be an afterthought:

Per-device tokens, only their SHA‑256 hashes stored on the box; revoke any device by id.
Single-use, rate-limited QR pairing — and the pairing secret rides in the URL fragment, so it's never sent to (or logged by) the server.
An Origin allowlist on the WebSocket and pairing endpoints (blocks malicious web pages / DNS-rebinding), a strict CSP (script-src 'self', no inline JS), and no-store on every credential-bearing response.
The daemon warns if you run it as root/Administrator and binds with a clear least-privilege note.

There's a small automated suite that asserts all of this (cross-origin pairing → 403, cross-origin WebSocket → rejected, headers present) so it can't quietly regress.

The bug only a real emulator could find

Here's my favorite part. Everything worked perfectly as a PWA — because the browser served the app and the agent from the same origin. Then I packaged the Android APK with Capacitor and installed it on an emulator. Pairing failed instantly: "Failed to fetch."

The cause was genuinely educational. Inside a Capacitor WebView the app's origin is http://localhost, so talking to the agent is cross-origin — which triggers a CORS preflight my server had never needed to handle, because the same-origin PWA never sent one. The fix was to add CORS scoped to the existing Origin allowlist (echo Access-Control-Allow-Origin for allowed origins, answer the OPTIONS preflight, and — Sol's catch — answer the Private Network Access preflight that Chromium sends when reaching a LAN/Tailscale address). A bug that would have broken every native-app user, invisible until I drove the real APK.

After the fix, the emulator paired, connected over WebSocket, attached a session, rendered PowerShell output, and replayed full session history on reconnect — the whole loop, natively.

Shipping it

The Android APK is built by GitHub Actions on every v* tag (debug-signed, androidScheme: http + cleartext so ws:// to a Tailscale IP works) and attached straight to the release. The landing page is GitHub Pages. Networking is Tailscale-first: WireGuard encrypts the hop, you get a stable *.ts.net name, and port 7443 never touches the public internet.

The good

Sessions that outlive the client turn a phone from a read-only status screen into a real remote control for long-running agents. Check a claude refactor from the sofa, unstick a build on the train, tap Ctrl‑C on a runaway process — then walk back to your desk and the exact same sessions are there in the browser. And because the whole thing is token-gated, Tailscale-scoped, and never exposed publicly, it stays yours.

The meta-lesson: pairing a builder (me, via Copilot CLI) with a dedicated reviewer (GPT‑5.6 Sol) in a persistent conversation produced noticeably better engineering than either alone — the 12-bug review and the CORS catch are things I'd have shipped without. And testing on a real emulator, not just a browser is what turned "looks done" into "actually works."

Try it

▶️ Live / install the PWA: naveenneog.github.io/cordless
📦 Android APK: github.com/naveenneog/cordless/releases/latest
💻 Source: github.com/naveenneog/cordless

naveenneog / cordless

Manage many remote terminal & coding-agent (Claude Code, Codex) sessions from your phone — like browser tabs. Node agent + PWA/Android client.

cordless

Manage many remote terminal / coding-agent sessions from your phone — like browser tabs.

cordless runs a small daemon on your dev box or laptop that owns real PTY sessions (a shell, or claude / codex), and a mobile web app that attaches to them like browser tabs. Sessions keep running when you disconnect; reconnecting replays exactly where you left off.

Site: naveenneog.github.io/cordless · Download: latest APK

Persistent sessions — PTYs survive phone disconnects, network switches, and app backgrounding Reconnect replays from your last-seen byte (or a full-screen snapshot if you were away too long).
Tabs for terminals — run several Claude Code / Codex / shell sessions at once, switch instantly.
Touch-first — an on-screen key bar (Esc, Tab, Ctrl/Alt, arrows, Ctrl-C/D, pipes, paste) makes a real terminal usable with thumbs.
Reach it from anywhere — Tailscale is the recommended path; same-Wi-Fi LAN also works.
Secure by…

View on GitHub

Part of the #AI4Good series. Built one day at a time. — @naveenneog

AI4Good: I Shipped an AI-for-Good App Every Few Days — Here's the Build Story

Naveen Gopalakrishna — Fri, 10 Jul 2026 08:14:57 +0000

#AI4Good started as a dare to myself: can I use AI to build and ship something genuinely useful — for kids, for health, for our culture — one build at a time? Eighteen days later there were eight live apps, each free, each on GitHub Pages. This is the story of how they came to be, in the order they were born — and each has its own deep-dive post on the AI4Good blog.

I'm Naveen Gopalakrishna — an AI Global Black Belt at Microsoft by day, a compulsive builder by night. The tooling that made this pace possible was GitHub Copilot CLI in autopilot mode (the agent researches, writes code, runs builds, and renders assets autonomously) on top of Azure AI — gpt-image-2 for art, Azure Speech for narration, and open models from Hugging Face for the heavy lifting. But tools are just tools. The thread that ties these eight together is a question I kept asking: who does this help?

Let's walk the timeline.

Jun 22 — PrimeBeats: your music, beautifully local

Where it started. PrimeBeats is an Amazon-Prime-Music-style player for the songs already on your phone — background playback, lock-screen controls, playlists, an on-device Smart Radio, and a real equalizer. No account, no ads, 100% offline. Built with React Native + Expo.

The good: ownership and privacy — your music, zero data, zero tracking, zero cost.

Jun 23 — ActionCut: put a pro video studio in everyone's pocket

The next build set the tone: take something normally locked behind subscriptions and make it free and open. ActionCut is a CapCut-class Android video editor — a real multi-track timeline, LUT color filters, GPU effects, audio mixing, and one-tap export presets for every platform. Built in Kotlin + Jetpack Compose + Media3.

The good: creators on entry-level Android phones get studio-grade editing without a paywall or a watermark. Storytelling shouldn't require a subscription.

Jun 26 — KidKat: only the good stuff, for curious kids

This is the app that named the whole campaign. KidKat plays a finite, parent-approved stream of short educational videos — inside the official YouTube player, using the official Data API, fully ToS-compliant. No infinite feed. No algorithmic rabbit holes. No doomscroll. A parent allowlist decides what's on the menu. Built with Flutter for Android and iOS.

The good: it turns the most anxiety-inducing part of modern parenting — handing a child a screen — into something calm and intentional. AI for good starts with protecting the youngest users.

Jun 27 — NeoFit: health that speaks your language

"Sehat, simple banayi." NeoFit is a science-informed Indian health and fitness app in 22 Indian languages — calorie tracking that actually knows dosa, biryani, and gulab jamun, on-device food recognition, AI-generated food photos, AI exercise videos, and Health Connect sync. Offline-first, powered by Azure AI, Kotlin/Compose.

The good: most fitness apps assume you eat like the West and read English fluently. NeoFit meets 1.4 billion people where they are — in their language, with their food. Inclusion is a health outcome.

Jul 04 — GpsCamera: proof you can trust

GpsCamera is a fast, native Android camera that burns your exact location and a live mini-map onto every photo, writes standards-compliant GPS EXIF, and files each shot into its own album. Kotlin, Compose, CameraX.

The good: field engineers, insurance surveyors, community reporters, and site inspectors need verifiable, tamper-evident documentation. A trustworthy timestamped-and-geotagged photo is a small tool that quietly protects people.

Jul 05 — The Lamp & the Machine: shadow-puppet theatre as an AI film studio

The Lamp & the Machine turns Karnataka's 500-year-old leather shadow-puppet theatre, Togalu Gombeyaata, into an AI film studio — cinematic scenes from Sora 2, narration from Azure AI, finished with Demucs + FFmpeg, retelling the story of Kempegowda, the founder of Bengaluru.

The good: generative AI as a preservation tool — putting a fading folk art in front of a new generation.

Jul 06 — Sopāna: a Snakes & Ladders that teaches

Sopāna reclaims the game the West calls Snakes & Ladders and restores its origin — the ancient Indian Moksha Patam, where every snake is a vice and every ladder a virtue. Land on one and the game animates and reads its meaning aloud. Play three ways (a 2D board, a 2.5D cinematic mode, and a 3D camera), across four worlds, with up to four players on one screen. A web PWA plus an Android APK.

The good: it turns a children's game back into what it was designed to be — a gentle lesson in ethics and consequence, wrapped in cultural heritage. AI narration and art make an 800-year-old teaching tool feel alive again.

Jul 09 — Chaturanga: ancient chess, reborn in glowing 3D

Chaturanga is the ancient Indian "game of the four divisions," played with modern chess rules but authentic piece identities — Raja, Mantri, Gaja, Ashva, Ratha, Padati — carved in real-time glowing 3D. It ships with a teaching AI (five levels), a coach that reviews your blunders, an openings trainer, a rotating piece inspector, and a Warrior's Eye camera. Four worlds, each teaching a moral lesson.

The pieces themselves are an AI-for-good story: I generated each one from a single concept image using a free Hugging Face Space and headless Blender — the full image-to-3D pipeline is its own post here.

The good: a free, offline, no-sign-in chess tutor that also carries culture — learning and heritage in one board.

What #AI4Good actually means

Look at all eight together and a pattern appears — not "AI apps," but apps that use AI to do something good:

Day	App	Who it serves	The good
Jun 22	PrimeBeats	Listeners	Own your music — offline, ad-free
Jun 23	ActionCut	Creators	Studio-grade editing, free
Jun 26	KidKat	Kids & parents	Safe, finite, educational screen time
Jun 27	NeoFit	1.4B Indians	Health in 22 languages
Jul 04	GpsCamera	Field workers	Verifiable documentation
Jul 05	The Lamp & the Machine	Culture	Preserving a folk art with AI
Jul 06	Sopāna	Families	Values + heritage, playfully
Jul 09	Chaturanga	Learners	Free chess tutor + culture

The method: one build at a time, from a single laptop, with Copilot CLI autopilot doing the heavy lifting and Azure AI + Hugging Face models supplying the intelligence. The mission: put that capability toward education, health, culture, and trust — and give it away.

This is just the beginning of the campaign. Next up the runway: Indian Tales, a multilingual Togalu Gombe (shadow-puppet) storytelling app to keep a fading folk art alive.

If you build things, I'd gently challenge you to the same dare: pick the "who does this help?" first, then let AI help you ship it. That's #AI4Good.

Follow the journey — GitHub · LinkedIn. Built one day at a time.

Carving a Glowing 3D Army from Single Images: Hugging Face + Blender, driven by Copilot CLI Autopilot

Naveen Gopalakrishna — Fri, 10 Jul 2026 07:54:18 +0000

TL;DR — One gpt-image-2 concept image per piece → a free Hugging Face Space (tencent/Hunyuan3D-2) turns it into a raw 3D mesh → headless Blender projects the concept back on as texture → a web-ready GLB that glows in Three.js. No local GPU. All of it — the research, the scripts, the Hugging Face calls, the Blender runs, and this very post and its auto-publish to DEV — was orchestrated by GitHub Copilot CLI in autopilot mode.

I've been building Chaturanga — the ancient Indian "game of the four divisions," played with modern chess moves but authentic piece identities (Raja, Mantri, Gaja, Ashva, Ratha, Padati). The board above is the payoff. The hard part was the pieces: carved-ivory war figures with real silhouettes, in four themed armies, that spin in a WebGL inspector — built for free, on a laptop with no GPU, in a fully scriptable way.

Here's how that pipeline came together, including the parts that didn't work.

The pipeline at a glance

Four stages, each free and headless:

Concept — Azure gpt-image-2 renders a carved-ivory concept per piece (front 3/4, plain background).
Image → 3D — the concept goes to a Hugging Face Space that runs image-to-3D on donated GPU and returns a mesh.
Texture — Blender 5.1, headless on CPU, projects the concept image onto the mesh.
Ship — export a decimated, textured GLB and load it in Three.js with a little emissive glow.

Step 2 is the heart: image → 3D on a free Hugging Face Space

Instead of buying GPU time, I call tencent/Hunyuan3D-2 through its Gradio API. The Space runs the heavy diffusion-to-mesh step on free ZeroGPU; I just pull back a .glb:

from gradio_client import Client, handle_file

client = Client("tencent/Hunyuan3D-2", hf_token=HF_TOKEN)   # token optional; helps rate limits
result = client.predict(
    image=handle_file("refs/raja.jpg"),
    steps=30, guidance_scale=5.0, seed=1234,
    octree_resolution=256, check_box_rembg=True,
    num_chunks=8000, randomize_seed=False,
    api_name="/shape_generation",     # geometry only — fast; texture done later in Blender
)
# result -> a raw .glb mesh, generated on someone else's GPU, for free

No-signup fallback: for a path that needs zero accounts, I keep stabilityai/TripoSR (MIT) running locally on CPU — the only open image-to-3D model I found that's genuinely CPU-feasible on Windows.

Discovering Spaces from the terminal

Copilot CLI has the Hugging Face MCP server wired in, so I search the Hub without leaving my shell. Asking for image-to-3D Spaces returns the exact shortlist this project lives on: microsoft/TRELLIS.2 (⭐1.7k), tencent/Hunyuan3D-2 (⭐3.3k, what I use), TencentARC/InstantMesh (⭐1.6k).

From flat concept to spinning figure

The gpt-image-2 concept on the left, the Hugging Face + Blender result on the right:

And on the turntable (Raja · Ashva · Gaja):

Step 3 — Where Blender earns its keep (and where it fights back)

The Hugging Face mesh has a correct silhouette but a soft surface. The crisp carving detail lives in the concept image. So Blender's job is concept-texture projection: orient the mesh, frame an orthographic camera on its front, and set each vertex's UV to that camera's projection — so the concept becomes the surface.

blender -b --python tooling/blender/texture_project.py -- \
    raw/raja_hunyuan.glb refs/raja.jpg web/raja.glb preview.png
# headless CPU: orient -> project concept as texture -> decimate to ~28k faces -> export GLB

The honest limitations I hit:

Back faces get a mirrored projection. Single-camera projection is perfect head-on; the reverse is a mirror. For board pieces seen from above, an acceptable trade — but a trade.
Blender 4 → 5 broke my material scripts. Principled BSDF sockets were renamed: Subsurface Weight not Subsurface, Specular IOR Level not Specular. KeyError until I re-bound each one.
Eevee Next won't render headless on Windows. blender -b with new Eevee crashes with an access violation — it wants a GPU context a background process lacks. Cycles on CPU renders fine; every image here is Cycles-CPU.
No native build allowed. Marching cubes runs via PyMCubes, not a compiled extension, to stay laptop-reproducible.

The detour: I first tried Blender-only procedural modeling (skin modifier, geometry nodes, baked PBR). Fully scriptable, GPU-free… and it produced primitive blobs after hours. Great for finishing, wrong tool for creating organic figures. That failure is why the Hugging Face step exists.

The tools I tried — and where they hit a wall

Constraints on purpose: free, Windows, no GPU, scriptable.

Tool	Route	Verdict under my constraints
Hunyuan3D-2 (HF Space)	image→mesh, free ZeroGPU	✅ Winner — GPU-quality geometry, no local GPU
TripoSR (local)	image→mesh, CPU	✅ Fallback — only CPU-feasible local model
Meshy AI	REST API, 200 credits/mo	⚠️ Great, but ~6 textured pieces/mo, CC-BY
Tripo AI	REST API, 300 credits/mo	⚠️ Good, but 15 downloads/mo
Rodin (Hyper3D)	REST API, pay-on-export	⚠️ Best detail, but credits burn on download
InstantMesh / TRELLIS / Wonder3D	local	❌ Not CPU-feasible — CUDA-only

The pattern: hosted APIs are excellent but metered; the best local models need a GPU I don't have. The escape hatch is a community-hosted Hugging Face Space — the model runs on donated GPU and I pay nothing but a queue wait.

The meta-story: built in Copilot CLI autopilot mode

I didn't hand-write most of this. I drove GitHub Copilot CLI in autopilot mode — where the agent runs shell commands, scripts, and tools autonomously, multi-step, without stopping for approval each move:

a research sub-agent fanned out across 13 image-to-3D tools and returned a sourced comparison;
the agent wrote and ran the batch driver, called the Hunyuan3D-2 Space, and retried on ZeroGPU hiccups;
headless Blender runs for texture and the turntables above — it caught the Eevee-headless crash and switched to Cycles itself;
and this post — rendered GIFs, diagram, prose — plus the GitHub Actions workflow that auto-published it to DEV on push.

Results & what's next

A full four-world army — Kurukshetra, Ramayana, Kalinga, Devasura — each piece a real 3D figure with a themed material and emissive bloom.

Try it: the game is live at naveenneog.github.io/Chaturanga.

naveenneog / Chaturanga

Chaturanga — the ancient Indian four-army game in real 3D: a teaching chess AI with levels, an openings trainer, a piece inspector, a Warrior's Eye camera, and two themed worlds. Web + Android.

Chaturanga — the four-army game of dharma

Chaturanga is the ancient Indian ancestor of chess — the game of the four army divisions. This is a real-3D, mobile-first take on it: authentic Chaturanga piece identities (Raja, Mantri, Ratha, Gaja, Ashva, Padati) that move by modern chess rules, where every world teaches a moral through its pieces, and a teaching AI explains the game as you play.

▶ Play: https://naveenneog.github.io/Chaturanga/ · ⬇ Android APK: see Releases

Features

Play the Guru — an alpha-beta chess AI with 5 difficulty levels (Padati → Mantri) running in a Web Worker so it stays smooth on phones.
A coach — a Hint that names the best move and why, and a blunder review that gently flags mistakes and shows the stronger move.
Openings trainer — six classic openings (Italian, Ruy López, Sicilian, French Queen's Gambit, King's Indian) walked move-by-move with a narrated…

View on GitHub

Steal the pipeline: gpt-image-2 → tencent/Hunyuan3D-2 Space → Blender projection → GLB. Free, no GPU, every step a script. For game assets, product mockups, or avatars, a free Hugging Face Space is the cheat code — and Copilot CLI autopilot stitches it all together.

Built one day at a time. — @naveenneog