add ProcessTransport unitTest and fix bug

packages/sdk-java/.editorconfig

@@ -0,0 +1,24 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+tab_width = 4
+ij_continuation_indent_size = 8
+
+[*.java]
+ij_java_doc_align_exception_comments = false
+ij_java_doc_align_param_comments = false
+
+[*.{yaml, yml, sh, ps1}]
+indent_size = 2
+
+[*.{md, mkd, markdown}]
+trim_trailing_whitespace = false
+
+[{**/res/**.xml, **/AndroidManifest.xml}]
+ij_continuation_indent_size = 4

packages/sdk-java/.gitignore

@@ -0,0 +1,13 @@
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+# Mac
+.DS_Store
+ 
+# Maven
+log/
+target/
+

packages/sdk-java/checkstyle.xml

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE module PUBLIC
+        "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+        "http://checkstyle.sourceforge.net/dtds/configuration_1_3.dtd">
+<module name="Checker">
+    <module name="FileTabCharacter" />
+    <module name="NewlineAtEndOfFile">
+        <property name="lineSeparator" value="lf" />
+    </module>
+    <module name="RegexpMultiline">
+        <property name="format" value="\r" />
+        <property name="message" value="Line contains carriage return" />
+    </module>
+    <module name="RegexpMultiline">
+        <property name="format" value=" \n" />
+        <property name="message" value="Line has trailing whitespace" />
+    </module>
+    <module name="RegexpMultiline">
+        <property name="format" value="\n\n\n" />
+        <property name="message" value="Multiple consecutive blank lines" />
+    </module>
+    <module name="RegexpMultiline">
+        <property name="format" value="\n\n\Z" />
+        <property name="message" value="Blank line before end of file" />
+    </module>
+
+    <module name="RegexpMultiline">
+        <property name="format" value="\{\n\n" />
+        <property name="message" value="Blank line after opening brace" />
+    </module>
+    <module name="RegexpMultiline">
+        <property name="format" value="\n\n\s*\}" />
+        <property name="message" value="Blank line before closing brace" />
+    </module>
+    <module name="RegexpMultiline">
+        <property name="format" value="->\s*\{\s+\}" />
+        <property name="message" value="Whitespace inside empty lambda body" />
+    </module>
+
+    <module name="TreeWalker">
+        <module name="SuppressWarningsHolder" />
+
+        <module name="EmptyBlock">
+            <property name="option" value="text" />
+            <property name="tokens" value="
+                LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_IF,
+                LITERAL_FOR, LITERAL_TRY, LITERAL_WHILE, INSTANCE_INIT, STATIC_INIT" />
+        </module>
+        <module name="EmptyStatement" />
+        <module name="EmptyForInitializerPad" />
+        <module name="MethodParamPad">
+            <property name="allowLineBreaks" value="true" />
+            <property name="option" value="nospace" />
+        </module>
+        <module name="ParenPad" />
+        <module name="TypecastParenPad" />
+        <module name="NeedBraces" />
+        <module name="LeftCurly">
+            <property name="option" value="eol" />
+            <property name="tokens" value="
+                 LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR,
+                 LITERAL_IF, LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE" />
+        </module>
+        <module name="GenericWhitespace" />
+        <module name="WhitespaceAfter" />
+        <module name="NoWhitespaceAfter" />
+        <module name="NoWhitespaceBefore" />
+        <module name="SingleSpaceSeparator" />
+        <module name="Indentation">
+            <property name="throwsIndent" value="8" />
+            <property name="lineWrappingIndentation" value="8" />
+        </module>
+
+        <module name="UpperEll" />
+        <module name="DefaultComesLast" />
+        <module name="ArrayTypeStyle" />
+        <module name="ModifierOrder" />
+        <module name="OneStatementPerLine" />
+        <module name="StringLiteralEquality" />
+        <module name="MutableException" />
+        <module name="EqualsHashCode" />
+        <module name="ExplicitInitialization" />
+        <module name="OneTopLevelClass" />
+
+        <module name="MemberName" />
+        <module name="PackageName" />
+        <module name="ClassTypeParameterName">
+            <property name="format" value="^[A-Z][0-9]?$" />
+        </module>
+        <module name="MethodTypeParameterName">
+            <property name="format" value="^[A-Z][0-9]?$" />
+        </module>
+        <module name="AnnotationUseStyle">
+            <property name="trailingArrayComma" value="ignore" />
+        </module>
+
+        <module name="RedundantImport" />
+        <module name="UnusedImports" />
+<!--        <module name="ImportOrder">-->
+<!--            <property name="groups" value="*,javax,java" />-->
+<!--            <property name="separated" value="true" />-->
+<!--            <property name="option" value="bottom" />-->
+<!--            <property name="sortStaticImportsAlphabetically" value="true" />-->
+<!--        </module>-->
+
+        <module name="WhitespaceAround">
+            <property name="allowEmptyConstructors" value="true" />
+            <property name="allowEmptyMethods" value="true" />
+            <property name="allowEmptyLambdas" value="true" />
+            <property name="ignoreEnhancedForColon" value="false" />
+            <property name="tokens" value="
+                ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN,
+                BXOR, BXOR_ASSIGN, COLON, DIV, DIV_ASSIGN, DO_WHILE, EQUAL, GE, GT, LAND,
+                LAMBDA, LE, LITERAL_ASSERT, LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE,
+                LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_RETURN, LITERAL_SWITCH,
+                LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE,
+                LOR, LT, MINUS, MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL,
+                PLUS, PLUS_ASSIGN, QUESTION, SL, SLIST, SL_ASSIGN, SR, SR_ASSIGN,
+                STAR, STAR_ASSIGN, TYPE_EXTENSION_AND" />
+        </module>
+
+        <module name="WhitespaceAfter" />
+
+        <module name="NoWhitespaceAfter">
+            <property name="tokens" value="DOT" />
+            <property name="allowLineBreaks" value="false" />
+        </module>
+
+        <module name="MissingOverride"/>
+    </module>
+</module>

packages/sdk-java/pom.xml

@@ -0,0 +1,105 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.alibaba</groupId>
+    <artifactId>qwencode-sdk-java</artifactId>
+    <packaging>jar</packaging>
+    <version>0.0.1</version>
+    <name>qwencode-sdk-java</name>
+    <url>https://maven.apache.org</url>
+    <licenses>
+        <license>
+            <name>Apache 2</name>
+            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
+            <distribution>repo</distribution>
+            <comments>A business-friendly OSS license</comments>
+        </license>
+    </licenses>
+    <scm>
+        <url>https://github.com/QwenLM/qwen-code</url>
+        <connection>scm:git:https://github.com/QwenLM/qwen-code.git</connection>
+    </scm>
+    <properties>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <checkstyle-maven-plugin.version>3.6.0</checkstyle-maven-plugin.version>
+        <junit5.version>5.14.1</junit5.version>
+        <logback-classic.version>1.3.16</logback-classic.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.junit</groupId>
+                <artifactId>junit-bom</artifactId>
+                <type>pom</type>
+                <version>${junit5.version}</version>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+    <dependencies>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>${logback-classic.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.20.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+                <version>${checkstyle-maven-plugin.version}</version>
+                <configuration>
+                    <configLocation>checkstyle.xml</configLocation>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <organization>
+        <name>Alibaba Group</name>
+        <url>https://github.com/alibaba</url>
+    </organization>
+    <developers>
+        <developer>
+            <id>skyfire</id>
+            <name>skyfire</name>
+            <email>gengwei.gw(at)alibaba-inc.com</email>
+            <roles>
+                <role>Developer</role>
+                <role>Designer</role>
+            </roles>
+            <timezone>+8</timezone>
+            <url>https://github.com/gwinthis</url>
+        </developer>
+    </developers>
+
+    <distributionManagement>
+        <snapshotRepository>
+            <id>central</id>
+            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
+        </snapshotRepository>
+    </distributionManagement>
+</project>

packages/sdk-java/src/main/java/com/alibaba/qwen/code/cli/transport/PermissionMode.java

@@ -0,0 +1,27 @@
+package com.alibaba.qwen.code.cli.transport;
+
+public enum PermissionMode {
+    DEFAULT("default"),
+    PLAN("plan"),
+    AUTO_EDIT("auto-edit"),
+    YOLO("yolo");
+
+    private final String value;
+
+    PermissionMode(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public static PermissionMode fromValue(String value) {
+        for (PermissionMode mode : PermissionMode.values()) {
+            if (mode.value.equals(value)) {
+                return mode;
+            }
+        }
+        throw new IllegalArgumentException("Unknown permission mode: " + value);
+    }
+}

packages/sdk-java/src/main/java/com/alibaba/qwen/code/cli/transport/TransportOptions.java

@@ -0,0 +1,133 @@
+package com.alibaba.qwen.code.cli.transport;
+
+import java.util.List;
+import java.util.Map;
+
+public class TransportOptions implements Cloneable {
+    private String pathToQwenExecutable;
+    private String cwd;
+    private String model;
+    private PermissionMode permissionMode;
+    private Map<String, String> env;
+    private Integer maxSessionTurns;
+    private List<String> coreTools;
+    private List<String> excludeTools;
+    private List<String> allowedTools;
+    private String authType;
+    private Boolean includePartialMessages;
+    private Long turnTimeoutMs;
+    private Long messageTimeoutMs;
+
+    public String getPathToQwenExecutable() {
+        return pathToQwenExecutable;
+    }
+
+    public void setPathToQwenExecutable(String pathToQwenExecutable) {
+        this.pathToQwenExecutable = pathToQwenExecutable;
+    }
+
+    public String getCwd() {
+        return cwd;
+    }
+
+    public void setCwd(String cwd) {
+        this.cwd = cwd;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    public PermissionMode getPermissionMode() {
+        return permissionMode;
+    }
+
+    public void setPermissionMode(PermissionMode permissionMode) {
+        this.permissionMode = permissionMode;
+    }
+
+    public Map<String, String> getEnv() {
+        return env;
+    }
+
+    public void setEnv(Map<String, String> env) {
+        this.env = env;
+    }
+
+    public Integer getMaxSessionTurns() {
+        return maxSessionTurns;
+    }
+
+    public void setMaxSessionTurns(Integer maxSessionTurns) {
+        this.maxSessionTurns = maxSessionTurns;
+    }
+
+    public List<String> getCoreTools() {
+        return coreTools;
+    }
+
+    public void setCoreTools(List<String> coreTools) {
+        this.coreTools = coreTools;
+    }
+
+    public List<String> getExcludeTools() {
+        return excludeTools;
+    }
+
+    public void setExcludeTools(List<String> excludeTools) {
+        this.excludeTools = excludeTools;
+    }
+
+    public List<String> getAllowedTools() {
+        return allowedTools;
+    }
+
+    public void setAllowedTools(List<String> allowedTools) {
+        this.allowedTools = allowedTools;
+    }
+
+    public String getAuthType() {
+        return authType;
+    }
+
+    public void setAuthType(String authType) {
+        this.authType = authType;
+    }
+
+    public Boolean getIncludePartialMessages() {
+        return includePartialMessages;
+    }
+
+    public void setIncludePartialMessages(Boolean includePartialMessages) {
+        this.includePartialMessages = includePartialMessages;
+    }
+
+    public Long getTurnTimeoutMs() {
+        return turnTimeoutMs;
+    }
+
+    public void setTurnTimeoutMs(Long turnTimeoutMs) {
+        this.turnTimeoutMs = turnTimeoutMs;
+    }
+
+    public Long getMessageTimeoutMs() {
+        return messageTimeoutMs;
+    }
+
+    public void setMessageTimeoutMs(Long messageTimeoutMs) {
+        this.messageTimeoutMs = messageTimeoutMs;
+    }
+
+    @Override
+    public TransportOptions clone() {
+        try {
+            return (TransportOptions) super.clone();
+        } catch (CloneNotSupportedException e) {
+            throw new AssertionError();
+        }
+    }
+}

packages/sdk-java/src/main/java/com/alibaba/qwen/code/cli/transport/process/ProcessTransport.java

@@ -0,0 +1,182 @@
+package com.alibaba.qwen.code.cli.transport.process;
+
+import com.alibaba.qwen.code.cli.transport.TransportOptions;
+
+import org.apache.commons.lang3.exception.ContextedRuntimeException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.lang.ProcessBuilder.Redirect;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
+
+public class ProcessTransport {
+    private static final Logger log = LoggerFactory.getLogger(ProcessTransport.class);
+    TransportOptionsAdapter transportOptionsAdapter;
+
+    protected final Long turnTimeoutMs;
+    protected final Long messageTimeoutMs;
+
+    protected Process process;
+    protected BufferedWriter processInput;
+    protected BufferedReader processOutput;
+    protected BufferedReader processError;
+
+    public ProcessTransport(TransportOptions transportOptions) throws IOException {
+        this.transportOptionsAdapter = new TransportOptionsAdapter(transportOptions);
+        turnTimeoutMs = transportOptionsAdapter.getHandledTransportOptions().getTurnTimeoutMs();
+        messageTimeoutMs = transportOptionsAdapter.getHandledTransportOptions().getMessageTimeoutMs();
+        start();
+    }
+
+    protected void start() throws IOException {
+        String[] commandArgs = transportOptionsAdapter.buildCommandArgs();
+        log.debug("trans to command args: {}", transportOptionsAdapter);
+
+        ProcessBuilder processBuilder = new ProcessBuilder(commandArgs)
+                .redirectOutput(Redirect.PIPE)
+                .redirectInput(Redirect.PIPE)
+                .redirectError(Redirect.PIPE)
+                .redirectErrorStream(false)
+                .directory(new File(transportOptionsAdapter.getCwd()));
+
+        process = processBuilder.start();
+        processInput = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
+        processOutput = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        processError = new BufferedReader(new InputStreamReader(process.getErrorStream()));
+        startErrorReading();
+    }
+
+    public void close() throws IOException {
+        if (processInput != null) {
+            processInput.close();
+        }
+        if (processOutput != null) {
+            processOutput.close();
+        }
+        if (processError != null) {
+            processError.close();
+        }
+        if (process != null) {
+            process.destroy();
+        }
+    }
+
+    public String inputWaitForOneLine(String message) throws IOException, ExecutionException, InterruptedException, TimeoutException {
+        return inputWaitForOneLine(message, turnTimeoutMs);
+    }
+
+    private String inputWaitForOneLine(String message, long timeOutInMs)
+            throws IOException, TimeoutException, InterruptedException, ExecutionException {
+        inputNoWaitResponse(message);
+        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
+            try {
+                return processOutput.readLine();
+            } catch (IOException e) {
+                throw new ContextedRuntimeException("read line error", e)
+                        .addContextValue("message", message);
+            }
+        });
+
+        try {
+            String line = future.get(timeOutInMs, TimeUnit.MILLISECONDS);
+            log.info("inputWaitForOneLine result: {}", line);
+            return line;
+        } catch (TimeoutException e) {
+            future.cancel(true);
+            log.warn("read message timeout {}, canceled readOneLine task", timeOutInMs, e);
+            throw e;
+        } catch (InterruptedException e) {
+            future.cancel(true);
+            log.warn("interrupted task, canceled task", e);
+            throw e;
+        } catch (ExecutionException e) {
+            future.cancel(true);
+            log.warn("the readOneLine task execute error", e);
+            throw e;
+        }
+    }
+
+    public void inputWaitForMultiLine(String message, Function<String, Boolean> callBackFunction) throws IOException {
+        inputWaitForMultiLine(message, callBackFunction, turnTimeoutMs);
+    }
+
+    private void inputWaitForMultiLine(String message, Function<String, Boolean> callBackFunction, long timeOutInMs) throws IOException {
+        log.debug("input message for multiLine: {}", message);
+        inputNoWaitResponse(message);
+
+        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> iterateOutput(callBackFunction));
+        try {
+            future.get(timeOutInMs, TimeUnit.MILLISECONDS);
+        } catch (TimeoutException e) {
+            future.cancel(true);
+            log.warn("read message timeout {}, canceled readMultiMessages task", timeOutInMs, e);
+        } catch (InterruptedException e) {
+            future.cancel(true);
+            log.warn("interrupted task, canceled task", e);
+        } catch (ExecutionException e) {
+            future.cancel(true);
+            log.warn("the readMultiMessages task execute error", e);
+        } catch (Exception e) {
+            future.cancel(true);
+            log.warn("other  error");
+        }
+    }
+
+    public void inputNoWaitResponse(String message) throws IOException {
+        log.debug("input message to agent: {}", message);
+        processInput.write(message);
+        processInput.newLine();
+        processInput.flush();
+    }
+
+    private void startErrorReading() {
+        CompletableFuture.runAsync(() -> {
+            try {
+                String line;
+                while ((line = processError.readLine()) != null) {
+                    System.err.println("错误: " + line);
+                }
+            } catch (Exception e) {
+                System.err.println("错误: " + e.getMessage());
+            }
+        });
+    }
+
+    private void iterateOutput(Function<String, Boolean> callBackFunction) {
+        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+            try {
+                for (String line = processOutput.readLine(); line != null; line = processOutput.readLine()) {
+                    log.debug("read a message from agent {}", line);
+                    if (callBackFunction.apply(line)) {
+                        break;
+                    }
+                }
+            } catch (IOException e) {
+                throw new RuntimeException("read process output error", e);
+            }
+        });
+
+        try {
+            future.get(messageTimeoutMs, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            log.warn("read message task interrupted", e);
+            future.cancel(true);
+        } catch (TimeoutException e) {
+            log.warn("Operation timed out", e);
+            future.cancel(true);
+        } catch (Exception e) {
+            future.cancel(true);
+            log.warn("Operation error", e);
+        }
+    }
+}

packages/sdk-java/src/main/java/com/alibaba/qwen/code/cli/transport/process/TransportOptionsAdapter.java

@@ -0,0 +1,102 @@
+package com.alibaba.qwen.code.cli.transport.process;
+
+import com.alibaba.qwen.code.cli.transport.TransportOptions;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+class TransportOptionsAdapter {
+    TransportOptions transportOptions;
+    private static final Long DEFAULT_TURN_TIMEOUT_MS = 1000 * 60 * 30L;
+    private static final Long DEFAULT_MESSAGE_TIMEOUT_MS = 1000 * 60 * 3L;
+
+    TransportOptionsAdapter(TransportOptions userTransportOptions) {
+        transportOptions = addDefaultTransportOptions(userTransportOptions);
+    }
+
+    TransportOptions getHandledTransportOptions() {
+        return transportOptions;
+    }
+
+    String getCwd() {
+        return transportOptions.getCwd();
+    }
+
+    String[] buildCommandArgs() {
+        List<String> args = new ArrayList<>(
+                Arrays.asList(transportOptions.getPathToQwenExecutable(), "--input-format", "stream-json", "--output-format",
+                        "stream-json", "--channel=SDK"));
+
+        if (StringUtils.isNotBlank(transportOptions.getModel())) {
+            args.add("--model");
+            args.add(transportOptions.getModel());
+        }
+
+        if (transportOptions.getPermissionMode() != null) {
+            args.add("--permission-mode");
+            args.add(transportOptions.getPermissionMode().getValue());
+        }
+
+        if (transportOptions.getMaxSessionTurns() != null) {
+            args.add("--max-session-turns");
+            args.add(transportOptions.getMaxSessionTurns().toString());
+        }
+
+        if (transportOptions.getCoreTools() != null && !transportOptions.getCoreTools().isEmpty()) {
+            args.add("--core-tools");
+            args.add(String.join(",", transportOptions.getCoreTools()));
+        }
+
+        if (transportOptions.getExcludeTools() != null && !transportOptions.getExcludeTools().isEmpty()) {
+            args.add("--exclude-tools");
+            args.add(String.join(",", transportOptions.getExcludeTools()));
+        }
+
+        if (transportOptions.getAllowedTools() != null && !transportOptions.getAllowedTools().isEmpty()) {
+            args.add("--allowed-tools");
+            args.add(String.join(",", transportOptions.getAllowedTools()));
+        }
+
+        if (StringUtils.isNotBlank(transportOptions.getAuthType())) {
+            args.add("--auth-type");
+            args.add(transportOptions.getAuthType());
+        }
+
+        if (transportOptions.getIncludePartialMessages() != null && transportOptions.getIncludePartialMessages()) {
+            args.add("--include-partial-messages");
+        }
+        return args.toArray(new String[] {});
+    }
+
+    private TransportOptions addDefaultTransportOptions(TransportOptions userTransportOptions) {
+        TransportOptions transportOptions = userTransportOptions.clone();
+
+        if (StringUtils.isBlank(transportOptions.getPathToQwenExecutable())) {
+            transportOptions.setPathToQwenExecutable("qwen");
+        }
+
+        if (StringUtils.isBlank(transportOptions.getCwd())) {
+            transportOptions.setCwd(new File("").getAbsolutePath());
+        }
+
+        Map<String, String> env = new HashMap<>(System.getenv());
+        Optional.ofNullable(transportOptions.getEnv()).ifPresent(env::putAll);
+        transportOptions.setEnv(env);
+
+        if (transportOptions.getTurnTimeoutMs() == null) {
+            transportOptions.setTurnTimeoutMs(DEFAULT_TURN_TIMEOUT_MS);
+        }
+
+        if (transportOptions.getMessageTimeoutMs() == null) {
+            transportOptions.setMessageTimeoutMs(DEFAULT_MESSAGE_TIMEOUT_MS);
+        }
+        return transportOptions;
+    }
+}

packages/sdk-java/src/test/java/com/alibaba/qwen/code/cli/transport/PermissionModeTest.java

@@ -0,0 +1,17 @@
+package com.alibaba.qwen.code.cli.transport;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class PermissionModeTest {
+
+    @Test
+    public void shouldBeReturnQwenPermissionModeValue() {
+        assertEquals("default", PermissionMode.DEFAULT.getValue());
+        assertEquals("plan", PermissionMode.PLAN.getValue());
+        assertEquals("auto-edit", PermissionMode.AUTO_EDIT.getValue());
+        assertEquals("yolo", PermissionMode.YOLO.getValue());
+    }
+
+}

packages/sdk-java/src/test/java/com/alibaba/qwen/code/cli/transport/process/ProcessTransportTest.java

@@ -0,0 +1,29 @@
+package com.alibaba.qwen.code.cli.transport.process;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+
+import com.alibaba.qwen.code.cli.transport.TransportOptions;
+
+import org.junit.jupiter.api.Test;
+
+class ProcessTransportTest {
+
+    @Test
+    void shouldStartAndCloseSuccessfully() throws IOException {
+        TransportOptions transportOptions = new TransportOptions();
+        ProcessTransport processTransport = new ProcessTransport(transportOptions);
+        processTransport.close();
+    }
+
+    @Test
+    void shouldInputWaitForOneLineSuccessfully() throws IOException, ExecutionException, InterruptedException, TimeoutException {
+        TransportOptions transportOptions = new TransportOptions();
+        ProcessTransport processTransport = new ProcessTransport(transportOptions);
+
+        String message = "{\"type\": \"control_request\", \"request_id\": \"1\", \"request\": {\"subtype\": \"initialize\"} }";
+        System.out.println(processTransport.inputWaitForOneLine(message));
+    }
+
+}

packages/sdk-typescript/src/utils/cliPath.ts

@@ -150,49 +150,48 @@ export function parseExecutableSpec(executableSpec?: string): {
   }
 
   // Check for runtime prefix (e.g., 'bun:/path/to/cli.js')
-  // Use whitelist mechanism: only treat as runtime spec if prefix matches supported runtimes
-  const supportedRuntimes = ['node', 'bun', 'tsx', 'deno'];
   const runtimeMatch = executableSpec.match(/^([^:]+):(.+)$/);
-
   if (runtimeMatch) {
     const [, runtime, filePath] = runtimeMatch;
-
-    // Only process as runtime specification if it matches a supported runtime
-    if (runtime && supportedRuntimes.includes(runtime)) {
-      if (!filePath) {
-        throw new Error(`Invalid runtime specification: '${executableSpec}'`);
-      }
-
-      if (!validateRuntimeAvailability(runtime)) {
-        throw new Error(
-          `Runtime '${runtime}' is not available on this system. Please install it first.`,
-        );
-      }
-
-      const resolvedPath = path.resolve(filePath);
-
-      if (!fs.existsSync(resolvedPath)) {
-        throw new Error(
-          `Executable file not found at '${resolvedPath}' for runtime '${runtime}'. ` +
-            'Please check the file path and ensure the file exists.',
-        );
-      }
-
-      if (!validateFileExtensionForRuntime(resolvedPath, runtime)) {
-        const ext = path.extname(resolvedPath);
-        throw new Error(
-          `File extension '${ext}' is not compatible with runtime '${runtime}'. ` +
-            `Expected extensions for ${runtime}: ${getExpectedExtensions(runtime).join(', ')}`,
-        );
-      }
-
-      return {
-        runtime,
-        executablePath: resolvedPath,
-        isExplicitRuntime: true,
-      };
+    if (!runtime || !filePath) {
+      throw new Error(`Invalid runtime specification: '${executableSpec}'`);
     }
-    // If not a supported runtime, fall through to treat as file path (e.g., Windows paths like 'D:\path\to\cli.js')
+
+    const supportedRuntimes = ['node', 'bun', 'tsx', 'deno'];
+    if (!supportedRuntimes.includes(runtime)) {
+      throw new Error(
+        `Unsupported runtime '${runtime}'. Supported runtimes: ${supportedRuntimes.join(', ')}`,
+      );
+    }
+
+    if (!validateRuntimeAvailability(runtime)) {
+      throw new Error(
+        `Runtime '${runtime}' is not available on this system. Please install it first.`,
+      );
+    }
+
+    const resolvedPath = path.resolve(filePath);
+
+    if (!fs.existsSync(resolvedPath)) {
+      throw new Error(
+        `Executable file not found at '${resolvedPath}' for runtime '${runtime}'. ` +
+          'Please check the file path and ensure the file exists.',
+      );
+    }
+
+    if (!validateFileExtensionForRuntime(resolvedPath, runtime)) {
+      const ext = path.extname(resolvedPath);
+      throw new Error(
+        `File extension '${ext}' is not compatible with runtime '${runtime}'. ` +
+          `Expected extensions for ${runtime}: ${getExpectedExtensions(runtime).join(', ')}`,
+      );
+    }
+
+    return {
+      runtime,
+      executablePath: resolvedPath,
+      isExplicitRuntime: true,
+    };
   }
 
   // Check if it's a command name (no path separators) or a file path

packages/sdk-typescript/test/unit/cliPath.test.ts

@@ -125,43 +125,12 @@ describe('CLI Path Utilities', () => {
         });
       });
 
-      it('should treat non-whitelisted runtime prefixes as command names', () => {
-        // With whitelist approach, 'invalid:format' is not recognized as a runtime spec
-        // so it's treated as a command name, which fails validation due to the colon
+      it('should throw for invalid runtime prefix format', () => {
         expect(() => parseExecutableSpec('invalid:format')).toThrow(
-          'Invalid command name',
+          'Unsupported runtime',
         );
       });
 
-      it('should treat Windows drive letters as file paths, not runtime specs', () => {
-        mockFs.existsSync.mockReturnValue(true);
-
-        // Test various Windows drive letters
-        const windowsPaths = [
-          'C:\\path\\to\\cli.js',
-          'D:\\path\\to\\cli.js',
-          'E:\\Users\\dev\\qwen\\cli.js',
-        ];
-
-        for (const winPath of windowsPaths) {
-          const result = parseExecutableSpec(winPath);
-
-          expect(result.isExplicitRuntime).toBe(false);
-          expect(result.runtime).toBeUndefined();
-          expect(result.executablePath).toBe(path.resolve(winPath));
-        }
-      });
-
-      it('should handle Windows paths with forward slashes', () => {
-        mockFs.existsSync.mockReturnValue(true);
-
-        const result = parseExecutableSpec('C:/path/to/cli.js');
-
-        expect(result.isExplicitRuntime).toBe(false);
-        expect(result.runtime).toBeUndefined();
-        expect(result.executablePath).toBe(path.resolve('C:/path/to/cli.js'));
-      });
-
       it('should throw when runtime-prefixed file does not exist', () => {
         mockFs.existsSync.mockReturnValue(false);
 
@@ -484,41 +453,6 @@ describe('CLI Path Utilities', () => {
         originalInput: `bun:${bundlePath}`,
       });
     });
-
-    it('should handle Windows paths with drive letters', () => {
-      const windowsPath = 'D:\\path\\to\\cli.js';
-      const result = prepareSpawnInfo(windowsPath);
-
-      expect(result).toEqual({
-        command: process.execPath,
-        args: [path.resolve(windowsPath)],
-        type: 'node',
-        originalInput: windowsPath,
-      });
-    });
-
-    it('should handle Windows paths with TypeScript files', () => {
-      const windowsPath = 'C:\\Users\\dev\\qwen\\index.ts';
-      const result = prepareSpawnInfo(windowsPath);
-
-      expect(result).toEqual({
-        command: 'tsx',
-        args: [path.resolve(windowsPath)],
-        type: 'tsx',
-        originalInput: windowsPath,
-      });
-    });
-
-    it('should not confuse Windows drive letters with runtime prefixes', () => {
-      // Ensure 'D:' is not treated as a runtime specification
-      const windowsPath = 'D:\\workspace\\project\\cli.js';
-      const result = prepareSpawnInfo(windowsPath);
-
-      // Should use node runtime based on .js extension, not treat 'D' as runtime
-      expect(result.type).toBe('node');
-      expect(result.command).toBe(process.execPath);
-      expect(result.args).toEqual([path.resolve(windowsPath)]);
-    });
   });
 
   describe('error cases', () => {
@@ -538,39 +472,21 @@ describe('CLI Path Utilities', () => {
       );
     });
 
-    it('should treat non-whitelisted runtime prefixes as command names', () => {
-      // With whitelist approach, 'invalid:spec' is not recognized as a runtime spec
-      // so it's treated as a command name, which fails validation due to the colon
+    it('should provide helpful error for invalid runtime specification', () => {
       expect(() => prepareSpawnInfo('invalid:spec')).toThrow(
-        'Invalid command name',
-      );
-    });
-
-    it('should handle Windows paths correctly even when file is missing', () => {
-      mockFs.existsSync.mockReturnValue(false);
-
-      expect(() => prepareSpawnInfo('D:\\missing\\cli.js')).toThrow(
-        'Executable file not found at',
-      );
-      // Should not throw 'Invalid command name' error (which would happen if 'D:' was treated as invalid command)
-      expect(() => prepareSpawnInfo('D:\\missing\\cli.js')).not.toThrow(
-        'Invalid command name',
+        'Unsupported runtime',
       );
     });
   });
 
   describe('comprehensive validation', () => {
     describe('runtime validation', () => {
-      it('should treat unsupported runtime prefixes as file paths', () => {
-        mockFs.existsSync.mockReturnValue(true);
-
-        // With whitelist approach, 'unsupported:' is not recognized as a runtime spec
-        // so 'unsupported:/path/to/file.js' is treated as a file path
-        const result = parseExecutableSpec('unsupported:/path/to/file.js');
-
-        // Should be treated as a file path, not a runtime specification
-        expect(result.isExplicitRuntime).toBe(false);
-        expect(result.runtime).toBeUndefined();
+      it('should reject unsupported runtimes', () => {
+        expect(() =>
+          parseExecutableSpec('unsupported:/path/to/file.js'),
+        ).toThrow(
+          "Unsupported runtime 'unsupported'. Supported runtimes: node, bun, tsx, deno",
+        );
       });
 
       it('should validate runtime availability for explicit runtime specs', () => {