@goodandready/dsh-remote-workspace 0.2.0 → 0.3.1

package/lib/diagnose-service.js

@@ -0,0 +1,57 @@
+export class DiagnoseService {
+  /**
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(sshService) {
+    this.sshService = sshService;
+  }
+
+  /**
+   * Diagnose system aspects on remote host
+   * @param {any} profile
+   * @param {'ports'|'disk'|'memory'|'oom_killer'|'service_logs'} category
+   * @param {string} [target] optional port, service name, or path
+   */
+  async diagnose(profile, category, target = '') {
+    if (!profile || !profile.host) throw new Error('Invalid profile');
+
+    let cmd = '';
+    switch (category) {
+      case 'ports': {
+        const filter = target ? `grep ':${target} '` : 'cat';
+        cmd = `(ss -tulpn 2>/dev/null || netstat -tulpn 2>/dev/null || lsof -i -P -n 2>/dev/null) | ${filter} | head -n 40`;
+        break;
+      }
+      case 'disk': {
+        const path = target || '/';
+        cmd = `df -h ${path} 2>/dev/null; echo "---TOP 10 DIRS---"; du -ahx ${path} 2>/dev/null | sort -rh | head -n 10`;
+        break;
+      }
+      case 'memory': {
+        cmd = `free -h 2>/dev/null || free -m; echo "---TOP 10 PROCESSES BY RAM---"; ps aux --sort=-%mem 2>/dev/null | head -n 11`;
+        break;
+      }
+      case 'oom_killer': {
+        cmd = `(dmesg -T 2>/dev/null || dmesg 2>/dev/null) | grep -i -E 'oom|out of memory|killed process' | tail -n 25 || echo "No OOM events detected"`;
+        break;
+      }
+      case 'service_logs': {
+        if (!target) throw new Error('Target service name required for service_logs');
+        const safeName = target.replace(/[^a-zA-Z0-9_.-]/g, '');
+        cmd = `(journalctl -u ${safeName} -n 40 --no-pager 2>/dev/null || pm2 logs ${safeName} --lines 40 --nostream 2>/dev/null || tail -n 40 /var/log/${safeName}.log 2>/dev/null || echo "No logs found for ${safeName}")`;
+        break;
+      }
+      default:
+        throw new Error(`Unsupported diagnosis category: ${category}`);
+    }
+
+    const res = await this.sshService.exec(profile, cmd);
+    const code = res.code !== undefined ? res.code : (res.exitCode !== undefined ? res.exitCode : 0);
+    return {
+      ok: code === 0,
+      category,
+      target: target || null,
+      output: (res.stdout || res.stderr || '').trim()
+    };
+  }
+}

package/lib/docker-service.js

@@ -0,0 +1,93 @@
+export class DockerService {
+  /**
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(sshService) {
+    this.sshService = sshService;
+  }
+
+  /**
+   * List active or all containers with JSON formatting
+   */
+  async listContainers(profile, all = true) {
+    // Detect docker or podman
+    const flag = all ? '-a' : '';
+    // Format as line-delimited JSON or tabbed format
+    const cmd = `docker ps ${flag} --format '{{json .}}' 2>/dev/null || podman ps ${flag} --format '{{json .}}' 2>/dev/null`;
+    const res = await this.sshService.exec(profile, cmd);
+
+    if (res.code !== 0 && !res.stdout.trim()) {
+      return {
+        available: false,
+        error: res.stderr || 'Docker not found or daemon not running',
+        containers: []
+      };
+    }
+
+    const containers = [];
+    const lines = res.stdout.split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const item = JSON.parse(line);
+        containers.push({
+          id: item.ID || item.Id || '',
+          names: item.Names || item.Name || '',
+          image: item.Image || '',
+          status: item.Status || '',
+          state: (item.State || '').toLowerCase(),
+          ports: item.Ports || '',
+          created: item.CreatedAt || item.Created || ''
+        });
+      } catch (_) {}
+    }
+
+    return {
+      available: true,
+      containers
+    };
+  }
+
+  /**
+   * Container action: start, stop, restart, pause, unpause
+   */
+  async containerAction(profile, containerId, action) {
+    const validActions = ['start', 'stop', 'restart', 'pause', 'unpause', 'rm'];
+    if (!validActions.includes(action)) {
+      throw new Error(`Invalid container action: ${action}`);
+    }
+    const cmd = `docker ${action} ${JSON.stringify(containerId)} 2>/dev/null || podman ${action} ${JSON.stringify(containerId)}`;
+    const res = await this.sshService.exec(profile, cmd);
+    return {
+      success: res.code === 0,
+      stdout: res.stdout.trim(),
+      stderr: res.stderr.trim()
+    };
+  }
+
+  /**
+   * Fetch container logs
+   */
+  async containerLogs(profile, containerId, tail = 100) {
+    const cmd = `docker logs --tail ${tail} ${JSON.stringify(containerId)} 2>&1 || podman logs --tail ${tail} ${JSON.stringify(containerId)} 2>&1`;
+    const res = await this.sshService.exec(profile, cmd);
+    return {
+      success: res.code === 0,
+      logs: res.stdout || res.stderr || ''
+    };
+  }
+
+  /**
+   * Docker compose lifecycle
+   */
+  async composeAction(profile, cwd, action = 'ps') {
+    const valid = ['up -d', 'down', 'ps', 'restart', 'pull'];
+    const safeAction = valid.includes(action) ? action : 'ps';
+    const cmd = `docker compose ${safeAction} 2>/dev/null || docker-compose ${safeAction} 2>/dev/null || podman-compose ${safeAction}`;
+    const res = await this.sshService.exec(profile, cmd, cwd);
+    return {
+      success: res.code === 0,
+      stdout: res.stdout,
+      stderr: res.stderr
+    };
+  }
+}

package/lib/env-service.js

@@ -0,0 +1,122 @@
+export class EnvService {
+  /**
+   * @param {import('./remote-fs-service.js').RemoteFsService} remoteFsService
+   */
+  constructor(remoteFsService) {
+    this.remoteFsService = remoteFsService;
+  }
+
+  /**
+   * Parse .env text into structured entries (preserving comments and order)
+   * @param {string} text
+   */
+  parseEnv(text) {
+    if (!text) return [];
+    const lines = text.split('\n');
+    const result = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (!trimmed) {
+        result.push({ type: 'empty', raw: line });
+        continue;
+      }
+      if (trimmed.startsWith('#')) {
+        result.push({ type: 'comment', raw: line });
+        continue;
+      }
+
+      const eqIdx = line.indexOf('=');
+      if (eqIdx === -1) {
+        result.push({ type: 'raw', raw: line });
+        continue;
+      }
+
+      const key = line.slice(0, eqIdx).trim();
+      let val = line.slice(eqIdx + 1);
+      // Check if value is wrapped in quotes
+      let isQuoted = false;
+      const valTrimmed = val.trim();
+      if ((valTrimmed.startsWith('"') && valTrimmed.endsWith('"')) ||
+          (valTrimmed.startsWith("'") && valTrimmed.endsWith("'"))) {
+        isQuoted = true;
+        val = valTrimmed.slice(1, -1);
+      }
+
+      result.push({
+        type: 'var',
+        key,
+        value: val,
+        isQuoted,
+        raw: line
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Read and parse remote .env file
+   */
+  async readEnv(profile, filePath) {
+    const content = await this.remoteFsService.readFile(profile, filePath);
+    const parsed = this.parseEnv(content);
+    return {
+      filePath,
+      entries: parsed,
+      raw: content
+    };
+  }
+
+  /**
+   * Set or update variable in remote .env file atomically
+   */
+  async setEnvVar(profile, filePath, key, value) {
+    if (!key || typeof key !== 'string') throw new Error('Key must be non-empty string');
+
+    let currentContent = '';
+    try {
+      currentContent = await this.remoteFsService.readFile(profile, filePath);
+    } catch {
+      currentContent = '';
+    }
+
+    const lines = currentContent ? currentContent.split('\n') : [];
+    let updated = false;
+    const newLines = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('#') && trimmed.includes('=')) {
+        const k = trimmed.slice(0, trimmed.indexOf('=')).trim();
+        if (k === key) {
+          // Quote if contains spaces or special symbols
+          const formattedVal = (value.includes(' ') || value.includes('\n')) ? `"${value}"` : value;
+          newLines.push(`${key}=${formattedVal}`);
+          updated = true;
+          continue;
+        }
+      }
+      newLines.push(line);
+    }
+
+    if (!updated) {
+      const formattedVal = (value.includes(' ') || value.includes('\n')) ? `"${value}"` : value;
+      if (newLines.length > 0 && newLines[newLines.length - 1].trim() !== '') {
+        newLines.push('');
+      }
+      newLines.push(`${key}=${formattedVal}`);
+    }
+
+    const finalContent = newLines.join('\n');
+    await this.remoteFsService.writeFile(profile, filePath, finalContent);
+
+    return {
+      ok: true,
+      filePath,
+      key,
+      updated
+    };
+  }
+}

package/lib/health-service.js

@@ -0,0 +1,117 @@
+export class HealthService {
+  /**
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(sshService) {
+    this.sshService = sshService;
+    /** @type {Map<string, { data: any, expiresAt: number }>} */
+    this.cache = new Map();
+    this.cacheTtlMs = 4000;
+  }
+
+  async getHealth(profile, bypassCache = false) {
+    if (!profile || !profile.host) {
+      throw new Error('Invalid profile');
+    }
+
+    const cacheKey = profile.id;
+    if (!bypassCache) {
+      const cached = this.cache.get(cacheKey);
+      if (cached && cached.expiresAt > Date.now()) {
+        return cached.data;
+      }
+    }
+
+    // Single compact shell command to gather all stats at once:
+    // 1. uptime (load averages)
+    // 2. memory (free -m)
+    // 3. disk usage (df -k /)
+    // 4. cpu info (cores & idle via /proc/stat or top)
+    const probeCmd = `
+echo "---UPTIME---"
+uptime 2>/dev/null || true
+echo "---MEM---"
+free -m 2>/dev/null || true
+echo "---DISK---"
+df -m / 2>/dev/null || df -m . 2>/dev/null || true
+echo "---CPU---"
+grep 'cpu ' /proc/stat 2>/dev/null || true
+`;
+
+    const res = await this.sshService.exec(profile, probeCmd);
+    const text = res.stdout || '';
+
+    const uptimeMatch = text.match(/---UPTIME---\n([\s\S]*?)(?=---MEM---)/);
+    const memMatch = text.match(/---MEM---\n([\s\S]*?)(?=---DISK---)/);
+    const diskMatch = text.match(/---DISK---\n([\s\S]*?)(?=---CPU---)/);
+
+    // 1. Parse Uptime & Load Avg
+    let uptimeStr = 'Unknown';
+    let loadAvg = [0, 0, 0];
+    if (uptimeMatch) {
+      const upLine = uptimeMatch[1].trim();
+      const loadMatch = upLine.match(/load average[s]?:\s*([\d.]+),?\s*([\d.]+),?\s*([\d.]+)/);
+      if (loadMatch) {
+        loadAvg = [parseFloat(loadMatch[1]), parseFloat(loadMatch[2]), parseFloat(loadMatch[3])];
+      }
+      const upPart = upLine.match(/up\s+(.*?),\s+\d+\s+user/);
+      if (upPart) uptimeStr = upPart[1];
+      else uptimeStr = upLine.split(',')[0] || 'Online';
+    }
+
+    // 2. Parse Memory
+    let memTotal = 0;
+    let memUsed = 0;
+    let memPercent = 0;
+    if (memMatch) {
+      const memLines = memMatch[1].trim().split('\n');
+      for (const line of memLines) {
+        if (line.startsWith('Mem:')) {
+          const parts = line.split(/\s+/);
+          memTotal = parseInt(parts[1], 10) || 0;
+          memUsed = parseInt(parts[2], 10) || 0;
+          if (memTotal > 0) {
+            memPercent = Math.round((memUsed / memTotal) * 100);
+          }
+          break;
+        }
+      }
+    }
+
+    // 3. Parse Disk
+    let diskTotal = 0;
+    let diskUsed = 0;
+    let diskPercent = 0;
+    if (diskMatch) {
+      const diskLines = diskMatch[1].trim().split('\n');
+      if (diskLines.length > 1) {
+        const parts = diskLines[1].split(/\s+/);
+        diskTotal = parseInt(parts[1], 10) || 0;
+        diskUsed = parseInt(parts[2], 10) || 0;
+        const pStr = parts[4] || '';
+        diskPercent = parseInt(pStr.replace('%', ''), 10) || (diskTotal > 0 ? Math.round((diskUsed / diskTotal) * 100) : 0);
+      }
+    }
+
+    const result = {
+      ok: true,
+      timestamp: Date.now(),
+      uptime: uptimeStr,
+      loadAverage: loadAvg,
+      cpuLoad: Math.min(100, Math.round(loadAvg[0] * 25)), // Normalized approx representation
+      memory: {
+        totalMb: memTotal,
+        usedMb: memUsed,
+        percent: memPercent
+      },
+      disk: {
+        totalMb: diskTotal,
+        usedMb: diskUsed,
+        percent: diskPercent
+      }
+    };
+
+    this.cache.set(cacheKey, { data: result, expiresAt: Date.now() + this.cacheTtlMs });
+    return result;
+  }
+}

package/lib/index.js

@@ -4,6 +4,13 @@ import { SshService } from './ssh-service.js';
 import { RemoteFsService } from './remote-fs-service.js';
 import { MirrorSyncService } from './mirror-sync-service.js';
 import { TunnelService } from './tunnel-service.js';
+import { DockerService } from './docker-service.js';
+import { HealthService } from './health-service.js';
+import { WatcherService } from './watcher-service.js';
+import { TarSyncService } from './tar-sync-service.js';
+import { DiagnoseService } from './diagnose-service.js';
+import { EnvService } from './env-service.js';
+import { AlertService } from './alert-service.js';
 import { registerRemoteTools } from './tools.js';
 import { registerApiRoutes } from './routes.js';
 
@@ -26,9 +33,12 @@ export const Config = z.object({
     passphrase: z.string().default(''),
     password: z.string().default(''),
     remoteWorkspace: z.string().default(''),
-    localMirrorPath: z.string().default('')
+    localMirrorPath: z.string().default(''),
+    jumpHostId: z.string().default('')
   })).default([]).description('List of configured remote machines and workspaces.'),
-  activeProfileId: z.string().default('').description('ID of active remote profile.')
+  activeProfileId: z.string().default('').description('ID of active remote profile.'),
+  autoSyncActive: z.boolean().default(false).description('Whether Live Auto-Sync watcher is enabled.'),
+  alertMonitoringActive: z.boolean().default(false).description('Whether background anomaly alerts are monitored.')
 });
 
 export function apply(ctx, config = {}) {
@@ -36,7 +46,9 @@ export function apply(ctx, config = {}) {
   let settingsApi = null;
   let currentConfig = {
     profiles: Array.isArray(cfg.profiles) ? cfg.profiles : [],
-    activeProfileId: cfg.activeProfileId || null
+    activeProfileId: cfg.activeProfileId || null,
+    autoSyncActive: Boolean(cfg.autoSyncActive),
+    alertMonitoringActive: Boolean(cfg.alertMonitoringActive)
   };
 
   const vaultService = new VaultService();
@@ -44,6 +56,13 @@ export function apply(ctx, config = {}) {
   const remoteFs = new RemoteFsService(sshService);
   const mirrorSync = new MirrorSyncService(remoteFs, sshService);
   const tunnelService = new TunnelService(sshService);
+  const dockerService = new DockerService(sshService);
+  const healthService = new HealthService(sshService);
+  const watcherService = new WatcherService();
+  const tarSyncService = new TarSyncService(sshService);
+  const diagnoseService = new DiagnoseService(sshService);
+  const envService = new EnvService(remoteFs);
+  const alertService = new AlertService(ctx, healthService, dockerService);
 
   // Migrate any existing plain passwords into vault upon start
   for (const p of currentConfig.profiles) {
@@ -78,11 +97,22 @@ export function apply(ctx, config = {}) {
       const p = (currentConfig.profiles || []).find((x) => x.id === currentConfig.activeProfileId);
       return p ? vaultService.hydrateProfile(p) : undefined;
     },
+    isAutoSyncEnabled() { return Boolean(currentConfig.autoSyncActive); },
+    async setAutoSyncEnabled(enabled) {
+      currentConfig.autoSyncActive = Boolean(enabled);
+      const active = store.getActiveProfile();
+      if (active) {
+        if (enabled) watcherService.start(active, mirrorSync);
+        else watcherService.stop(active.id);
+      }
+      if (settingsApi?.replace) {
+        try { await settingsApi.replace(Config(currentConfig)); } catch (_) {}
+      }
+    },
     async saveProfile(rawP) {
       const list = [...(currentConfig.profiles || [])];
       const p = { ...rawP };
 
-      // Save secret credentials into isolated .env file if provided
       const secretsToUpdate = {};
       if (p.password !== undefined && p.password !== '••••••••') {
         secretsToUpdate.password = p.password;
@@ -97,7 +127,6 @@ export function apply(ctx, config = {}) {
         vaultService.setProfileSecrets(p.id, secretsToUpdate);
       }
 
-      // Do NOT keep raw secrets in public config
       p.password = '';
       p.privateKey = '';
       p.passphrase = '';
@@ -116,6 +145,7 @@ export function apply(ctx, config = {}) {
       }
     },
     async deleteProfile(id) {
+      watcherService.stop(id);
       currentConfig.profiles = (currentConfig.profiles || []).filter((p) => p.id !== id);
       if (currentConfig.activeProfileId === id) {
         currentConfig.activeProfileId = currentConfig.profiles[0]?.id || null;
@@ -128,12 +158,25 @@ export function apply(ctx, config = {}) {
     },
     async setActiveId(id) {
       currentConfig.activeProfileId = id;
+      if (currentConfig.autoSyncActive) {
+        watcherService.stopAll();
+        const active = store.getActiveProfile();
+        if (active) watcherService.start(active, mirrorSync);
+      }
       if (settingsApi?.replace) {
         try { await settingsApi.replace(Config(currentConfig)); } catch (_) {}
       }
     }
   };
 
+  sshService.setJumpProfileResolver((jumpId) => store.getProfile(jumpId));
+
+  // If autoSync was enabled on restart, resume watcher for active profile
+  if (currentConfig.autoSyncActive && currentConfig.activeProfileId) {
+    const active = store.getActiveProfile();
+    if (active) watcherService.start(active, mirrorSync);
+  }
+
   // Register settings namespace if settings service is available
   ctx.inject(['settings'], (sctx) => {
     const settingsService = sctx.get ? (sctx.get('settings') ?? sctx.settings) : sctx.settings;
@@ -145,6 +188,8 @@ export function apply(ctx, config = {}) {
     if (snap) {
       if (Array.isArray(snap.profiles)) currentConfig.profiles = snap.profiles;
       if (snap.activeProfileId !== undefined) currentConfig.activeProfileId = snap.activeProfileId;
+      if (snap.autoSyncActive !== undefined) currentConfig.autoSyncActive = snap.autoSyncActive;
+      if (snap.alertMonitoringActive !== undefined) currentConfig.alertMonitoringActive = snap.alertMonitoringActive;
     }
     sctx.effect(() => () => {
       settingsApi = null;
@@ -156,21 +201,63 @@ export function apply(ctx, config = {}) {
   ctx.provide('remoteSync');
   ctx.provide('remoteTunnel');
   ctx.provide('remoteVault');
+  ctx.provide('remoteDocker');
+  ctx.provide('remoteHealth');
+  ctx.provide('remoteWatcher');
+  ctx.provide('remoteTarSync');
+  ctx.provide('remoteDiagnose');
+  ctx.provide('remoteEnv');
+  ctx.provide('remoteAlert');
 
   ctx.remoteSsh = sshService;
   ctx.remoteFs = remoteFs;
   ctx.remoteSync = mirrorSync;
   ctx.remoteTunnel = tunnelService;
   ctx.remoteVault = vaultService;
+  ctx.remoteDocker = dockerService;
+  ctx.remoteHealth = healthService;
+  ctx.remoteWatcher = watcherService;
+  ctx.remoteTarSync = tarSyncService;
+  ctx.remoteDiagnose = diagnoseService;
+  ctx.remoteEnv = envService;
+  ctx.remoteAlert = alertService;
 
   // Tools registration
-  registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, () => store.getActiveProfile());
+  registerRemoteTools(
+    ctx,
+    sshService,
+    remoteFs,
+    mirrorSync,
+    tunnelService,
+    () => store.getActiveProfile(),
+    (id) => store.getProfile(id),
+    dockerService,
+    diagnoseService,
+    envService,
+    tarSyncService
+  );
 
   // API Routes
-  registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store);
+  registerApiRoutes(
+    ctx,
+    sshService,
+    remoteFs,
+    mirrorSync,
+    tunnelService,
+    store,
+    dockerService,
+    healthService,
+    watcherService,
+    diagnoseService,
+    envService,
+    tarSyncService,
+    alertService
+  );
 
   // Cleanup on unload
   ctx.on('dispose', () => {
+    alertService.stop();
+    watcherService.stopAll();
     tunnelService.stopAll();
     sshService.disconnectAll();
   });