feat: uploads sync (#30)

fix #27

Author: MoustaphaCamara

crypto.go

@@ -73,65 +73,36 @@ func deriveProfileKey(passphrase string, salt []byte) []byte {
 	)
 }
 
-func encryptBytes(key []byte, plaintext []byte) (string, error) {
+func encodeToBase64(key []byte, plaintext []byte) (string, error) {
 	// XChaCha20-Poly1305 requires a unique nonce for each encryption.
 	// The nonce is not secret, so we store it next to the ciphertext.
 	// Stored format:
 	//   base64(nonce || ciphertext)
-	aead, err := chacha20poly1305.NewX(key)
-	if err != nil {
-		return "", fmt.Errorf("Create cipher: %w", err)
-	}
-
-	nonce, err := randomBytes(aead.NonceSize())
+	payload, err := encryptRawBytes(key, plaintext)
 	if err != nil {
 		return "", err
 	}
 
-	ciphertext := aead.Seal(nil, nonce, plaintext, nil)
-
-	payload := make([]byte, 0, len(nonce)+len(ciphertext))
-	payload = append(payload, nonce...)
-	payload = append(payload, ciphertext...)
-
 	return base64Encoding.EncodeToString(payload), nil
 }
 
-func decryptBytes(key []byte, encoded string) ([]byte, error) {
+func decodeFromBase64(key []byte, encoded string) ([]byte, error) {
 	// The encrypted payload is stored as base64(nonce || ciphertext).
 	// Split the nonce back out before opening the ciphertext.
 	payload, err := base64Encoding.DecodeString(encoded)
 	if err != nil {
 		return nil, fmt.Errorf("Decode ciphertext: %w", err)
 	}
 
-	aead, err := chacha20poly1305.NewX(key)
-	if err != nil {
-		return nil, fmt.Errorf("Create cipher: %w", err)
-	}
-
-	nonceSize := aead.NonceSize()
-	if len(payload) < nonceSize {
-		return nil, fmt.Errorf("Ciphertext is too short")
-	}
-
-	nonce := payload[:nonceSize]
-	ciphertext := payload[nonceSize:]
-
-	plaintext, err := aead.Open(nil, nonce, ciphertext, nil)
-	if err != nil {
-		return nil, fmt.Errorf("Decrypt: %w", err)
-	}
-
-	return plaintext, nil
+	return decryptRawBytes(key, payload)
 }
 
 func encryptString(key []byte, plaintext string) (string, error) {
-	return encryptBytes(key, []byte(plaintext))
+	return encodeToBase64(key, []byte(plaintext))
 }
 
 func decryptString(key []byte, encoded string) (string, error) {
-	plaintext, err := decryptBytes(key, encoded)
+	plaintext, err := decodeFromBase64(key, encoded)
 	if err != nil {
 		return "", err
 	}
@@ -192,3 +163,46 @@ func unlockProfileCryptoParams(profile *ProfileEntry, passphrase string) ([]byte
 
 	return key, nil
 }
+
+// encryptRawBytes encrypts binary data with chacha20poly1305
+func encryptRawBytes(key []byte, plaintext []byte) ([]byte, error) {
+	aead, err := chacha20poly1305.NewX(key)
+	if err != nil {
+		return nil, fmt.Errorf("Create cipher: %w", err)
+	}
+
+	nonce, err := randomBytes(aead.NonceSize())
+	if err != nil {
+		return nil, err
+	}
+
+	ciphertext := aead.Seal(nil, nonce, plaintext, nil)
+
+	payload := make([]byte, 0, len(nonce)+len(ciphertext))
+	payload = append(payload, nonce...)
+	payload = append(payload, ciphertext...)
+
+	return payload, nil
+}
+
+func decryptRawBytes(key []byte, payload []byte) ([]byte, error) {
+	aead, err := chacha20poly1305.NewX(key)
+	if err != nil {
+		return nil, fmt.Errorf("Create cipher: %w", err)
+	}
+
+	nonceSize := aead.NonceSize()
+	if len(payload) < nonceSize {
+		return nil, fmt.Errorf("Ciphertext is too short")
+	}
+
+	nonce := payload[:nonceSize]
+	ciphertext := payload[nonceSize:]
+
+	plaintext, err := aead.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return nil, fmt.Errorf("Decrypt: %w", err)
+	}
+
+	return plaintext, nil
+}

elabftw_client.go

@@ -14,6 +14,7 @@ import (
 	"crypto/tls"
 	"database/sql"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -32,6 +33,12 @@ type ElabftwInfo struct {
 	Raw map[string]any `json:"raw"`
 }
 
+type elabftwErrorResponse struct {
+	Code        int    `json:"code"`
+	Message     string `json:"message"`
+	Description string `json:"description"`
+}
+
 func (a *App) loadElabftwClientConfig(profileUUID string, instanceID int64) (*elabftwClientConfig, error) {
 	profileUUID, err := a.requireUnlockedProfile(profileUUID)
 	if err != nil {
@@ -91,18 +98,24 @@ func (a *App) loadElabftwClientConfig(profileUUID string, instanceID int64) (*el
 	return &cfg, nil
 }
 
-func elabftwHTTPClient(verifyTLS bool) *http.Client {
+func elabftwHTTPClient(verifyTLS bool, longTimeout bool) *http.Client {
 	transport := &http.Transport{
 		TLSClientConfig: &tls.Config{
 			// Only false when the user explicitly disables TLS verification.
 			InsecureSkipVerify: !verifyTLS,
 		},
 	}
 
-	// timeout prevents the desktop app from hanging forever if the server is unreachable
-	// Transport carries our TLS configuration, including whether to verify certificates
+	// regular API requests should fail quickly if the server is unreachable
+	// but Uploads get a much longer timeout because the deadline covers the entire
+	// request, including sending the file, which may take several minutes on
+	// slower connections
+	timeout := 30 * time.Second // 30 sec
+	if longTimeout {
+		timeout = 10 * time.Minute // 10 mins
+	}
 	return &http.Client{
-		Timeout:   30 * time.Second,
+		Timeout:   timeout,
 		Transport: transport,
 	}
 }
@@ -111,18 +124,17 @@ func (a *App) elabftwRequest(
 	profileUUID string,
 	instanceID int64,
 	method string,
-	apiPath string,
+	path string,
 	body io.Reader,
+	isUpload bool,
+	headers ...map[string]string,
 ) (*http.Response, error) {
 	cfg, err := a.loadElabftwClientConfig(profileUUID, instanceID)
 	if err != nil {
 		return nil, err
 	}
 
-	apiPath = "/" + strings.TrimLeft(apiPath, "/")
-	url := elabftwAPIBaseURL(cfg.SiteURL) + apiPath
-
-	req, err := http.NewRequest(method, url, body)
+	req, err := http.NewRequest(method, elabftwAPIBaseURL(cfg.SiteURL)+path, body)
 	if err != nil {
 		return nil, fmt.Errorf("create elabftw request: %w", err)
 	}
@@ -134,9 +146,17 @@ func (a *App) elabftwRequest(
 		req.Header.Set("Content-Type", "application/json")
 	}
 
-	resp, err := elabftwHTTPClient(cfg.VerifyTLS).Do(req)
+	for _, h := range headers {
+		for k, v := range h {
+			req.Header.Set(k, v)
+		}
+	}
+
+	client := elabftwHTTPClient(cfg.VerifyTLS, isUpload)
+
+	resp, err := client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("call elabftw %s %s: %w", method, apiPath, err)
+		return nil, fmt.Errorf("call elabftw %s %s: %w", method, path, err)
 	}
 
 	return resp, nil
@@ -156,11 +176,26 @@ func decodeElabftwJSONResponse(resp *http.Response, target any) error {
 
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
 		body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+
+		var apiErr elabftwErrorResponse
+		if err := json.Unmarshal(body, &apiErr); err == nil {
+			// Prefer a detailed description if available.
+			if apiErr.Description != "" {
+				return errors.New(apiErr.Description)
+			}
+
+			if apiErr.Message != "" {
+				return errors.New(apiErr.Message)
+			}
+		}
+
+		// Fallback if the response isn't JSON.
 		msg := strings.TrimSpace(string(body))
-		if msg == "" {
-			return fmt.Errorf("elabftw returned HTTP %d", resp.StatusCode)
+		if msg != "" {
+			return errors.New(msg)
 		}
-		return fmt.Errorf("elabftw returned HTTP %d: %s", resp.StatusCode, msg)
+
+		return fmt.Errorf("eLabFTW returned HTTP %d", resp.StatusCode)
 	}
 
 	if target == nil {
@@ -184,7 +219,7 @@ func jsonBody(v any) (*bytes.Reader, error) {
 
 /* ---------- INFO ENDPOINT ---------- */
 func (a *App) FetchElabftwInfo(profileUUID string, instanceID int64) (*ElabftwInfo, error) {
-	resp, err := a.elabftwRequest(profileUUID, instanceID, http.MethodGet, "/info", nil)
+	resp, err := a.elabftwRequest(profileUUID, instanceID, http.MethodGet, "/info", nil, false)
 	if err != nil {
 		return nil, err
 	}

frontend/eslint.config.js

@@ -22,16 +22,12 @@ export default [
   },
 
   {
-    files: ['**/*.svelte'],
+    files: ['**/*.svelte', '**/*.svelte.ts'],
     languageOptions: {
       parser: svelteParser,
       parserOptions: {
         parser: ts.parser,
       },
-      // rules: {
-      //   ...svelte.configs.recommended.rules,
-      //   'no-unused-vars': 'warn',
-      // },
     },
   },
 ];

frontend/src/App.svelte

@@ -12,13 +12,15 @@ SPDX-License-Identifier: GPL-3.0-or-later
   import ProfileSelector from './components/ProfileSelector/ProfileSelector.svelte';
   import MainApp from './components/MainApp.svelte';
   import logo from './assets/images/elabftw-logo-white-800px.png';
+  import Alert from './components/Alert.svelte';
 
   let appState = $state('select-profile');
   let activeProfile = $state(null);
   let activeProfileName = $state(null);
 </script>
 
 <main>
+  <Alert />
   {#if appState === 'select-profile'}
     <img alt='eLabFTW logo' id='logo' src={logo} style='width: 200px;' />
     <ProfileSelector

frontend/src/components/Alert.svelte

@@ -9,15 +9,8 @@ SPDX-License-Identifier: GPL-3.0-or-later
 -->
 
 <script lang='ts'>
-  export type AlertState = {
-    type: 'success' | 'error' | 'warning' | 'info';
-    message: string;
-  };
+  import { alert, showAlert } from "./stores/alert.svelte";
 
-  type AlertProps = Partial<AlertState>;
-
-  let { type = 'success', message = '' }: AlertProps = $props();
-  let visible = $state(true);
   let closing = $state(false);
 
   /* allow having the Alert at the top left of every component (not depend of its parent) */
@@ -28,12 +21,8 @@ SPDX-License-Identifier: GPL-3.0-or-later
     };
   }
 
-  // Re-show the alert when the parent provides a new message.
   $effect(() => {
-    if (message) {
-      visible = true;
-      closing = false;
-    }
+    if (alert.current) closing = false;
   });
 
   function close() {
@@ -42,19 +31,19 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
   function onAnimationEnd() {
     if (closing) {
-      visible = false;
       closing = false;
+      showAlert(null);
     }
   }
 </script>
 
-{#if message && visible}
+{#if alert.current}
   <div
     use:portal
-    class={`alert alert-${type} alert-floating ${closing ? 'alert-closing' : ''}`}
+    class={`alert alert-${alert.current.type} alert-floating ${closing ? 'alert-closing' : ''}`}
     onanimationend={onAnimationEnd}
   >
-    <strong>{message}</strong>
+    <strong>{alert.current.message}</strong>
     <button class='alert-close' type='button' aria-label='Close alert' onclick={close}>&#x2717;</button>
   </div>
 {/if}