Add commands for managing passwords in keychain

gjsjohnmurray · gjsjohnmurray · commit 6f07f6b57069 · 2020-07-24T01:14:09.000+01:00
diff --git a/package.json b/package.json
@@ -60,7 +60,9 @@
   "activationEvents": [
     "onCommand:intersystems-community.servermanager.testPickServer",
     "onCommand:intersystems-community.servermanager.testPickServerFlushingCachedCredentials",
-    "onCommand:intersystems-community.servermanager.testPickServerDetailed"
+    "onCommand:intersystems-community.servermanager.testPickServerDetailed",
+    "onCommand:intersystems-community.servermanager.storePassword",
+    "onCommand:intersystems-community.servermanager.clearPassword"
   ],
   "contributes": {
     "configuration": {
@@ -180,6 +182,16 @@
       }
     },
     "commands": [
+      {
+        "command": "intersystems-community.servermanager.storePassword",
+        "category": "InterSystems Server Manager",
+        "title": "Store Password in Keychain"
+      },
+      {
+        "command": "intersystems-community.servermanager.clearPassword",
+        "category": "InterSystems Server Manager",
+        "title": "Clear Password from Keychain"
+      },
       {
         "command": "intersystems-community.servermanager.testPickServer",
         "category": "InterSystems Server Manager",
diff --git a/src/api/getServerSpec.ts b/src/api/getServerSpec.ts
@@ -7,7 +7,7 @@ interface CredentialSet {
     password: string
 }
 
-let credentialCache = new Map<string, CredentialSet>();
+export let credentialCache = new Map<string, CredentialSet>();
 
 export async function getServerSpec(name: string, scope?: vscode.ConfigurationScope, flushCredentialCache: boolean = false): Promise<ServerSpec | undefined> {
     if (flushCredentialCache) {
@@ -21,7 +21,6 @@ export async function getServerSpec(name: string, scope?: vscode.ConfigurationSc
     }
 
     server.name = name;
-    server.storePassword = server.storePassword ?? true;
     server.description = server.description || '';
     server.webServer.scheme = server.webServer.scheme || 'http';
     server.webServer.pathPrefix = server.webServer.pathPrefix || '';
@@ -51,7 +50,7 @@ export async function getServerSpec(name: string, scope?: vscode.ConfigurationSc
     if (server.username && !server.password) {
         if (credentialCache[name] && credentialCache[name].username === server.username) {
             server.password = credentialCache[name];
-        } else if (server.storePassword) {
+        } else {
             const keychain = new Keychain(name);
             const password = await keychain.getPassword().then(result => {
                 if (typeof result === 'string') {
diff --git a/src/api/pickServer.ts b/src/api/pickServer.ts
@@ -1,9 +1,7 @@
 import * as vscode from 'vscode';
-import { ServerSpec } from '../extension';
 import { getServerNames } from './getServerNames';
-import { getServerSpec } from './getServerSpec';
 
-export async function pickServer(scope?: vscode.ConfigurationScope, options: vscode.QuickPickOptions = {}, flushCredentialCache: boolean = false): Promise<ServerSpec | undefined> {
+export async function pickServer(scope?: vscode.ConfigurationScope, options: vscode.QuickPickOptions = {}): Promise<string | undefined> {
     const names = getServerNames(scope);
 
     let qpItems: vscode.QuickPickItem[] = [];
@@ -16,14 +14,6 @@ export async function pickServer(scope?: vscode.ConfigurationScope, options: vsc
         qpItems.push({label: element.name, description: element.description, detail: options?.matchOnDetail ? element.detail : undefined});
     });
     return await vscode.window.showQuickPick(qpItems, options).then(item => {
-        if (item) {
-            const name = item.label;
-            return getServerSpec(name, scope, flushCredentialCache).then(connSpec => {
-                if (connSpec) {
-                    connSpec.name = name;
-                }
-                return connSpec;
-            });
-        }
-    })
+        return item ? item.label : undefined;
+    });
 }
diff --git a/src/commands/managePasswords.ts b/src/commands/managePasswords.ts
@@ -0,0 +1,59 @@
+import * as vscode from 'vscode';
+import { extensionId } from '../extension';
+import { Keychain } from '../keychain';
+import { credentialCache } from '../api/getServerSpec';
+
+export async function storePassword() {
+    const name = await commonPickServer({matchOnDetail: true});
+    if (name) {
+        await vscode.window
+        .showInputBox({
+            password: true,
+            placeHolder: 'Password to store in keychain',
+            prompt: `For connection to InterSystems server '${name}'`,
+            validateInput: (value => {
+                return value.length > 0 ? '' : 'Mandatory field';
+            }),
+            ignoreFocusOut: true,
+        })
+        .then((password) => {
+            if (password) {
+                credentialCache[name] = undefined;
+                new Keychain(name).setPassword(password).then(() => {
+                    vscode.window.showInformationMessage(`Password for '${name}' stored in keychain.`);
+                });
+            }
+        })
+     
+    }
+}
+
+export async function clearPassword() {
+    const name = await commonPickServer({matchOnDetail: true});
+    if (name) {
+        credentialCache[name] = undefined;
+        const keychain = new Keychain(name);
+        if (!await keychain.getPassword()) {
+            vscode.window.showWarningMessage(`No password for '${name}' found in keychain.`);          
+        } else if (await keychain.deletePassword()) {
+            vscode.window.showInformationMessage(`Password for '${name}' removed from keychain.`);
+        } else {
+            vscode.window.showWarningMessage(`Failed to remove password for '${name}' from keychain.`);
+        }
+    }
+}
+
+async function commonPickServer(options?: vscode.QuickPickOptions): Promise<string | undefined> {
+    // Deliberately uses its own API to illustrate how other extensions would
+    const serverManagerExtension = vscode.extensions.getExtension(extensionId);
+    if (!serverManagerExtension) {
+        vscode.window.showErrorMessage(`Extension '${extensionId}' is not installed, or has been disabled.`)
+        return;
+    }
+    if (!serverManagerExtension.isActive) {
+        serverManagerExtension.activate();
+    }
+    const myApi = serverManagerExtension.exports;
+
+    return await myApi.pickServer(undefined, options);
+}
diff --git a/src/commands/testPickServer.ts b/src/commands/testPickServer.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { extensionId } from '../extension';
+import { extensionId, ServerSpec } from '../extension';
 
 export async function testPickServer() {
     await commonTestPickServer();
@@ -25,8 +25,11 @@ async function commonTestPickServer(options?: vscode.QuickPickOptions, flushCred
     }
     const myApi = serverManagerExtension.exports;
 
-    const connSpec = await myApi.pickServer(undefined, options, flushCredentialCache);
-    if (connSpec) {
-        vscode.window.showInformationMessage(`Picked server '${connSpec.name}' at ${connSpec.webServer.scheme}://${connSpec.webServer.host}:${connSpec.webServer.port}/${connSpec.webServer.pathPrefix} ${!connSpec.username ? 'with unauthenticated access' : 'as user ' + connSpec.username }.`, 'OK');
+    const name: string = await myApi.pickServer(undefined, options);
+    if (name) {
+        const connSpec: ServerSpec = await myApi.getServerSpec(name, undefined, flushCredentialCache);
+        if (connSpec) {
+            vscode.window.showInformationMessage(`Picked server '${connSpec.name}' at ${connSpec.webServer.scheme}://${connSpec.webServer.host}:${connSpec.webServer.port}/${connSpec.webServer.pathPrefix} ${!connSpec.username ? 'with unauthenticated access' : 'as user ' + connSpec.username }.`, 'OK');
+        }
     }
 }
diff --git a/src/extension.ts b/src/extension.ts
@@ -6,6 +6,7 @@ import { testPickServer, testPickServerWithoutCachedCredentials as testPickServe
 import { pickServer } from './api/pickServer';
 import { getServerNames } from './api/getServerNames';
 import { getServerSpec } from './api/getServerSpec';
+import { storePassword, clearPassword } from './commands/managePasswords';
 
 export interface ServerName {
     name: string,
@@ -25,14 +26,24 @@ export interface ServerSpec {
     webServer: WebServerSpec,
     username: string,
     password: string,
-    storePassword: boolean,
     description: string
 }
 
 export function activate(context: vscode.ExtensionContext) {
 
 
 	// Register the commands
+	context.subscriptions.push(
+		vscode.commands.registerCommand(`${extensionId}.storePassword`, () => {
+            storePassword();
+        })
+    );
+	context.subscriptions.push(
+		vscode.commands.registerCommand(`${extensionId}.clearPassword`, () => {
+            clearPassword();
+        })
+    );
+
 	context.subscriptions.push(
 		vscode.commands.registerCommand(`${extensionId}.testPickServer`, () => {
             testPickServer();
@@ -50,16 +61,16 @@ export function activate(context: vscode.ExtensionContext) {
     );
 
     let api = {
-        async pickServer(scope?: vscode.ConfigurationScope, options: vscode.QuickPickOptions = {}, flushCredentialCache: boolean = false): Promise<ServerSpec | undefined> {
-            return await pickServer(scope, options, flushCredentialCache);
+        async pickServer(scope?: vscode.ConfigurationScope, options: vscode.QuickPickOptions = {}): Promise<string | undefined> {
+            return await pickServer(scope, options);
 
         },
         getServerNames(scope?: vscode.ConfigurationScope): ServerName[] {
             return getServerNames(scope);
         },
 
-        async getServerSpec(name: string, scope?: vscode.ConfigurationScope): Promise<ServerSpec | undefined> {
-            return await getServerSpec(name, scope);
+        async getServerSpec(name: string, scope?: vscode.ConfigurationScope, flushCredentialCache: boolean = false): Promise<ServerSpec | undefined> {
+            return await getServerSpec(name, scope, flushCredentialCache);
         }
 
     };

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`import * as vscode from 'vscode';`
`2`		`-import { extensionId } from '../extension';`
	`2`	`+import { extensionId, ServerSpec } from '../extension';`
`3`	`3`
`4`	`4`	`export async function testPickServer() {`
`5`	`5`	`await commonTestPickServer();`
`@@ -25,8 +25,11 @@ async function commonTestPickServer(options?: vscode.QuickPickOptions, flushCred`
`25`	`25`	`}`
`26`	`26`	`const myApi = serverManagerExtension.exports;`
`27`	`27`
`28`		`- const connSpec = await myApi.pickServer(undefined, options, flushCredentialCache);`
`29`		`- if (connSpec) {`
`30`		- vscode.window.showInformationMessage(`Picked server '${connSpec.name}' at ${connSpec.webServer.scheme}://${connSpec.webServer.host}:${connSpec.webServer.port}/${connSpec.webServer.pathPrefix} ${!connSpec.username ? 'with unauthenticated access' : 'as user ' + connSpec.username }.`, 'OK');
	`28`	`+ const name: string = await myApi.pickServer(undefined, options);`
	`29`	`+ if (name) {`
	`30`	`+ const connSpec: ServerSpec = await myApi.getServerSpec(name, undefined, flushCredentialCache);`
	`31`	`+ if (connSpec) {`
	`32`	+ vscode.window.showInformationMessage(`Picked server '${connSpec.name}' at ${connSpec.webServer.scheme}://${connSpec.webServer.host}:${connSpec.webServer.port}/${connSpec.webServer.pathPrefix} ${!connSpec.username ? 'with unauthenticated access' : 'as user ' + connSpec.username }.`, 'OK');
	`33`	`+ }`
`31`	`34`	`}`
`32`	`35`	`}`