@goodandready/dsh-remote-workspace 0.3.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/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/index.js

@@ -7,6 +7,10 @@ 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';
 
@@ -33,7 +37,8 @@ export const Config = z.object({
     jumpHostId: z.string().default('')
   })).default([]).description('List of configured remote machines and workspaces.'),
   activeProfileId: z.string().default('').description('ID of active remote profile.'),
-  autoSyncActive: z.boolean().default(false).description('Whether Live Auto-Sync watcher is enabled.')
+  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 = {}) {
@@ -42,7 +47,8 @@ export function apply(ctx, config = {}) {
   let currentConfig = {
     profiles: Array.isArray(cfg.profiles) ? cfg.profiles : [],
     activeProfileId: cfg.activeProfileId || null,
-    autoSyncActive: Boolean(cfg.autoSyncActive)
+    autoSyncActive: Boolean(cfg.autoSyncActive),
+    alertMonitoringActive: Boolean(cfg.alertMonitoringActive)
   };
 
   const vaultService = new VaultService();
@@ -53,6 +59,10 @@ export function apply(ctx, config = {}) {
   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) {
@@ -179,6 +189,7 @@ export function apply(ctx, config = {}) {
       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;
@@ -193,6 +204,10 @@ export function apply(ctx, config = {}) {
   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;
@@ -202,6 +217,10 @@ export function apply(ctx, config = {}) {
   ctx.remoteDocker = dockerService;
   ctx.remoteHealth = healthService;
   ctx.remoteWatcher = watcherService;
+  ctx.remoteTarSync = tarSyncService;
+  ctx.remoteDiagnose = diagnoseService;
+  ctx.remoteEnv = envService;
+  ctx.remoteAlert = alertService;
 
   // Tools registration
   registerRemoteTools(
@@ -212,14 +231,32 @@ export function apply(ctx, config = {}) {
     tunnelService,
     () => store.getActiveProfile(),
     (id) => store.getProfile(id),
-    dockerService
+    dockerService,
+    diagnoseService,
+    envService,
+    tarSyncService
   );
 
   // API Routes
-  registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store, dockerService, healthService, watcherService);
+  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();