@goodandready/dsh-remote-workspace 0.1.0

package/lib/index.js

@@ -0,0 +1,116 @@
+import z from '@deepseek-ai/schemastery';
+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 { registerRemoteTools } from './tools.js';
+import { registerApiRoutes } from './routes.js';
+
+export const name = '@goodandready/dsh-remote-workspace';
+
+const NS = 'dsh-remote-workspace';
+
+export const inject = ['tools'];
+
+export const Config = z.object({
+  profiles: z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    host: z.string(),
+    port: z.number().default(22),
+    username: z.string(),
+    authType: z.string().default('key'),
+    privateKeyPath: z.string().default(''),
+    privateKey: z.string().default(''),
+    passphrase: z.string().default(''),
+    password: z.string().default(''),
+    remoteWorkspace: z.string().default(''),
+    localMirrorPath: z.string().default('')
+  })).default([]).description('List of configured remote machines and workspaces.'),
+  activeProfileId: z.string().default('').description('ID of active remote profile.')
+});
+
+export function apply(ctx, config = {}) {
+  const cfg = config || {};
+  let settingsApi = null;
+  let currentConfig = {
+    profiles: Array.isArray(cfg.profiles) ? cfg.profiles : [],
+    activeProfileId: cfg.activeProfileId || null
+  };
+
+  const store = {
+    getProfiles() { return currentConfig.profiles || []; },
+    getProfile(id) { return (currentConfig.profiles || []).find((p) => p.id === id); },
+    getActiveId() { return currentConfig.activeProfileId; },
+    getActiveProfile() { return (currentConfig.profiles || []).find((p) => p.id === currentConfig.activeProfileId); },
+    async saveProfile(p) {
+      const list = [...(currentConfig.profiles || [])];
+      const idx = list.findIndex((x) => x.id === p.id);
+      if (idx >= 0) list[idx] = { ...list[idx], ...p };
+      else list.push(p);
+      currentConfig.profiles = list;
+      if (!currentConfig.activeProfileId && list.length === 1) {
+        currentConfig.activeProfileId = p.id;
+      }
+      if (settingsApi?.replace) {
+        await settingsApi.replace(Config(currentConfig));
+      }
+    },
+    async deleteProfile(id) {
+      currentConfig.profiles = (currentConfig.profiles || []).filter((p) => p.id !== id);
+      if (currentConfig.activeProfileId === id) {
+        currentConfig.activeProfileId = currentConfig.profiles[0]?.id || null;
+      }
+      if (settingsApi?.replace) {
+        await settingsApi.replace(Config(currentConfig));
+      }
+    },
+    async setActiveId(id) {
+      currentConfig.activeProfileId = id;
+      if (settingsApi?.replace) {
+        await settingsApi.replace(Config(currentConfig));
+      }
+    }
+  };
+
+  // Register settings namespace if settings service is available
+  ctx.inject(['settings'], (sctx) => {
+    const scope = sctx.settings.register(NS, Config, { base: cfg });
+    settingsApi = scope;
+    const snap = scope.get();
+    if (snap) {
+      if (Array.isArray(snap.profiles)) currentConfig.profiles = snap.profiles;
+      if (snap.activeProfileId !== undefined) currentConfig.activeProfileId = snap.activeProfileId;
+    }
+    sctx.effect(() => () => {
+      settingsApi = null;
+    });
+  });
+
+  const sshService = new SshService(ctx);
+  const remoteFs = new RemoteFsService(sshService);
+  const mirrorSync = new MirrorSyncService(remoteFs, sshService);
+  const tunnelService = new TunnelService(sshService);
+
+  ctx.provide('remoteSsh');
+  ctx.provide('remoteFs');
+  ctx.provide('remoteSync');
+  ctx.provide('remoteTunnel');
+
+  ctx.remoteSsh = sshService;
+  ctx.remoteFs = remoteFs;
+  ctx.remoteSync = mirrorSync;
+  ctx.remoteTunnel = tunnelService;
+
+  // Tools registration
+  registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, () => store.getActiveProfile());
+
+  // API Routes
+  registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store);
+
+  // Cleanup on unload
+  ctx.on('dispose', () => {
+    tunnelService.stopAll();
+    sshService.disconnectAll();
+  });
+}

package/lib/mirror-sync-service.js

@@ -0,0 +1,180 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+export class MirrorSyncService {
+  /**
+   * @param {import('./remote-fs-service.js').RemoteFsService} remoteFs
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(remoteFs, sshService) {
+    this.remoteFs = remoteFs;
+    this.sshService = sshService;
+    this.defaultIgnore = [
+      '.git',
+      'node_modules',
+      '.worktrees',
+      'dist',
+      'build',
+      '.next',
+      '.cache',
+      '*.pyc',
+      '__pycache__'
+    ];
+  }
+
+  computeHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+  }
+
+  isIgnored(relPath) {
+    const parts = relPath.split(/[\\/]/);
+    for (const pattern of this.defaultIgnore) {
+      if (pattern.startsWith('*.')) {
+        const ext = pattern.slice(1);
+        if (relPath.endsWith(ext)) return true;
+      } else {
+        if (parts.includes(pattern)) return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * 3-way conflict aware pull: Remote -> Local Mirror
+   */
+  async pull(profile, remoteDir, localDir, dryRun = false) {
+    fs.mkdirSync(localDir, { recursive: true });
+    const snapshotFile = path.join(localDir, '.dsh-sync-snapshot.json');
+    let lastSnapshot = {};
+    if (fs.existsSync(snapshotFile)) {
+      try {
+        lastSnapshot = JSON.parse(fs.readFileSync(snapshotFile, 'utf8'));
+      } catch (_) {}
+    }
+
+    const conflicts = [];
+    const updated = [];
+    const newSnapshot = { ...lastSnapshot };
+
+    // Find remote files using find over ssh for speed
+    const findCmd = `find . -maxdepth 5 -type f ! -path '*/.*' ! -path '*/node_modules/*' -printf '%P\\t%s\\t%T@\\n'`;
+    const execRes = await this.sshService.exec(profile, findCmd, remoteDir);
+    if (execRes.code !== 0) {
+      throw new Error(`Failed to scan remote dir: ${execRes.stderr}`);
+    }
+
+    const lines = execRes.stdout.split('\n').filter(Boolean);
+    for (const line of lines) {
+      const [relPath] = line.split('\t');
+      if (!relPath || this.isIgnored(relPath)) continue;
+
+      const remoteFullPath = path.posix.join(remoteDir, relPath);
+      const localFullPath = path.join(localDir, relPath);
+
+      const remoteContent = await this.remoteFs.readFile(profile, remoteFullPath, 'utf8');
+      const remoteHash = this.computeHash(remoteContent);
+      const baseHash = lastSnapshot[relPath];
+
+      let localContent = null;
+      let localHash = null;
+      if (fs.existsSync(localFullPath)) {
+        localContent = fs.readFileSync(localFullPath, 'utf8');
+        localHash = this.computeHash(localContent);
+      }
+
+      // Check conflict: both changed compared to last baseline
+      if (baseHash && localHash && remoteHash !== baseHash && localHash !== baseHash && remoteHash !== localHash) {
+        conflicts.push({ path: relPath, reason: 'Modified on both remote and local' });
+        continue;
+      }
+
+      if (localHash !== remoteHash) {
+        updated.push(relPath);
+        if (!dryRun) {
+          fs.mkdirSync(path.dirname(localFullPath), { recursive: true });
+          fs.writeFileSync(localFullPath, remoteContent, 'utf8');
+          newSnapshot[relPath] = remoteHash;
+        }
+      } else {
+        newSnapshot[relPath] = remoteHash;
+      }
+    }
+
+    if (!dryRun) {
+      fs.writeFileSync(snapshotFile, JSON.stringify(newSnapshot, null, 2), 'utf8');
+    }
+
+    return {
+      success: conflicts.length === 0,
+      pulled: updated,
+      conflicts,
+      dryRun
+    };
+  }
+
+  /**
+   * 3-way conflict aware push: Local Mirror -> Remote
+   */
+  async push(profile, localDir, remoteDir, force = false, dryRun = false) {
+    const snapshotFile = path.join(localDir, '.dsh-sync-snapshot.json');
+    let snapshot = {};
+    if (fs.existsSync(snapshotFile)) {
+      try {
+        snapshot = JSON.parse(fs.readFileSync(snapshotFile, 'utf8'));
+      } catch (_) {}
+    }
+
+    const pushed = [];
+    const conflicts = [];
+
+    const walkLocal = (dir, rootDir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      let files = [];
+      for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        const rel = path.relative(rootDir, full);
+        if (this.isIgnored(rel)) continue;
+        if (entry.isDirectory()) {
+          files = files.concat(walkLocal(full, rootDir));
+        } else if (entry.isFile()) {
+          files.push(rel);
+        }
+      }
+      return files;
+    };
+
+    const localFiles = walkLocal(localDir, localDir);
+    for (const rel of localFiles) {
+      const localFull = path.join(localDir, rel);
+      const remoteFull = path.posix.join(remoteDir, rel.replace(/\\/g, '/'));
+      const content = fs.readFileSync(localFull, 'utf8');
+      const localHash = this.computeHash(content);
+      const baseHash = snapshot[rel];
+
+      if (baseHash && baseHash === localHash && !force) {
+        continue; // Unchanged locally
+      }
+
+      if (!dryRun) {
+        // Ensure remote parent dir exists
+        const parent = path.posix.dirname(remoteFull);
+        await this.remoteFs.mkdir(profile, parent);
+        await this.remoteFs.writeFile(profile, remoteFull, content, 'utf8');
+        snapshot[rel] = localHash;
+      }
+      pushed.push(rel);
+    }
+
+    if (!dryRun) {
+      fs.writeFileSync(snapshotFile, JSON.stringify(snapshot, null, 2), 'utf8');
+    }
+
+    return {
+      success: true,
+      pushed,
+      conflicts,
+      dryRun
+    };
+  }
+}

package/lib/remote-fs-service.js

@@ -0,0 +1,117 @@
+import path from 'node:path';
+
+export class RemoteFsService {
+  /**
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(sshService) {
+    this.sshService = sshService;
+  }
+
+  /**
+   * Read directory entries
+   */
+  async listDir(profile, remotePath) {
+    const sftp = await this.sshService.getSftp(profile);
+    return new Promise((resolve, reject) => {
+      sftp.readdir(remotePath, (err, list) => {
+        if (err) return reject(err);
+        const entries = list.map((item) => ({
+          filename: item.filename,
+          isDirectory: (item.attrs.mode & 0o40000) !== 0,
+          isFile: (item.attrs.mode & 0o100000) !== 0,
+          size: item.attrs.size,
+          mtime: item.attrs.mtime,
+          permissions: (item.attrs.mode & 0o777).toString(8)
+        }));
+        resolve(entries);
+      });
+    });
+  }
+
+  /**
+   * Stat remote path
+   */
+  async stat(profile, remotePath) {
+    const sftp = await this.sshService.getSftp(profile);
+    return new Promise((resolve, reject) => {
+      sftp.stat(remotePath, (err, stats) => {
+        if (err) return reject(err);
+        resolve({
+          isDirectory: (stats.mode & 0o40000) !== 0,
+          isFile: (stats.mode & 0o100000) !== 0,
+          size: stats.size,
+          mtime: stats.mtime
+        });
+      });
+    });
+  }
+
+  /**
+   * Read file content with buffer/string conversion
+   */
+  async readFile(profile, remotePath, encoding = 'utf8') {
+    const sftp = await this.sshService.getSftp(profile);
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      const stream = sftp.createReadStream(remotePath);
+      stream.on('data', (chunk) => chunks.push(chunk));
+      stream.on('end', () => {
+        const buf = Buffer.concat(chunks);
+        resolve(encoding ? buf.toString(encoding) : buf);
+      });
+      stream.on('error', (err) => reject(err));
+    });
+  }
+
+  /**
+   * Atomic file write using temp file and rename
+   */
+  async writeFile(profile, remotePath, content, encoding = 'utf8') {
+    const sftp = await this.sshService.getSftp(profile);
+    const tempPath = `${remotePath}.dsh-tmp.${Date.now()}`;
+    const data = Buffer.isBuffer(content) ? content : Buffer.from(content, encoding);
+
+    await new Promise((resolve, reject) => {
+      const stream = sftp.createWriteStream(tempPath);
+      stream.on('finish', () => resolve());
+      stream.on('error', (err) => reject(err));
+      stream.end(data);
+    });
+
+    return new Promise((resolve, reject) => {
+      sftp.rename(tempPath, remotePath, (err) => {
+        if (err) {
+          // If rename fails, try unlink temp
+          sftp.unlink(tempPath, () => {});
+          return reject(err);
+        }
+        resolve({ success: true, bytes: data.length });
+      });
+    });
+  }
+
+  /**
+   * Create remote directory recursively
+   */
+  async mkdir(profile, remotePath) {
+    const cmd = `mkdir -p ${JSON.stringify(remotePath)}`;
+    const res = await this.sshService.exec(profile, cmd);
+    if (res.code !== 0) {
+      throw new Error(`Failed to create remote dir ${remotePath}: ${res.stderr}`);
+    }
+    return { success: true };
+  }
+
+  /**
+   * Remove remote file or directory
+   */
+  async remove(profile, remotePath, recursive = false) {
+    const cmd = recursive ? `rm -rf ${JSON.stringify(remotePath)}` : `rm -f ${JSON.stringify(remotePath)}`;
+    const res = await this.sshService.exec(profile, cmd);
+    if (res.code !== 0) {
+      throw new Error(`Failed to remove remote path ${remotePath}: ${res.stderr}`);
+    }
+    return { success: true };
+  }
+}

package/lib/routes.js

@@ -0,0 +1,164 @@
+function writeJson(res, code, data) {
+  try {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  } catch {}
+}
+
+function readBody(req, maxBytes = 256 * 1024) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > maxBytes) {
+        reject(new Error('Payload too large'));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on('end', () => {
+      try {
+        const raw = Buffer.concat(chunks).toString('utf8');
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch (err) {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+export function registerApiRoutes(ctx, sshService, remoteFs, mirrorSync, tunnelService, store) {
+  ctx.inject(['webServer'], (sctx) => {
+    // 1. GET /dsh-remote-workspace/state
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/state',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') return writeJson(res, 405, { error: 'GET only' });
+        const profiles = store.getProfiles();
+        const activeId = store.getActiveId();
+        const tunnels = tunnelService.listActiveTunnels();
+        writeJson(res, 200, { ok: true, profiles, activeId, tunnels });
+      }
+    }), 'dsh-remote-workspace: /state');
+
+    // 2. POST /dsh-remote-workspace/profiles/save
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/profiles/save',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { error: 'POST only' });
+        try {
+          const profile = await readBody(req);
+          if (!profile.id || !profile.host) {
+            return writeJson(res, 400, { ok: false, error: 'ID and Host are required' });
+          }
+          await store.saveProfile(profile);
+          writeJson(res, 200, { ok: true, profile });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /profiles/save');
+
+    // 3. POST /dsh-remote-workspace/profiles/delete
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/profiles/delete',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { error: 'POST only' });
+        try {
+          const { id } = await readBody(req);
+          if (!id) return writeJson(res, 400, { ok: false, error: 'ID is required' });
+          await store.deleteProfile(id);
+          writeJson(res, 200, { ok: true });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /profiles/delete');
+
+    // 4. POST /dsh-remote-workspace/profiles/active
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/profiles/active',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { error: 'POST only' });
+        try {
+          const { id } = await readBody(req);
+          await store.setActiveId(id || null);
+          writeJson(res, 200, { ok: true, activeId: store.getActiveId() });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /profiles/active');
+
+    // 5. POST /dsh-remote-workspace/test
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/test',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { error: 'POST only' });
+        try {
+          const body = await readBody(req);
+          const profile = body.profile || (body.id ? store.getProfile(body.id) : body);
+          if (!profile || !profile.host) {
+            return writeJson(res, 400, { ok: false, error: 'Invalid profile configuration' });
+          }
+          const result = await sshService.testConnection(profile);
+          writeJson(res, 200, { ok: result.success, ...result });
+        } catch (err) {
+          writeJson(res, 200, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /test');
+
+    // 6. POST /dsh-remote-workspace/browse
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/browse',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { error: 'POST only' });
+        try {
+          const body = await readBody(req);
+          const profile = body.profile || (body.profileId ? store.getProfile(body.profileId) : store.getActiveProfile());
+          if (!profile || !profile.host) {
+            return writeJson(res, 400, { ok: false, error: 'No profile specified' });
+          }
+          const remotePath = body.remotePath || '/';
+          const entries = await remoteFs.listDir(profile, remotePath);
+          writeJson(res, 200, { ok: true, currentPath: remotePath, entries });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /browse');
+
+    // 7. POST /dsh-remote-workspace/sync
+    sctx.effect(() => sctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-remote-workspace/sync',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { error: 'POST only' });
+        try {
+          const { profileId, direction } = await readBody(req);
+          const profile = store.getProfile(profileId) || store.getActiveProfile();
+          if (!profile) return writeJson(res, 404, { ok: false, error: 'Profile not found' });
+          if (!profile.remoteWorkspace || !profile.localMirrorPath) {
+            return writeJson(res, 400, { ok: false, error: 'Both remoteWorkspace and localMirrorPath must be set' });
+          }
+          const resSync = direction === 'push'
+            ? await mirrorSync.push(profile, profile.localMirrorPath, profile.remoteWorkspace)
+            : await mirrorSync.pull(profile, profile.remoteWorkspace, profile.localMirrorPath);
+          writeJson(res, 200, { ok: resSync.success, ...resSync });
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message });
+        }
+      }
+    }), 'dsh-remote-workspace: /sync');
+  });
+}