feat: Cache interactive login credentials

src/plugins/login/azureLoginPlugin.ts

@@ -2,13 +2,17 @@ import Serverless from "serverless";
 import { AzureLoginOptions, AzureLoginService } from "../../services/loginService";
 import { AzureBasePlugin } from "../azureBasePlugin";
 import { loginHooks } from "./loginHooks";
+import { SimpleFileTokenCache } from "./utils/simpleFileTokenCache";
 
 export class AzureLoginPlugin extends AzureBasePlugin<AzureLoginOptions> {
+  private fileTokenCache: SimpleFileTokenCache;
   public hooks: { [eventName: string]: Promise<any> };
 
   public constructor(serverless: Serverless, options: AzureLoginOptions) {
     super(serverless, options);
 
+    this.fileTokenCache = new SimpleFileTokenCache();
+
     this.hooks = {};
     for (const h of loginHooks) {
       this.hooks[`before:${h}`] = this.login.bind(this);
@@ -24,12 +28,13 @@ export class AzureLoginPlugin extends AzureBasePlugin<AzureLoginOptions> {
     this.log("Logging into Azure");
 
     try {
-      const authResult = await AzureLoginService.login();
+      const authResult = await AzureLoginService.login({tokenCache: this.fileTokenCache});
       this.serverless.variables["azureCredentials"] = authResult.credentials;
       // Use environment variable for sub ID or use the first subscription in the list (service principal can
       // have access to more than one subscription)
       this.serverless.variables["subscriptionId"] = this.options.subscriptionId || process.env.azureSubId || this.serverless.service.provider["subscriptionId"] || authResult.subscriptions[0].id;
       this.serverless.cli.log(`Using subscription ID: ${this.serverless.variables["subscriptionId"]}`);
+      this.fileTokenCache.addSubs(authResult.subscriptions);
     }
     catch (e) {
       this.log("Error logging into azure");

src/plugins/login/utils/simpleFileTokenCache.ts

@@ -0,0 +1,92 @@
+import * as fs from "fs";
+import path from "path";
+import os from "os";
+
+const CONFIG_DIRECTORY = path.join(os.homedir(), ".azure");
+const SLS_TOKEN_FILE = path.join(CONFIG_DIRECTORY, "slsTokenCache.json");
+
+export class SimpleFileTokenCache {
+  private tokens: any[] = [];
+  private subscriptions: any[] = [];
+  public constructor() {
+    console.log("new Simple file toke cache");
+    this.load();
+  }
+
+  public isSecureCache() {
+    throw "isSecureCache not implemented";
+  }
+
+  public add(entries: any, cb: any) {
+    console.log("adding")
+    this.tokens.push(...entries);
+    this.save();
+    cb();
+  }
+
+  public addSubs(entries: any) {
+    console.log("adding")
+    this.subscriptions.push(...entries);
+    this.save();
+  }
+
+  public remove(entries: any, cb: any) {
+    console.log("remove")
+    this.tokens = this.tokens.filter(e => {
+      return !Object.keys(entries[0]).every(key => e[key] === entries[0][key]);
+    });
+    this.save();
+    cb();
+  }
+
+  public clear(cb: any) {
+    console.log("clear");
+    this.tokens = [];
+    this.subscriptions = [];
+    this.save();
+    cb();
+  }
+
+  public find(query, cb) {
+    console.log("find")
+    let result = this.tokens.filter(e => {
+      return Object.keys(query).every(key => e[key] === query[key]);
+    });
+    cb(null, result);
+    return result;
+  }
+
+  public empty() {
+    console.log("empty")
+    // this.deleteOld();
+    return this.tokens.length === 0;
+  }
+
+  public first() {
+    return this.tokens[0];
+  }
+
+  public listSubscriptions() {
+    return this.subscriptions;
+  }
+
+  private load() {
+    try {
+      let savedCache = JSON.parse(fs.readFileSync(SLS_TOKEN_FILE).toString());
+      this.tokens = savedCache.tokens;
+      this.tokens.map(t => t.expiresOn = new Date(t.expiresOn))
+      this.subscriptions = savedCache.subscriptions;
+    } catch (e) {}
+  }
+
+  public save() {
+    console.log("save")
+    fs.writeFileSync(SLS_TOKEN_FILE, JSON.stringify({tokens: this.tokens, subscriptions: this.subscriptions}));
+  }
+
+  private deleteOld() {
+    this.tokens = this.tokens.filter(
+      t => t.expiresOn > Date.now() - 5 * 60 * 1000
+    );
+  }
+}

src/services/baseService.ts

@@ -14,6 +14,7 @@ import {
 } from "../models/serverless";
 import { Guard } from "../shared/guard";
 import { Utils } from "../shared/utils";
+import { SimpleFileTokenCache } from "../plugins/login/utils/simpleFileTokenCache";
 
 export abstract class BaseService {
   protected baseUrl: string;
@@ -124,7 +125,7 @@ export abstract class BaseService {
    * Get the access token from credentials token cache
    */
   protected getAccessToken(): string {
-    return (this.credentials.tokenCache as any)._entries[0].accessToken;
+    return (this.credentials.tokenCache as SimpleFileTokenCache).first().accessToken;
   }
 
   /**

src/services/loginService.ts

@@ -5,8 +5,10 @@ import {
   loginWithServicePrincipalSecretWithAuthResponse,
   AuthResponse,
   AzureTokenCredentialsOptions,
-  InteractiveLoginOptions,  
+  InteractiveLoginOptions,
+  DeviceTokenCredentials,  
 } from "@azure/ms-rest-nodeauth";
+import { SimpleFileTokenCache } from "../plugins/login/utils/simpleFileTokenCache";
 
 export interface AzureLoginOptions extends Serverless.Options {
   subscriptionId?: string;
@@ -32,9 +34,25 @@ export class AzureLoginService {
     }
   }
 
-  public static async interactiveLogin(options: InteractiveLoginOptions): Promise<AuthResponse> {
-    await open("https://microsoft.com/devicelogin");
-    return await interactiveLoginWithAuthResponse(options);
+  public static async interactiveLogin(options?: InteractiveLoginOptions): Promise<AuthResponse> {
+    // await open("https://microsoft.com/devicelogin");
+    // return await interactiveLoginWithAuthResponse(options);
+    var authResp: AuthResponse = {credentials: undefined, subscriptions: []};
+    if(!(options.tokenCache as SimpleFileTokenCache).empty()){
+      console.log("exisitng token");
+      var devOptions = {
+        tokenCache: options.tokenCache as SimpleFileTokenCache
+      }
+      // I don't think DeviceTokenCredentials is what we want... maybe MSITokenCredentials?
+      authResp.credentials = new DeviceTokenCredentials(undefined, undefined, devOptions.tokenCache.first().userId, undefined, undefined, options.tokenCache);
+      authResp.subscriptions = devOptions.tokenCache.listSubscriptions();
+    } else {
+      console.log("need to do interactive login now");
+      await open("https://microsoft.com/devicelogin");
+      authResp = await interactiveLoginWithAuthResponse(options); 
+    }
+    return authResp;//iOptions ? interactiveLoginWithAuthResponse(iOptions) : interactiveLoginWithAuthResponse();
+
   }
 
   public static async servicePrincipalLogin(clientId: string, secret: string, tenantId: string, options: AzureTokenCredentialsOptions): Promise<AuthResponse> {