How can i setup autojs so that it has always server mode on.

[solid-drui]

I have android phone and want to automate it. This automation requires complete device reset and reinstall of autojs.
I want to execute code from my own machine connecting with sockets, similar to VSCode Extension.

So more detailed:

I have a fresh device with fresh AutoJs installed. I want to have server mode on, so that i can connect to it.

Appreciate for help

[SuperMonster003]

AutoJs6 requires you to manually enable the Server Mode switch after a fresh install. Once enabled, AutoJs6 will keep listening on the port for remote connections.

Connect via TCP to the IP:Port shown on the phone (the port is typically 7347). Each frame uses this layout:

• int32BE length + int32BE type + payload
• type = 1 → JSON
• type = 2 → raw bytes

Workflow:

1. After the connection is established, wait for the server to send a type="hello" message.
2. The client replies with a type="hello" message (including version info).
3. Send type="command" with data.command="run", and include id / name / script.

Below are two examples that connect to AutoJs6 remotely and send commands.

---

Python demo (6.6.4)

Save as autojs6_client_664.py:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import argparse
import json
import socket
import struct
import threading
import time
from typing import Any, Dict, Optional

TYPE_JSON = 1
HEADER_SIZE = 8
MAX_FRAME_SIZE = 64 * 1024 * 1024  # 64MB


def pack_frame(payload: bytes, frame_type: int = TYPE_JSON) -> bytes:
    return struct.pack(">ii", len(payload), frame_type) + payload


def recv_exact(sock: socket.socket, n: int) -> bytes:
    buf = b""
    while len(buf) < n:
        chunk = sock.recv(n - len(buf))
        if not chunk:
            raise ConnectionError("socket closed")
        buf += chunk
    return buf


def recv_frame(sock: socket.socket) -> (int, bytes):
    header = recv_exact(sock, HEADER_SIZE)
    length, frame_type = struct.unpack(">ii", header)
    if length < 0 or length > MAX_FRAME_SIZE:
        raise ValueError(f"invalid frame length: {length}")
    return frame_type, recv_exact(sock, length)


class AutoJs6Client:
    def __init__(self, host: str, port: int, ext_version: str):
        self.host = host
        self.port = port
        self.ext_version = ext_version
        self.sock: Optional[socket.socket] = None
        self._rx_thread: Optional[threading.Thread] = None
        self._stop = threading.Event()
        self._req_id = 1
        self._server_hello = threading.Event()

    def connect(self, timeout: float = 5.0):
        self.sock = socket.create_connection((self.host, self.port), timeout=timeout)
        self.sock.settimeout(None)
        self._rx_thread = threading.Thread(target=self._rx_loop, daemon=True)
        self._rx_thread.start()

    def close(self):
        self._stop.set()
        try:
            if self.sock:
                self.sock.shutdown(socket.SHUT_RDWR)
        except Exception:
            pass
        try:
            if self.sock:
                self.sock.close()
        except Exception:
            pass

    def _next_id(self) -> int:
        rid = self._req_id
        self._req_id += 1
        return rid

    def send_json(self, obj: Dict[str, Any]):
        assert self.sock is not None
        payload = json.dumps(obj, ensure_ascii=False).encode("utf-8")
        self.sock.sendall(pack_frame(payload, TYPE_JSON))

    def wait_server_hello(self, timeout: float = 5.0) -> bool:
        return self._server_hello.wait(timeout=timeout)

    def send_hello(self, err: Optional[str] = None):
        data = {
            # Compatibility: provide both extensionVersion and version
            "extensionVersion": self.ext_version,
            "version": self.ext_version,
        }
        if err:
            data["errorMessage"] = err
        self.send_json({
            "id": self._next_id(),
            "type": "hello",
            "data": data
        })

    def run_script(self, script: str, script_id: str = "demo", name: str = "demo.js"):
        self.send_json({
            "id": self._next_id(),
            "type": "command",
            "data": {
                "command": "run",
                "id": script_id,     # used by server to locate viewId / stop target
                "name": name,        # optional, but recommended
                "script": script
            }
        })

    def stop_script(self, script_id: str = "demo"):
        self.send_json({
            "id": self._next_id(),
            "type": "command",
            "data": {
                "command": "stop",
                "id": script_id
            }
        })

    def stop_all(self):
        self.send_json({
            "id": self._next_id(),
            "type": "command",
            "data": {"command": "stopAll"}
        })

    def _rx_loop(self):
        assert self.sock is not None
        while not self._stop.is_set():
            try:
                frame_type, payload = recv_frame(self.sock)
                if frame_type != TYPE_JSON:
                    # Ignore bytes frames for now (used for project sync)
                    continue
                msg = json.loads(payload.decode("utf-8", errors="replace"))
                mtype = msg.get("type")
                data = msg.get("data")
                # Print all messages for protocol debugging
                print(f"<< {mtype}: {data}")
                if mtype == "hello":
                    self._server_hello.set()
            except (ConnectionError, OSError) as e:
                print(f"[disconnected] {e}")
                break
            except Exception as e:
                print(f"[rx error] {e}")
                break


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("host", help="AutoJs6 device IP (shown in Server Mode)")
    ap.add_argument("port", type=int, help="Port (shown in Server Mode, usually 7347)")
    ap.add_argument("--code", help="JavaScript code to run directly")
    ap.add_argument("--file", help="Read JavaScript code from a file")
    ap.add_argument("--id", default="demo", help="Script id (used for stop targeting)")
    ap.add_argument("--name", default="demo.js", help="Script name")
    ap.add_argument("--ext", default="1.0.0", help="Extension/client version placeholder")
    args = ap.parse_args()

    if not args.code and not args.file:
        ap.error("Either --code or --file must be provided")

    script = args.code
    if args.file:
        with open(args.file, "r", encoding="utf-8") as f:
            script = f.read()

    c = AutoJs6Client(args.host, args.port, args.ext)
    c.connect()

    # Wait for server hello (closer to VSCode extension behavior)
    c.wait_server_hello(timeout=5.0)
    c.send_hello()

    # Slight delay before run (avoid edge cases where server hasn't processed hello yet)
    time.sleep(0.1)
    c.run_script(script, script_id=args.id, name=args.name)

    print(">> run sent. Press Ctrl+C to exit.")
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print(">> stopping...")
        c.stop_script(args.id)
        time.sleep(0.2)
        c.close()


if __name__ == "__main__":
    main()

Python usage example:

python autojs6_client_664.py 192.168.1.20 7347 --code "toast('hello 6.6.4'); console.log('hi');"

---

Node.js demo (6.6.4)

Save as autojs6_client_664.mjs:

import net from "net";
import fs from "fs";

const TYPE_JSON = 1;
const HEADER_SIZE = 8;
const MAX_FRAME_SIZE = 64 * 1024 * 1024;

function usage() {
  console.log(`Usage:
  node autojs6_client_664.mjs <host> <port> --code "<js>"
  node autojs6_client_664.mjs <host> <port> --file script.js

Options:
  --id   <id>    script id (default: demo)
  --name <name>  script name (default: demo.js)
  --ext  <ver>   extension/client version (default: 1.0.0)`);
}

function parseArgs(argv) {
  const args = { id: "demo", name: "demo.js", ext: "1.0.0" };
  const pos = [];
  for (let i = 2; i < argv.length; i++) {
    const a = argv[i];
    if (a === "--code") args.code = argv[++i];
    else if (a === "--file") args.file = argv[++i];
    else if (a === "--id") args.id = argv[++i];
    else if (a === "--name") args.name = argv[++i];
    else if (a === "--ext") args.ext = argv[++i];
    else pos.push(a);
  }
  args.host = pos[0];
  args.port = pos[1] ? parseInt(pos[1], 10) : NaN;
  return args;
}

function writeJson(sock, obj) {
  const payload = Buffer.from(JSON.stringify(obj), "utf8");
  const header = Buffer.allocUnsafe(HEADER_SIZE);
  header.writeInt32BE(payload.length, 0);
  header.writeInt32BE(TYPE_JSON, 4);
  sock.write(header);
  sock.write(payload);
}

function main() {
  const args = parseArgs(process.argv);
  if (!args.host || !Number.isFinite(args.port) || (!args.code && !args.file)) {
    usage();
    process.exit(1);
  }

  const script = args.file ? fs.readFileSync(args.file, "utf8") : args.code;

  let reqId = 1;
  let attached = false;

  const sock = net.createConnection({ host: args.host, port: args.port }, () => {
    console.log(`connected to ${args.host}:${args.port}`);
  });

  let buffer = Buffer.alloc(0);

  function sendHello() {
    const data = {
      extensionVersion: args.ext,
      version: args.ext, // compatibility field
    };
    writeJson(sock, { id: reqId++, type: "hello", data });
  }

  function runScript() {
    writeJson(sock, {
      id: reqId++,
      type: "command",
      data: {
        command: "run",
        id: args.id,
        name: args.name,
        script,
      },
    });
  }

  sock.on("data", (chunk) => {
    buffer = Buffer.concat([buffer, chunk]);
    while (buffer.length >= HEADER_SIZE) {
      const len = buffer.readInt32BE(0);
      const type = buffer.readInt32BE(4);

      if (len < 0 || len > MAX_FRAME_SIZE) {
        console.error(`invalid frame length: ${len}, destroy`);
        sock.destroy();
        return;
      }

      const total = HEADER_SIZE + len;
      if (buffer.length < total) break;

      const payload = buffer.subarray(HEADER_SIZE, total);
      buffer = buffer.subarray(total);

      if (type !== TYPE_JSON) continue;

      let msg;
      try {
        msg = JSON.parse(payload.toString("utf8"));
      } catch (e) {
        console.error("json parse error:", e);
        continue;
      }

      console.log("<<", msg.type, msg.data);

      // VSCode-extension-like flow:
      // wait for server hello -> reply hello -> then send run
      if (!attached && msg.type === "hello") {
        attached = true;
        sendHello();
        setTimeout(runScript, 100);
      }
    }
  });

  sock.on("close", () => console.log("socket closed"));
  sock.on("error", (e) => console.error("socket error:", e));

  process.on("SIGINT", () => {
    console.log("Ctrl+C, closing...");
    sock.destroy();
    process.exit(0);
  });
}

main();

Node.js usage example:

node autojs6_client_664.mjs 192.168.1.20 7347 --code "toast('hello 6.6.4'); console.log('hi');"