Kanban Board

**Priority Classification**: Functional failures → High priority (To Do), General errors → Medium priority (Backlog)

**User Request Handling**: Direct requests added as high priority to To Do section

Hosting Management System: Implement Nginx config reading service in web/services/config_manager.py. Add methods to list all Nginx configs, read specific config file, validate config paths, and return formatted config content. Include error handling for missing files and permission issues.

Hosting Management System: Create config editing UI at /configs route. Display list of all Nginx configs with syntax-highlighted editor using CodeMirror or Monaco. Add save/cancel buttons and real-time validation feedback. Ensure changes are staged before applying.

Hosting Management System: Implement Nginx config validation with 'nginx -t' before applying changes. Add API endpoint POST /api/configs/nginx/test that runs validation and returns success/error. Display validation results in UI before allowing save. Test with intentionally broken config.

Hosting Management System: Add API endpoint PUT /api/configs/nginx/{site} for updating config files. Validate input, create backup, write new config, test with nginx -t, reload if valid. Rollback on failure. Test with all three sites (cigar, tobacco, hosting).

Hosting Management System: Write pytest tests for config management covering read, write, validate, backup, restore, and rollback scenarios. Achieve 100% coverage for config_manager.py. Mock filesystem operations and nginx commands.

Cigar Management System: Setup Devise gem for user authentication. Configure Devise with email/password authentication, confirmable, recoverable, and rememberable modules. Create User model with email, encrypted_password, and admin boolean. Verify Devise routes are properly installed.

Cigar Management System: Create default admin user via rake task using credentials from .secrets.json (email: admin@remoteds.us). Add db/seeds.rb entry for admin user creation. Verify admin user can login, logout, and reset password. Test all Devise flows with RSpec.

Cigar Management System: Modify ApplicationController to require authentication for all routes using before_action :authenticate_user! Add public routes exception list if needed. Verify unauthenticated users are redirected to login. Test with RSpec request specs.

Cigar Management System: Create Humidor model with name, location, capacity, and temperature/humidity fields. Add CRUD views with Bootstrap 5 styling. Implement humidor listing, create, edit, and delete functionality. Verify all CRUD operations work correctly.

Cigar Management System: Create Cigar model with brand, name, size, wrapper, strength, humidor association. Add CRUD views with search and filtering. Implement pagination for large lists. Test all CRUD operations and associations with RSpec.

Cigar Management System: Write comprehensive RSpec tests for all models, controllers, and views covering validations, associations, CRUD operations, search, and filtering. Achieve minimum 80% test coverage.

Tobacco Management System: Create default admin user via rake task using credentials from .secrets.json (email: admin@remoteds.us). Add db/seeds.rb entry for admin user creation. Verify admin user can login, logout, and reset password. Test all Devise flows with RSpec.

Tobacco Management System: Modify ApplicationController to require authentication for all routes using before_action :authenticate_user! Add public routes exception list if needed. Verify unauthenticated users are redirected to login. Test with RSpec request specs.

Tobacco Management System: Create Product model with name, brand, type (pipe/cigar/cigarette), flavor_profile, nicotine_strength fields. Add CRUD views with Bootstrap 5 styling. Implement search and filtering by type and brand. Test all CRUD operations with RSpec.

Tobacco Management System: Write comprehensive RSpec tests for all models, controllers, and views covering validations, associations, CRUD operations, search, and inventory tracking. Achieve minimum 80% test coverage.

Infrastructure: Document PostgreSQL restore procedure in BACKUP_RESTORE_GUIDE.md. Include steps for stopping services, dropping/creating database, restoring from backup, and restarting services. Test restore procedure on QA environment.

Documentation: Document full Ruby 3.3+/Rails 7.2+ local development setup including rbenv/rvm installation, PostgreSQL setup, gem installation, and database creation. Add to development guide with step-by-step instructions.

Hosting Management System: Implement Nginx config reading service in web/services/config_manager.py. Add methods to list all Nginx configs, read specific config file, validate config paths, and return formatted config content. Include error handling for missing files and permission issues.

Hosting Management System: Create config editing UI at /configs route. Display list of all Nginx configs with syntax-highlighted editor using CodeMirror or Monaco. Add save/cancel buttons and real-time validation feedback. Ensure changes are staged before applying.

Hosting Management System: Implement Nginx config validation with 'nginx -t' before applying changes. Add API endpoint POST /api/configs/nginx/test that runs validation and returns success/error. Display validation results in UI before allowing save. Test with intentionally broken config.

Hosting Management System: Add API endpoint PUT /api/configs/nginx/{site} for updating config files. Validate input, create backup, write new config, test with nginx -t, reload if valid. Rollback on failure. Test with all three sites (cigar, tobacco, hosting).

Hosting Management System: Write pytest tests for config management covering read, write, validate, backup, restore, and rollback scenarios. Achieve 100% coverage for config_manager.py. Mock filesystem operations and nginx commands.

Cigar Management System: Setup Devise gem for user authentication. Configure Devise with email/password authentication, confirmable, recoverable, and rememberable modules. Create User model with email, encrypted_password, and admin boolean. Verify Devise routes are properly installed.

Cigar Management System: Create default admin user via rake task using credentials from .secrets.json (email: admin@remoteds.us). Add db/seeds.rb entry for admin user creation. Verify admin user can login, logout, and reset password. Test all Devise flows with RSpec.

Cigar Management System: Create Cigar model with brand, name, size, wrapper, strength, humidor association. Add CRUD views with search and filtering. Implement pagination for large lists. Test all CRUD operations and associations with RSpec.

Cigar Management System: Write comprehensive RSpec tests for all models, controllers, and views covering validations, associations, CRUD operations, search, and filtering. Achieve minimum 80% test coverage.

Tobacco Management System: Create default admin user via rake task using credentials from .secrets.json (email: admin@remoteds.us). Add db/seeds.rb entry for admin user creation. Verify admin user can login, logout, and reset password. Test all Devise flows with RSpec.

Tobacco Management System: Create Product model with name, brand, type (pipe/cigar/cigarette), flavor_profile, nicotine_strength fields. Add CRUD views with Bootstrap 5 styling. Implement search and filtering by type and brand. Test all CRUD operations with RSpec.

Tobacco Management System: Write comprehensive RSpec tests for all models, controllers, and views covering validations, associations, CRUD operations, search, and inventory tracking. Achieve minimum 80% test coverage.

Infrastructure: Implement automated PostgreSQL backup with pg_dump running via cron every 6 hours. Store backups in /opt/backups/postgresql/ with 7-day rotation. Create backup script in /usr/local/bin/backup_databases.sh. Verify backup files are created and rotated correctly.

Infrastructure: Document PostgreSQL restore procedure in BACKUP_RESTORE_GUIDE.md. Include steps for stopping services, dropping/creating database, restoring from backup, and restarting services. Test restore procedure on QA environment.

Documentation: Document full Ruby 3.3+/Rails 7.2+ local development setup including rbenv/rvm installation, PostgreSQL setup, gem installation, and database creation. Add to development guide with step-by-step instructions.

Phase 4: Add local/remote execution modes to manager.py (--execute-locally, --execute-remotely flags)

Deploy cigar app from scratch with new database-backed setup

Deploy hosting app updates to production server

Test input validation

Test error responses

Test full workflows (deploy → start → stop)

Test with real systemctl commands (in test environment)

Test Nginx config changes

Test CLI commands

Test API communication

Test error handling

Test authentication

Test JWT token validation

Test rate limiting

Test password requirements

✅ Minimum 80% code coverage

✅ No hardcoded credentials in tests

✅ Use fixtures for test data

✅ Clean up test data after tests

[x] Update .secrets.json format

[x] Create web/ directory structure

[x] Implement basic FastAPI app with authentication

[x] Create dashboard HTML template

[x] Deploy to server (bootstrap method)

[x] Write tests for authentication

[x] Implement app status checking

[x] Implement start/stop/restart functionality

[x] Create app management UI

[x] Add API endpoints for app control

[x] Write tests for app management

[x] Test with cigar and tobacco apps

[x] Add `letsencrypt_email` to `config.json` (contact for LE terms)

[x] Install Certbot + nginx plugin on remote host

[x] Issue staging certs for: hosting.remoteds.us, cigars.remoteds.us, tobacco.remoteds.us

[x] Switch to production issuance for all three domains

[ ] Verify auto-renew timer and dry-run; confirm Nginx reload on renew

[x] Update `ssl_config` to LE live paths (if not already)

[x] Implement log reading service

[x] Create logs UI with filtering

[x] Add Nginx log support

[x] Implement real-time log tailing

[x] Write tests for log viewing

[ ] Implement config reading/writing

[ ] Create config editing UI

[ ] Add Nginx config validation

[ ] Implement backup/restore

[ ] Write tests for config management

[ ] Create troubleshooting scripts

[ ] Implement script runner service

[ ] Create scripts UI

[ ] Add script output streaming

[ ] Write tests for script execution

[ ] Implement self-update functionality

[ ] Add deployment UI

[ ] Test graceful restart

[ ] Document update procedures

[ ] Write tests for self-updates

✅ Can access https://hosting.remoteds.us with password

✅ Dashboard shows all apps with status

✅ Authentication tests pass

✅ Deployed via bootstrap method

✅ Can start/stop/restart all Rails apps via web UI

✅ Can start/stop/restart via API from laptop

✅ All app management tests pass

✅ Can view logs for all Rails apps

✅ Can view Nginx access and error logs

✅ Can search and filter logs

✅ All log viewing tests pass

✅ Can view all Nginx configs

✅ Can edit and test configs

✅ Changes are validated before applying

✅ All config management tests pass

✅ Can list all troubleshooting scripts

✅ Can execute scripts with parameters

✅ Can view script output in real-time

✅ All script execution tests pass

✅ Can update hosting system via web UI

✅ Updates are graceful (no downtime)

✅ Can rollback if needed

✅ All self-update tests pass

**Phase 1**: Core Infrastructure - Authentication, basic web interface

**Phase 2**: App Management - Start/stop/restart functionality

**Phase 3**: Log Viewing - Comprehensive log viewing with filtering

**Phase 4**: Config Management - Nginx configuration editing

**Phase 5**: Script Execution - Troubleshooting script runner

**Phase 6**: Self-Management - System updates and deployment

**Total Tests**: 89 passing tests

**Log Viewer Tests**: 23 tests covering all functionality

**API Routes Tests**: 26 tests covering all endpoints

**Existing Tests**: 40 tests for core functionality

**NO root-level git repository** - only individual app repos exist

**Local CLI tool only** (no Flask/FastAPI locally)

**Rails-only** applications on remote (Puma + Nginx)

**Remote web interface** at hosting.remoteds.us (to be built)

**Infrastructure as Code** - everything automated and repeatable

**Location**: `/Users/bpauley/Projects/mangement-systems/hosting-management-system/`

**Type**: Python 3.12 CLI tool (`manager.py`)

**Framework**: Click + Fabric/Paramiko

**Purpose**: Provision servers, deploy apps, manage configs

**No Web Server**: CLI-only, no local dashboard

**Host**: Ubuntu 25.04 LTS (Digital Ocean)

**Apps Deployed**:

`cigars.remoteds.us` → Cigar Management (Rails 7.2.2 + Puma)

`tobacco.remoteds.us` → Tobacco Management (Rails 7.2.2 + Puma)

`hosting.remoteds.us` → Management Interface (Rails 7.2.2 + Puma)

**Web Server**: Nginx (reverse proxy to Puma)

**App Server**: Puma (running as www-data user)

**Database**: PostgreSQL

Local: CLI tool (`manager.py`)

Remote: Rails web interface (to be built)

Same Ruby version (3.3+)

Same Rails version (7.2.2)

Same gem versions

✅ Manual verification complete

Redeployments **NEVER erase production data** by default

Database and uploaded files are preserved

Only use `--reset-data` flag when explicitly needed

All operations are idempotent (safe to run multiple times)

[ ] Create `DEPLOYMENT_LOG.md` in hosting-management-system/

[ ] Verify `deployment_key` and `deployment_key.pub` exist

[ ] Create `remote_cli_tools/` directory with scripts:

`parse_logs.sh` - Find errors in logs

`check_status.sh` - Check all service statuses

`restart_service.sh` - Quick service restart

[ ] Add `_install_remote_cli_tools()` method to provisioning

[ ] Add `view_logs` CLI command (stream journalctl)

[ ] Add `check_status` CLI command (query systemctl)

[ ] Verify SSH key deployment works correctly

[ ] Verify www-data ownership is set correctly

[ ] Document current server state in DEPLOYMENT_LOG.md

[ ] Run full provision + deploy cycle

[ ] Verify all apps deploy successfully

[ ] Test SSH key deployment

[ ] Test www-data ownership

[ ] **Destroy server and rebuild** to verify repeatability

[ ] Rewrite hosting-management-system/README.md

[ ] Remove all FastAPI/Flask references

[ ] Document CLI-only architecture

[ ] Add deployment procedure examples

[ ] Cross-reference with agents.md

[ ] Install Ruby 3.3+ locally

[ ] Install Rails 7.2.2 locally

[ ] Verify local environment matches production

[ ] Document local setup process

[ ] Create test checklist template

**Technology**: Rails 7.2.2 application

**Location**: `/var/www/hosting` on remote server

**Domain**: hosting.remoteds.us

**Features**:

Secure login/password authentication

Dashboard showing all app statuses

Real-time log viewing

App control (start/stop/restart)

Trigger deployments

View configurations

API endpoints for programmatic access

Backup management

Create new Rails 7.2.2 app in hosting-management-system repo

Add to config.json as deployment target

Deploy via same manager.py tool

Build authentication system

Create dashboard views

Implement API endpoints

[ ] Pytest coverage for ALL manager.py Fabric tasks

[ ] Mock connection tests

[ ] qa-test-repo deployment smoke tests

[ ] Full deployment cycle automated tests

[ ] Data preservation verification tests

"In Progress" item references old secrets management (complete)

Missing Phase 1 infrastructure tasks

No tasks for DEPLOYMENT_LOG.md creation

No tasks for remote CLI tools

Verify and document SSH key deployment

Create remote_cli_tools directory and scripts

Update manager.py with remote tool installation

Full provision + deploy cycle test

✅ Can provision bare Ubuntu server to production-ready state

✅ All steps documented in DEPLOYMENT_LOG.md

✅ Destroy/rebuild produces identical results

✅ No manual intervention required

✅ All configuration in code (Infrastructure as Code)

✅ Local Ruby/Rails environment matches production

✅ Can develop and test Rails apps locally

✅ Test suite running locally

✅ Development workflow documented

✅ hosting.remoteds.us serves management interface

✅ Can monitor all apps via web dashboard

✅ Can control apps via web interface

✅ API endpoints functional

✅ Secure authentication working

**Remember**: NO root-level git - only individual app repos

**Testing**: No production deploy without passing local tests

**Data Safety**: Never erase production data unless explicitly told

**Documentation**: Update DEPLOYMENT_LOG.md with every change

**Fixed Delete Bug**: Template was using `task.line_number` instead of `task.id` for PostgreSQL

**Fixed Pydantic v2**: Changed `regex` to `pattern` in field validation

**Added Tags API**: `/api/v1/kanban/tags` endpoint for tag management

**Added Tag Management**: Full CRUD interface at `/tags`

**Added Tag Filter**: Filter kanban tasks by assigned tags

<7 Days, <=2 Weeks, <=1 Month, <=3 Months, <=1 Year, All Issues

**Updated Task Cards**: Display tags with custom colors

**Added Manage Tags Button**: Quick access from kanban board

**Added Unit Tests**: 20 comprehensive pytest tests for all CRUD operations

**All Tests Pass**: Verified locally before deployment

**Test Coverage**: API endpoints, database models, validation rules

**PostgreSQL Remote Access**: Configured for user `bpauley`

**Firewall**: Opened port 5432 for remote connections

**Dependencies**: `sqlalchemy` and `psycopg2-binary` in requirements.txt

**Database**: `hosting_production` PostgreSQL database

**Tables**:

`kanban_tasks` - Main task storage with full metadata

`kanban_task_history` - Audit log for all changes

`kanban_tags` - Flexible tagging system

`kanban_task_tags` - Many-to-many task/tag relationship

**Schema File**: `docs/DATABASE_MIGRATION_KANBAN.sql`

**Migration Script**: `docs/migrate_todo_to_postgres.py`

**Source**: `/opt/hosting-api/TODO.md` → PostgreSQL

**Preserves**: All metadata (created_at, epic, priority, occurrence_count)

**Backup**: Original TODO.md automatically backed up

**Base URL**: `/api/v1/kanban/*`

**Authentication**: JWT Bearer token required

**All endpoints updated** to use SQLAlchemy instead of file operations

`GET /tasks` - Now supports advanced filtering (section, priority, status, epic)

`GET /tasks/{task_id}` - Changed from line_number to database ID

`POST /tasks` - Returns database ID instead of line number

`PUT /tasks/{task_id}` - Database-backed updates with transaction support

`POST /tasks/{task_id}/move` - Atomic section moves with position tracking

`DELETE /tasks/{task_id}` - Proper cascade delete with history preservation

`GET /health` - New endpoint for database connectivity checks

**Routes**: `docs/kanban_api_routes_postgres.py`

**Models**: `docs/kanban_models.py` (SQLAlchemy)

**File**: `docs/test_kanban_postgres.py`

**Framework**: pytest with requests library

**Test Classes**:

✅ API endpoint testing (all CRUD operations)

✅ Database constraint validation

✅ Authentication/authorization

✅ Filtering and pagination

✅ Task lifecycle (create → move → complete → delete)

✅ Concurrent access scenarios

✅ Web interface integration

**agents.md**:

Updated TODO Management System Rules section

Changed data storage from file to PostgreSQL database

Updated API endpoint documentation

Added database backup information

Removed file-based references

**KANBAN_POSTGRES_IMPLEMENTATION.md**: Complete implementation guide

Step-by-step migration procedures

Testing checklist

Troubleshooting guide

Rollback plan

Security considerations

**config.json**: Added `hosting` app configuration with database field

**.secrets.json**: Requires `hosting_production` database credentials

**Dependencies**: Added SQLAlchemy, psycopg2-binary, alembic to requirements.txt

**Included**: Kanban data now part of PostgreSQL backup system

**Automatic**: Same backup schedule as Rails applications

**No additional work**: Leverages existing infrastructure

Check: `priority IN ('high', 'medium', 'low')`

Check: `owner IN ('user', 'agent')`

`idx_kanban_section` on `section`

`idx_kanban_status` on `status`

`idx_kanban_priority` on `priority`

`idx_kanban_created_at` on `created_at DESC`

`idx_kanban_epic` on `epic`

`idx_kanban_position` on `section, position`

Auto-update `updated_at` on row modification

Log changes to `kanban_task_history` table

✅ Backup existing TODO.md file

✅ Document current task count and distribution

✅ Test migration script with dry-run

✅ Verify database connectivity

Run migration script: `python migrate_todo_to_postgres.py /opt/hosting-api/TODO.md`

Verify all tasks imported correctly

Check for any parsing errors

Validate metadata preservation

Remove or archive TODO.md files

Update all references to file-based system

Verify web interface displays correctly

Run full test suite

Monitor performance

[ ] All pytest tests pass

[ ] Database connection successful

[ ] CRUD operations work correctly

[ ] Constraints enforce data integrity

[ ] Audit trail logs changes

[ ] API endpoints respond correctly

[ ] Web interface renders tasks

[ ] Filtering and sorting work

[ ] Drag-and-drop functionality preserved

[ ] Authentication enforced

[ ] List queries < 100ms

[ ] Concurrent user access works

[ ] No file locking issues

[ ] Database indexes utilized

**Implementation Guide**: [docs/KANBAN_POSTGRES_IMPLEMENTATION.md](KANBAN_POSTGRES_IMPLEMENTATION.md)