@goodandready/dsh-remote-workspace 0.3.14 → 0.3.16

package/lib/tar-sync-service.js

@@ -40,7 +40,7 @@ export class TarSyncService {
 
         localTar.on('close', (code) => {
           if (code !== 0) {
-            try { stream.destroy(); } catch (_) {}
+            try { stream.destroy(); } catch (_err) { /* ignore best-effort stream cleanup */ }
             reject(new Error(`Local tar extraction failed (code ${code}): ${stderr}`));
           } else {
             resolve({ ok: true, direction: 'pull', remoteDir, localDir });
@@ -48,17 +48,17 @@ export class TarSyncService {
         });
 
         localTar.on('error', (err) => {
-          try { stream.destroy(); } catch (_) {}
+          try { stream.destroy(); } catch (_err) { /* ignore best-effort stream cleanup */ }
           reject(err);
         });
 
         stream.on('error', (err) => {
-          try { localTar.kill('SIGTERM'); } catch (_) {}
+          try { localTar.kill('SIGTERM'); } catch (_err) { /* ignore best-effort process termination */ }
           reject(err);
         });
 
         localTar.stdin.on('error', (err) => {
-          try { stream.destroy(); } catch (_) {}
+          try { stream.destroy(); } catch (_err) { /* ignore best-effort stream cleanup */ }
           reject(err);
         });
       });
@@ -93,7 +93,7 @@ export class TarSyncService {
 
         stream.on('close', (code) => {
           if (code !== 0) {
-            try { localTar.kill('SIGTERM'); } catch (_) {}
+            try { localTar.kill('SIGTERM'); } catch (_err) { /* ignore best-effort process termination */ }
             reject(new Error(`Remote tar extraction failed (code ${code}): ${remoteStderr}`));
           } else {
             resolve({ ok: true, direction: 'push', localDir, remoteDir });
@@ -101,12 +101,12 @@ export class TarSyncService {
         });
 
         stream.on('error', (err) => {
-          try { localTar.kill('SIGTERM'); } catch (_) {}
+          try { localTar.kill('SIGTERM'); } catch (_err) { /* ignore best-effort process termination */ }
           reject(err);
         });
 
         localTar.on('error', (err) => {
-          try { stream.destroy(); } catch (_) {}
+          try { stream.destroy(); } catch (_err) { /* ignore best-effort stream cleanup */ }
           reject(err);
         });
       });

package/lib/tools.js

@@ -1,7 +1,80 @@
+import path from 'node:path';
+import { shellQuote } from './tar-sync-service.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { renderHostTable } from './host-projection.js';
 import { filterClusterProfiles, runCluster } from './cluster-service.js';
 
+
+export function isWithinWorkspace(normWorkspace, candidatePath) {
+  const normCandidate = path.posix.normalize(candidatePath);
+  const prefix = normWorkspace.endsWith('/') ? normWorkspace : normWorkspace + '/';
+  return normCandidate === normWorkspace || normCandidate.startsWith(prefix);
+}
+
+export function resolveWorkspacePath(workspace, targetPath) {
+  if (!workspace || typeof workspace !== 'string' || !workspace.trim()) {
+    throw new Error('Remote workspace is not configured for active profile');
+  }
+  const trimmedWorkspace = workspace.trim();
+  if (trimmedWorkspace.includes('\0') || !path.posix.isAbsolute(trimmedWorkspace)) {
+    throw new Error('Remote workspace must be an absolute path starting with "/"');
+  }
+  if (!targetPath || typeof targetPath !== 'string' || targetPath.includes('\0')) {
+    throw new Error('Path must be a non-empty string without null bytes');
+  }
+  const normWorkspace = path.posix.normalize(trimmedWorkspace);
+  const resolved = path.posix.isAbsolute(targetPath)
+    ? path.posix.normalize(targetPath)
+    : path.posix.resolve(normWorkspace, targetPath);
+
+  if (!isWithinWorkspace(normWorkspace, resolved)) {
+    throw new Error(`Access denied: path "${targetPath}" is outside configured remoteWorkspace "${workspace}"`);
+  }
+  return resolved;
+}
+
+export async function verifyWorkspaceRealpath(remoteFs, profile, workspace, resolvedPath, targetPath) {
+  if (!remoteFs || typeof remoteFs.realpath !== 'function') {
+    return resolvedPath;
+  }
+  const normWorkspace = path.posix.normalize(workspace.trim());
+  let realWorkspace = normWorkspace;
+  try {
+    const resolvedWs = await remoteFs.realpath(profile, normWorkspace);
+    if (resolvedWs && typeof resolvedWs === 'string') {
+      realWorkspace = path.posix.normalize(resolvedWs);
+    }
+  } catch (_err) {
+    // Fallback to normalized configured workspace if workspace root itself cannot be resolved yet
+  }
+
+  let checkPath = resolvedPath;
+  let realCandidate = null;
+  try {
+    realCandidate = await remoteFs.realpath(profile, checkPath);
+  } catch (_err) {
+    // For non-existent leaf targets (e.g., write / mkdir), verify the parent directory realpath
+    const parentPath = path.posix.dirname(checkPath);
+    try {
+      const realParent = await remoteFs.realpath(profile, parentPath);
+      if (realParent && typeof realParent === 'string') {
+        realCandidate = path.posix.join(realParent, path.posix.basename(checkPath));
+      }
+    } catch (_parentErr) {
+      realCandidate = null;
+    }
+  }
+
+  if (realCandidate && typeof realCandidate === 'string') {
+    const normReal = path.posix.normalize(realCandidate);
+    if (!isWithinWorkspace(realWorkspace, normReal)) {
+      throw new Error(`Access denied: symlink target "${normReal}" for path "${targetPath}" escapes configured remoteWorkspace "${workspace}"`);
+    }
+    return normReal;
+  }
+  return resolvedPath;
+}
+
 export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile, getProfileById, dockerService, diagnoseService, envService, tarSyncService, listProfiles = null) {
   if (!ctx.tools || typeof ctx.tools.register !== 'function') {
     return;
@@ -9,7 +82,10 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
 
   const genericOutput = {
     schema: { type: 'object', additionalProperties: true },
-    render: (_args, value) => ({ type: 'text', content: typeof value === 'string' ? value : JSON.stringify(value, null, 2) })
+    render: (_args, value) => [{
+      type: 'text',
+      text: typeof value === 'string' ? value : JSON.stringify(value, null, 2)
+    }]
   };
 
   // 1. remote_exec
@@ -68,28 +144,38 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       if (!profile) throw new Error('No active remote workspace profile selected');
       const { action, path: targetPath, content, recursive, bypassCache } = args;
 
+      const lexicalPath = resolveWorkspacePath(profile.remoteWorkspace, targetPath);
+      const normWs = path.posix.normalize(profile.remoteWorkspace.trim());
+      if (action === 'remove' && lexicalPath === normWs) {
+        throw new Error('Cannot remove root workspace directory');
+      }
+      const resolvedPath = await verifyWorkspaceRealpath(remoteFs, profile, profile.remoteWorkspace, lexicalPath, targetPath);
+      if (action === 'remove' && resolvedPath === normWs) {
+        throw new Error('Cannot remove root workspace directory');
+      }
+
       switch (action) {
         case 'read': {
-          const data = await remoteFs.readFile(profile, targetPath, 'utf8');
+          const data = await remoteFs.readFile(profile, resolvedPath, 'utf8');
           return { content: data };
         }
         case 'write': {
           if (content === undefined) throw new Error('Content is required for write action');
-          const res = await remoteFs.writeFile(profile, targetPath, content, 'utf8');
+          const res = await remoteFs.writeFile(profile, resolvedPath, content, 'utf8');
           return res;
         }
         case 'stat': {
-          return await remoteFs.stat(profile, targetPath, Boolean(bypassCache));
+          return await remoteFs.stat(profile, resolvedPath, Boolean(bypassCache));
         }
         case 'list': {
-          const entries = await remoteFs.listDir(profile, targetPath, Boolean(bypassCache));
+          const entries = await remoteFs.listDir(profile, resolvedPath, Boolean(bypassCache));
           return { entries };
         }
         case 'mkdir': {
-          return await remoteFs.mkdir(profile, targetPath);
+          return await remoteFs.mkdir(profile, resolvedPath);
         }
         case 'remove': {
-          return await remoteFs.remove(profile, targetPath, recursive);
+          return await remoteFs.remove(profile, resolvedPath, recursive);
         }
         default:
           throw new Error(`Unknown action: ${action}`);
@@ -216,18 +302,32 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       const profile = getActiveProfile();
       if (!profile) throw new Error('No active remote workspace profile selected');
 
-      const mgr = args.manager || 'systemd';
+      const ALLOWED_ACTIONS = ['status', 'start', 'stop', 'restart', 'reload', 'enable', 'disable', 'logs'];
+      if (!args.action || !ALLOWED_ACTIONS.includes(args.action)) {
+        throw new Error(`Invalid service action: "${args.action}". Allowed actions: ${ALLOWED_ACTIONS.join(', ')}`);
+      }
+
+      const mgr = (args.manager || 'systemd').toLowerCase();
+      if (!['systemd', 'pm2'].includes(mgr)) {
+        throw new Error(`Invalid service manager: "${args.manager}". Allowed managers: systemd, pm2`);
+      }
+
       const svc = args.service;
-      const lines = args.lines || 40;
+      if (!svc || typeof svc !== 'string' || svc.trim() === '') {
+        throw new Error('Service name is required');
+      }
+
+      const lines = Math.max(1, Math.min(10000, parseInt(args.lines, 10) || 40));
+      const safeSvc = shellQuote(svc.trim());
 
       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)}`;
+        if (args.action === 'logs') cmd = `pm2 logs ${safeSvc} --lines ${lines} --nostream`;
+        else cmd = `pm2 ${args.action} ${safeSvc}`;
       } else {
-        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)}`;
+        if (args.action === 'logs') cmd = `journalctl -u ${safeSvc} -n ${lines} --no-pager`;
+        else if (args.action === 'status') cmd = `systemctl status ${safeSvc} --no-pager`;
+        else cmd = `sudo systemctl ${args.action} ${safeSvc} || systemctl ${args.action} ${safeSvc}`;
       }
 
       const res = await sshService.exec(profile, cmd, { cleanAnsi: true });
@@ -303,7 +403,7 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
         },
         key: {
           type: 'string',
-          description: 'Environment variable key (required for set)'
+          description: 'Environment variable key (optional for read to retrieve a specific variable; required for set)'
         },
         value: {
           type: 'string',
@@ -316,7 +416,32 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
         if (!profile) throw new Error('No active remote workspace profile selected');
 
         if (args.action === 'read') {
-          return await envService.readEnv(profile, args.filePath);
+          const res = await envService.readEnv(profile, args.filePath);
+          if (args.key) {
+            const entry = (res.entries || []).find((e) => e.key === args.key);
+            const val = entry ? entry.value : (res.variables ? res.variables[args.key] : undefined);
+            return {
+              filePath: res.filePath || args.filePath,
+              key: args.key,
+              exists: entry !== undefined || (res.variables && res.variables[args.key] !== undefined),
+              value: val !== undefined ? val : null
+            };
+          }
+          const keys = res.entries
+            ? res.entries.filter((e) => e.key).map((e) => e.key)
+            : (res.variables ? Object.keys(res.variables) : []);
+          const sanitizedEntries = (res.entries || []).map((e) => ({
+            key: e.key,
+            isComment: Boolean(e.isComment),
+            hasValue: Boolean(e.value),
+            value: e.value ? '••••••••' : ''
+          }));
+          return {
+            filePath: res.filePath || args.filePath,
+            keys,
+            entries: sanitizedEntries,
+            note: 'Values are masked to prevent secret leakage into LLM context. Pass "key" argument to read a specific variable.'
+          };
         } else if (args.action === 'set') {
           if (!args.key) throw new Error('key is required for set action');
           return await envService.setEnvVar(profile, args.filePath, args.key, args.value || '');
@@ -360,7 +485,10 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
     },
     output: {
       schema: { type: 'object', additionalProperties: true },
-      render: (_args, value) => ({ type: 'text', content: value && value.table ? value.table : '' })
+      render: (_args, value) => [{
+        type: 'text',
+        text: value && value.table ? value.table : ''
+      }]
     },
     async execute(args) {
       const profiles = typeof listProfiles === 'function' ? (listProfiles() || []) : [];

package/lib/updater-service.js

@@ -3,7 +3,6 @@ import { existsSync, readFileSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, dirname, isAbsolute, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
 
 /**
  * Host-side one-click updater for @goodandready/dsh-remote-workspace.
@@ -206,21 +205,25 @@ export async function status(options, target) {
   }
 }
 
+export function buildInstallArgs(target, packageSpec, options = {}) {
+  // Note: Do NOT add --config.minimumReleaseAge=0 per issue #214 / dsh-plugin-guard#65
+  return [
+    target.cliEntry,
+    'plugin',
+    '--profile',
+    target.profileName,
+    'add',
+    packageSpec,
+    `--registry=${options.registry ?? 'https://registry.npmjs.org/'}`,
+  ];
+}
+
 async function installExact(target, packageSpec, options) {
   if (target.cliEntry === undefined) throw new Error('Automatic update is unavailable in this runtime.')
   await new Promise((resolvePromise, reject) => {
     const child = spawn(
       process.execPath,
-      [
-        target.cliEntry,
-        'plugin',
-        '--profile',
-        target.profileName,
-        'add',
-        '--config.minimumReleaseAge=0',
-        packageSpec,
-        `--registry=${options.registry ?? 'https://registry.npmjs.org/'}`,
-      ],
+      buildInstallArgs(target, packageSpec, options),
       {
         cwd: target.profileDir,
         windowsHide: true,

package/lib/vault-service.js

@@ -2,9 +2,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
+/**
+ * Resolve DSH home directory, respecting custom DSH_HOME environment variable.
+ */
+export function resolveDshHome() {
+  return process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+}
+
 /**
  * VaultService manages credentials (password, privateKey, passphrase)
- * stored in an isolated, secure .env file instead of DSH profiles JSON.
+ * stored in an isolated, secure .env file with owner-only (0600) permissions
+ * instead of DSH profiles JSON.
  */
 export class VaultService {
   constructor(customPath = null) {
@@ -12,8 +20,8 @@ export class VaultService {
     if (customPath) {
       this.envPath = customPath;
     } else {
-      const homeDir = os.homedir();
-      const secretsDir = path.join(homeDir, '.dsh', 'secrets');
+      const dshHome = resolveDshHome();
+      const secretsDir = path.join(dshHome, 'secrets');
       try {
         if (!fs.existsSync(secretsDir)) {
           fs.mkdirSync(secretsDir, { recursive: true, mode: 0o700 });
@@ -36,7 +44,7 @@ export class VaultService {
   ensureEnvFile() {
     try {
       if (!fs.existsSync(this.envPath)) {
-        fs.writeFileSync(this.envPath, '# DSH Remote Workspace Encrypted Secrets Vault\n', { mode: 0o600, encoding: 'utf8' });
+        fs.writeFileSync(this.envPath, '# DSH Remote Workspace Secrets Vault (Owner-Only Permissions 0600)\n', { mode: 0o600, encoding: 'utf8' });
       } else {
         // Ensure file permissions are restricted to owner only
         try {
@@ -53,6 +61,7 @@ export class VaultService {
   getPermissionStatus() {
     return {
       secure: !this.permissionError,
+      protection: 'owner-only-permissions',
       error: this.permissionError,
       path: this.envPath
     };
@@ -109,7 +118,7 @@ export class VaultService {
 
   writeAll(store) {
     this.ensureEnvFile();
-    const lines = ['# DSH Remote Workspace Secrets Vault - Auto Generated', ''];
+    const lines = ['# DSH Remote Workspace Secrets Vault (Owner-Only Permissions 0600)', ''];
     for (const [key, val] of Object.entries(store)) {
       if (val === undefined || val === null || val === '') continue;
       const strVal = String(val);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-remote-workspace",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "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",
@@ -16,7 +16,8 @@
     "README.md",
     "README.ru.md",
     "README.zh.md",
-    "LICENSE"
+    "LICENSE",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsup",

package/lib/workspace-mount.js

@@ -1,5 +0,0 @@
-export function attachWorkspaceNode(column, node) {
-  if (!column || !node || typeof column.appendChild !== 'function') return false;
-  if (node.parentElement !== column) column.appendChild(node);
-  return node.parentElement === column;
-}