User interface implementation

hub/src/main/java/cloud/katta/core/DefaultDeviceSetupCallback.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2025 shift7 GmbH. All rights reserved.
+ */
+
+package cloud.katta.core;
+
+import ch.cyberduck.core.Credentials;
+import ch.cyberduck.core.Host;
+import ch.cyberduck.core.LocaleFactory;
+import ch.cyberduck.core.LoginCallback;
+import ch.cyberduck.core.LoginOptions;
+import ch.cyberduck.core.StringAppender;
+import ch.cyberduck.core.exception.LoginCanceledException;
+
+import cloud.katta.model.AccountKeyAndDeviceName;
+import cloud.katta.workflows.exceptions.AccessException;
+
+public class DefaultDeviceSetupCallback implements DeviceSetupCallback {
+
+    private final LoginCallback prompt;
+
+    public DefaultDeviceSetupCallback(final LoginCallback prompt) {
+        this.prompt = prompt;
+    }
+
+    @Override
+    public AccountKeyAndDeviceName displayAccountKeyAndAskDeviceName(final Host bookmark, final AccountKeyAndDeviceName accountKeyAndDeviceName) throws AccessException {
+        try {
+            final Credentials input = prompt.prompt(bookmark, accountKeyAndDeviceName.accountKey(),
+                    LocaleFactory.localizedString("Account Key", "Hub"),
+                    new StringAppender()
+                            .append(LocaleFactory.localizedString("On first login, every user gets a unique Account Key", "Hub"))
+                            .append(LocaleFactory.localizedString("Your Account Key is required to login from other apps or browsers", "Hub"))
+                            .append(LocaleFactory.localizedString("You can see a list of authorized apps on your profile page", "Hub")).toString(),
+                    new LoginOptions()
+                            .usernamePlaceholder(LocaleFactory.localizedString("Account Key", "Hub"))
+                            // Account key not editable
+                            .user(false)
+                            .passwordPlaceholder(accountKeyAndDeviceName.deviceName())
+                            // Input device name
+                            .password(true)
+                            .keychain(true)
+            );
+            return new AccountKeyAndDeviceName()
+                    .withAddToKeychain(input.isSaved())
+                    .withDeviceName(input.getUsername())
+                    .withAccountKey(input.getPassword());
+        }
+        catch(LoginCanceledException e) {
+            throw new AccessException(e);
+        }
+    }
+
+    @Override
+    public AccountKeyAndDeviceName askForAccountKeyAndDeviceName(final Host bookmark, final String initialDeviceName) throws AccessException {
+        try {
+            final Credentials input = prompt.prompt(bookmark, initialDeviceName,
+                    LocaleFactory.localizedString("Authorization Required", "Hub"),
+                    new StringAppender()
+                            .append(LocaleFactory.localizedString("This is your first login on this device.", "Hub"))
+                            .append(LocaleFactory.localizedString("Your Account Key is required to link this browser to your account.", "Hub")).toString(),
+                    new LoginOptions()
+                            .usernamePlaceholder(LocaleFactory.localizedString("Device Name", "Hub"))
+                            // Customize device name
+                            .user(true)
+                            .passwordPlaceholder(LocaleFactory.localizedString("Account Key", "Hub"))
+                            // Input account key
+                            .password(true)
+                            .keychain(true)
+            );
+            return new AccountKeyAndDeviceName()
+                    .withAddToKeychain(input.isSaved())
+                    .withDeviceName(input.getUsername())
+                    .withAccountKey(input.getPassword());
+        }
+        catch(LoginCanceledException e) {
+            throw new AccessException(e);
+        }
+    }
+}

hub/src/main/java/cloud/katta/core/DeviceSetupCallback.java

@@ -17,10 +17,10 @@ public interface DeviceSetupCallback {
     /**
      * Prompt user for device name
      *
-     * @return Device name
+     * @return Account key and device name
      * @throws AccessException Canceled prompt by user
      */
-    String displayAccountKeyAndAskDeviceName(Host bookmark, AccountKeyAndDeviceName accountKeyAndDeviceName) throws AccessException;
+    AccountKeyAndDeviceName displayAccountKeyAndAskDeviceName(Host bookmark, AccountKeyAndDeviceName accountKeyAndDeviceName) throws AccessException;
 
     /**
      * Prompt user for existing account key
@@ -50,7 +50,7 @@ default UserKeys generateUserKeys() {
 
     DeviceSetupCallback disabled = new DeviceSetupCallback() {
         @Override
-        public String displayAccountKeyAndAskDeviceName(final Host bookmark, final AccountKeyAndDeviceName accountKeyAndDeviceName) throws AccessException {
+        public AccountKeyAndDeviceName displayAccountKeyAndAskDeviceName(final Host bookmark, final AccountKeyAndDeviceName accountKeyAndDeviceName) throws AccessException {
             throw new AccessException("Disabled");
         }
 

hub/src/main/java/cloud/katta/crypto/uvf/UvfMetadataPayloadPasswordCallback.java

@@ -15,19 +15,18 @@
 
 public class UvfMetadataPayloadPasswordCallback extends DisabledPasswordCallback {
 
-    private final UvfMetadataPayload payload;
+    private final String payloadJson;
 
-    public UvfMetadataPayloadPasswordCallback(final UvfMetadataPayload payload) {
-        this.payload = payload;
+    public UvfMetadataPayloadPasswordCallback(final UvfMetadataPayload payload) throws JsonProcessingException {
+        this(payload.toJSON());
+    }
+
+    public UvfMetadataPayloadPasswordCallback(final String payloadJson) {
+        this.payloadJson = payloadJson;
     }
 
     @Override
     public Credentials prompt(final Host bookmark, final String title, final String reason, final LoginOptions options) throws LoginCanceledException {
-        try {
-            return new VaultCredentials(payload.toJSON());
-        }
-        catch(JsonProcessingException e) {
-            throw new LoginCanceledException(e);
-        }
+        return new VaultCredentials(payloadJson);
     }
 }

hub/src/main/java/cloud/katta/model/AccountKeyAndDeviceName.java

@@ -7,6 +7,7 @@
 public class AccountKeyAndDeviceName {
     private String accountKey;
     private String deviceName;
+    private boolean addToKeychain;
 
     public String accountKey() {
         return accountKey;
@@ -16,6 +17,10 @@ public String deviceName() {
         return deviceName;
     }
 
+    public boolean addToKeychain() {
+        return addToKeychain;
+    }
+
     public AccountKeyAndDeviceName withAccountKey(final String accountKey) {
         this.accountKey = accountKey;
         return this;
@@ -25,4 +30,9 @@ public AccountKeyAndDeviceName withDeviceName(final String deviceName) {
         this.deviceName = deviceName;
         return this;
     }
+
+    public AccountKeyAndDeviceName withAddToKeychain(final boolean addToKeychain) {
+        this.addToKeychain = addToKeychain;
+        return this;
+    }
 }

hub/src/main/java/cloud/katta/protocols/hub/HubAwareProfile.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 shift7 GmbH. All rights reserved.
+ */
+
+package cloud.katta.protocols.hub;
+
+import ch.cyberduck.core.Profile;
+import ch.cyberduck.core.Protocol;
+
+import cloud.katta.client.model.ConfigDto;
+import cloud.katta.model.StorageProfileDtoWrapper;
+import cloud.katta.protocols.hub.serializer.HubConfigDtoDeserializer;
+import cloud.katta.protocols.hub.serializer.StorageProfileDtoWrapperDeserializer;
+
+public final class HubAwareProfile extends Profile {
+
+    public HubAwareProfile(final Protocol parent, final ConfigDto configDto, final StorageProfileDtoWrapper storageProfile) {
+        super(parent, new HubConfigDtoDeserializer(configDto, new StorageProfileDtoWrapperDeserializer(storageProfile)));
+    }
+}

hub/src/main/java/cloud/katta/protocols/hub/HubGrantAccessSchedulerService.java

@@ -8,7 +8,7 @@
 import ch.cyberduck.core.HostPasswordStore;
 import ch.cyberduck.core.PasswordCallback;
 import ch.cyberduck.core.exception.BackgroundException;
-import ch.cyberduck.core.preferences.HostPreferences;
+import ch.cyberduck.core.preferences.HostPreferencesFactory;
 import ch.cyberduck.core.shared.ThreadPoolSchedulerFeature;
 
 import org.apache.logging.log4j.LogManager;
@@ -18,14 +18,14 @@
 
 import cloud.katta.client.ApiException;
 import cloud.katta.client.api.DeviceResourceApi;
+import cloud.katta.client.api.StorageProfileResourceApi;
 import cloud.katta.client.api.UsersResourceApi;
 import cloud.katta.client.api.VaultResourceApi;
 import cloud.katta.client.model.Role;
 import cloud.katta.client.model.VaultDto;
 import cloud.katta.crypto.UserKeys;
 import cloud.katta.protocols.hub.exceptions.HubExceptionMappingService;
 import cloud.katta.workflows.DeviceKeysServiceImpl;
-import cloud.katta.workflows.GrantAccessService;
 import cloud.katta.workflows.GrantAccessServiceImpl;
 import cloud.katta.workflows.UserKeysServiceImpl;
 import cloud.katta.workflows.exceptions.AccessException;
@@ -36,40 +36,32 @@ public class HubGrantAccessSchedulerService extends ThreadPoolSchedulerFeature<H
 
     private final HubSession session;
     private final HostPasswordStore keychain;
-    private final VaultResourceApi vaults;
-    private final UsersResourceApi users;
-    private final DeviceResourceApi devices;
-    private final GrantAccessService service;
 
     public HubGrantAccessSchedulerService(final HubSession session, final HostPasswordStore keychain) {
-        this(session, keychain, new VaultResourceApi(session.getClient()), new UsersResourceApi(session.getClient()), new DeviceResourceApi(session.getClient()), new GrantAccessServiceImpl(session));
-    }
-
-    public HubGrantAccessSchedulerService(final HubSession session, final HostPasswordStore keychain, final VaultResourceApi vaults, final UsersResourceApi users, final DeviceResourceApi devices, final GrantAccessService service) {
-        super(new HostPreferences(session.getHost()).getLong("hub.protocol.scheduler.period"));
+        super(HostPreferencesFactory.get(session.getHost()).getLong("hub.protocol.scheduler.period"));
         this.session = session;
         this.keychain = keychain;
-        this.vaults = vaults;
-        this.users = users;
-        this.devices = devices;
-        this.service = service;
     }
 
     @Override
     public Host operate(final PasswordCallback callback) throws BackgroundException {
         log.info("Scheduler for {}", session.getHost());
         try {
-            final UserKeys userKeys = new UserKeysServiceImpl(users, devices).getUserKeys(session.getHost(), session.getMe(),
+            final UserKeys userKeys = new UserKeysServiceImpl(
+                    new UsersResourceApi(session.getClient()),
+                    new DeviceResourceApi(session.getClient())).getUserKeys(session.getHost(), session.getMe(),
                     new DeviceKeysServiceImpl(keychain).getDeviceKeys(session.getHost()));
-
-            final List<VaultDto> accessibleVaults = vaults.apiVaultsAccessibleGet(Role.OWNER);
-
+            final List<VaultDto> accessibleVaults = new VaultResourceApi(session.getClient()).apiVaultsAccessibleGet(Role.OWNER);
             for(final VaultDto accessibleVault : accessibleVaults) {
                 if(Boolean.TRUE.equals(accessibleVault.getArchived())) {
                     log.debug("Skip archived vault {}", accessibleVault);
                     continue;
                 }
-                service.grantAccessToUsersRequiringAccessGrant(accessibleVault.getId(), userKeys);
+                new GrantAccessServiceImpl(
+                        new VaultResourceApi(session.getClient()),
+                        new StorageProfileResourceApi(session.getClient()),
+                        new UsersResourceApi(session.getClient())
+                ).grantAccessToUsersRequiringAccessGrant(accessibleVault.getId(), userKeys);
             }
             userKeys.destroy();
         }

hub/src/main/java/cloud/katta/protocols/hub/HubOAuthTokensCredentialsConfigurator.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2025 shift7 GmbH. All rights reserved.
+ */
+
+package cloud.katta.protocols.hub;
+
+import ch.cyberduck.core.Credentials;
+import ch.cyberduck.core.CredentialsConfigurator;
+import ch.cyberduck.core.Host;
+import ch.cyberduck.core.HostPasswordStore;
+import ch.cyberduck.core.OAuthTokens;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class HubOAuthTokensCredentialsConfigurator implements CredentialsConfigurator {
+    private static final Logger log = LogManager.getLogger(HubOAuthTokensCredentialsConfigurator.class);
+
+    private final HostPasswordStore keychain;
+    private final Host host;
+
+    private OAuthTokens tokens = OAuthTokens.EMPTY;
+
+    public HubOAuthTokensCredentialsConfigurator(final HostPasswordStore keychain, final Host host) {
+        this.keychain = keychain;
+        this.host = host;
+    }
+
+    @Override
+    public Credentials configure(final Host host) {
+        return new Credentials(host.getCredentials()).setOauth(tokens);
+    }
+
+    @Override
+    public CredentialsConfigurator reload() {
+        if(tokens.isExpired()) {
+            log.debug("Reload expired tokens from keychain for {}", host);
+            tokens = keychain.findOAuthTokens(host);
+            log.debug("Retrieved tokens {}", tokens);
+        }
+        return this;
+    }
+}

hub/src/main/java/cloud/katta/protocols/hub/HubProtocol.java

@@ -62,4 +62,9 @@ public boolean isUsernameConfigurable() {
     public boolean isPasswordConfigurable() {
         return false;
     }
+
+    @Override
+    public VersioningMode getVersioningMode() {
+        return VersioningMode.storage;
+    }
 }