Merge branch 'AsamK:master' into dev-http

graalvm-config-dir/proxy-config.json

@@ -1,23 +1,23 @@
 [
   {
-    "interfaces":["java.sql.Connection"]}
+    "interfaces":["java.sql.Connection"]
-  ,
+  },
   {
-    "interfaces":["org.asamk.Signal"]}
+    "interfaces":["org.asamk.Signal"]
-  ,
+  },
   {
-    "interfaces":["org.asamk.Signal$Configuration"]}
+    "interfaces":["org.asamk.Signal$Configuration"]
-  ,
+  },
   {
-    "interfaces":["org.asamk.Signal$Device"]}
+    "interfaces":["org.asamk.Signal$Device"]
-  ,
+  },
   {
-    "interfaces":["org.asamk.Signal$Group"]}
+    "interfaces":["org.asamk.Signal$Group"]
-  ,
+  },
   {
-    "interfaces":["org.asamk.SignalControl"]}
+    "interfaces":["org.asamk.SignalControl"]
-  ,
+  },
   {
-    "interfaces":["org.freedesktop.dbus.interfaces.DBus"]}
+    "interfaces":["org.freedesktop.dbus.interfaces.DBus"]
-  
+  }
 ]

graalvm-config-dir/reflect-config.json

@@ -78,10 +78,22 @@
   "allDeclaredFields":true,
   "allDeclaredMethods":true
 },
+{
+  "name":"com.google.protobuf.DescriptorMessageInfoFactory"
+},
+{
+  "name":"com.google.protobuf.ExtensionRegistry"
+},
+{
+  "name":"com.google.protobuf.ExtensionSchemaFull"
+},
 {
   "name":"com.google.protobuf.GeneratedMessageLite",
   "fields":[{"name":"unknownFields"}]
 },
+{
+  "name":"com.google.protobuf.GeneratedMessageV3"
+},
 {
   "name":"com.google.protobuf.Internal$LongList",
   "allDeclaredMethods":true
@@ -96,10 +108,19 @@
   "allDeclaredMethods":true,
   "allDeclaredConstructors":true
 },
+{
+  "name":"com.google.protobuf.MapFieldSchemaFull"
+},
+{
+  "name":"com.google.protobuf.NewInstanceSchemaFull"
+},
 {
   "name":"com.google.protobuf.PrimitiveNonBoxingCollection",
   "allDeclaredMethods":true
 },
+{
+  "name":"com.google.protobuf.UnknownFieldSetSchema"
+},
 {
   "name":"com.sun.crypto.provider.AESCipher$General",
   "methods":[{"name":"<init>","parameterTypes":[] }]
@@ -187,7 +208,42 @@
     {"name":"isAutoCommit","parameterTypes":[] }, 
     {"name":"isIsolateInternalQueries","parameterTypes":[] }, 
     {"name":"isReadOnly","parameterTypes":[] }, 
-    {"name":"isRegisterMbeans","parameterTypes":[] }
+    {"name":"isRegisterMbeans","parameterTypes":[] }, 
+    {"name":"setAllowPoolSuspension","parameterTypes":["boolean"] }, 
+    {"name":"setAutoCommit","parameterTypes":["boolean"] }, 
+    {"name":"setCatalog","parameterTypes":["java.lang.String"] }, 
+    {"name":"setConnectionInitSql","parameterTypes":["java.lang.String"] }, 
+    {"name":"setConnectionTestQuery","parameterTypes":["java.lang.String"] }, 
+    {"name":"setConnectionTimeout","parameterTypes":["long"] }, 
+    {"name":"setDataSource","parameterTypes":["javax.sql.DataSource"] }, 
+    {"name":"setDataSourceClassName","parameterTypes":["java.lang.String"] }, 
+    {"name":"setDataSourceJNDI","parameterTypes":["java.lang.String"] }, 
+    {"name":"setDataSourceProperties","parameterTypes":["java.util.Properties"] }, 
+    {"name":"setDriverClassName","parameterTypes":["java.lang.String"] }, 
+    {"name":"setExceptionOverrideClassName","parameterTypes":["java.lang.String"] }, 
+    {"name":"setHealthCheckProperties","parameterTypes":["java.util.Properties"] }, 
+    {"name":"setHealthCheckRegistry","parameterTypes":["java.lang.Object"] }, 
+    {"name":"setIdleTimeout","parameterTypes":["long"] }, 
+    {"name":"setInitializationFailTimeout","parameterTypes":["long"] }, 
+    {"name":"setIsolateInternalQueries","parameterTypes":["boolean"] }, 
+    {"name":"setJdbcUrl","parameterTypes":["java.lang.String"] }, 
+    {"name":"setKeepaliveTime","parameterTypes":["long"] }, 
+    {"name":"setLeakDetectionThreshold","parameterTypes":["long"] }, 
+    {"name":"setMaxLifetime","parameterTypes":["long"] }, 
+    {"name":"setMaximumPoolSize","parameterTypes":["int"] }, 
+    {"name":"setMetricRegistry","parameterTypes":["java.lang.Object"] }, 
+    {"name":"setMetricsTrackerFactory","parameterTypes":["com.zaxxer.hikari.metrics.MetricsTrackerFactory"] }, 
+    {"name":"setMinimumIdle","parameterTypes":["int"] }, 
+    {"name":"setPassword","parameterTypes":["java.lang.String"] }, 
+    {"name":"setPoolName","parameterTypes":["java.lang.String"] }, 
+    {"name":"setReadOnly","parameterTypes":["boolean"] }, 
+    {"name":"setRegisterMbeans","parameterTypes":["boolean"] }, 
+    {"name":"setScheduledExecutor","parameterTypes":["java.util.concurrent.ScheduledExecutorService"] }, 
+    {"name":"setSchema","parameterTypes":["java.lang.String"] }, 
+    {"name":"setThreadFactory","parameterTypes":["java.util.concurrent.ThreadFactory"] }, 
+    {"name":"setTransactionIsolation","parameterTypes":["java.lang.String"] }, 
+    {"name":"setUsername","parameterTypes":["java.lang.String"] }, 
+    {"name":"setValidationTimeout","parameterTypes":["long"] }
   ]
 },
 {
@@ -406,6 +462,12 @@
   "name":"javax.security.auth.x500.X500Principal",
   "methods":[{"name":"<init>","parameterTypes":["sun.security.x509.X500Name"] }]
 },
+{
+  "name":"javax.smartcardio.CardPermission"
+},
+{
+  "name":"libcore.io.Memory"
+},
 {
   "name":"long",
   "allDeclaredMethods":true,
@@ -1746,6 +1808,9 @@
   "name":"org.freedesktop.dbus.interfaces.Properties$PropertiesChanged",
   "allPublicConstructors":true
 },
+{
+  "name":"org.robolectric.Robolectric"
+},
 {
   "name":"org.signal.cdsi.proto.ClientRequest",
   "fields":[

graalvm-config-dir/serialization-config.json

@@ -2,5 +2,7 @@
   "types":[
   ],
   "lambdaCapturingTypes":[
+  ],
+  "proxies":[
   ]
 }

lib/build.gradle.kts

@@ -14,7 +14,7 @@ repositories {
 }
 
 dependencies {
-    implementation("com.github.turasa", "signal-service-java", "2.15.3_unofficial_62")
+    implementation("com.github.turasa", "signal-service-java", "2.15.3_unofficial_63")
     implementation("com.fasterxml.jackson.core", "jackson-databind", "2.13.4.2")
     implementation("com.google.protobuf", "protobuf-javalite", "3.21.6")
     implementation("org.bouncycastle", "bcprov-jdk15on", "1.70")

lib/src/main/java/org/asamk/signal/manager/Manager.java

@@ -1,5 +1,6 @@
 package org.asamk.signal.manager;
 
+import org.asamk.signal.manager.api.AlreadyReceivingException;
 import org.asamk.signal.manager.api.AttachmentInvalidException;
 import org.asamk.signal.manager.api.Configuration;
 import org.asamk.signal.manager.api.Device;
@@ -204,7 +205,7 @@ public interface Manager extends Closeable {
      */
     public void receiveMessages(
             Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
-    ) throws IOException;
+    ) throws IOException, AlreadyReceivingException;
 
     void setReceiveConfig(ReceiveConfig receiveConfig);
 

lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java

@@ -16,6 +16,7 @@
  */
 package org.asamk.signal.manager;
 
+import org.asamk.signal.manager.api.AlreadyReceivingException;
 import org.asamk.signal.manager.api.AttachmentInvalidException;
 import org.asamk.signal.manager.api.Configuration;
 import org.asamk.signal.manager.api.Device;
@@ -25,6 +26,7 @@ import org.asamk.signal.manager.api.InactiveGroupLinkException;
 import org.asamk.signal.manager.api.InvalidDeviceLinkException;
 import org.asamk.signal.manager.api.InvalidStickerException;
 import org.asamk.signal.manager.api.Message;
+import org.asamk.signal.manager.api.MessageEnvelope;
 import org.asamk.signal.manager.api.NotPrimaryDeviceException;
 import org.asamk.signal.manager.api.Pair;
 import org.asamk.signal.manager.api.PendingAdminApprovalException;
@@ -874,9 +876,6 @@ class ManagerImpl implements Manager {
 
     @Override
     public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) {
-        if (isReceivingSynchronous) {
-            throw new IllegalStateException("Already receiving message synchronously.");
-        }
         synchronized (messageHandlers) {
             if (isWeakListener) {
                 weakHandlers.add(handler);
@@ -890,23 +889,12 @@ class ManagerImpl implements Manager {
     private static final AtomicInteger threadNumber = new AtomicInteger(0);
 
     private void startReceiveThreadIfRequired() {
-        if (receiveThread != null) {
+        if (receiveThread != null || isReceivingSynchronous) {
             return;
         }
         receiveThread = new Thread(() -> {
             logger.debug("Starting receiving messages");
-            context.getReceiveHelper().receiveMessagesContinuously((envelope, e) -> {
+            context.getReceiveHelper().receiveMessagesContinuously(this::passReceivedMessageToHandlers);
-                synchronized (messageHandlers) {
-                    final var handlers = Stream.concat(messageHandlers.stream(), weakHandlers.stream()).toList();
-                    handlers.forEach(h -> {
-                        try {
-                            h.handleMessage(envelope, e);
-                        } catch (Throwable ex) {
-                            logger.warn("Message handler failed, ignoring", ex);
-                        }
-                    });
-                }
-            });
             logger.debug("Finished receiving messages");
             synchronized (messageHandlers) {
                 receiveThread = null;
@@ -923,6 +911,18 @@ class ManagerImpl implements Manager {
         receiveThread.start();
     }
 
+    private void passReceivedMessageToHandlers(MessageEnvelope envelope, Throwable e) {
+        synchronized (messageHandlers) {
+            Stream.concat(messageHandlers.stream(), weakHandlers.stream()).forEach(h -> {
+                try {
+                    h.handleMessage(envelope, e);
+                } catch (Throwable ex) {
+                    logger.warn("Message handler failed, ignoring", ex);
+                }
+            });
+        }
+    }
+
     @Override
     public void removeReceiveHandler(final ReceiveMessageHandler handler) {
         final Thread thread;
@@ -962,26 +962,34 @@ class ManagerImpl implements Manager {
 
     @Override
     public void receiveMessages(
-            Optional<Duration> timeout,
+            Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
-            Optional<Integer> maxMessages,
+    ) throws IOException, AlreadyReceivingException {
-            ReceiveMessageHandler handler
-    ) throws IOException {
         receiveMessages(timeout.orElse(Duration.ofMinutes(1)), timeout.isPresent(), maxMessages.orElse(null), handler);
     }
 
     private void receiveMessages(
             Duration timeout, boolean returnOnTimeout, Integer maxMessages, ReceiveMessageHandler handler
-    ) throws IOException {
+    ) throws IOException, AlreadyReceivingException {
-        if (isReceiving()) {
+        synchronized (messageHandlers) {
-            throw new IllegalStateException("Already receiving message.");
+            if (isReceiving()) {
+                throw new AlreadyReceivingException("Already receiving message.");
+            }
+            isReceivingSynchronous = true;
+            receiveThread = Thread.currentThread();
         }
-        isReceivingSynchronous = true;
-        receiveThread = Thread.currentThread();
         try {
-            context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, maxMessages, handler);
+            context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, maxMessages, (envelope, e) -> {
+                passReceivedMessageToHandlers(envelope, e);
+                handler.handleMessage(envelope, e);
+            });
         } finally {
-            receiveThread = null;
+            synchronized (messageHandlers) {
-            isReceivingSynchronous = false;
+                receiveThread = null;
+                isReceivingSynchronous = false;
+                if (messageHandlers.size() > 0) {
+                    startReceiveThreadIfRequired();
+                }
+            }
         }
     }
 

lib/src/main/java/org/asamk/signal/manager/api/AlreadyReceivingException.java

@@ -0,0 +1,12 @@
+package org.asamk.signal.manager.api;
+
+public class AlreadyReceivingException extends Exception {
+
+    public AlreadyReceivingException(String message) {
+        super(message);
+    }
+
+    public AlreadyReceivingException(String message, Exception e) {
+        super(message, e);
+    }
+}

src/main/java/org/asamk/signal/commands/ReceiveCommand.java

@@ -10,8 +10,10 @@ import org.asamk.signal.OutputType;
 import org.asamk.signal.ReceiveMessageHandler;
 import org.asamk.signal.commands.exceptions.CommandException;
 import org.asamk.signal.commands.exceptions.IOErrorException;
+import org.asamk.signal.commands.exceptions.UserErrorException;
 import org.asamk.signal.json.JsonReceiveMessageHandler;
 import org.asamk.signal.manager.Manager;
+import org.asamk.signal.manager.api.AlreadyReceivingException;
 import org.asamk.signal.manager.api.ReceiveConfig;
 import org.asamk.signal.output.JsonWriter;
 import org.asamk.signal.output.OutputWriter;
@@ -79,6 +81,8 @@ public class ReceiveCommand implements LocalCommand, JsonRpcSingleCommand<Receiv
             m.receiveMessages(Optional.ofNullable(duration), Optional.ofNullable(maxMessages), handler);
         } catch (IOException e) {
             throw new IOErrorException("Error while receiving messages: " + e.getMessage(), e);
+        } catch (AlreadyReceivingException e) {
+            throw new UserErrorException("Receive command cannot be used if messages are already being received.", e);
         }
     }
 
@@ -103,6 +107,8 @@ public class ReceiveCommand implements LocalCommand, JsonRpcSingleCommand<Receiv
             jsonWriter.write(messages);
         } catch (IOException e) {
             throw new IOErrorException("Error while receiving messages: " + e.getMessage(), e);
+        } catch (AlreadyReceivingException e) {
+            throw new UserErrorException("Receive command cannot be used if messages are already being received.", e);
         }
     }
 

src/main/java/org/asamk/signal/jsonrpc/JsonRpcReader.java

@@ -13,6 +13,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -24,43 +25,77 @@ public class JsonRpcReader {
 
     private final JsonRpcSender jsonRpcSender;
     private final ObjectMapper objectMapper;
+    private final InputStream input;
     private final Supplier<String> lineSupplier;
 
-    public JsonRpcReader(
+    public JsonRpcReader(final JsonRpcSender jsonRpcSender, final Supplier<String> lineSupplier) {
-            final JsonRpcSender jsonRpcSender, final Supplier<String> lineSupplier
-    ) {
         this.jsonRpcSender = jsonRpcSender;
+        this.input = null;
         this.lineSupplier = lineSupplier;
         this.objectMapper = Util.createJsonObjectMapper();
     }
 
+    public JsonRpcReader(final JsonRpcSender jsonRpcSender, final InputStream input) {
+        this.jsonRpcSender = jsonRpcSender;
+        this.input = input;
+        this.lineSupplier = null;
+        this.objectMapper = Util.createJsonObjectMapper();
+    }
+
     public void readMessages(final RequestHandler requestHandler, final Consumer<JsonRpcResponse> responseHandler) {
-        while (!Thread.interrupted()) {
+        if (input != null) {
-            JsonRpcMessage message = readMessage();
+            JsonRpcMessage message = parseJsonRpcMessage(input);
-            if (message == null) break;
+            if (message == null) {
-
+                return;
-            if (message instanceof final JsonRpcRequest jsonRpcRequest) {
-                logger.debug("Received json rpc request, method: " + jsonRpcRequest.getMethod());
-                final var response = handleRequest(requestHandler, jsonRpcRequest);
-                if (response != null) {
-                    jsonRpcSender.sendResponse(response);
-                }
-            } else if (message instanceof JsonRpcResponse jsonRpcResponse) {
-                responseHandler.accept(jsonRpcResponse);
-            } else {
-                final var responseList = ((JsonRpcBatchMessage) message).getMessages().stream().map(jsonNode -> {
-                    final JsonRpcRequest request;
-                    try {
-                        request = parseJsonRpcRequest(jsonNode);
-                    } catch (JsonRpcException e) {
-                        return JsonRpcResponse.forError(e.getError(), getId(jsonNode));
-                    }
-
-                    return handleRequest(requestHandler, request);
-                }).filter(Objects::nonNull).toList();
-
-                jsonRpcSender.sendBatchResponses(responseList);
             }
+
+            handleMessage(message, requestHandler, responseHandler);
+            return;
+        }
+
+        while (!Thread.interrupted()) {
+            String input = lineSupplier.get();
+            if (input == null) {
+                logger.trace("Reached end of JSON-RPC input stream.");
+                break;
+            }
+
+            logger.trace("Incoming JSON-RPC message: {}", input);
+            JsonRpcMessage message = parseJsonRpcMessage(input);
+            if (message == null) {
+                continue;
+            }
+
+            handleMessage(message, requestHandler, responseHandler);
+        }
+    }
+
+    private void handleMessage(
+            final JsonRpcMessage message,
+            final RequestHandler requestHandler,
+            final Consumer<JsonRpcResponse> responseHandler
+    ) {
+        if (message instanceof final JsonRpcRequest jsonRpcRequest) {
+            logger.debug("Received json rpc request, method: " + jsonRpcRequest.getMethod());
+            final var response = handleRequest(requestHandler, jsonRpcRequest);
+            if (response != null) {
+                jsonRpcSender.sendResponse(response);
+            }
+        } else if (message instanceof JsonRpcResponse jsonRpcResponse) {
+            responseHandler.accept(jsonRpcResponse);
+        } else {
+            final var responseList = ((JsonRpcBatchMessage) message).getMessages().stream().map(jsonNode -> {
+                final JsonRpcRequest request;
+                try {
+                    request = parseJsonRpcRequest(jsonNode);
+                } catch (JsonRpcException e) {
+                    return JsonRpcResponse.forError(e.getError(), getId(jsonNode));
+                }
+
+                return handleRequest(requestHandler, request);
+            }).filter(Objects::nonNull).toList();
+
+            jsonRpcSender.sendBatchResponses(responseList);
         }
     }
 
@@ -85,25 +120,6 @@ public class JsonRpcReader {
         return null;
     }
 
-    private JsonRpcMessage readMessage() {
-        while (!Thread.interrupted()) {
-            String input = lineSupplier.get();
-
-            if (input == null) {
-                logger.trace("Reached end of JSON-RPC input stream.");
-                break;
-            }
-
-            logger.trace("Incoming JSON-RPC message: {}", input);
-            JsonRpcMessage message = parseJsonRpcMessage(input);
-            if (message == null) continue;
-
-            return message;
-        }
-
-        return null;
-    }
-
     private JsonRpcMessage parseJsonRpcMessage(final String input) {
         final JsonNode jsonNode;
         try {
@@ -117,6 +133,26 @@ public class JsonRpcReader {
             throw new AssertionError(e);
         }
 
+        return parseJsonRpcMessage(jsonNode);
+    }
+
+    private JsonRpcMessage parseJsonRpcMessage(final InputStream input) {
+        final JsonNode jsonNode;
+        try {
+            jsonNode = objectMapper.readTree(input);
+        } catch (JsonParseException e) {
+            jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.PARSE_ERROR,
+                    e.getMessage(),
+                    null), null));
+            return null;
+        } catch (IOException e) {
+            throw new AssertionError(e);
+        }
+
+        return parseJsonRpcMessage(jsonNode);
+    }
+
+    private JsonRpcMessage parseJsonRpcMessage(final JsonNode jsonNode) {
         if (jsonNode == null) {
             jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
                     "invalid request",

src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcCommandHandler.java

@@ -0,0 +1,257 @@
+package org.asamk.signal.jsonrpc;
+
+import com.fasterxml.jackson.core.TreeNode;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ContainerNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import org.asamk.signal.commands.Command;
+import org.asamk.signal.commands.JsonRpcMultiCommand;
+import org.asamk.signal.commands.JsonRpcRegistrationCommand;
+import org.asamk.signal.commands.JsonRpcSingleCommand;
+import org.asamk.signal.commands.exceptions.CommandException;
+import org.asamk.signal.commands.exceptions.IOErrorException;
+import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException;
+import org.asamk.signal.commands.exceptions.UserErrorException;
+import org.asamk.signal.manager.Manager;
+import org.asamk.signal.manager.MultiAccountManager;
+import org.asamk.signal.manager.RegistrationManager;
+import org.asamk.signal.output.JsonWriter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.channels.OverlappingFileLockException;
+import java.util.Map;
+import java.util.function.Function;
+
+public class SignalJsonRpcCommandHandler {
+
+    private final static Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);
+
+    private static final int USER_ERROR = -1;
+    private static final int IO_ERROR = -3;
+    private static final int UNTRUSTED_KEY_ERROR = -4;
+
+    private final Manager m;
+    private final MultiAccountManager c;
+    private final Function<String, Command> commandProvider;
+
+    public SignalJsonRpcCommandHandler(final Manager m, final Function<String, Command> commandProvider) {
+        this.c = null;
+        this.m = m;
+        this.commandProvider = commandProvider;
+    }
+
+    public SignalJsonRpcCommandHandler(final MultiAccountManager c, final Function<String, Command> commandProvider) {
+        this.c = c;
+        this.m = null;
+        this.commandProvider = commandProvider;
+    }
+
+    JsonNode handleRequest(
+            final ObjectMapper objectMapper, final String method, ContainerNode<?> params
+    ) throws JsonRpcException {
+        var command = getCommand(method);
+        if (c != null) {
+            if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
+                final var manager = getManagerFromParams(params);
+                if (manager != null) {
+                    return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
+                }
+            }
+            if (command instanceof JsonRpcMultiCommand<?> jsonRpcCommand) {
+                return runCommand(objectMapper, params, new MultiCommandRunnerImpl<>(c, jsonRpcCommand));
+            }
+            if (command instanceof JsonRpcRegistrationCommand<?> jsonRpcCommand) {
+                try (var manager = getRegistrationManagerFromParams(params)) {
+                    if (manager != null) {
+                        return runCommand(objectMapper,
+                                params,
+                                new RegistrationCommandRunnerImpl<>(manager, c, jsonRpcCommand));
+                    } else {
+                        throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
+                                "Method requires valid account parameter",
+                                null));
+                    }
+                } catch (IOException e) {
+                    logger.warn("Failed to close registration manager", e);
+                }
+            }
+        }
+        if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
+            if (m != null) {
+                return runCommand(objectMapper, params, new CommandRunnerImpl<>(m, jsonRpcCommand));
+            }
+
+            final var manager = getManagerFromParams(params);
+            if (manager != null) {
+                return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
+            } else {
+                throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
+                        "Method requires valid account parameter",
+                        null));
+            }
+        }
+
+        throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND,
+                "Method not implemented",
+                null));
+    }
+
+    private Manager getManagerFromParams(final ContainerNode<?> params) throws JsonRpcException {
+        if (params != null && params.hasNonNull("account")) {
+            final var manager = c.getManager(params.get("account").asText());
+            ((ObjectNode) params).remove("account");
+            if (manager == null) {
+                throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
+                        "Specified account does not exist",
+                        null));
+            }
+            return manager;
+        }
+        return null;
+    }
+
+    private RegistrationManager getRegistrationManagerFromParams(final ContainerNode<?> params) {
+        if (params != null && params.has("account")) {
+            try {
+                final var registrationManager = c.getNewRegistrationManager(params.get("account").asText());
+                ((ObjectNode) params).remove("account");
+                return registrationManager;
+            } catch (OverlappingFileLockException e) {
+                logger.warn("Account is already in use");
+                return null;
+            } catch (IOException | IllegalStateException e) {
+                logger.warn("Failed to load registration manager", e);
+                return null;
+            }
+        }
+        return null;
+    }
+
+    private Command getCommand(final String method) {
+        return commandProvider.apply(method);
+    }
+
+    private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
+
+        @Override
+        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
+            command.handleCommand(request, m, jsonWriter);
+        }
+
+        @Override
+        public TypeReference<T> getRequestType() {
+            return command.getRequestType();
+        }
+    }
+
+    private record RegistrationCommandRunnerImpl<T>(
+            RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
+    ) implements CommandRunner<T> {
+
+        @Override
+        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
+            command.handleCommand(request, m, jsonWriter);
+        }
+
+        @Override
+        public TypeReference<T> getRequestType() {
+            return command.getRequestType();
+        }
+    }
+
+    private record MultiCommandRunnerImpl<T>(
+            MultiAccountManager c, JsonRpcMultiCommand<T> command
+    ) implements CommandRunner<T> {
+
+        @Override
+        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
+            command.handleCommand(request, c, jsonWriter);
+        }
+
+        @Override
+        public TypeReference<T> getRequestType() {
+            return command.getRequestType();
+        }
+    }
+
+    interface CommandRunner<T> {
+
+        void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
+
+        TypeReference<T> getRequestType();
+    }
+
+    private JsonNode runCommand(
+            final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
+    ) throws JsonRpcException {
+        final Object[] result = {null};
+        final JsonWriter commandJsonWriter = s -> {
+            if (result[0] != null) {
+                throw new AssertionError("Command may only write one json result");
+            }
+
+            result[0] = s;
+        };
+
+        try {
+            parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command);
+        } catch (JsonMappingException e) {
+            throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
+                    e.getMessage(),
+                    null));
+        } catch (UserErrorException e) {
+            throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR,
+                    e.getMessage(),
+                    getErrorDataNode(objectMapper, result)));
+        } catch (IOErrorException e) {
+            throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR,
+                    e.getMessage(),
+                    getErrorDataNode(objectMapper, result)));
+        } catch (UntrustedKeyErrorException e) {
+            throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR,
+                    e.getMessage(),
+                    getErrorDataNode(objectMapper, result)));
+        } catch (Throwable e) {
+            logger.error("Command execution failed", e);
+            throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
+                    e.getMessage(),
+                    getErrorDataNode(objectMapper, result)));
+        }
+
+        Object output = result[0] == null ? Map.of() : result[0];
+        return objectMapper.valueToTree(output);
+    }
+
+    private JsonNode getErrorDataNode(final ObjectMapper objectMapper, final Object[] result) {
+        if (result[0] == null) {
+            return null;
+        }
+        return objectMapper.valueToTree(Map.of("response", result[0]));
+    }
+
+    private <T> void parseParamsAndRunCommand(
+            final ObjectMapper objectMapper,
+            final TreeNode params,
+            final JsonWriter jsonWriter,
+            final CommandRunner<T> command
+    ) throws CommandException, JsonMappingException {
+        T requestParams = null;
+        final var requestType = command.getRequestType();
+        if (params != null && requestType != null) {
+            try {
+                requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
+            } catch (JsonMappingException e) {
+                throw e;
+            } catch (IOException e) {
+                throw new AssertionError(e);
+            }
+        }
+        command.handleCommand(requestParams, jsonWriter);
+    }
+}

src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java

@@ -1,8 +1,6 @@
 package org.asamk.signal.jsonrpc;
 
-import com.fasterxml.jackson.core.TreeNode;
 import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
@@ -13,25 +11,19 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.asamk.signal.commands.Command;
 import org.asamk.signal.commands.Commands;
 import org.asamk.signal.commands.JsonRpcMultiCommand;
-import org.asamk.signal.commands.JsonRpcRegistrationCommand;
 import org.asamk.signal.commands.JsonRpcSingleCommand;
 import org.asamk.signal.commands.exceptions.CommandException;
-import org.asamk.signal.commands.exceptions.IOErrorException;
-import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException;
 import org.asamk.signal.commands.exceptions.UserErrorException;
 import org.asamk.signal.json.JsonReceiveMessageHandler;
 import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.MultiAccountManager;
-import org.asamk.signal.manager.RegistrationManager;
 import org.asamk.signal.manager.api.Pair;
 import org.asamk.signal.output.JsonWriter;
 import org.asamk.signal.util.Util;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
 import java.nio.channels.ClosedChannelException;
-import java.nio.channels.OverlappingFileLockException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -42,19 +34,13 @@ public class SignalJsonRpcDispatcherHandler {
 
     private final static Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);
 
-    private static final int USER_ERROR = -1;
-    private static final int IO_ERROR = -3;
-    private static final int UNTRUSTED_KEY_ERROR = -4;
-
     private final ObjectMapper objectMapper;
     private final JsonRpcSender jsonRpcSender;
     private final JsonRpcReader jsonRpcReader;
     private final boolean noReceiveOnStart;
 
-    private MultiAccountManager c;
     private final Map<Integer, List<Pair<Manager, Manager.ReceiveMessageHandler>>> receiveHandlers = new HashMap<>();
-
+    private SignalJsonRpcCommandHandler commandHandler;
-    private Manager m;
 
     public SignalJsonRpcDispatcherHandler(
             final JsonWriter jsonWriter, final Supplier<String> lineSupplier, final boolean noReceiveOnStart
@@ -66,7 +52,7 @@ public class SignalJsonRpcDispatcherHandler {
     }
 
     public void handleConnection(final MultiAccountManager c) {
-        this.c = c;
+        this.commandHandler = new SignalJsonRpcCommandHandler(c, this::getCommand);
 
         if (!noReceiveOnStart) {
             this.subscribeReceive(c.getManagers());
@@ -78,7 +64,7 @@ public class SignalJsonRpcDispatcherHandler {
     }
 
     public void handleConnection(final Manager m) {
-        this.m = m;
+        this.commandHandler = new SignalJsonRpcCommandHandler(m, this::getCommand);
 
         if (!noReceiveOnStart) {
             subscribeReceive(m);
@@ -141,7 +127,7 @@ public class SignalJsonRpcDispatcherHandler {
 
     private void handleConnection() {
         try {
-            jsonRpcReader.readMessages((method, params) -> handleRequest(objectMapper, method, params),
+            jsonRpcReader.readMessages((method, params) -> commandHandler.handleRequest(objectMapper, method, params),
                     response -> logger.debug("Received unexpected response for id {}", response.getId()));
         } finally {
             receiveHandlers.forEach((_subscriptionId, handlers) -> handlers.forEach(this::unsubscribeReceiveHandler));
@@ -155,87 +141,6 @@ public class SignalJsonRpcDispatcherHandler {
         m.removeReceiveHandler(handler);
     }
 
-    private JsonNode handleRequest(
-            final ObjectMapper objectMapper, final String method, ContainerNode<?> params
-    ) throws JsonRpcException {
-        var command = getCommand(method);
-        if (c != null) {
-            if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
-                final var manager = getManagerFromParams(params);
-                if (manager != null) {
-                    return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
-                }
-            }
-            if (command instanceof JsonRpcMultiCommand<?> jsonRpcCommand) {
-                return runCommand(objectMapper, params, new MultiCommandRunnerImpl<>(c, jsonRpcCommand));
-            }
-            if (command instanceof JsonRpcRegistrationCommand<?> jsonRpcCommand) {
-                try (var manager = getRegistrationManagerFromParams(params)) {
-                    if (manager != null) {
-                        return runCommand(objectMapper,
-                                params,
-                                new RegistrationCommandRunnerImpl<>(manager, c, jsonRpcCommand));
-                    } else {
-                        throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
-                                "Method requires valid account parameter",
-                                null));
-                    }
-                } catch (IOException e) {
-                    logger.warn("Failed to close registration manager", e);
-                }
-            }
-        }
-        if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
-            if (m != null) {
-                return runCommand(objectMapper, params, new CommandRunnerImpl<>(m, jsonRpcCommand));
-            }
-
-            final var manager = getManagerFromParams(params);
-            if (manager != null) {
-                return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
-            } else {
-                throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
-                        "Method requires valid account parameter",
-                        null));
-            }
-        }
-
-        throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND,
-                "Method not implemented",
-                null));
-    }
-
-    private Manager getManagerFromParams(final ContainerNode<?> params) throws JsonRpcException {
-        if (params != null && params.hasNonNull("account")) {
-            final var manager = c.getManager(params.get("account").asText());
-            ((ObjectNode) params).remove("account");
-            if (manager == null) {
-                throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
-                        "Specified account does not exist",
-                        null));
-            }
-            return manager;
-        }
-        return null;
-    }
-
-    private RegistrationManager getRegistrationManagerFromParams(final ContainerNode<?> params) {
-        if (params != null && params.has("account")) {
-            try {
-                final var registrationManager = c.getNewRegistrationManager(params.get("account").asText());
-                ((ObjectNode) params).remove("account");
-                return registrationManager;
-            } catch (OverlappingFileLockException e) {
-                logger.warn("Account is already in use");
-                return null;
-            } catch (IOException | IllegalStateException e) {
-                logger.warn("Failed to load registration manager", e);
-                return null;
-            }
-        }
-        return null;
-    }
-
     private Command getCommand(final String method) {
         if ("subscribeReceive".equals(method)) {
             return new SubscribeReceiveCommand();
@@ -246,124 +151,6 @@ public class SignalJsonRpcDispatcherHandler {
         return Commands.getCommand(method);
     }
 
-    private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
-
-        @Override
-        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
-            command.handleCommand(request, m, jsonWriter);
-        }
-
-        @Override
-        public TypeReference<T> getRequestType() {
-            return command.getRequestType();
-        }
-    }
-
-    private record RegistrationCommandRunnerImpl<T>(
-            RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
-    ) implements CommandRunner<T> {
-
-        @Override
-        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
-            command.handleCommand(request, m, jsonWriter);
-        }
-
-        @Override
-        public TypeReference<T> getRequestType() {
-            return command.getRequestType();
-        }
-    }
-
-    private record MultiCommandRunnerImpl<T>(
-            MultiAccountManager c, JsonRpcMultiCommand<T> command
-    ) implements CommandRunner<T> {
-
-        @Override
-        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
-            command.handleCommand(request, c, jsonWriter);
-        }
-
-        @Override
-        public TypeReference<T> getRequestType() {
-            return command.getRequestType();
-        }
-    }
-
-    interface CommandRunner<T> {
-
-        void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
-
-        TypeReference<T> getRequestType();
-    }
-
-    private JsonNode runCommand(
-            final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
-    ) throws JsonRpcException {
-        final Object[] result = {null};
-        final JsonWriter commandJsonWriter = s -> {
-            if (result[0] != null) {
-                throw new AssertionError("Command may only write one json result");
-            }
-
-            result[0] = s;
-        };
-
-        try {
-            parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command);
-        } catch (JsonMappingException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
-                    e.getMessage(),
-                    null));
-        } catch (UserErrorException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        } catch (IOErrorException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        } catch (UntrustedKeyErrorException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        } catch (Throwable e) {
-            logger.error("Command execution failed", e);
-            throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        }
-
-        Object output = result[0] == null ? Map.of() : result[0];
-        return objectMapper.valueToTree(output);
-    }
-
-    private JsonNode getErrorDataNode(final ObjectMapper objectMapper, final Object[] result) {
-        if (result[0] == null) {
-            return null;
-        }
-        return objectMapper.valueToTree(Map.of("response", result[0]));
-    }
-
-    private <T> void parseParamsAndRunCommand(
-            final ObjectMapper objectMapper,
-            final TreeNode params,
-            final JsonWriter jsonWriter,
-            final CommandRunner<T> command
-    ) throws CommandException, JsonMappingException {
-        T requestParams = null;
-        final var requestType = command.getRequestType();
-        if (params != null && requestType != null) {
-            try {
-                requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
-            } catch (JsonMappingException e) {
-                throw e;
-            } catch (IOException e) {
-                throw new AssertionError(e);
-            }
-        }
-        command.handleCommand(requestParams, jsonWriter);
-    }
-
     private class SubscribeReceiveCommand implements JsonRpcSingleCommand<Void>, JsonRpcMultiCommand<Void> {
 
         @Override