feat(sltt-app): auto-login to samba drive (#45)

What issue(s) is this trying to resolve?
* feat(sltt-app): detect when samba drive needs user to login to the
router again #44

How does it all work?
* in handleProbeConnections, determine if the url has an ipaddress and
if so, issue an OS command (e.g. net use on windows) to authorize the
connection once.

Steps for testing
Scenario 1 - newer windows computer
1. connect newer windows (11) computer to network storage samba drive
(e.g. via wifi)
2. reboot computer
3. launch latest sltt-app (with these changes). Expect it to detect the
local team storage and show an icon that allows an admin to connect
and/or turn it on for the project.

Scenario 2 - older windows computer
1. repeat on older Windows 10

Scenario 3: repeat for newer macos computer
Scenario 4: repeat for older macos computer

ticket: #44
commit-convention: https://www.conventionalcommits.org/en/v1.0.0/

Author: ericpyle

storage/connections.ts

@@ -1,8 +1,37 @@
 import { access, appendFile, readFile } from 'fs/promises'
 import { constants, ensureDir } from 'fs-extra'
+import { exec } from 'child_process'
+import { promisify } from 'util'
 import { pathToFileURL, fileURLToPath } from 'url'
 import { AddStorageProjectArgs, ConnectToUrlArgs, ConnectToUrlResponse, GetStorageProjectsArgs, GetStorageProjectsResponse, ProbeConnectionsArgs, ProbeConnectionsResponse, RemoveStorageProjectArgs } from './connections.d'
 
+const execPromise = promisify(exec)
+
+async function connectToSambaWithCommand(command: string): Promise<boolean> {
+    try {
+        const { stdout, stderr } = await execPromise(command)
+        console.log(`Successfully connected to Samba drive (${command})`)
+        console.log(stdout)
+        return true
+    } catch (error) {
+        console.error(`Error connecting to Samba drive (${command}): ${error.message}`)
+        return false
+    }
+}
+
+async function connectToSamba(sambaIP: string): Promise<boolean> {
+    if (process.platform === 'win32') {
+        const command = `net use \\\\${sambaIP}\\sltt-app /user:guest ""`
+        return await connectToSambaWithCommand(command)
+    } else if (process.platform === 'darwin') {
+        const command = `mount_smbfs //guest:@${sambaIP}/sltt-app /Volumes/sltt-app`
+        return await connectToSambaWithCommand(command)
+    } else {
+        console.error('Unsupported platform')
+        return false
+    }
+}
+
 export const handleGetStorageProjects = async (defaultStoragePath: string, { clientId }: GetStorageProjectsArgs): Promise<GetStorageProjectsResponse> => {
     await ensureDir(defaultStoragePath)
     console.log(`handleGetStorageProjects by client '${clientId}'`)
@@ -49,21 +78,31 @@ export const handleRemoveStorageProject = async (defaultStoragePath: string, { u
     }
 }
 
+let lastSambaIP = ''
+
 export const handleProbeConnections = async (defaultStoragePath: string, { urls }: ProbeConnectionsArgs): Promise<ProbeConnectionsResponse> => {
 
     await ensureDir(defaultStoragePath)
     const connections = await Promise.all(
-        [pathToFileURL(defaultStoragePath).href, ...(urls || [])].map(
-            async (url) => {
-                let filePath = ''
-                try {
-                    filePath = fileURLToPath(url)
-                } catch (e) {
-                    console.error(`fileURLToPath(${url}) error`, e)
-                    return { url, accessible: false, error: e.message }
+        [pathToFileURL(defaultStoragePath).href, ...(urls || [])]
+            .map(
+                async (url) => {
+                    let filePath = ''
+                    try {
+                        const urlObj = new URL(url)
+                        const ipAddress = urlObj.hostname
+                        if (urlObj.protocol === 'file:'
+                            && ipAddress && ipAddress !== lastSambaIP) {
+                            lastSambaIP = ipAddress
+                            await connectToSamba(ipAddress)
+                        }
+                        filePath = fileURLToPath(url)
+                    } catch (e) {
+                        console.error(`fileURLToPath(${url}) error`, e)
+                        return { url, accessible: false, error: e.message }
+                    }
+                    return { url, accessible: await canAccess(filePath) }
                 }
-                return { url, accessible: await canAccess(filePath) }
-            }
         )
     )
     return connections