DEV Community: twistedtransistor

Meet my simple CLI Tool That Makes Oh My Posh Theme-Hopping Effortless

twistedtransistor — Wed, 20 Aug 2025 04:40:46 +0000

Theme manager for Oh My Posh that lets you browse, preview, install, activate, add custom and tweak themes directly inside your terminal.

Features

💻 Fast and simple: runs from terminal. Simple interface.
🔍 Real-time Search: Filter local and remote theme repo
⚡ Fast Installation: Single or multiple theme download
🔄 Easy Theme Switching: Theme activation (Bash/Zsh/Fish)
🗂️ Dual Panel Interface: Local and remote theme management
🎯 Custom Repositories: Add themes from Git repository (json has to be in root)
🎨 Theme Customization: Built-in color editor
🎨 Basic Previews: Sample prompt structure with basic metadata (Name, Version, Source, Color variation)
🚀 Performance Optimized: Smart caching and modular architecture

Prerequisites

Before using this tool, you need:

Oh My Posh installed - Visit ohmyposh.dev for installation instructions
Compatible shell: Bash, Zsh, or Fish
Python 3.6+ with standard libraries

Installation

Method 1: PyPI (Recommended)

pip install oh-my-theme

Method 2: AUR (Arch Linux)

yay -S oh-my-theme
# or
paru -S oh-my-theme

Method 3: Git Clone

git clone https://github.com/mikeisfree/oh-my-theme.git
pip install -e .

Usage After Installation

Once installed run with:

omt

Shell Config

The tool automatically updates your shell configuration:

Bash: ~/.bashrc
Zsh: ~/.zshrc
Fish: ~/.config/fish/config.fish

Clean Theme Management:

Removes all existing Oh My Posh theme lines when activating a new theme - If You want to keep existing oh-my-posh configuration commenting it out will not be enough - back it up to a separate file!
Adds only the new active theme command
Preserves all other shell configuration! (aliases, exports, functions)

After activating a theme, reload your shell:

source ~/.bashrc    # For Bash
source ~/.zshrc     # For Zsh

Usage Details

Interface Overview

The tool displays two panels:

Left Panel: installed themes (local)
Right Panel: Available themes from Oh My Posh main repository + custom repos added by user (remote)

Keyboard Shortcuts

Key	Action
`TAB`	Switch between panels
`↑/↓`	Navigate theme list
`ENTER`	Activate/Remove/Customize local theme or Select remote theme
`SPACE`	Toggle selection for remote themes
`p`	Preview selected theme
`i`	Install selected remote themes
`/`	NEW: Enter search mode for real-time theme filtering
`+`	NEW: Add custom Git repository
`ESC`	Exit search mode & cancel dialogs
`q`	Quit application

Local Theme Actions (ENTER)

When you press ENTER on a local theme, you'll see these options:

A - Activate theme in shell
R - Remove theme
C - Customize theme colors

Getting Started

Browse Remote Themes: Use TAB to switch to the right panel and browse available themes
Search Themes: Press / to search and filter themes in real-time
Preview Themes: Press p to see previews with sample prompts and metadata
Select Themes: Use SPACE to select multiple themes for installation
Install Themes: Press i to download selected themes
Activate Theme: Switch to local panel (TAB) and press ENTER → A on your desired theme
Customize Theme: Press ENTER → C on local themes to edit colors
Add Custom Repos: Press + to add themes from custom Git repositories

Theme Previews

Preview feature shows:

Sample prompt structure git status, paths, segments
Essential metadata: Name, Version, Source (git repository), Color variation

Filter

Press / to enter search mode
Type to filter themes in real-time across both local and remote panels
Search results highlight matching text
Press ESC to exit search and process filtered items

Custom Repository Support

Press + to add themes from custom Git repository
Enter the Git repository URL when prompted
The tool will fetch all .omp.json files from the repository root
Custom themes are downloaded to your local themes directory
repository address will be added to filter array

Theme Customization

Select any local theme and press ENTER → C
Visual color editor shows current segment colors
Simple color picker interface for modifications
Save as new theme (new json file) or overwrite original
Preserve customizations across updates

Theme Storage

Downloaded themes are stored in ~/.poshthemes/ directory. The tool manages this directory automatically.

Troubleshooting

"Unsupported shell" Error

Make sure your SHELL environment variable is set correctly:

echo $SHELL

Safety measures:

Backup-friendly: Uses a clean replacement strategy that preserves non-Oh My Posh configurations

Atomic updates: Reads entire file, modifies in memory, then writes back

Error handling: Returns success/failure status

uses regex pattern to identify Oh My Posh lines:

init_pattern = re.compile(r"^\s*(eval.*oh-my-posh init.*|oh-my-posh init.*fish.*)")

User confirmation: Always asks for confirmation before activating themes

Theme Not Activating

Ensure Oh My Posh is properly installed and in your PATH
Check that your shell configuration file exists and is writable
Reload your shell after theme activation

Preview Not Working

For remote themes: The tool will offer to download the theme for preview
For local themes: Ensure the theme file exists in ~/.poshthemes/

Search Not Responding

Make sure you're in search mode (press / first)
Press ESC to exit search mode if stuck
Search works across both local and remote theme panels

Custom Repository Issues

Ensure the Git repository URL is valid and accessible
Repository must contain .omp.json files in the root directory
Check your internet connection for repository access

Theme Customization Problems

Only local themes can be customized
Ensure you have write permissions to the themes directory
Invalid JSON themes cannot be edited safely

Performance Features

Smart Caching: Theme metadata is cached to speed up repeated previews
File Reuse: Existing downloaded themes are reused for previews
Memory Management: Cache size is limited to prevent memory bloat
Lazy Loading: Theme parsing only when needed

What's New in v2.0

🔍 Search: Filter themes instantly with / keybind
🎯 Custom Repositories: Add themes from Git repository with + keybind
🎨 Theme Customization: Built-in color editor for personalizing themes
✨ Enhanced Previews: sample prompts with essential metadata
🏗️ Modular Architecture: Improved code organization and maintainability

Contributing

⭐ Star on GitHub if you like it!

📦 Review the package on PyPI or AUR

🐛 Report issues on GitHub

🔧 Submit pull requests with updates/upgrades

License

This project is open source. Please check the license file for details.

Architecture

Oh My Theme v2.0 features a modular architecture:

oh_my_theme/main.py: Core UI and application logic
oh_my_theme/preview.py: Enhanced theme previews and sample generation
oh_my_theme/search.py: Real-time search and filtering functionality
oh_my_theme/repositories.py: Custom Git repository management
oh_my_theme/editor.py: Theme color customization interface
oh_my_theme/config.py: Configuration and settings management

Dependencies

Python 3.6+: Core runtime requirement
Standard libraries only: curses, json, os, subprocess, urllib
No external dependencies required: Pure Python implementation

Google's Hand & Gesture Recognition + my playground

twistedtransistor — Thu, 14 Aug 2025 22:33:37 +0000

Playground Git repo

Google product page

Why Hand & Gesture

When I just learned about this project's existence, I knew I had to try it out. If you are a kid of the 80s/90s like me and still haven't received a functioning Power Glove for which your parents paid ~35 years ago... you might be thinking... that's about time!

Were there other attempts over time? Sure! Quite a lot, especially since modern VR headsets are on the market. Even though it had far superior successors, something was still lacking. The promise of a unified controller and seamless interaction using just the human hand had never been fulfilled.

Why Nextjs viewTransitions

When I think of UIs that could benefit from hand tracking solutions, what first comes to my mind is a multi-layered control panel where the user who interacts with it should not experience typical HTTP loading screens between pages, but rather be served with a consistent and continuous environment that can grow and grow while keeping reasonable efficiency at low resource consumption.

What is the status

Well... I should probably end this simple test right after I implemented MediaPipe to a Next.js example project from GitHub and added camera controls. But then I started to think about how it will work with this or that kind of slider.
How can I improve my own ease of interaction? How can I scale it to work with every machine I run it on?

This is why it is what it is now: a playground that can be easily adjusted by tilting tracking confidence or gesture threshold and also calibrated for every screen and resolution.

The project currently also contains some components that can be reused, like an image slider, horizontal page slider, articles to scroll through, music player with volume rocker...

What do i think

I think it is worth giving it a shot. It most probably will not be something that will resonate with everyone, but if you are willing to spend a bit of time to get used to it and also tweak the settings, then I believe it could be an enjoyable experience and also maybe the start of a new idea for a smart TV control app or a PC UI HUD, or maybe some gaming experience or lots and lots...

Whats the future like

My plan is to add more and more elements and finally build THE control room within a Clear Canvas component from which I will be able to interact with all created tools using two hands, including both preconfigured and custom-made gestures.

Tech list

Next.js:
React:
MediaPipe:
TypeScript:
Tailwind CSS:

Building and Running

This is very simple. Just use following commands:

pnpm install
pnpm dev

Architecture Overview

The application follows a layered architecture with React Context providers managing state and MediaPipe handling computer vision processing:

┌─────────────────────────────────────────┐
│           Next.js App Router            │
├─────────────────────────────────────────┤
│        Context Providers Layer         │
│  ┌─────────────────────────────────────┐ │
│  │ MediaPipeOptionsProvider            │ │
│  │ GestureOptionsProvider              │ │
│  │ CalibrationProvider                 │ │
│  │ HandTrackingProvider                │ │
│  └─────────────────────────────────────┘ │
├─────────────────────────────────────────┤
│         Hand Tracking Layer            │
│  ┌─────────────────────────────────────┐ │
│  │ MediaPipe Hands API                 │ │
│  │ Camera Utils                        │ │
│  │ Gesture Recognition                 │ │
│  └─────────────────────────────────────┘ │
├─────────────────────────────────────────┤
│            UI Components               │
│  ┌─────────────────────────────────────┐ │
│  │ GestureCursor                       │ │
│  │ HandTrackingOverlay                 │ │
│  │ MediaPipeControls                   │ │
│  └─────────────────────────────────────┘ │
└─────────────────────────────────────────┘

Routes Structure

The application uses Next.js App Router with the following route structure:

Main Routes

/ (Home Page): Landing page with navigation to all demo routes and MediaPipe controls
/blog: Floating cards demo with ViewTransition animations
/card: Interactive card gallery with image transitions
/scroll-test: Horizontal slider controlled by hand gestures
/slider: Play around with (add any "further.mp3" to public/sfx first)
/clear-canvas: Canvas drawing application with gesture controls
/calibration: Hand tracking calibration interface

Route Functionality

Each route demonstrates different aspects of gesture control:

Blog Route (/blog): Showcases ViewTransition API with floating card layouts
Card Route (/card): Image gallery with smooth transitions between views
Scroll Test (/scroll-test): Horizontal navigation using pinch-and-drag gestures
Slider Route (/slider): Volume control using hand position mapping
Clear Canvas (/clear-canvas): Drawing interface with gesture-based controls
Calibration (/calibration): Setup interface for hand tracking accuracy

Context Providers & State Management

The application uses a hierarchical context provider system to manage different aspects of the hand tracking system:

1. MediaPipeOptionsProvider

Location: contexts/MediaPipeOptionsContext.tsx

Purpose: Manages MediaPipe hand detection configuration options

Key Features:

Persistent storage via localStorage
Real-time option updates
Default configuration management

Configuration Options:

interface MediaPipeOptions {
  runningMode: "IMAGE" | "VIDEO"; // Processing mode
  maxNumHands: number; // Max hands to detect (1-4)
  minHandDetectionConfidence: number; // Palm detection threshold (0-1)
  minHandPresenceConfidence: number; // Hand presence threshold (0-1)
  minTrackingConfidence: number; // Tracking confidence (0-1)
  modelComplexity: 0 | 1; // Model accuracy vs speed
  staticImageMode: boolean; // Static vs video processing
}

2. GestureOptionsProvider

Location: contexts/GestureOptionsContext.tsx

Purpose: Manages gesture detection algorithms and thresholds

Key Features:

Multiple pinch detection modes
Configurable sensitivity thresholds
Algorithm switching capabilities

Detection Modes:

Original: Simple bone landmark distance calculation
Simple: Flesh-compensated distance with palm width normalization
Advanced: Multi-factor detection with confidence scoring

3. CalibrationProvider

Location: contexts/CalibrationContext.tsx

Purpose: Handles coordinate transformation between camera space and screen space

Key Features:

Screen resolution awareness
Coordinate transformation algorithms
Persistent calibration storage
Automatic invalidation on resolution changes

Calibration Data Structure:

interface CalibrationData {
  screenWidth: number; // Current screen width
  screenHeight: number; // Current screen height
  cameraAspectRatio: number; // Camera feed aspect ratio
  scaleFactorX: number; // X-axis scaling factor
  scaleFactorY: number; // Y-axis scaling factor
  offsetX: number; // X-axis offset
  offsetY: number; // Y-axis offset
}

4. HandTrackingProvider

Location: components/hand-tracking/HandTrackingProvider.tsx

Purpose: Core MediaPipe integration and hand detection processing

Key Features:

Dynamic MediaPipe script loading
Camera initialization and management
Real-time hand landmark processing
Error handling and recovery

Options-to-UI Integration

The system provides a comprehensive UI for configuring all hand tracking parameters:

MediaPipeControls Component

Location: components/MediaPipeControls.tsx

Integration Pattern:

Context Consumption: Uses both MediaPipeOptions and GestureOptions contexts
Real-time Updates: Changes immediately affect hand tracking behavior
Persistent Storage: All settings automatically saved to localStorage
Import/Export: JSON-based configuration sharing

UI Control Types:

SliderControl: Numeric range inputs with visual feedback
ToggleControl: Boolean switches with animated states
SelectControl: Dropdown menus for enumerated options

Control Categories:

MediaPipe Core Settings:

Running mode selection
Hand count limits
Confidence thresholds
Model complexity

Gesture Detection Settings:

Detection algorithm selection
Sensitivity thresholds per algorithm
Mode-specific parameter tuning

Configuration Management:
- Settings export/import
- Reset to defaults
- Real-time configuration preview

Calibration System

Why Calibration is Necessary

The calibration system addresses fundamental challenges in hand tracking applications:

Coordinate System Mismatch: MediaPipe returns normalized coordinates (0-1) from camera space, but UI interactions require pixel-perfect screen coordinates
Camera-Screen Alignment: The camera's field of view rarely matches the screen's aspect ratio or position perfectly
Perspective Distortion: Hand movements in 3D space need accurate mapping to 2D screen interactions
User Variability: Different users have varying hand sizes, camera positions, and interaction preferences

Calibration Structure

Location: app/calibration/ route

Process Flow:

User Input → Camera Capture → Coordinate Mapping → Validation → Storage

Calibration Steps:

Screen Resolution Detection: Captures current viewport dimensions
Camera Aspect Ratio Calculation: Determines camera feed proportions
Reference Point Mapping: User touches screen corners/edges while system records hand positions
Transform Matrix Generation: Calculates scale factors and offsets for coordinate conversion
Validation Testing: User tests accuracy across screen regions
Persistent Storage: Saves calibration data with resolution validation

Calibration Data Processing

Coordinate Transformation Algorithm:

const applyCalibration = (normalizedX: number, normalizedY: number) => {
  if (!calibrationData) {
    // Fallback: simple mapping
    return {
      x: (1 - normalizedX) * window.innerWidth,
      y: normalizedY * window.innerHeight,
    };
  }

  // Apply calibration transformation
  const handX = 1 - normalizedX; // Mirror horizontally
  const handY = normalizedY;

  return {
    x: calibrationData.scaleFactorX * handX + calibrationData.offsetX,
    y: calibrationData.scaleFactorY * handY + calibrationData.offsetY,
  };
};

Calibration Persistence:

Stored in localStorage as handTrackingCalibration
Automatically invalidated when screen resolution changes
Includes timestamp and validation checksums

Benefits of Calibration

Accuracy: Precise cursor positioning across the entire screen
Consistency: Reliable gesture recognition regardless of camera setup
User Experience: Reduced frustration from misaligned interactions
Adaptability: Works with various camera positions and screen sizes
Performance: Optimized coordinate calculations reduce processing overhead

Gesture Recognition System

Detection Algorithms

The system implements three distinct gesture detection approaches:

1. Original Mode

Method: Direct 3D distance calculation between fingertip landmarks
Use Case: High precision applications requiring exact finger positioning
Pros: Simple, fast, precise for ideal conditions
Cons: Sensitive to hand size variations and camera distance

2. Simple Mode

Method: Palm-width normalized distance with flesh compensation
Use Case: General-purpose applications with varied users
Pros: Accounts for hand size differences, more forgiving
Cons: Less precise than original mode

3. Advanced Mode

Method: Multi-factor confidence scoring with weighted detection
Use Case: Professional applications requiring robust detection
Factors:
- Fingertip distance (40% weight)
- Joint distance (40% weight)
- Finger curl detection (20% weight)
Pros: Most robust, handles edge cases, configurable
Cons: Higher computational cost, more complex tuning

Seemless Coolify SSL. Self-sign, self-renew with Telegram/Discord status reports. Coolify + Ubuntu + Oracle

twistedtransistor — Sun, 13 Apr 2025 12:05:15 +0000

You host apps like the big boys do ?
You don't afraid to take responsibility for Your own VPS ?
You say "NO" to those childish domains with fancy letters and words like: "lookatmydomainname.com" but rather prefer highly enjoyable IP numbers sexy as Tom Cruise and old Cadillac ?
You dont like setting up SSl and refreshing it over and over again ?

Youre in a good spot! Follow along and make SSL certs run on IP address of your COOLIFY VPS best way there always been!

How it works ?

If the cert or key doesn’t exist — it:
- Creates /etc/ssl/certs/coolify-selfsigned.crt
- Creates /etc/ssl/private/coolify-selfsigned.key
- Uses default values for country/state/org (you can customize them if you like)
- Logs the entire process
- Emails you that it successfully created the cert

🔁 Renewal (if certs already exist)

It:
- Backs up current cert and key to a timestamped folder
- Creates a fresh new cert valid for 365 days
- Replaces the old one
- Reloads NGINX to apply it
- Emails you success or failure
- Logs it all

🧠 Smart Logic

Doesn’t break if files are missing — just regenerates them
Doesn’t overwrite backups — stores them neatly by date
Won’t crash silently — will email you even if NGINX fails to reload

🤖 Auto Mode (via cron)

You can schedule it (e.g., every 6 months)
run it by cron or manually, -> it does the same full check + create + backup + renew process
You don’t need to do anything — take Your mama on pizza, smash buttons or do whatever the hell you want

🧪SETUP

you don't ask...You COMMAND!

Open with nano:

sudo nano /usr/local/bin/renew-coolify-cert-auto.sh

Paste the script and save it:


#!/bin/bash

CERT_PATH="/etc/ssl/certs/coolify-selfsigned.crt"
KEY_PATH="/etc/ssl/private/coolify-selfsigned.key"
BACKUP_DIR="/etc/ssl/backup-$(date +%F_%H-%M-%S)"
LOG_FILE="/var/log/coolify-cert-renew.log"
ALERT_EMAIL="your@email.com" # <-- CHANGE THIS


{
echo "========== $(date '+%F %T') =========="

# Check if cert/key exist
if [[ ! -f "$CERT_PATH" || ! -f "$KEY_PATH" ]]; then
    echo "[!] Cert or key missing. First-time setup or files deleted."
    echo "[+] Generating new certificate..."
    mkdir -p "$(dirname "$CERT_PATH")" "$(dirname "$KEY_PATH")"
else
    echo "[*] Backing up existing certs to $BACKUP_DIR"
    mkdir -p "$BACKUP_DIR"
    cp "$CERT_PATH" "$BACKUP_DIR/"
    cp "$KEY_PATH" "$BACKUP_DIR/"
fi

# Generate new cert
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout "$KEY_PATH" \
-out "$CERT_PATH" \
-subj "/C=US/ST=None/L=None/O=SelfSigned/CN=coolify.local"

# Secure the key file
chmod 600 "$KEY_PATH"

# Reload NGINX
echo "[*] Reloading NGINX..."
if systemctl reload nginx; then
    echo "[✓] SSL cert created or renewed successfully."
    mail -s "✅ Coolify SSL Cert Created/Renewed" "$ALERT_EMAIL" <<< "Success: Coolify self-signed cert created or renewed on $(hostname) at $(date)"
else
    echo "[X] NGINX reload failed!"
    mail -s "❌ Coolify SSL Renewal Failed" "$ALERT_EMAIL" <<< "ERROR: Coolify cert was generated but NGINX reload failed on $(hostname) at $(date). Check it manually."
fi

echo "====================================="
} | tee -a "$LOG_FILE"

Make it executable:

sudo chmod +x /usr/local/bin/renew-coolify-cert-auto.sh

Do the test run :

sudo /usr/local/bin/renew-coolify-cert-auto.sh

🔁 Add Cron (6-month schedule):

sudo crontab -e

Paste:

0 0 1 1,7 * /usr/local/bin/renew-coolify-cert-auto.sh

🔥CONGRATS! You became a LEGEND running hardened, hands-off Coolify cert!

...but just in case Your'e ambitions havent been fulfied yet... you need more and being a legend is simply not enough for You...

Telegram + Discord Alerts Setup (instead of/in addition to Email)

This baby will:

✅ Message your Telegram

✅ Post to Discord channel webhook

✅ Still support email if you so choose

🧪 Step 1: Prepare Telegram Bot

In Telegram, search: @BotFather
Type /newbot and follow the prompts to:
- Name your bot
- Get your bot token (save it)
Copy the token (looks like 123456789:ABCdefGHI...)
Start a chat with your bot (/start)
Now find your Telegram user ID:

- Visit this bot: https://t.me/userinfobot
- It’ll reply with your user ID

🧪 Step 2: Create Discord Webhook

Go to your server settings → Integrations → Webhooks
Click New Webhook
Choose a channel
Copy the Webhook URL

🧠 Step 3: Update the Script

Here’s the updated portion of the script with Telegram + Discord alerts (plus optional email)
Paste it at the bottom of script below "} | tee -a "$LOG_FILE"

# Send Telegram Alert
send_telegram() {
  local MESSAGE=$1
  TELEGRAM_TOKEN="YOUR_TELEGRAM_BOT_TOKEN"
  TELEGRAM_USER_ID="YOUR_TELEGRAM_USER_ID"
  curl -s -X POST "https://api.telegram.org/bot$TELEGRAM_TOKEN/sendMessage" \
       -d chat_id="$TELEGRAM_USER_ID" \
       -d text="$MESSAGE" \
       -d parse_mode="Markdown"
}

# Send Discord Alert
send_discord() {
  local MESSAGE=$1
  DISCORD_WEBHOOK_URL="YOUR_DISCORD_WEBHOOK_URL"
  curl -s -H "Content-Type: application/json" \
       -X POST \
       -d "{\"content\": \"$MESSAGE\"}" \
       "$DISCORD_WEBHOOK_URL"
}

# Alert message text
ALERT_MSG="[*] Coolify SSL Cert was updated on $(hostname) at $(date +'%F %T')"

# Success alert
if systemctl reload nginx; then
  ALERT_MSG="✅ *Coolify SSL updated successfully* on \`$(hostname)\` at \`$(date +'%F %T')\`"
else
  ALERT_MSG="❌ *Coolify SSL updated but NGINX reload failed!* on \`$(hostname)\` at \`$(date +'%F %T')\`"
fi

# Send alerts
send_telegram "$ALERT_MSG"
send_discord "$ALERT_MSG"

# Optional Email (still supported)
mail -s "Coolify SSL Update Status" "$ALERT_EMAIL" <<< "$ALERT_MSG"

🔧 Replace placeholders:

YOUR_TELEGRAM_BOT_TOKEN → Your bot token
YOUR_TELEGRAM_USER_ID → From @userinfobot
YOUR_DISCORD_WEBHOOK_URL → Your webhook URL
(Optional) Change or remove email alert

✅ Done!

Try a manual run:

sudo /usr/local/bin/renew-coolify-cert-auto.sh

You should see messages pop up on both Telegram and Discord. 🔔💬

The world salutes You!

Oracle Cloud VPS - recover SSH access to your instance with webUI & cloud shell. No user pass or scripts

twistedtransistor — Wed, 09 Apr 2025 17:00:16 +0000

Tutorial Content

Intro - time waster & page filler
Starting point
Step by step solution

Intro

As many of You I host some of evil "world shall know my name" experiments on Oracle infrastructure. Free tier of service gained a lot of traction and with that I stumbled upon more and more reports on the web written by users who accidently blocked SSH access to their instances while mixing "the ultimate weapon" ingredients.

I haven't paid much attention to those lenghty posts, tips, replies, feedbacks as other people already involved seemed more than capable to provide support.
Plus: Hey...this does not concern me! - I use CLI & scripts with caution and keep config files clean and always ready for upcoming world domination.

Yeah...so Yesterday things got turned as I rushed ports forwarding.
Have any of You ever heard of tool which fits task better than "ufw"?

me neither! Damn....

2 commands and SSH was cooked. Right away i did some tests against the wall emerged in between me and my SSH jar and few terminals later I can confirm sh...t is solid.

Running scripts against instance was tempting althou "run command" plugin on my Ubuntu instance was inactive.
Why ? - how should I know ? broken or someth...

Connecting to the instance from web CLI directly to instance required user password...and I used my instance with ssh key thus I did what all IT professionals have before me - never chrooted to set the passswdssw..whatever...or maybe just lost the damn thing - YOLO!

If You stuck like i did - follow along.
Fortunately this is Linux. Modular system made of modules and submodules developed with modular modulesss - ok! I shut up! - follow along please

Finally I found THE solution! - and decided to post it here for fame and money!🤩

Starting point - why it had to be me and You?!

SSH access is blocked by ufw.
Run Command is unavailable because the Oracle Cloud Agent isn't communicating.
Console Connection access is blocked because the ubuntu user has no password.
people who can't tell CLI Terminal from terminal at the airport laught at You

THE PATH Forward: Resetting the User Passswwwr..bla..bla like a champ

Since you cannot log in via any standard means, the primary way to regain control is to modify the instance's boot disk offline to set a password for the ubuntu user (or create a new user with a password). The standard procedure for this in OCI is:

Method: Attach Boot Volume to a Rescue Instance

This involves detaching the boot disk from your broken instance and temporarily attaching it to another (working) Linux instance to modify it.

Step by step solution

Stop Your Instance:
Go to the OCI Console -> Compute -> Instances -> Select 'your-instance' -> Click Stop.
Wait for it to fully stop (icon turns red/grey).

Did that made Your'e screen to exploade ? - damn...why the hell mine did!?
Identify the Boot Volume:
On the Instance Details page, scroll down to 'Resources' -> 'Boot Volume'. Click on the boot volume name to go to its details page. Note its name.
Detach the Boot Volume:
On the Boot Volume Details page, click the Detach button.
Confirm the detachment. Wait for it to complete.
Create or Use a "Rescue" Instance:
You need another Linux instance in the same Availability Domain (AD) that you can SSH into.

If you don't have one, create a small, temporary Linux instance (Oracle Linux is fine) in the same AD as your original instance. Make sure you can SSH into this new instance. Let's call this the 'Rescue Instance'.
Attach the Boot Volume to the Rescue Instance:
- Navigate to the Rescue Instance's details page.
- Go to "Resources" -> "Attached block volumes"
- Click "Attach Block Volume"
- Select "Paravirtualized" as the attachment type.
- Choose detached "your-instance-name" boot volume
- Choose a device path (usually /dev/oracleoci/oraclevdb or similar is fine, the OS will likely see it as /dev/sdb or /dev/sdc, etc.).
- Click Attach. Wait for the attachment to complete.
SSH into the Rescue Instance:
Connect to your working Rescue Instance via SSH.
Identify the Attached Disk:
Run the following command on the Rescue Instance to identify the newly attached disk (e.g., /dev/sdb, /dev/sdc) and its partitions (e.g., /dev/sdb1 which should contain the root filesystem /):
```
sudo fdisk -l
```
Mount the Filesystem:
Create a mount point:
```
sudo mkdir /mnt/rescue
```
Mount the root partition of the attached volume (Replace /dev/sdb1 with the correct partition identified in the previous step):
```
sudo mount /dev/sdb1 /mnt/rescue
```
Chroot into the Mounted Filesystem:
This allows you to run commands as if you were inside the original instance's OS:
```
sudo chroot /mnt/rescue
```
Set the Password:
Now that you are 'inside' the original OS environment, set a password for the ubuntu user:
```
passwd ubuntu
```
Enter and confirm a new, strong password when prompted.
Exit Chroot:
Type exit:
```
exit
```
Unmount the Filesystem:
Unmount the volume:
```
sudo umount /mnt/rescue
```
Detach the Volume from Rescue Instance:

Go back to the OCI Console -> Rescue Instance Details -> Attached Block Volumes -> Find the attached boot volume -> Click the Actions menu (...) -> Detach. Wait for detachment.
Re-attach Boot Volume to Original Instance:

Go back to your original instance details page -> Resources -> Boot Volume -> Click Attach. Select the correct boot volume. Confirm. Wait for attachment.
Start Original Instance:

Go back to the original instance's details page and click Start.
Use Console Connection:

Once the instance is running, create a new Console Connection, connect to it, and log in as ubuntu using the password you just set.
Fix the Firewall:
Once logged in via the console, allow SSH traffic and reload the firewall:
```
sudo ufw allow 22/tcp
sudo ufw reload
sudo ufw status # (to verify)
```
Test SSH:
Disconnect the console connection and try SSHing normally (replace YOUR_INSTANCE_IP with the actual IP):
```
ssh ubuntu@YOUR_INSTANCE_IP
```
Enjoy new life. Make plans.

Never allow people to tell You that Apps primarly made to indefinitely shuffle icons on desktop are absurdly useless and do not solve real life problems!

obviously they just want to get the license cheaper

DEV Community: twistedtransistor

Meet my simple CLI Tool That Makes Oh My Posh Theme-Hopping Effortless

Features

Prerequisites

Installation

Method 1: PyPI (Recommended)

Method 2: AUR (Arch Linux)

Method 3: Git Clone

Usage After Installation

Shell Config

Clean Theme Management:

Usage Details

Interface Overview

Keyboard Shortcuts

Local Theme Actions (ENTER)

Getting Started

Theme Previews

Filter

Custom Repository Support

Theme Customization

Theme Storage

Troubleshooting

"Unsupported shell" Error

Safety measures:

Backup-friendly: Uses a clean replacement strategy that preserves non-Oh My Posh configurations

Atomic updates: Reads entire file, modifies in memory, then writes back

Error handling: Returns success/failure status

uses regex pattern to identify Oh My Posh lines:

User confirmation: Always asks for confirmation before activating themes

Theme Not Activating

Preview Not Working

Search Not Responding

Custom Repository Issues

Theme Customization Problems

Performance Features

What's New in v2.0

Contributing

License

Architecture

Dependencies

Related Links

Google's Hand & Gesture Recognition + my playground

Why Hand & Gesture

Why Nextjs viewTransitions

What is the status

What do i think

Whats the future like

Tech list

Building and Running

Architecture Overview

Routes Structure

Main Routes

Route Functionality

Context Providers & State Management

1. MediaPipeOptionsProvider

2. GestureOptionsProvider

3. CalibrationProvider

4. HandTrackingProvider

Options-to-UI Integration

MediaPipeControls Component

Calibration System

Why Calibration is Necessary

Calibration Structure

Calibration Data Processing

Benefits of Calibration

Gesture Recognition System

Detection Algorithms

1. Original Mode

2. Simple Mode

3. Advanced Mode

Seemless Coolify SSL. Self-sign, self-renew with Telegram/Discord status reports. Coolify + Ubuntu + Oracle

Youre in a good spot! Follow along and make SSL certs run on IP address of your COOLIFY VPS best way there always been!

How it works ?

🔁 Renewal (if certs already exist)

🧠 Smart Logic

🤖 Auto Mode (via cron)

🧪SETUP

Open with nano:

Paste the script and save it:

Make it executable: