Global SSH config with workspace merge

Author: Miguel Targa

CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to the "ssh-control" extension will be documented in this fi
 
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
+## [1.0.1] - 2025-10-01
+
+### Changed
+- **Global Configuration by Default**: SSH config now saves to `~/.ssh-control/ssh-config.json` by default
+  - Configuration is now shared across all workspaces
+  - Workspace-specific configs (`ssh-config.json` in project root) are still supported if they exist
+  - Both configs are merged when workspace config is present (workspace groups prefixed with `[Workspace]`)
+- **Config Button Behavior**: Open config button now opens workspace config if it exists, otherwise opens global config
+
+### Fixed
+- Removed annoying "SSH Control loaded" notification that appeared on every terminal open
+
 ## [1.0.0] - 2025-09-26
 
 ### Added

package.json

@@ -2,7 +2,7 @@
   "name": "ssh-control",
   "displayName": "SSH Control",
   "description": "Manage SSH connections directly from VSCode.",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "publisher": "migueltarga",
   "author": {
     "name": "Miguel Targa",

src/extension.ts

@@ -175,7 +175,7 @@ export function activate(context: vscode.ExtensionContext) {
 	});
 
 	const openConfigCommand = vscode.commands.registerCommand('sshServers.openConfig', async () => {
-		const configPath = configManager.getConfigFilePath();
+		const configPath = configManager.getConfigFilePathForEditing();
 		try {
 			const document = await vscode.workspace.openTextDocument(configPath);
 			await vscode.window.showTextDocument(document);
@@ -248,7 +248,6 @@ export function activate(context: vscode.ExtensionContext) {
 		hostHistoryClearFilterCommand,
 		runSnippetCommand
 	);
-	vscode.window.showInformationMessage(`SSH Control loaded. Config file: ${configManager.getConfigFilePath()}`);
 }
 
 export function deactivate() {}

src/sshConfigManager.ts

@@ -1,67 +1,105 @@
 import * as vscode from 'vscode';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { SSHConfig, SSHGroup, SSHHost } from './types';
 
 export class SSHConfigManager {
-  private configPath: string;
+  private readonly globalConfigPath: string;
+  private readonly workspaceConfigPath: string | null;
   private _onDidChangeConfig: vscode.EventEmitter<void> = new vscode.EventEmitter<void>();
   readonly onDidChangeConfig: vscode.Event<void> = this._onDidChangeConfig.event;
 
   constructor() {
-    this.configPath = this.getConfigPath();
+    this.globalConfigPath = path.join(os.homedir(), '.ssh-control', 'ssh-config.json');
+    
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    this.workspaceConfigPath = workspaceFolder 
+      ? path.join(workspaceFolder.uri.fsPath, 'ssh-config.json')
+      : null;
   }
 
-  private getConfigPath(): string {
-    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
-    if (workspaceFolder) {
-      return path.join(workspaceFolder.uri.fsPath, 'ssh-config.json');
-    }
+  private hasWorkspaceConfig(): boolean {
+    return this.workspaceConfigPath !== null && fs.existsSync(this.workspaceConfigPath);
+  }
+
+  private getSaveConfigPath(): string {
+    return this.hasWorkspaceConfig() ? this.workspaceConfigPath! : this.globalConfigPath;
+  }
 
-    const homeDir = require('os').homedir();
-    return path.join(homeDir, '.ssh-control', 'ssh-config.json');
+  private getDefaultConfig(): SSHConfig {
+    return {
+      groups: [
+        {
+          name: "Default",
+          defaultUser: "root",
+          defaultPort: 22,
+          defaultIdentityFile: "",
+          snippets: [
+            {
+              name: "System Status",
+              command: "uname -a && uptime && df -h"
+            },
+            {
+              name: "Process Monitor",
+              command: "top -n 1 | head -20"
+            }
+          ],
+          hosts: []
+        }
+      ]
+    };
   }
 
   private async ensureConfigExists(): Promise<void> {
-    if (!fs.existsSync(this.configPath)) {
-      const defaultConfig: SSHConfig = {
-        groups: [
-          {
-            name: "Default",
-            defaultUser: "root",
-            defaultPort: 22,
-            defaultIdentityFile: "",
-            snippets: [
-              {
-                name: "System Status",
-                command: "uname -a && uptime && df -h"
-              },
-              {
-                name: "Process Monitor",
-                command: "top -n 1 | head -20"
-              }
-            ],
-            hosts: []
-          }
-        ]
-      };
-
-      const configDir = path.dirname(this.configPath);
-      if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true });
+    const globalConfigDir = path.dirname(this.globalConfigPath);
+    if (!fs.existsSync(globalConfigDir)) {
+      fs.mkdirSync(globalConfigDir, { recursive: true });
+    }
+
+    if (!fs.existsSync(this.globalConfigPath) && !this.hasWorkspaceConfig()) {
+      await this.saveConfig(this.getDefaultConfig());
+    }
+  }
+
+  private mergeConfigs(globalConfig: SSHConfig, workspaceConfig: SSHConfig): SSHConfig {
+    const workspaceGroups = workspaceConfig.groups.map(group => ({
+      ...group,
+      name: `[Workspace] ${group.name}`
+    }));
+
+    return {
+      groups: [...globalConfig.groups, ...workspaceGroups]
+    };
+  }
+
+  private loadConfigFile(filePath: string): SSHConfig | null {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return null;
       }
-      
-      await this.saveConfig(defaultConfig);
+      const configData = fs.readFileSync(filePath, 'utf8');
+      return this.validateAndNormalizeConfig(JSON.parse(configData));
+    } catch (error) {
+      console.error(`Failed to load config from ${filePath}:`, error);
+      return null;
     }
   }
 
   async loadConfig(): Promise<SSHConfig> {
     await this.ensureConfigExists();
 
     try {
-      const configData = fs.readFileSync(this.configPath, 'utf8');
-      const config = JSON.parse(configData);
-      return this.validateAndNormalizeConfig(config);
+      const globalConfig = this.loadConfigFile(this.globalConfigPath) || { groups: [] };
+      
+      if (this.hasWorkspaceConfig()) {
+        const workspaceConfig = this.loadConfigFile(this.workspaceConfigPath!);
+        if (workspaceConfig) {
+          return this.mergeConfigs(globalConfig, workspaceConfig);
+        }
+      }
+
+      return globalConfig;
     } catch (error) {
       vscode.window.showErrorMessage(`Failed to load SSH config: ${error}`);
       return { groups: [] };
@@ -101,7 +139,8 @@ export class SSHConfigManager {
   async saveConfig(config: SSHConfig): Promise<void> {
     try {
       const configData = JSON.stringify(config, null, 2);
-      fs.writeFileSync(this.configPath, configData, 'utf8');
+      const targetPath = this.getSaveConfigPath();
+      fs.writeFileSync(targetPath, configData, 'utf8');
       this._onDidChangeConfig.fire();
     } catch (error) {
       vscode.window.showErrorMessage(`Failed to save SSH config: ${error}`);
@@ -187,6 +226,15 @@ export class SSHConfigManager {
   }
 
   getConfigFilePath(): string {
-    return this.configPath;
+    const paths = [];
+    if (this.hasWorkspaceConfig()) {
+      paths.push(`Workspace: ${this.workspaceConfigPath}`);
+    }
+    paths.push(`Global: ${this.globalConfigPath}`);
+    return paths.join(' | ');
+  }
+
+  getConfigFilePathForEditing(): string {
+    return this.getSaveConfigPath();
   }
 }