portok 1.0.5 → 1.0.6

package/README.md

@@ -195,9 +195,10 @@ curl -H "x-admin-token: your-token" http://127.0.0.1:3000/__health
 portok <command> [options]
 
 Management Commands:
-  init            Initialize portok directories (/etc/portok, /var/lib/portok)
+  init            Initialize portok (creates dirs, installs systemd service)
   add <name>      Create a new service instance
   remove <name>   Remove a service instance (stops, disables, deletes config/state)
+  clean           Remove ALL portok data (configs, states, systemd service)
   list            List all configured instances and their status
 
 Service Control Commands:
@@ -231,6 +232,9 @@ Options for 'remove' command:
   --force           Skip confirmation prompt
   --keep-state      Keep state file (/var/lib/portok/<name>.json)
 
+Options for 'clean' command:
+  --force           Skip confirmation prompt (required)
+
 Options for 'logs' command:
   --follow, -f      Follow log output
   --lines, -n       Number of lines to show (default: 50)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portok",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Zero-downtime deployment proxy - routes traffic through a stable port to internal app instances with health-gated switching",
   "main": "portokd.js",
   "bin": {

package/portok.js

@@ -316,12 +316,26 @@ async function cmdInit(options) {
   const stateDir = '/var/lib/portok';
   const systemdDir = '/etc/systemd/system';
   const serviceFileName = 'portok@.service';
+  const { execSync } = require('child_process');
 
-  console.log(`${colors.bold}Initializing Portok...${colors.reset}\n`);
+  // Detect current user for service configuration
+  let currentUser = 'root';
+  let currentGroup = 'root';
+  
+  try {
+    currentUser = execSync('whoami', { encoding: 'utf-8' }).trim();
+    currentGroup = execSync(`id -gn ${currentUser}`, { encoding: 'utf-8' }).trim();
+  } catch (e) {
+    // Fallback to root if detection fails
+  }
 
-  // Check if running as root (needed for /etc and /var/lib)
   const isRoot = process.getuid && process.getuid() === 0;
 
+  console.log(`${colors.bold}Initializing Portok...${colors.reset}\n`);
+  console.log(`  User:  ${colors.cyan}${currentUser}${colors.reset}`);
+  console.log(`  Group: ${colors.cyan}${currentGroup}${colors.reset}`);
+  console.log(`  Node:  ${colors.dim}${process.execPath}${colors.reset}\n`);
+
   if (!isRoot && !options.force) {
     console.log(`${colors.yellow}Warning:${colors.reset} This command typically requires root privileges.`);
     console.log(`Run with sudo or use --force to attempt anyway.\n`);
@@ -394,6 +408,10 @@ async function cmdInit(options) {
       serviceContent = serviceContent.replace(/WorkingDirectory=\/opt\/portok/g, `WorkingDirectory=${portokDir}`);
       serviceContent = serviceContent.replace(/\/opt\/portok\/portokd\.js/g, `${portokDir}/portokd.js`);
       
+      // Replace user/group with detected user (important for nvm/fnm compatibility)
+      serviceContent = serviceContent.replace(/User=www-data/g, `User=${currentUser}`);
+      serviceContent = serviceContent.replace(/Group=www-data/g, `Group=${currentGroup}`);
+      
       const existingContent = fs.existsSync(systemdDest) ? fs.readFileSync(systemdDest, 'utf-8') : null;
       
       if (existingContent && existingContent.trim() === serviceContent.trim()) {
@@ -404,7 +422,6 @@ async function cmdInit(options) {
         
         // Reload systemd daemon
         try {
-          const { execSync } = require('child_process');
           execSync('systemctl daemon-reload', { stdio: 'pipe' });
           results.push({ path: 'systemctl daemon-reload', status: 'created' });
         } catch (e) {
@@ -687,6 +704,125 @@ async function cmdRemove(name, options) {
   return 0;
 }
 
+async function cmdClean(options) {
+  const configDir = ENV_FILE_DIR;
+  const stateDir = '/var/lib/portok';
+  const systemdDir = '/etc/systemd/system';
+  const serviceFileName = 'portok@.service';
+  const systemdDest = path.join(systemdDir, serviceFileName);
+
+  // Check if running as root
+  const isRoot = process.getuid && process.getuid() === 0;
+
+  if (!isRoot && !options.force) {
+    console.error(`${colors.red}Error:${colors.reset} This command requires root privileges.`);
+    console.error('Run with: sudo portok clean');
+    return 1;
+  }
+
+  // Confirmation (unless --force)
+  if (!options.force && !options.json) {
+    console.log(`${colors.yellow}Warning:${colors.reset} This will remove ALL portok data:\n`);
+    console.log(`  • ${configDir}/ (all service configs)`);
+    console.log(`  • ${stateDir}/ (all state files)`);
+    console.log(`  • ${systemdDest}`);
+    console.log(`\nUse ${colors.cyan}--force${colors.reset} to confirm.\n`);
+    return 1;
+  }
+
+  const { execSync } = require('child_process');
+  const results = [];
+
+  // 1. Stop and disable all running portok services
+  try {
+    const output = execSync('systemctl list-units --type=service --all | grep "portok@" | awk \'{print $1}\'', { encoding: 'utf-8' });
+    const services = output.trim().split('\n').filter(s => s);
+    
+    for (const service of services) {
+      try {
+        execSync(`systemctl stop ${service}`, { stdio: 'pipe' });
+        execSync(`systemctl disable ${service}`, { stdio: 'pipe' });
+        results.push({ action: `stop ${service}`, status: 'success' });
+      } catch (e) {
+        results.push({ action: `stop ${service}`, status: 'skipped' });
+      }
+    }
+  } catch (e) {
+    // No services found, that's ok
+  }
+
+  // 2. Remove systemd service file
+  if (fs.existsSync(systemdDest)) {
+    try {
+      fs.unlinkSync(systemdDest);
+      results.push({ action: 'remove systemd service', status: 'success', path: systemdDest });
+      
+      // Reload systemd
+      try {
+        execSync('systemctl daemon-reload', { stdio: 'pipe' });
+      } catch (e) {}
+    } catch (err) {
+      results.push({ action: 'remove systemd service', status: 'error', error: err.message });
+    }
+  } else {
+    results.push({ action: 'remove systemd service', status: 'skipped' });
+  }
+
+  // 3. Remove config directory
+  if (fs.existsSync(configDir)) {
+    try {
+      fs.rmSync(configDir, { recursive: true, force: true });
+      results.push({ action: 'remove config dir', status: 'success', path: configDir });
+    } catch (err) {
+      results.push({ action: 'remove config dir', status: 'error', error: err.message });
+    }
+  } else {
+    results.push({ action: 'remove config dir', status: 'skipped' });
+  }
+
+  // 4. Remove state directory
+  if (fs.existsSync(stateDir)) {
+    try {
+      fs.rmSync(stateDir, { recursive: true, force: true });
+      results.push({ action: 'remove state dir', status: 'success', path: stateDir });
+    } catch (err) {
+      results.push({ action: 'remove state dir', status: 'error', error: err.message });
+    }
+  } else {
+    results.push({ action: 'remove state dir', status: 'skipped' });
+  }
+
+  const hasError = results.some(r => r.status === 'error');
+
+  if (options.json) {
+    console.log(JSON.stringify({ success: !hasError, results }, null, 2));
+    return hasError ? 1 : 0;
+  }
+
+  // Display results
+  console.log(`\n${colors.bold}Cleaning Portok...${colors.reset}\n`);
+  
+  for (const r of results) {
+    const icon = r.status === 'success' ? `${colors.green}✓${colors.reset}` :
+                 r.status === 'skipped' ? `${colors.dim}○${colors.reset}` :
+                 `${colors.red}✗${colors.reset}`;
+    
+    const statusLabel = r.status === 'success' ? (r.path ? `Removed ${r.path}` : 'Done') :
+                        r.status === 'skipped' ? 'Skipped (not found)' :
+                        `Error: ${r.error}`;
+    
+    console.log(`  ${icon} ${r.action.padEnd(24)} ${statusLabel}`);
+  }
+
+  if (hasError) {
+    console.log(`\n${colors.yellow}Warning:${colors.reset} Some operations failed.`);
+    return 1;
+  }
+
+  console.log(`\n${colors.green}✓ Portok cleaned successfully!${colors.reset}`);
+  return 0;
+}
+
 async function cmdList(options) {
   const configDir = ENV_FILE_DIR;
 
@@ -918,9 +1054,10 @@ ${colors.bold}USAGE${colors.reset}
 
 ${colors.bold}COMMANDS${colors.reset}
   ${colors.cyan}Management:${colors.reset}
-  init            Initialize portok directories (/etc/portok, /var/lib/portok)
+  init            Initialize portok (creates dirs, installs systemd service)
   add <name>      Create a new service instance
   remove <name>   Remove a service instance (config + state)
+  clean           Remove ALL portok data (configs, states, systemd service)
   list            List all configured instances and their status
 
   ${colors.cyan}Service Control:${colors.reset}
@@ -954,6 +1091,9 @@ ${colors.bold}OPTIONS${colors.reset}
   --force           Skip confirmation prompt
   --keep-state      Keep state file (/var/lib/portok/<name>.json)
 
+  ${colors.dim}For 'clean' command:${colors.reset}
+  --force           Skip confirmation prompt (required)
+
   ${colors.dim}For 'logs' command:${colors.reset}
   --follow, -f      Follow log output
   --lines, -n       Number of lines to show (default: 50)
@@ -1013,7 +1153,7 @@ async function main() {
   }
 
   // Management commands (don't require daemon connection)
-  const managementCommands = ['init', 'add', 'remove', 'list', 'start', 'stop', 'restart', 'enable', 'disable', 'logs'];
+  const managementCommands = ['init', 'add', 'remove', 'clean', 'list', 'start', 'stop', 'restart', 'enable', 'disable', 'logs'];
 
   if (managementCommands.includes(args.command)) {
     let exitCode = 1;
@@ -1027,6 +1167,9 @@ async function main() {
       case 'remove':
         exitCode = await cmdRemove(args.positional[0], args.options);
         break;
+      case 'clean':
+        exitCode = await cmdClean(args.options);
+        break;
       case 'list':
         exitCode = await cmdList(args.options);
         break;

package/test/init.test.js

@@ -0,0 +1,269 @@
+/**
+ * Init Command Tests
+ * Tests user detection, node path detection, and service template replacement
+ */
+
+const { describe, it, before, after, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+const { spawn, execSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// Test directory for temporary files
+const TEST_DIR = path.join(os.tmpdir(), `portok-init-test-${Date.now()}`);
+const TEST_CONFIG_DIR = path.join(TEST_DIR, 'etc', 'portok');
+const TEST_STATE_DIR = path.join(TEST_DIR, 'var', 'lib', 'portok');
+const TEST_SYSTEMD_DIR = path.join(TEST_DIR, 'etc', 'systemd', 'system');
+
+describe('Init Command', () => {
+  before(() => {
+    // Create test directories
+    fs.mkdirSync(TEST_SYSTEMD_DIR, { recursive: true });
+  });
+
+  after(() => {
+    // Cleanup test directories
+    try {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('User Detection', () => {
+    it('should detect current user via whoami', () => {
+      const whoami = execSync('whoami', { encoding: 'utf-8' }).trim();
+      assert.ok(whoami.length > 0, 'whoami should return a user');
+      
+      // In Docker Alpine, this is typically 'root'
+      console.log(`    Detected user: ${whoami}`);
+    });
+
+    it('should detect current user group via id -gn', () => {
+      const user = execSync('whoami', { encoding: 'utf-8' }).trim();
+      const group = execSync(`id -gn ${user}`, { encoding: 'utf-8' }).trim();
+      assert.ok(group.length > 0, 'id -gn should return a group');
+      
+      console.log(`    Detected group: ${group}`);
+    });
+
+    it('should have process.getuid() available', () => {
+      assert.ok(typeof process.getuid === 'function', 'process.getuid should be a function');
+      const uid = process.getuid();
+      assert.ok(typeof uid === 'number', 'getuid should return a number');
+      
+      console.log(`    UID: ${uid}`);
+    });
+  });
+
+  describe('Node Path Detection', () => {
+    it('should detect node executable path via process.execPath', () => {
+      const nodePath = process.execPath;
+      assert.ok(nodePath.length > 0, 'process.execPath should not be empty');
+      assert.ok(fs.existsSync(nodePath), 'node executable should exist');
+      
+      console.log(`    Node path: ${nodePath}`);
+    });
+
+    it('should work with nvm-style paths', () => {
+      const nodePath = process.execPath;
+      
+      // Node path should be a valid executable
+      const version = execSync(`"${nodePath}" --version`, { encoding: 'utf-8' }).trim();
+      assert.ok(version.startsWith('v'), 'Should be able to get node version');
+      
+      console.log(`    Node version: ${version}`);
+    });
+
+    it('should not be hardcoded /usr/bin/node when using nvm', () => {
+      const nodePath = process.execPath;
+      
+      // In a proper setup, this could be /usr/bin/node, /usr/local/bin/node, 
+      // or ~/.nvm/versions/node/vX.X.X/bin/node
+      // We just verify it's a valid path
+      assert.ok(
+        nodePath.includes('node'),
+        'Path should contain "node"'
+      );
+    });
+  });
+
+  describe('Service Template Replacement', () => {
+    it('should read portok@.service template', () => {
+      const serviceFile = path.join(__dirname, '..', 'portok@.service');
+      assert.ok(fs.existsSync(serviceFile), 'portok@.service should exist');
+      
+      const content = fs.readFileSync(serviceFile, 'utf-8');
+      assert.ok(content.includes('[Unit]'), 'Should be a valid systemd unit');
+      assert.ok(content.includes('[Service]'), 'Should have Service section');
+      assert.ok(content.includes('[Install]'), 'Should have Install section');
+    });
+
+    it('should have replaceable placeholders in template', () => {
+      const serviceFile = path.join(__dirname, '..', 'portok@.service');
+      const content = fs.readFileSync(serviceFile, 'utf-8');
+      
+      // Check for placeholder patterns that will be replaced
+      assert.ok(content.includes('/usr/bin/node'), 'Should have node path placeholder');
+      assert.ok(content.includes('/opt/portok'), 'Should have portok dir placeholder');
+      assert.ok(content.includes('User=www-data'), 'Should have user placeholder');
+      assert.ok(content.includes('Group=www-data'), 'Should have group placeholder');
+    });
+
+    it('should correctly replace node path', () => {
+      const serviceFile = path.join(__dirname, '..', 'portok@.service');
+      let content = fs.readFileSync(serviceFile, 'utf-8');
+      
+      const nodePath = process.execPath;
+      content = content.replace(/\/usr\/bin\/node/g, nodePath);
+      
+      assert.ok(content.includes(nodePath), 'Node path should be replaced');
+      assert.ok(!content.includes('/usr/bin/node'), 'Old node path should be gone');
+    });
+
+    it('should correctly replace working directory', () => {
+      const serviceFile = path.join(__dirname, '..', 'portok@.service');
+      let content = fs.readFileSync(serviceFile, 'utf-8');
+      
+      const portokDir = path.dirname(serviceFile);
+      content = content.replace(/WorkingDirectory=\/opt\/portok/g, `WorkingDirectory=${portokDir}`);
+      content = content.replace(/\/opt\/portok\/portokd\.js/g, `${portokDir}/portokd.js`);
+      
+      assert.ok(content.includes(portokDir), 'Portok dir should be replaced');
+    });
+
+    it('should correctly replace user and group', () => {
+      const serviceFile = path.join(__dirname, '..', 'portok@.service');
+      let content = fs.readFileSync(serviceFile, 'utf-8');
+      
+      const user = execSync('whoami', { encoding: 'utf-8' }).trim();
+      const group = execSync(`id -gn ${user}`, { encoding: 'utf-8' }).trim();
+      
+      content = content.replace(/User=www-data/g, `User=${user}`);
+      content = content.replace(/Group=www-data/g, `Group=${group}`);
+      
+      assert.ok(content.includes(`User=${user}`), 'User should be replaced');
+      assert.ok(content.includes(`Group=${group}`), 'Group should be replaced');
+      assert.ok(!content.includes('www-data'), 'www-data should be gone');
+    });
+
+    it('should produce valid systemd unit after all replacements', () => {
+      const serviceFile = path.join(__dirname, '..', 'portok@.service');
+      let content = fs.readFileSync(serviceFile, 'utf-8');
+      
+      const nodePath = process.execPath;
+      const portokDir = path.dirname(serviceFile);
+      const user = execSync('whoami', { encoding: 'utf-8' }).trim();
+      const group = execSync(`id -gn ${user}`, { encoding: 'utf-8' }).trim();
+      
+      // Apply all replacements
+      content = content.replace(/\/usr\/bin\/node/g, nodePath);
+      content = content.replace(/WorkingDirectory=\/opt\/portok/g, `WorkingDirectory=${portokDir}`);
+      content = content.replace(/\/opt\/portok\/portokd\.js/g, `${portokDir}/portokd.js`);
+      content = content.replace(/User=www-data/g, `User=${user}`);
+      content = content.replace(/Group=www-data/g, `Group=${group}`);
+      
+      // Verify structure
+      assert.ok(content.includes('[Unit]'), 'Should have Unit section');
+      assert.ok(content.includes('[Service]'), 'Should have Service section');
+      assert.ok(content.includes('[Install]'), 'Should have Install section');
+      assert.ok(content.includes(`ExecStart=${nodePath}`), 'Should have correct ExecStart');
+      assert.ok(content.includes(`User=${user}`), 'Should have correct User');
+      assert.ok(content.includes(`Group=${group}`), 'Should have correct Group');
+      
+      // Write to test file for inspection
+      const testServiceFile = path.join(TEST_SYSTEMD_DIR, 'portok@.service');
+      fs.writeFileSync(testServiceFile, content);
+      
+      console.log(`    Generated service file: ${testServiceFile}`);
+      console.log(`    ExecStart: ${nodePath} ${portokDir}/portokd.js`);
+      console.log(`    User: ${user}, Group: ${group}`);
+    });
+  });
+
+  describe('Root User Handling', () => {
+    it('should detect if running as root', () => {
+      const isRoot = process.getuid && process.getuid() === 0;
+      console.log(`    Running as root: ${isRoot}`);
+      
+      // In Docker, we typically run as root
+      if (process.env.CI || process.env.DOCKER) {
+        assert.strictEqual(isRoot, true, 'Should be root in Docker/CI');
+      }
+    });
+
+    it('should set User=root when running as root', () => {
+      const isRoot = process.getuid && process.getuid() === 0;
+      
+      if (isRoot) {
+        const user = execSync('whoami', { encoding: 'utf-8' }).trim();
+        assert.strictEqual(user, 'root', 'whoami should return root');
+      }
+    });
+
+    it('should handle nvm paths in root home directory', () => {
+      const nodePath = process.execPath;
+      const isRoot = process.getuid && process.getuid() === 0;
+      
+      // NVM typically installs to ~/.nvm which for root is /root/.nvm
+      // But in Docker Alpine, it's usually /usr/local/bin/node
+      console.log(`    Node in root home: ${nodePath.startsWith('/root/')}`);
+      console.log(`    Node path: ${nodePath}`);
+      
+      // The important thing is that the path is accessible
+      assert.ok(fs.existsSync(nodePath), 'Node path should be accessible');
+    });
+  });
+
+  describe('Init Output Format', () => {
+    it('should display user info in init output', async () => {
+      // Run portok.js with a mock to capture output
+      const portokPath = path.join(__dirname, '..', 'portok.js');
+      
+      // Just verify the script exists and is executable
+      assert.ok(fs.existsSync(portokPath), 'portok.js should exist');
+      
+      const stats = fs.statSync(portokPath);
+      assert.ok(stats.mode & 0o111, 'portok.js should be executable');
+    });
+  });
+});
+
+describe('Clean Command', () => {
+  const CLEAN_TEST_DIR = path.join(os.tmpdir(), `portok-clean-test-${Date.now()}`);
+  const CLEAN_CONFIG_DIR = path.join(CLEAN_TEST_DIR, 'etc', 'portok');
+  const CLEAN_STATE_DIR = path.join(CLEAN_TEST_DIR, 'var', 'lib', 'portok');
+
+  before(() => {
+    // Create test directories with some files
+    fs.mkdirSync(CLEAN_CONFIG_DIR, { recursive: true });
+    fs.mkdirSync(CLEAN_STATE_DIR, { recursive: true });
+    fs.writeFileSync(path.join(CLEAN_CONFIG_DIR, 'test.env'), 'TEST=1');
+    fs.writeFileSync(path.join(CLEAN_STATE_DIR, 'test.json'), '{}');
+  });
+
+  after(() => {
+    try {
+      fs.rmSync(CLEAN_TEST_DIR, { recursive: true, force: true });
+    } catch (e) {}
+  });
+
+  it('should require --force flag', () => {
+    // The clean command should require --force
+    // This is just a logical test - actual command testing would need sudo
+    assert.ok(true, 'Clean command requires --force flag');
+  });
+
+  it('should be able to remove directories recursively', () => {
+    // Test fs.rmSync works
+    const testDir = path.join(CLEAN_TEST_DIR, 'rmtest');
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'file.txt'), 'test');
+    
+    fs.rmSync(testDir, { recursive: true, force: true });
+    
+    assert.ok(!fs.existsSync(testDir), 'Directory should be removed');
+  });
+});
+