@goodandready/dsh-remote-workspace 0.2.0 → 0.3.0

package/lib/client.js

@@ -90,6 +90,15 @@ window.__ModuleLoader__.load({
 .drw-modal-dialog{background:var(--dsw-alias-bg-layer-3);border:1px solid var(--dsw-alias-border-l2);border-radius:12px;width:100%;max-width:800px;max-height:85vh;display:flex;flex-direction:column;overflow:hidden;box-shadow:0 12px 32px rgba(0,0,0,0.4)}
 .drw-modal-hdr{padding:12px 16px;border-bottom:1px solid var(--dsw-alias-border-l2);display:flex;align-items:center;justify-content:space-between;font-weight:600}
 .drw-modal-body{flex:1;padding:12px 16px;overflow-y:auto}
+
+.drw-health-bar{display:grid;grid-template-columns:repeat(auto-fit, minmax(130px, 1fr));gap:8px;padding:8px 12px;background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l2);border-radius:8px;font-size:11.5px;font-family:monospace}
+.drw-health-item{display:flex;flex-direction:column;gap:2px}
+.drw-progress{height:6px;background:var(--dsw-alias-bg-layer-1);border-radius:3px;overflow:hidden}
+.drw-progress-fill{height:100%;border-radius:3px;transition:width .2s ease}
+
+.drw-container-row{display:grid;grid-template-columns:2fr 2fr 1.5fr 1.5fr auto;align-items:center;gap:10px;padding:8px 10px;border-bottom:1px solid var(--dsw-alias-border-l2);font-size:12.5px;font-family:monospace}
+.drw-container-row:hover{background:var(--dsw-alias-bg-layer-3)}
+
       `
       document.head.appendChild(style)
     }
@@ -100,6 +109,32 @@ window.__ModuleLoader__.load({
       status: 'Ready',
 
       tabProfiles: '🖥️ Host Profiles',
+
+      tabContainers: '🐳 Containers',
+      containersTitle: 'Remote Docker / Podman Engine',
+      containerName: 'Container',
+      containerImage: 'Image',
+      containerStatus: 'Status',
+      containerPorts: 'Ports',
+      btnLogs: 'Logs',
+      btnRestart: 'Restart',
+      btnStop: 'Stop',
+      noContainers: 'No active containers found or Docker daemon not running.',
+      healthCpu: 'CPU: {val}%',
+      healthMem: 'RAM: {val}% ({used}/{total} MB)',
+      healthDisk: 'Disk: {val}%',
+      healthUptime: 'Up: {val}',
+      autoSyncTitle: 'Live Auto-Sync on Save',
+      autoSyncDesc: 'Automatically push modified files to remote workspace on local save.',
+      btnTransfer: 'Copy to Host...',
+      transferTitle: 'Server-to-Server Direct Transfer',
+      transferDestHost: 'Destination Server',
+      transferDestPath: 'Destination File Path',
+      transferBtnExec: 'Transfer Directly',
+      transferSuccess: 'Successfully transferred {bytes} bytes to {host}:{path}',
+      fJumpHost: 'Jump Host (Bastion)',
+      fJumpHostNone: 'Direct Connection (No Jump Host)',
+
       tabTerminal: '⚡ Web Terminal',
       tabExplorer: '📂 File Explorer',
       tabTunnels: '🔗 Port Tunnels',
@@ -294,6 +329,157 @@ window.__ModuleLoader__.load({
     }
 
 
+
+    // --- Sub-component: Docker Containers Tab ---
+    function ContainersTab(props) {
+      const { activeProfile, t } = props
+      const [containers, setContainers] = React.useState([])
+      const [loading, setLoading] = React.useState(false)
+      const [logsModal, setLogsModal] = React.useState(null)
+      const [logsContent, setLogsContent] = React.useState('')
+      const [logsLoading, setLogsLoading] = React.useState(false)
+
+      const loadContainers = async () => {
+        if (!activeProfile) return
+        setLoading(true)
+        try {
+          const res = await fetch(`/dsh-remote-workspace/docker/list?profileId=${activeProfile.id}`)
+          const data = await res.json()
+          if (data.ok && Array.isArray(data.containers)) {
+            setContainers(data.containers)
+          } else {
+            setContainers([])
+          }
+        } catch (_) {}
+        setLoading(false)
+      }
+
+      React.useEffect(() => {
+        loadContainers()
+      }, [activeProfile?.id])
+
+      const handleAction = async (containerId, action) => {
+        try {
+          await fetch('/dsh-remote-workspace/docker/action', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ profileId: activeProfile.id, containerId, action })
+          })
+          await loadContainers()
+        } catch (_) {}
+      }
+
+      const showLogs = async (containerId, name) => {
+        setLogsModal({ id: containerId, name })
+        setLogsLoading(true)
+        try {
+          const res = await fetch('/dsh-remote-workspace/docker/logs', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ profileId: activeProfile.id, containerId, tail: 150 })
+          })
+          const data = await res.json()
+          setLogsContent(data.logs || '[No logs output]')
+        } catch (err) {
+          setLogsContent(`[Error: ${err.message}]`)
+        }
+        setLogsLoading(false)
+      }
+
+      return React.createElement(
+        'div',
+        { style: { display: 'flex', flexDirection: 'column', gap: '12px' } },
+        React.createElement(
+          'div',
+          { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center' } },
+          React.createElement('div', { style: { fontWeight: 600, fontSize: '14px' } }, t('containersTitle')),
+          React.createElement(
+            'button',
+            {
+              type: 'button',
+              className: 'drw-btn',
+              onClick: loadContainers,
+              disabled: loading
+            },
+            loading ? 'Refreshing...' : '🔄 Refresh'
+          )
+        ),
+        React.createElement(
+          'div',
+          { style: { border: '1px solid var(--dsw-alias-border-l2)', borderRadius: '8px', overflow: 'hidden', background: 'var(--dsw-alias-bg-layer-2)' } },
+          React.createElement(
+            'div',
+            { className: 'drw-container-row', style: { fontWeight: 600, color: 'var(--dsw-alias-label-secondary)', background: 'var(--dsw-alias-bg-layer-1)' } },
+            React.createElement('span', null, t('containerName')),
+            React.createElement('span', null, t('containerImage')),
+            React.createElement('span', null, t('containerStatus')),
+            React.createElement('span', null, t('containerPorts')),
+            React.createElement('span', { style: { textAlign: 'right' } }, t('actionsCol'))
+          ),
+          containers.length === 0
+            ? React.createElement('div', { style: { padding: '24px', textAlign: 'center', color: 'var(--dsw-alias-label-secondary)' } }, t('noContainers'))
+            : containers.map((c) =>
+                React.createElement(
+                  'div',
+                  { key: c.id, className: 'drw-container-row' },
+                  React.createElement(
+                    'div',
+                    { style: { display: 'flex', alignItems: 'center', gap: '6px' } },
+                    React.createElement('span', { className: `drw-badge ${c.state === 'running' ? 'drw-badge-ok' : 'drw-badge-warn'}` }, c.state),
+                    React.createElement('span', { style: { fontWeight: 600 } }, c.names)
+                  ),
+                  React.createElement('span', { style: { opacity: 0.8, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, c.image),
+                  React.createElement('span', { style: { fontSize: '11px', opacity: 0.7 } }, c.status),
+                  React.createElement('span', { style: { fontSize: '11px', opacity: 0.7, overflow: 'hidden', textOverflow: 'ellipsis' } }, c.ports || '—'),
+                  React.createElement(
+                    'div',
+                    { style: { display: 'flex', gap: '4px', justifyContent: 'flex-end' } },
+                    React.createElement(
+                      'button',
+                      { type: 'button', className: 'drw-btn', style: { padding: '2px 6px', fontSize: '11px' }, onClick: () => showLogs(c.id, c.names) },
+                      t('btnLogs')
+                    ),
+                    React.createElement(
+                      'button',
+                      { type: 'button', className: 'drw-btn', style: { padding: '2px 6px', fontSize: '11px' }, onClick: () => handleAction(c.id, 'restart') },
+                      t('btnRestart')
+                    ),
+                    c.state === 'running'
+                      ? React.createElement(
+                          'button',
+                          { type: 'button', className: 'drw-btn drw-btn-danger', style: { padding: '2px 6px', fontSize: '11px' }, onClick: () => handleAction(c.id, 'stop') },
+                          t('btnStop')
+                        )
+                      : null
+                  )
+                )
+              )
+        ),
+        // Container Logs Modal
+        logsModal
+          ? React.createElement(
+              'div',
+              { className: 'drw-modal-overlay', onClick: () => setLogsModal(null) },
+              React.createElement(
+                'div',
+                { className: 'drw-modal-dialog', onClick: (e) => e.stopPropagation() },
+                React.createElement(
+                  'div',
+                  { className: 'drw-modal-hdr' },
+                  React.createElement('span', { style: { fontFamily: 'monospace' } }, `Docker Logs: ${logsModal.name} (${logsModal.id})`),
+                  React.createElement('button', { type: 'button', className: 'drw-btn', onClick: () => setLogsModal(null) }, '✕')
+                ),
+                React.createElement(
+                  'div',
+                  { className: 'drw-modal-body' },
+                  React.createElement('pre', { style: { background: '#0d1117', color: '#c9d1d9', padding: '12px', borderRadius: '8px', fontSize: '12px', maxHeight: '420px', overflowY: 'auto', whiteSpace: 'pre-wrap' } }, logsLoading ? 'Fetching logs...' : logsContent)
+                )
+              )
+            )
+          : null
+      )
+    }
+
     // --- Sub-component: Web Terminal Tab ---
     function TerminalTab(props) {
       const { activeProfile, t } = props
@@ -737,6 +923,8 @@ window.__ModuleLoader__.load({
 
     function SettingsView(props) {
       const [activeTab, setActiveTab] = React.useState('profiles')
+      const [healthData, setHealthData] = React.useState(null)
+      const [autoSync, setAutoSync] = React.useState(false)
 
       const t = props.locale === 'ru' ? makeT(ru, en) : makeT(en, ru)
       const [profiles, setProfiles] = React.useState([])
@@ -768,6 +956,10 @@ window.__ModuleLoader__.load({
               setProfiles(data.profiles || [])
               setActiveId(data.activeId || null)
               setTunnels(data.tunnels || [])
+              setAutoSync(Boolean(data.autoSync))
+              if (data.activeId) {
+                fetch(`/dsh-remote-workspace/health?profileId=${data.activeId}`).then(r => r.json()).then(h => { if (h.ok) setHealthData(h.health) }).catch(() => {})
+              }
             }
           }
         } catch (_) {}
@@ -1482,6 +1674,39 @@ window.__ModuleLoader__.load({
               { className: 'drw-card' },
               React.createElement('div', { className: 'drw-card-title' }, t('syncTitle')),
               React.createElement('div', { className: 'drw-card-desc' }, t('syncDesc')),
+
+              React.createElement(
+                'div',
+                { style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '10px 14px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: '8px', border: '1px solid var(--dsw-alias-border-l2)', marginBottom: '12px' } },
+                React.createElement(
+                  'div',
+                  { style: { display: 'flex', flexDirection: 'column', gap: '2px' } },
+                  React.createElement('span', { style: { fontWeight: 600, fontSize: '13px' } }, t('autoSyncTitle')),
+                  React.createElement('span', { style: { fontSize: '11px', color: 'var(--dsw-alias-label-secondary)' } }, t('autoSyncDesc'))
+                ),
+                React.createElement(
+                  'button',
+                  {
+                    type: 'button',
+                    className: `drw-btn ${autoSync ? 'drw-btn-primary' : ''}`,
+                    style: { padding: '4px 12px', fontSize: '12px' },
+                    onClick: async () => {
+                      const next = !autoSync
+                      try {
+                        const res = await fetch('/dsh-remote-workspace/watcher/toggle', {
+                          method: 'POST',
+                          headers: { 'Content-Type': 'application/json' },
+                          body: JSON.stringify({ enabled: next })
+                        })
+                        const d = await res.json()
+                        if (d.ok) setAutoSync(d.autoSync)
+                      } catch (_) {}
+                    }
+                  },
+                  autoSync ? '⚡ Active (ON)' : '⚪ Off'
+                )
+              ),
+
               React.createElement(
                 'div',
                 { className: 'drw-row' },

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/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,9 @@ 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 { registerRemoteTools } from './tools.js';
 import { registerApiRoutes } from './routes.js';
 
@@ -26,9 +29,11 @@ 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.')
 });
 
 export function apply(ctx, config = {}) {
@@ -36,7 +41,8 @@ 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)
   };
 
   const vaultService = new VaultService();
@@ -44,6 +50,9 @@ 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();
 
   // Migrate any existing plain passwords into vault upon start
   for (const p of currentConfig.profiles) {
@@ -78,11 +87,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 +117,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 +135,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 +148,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 +178,7 @@ 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;
     }
     sctx.effect(() => () => {
       settingsApi = null;
@@ -156,21 +190,37 @@ export function apply(ctx, config = {}) {
   ctx.provide('remoteSync');
   ctx.provide('remoteTunnel');
   ctx.provide('remoteVault');
+  ctx.provide('remoteDocker');
+  ctx.provide('remoteHealth');
+  ctx.provide('remoteWatcher');
 
   ctx.remoteSsh = sshService;
   ctx.remoteFs = remoteFs;
   ctx.remoteSync = mirrorSync;
   ctx.remoteTunnel = tunnelService;
   ctx.remoteVault = vaultService;
+  ctx.remoteDocker = dockerService;
+  ctx.remoteHealth = healthService;
+  ctx.remoteWatcher = watcherService;
 
   // Tools registration
-  registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, () => store.getActiveProfile());
+  registerRemoteTools(
+    ctx,
+    sshService,
+    remoteFs,
+    mirrorSync,
+    tunnelService,
+    () => store.getActiveProfile(),
+    (id) => store.getProfile(id),
+    dockerService
+  );
 
   // API Routes
-  registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store);
+  registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store, dockerService, healthService, watcherService);
 
   // Cleanup on unload
   ctx.on('dispose', () => {
+    watcherService.stopAll();
     tunnelService.stopAll();
     sshService.disconnectAll();
   });

package/lib/routes.js

@@ -1,4 +1,4 @@
-export function registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store) {
+export function registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store, dockerService, healthService, watcherService) {
   function writeJson(res, statusCode, body) {
     if (typeof res.setHeader === 'function') {
       res.setHeader('Content-Type', 'application/json; charset=utf-8');
@@ -54,11 +54,13 @@ export function registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelS
           const profiles = store.getProfiles();
           const activeId = store.getActiveId() || (profiles[0]?.id || '');
           const tunnels = tunnelService.listActiveTunnels();
+          const autoSync = store.isAutoSyncEnabled ? store.isAutoSyncEnabled() : false;
           writeJson(res, 200, {
             ok: true,
             profiles,
             activeId,
             tunnels,
+            autoSync,
             vaultProtected: true
           });
         } catch (err) {
@@ -282,7 +284,6 @@ export function registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelS
           });
         }
 
-        // Send historical buffer
         for (const chunk of session.buffer) {
           res.write(`data: ${JSON.stringify({ chunk })}\n\n`);
         }
@@ -394,5 +395,128 @@ export function registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelS
         }
       }
     }), 'dsh-remote-workspace: /tunnels/telemetry');
+
+    // 17. GET /dsh-remote-workspace/health
+    sctx.effect(() => webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/health',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' });
+        try {
+          const url = new URL(req.url, 'http://localhost');
+          const profileId = url.searchParams.get('profileId');
+          const profile = profileId ? store.getProfile(profileId) : store.getActiveProfile();
+          if (!profile) return writeJson(res, 404, { ok: false, error: 'No active profile' });
+
+          const health = await healthService.getHealth(profile);
+          writeJson(res, 200, { ok: true, health });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /health');
+
+    // 18. GET /dsh-remote-workspace/docker/list
+    sctx.effect(() => webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/docker/list',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' });
+        try {
+          const url = new URL(req.url, 'http://localhost');
+          const profileId = url.searchParams.get('profileId');
+          const profile = profileId ? store.getProfile(profileId) : store.getActiveProfile();
+          if (!profile) return writeJson(res, 404, { ok: false, error: 'No active profile' });
+
+          const result = await dockerService.listContainers(profile, true);
+          writeJson(res, 200, { ok: true, ...result });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /docker/list');
+
+    // 19. POST /dsh-remote-workspace/docker/action
+    sctx.effect(() => webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/docker/action',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+        if (!isTrustedSettingsRequest(req)) return writeJson(res, 403, { ok: false, error: 'Forbidden' });
+        try {
+          const { profileId, containerId, action } = await readBody(req);
+          const profile = profileId ? store.getProfile(profileId) : store.getActiveProfile();
+          if (!profile) return writeJson(res, 404, { ok: false, error: 'No active profile' });
+          if (!containerId || !action) return writeJson(res, 400, { ok: false, error: 'containerId and action required' });
+
+          const result = await dockerService.containerAction(profile, containerId, action);
+          writeJson(res, 200, { ok: result.success, ...result });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /docker/action');
+
+    // 20. POST /dsh-remote-workspace/docker/logs
+    sctx.effect(() => webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/docker/logs',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+        if (!isTrustedSettingsRequest(req)) return writeJson(res, 403, { ok: false, error: 'Forbidden' });
+        try {
+          const { profileId, containerId, tail } = await readBody(req);
+          const profile = profileId ? store.getProfile(profileId) : store.getActiveProfile();
+          if (!profile) return writeJson(res, 404, { ok: false, error: 'No active profile' });
+          if (!containerId) return writeJson(res, 400, { ok: false, error: 'containerId required' });
+
+          const result = await dockerService.containerLogs(profile, containerId, tail || 100);
+          writeJson(res, 200, { ok: result.success, ...result });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /docker/logs');
+
+    // 21. POST /dsh-remote-workspace/watcher/toggle
+    sctx.effect(() => webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/watcher/toggle',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+        if (!isTrustedSettingsRequest(req)) return writeJson(res, 403, { ok: false, error: 'Forbidden' });
+        try {
+          const { enabled } = await readBody(req);
+          await store.setAutoSyncEnabled(Boolean(enabled));
+          writeJson(res, 200, { ok: true, autoSync: store.isAutoSyncEnabled() });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /watcher/toggle');
+
+    // 22. POST /dsh-remote-workspace/transfer
+    sctx.effect(() => webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/transfer',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+        if (!isTrustedSettingsRequest(req)) return writeJson(res, 403, { ok: false, error: 'Forbidden' });
+        try {
+          const { sourceProfileId, sourcePath, destProfileId, destPath } = await readBody(req);
+          const srcProfile = sourceProfileId ? store.getProfile(sourceProfileId) : store.getActiveProfile();
+          const destProfile = store.getProfile(destProfileId);
+
+          if (!srcProfile) return writeJson(res, 404, { ok: false, error: 'Source profile not found' });
+          if (!destProfile) return writeJson(res, 404, { ok: false, error: 'Destination profile not found' });
+          if (!sourcePath || !destPath) return writeJson(res, 400, { ok: false, error: 'sourcePath and destPath required' });
+
+          const result = await sshService.transferFileBetweenHosts(srcProfile, sourcePath, destProfile, destPath);
+          writeJson(res, 200, { ok: result.success, ...result });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /transfer');
   });
 }

package/lib/ssh-service.js

@@ -8,7 +8,6 @@ import os from 'node:os';
  */
 export function stripAnsi(str) {
   if (!str) return '';
-  // Match standard ANSI escape codes, OSC sequences, and CSI codes
   return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
 }
 
@@ -26,15 +25,17 @@ export class SshService {
     this.sftpSessions = new Map();
     /** @type {Map<string, any>} */
     this.terminalSessions = new Map();
+    this.getJumpProfile = null;
   }
 
   setVaultService(vault) {
     this.vaultService = vault;
   }
 
-  /**
-   * Resolve private key content either from direct string or file path
-   */
+  setJumpProfileResolver(resolver) {
+    this.getJumpProfile = resolver;
+  }
+
   resolvePrivateKey(profile) {
     if (profile.privateKey && profile.privateKey.trim()) {
       return profile.privateKey;
@@ -54,7 +55,7 @@ export class SshService {
   }
 
   /**
-   * Connect to remote machine with pooling, keep-alive, and auto-reconnect
+   * Connect to remote machine with pooling, keep-alive, auto-reconnect and ProxyJump
    */
   async getConnection(rawProfile) {
     const profile = this.vaultService ? this.vaultService.hydrateProfile(rawProfile) : rawProfile;
@@ -65,10 +66,24 @@ export class SshService {
       return existing;
     }
 
-    // Clean any broken reference
     this.connections.delete(connId);
     this.sftpSessions.delete(connId);
 
+    // If jumpHost is configured, obtain socket through the jump host first
+    let sock = undefined;
+    if (profile.jumpHostId && this.getJumpProfile) {
+      const jumpProfile = this.getJumpProfile(profile.jumpHostId);
+      if (jumpProfile) {
+        const jumpConn = await this.getConnection(jumpProfile);
+        sock = await new Promise((resolve, reject) => {
+          jumpConn.forwardOut('127.0.0.1', 0, profile.host, profile.port || 22, (err, stream) => {
+            if (err) return reject(new Error(`ProxyJump via ${jumpProfile.host} failed: ${err.message}`));
+            resolve(stream);
+          });
+        });
+      }
+    }
+
     return new Promise((resolve, reject) => {
       const conn = new Client();
       const connConfig = {
@@ -80,6 +95,10 @@ export class SshService {
         readyTimeout: 20000
       };
 
+      if (sock) {
+        connConfig.sock = sock;
+      }
+
       if (profile.authType === 'password') {
         connConfig.password = profile.password || '';
       } else if (profile.authType === 'agent') {
@@ -116,9 +135,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Test connection and measure ping / detect OS
-   */
   async testConnection(profile) {
     if (profile.id) {
       this.disconnect(profile.id);
@@ -154,9 +170,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Obtain active SFTP wrapper with connection reuse
-   */
   async getSftp(profile) {
     const connId = profile.id;
     if (this.sftpSessions.has(connId)) {
@@ -172,13 +185,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Execute command on remote host with PTY, streaming, timeout, and ANSI sanitization
-   * @param {any} profile
-   * @param {string} command
-   * @param {string|object} [optionsOrCwd] - cwd string or options object
-   * @param {function} [legacyOnData]
-   */
   async exec(profile, command, optionsOrCwd = null, legacyOnData = null) {
     let cwd = null;
     let onData = legacyOnData;
@@ -256,8 +262,41 @@ export class SshService {
   }
 
   /**
-   * Create an interactive PTY terminal session for Web UI
+   * Direct Server-to-Server file transfer streaming between two SSH hosts.
+   * Reads from srcProfile SFTP stream and pipes directly into destProfile SFTP stream.
+   * No intermediate files touch the local DSH disk!
    */
+  async transferFileBetweenHosts(srcProfile, srcPath, destProfile, destPath) {
+    const srcSftp = await this.getSftp(srcProfile);
+    const destSftp = await this.getSftp(destProfile);
+
+    return new Promise((resolve, reject) => {
+      const readStream = srcSftp.createReadStream(srcPath);
+      const writeStream = destSftp.createWriteStream(destPath);
+      let bytesTransferred = 0;
+
+      readStream.on('data', (chunk) => {
+        bytesTransferred += chunk.length;
+      });
+
+      writeStream.on('finish', () => {
+        resolve({
+          success: true,
+          bytesTransferred,
+          srcHost: srcProfile.host,
+          destHost: destProfile.host,
+          srcPath,
+          destPath
+        });
+      });
+
+      readStream.on('error', (err) => reject(new Error(`Read from ${srcProfile.host} failed: ${err.message}`)));
+      writeStream.on('error', (err) => reject(new Error(`Write to ${destProfile.host} failed: ${err.message}`)));
+
+      readStream.pipe(writeStream);
+    });
+  }
+
   async createTerminalSession(profile, options = {}) {
     const conn = await this.getConnection(profile);
     const cols = options.cols || 80;

package/lib/tools.js

@@ -1,4 +1,4 @@
-export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile) {
+export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile, getProfileById, dockerService) {
   if (!ctx.tools || typeof ctx.tools.register !== 'function') {
     return;
   }
@@ -149,4 +149,102 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       }
     }
   });
+
+  // 5. remote_docker
+  if (dockerService) {
+    ctx.tools.register({
+      name: 'remote_docker',
+      description: 'Manage Docker/Podman containers and Docker Compose on remote host',
+      parameters: {
+        action: { type: 'string', required: true, description: 'list, logs, start, stop, restart, compose' },
+        containerId: { type: 'string', description: 'Container ID or name' },
+        tail: { type: 'number', description: 'Number of log lines to retrieve (default 50)' },
+        composeAction: { type: 'string', description: 'Compose action: up -d, down, ps, restart' },
+        composeCwd: { type: 'string', description: 'Directory containing docker-compose.yml' }
+      },
+      output: genericOutput,
+      async execute(args) {
+        const profile = getActiveProfile();
+        if (!profile) throw new Error('No active remote workspace profile selected');
+
+        switch (args.action) {
+          case 'list':
+            return await dockerService.listContainers(profile, true);
+          case 'logs':
+            if (!args.containerId) throw new Error('containerId required for logs');
+            return await dockerService.containerLogs(profile, args.containerId, args.tail || 50);
+          case 'start':
+          case 'stop':
+          case 'restart':
+            if (!args.containerId) throw new Error(`containerId required for ${args.action}`);
+            return await dockerService.containerAction(profile, args.containerId, args.action);
+          case 'compose':
+            const dir = args.composeCwd || profile.remoteWorkspace;
+            return await dockerService.composeAction(profile, dir, args.composeAction || 'ps');
+          default:
+            throw new Error(`Unknown docker action: ${args.action}`);
+        }
+      }
+    });
+  }
+
+  // 6. remote_service
+  ctx.tools.register({
+    name: 'remote_service',
+    description: 'Inspect and manage Linux systemd or PM2 services on the remote machine',
+    parameters: {
+      action: { type: 'string', required: true, description: 'status, start, stop, restart, logs' },
+      service: { type: 'string', required: true, description: 'Service name (e.g. nginx, redis, my-app)' },
+      manager: { type: 'string', description: 'systemd (default) or pm2' },
+      lines: { type: 'number', description: 'Number of log lines for logs action (default 40)' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const profile = getActiveProfile();
+      if (!profile) throw new Error('No active remote workspace profile selected');
+
+      const mgr = args.manager || 'systemd';
+      const svc = args.service;
+      const lines = args.lines || 40;
+
+      let cmd = '';
+      if (mgr === 'pm2') {
+        if (args.action === 'logs') cmd = `pm2 logs ${JSON.stringify(svc)} --lines ${lines} --nostream`;
+        else cmd = `pm2 ${args.action} ${JSON.stringify(svc)}`;
+      } else {
+        // systemd
+        if (args.action === 'logs') cmd = `journalctl -u ${JSON.stringify(svc)} -n ${lines} --no-pager`;
+        else if (args.action === 'status') cmd = `systemctl status ${JSON.stringify(svc)} --no-pager`;
+        else cmd = `sudo systemctl ${args.action} ${JSON.stringify(svc)} || systemctl ${args.action} ${JSON.stringify(svc)}`;
+      }
+
+      const res = await sshService.exec(profile, cmd, { cleanAnsi: true });
+      return {
+        exitCode: res.code,
+        output: res.stdout || res.stderr
+      };
+    }
+  });
+
+  // 7. remote_transfer
+  ctx.tools.register({
+    name: 'remote_transfer',
+    description: 'Transfer a file directly between two configured remote servers via in-memory SFTP streams',
+    parameters: {
+      sourcePath: { type: 'string', required: true, description: 'File path on the source remote server' },
+      destPath: { type: 'string', required: true, description: 'File path on the destination remote server' },
+      destProfileId: { type: 'string', required: true, description: 'Target remote profile ID' },
+      sourceProfileId: { type: 'string', description: 'Source remote profile ID (defaults to active profile)' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const srcProfile = args.sourceProfileId && getProfileById ? getProfileById(args.sourceProfileId) : getActiveProfile();
+      if (!srcProfile) throw new Error('Source profile not found or no active profile');
+
+      const destProfile = getProfileById ? getProfileById(args.destProfileId) : null;
+      if (!destProfile) throw new Error(`Destination profile "${args.destProfileId}" not found`);
+
+      return await sshService.transferFileBetweenHosts(srcProfile, args.sourcePath, destProfile, args.destPath);
+    }
+  });
 }

package/lib/watcher-service.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class WatcherService {
+  constructor() {
+    /** @type {Map<string, { watcher: fs.FSWatcher, profile: any, running: boolean }>} */
+    this.watchers = new Map();
+    /** @type {Map<string, NodeJS.Timeout>} */
+    this.debounceTimers = new Map();
+    this.debounceMs = 350;
+    this.onSyncCallback = null;
+  }
+
+  setOnSync(cb) {
+    this.onSyncCallback = cb;
+  }
+
+  isIgnored(filename) {
+    if (!filename) return true;
+    const parts = filename.split(/[\\/]/);
+    const ignoreList = ['.git', 'node_modules', '.dsh-sync-snapshot.json', '.cache', 'dist', 'build', '.next'];
+    for (const part of parts) {
+      if (ignoreList.includes(part)) return true;
+      if (part.endsWith('.tmp') || part.endsWith('.swp') || part.endsWith('~')) return true;
+    }
+    return false;
+  }
+
+  start(profile, mirrorSync) {
+    if (!profile || !profile.id || !profile.localMirrorPath || !profile.remoteWorkspace) {
+      return { success: false, error: 'Both localMirrorPath and remoteWorkspace must be set' };
+    }
+
+    if (this.watchers.has(profile.id)) {
+      return { success: true, alreadyRunning: true };
+    }
+
+    if (!fs.existsSync(profile.localMirrorPath)) {
+      try {
+        fs.mkdirSync(profile.localMirrorPath, { recursive: true });
+      } catch (err) {
+        return { success: false, error: `Failed to create local mirror dir: ${err.message}` };
+      }
+    }
+
+    try {
+      const watcher = fs.watch(profile.localMirrorPath, { recursive: true }, (_eventType, filename) => {
+        if (!filename || this.isIgnored(filename)) return;
+
+        // Debounce sync triggers
+        if (this.debounceTimers.has(profile.id)) {
+          clearTimeout(this.debounceTimers.get(profile.id));
+        }
+
+        const timer = setTimeout(async () => {
+          this.debounceTimers.delete(profile.id);
+          try {
+            const syncRes = await mirrorSync.push(profile, profile.localMirrorPath, profile.remoteWorkspace);
+            if (this.onSyncCallback) {
+              this.onSyncCallback({ profileId: profile.id, syncRes });
+            }
+          } catch (_) {}
+        }, this.debounceMs);
+
+        this.debounceTimers.set(profile.id, timer);
+      });
+
+      this.watchers.set(profile.id, { watcher, profile, running: true });
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  stop(profileId) {
+    if (this.debounceTimers.has(profileId)) {
+      clearTimeout(this.debounceTimers.get(profileId));
+      this.debounceTimers.delete(profileId);
+    }
+    const item = this.watchers.get(profileId);
+    if (item) {
+      try {
+        item.watcher.close();
+      } catch (_) {}
+      this.watchers.delete(profileId);
+      return true;
+    }
+    return false;
+  }
+
+  getStatus(profileId) {
+    return this.watchers.has(profileId);
+  }
+
+  listActive() {
+    return Array.from(this.watchers.keys());
+  }
+
+  stopAll() {
+    for (const [id, item] of this.watchers.entries()) {
+      try {
+        item.watcher.close();
+      } catch (_) {}
+      if (this.debounceTimers.has(id)) {
+        clearTimeout(this.debounceTimers.get(id));
+      }
+    }
+    this.watchers.clear();
+    this.debounceTimers.clear();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-remote-workspace",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Enterprise Remote Workspace Plugin for DeepSeek Harness: SSH2 connection pool, SFTP operations, 3-way conflict-aware mirror sync, port forwarding, and native DSH UI.",
   "type": "module",
   "main": "lib/index.js",