n-OS-tr

n-OS-tr is an attempt to create a nostr based operating system / distro.

We are starting with a base of debian live.

Currently exploring different means to this end.

Debian Live Build Setup and Tutorial 1 Implementation

This document covers the complete process of setting up live-build and implementing Tutorial 1 from the Debian Live Manual.

System Requirements

Tested on Pop!_OS 22.04 LTS (Ubuntu-based system).

Phase 1: Installing Dependencies

The following packages are required for building Debian Live images:

sudo apt update
sudo apt install debootstrap xorriso squashfs-tools syslinux-utils cpio gzip gettext

Package purposes:

• debootstrap: Creates minimal Debian base system
• xorriso: Creates ISO images
• squashfs-tools: Creates compressed filesystem
• syslinux-utils: Boot loader utilities
• cpio, gzip, gettext: Archive and localization utilities

Phase 2: Setting up Live-Build from Repository

Instead of installing live-build via system packages (which may be outdated), we use the repository directly for the most current version.

Creating the Wrapper Script

Create lb-wrapper.sh for convenient access to live-build commands:

#!/bin/bash

# Set the LIVE_BUILD environment variable to point to our repository
export LIVE_BUILD="$(dirname "$0")/live-build"

# Execute the live-build frontend with all arguments passed through
"$LIVE_BUILD/frontend/lb" "$@"

Make it executable:

chmod +x lb-wrapper.sh

Usage: Replace all lb commands with ./lb-wrapper.sh to use the repository version.

Phase 3: Tutorial 1 - Default Image Creation

Following the Debian Live Manual Tutorial 1 to create a basic live system:

mkdir tutorial1
cd tutorial1
../lb-wrapper.sh config

This creates the basic configuration structure in the config/ directory.

Phase 4: Building the Image

Important: Due to keyring compatibility issues between Ubuntu/Pop!_OS and Debian, we need to bypass GPG verification for development builds.

Build the image as root with security bypass:

sudo ../lb-wrapper.sh config --apt-secure false --distribution stable
sudo ../lb-wrapper.sh build 2>&1 | tee build.log

Keyring Issues and Troubleshooting

Problem: Pop!_OS/Ubuntu keyrings are incompatible with both Debian testing and stable distributions, causing GPG verification failures.

Error examples:

• Debian testing: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 78DBA3BC47EF2265
• Debian stable: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 762F67A0B2C39DE4

Solution: Use --apt-secure false flag to bypass GPG verification for development purposes.

Production note: For production builds, proper keyring setup should be implemented instead of disabling security checks.

Expected Results

• Build time: Varies based on internet connection and system performance
• Output file: live-image-amd64.hybrid.iso (approximately 298MB)
• This ISO can be:
  • Tested in virtual machines (QEMU, VirtualBox)
  • Written to USB drives
  • Burned to optical media

Command Summary

Complete sequence for Tutorial 1:

# 1. Install dependencies
sudo apt install debootstrap xorriso squashfs-tools syslinux-utils cpio gzip gettext

# 2. Create wrapper script (if not exists)
# [Create lb-wrapper.sh as shown above]
chmod +x lb-wrapper.sh

# 3. Create and configure tutorial
mkdir tutorial1
cd tutorial1
../lb-wrapper.sh config --apt-secure false --distribution stable

# 4. Build image
sudo ../lb-wrapper.sh build 2>&1 | tee build.log

# 5. Result: live-image-amd64.hybrid.iso ready for testing

Notes

• The --distribution stable ensures we use Debian stable instead of the default testing
• Build logs are automatically saved due to the wrapper script configuration
• The --apt-secure false flag is a workaround for keyring issues on Ubuntu-based systems
• For clean rebuilds, use sudo ../lb-wrapper.sh clean before building again

FAQ

Q: What are the auto, config, and local directories created by lb config for?

A: When you run lb config, three directories are created:

1. auto/ - Created but empty by default

   • Used for optional automation scripts that you create yourself
   • You can add auto/config, auto/build, auto/clean scripts that run automatically before their respective lb commands
   • Most basic builds (like Tutorial 1) don't need these files
   • Useful for advanced scenarios where you want reproducible builds with version control

2. config/ - This is where the real configuration lives

   • Contains all the subdirectories for customizing your live system
   • Has the main config files (binary, bootstrap, chroot, common, source) with your build parameters
   • This is where you add package lists, custom files, hooks, etc.
   • Most important directory for customization

3. local/ - For local customizations

   • Also typically empty unless you have custom executables or files to include
   • Used for build-time scripts and tools, not files to include in the final system

Q: How do I add files to specific locations in the final live system?

A: Several directories in the config structure map directly to the final system filesystem:

For files you want in the final live system:

1. config/includes.chroot/ - Maps directly to the root filesystem (/)

   • To put a file in /usr/local/bin/myscript in the final system
   • Place it at config/includes.chroot/usr/local/bin/myscript
   • Everything in this directory gets copied to / in the live system

2. config/includes.chroot_after_packages/ - Same mapping, but copied after packages are installed

   • Use when you want to overwrite files that packages might have installed
   • Same directory mapping as above

3. config/includes.chroot_before_packages/ - Copied before packages are installed

   • Less commonly used, but available if needed

For files you want on the ISO/boot media itself (not in the live system):

4. config/includes.binary/ - Files that go on the boot media
   • These appear on the USB/CD itself, not inside the running live system
   • Useful for documentation, additional tools, etc.

Example: To put a custom script in /usr/local/bin/hello in your live system:

# 1. Create the directory structure
mkdir -p config/includes.chroot/usr/local/bin/

# 2. Put your script there
cp myscript config/includes.chroot/usr/local/bin/hello

# 3. Make it executable
chmod +x config/includes.chroot/usr/local/bin/hello

The build process will automatically copy it to the correct location in the live system.