fix(production): 同步 3.0.x 生产就绪深审修复（Jackson 2 适配）

Author: loong10k

src/main/java/io/github/easy4j/kimi/acp/KimiAcpClient.java

@@ -79,6 +79,7 @@ public class KimiAcpClient implements AutoCloseable {
     private final Map<String, PromptStream> promptStreams = new ConcurrentHashMap<String, PromptStream>();
     private final AtomicLong rpcIds = new AtomicLong();
     private final AtomicBoolean closed = new AtomicBoolean(false);
+    private final AtomicBoolean connected = new AtomicBoolean(false);
     private final ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor(r -> {
         Thread thread = new Thread(r, "kimi-acp-timer");
         thread.setDaemon(true);
@@ -109,6 +110,13 @@ public KimiAcpClient(KimiAcpConfig config) {
      *                        fails or times out.
      */
     public String connect() {
+        if (closed.get()) {
+            throw new IllegalStateException("kimi acp client is closed");
+        }
+        // CAS guard: a second connect would orphan the first child process.
+        if (!connected.compareAndSet(false, true)) {
+            throw new IllegalStateException("kimi acp client is already connected");
+        }
         List<String> command = new ArrayList<String>();
         command.add(config.getLocalExecutable());
         if (config.getAcpSubcommand() != null) {
@@ -124,6 +132,7 @@ public String connect() {
         try {
             process = builder.start();
         } catch (IOException e) {
+            connected.set(false);
             throw new KimiException("Failed to spawn kimi acp: " + config.getLocalExecutable(), e);
         }
         stdin = new PrintWriter(new OutputStreamWriter(process.getOutputStream(), StandardCharsets.UTF_8), true);
@@ -135,14 +144,27 @@ public String connect() {
         params.put("protocolVersion", Integer.valueOf(1));
         Map<String, Object> clientCaps = new LinkedHashMap<String, Object>();
         params.put("clientCapabilities", clientCaps);
-        JsonNode result = await(request("initialize", params), config.getConnectTimeoutMillis(), "initialize");
-        if (result.hasNonNull("protocolVersion")) {
-            protocolVersion = result.path("protocolVersion").asText(null);
-        }
-        if (result.hasNonNull("agentInfo")) {
-            agentVersion = result.path("agentInfo").path("version").asText(null);
+        try {
+            JsonNode result = await(request("initialize", params), config.getConnectTimeoutMillis(), "initialize");
+            if (result.hasNonNull("protocolVersion")) {
+                protocolVersion = result.path("protocolVersion").asText(null);
+            }
+            if (result.hasNonNull("agentInfo")) {
+                agentVersion = result.path("agentInfo").path("version").asText(null);
+            }
+            return agentVersion;
+        } catch (RuntimeException e) {
+            // Handshake failure leaves the child alive — destroy it here so a
+            // discarded client cannot leak the process, and allow a retry.
+            Process current = process;
+            if (current != null) {
+                current.destroy();
+            }
+            process = null;
+            stdin = null;
+            connected.set(false);
+            throw e;
         }
-        return agentVersion;
     }
 
     /**

src/main/java/io/github/easy4j/kimi/cli/KimiCli.java

@@ -253,6 +253,12 @@ public KimiCliResult prompt(RunOptions options) {
     }
 
     private String[] buildPromptArgs(RunOptions options) {
+        if (options.session != null && options.continueLast) {
+            // The kimi CLI rejects this combination at startup; fail here
+            // with a clear message instead.
+            throw new IllegalArgumentException(
+                    "RunOptions: --session and --continue are mutually exclusive");
+        }
         List<String> args = new ArrayList<String>();
         if (options.model != null) {
             args.add("--model");

src/main/java/io/github/easy4j/kimi/server/KimiServerClient.java

@@ -75,8 +75,12 @@ public class KimiServerClient implements AutoCloseable {
             JsonMapper.builder().disable(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                     .build();
 
+    private static final java.util.regex.Pattern HTTP_URL =
+            java.util.regex.Pattern.compile("https?://\\S+");
+
     private final KimiServerConfig config;
     private final AtomicBoolean ownsServer = new AtomicBoolean(false);
+    private final java.util.List<String> startupOutput = new java.util.ArrayList<String>();
 
     private volatile Process process;
     private volatile String baseUrl;
@@ -119,12 +123,20 @@ public String start() {
             throw new KimiException("Failed to spawn kimi web: " + config.getLocalExecutable(), e);
         }
         ownsServer.set(true);
-        // Drain child output so the process never blocks on a full pipe.
+        // Drain child output so the process never blocks on a full pipe, and
+        // keep the last lines: when the configured port is busy the CLI
+        // retries on port+1 and announces the real URL on stdout.
         Thread drainer = new Thread(() -> {
             try (BufferedReader reader =
                     new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
-                while (reader.readLine() != null) {
-                    // discard
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    synchronized (startupOutput) {
+                        startupOutput.add(line);
+                        if (startupOutput.size() > 100) {
+                            startupOutput.remove(0);
+                        }
+                    }
                 }
             } catch (IOException e) {
                 log.debug("kimi web output drain ended: {}", e.getMessage());
@@ -147,6 +159,7 @@ public String start() {
                 return baseUrl;
             } catch (Exception e) {
                 lastError = e;
+                candidate = detectBaseUrl(candidate);
                 sleepQuietly(300);
             }
         }
@@ -372,6 +385,27 @@ private JsonNode exchange(String base, String method, String path, Object body)
         }
     }
 
+    /**
+     * Returns the first {@code http://...} URL announced on the child's
+     * stdout that differs from {@code current}, or {@code current} when none
+     * was found. Handles the CLI's busy-port {@code +1} retry behaviour.
+     */
+    private String detectBaseUrl(String current) {
+        synchronized (startupOutput) {
+            for (String line : startupOutput) {
+                java.util.regex.Matcher matcher = HTTP_URL.matcher(line);
+                if (matcher.find()) {
+                    String url = matcher.group().replaceAll("/+$", "");
+                    if (!url.equals(current)) {
+                        log.debug("kimi web announced actual base url: {}", url);
+                        return url;
+                    }
+                }
+            }
+        }
+        return current;
+    }
+
     private String readToken() {
         String explicit = config.getToken();
         if (explicit != null && !explicit.trim().isEmpty()) {

src/test/java/io/github/easy4j/kimi/acp/KimiAcpClientE2ETest.java

@@ -110,6 +110,23 @@ void shouldFailConnectWhenAgentExitsPrematurely() {
         client.close();
     }
 
+    @Test
+    void shouldRejectDoubleConnect() {
+        try (KimiAcpClient client = new KimiAcpClient(config())) {
+            client.connect();
+            assertThrows(IllegalStateException.class, client::connect);
+        }
+    }
+
+    @Test
+    void shouldAllowRetryAfterFailedConnectWithoutLeakingProcess() {
+        KimiAcpConfig config = config();
+        config.setLocalExecutable("/nonexistent/kimi");
+        KimiAcpClient client = new KimiAcpClient(config);
+        assertThrows(KimiException.class, client::connect);
+        assertFalse(client.isClosed(), "failed connect must leave the client open for a retry");
+    }
+
     @Test
     void shouldRejectUseAfterClose() {
         KimiAcpClient client = new KimiAcpClient(config());

src/test/java/io/github/easy4j/kimi/cli/KimiCliTest.java

@@ -114,6 +114,12 @@ void shouldDelegatePromptContinueLast() {
         assertTrue(out.contains("--prompt hi"));
     }
 
+    @Test
+    void shouldRejectSessionAndContinueTogether() {
+        KimiCli.RunOptions options = new KimiCli.RunOptions("hi", null).session("s1").continueLast(true);
+        assertThrows(IllegalArgumentException.class, () -> echoCli().prompt(options));
+    }
+
     @Test
     void shouldRejectBlankPrompt() {
         assertThrows(IllegalArgumentException.class, () -> echoCli().prompt("  "));