@abyrd9/harbor-cli 0.0.1

package/README.md

@@ -0,0 +1,119 @@
+# Harbor CLI
+
+A CLI tool for those small side projects that only run a few services. Harbor allows you to:
+
+1. 🛠️ Define your services in a configuration file
+2. 🔄 Generate a Caddyfile to reverse proxy certain services to subdomains
+3. 🚀 Launch your services in a tmux session with Caddy and your services automatically proxied
+
+## Installation
+
+```bash
+npm i -g harbor-cli
+```
+
+## Prerequisites
+
+Before using Harbor, make sure you have the following installed:
+
+- [Caddy](https://caddyserver.com/docs/install) (for reverse proxy)
+- [tmux](https://github.com/tmux/tmux/wiki/Installing) (for terminal multiplexing)
+- [jq](https://stedolan.github.io/jq/download/) (for JSON processing within tmux)
+
+## Quick Start
+
+1. Initialize your development environment:
+```bash
+harbor dock
+```
+
+2. Add new services to your configuration:
+```bash
+harbor moor
+```
+
+3. Update your Caddyfile:
+```bash
+harbor anchor
+```
+
+4. Launch your services:
+```bash
+harbor launch
+```
+
+## Configuration
+
+Harbor uses two main configuration files:
+
+### harbor.json
+
+Contains your service configurations that are used to generate the Caddyfile and launch the services:
+
+```json
+{
+  "domain": "localhost",
+  "services": [
+    {
+      "name": "frontend",
+      "path": "./vite-frontend",
+      "command": "npm run dev",
+      "port": 3000,
+      "subdomain": "app"
+    },
+    {
+      "name": "api",
+      "path": "./go-api",
+      "command": "go run .",
+      "port": 8080,
+      "subdomain": "api"
+    },
+    {
+      "name": "dashboard",
+      "path": "./vite-frontend",
+      "command": "npx drizzle-kit studio",
+    }
+  ]
+}
+```
+
+> Note: The dashboard service is a bit special. This is a drizzle studio instance to view your database. There's no subdomain value and no port declared because it typically runs at `local.drizzle.studio`. This will still be running and viewable in your tmux session, but it won't be automatically proxied.
+
+### Caddyfile
+
+Automatically generated reverse proxy configuration:
+
+```caddy
+api.localhost {
+    reverse_proxy localhost:8080
+}
+
+app.localhost {
+    reverse_proxy localhost:3000
+}
+```
+
+## Commands
+
+- `harbor dock`: Generate a new harbor.json file
+- `harbor moor`: Add new services to your harbor.json file
+- `harbor anchor`: Update your Caddyfile from the current harbor.json file
+- `harbor launch`: Start all services defined in your harbor.json file in a tmux session
+
+## Terminal Multiplexer
+
+Harbor uses tmux for managing your services. Some useful shortcuts:
+
+- `Ctrl+a d`: Detach from session
+- `Ctrl+a c`: Create new window
+- `Ctrl+a n`: Next window
+- `Ctrl+a p`: Previous window
+- `Ctrl+q`: Quit session
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+import { Command } from '@commander-js/extra-typings';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { chmodSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+// Read version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageJson = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+const requiredDependencies = [
+    {
+        name: 'Caddy',
+        command: 'caddy version',
+        installMsg: 'https://caddyserver.com/docs/install',
+        requiredFor: 'reverse proxy functionality',
+    },
+    {
+        name: 'tmux',
+        command: 'tmux -V',
+        installMsg: 'https://github.com/tmux/tmux/wiki/Installing',
+        requiredFor: 'terminal multiplexing',
+    },
+    {
+        name: 'jq',
+        command: 'jq --version',
+        installMsg: 'https://stedolan.github.io/jq/download/',
+        requiredFor: 'JSON processing in service management',
+    },
+];
+async function checkDependencies() {
+    const missingDeps = [];
+    for (const dep of requiredDependencies) {
+        try {
+            await new Promise((resolve, reject) => {
+                const process = spawn('sh', ['-c', dep.command]);
+                process.on('close', (code) => {
+                    if (code === 0)
+                        resolve(null);
+                    else
+                        reject();
+                });
+            });
+        }
+        catch {
+            missingDeps.push(dep);
+        }
+    }
+    if (missingDeps.length > 0) {
+        console.log('❌ Missing required dependencies:');
+        for (const dep of missingDeps) {
+            console.log(`\n${dep.name} (required for ${dep.requiredFor})`);
+            console.log(`Install instructions: ${dep.installMsg}`);
+        }
+        throw new Error('Please install missing dependencies before continuing');
+    }
+}
+const possibleProjectFiles = [
+    'package.json', // Node.js projects
+    'go.mod', // Go projects
+    'Cargo.toml', // Rust projects
+    'composer.json', // PHP projects
+    'requirements.txt', // Python projects
+    'Gemfile', // Ruby projects
+    'pom.xml', // Java Maven projects
+    'build.gradle', // Java Gradle projects
+];
+const program = new Command();
+program
+    .name('harbor')
+    .description(`A CLI tool for managing your project's local development services
+
+Harbor helps you manage multiple local development services with ease.
+It provides a simple way to configure and run your services with automatic
+subdomain routing through Caddy reverse proxy.
+
+Available Commands:
+  dock      Initialize a new Harbor project
+  moor      Add new services to your configuration
+  anchor    Generate Caddy reverse proxy configuration
+  launch    Start all services in tmux sessions`)
+    .version(packageJson.version)
+    .action(async () => await checkDependencies())
+    .addHelpCommand(false);
+// If no command is provided, display help
+if (process.argv.length <= 2) {
+    program.help();
+}
+program.command('dock')
+    .description(`Prepares your development environment by creating both:
+- harbor.json configuration file
+- Caddyfile for reverse proxy
+	
+This is typically the first command you'll run in a new project.`)
+    .option('-p, --path <path>', 'The path to the root of your project', './')
+    .action(async (options) => {
+    const caddyFileExists = fileExists('Caddyfile');
+    const configFileExists = fileExists('harbor.json');
+    if (caddyFileExists || configFileExists) {
+        console.log('❌ Error: Harbor project already initialized');
+        if (caddyFileExists) {
+            console.log('   - Caddyfile already exists');
+        }
+        if (configFileExists) {
+            console.log('   - harbor.json already exists');
+        }
+        console.log('\nTo reinitialize, please remove these files first.');
+        process.exit(1);
+    }
+    await generateDevFile(options.path);
+    await generateCaddyFile();
+    console.log('✨ Environment successfully prepared and anchored!');
+});
+program.command('moor')
+    .description('Add new services to your harbor.json configuration file')
+    .option('-p, --path <path>', 'The path to the root of your project', './')
+    .action(async (options) => {
+    if (!fileExists('harbor.json')) {
+        console.log('❌ No harbor.json configuration found');
+        console.log('\nTo initialize a new Harbor project, please use:');
+        console.log('  harbor anchor');
+        process.exit(1);
+    }
+    await generateDevFile(options.path);
+});
+program.command('anchor')
+    .description(`Add new services to your Caddyfile
+
+Note: This command will stop any active Caddy processes, including those from other Harbor projects.`)
+    .action(async () => {
+    if (!fileExists('harbor.json')) {
+        console.log('❌ No harbor.json configuration found');
+        console.log('\nTo initialize a new Harbor project, please use:');
+        console.log('  harbor anchor');
+        process.exit(1);
+    }
+    await generateCaddyFile();
+});
+program.command('launch')
+    .description(`Launch your services in the harbor terminal multiplexer (Using tmux)
+
+Note: This command will stop any active Caddy processes, including those from other Harbor projects.`)
+    .action(async () => {
+    await runServices();
+});
+program.parse();
+function fileExists(path) {
+    return fs.existsSync(`${process.cwd()}/${path}`);
+}
+function isProjectDirectory(dirPath) {
+    return possibleProjectFiles.some(file => {
+        try {
+            return fs.existsSync(path.join(process.cwd(), dirPath, file));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function validateConfig(config) {
+    if (!config.domain) {
+        return 'Domain is required';
+    }
+    if (!Array.isArray(config.services)) {
+        return 'Services must be an array';
+    }
+    for (const service of config.services) {
+        if (!service.name) {
+            return 'Service name is required';
+        }
+        if (!service.path) {
+            return 'Service path is required';
+        }
+    }
+    return null;
+}
+async function generateDevFile(dirPath) {
+    let config;
+    try {
+        const existing = await fs.promises.readFile('harbor.json', 'utf-8');
+        config = JSON.parse(existing);
+        console.log('Found existing harbor.json, scanning for new services...');
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            console.error('Error reading harbor.json:', err);
+            process.exit(1);
+        }
+        // Initialize new config with defaults
+        config = {
+            domain: 'localhost',
+            useSudo: false,
+            services: [],
+        };
+        console.log('Creating new harbor.json...');
+    }
+    // Create a map of existing services for easy lookup
+    const existing = new Set(config.services.map(s => s.name));
+    let newServicesAdded = false;
+    try {
+        const folders = await fs.promises.readdir(dirPath, { withFileTypes: true });
+        for (const folder of folders) {
+            if (folder.isDirectory()) {
+                const folderPath = path.join(dirPath, folder.name);
+                // Only add directories that contain project files and aren't already in config
+                if (isProjectDirectory(folderPath) && !existing.has(folder.name)) {
+                    const service = {
+                        name: folder.name,
+                        path: folderPath,
+                        subdomain: folder.name.toLowerCase().replace(/\s+/g, ''),
+                    };
+                    // Try to determine default command based on project type
+                    if (fs.existsSync(path.join(folderPath, 'package.json'))) {
+                        service.command = 'npm run dev';
+                    }
+                    else if (fs.existsSync(path.join(folderPath, 'go.mod'))) {
+                        service.command = 'go run .';
+                    }
+                    config.services.push(service);
+                    console.log(`Added new service: ${folder.name}`);
+                    newServicesAdded = true;
+                }
+                else if (existing.has(folder.name)) {
+                    console.log(`Skipping existing service: ${folder.name}`);
+                }
+                else {
+                    console.log(`Skipping directory ${folder.name} (no recognized project files)`);
+                }
+            }
+        }
+        if (!newServicesAdded) {
+            console.log('No new services found to add, feel free to add them manually');
+            return;
+        }
+        const validationError = validateConfig(config);
+        if (validationError) {
+            console.log(`❌ Invalid harbor.json configuration: ${validationError}`);
+            process.exit(1);
+        }
+        await fs.promises.writeFile('harbor.json', JSON.stringify(config, null, 2), 'utf-8');
+        console.log('\nharbor.json updated successfully');
+        console.log('\nImportant:');
+        console.log('  - Update the \'Port\' field for each service to match its actual port or leave blank to ignore in the Caddyfile');
+        console.log('  - Verify the auto-detected commands are correct for your services');
+    }
+    catch (err) {
+        console.error('Error processing directory:', err);
+        process.exit(1);
+    }
+}
+async function readHarborConfig() {
+    try {
+        const data = await fs.promises.readFile('harbor.json', 'utf-8');
+        const config = JSON.parse(data);
+        const validationError = validateConfig(config);
+        if (validationError) {
+            throw new Error(`Invalid configuration: ${validationError}`);
+        }
+        return config;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            throw new Error('harbor.json not found');
+        }
+        throw err;
+    }
+}
+async function stopCaddy() {
+    try {
+        console.log('\n⚠️  Stopping any existing Caddy processes...');
+        console.log('   This will interrupt any active Harbor or Caddy services\n');
+        // Try to kill any existing Caddy processes
+        await new Promise((resolve) => {
+            const isWindows = process.platform === 'win32';
+            const killCommand = isWindows ? 'taskkill /F /IM caddy.exe' : 'pkill caddy';
+            const childProcess = spawn('sh', ['-c', killCommand]);
+            childProcess.on('close', () => {
+                // It's okay if there was no process to kill (code 1)
+                resolve();
+            });
+        });
+        // Give it a moment to fully release ports
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    catch (err) {
+        // Ignore errors as the process might not exist
+    }
+}
+async function generateCaddyFile() {
+    try {
+        const config = await readHarborConfig();
+        let caddyfileContent = '';
+        for (const svc of config.services) {
+            if (!svc.port || !svc.subdomain) {
+                continue;
+            }
+            const serverName = `${svc.subdomain}.${config.domain}`;
+            caddyfileContent += `${serverName} {\n`;
+            caddyfileContent += `  reverse_proxy localhost:${svc.port}\n`;
+            caddyfileContent += "}\n\n";
+        }
+        await fs.promises.writeFile('Caddyfile', caddyfileContent, 'utf-8');
+        // Stop existing Caddy process before proceeding
+        await stopCaddy();
+        console.log('Caddyfile generated successfully');
+    }
+    catch (err) {
+        console.error('Error generating Caddyfile:', err);
+        process.exit(1);
+    }
+}
+async function runServices() {
+    // Check for required files
+    if (!fileExists('harbor.json')) {
+        console.log('❌ No harbor.json configuration found');
+        console.log('\nTo initialize a new Harbor project, please use:');
+        console.log('  harbor anchor');
+        process.exit(1);
+    }
+    // Load and validate config
+    try {
+        const config = await readHarborConfig();
+        const validationError = validateConfig(config);
+        if (validationError) {
+            console.log(`❌ Invalid harbor.json configuration: ${validationError}`);
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error('Error reading config:', err);
+        process.exit(1);
+    }
+    if (!fileExists('Caddyfile')) {
+        console.log('❌ No Caddyfile found');
+        console.log('\nTo initialize a new Harbor project, please use:');
+        console.log('  harbor anchor');
+        console.log('\nOr to generate just the Caddyfile:');
+        console.log('  harbor moor');
+        process.exit(1);
+    }
+    // Stop any existing Caddy process
+    await stopCaddy();
+    // Ensure scripts exist and are executable
+    await ensureScriptsExist();
+    // Execute the script directly using spawn to handle I/O streams
+    const scriptPath = path.join(getScriptsDir(), 'dev.sh');
+    const command = spawn('bash', [scriptPath], {
+        stdio: 'inherit', // This will pipe stdin/stdout/stderr to the parent process
+    });
+    return new Promise((resolve, reject) => {
+        command.on('error', (err) => {
+            console.error(`Error running dev.sh: ${err}`);
+            process.exit(1);
+        });
+        command.on('close', (code) => {
+            if (code !== 0) {
+                console.error(`dev.sh exited with code ${code}`);
+                process.exit(1);
+            }
+            resolve();
+        });
+    });
+}
+// Get the package root directory
+function getPackageRoot() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(__dirname, '..');
+}
+// Get the template scripts directory (where our source scripts live)
+function getTemplateScriptsDir() {
+    return path.join(getPackageRoot(), 'scripts');
+}
+// Get the scripts directory (where we'll create the scripts for the user)
+function getScriptsDir() {
+    return path.join(getPackageRoot(), 'scripts');
+}
+async function ensureScriptsExist() {
+    const scriptsDir = getScriptsDir();
+    const templateDir = getTemplateScriptsDir();
+    // Ensure scripts directory exists
+    if (!fs.existsSync(scriptsDir)) {
+        fs.mkdirSync(scriptsDir, { recursive: true });
+    }
+    try {
+        const scriptPath = path.join(scriptsDir, 'dev.sh');
+        const templatePath = path.join(templateDir, 'dev.sh');
+        // Create the script if it doesn't exist
+        if (!fs.existsSync(scriptPath)) {
+            const templateContent = readFileSync(templatePath, 'utf-8');
+            fs.writeFileSync(scriptPath, templateContent, 'utf-8');
+            console.log('Created dev.sh');
+        }
+        // Make the script executable
+        chmodSync(scriptPath, '755');
+    }
+    catch (err) {
+        console.error('Error setting up dev.sh:', err);
+        throw err;
+    }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@abyrd9/harbor-cli",
+  "version": "0.0.1",
+  "description": "A CLI tool for managing local development services with automatic subdomain routing",
+  "type": "module",
+  "bin": {
+    "harbor": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "bun run build",
+    "start": "node dist/index.js",
+    "harbor": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "release": "npm run build && changeset publish",
+    "changeset": "changeset",
+    "version": "changeset version"
+  },
+  "keywords": [
+    "cli",
+    "development",
+    "proxy",
+    "caddy",
+    "tmux",
+    "local-development"
+  ],
+  "author": "Andrew Byrd",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Abyrd9/harbor-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Abyrd9/harbor-cli/issues"
+  },
+  "homepage": "https://github.com/Abyrd9/harbor-cli#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@commander-js/extra-typings": "^11.1.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.10",
+    "@types/node": "^20.10.5",
+    "bun-types": "latest",
+    "typescript": "^5.3.3"
+  },
+  "main": "index.js"
+}

package/scripts/dev.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+
+# Check if the session already exists and kill it
+if tmux has-session -t local-dev-test 2>/dev/null; then
+    echo "Killing existing tmux session 'local-dev-test'"
+    tmux kill-session -t local-dev-test
+fi
+
+# Start a new tmux session named 'local-dev-test' and rename the initial window
+tmux new-session -d -s local-dev-test
+
+# Set tmux options
+tmux set-option -g prefix C-a
+tmux bind-key C-a send-prefix
+tmux set-option -g mouse on
+tmux set-option -g history-limit 50000
+tmux set-window-option -g mode-keys vi
+
+# Add binding to kill session with Ctrl+q
+tmux bind-key -n C-q kill-session
+
+# Add padding and styling to panes
+tmux set-option -g pane-border-style fg="#3f3f3f"
+tmux set-option -g pane-active-border-style fg="#6366f1"
+tmux set-option -g pane-border-status top
+tmux set-option -g pane-border-format ""
+
+# Add padding inside panes
+tmux set-option -g status-left-length 100
+tmux set-option -g status-right-length 100
+tmux set-window-option -g window-style 'fg=colour247,bg=colour236'
+tmux set-window-option -g window-active-style 'fg=colour250,bg=black'
+
+# Set inner padding
+tmux set-option -g window-style "bg=#1c1917 fg=#a8a29e"
+tmux set-option -g window-active-style "bg=#1c1917 fg=#ffffff"
+
+# Improve copy mode and mouse behavior
+tmux set-option -g set-clipboard external
+tmux bind-key -T copy-mode-vi v send-keys -X begin-selection
+tmux bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel
+tmux bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"
+
+# Set easier window navigation shortcuts
+tmux bind-key -n Left select-window -t :-
+tmux bind-key -n Right select-window -t :+
+
+# Configure status bar
+tmux set-option -g status-position top
+tmux set-option -g status-style bg="#1c1917",fg="#a8a29e"
+tmux set-option -g status-left ""
+tmux set-option -g status-right "#[fg=#a8a29e]Close with ctrl+q · #[fg=white]%H:%M#[default]"
+tmux set-window-option -g window-status-current-format "\
+#[fg=#6366f1, bg=#1c1917] →
+#[fg=#6366f1, bg=#1c1917, bold] #W
+#[fg=#6366f1, bg=#1c1917]  "
+tmux set-window-option -g window-status-format "\
+#[fg=#a8a29e, bg=#1c1917]  
+#[fg=#a8a29e, bg=#1c1917] #W \
+#[fg=#a8a29e, bg=#1c1917] "
+
+# Add padding below status bar
+tmux set-option -g status 2
+tmux set-option -Fg 'status-format[1]' '#{status-format[0]}'
+tmux set-option -g 'status-format[0]' ''
+
+# Create a new window for the interactive shell
+echo "Creating window for interactive shell"
+tmux rename-window -t local-dev-test:0 'Terminal'
+
+# Create a new window for Caddy (now on index 1)
+echo "Creating window for Caddy"
+tmux new-window -t local-dev-test:1 -n 'Caddy'
+tmux send-keys -t local-dev-test:1 'caddy run' C-m
+
+# Create windows dynamically based on harbor.json
+window_index=2  # Start from index 2 since we have Terminal and Caddy
+jq -c '.services[]' harbor.json | while read service; do
+    name=$(echo $service | jq -r '.name')
+    path=$(echo $service | jq -r '.path')
+    command=$(echo $service | jq -r '.command')
+    
+    echo "Creating window for service: $name"
+    echo "Path: $path"
+    echo "Command: $command"
+    
+    tmux new-window -t local-dev-test:$window_index -n "$name"
+    tmux send-keys -t local-dev-test:$window_index "cd $path && $command" C-m
+    
+    ((window_index++))
+done
+
+# Bind 'Home' key to switch to the terminal window
+tmux bind-key -n Home select-window -t :0
+
+# Select the terminal window
+tmux select-window -t local-dev-test:0
+
+# Attach to the tmux session
+tmux attach-session -t local-dev-test