atsq 1.0.0a4__tar.gz

atsq-1.0.0a4/.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: atsq CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+# One pipeline per ref at a time: the self-hosted runner hosts several repos,
+# and parallel docker integration stacks collide on memory.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+# The runner may not have python3.13/3.14 binaries; python-checks.yml would
+# silently fall back to python3. So every job pins its interpreter through
+# uv (which downloads the requested CPython itself) instead of relying on
+# the workflow's python_version resolution.
+
+jobs:
+  unit-py312:
+    uses: dev-lukas/ci-cd-actions/.github/workflows/python-checks.yml@main
+    with:
+      install_command: python -m pip install --quiet uv && uv sync --frozen --python 3.12
+      check_commands: |
+        uv run --frozen ruff check src tests
+        uv run --frozen mypy
+        uv run --frozen pytest -q
+
+  unit-py313:
+    uses: dev-lukas/ci-cd-actions/.github/workflows/python-checks.yml@main
+    with:
+      install_command: python -m pip install --quiet uv && uv sync --frozen --python 3.13
+      check_commands: |
+        uv run --frozen python -c "import sys; assert sys.version_info[:2] == (3, 13), sys.version"
+        uv run --frozen pytest -q
+
+  unit-py314:
+    uses: dev-lukas/ci-cd-actions/.github/workflows/python-checks.yml@main
+    with:
+      install_command: python -m pip install --quiet uv && uv sync --frozen --python 3.14
+      check_commands: |
+        uv run --frozen python -c "import sys; assert sys.version_info[:2] == (3, 14), sys.version"
+        uv run --frozen pytest -q
+
+  integration:
+    needs: [unit-py312, unit-py313, unit-py314]
+    if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
+    uses: dev-lukas/ci-cd-actions/.github/workflows/python-checks.yml@main
+    with:
+      install_command: python -m pip install --quiet uv && uv sync --frozen --python 3.12
+      check_commands: |
+        ./scripts/run-integration-tests.sh

atsq-1.0.0a4/.github/workflows/release.yml

@@ -0,0 +1,53 @@
+name: Release to PyPI
+
+# Publishes on version tags (e.g. 1.0.0a4) via PyPI Trusted Publishing:
+# the pypa action exchanges GitHub's OIDC token for a short-lived PyPI
+# token - no stored secrets. The publisher is registered on PyPI as
+# repo dev-lukas/atsq, workflow release.yml, environment pypi.
+on:
+  push:
+    tags:
+      # glob, not regex: any x.y.z-style tag incl. pre-releases (1.0.0a4)
+      - "[0-9]*.[0-9]*.[0-9]*"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: self-hosted
+    steps:
+      - uses: actions/checkout@v6.0.2
+      - name: Build sdist and wheel
+        # The venv lives OUTSIDE the checkout: anything inside the project
+        # dir would get packed into the sdist and break the build.
+        run: |
+          set -euo pipefail
+          python3 -m venv "$RUNNER_TEMP/release-venv"
+          "$RUNNER_TEMP/release-venv/bin/pip" install --quiet uv
+          "$RUNNER_TEMP/release-venv/bin/uv" build
+      - name: Check tag matches project version
+        run: |
+          set -euo pipefail
+          version="$("$RUNNER_TEMP/release-venv/bin/uv" version --short)"
+          [ "$version" = "${GITHUB_REF_NAME}" ] || {
+            echo "tag ${GITHUB_REF_NAME} != pyproject version ${version}" >&2
+            exit 1
+          }
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: self-hosted
+    environment: pypi
+    permissions:
+      id-token: write  # OIDC for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

atsq-1.0.0a4/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

atsq-1.0.0a4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lukas Roth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atsq-1.0.0a4/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: atsq
+Version: 1.0.0a4
+Summary: Asyncio TeamSpeak ServerQuery client for TeamSpeak 3 and TeamSpeak 6 over SSH
+Project-URL: Repository, https://github.com/dev-lukas/atsq
+Author: Lukas Roth
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Communications :: Conferencing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: asyncssh>=2.14
+Description-Content-Type: text/markdown
+
+# atsq
+
+Asyncio TeamSpeak ServerQuery client for **TeamSpeak 3** and **TeamSpeak 6**, over SSH.
+
+TeamSpeak 6 removed the classic raw/telnet ServerQuery — SSH query (port 10022) is the
+only line-protocol interface left. `atsq` speaks that protocol against both server
+generations with one async API, runs on modern Python (3.12–3.14+), and its whole test
+suite executes against real `teamspeak:3.13` and `teamspeaksystems/teamspeak6-server`
+containers.
+
+## Why
+
+- [`py-ts3`](https://github.com/benediktschmitt/py-ts3) is unmaintained and imports
+  `telnetlib` at module load — removed from the standard library in Python 3.13.
+- TeamSpeak 6 servers only offer SSH query (and HTTP WebQuery).
+- Bots want asyncio-native ergonomics: awaitable commands, `@client.on` event handlers,
+  automatic keepalive and reconnect — the `discord.py` feel.
+
+## Install
+
+```
+uv add atsq          # or: pip install atsq
+```
+
+Requires Python ≥ 3.12. The only runtime dependency is
+[asyncssh](https://asyncssh.readthedocs.io/).
+
+## Usage
+
+One-shot administrative session:
+
+```python
+import atsq
+
+async with await atsq.connect("ts.example.com", 10022,
+                             password="...", server_id=1) as ts:
+    for row in await ts.client_list("uid"):
+        print(row["clid"], row["client_nickname"])
+    cid = await ts.channel_create("Lounge", channel_flag_permanent=1)
+```
+
+Long-running bot with events and automatic reconnect:
+
+```python
+client = atsq.Client("ts.example.com", 10022, password="...",
+                    server_id=1,                    # or server_port=9987
+                    nickname="My Bot",              # re-applied on reconnect
+                    register_events=atsq.ALL_EVENTS) # or "server", or a list
+
+@client.on("cliententerview")
+async def on_join(event: atsq.Event) -> None:
+    if event.get("reasonid") == "0" and event.get("client_type") == "0":
+        print("joined:", event["client_unique_identifier"])
+
+@client.on("clientleftview")
+async def on_leave(event: atsq.Event) -> None:
+    print("left:", event.get("clid"))
+
+await client.run_forever()   # reconnects with backoff; keepalive automatic
+```
+
+Pull-style event consumption (instead of handlers):
+
+```python
+async for event in client.events():
+    handle(event)
+# or: event = await client.wait_for_event(timeout=240)
+```
+
+Anything without a typed wrapper goes through the generic escape-safe `exec()`,
+including pipelined bulk commands (many parameter blocks, one round trip):
+
+```python
+rows = await ts.exec("servergrouplist")
+await ts.exec("clientmove", clid=5, cid=42)
+await ts.exec("channeladdperm", cid=60, blocks=[
+    {"permsid": "i_channel_needed_join_power", "permvalue": 75},
+    {"permsid": "i_channel_needed_subscribe_power", "permvalue": 60},
+])
+```
+
+Wire constants are available as `StrEnum`s that compare directly against
+event/row values:
+
+```python
+from atsq import ReasonId, TargetMode, ClientType, LEAVE_REASONS
+
+if event["reasonid"] == ReasonId.CONNECT and event["client_type"] == ClientType.VOICE:
+    ...
+if event.get("reasonid") in LEAVE_REASONS:
+    ...
+```
+
+File transfer (icons, avatars, channel files) — same API against TS3 and TS6:
+
+```python
+ft = atsq.FileTransfer(client)
+icon_id = await ft.upload_icon(png_bytes)            # crc32-named, returns the id
+data = await ft.download("/atsq.bin", cid=42)
+rows = await ft.file_list(cid=42, path="/")          # [] for empty dirs
+await ft.delete_file("/atsq.bin", cid=42)
+```
+
+### Errors
+
+```python
+try:
+    await ts.use(99)
+except atsq.QueryError as e:        # error id != 0; str(e) carries the server msg
+    print(e.error_id, e.msg)
+except atsq.QueryTimeoutError:      # no response in time (connection is closed)
+    ...
+except atsq.ConnectionClosedError:  # connection gone
+    ...
+```
+
+`atsq.FloodError` (a `QueryError`, id 524) signals server flood protection — add your
+client's IP to the server's `query_ip_allowlist.txt` to be exempt.
+
+### Defaults worth knowing
+
+- **Keepalive**: automatic `whoami` after 240 s idle (servers kick at ~300 s).
+  Configure via `keepalive_interval`; `0` disables.
+- **Flood protection**: an `error 524` is retried automatically after the wait
+  the server asks for (`flood_retries`, default 2; `0` disables). Allowlisted
+  IPs (`query_ip_allowlist.txt`) never hit it in the first place.
+- **Snapshots** work via plain `exec("serversnapshotcreate")` /
+  `exec("serversnapshotdeploy", version=..., data=...)` — note deploy
+  deselects the session; call `use` again afterwards.
+- **Reconnect** (`run_forever`): exponential backoff 5 s → 300 s; a server message
+  containing "banned" waits 300 s. `use`/`servernotifyregister` and `on_ready` re-run
+  after every reconnect.
+- **Host keys**: verification is off by default (TeamSpeak servers generate ephemeral
+  query host keys). Pin one in production: `atsq.connect(..., known_hosts=...)`
+  (forwarded to asyncssh).
+- **close() sends `quit`**: on TS6 a query client that silently drops the SSH
+  connection never produces a `notifyclientleftview`; a clean `quit` does (on both
+  generations). See [docs/dialects.md](docs/dialects.md).
+
+## TS3 vs TS6
+
+Probed against real servers — the wire dialects are near-identical, and `atsq`
+auto-detects the generation from the greeting (`client.dialect`). All recorded
+differences and server-config notes live in [docs/dialects.md](docs/dialects.md).
+
+Enable SSH query on a TS3 server with `TS3SERVER_QUERY_PROTOCOLS=raw,ssh`; on TS6 with
+`TSSERVER_QUERY_SSH_ENABLED=1` (password via `TSSERVER_QUERY_ADMIN_PASSWORD`).
+
+## Migrating from py-ts3
+
+| py-ts3 | atsq |
+|---|---|
+| `TS3ServerConnection("telnet://user:pass@host:10011")` | `await atsq.connect(host, 10022, username=..., password=...)` (SSH) |
+| `conn.exec_("clientlist", "uid")` | `await ts.exec("clientlist", "uid")` or `await ts.client_list("uid")` |
+| response `resp[0]["cldbid"]` | same shape: `rows[0]["cldbid"]` (`list[dict[str, str]]`) |
+| `conn.wait_for_event(timeout=240)` | `await client.wait_for_event(timeout=240)` or `@client.on(...)` |
+| `event[0]["reasonid"]` | `event["reasonid"]` (Event is a `Mapping[str, str]`) |
+| `conn.send_keepalive()` | automatic (or `await ts.send_keepalive()`) |
+| `ts3.query.TS3QueryError` | `atsq.QueryError` (str() still contains the server msg) |
+| `ts3.query.TS3TimeoutError` | `atsq.QueryTimeoutError` |
+| query builder `.pipe()` | `exec(cmd, blocks=[{...}, {...}], **shared)` |
+| `ts3.definitions` constants | `atsq.ReasonId` / `TargetMode` / `ClientType` / `LEAVE_REASONS` |
+| `ts3.filetransfer.TS3FileTransfer` | `atsq.FileTransfer` (asyncio, TS3+TS6) |
+| manual reconnect loop | `await client.run_forever()` |
+
+## Development
+
+```
+uv sync
+uv run pytest                        # unit + fake-transport tests (no docker)
+./scripts/run-integration-tests.sh   # full suite vs real TS3 + TS6 in docker
+uv run ruff check src tests scripts && uv run mypy
+```
+
+`scripts/probe_dialect.py` records raw protocol transcripts from a live server —
+rerun it when a new TS6 build lands and diff against `tests/unit/fixtures/`.
+
+## License
+
+MIT

atsq-1.0.0a4/README.md

@@ -0,0 +1,180 @@
+# atsq
+
+Asyncio TeamSpeak ServerQuery client for **TeamSpeak 3** and **TeamSpeak 6**, over SSH.
+
+TeamSpeak 6 removed the classic raw/telnet ServerQuery — SSH query (port 10022) is the
+only line-protocol interface left. `atsq` speaks that protocol against both server
+generations with one async API, runs on modern Python (3.12–3.14+), and its whole test
+suite executes against real `teamspeak:3.13` and `teamspeaksystems/teamspeak6-server`
+containers.
+
+## Why
+
+- [`py-ts3`](https://github.com/benediktschmitt/py-ts3) is unmaintained and imports
+  `telnetlib` at module load — removed from the standard library in Python 3.13.
+- TeamSpeak 6 servers only offer SSH query (and HTTP WebQuery).
+- Bots want asyncio-native ergonomics: awaitable commands, `@client.on` event handlers,
+  automatic keepalive and reconnect — the `discord.py` feel.
+
+## Install
+
+```
+uv add atsq          # or: pip install atsq
+```
+
+Requires Python ≥ 3.12. The only runtime dependency is
+[asyncssh](https://asyncssh.readthedocs.io/).
+
+## Usage
+
+One-shot administrative session:
+
+```python
+import atsq
+
+async with await atsq.connect("ts.example.com", 10022,
+                             password="...", server_id=1) as ts:
+    for row in await ts.client_list("uid"):
+        print(row["clid"], row["client_nickname"])
+    cid = await ts.channel_create("Lounge", channel_flag_permanent=1)
+```
+
+Long-running bot with events and automatic reconnect:
+
+```python
+client = atsq.Client("ts.example.com", 10022, password="...",
+                    server_id=1,                    # or server_port=9987
+                    nickname="My Bot",              # re-applied on reconnect
+                    register_events=atsq.ALL_EVENTS) # or "server", or a list
+
+@client.on("cliententerview")
+async def on_join(event: atsq.Event) -> None:
+    if event.get("reasonid") == "0" and event.get("client_type") == "0":
+        print("joined:", event["client_unique_identifier"])
+
+@client.on("clientleftview")
+async def on_leave(event: atsq.Event) -> None:
+    print("left:", event.get("clid"))
+
+await client.run_forever()   # reconnects with backoff; keepalive automatic
+```
+
+Pull-style event consumption (instead of handlers):
+
+```python
+async for event in client.events():
+    handle(event)
+# or: event = await client.wait_for_event(timeout=240)
+```
+
+Anything without a typed wrapper goes through the generic escape-safe `exec()`,
+including pipelined bulk commands (many parameter blocks, one round trip):
+
+```python
+rows = await ts.exec("servergrouplist")
+await ts.exec("clientmove", clid=5, cid=42)
+await ts.exec("channeladdperm", cid=60, blocks=[
+    {"permsid": "i_channel_needed_join_power", "permvalue": 75},
+    {"permsid": "i_channel_needed_subscribe_power", "permvalue": 60},
+])
+```
+
+Wire constants are available as `StrEnum`s that compare directly against
+event/row values:
+
+```python
+from atsq import ReasonId, TargetMode, ClientType, LEAVE_REASONS
+
+if event["reasonid"] == ReasonId.CONNECT and event["client_type"] == ClientType.VOICE:
+    ...
+if event.get("reasonid") in LEAVE_REASONS:
+    ...
+```
+
+File transfer (icons, avatars, channel files) — same API against TS3 and TS6:
+
+```python
+ft = atsq.FileTransfer(client)
+icon_id = await ft.upload_icon(png_bytes)            # crc32-named, returns the id
+data = await ft.download("/atsq.bin", cid=42)
+rows = await ft.file_list(cid=42, path="/")          # [] for empty dirs
+await ft.delete_file("/atsq.bin", cid=42)
+```
+
+### Errors
+
+```python
+try:
+    await ts.use(99)
+except atsq.QueryError as e:        # error id != 0; str(e) carries the server msg
+    print(e.error_id, e.msg)
+except atsq.QueryTimeoutError:      # no response in time (connection is closed)
+    ...
+except atsq.ConnectionClosedError:  # connection gone
+    ...
+```
+
+`atsq.FloodError` (a `QueryError`, id 524) signals server flood protection — add your
+client's IP to the server's `query_ip_allowlist.txt` to be exempt.
+
+### Defaults worth knowing
+
+- **Keepalive**: automatic `whoami` after 240 s idle (servers kick at ~300 s).
+  Configure via `keepalive_interval`; `0` disables.
+- **Flood protection**: an `error 524` is retried automatically after the wait
+  the server asks for (`flood_retries`, default 2; `0` disables). Allowlisted
+  IPs (`query_ip_allowlist.txt`) never hit it in the first place.
+- **Snapshots** work via plain `exec("serversnapshotcreate")` /
+  `exec("serversnapshotdeploy", version=..., data=...)` — note deploy
+  deselects the session; call `use` again afterwards.
+- **Reconnect** (`run_forever`): exponential backoff 5 s → 300 s; a server message
+  containing "banned" waits 300 s. `use`/`servernotifyregister` and `on_ready` re-run
+  after every reconnect.
+- **Host keys**: verification is off by default (TeamSpeak servers generate ephemeral
+  query host keys). Pin one in production: `atsq.connect(..., known_hosts=...)`
+  (forwarded to asyncssh).
+- **close() sends `quit`**: on TS6 a query client that silently drops the SSH
+  connection never produces a `notifyclientleftview`; a clean `quit` does (on both
+  generations). See [docs/dialects.md](docs/dialects.md).
+
+## TS3 vs TS6
+
+Probed against real servers — the wire dialects are near-identical, and `atsq`
+auto-detects the generation from the greeting (`client.dialect`). All recorded
+differences and server-config notes live in [docs/dialects.md](docs/dialects.md).
+
+Enable SSH query on a TS3 server with `TS3SERVER_QUERY_PROTOCOLS=raw,ssh`; on TS6 with
+`TSSERVER_QUERY_SSH_ENABLED=1` (password via `TSSERVER_QUERY_ADMIN_PASSWORD`).
+
+## Migrating from py-ts3
+
+| py-ts3 | atsq |
+|---|---|
+| `TS3ServerConnection("telnet://user:pass@host:10011")` | `await atsq.connect(host, 10022, username=..., password=...)` (SSH) |
+| `conn.exec_("clientlist", "uid")` | `await ts.exec("clientlist", "uid")` or `await ts.client_list("uid")` |
+| response `resp[0]["cldbid"]` | same shape: `rows[0]["cldbid"]` (`list[dict[str, str]]`) |
+| `conn.wait_for_event(timeout=240)` | `await client.wait_for_event(timeout=240)` or `@client.on(...)` |
+| `event[0]["reasonid"]` | `event["reasonid"]` (Event is a `Mapping[str, str]`) |
+| `conn.send_keepalive()` | automatic (or `await ts.send_keepalive()`) |
+| `ts3.query.TS3QueryError` | `atsq.QueryError` (str() still contains the server msg) |
+| `ts3.query.TS3TimeoutError` | `atsq.QueryTimeoutError` |
+| query builder `.pipe()` | `exec(cmd, blocks=[{...}, {...}], **shared)` |
+| `ts3.definitions` constants | `atsq.ReasonId` / `TargetMode` / `ClientType` / `LEAVE_REASONS` |
+| `ts3.filetransfer.TS3FileTransfer` | `atsq.FileTransfer` (asyncio, TS3+TS6) |
+| manual reconnect loop | `await client.run_forever()` |
+
+## Development
+
+```
+uv sync
+uv run pytest                        # unit + fake-transport tests (no docker)
+./scripts/run-integration-tests.sh   # full suite vs real TS3 + TS6 in docker
+uv run ruff check src tests scripts && uv run mypy
+```
+
+`scripts/probe_dialect.py` records raw protocol transcripts from a live server —
+rerun it when a new TS6 build lands and diff against `tests/unit/fixtures/`.
+
+## License
+
+MIT

atsq-1.0.0a4/docker/docker-compose.test.yml

@@ -0,0 +1,62 @@
+# Real TeamSpeak servers for integration tests and the dialect probe.
+#
+# Host ports are ephemeral (127.0.0.1::10022) on purpose: the CI runner is
+# shared between repos, fixed ports would collide. Discover them with
+#   docker compose -p atsq-integration port ts3 10022
+#
+# ts3: serveradmin password is generated on first boot and printed once in
+#      the logs (loginname= "serveradmin", password= "..."). Teardown uses
+#      -v so every run is a first boot.
+#      The query IP allowlist must contain the client's source subnet or the
+#      server drops/bans query connections; 0.0.0.0/0 is fine for these
+#      throwaway test servers only.
+# ts6: password is deterministic via TSSERVER_QUERY_ADMIN_PASSWORD.
+
+name: atsq-integration
+
+services:
+  ts3:
+    image: teamspeak:3.13
+    environment:
+      TS3SERVER_LICENSE: accept
+      TS3SERVER_QUERY_PROTOCOLS: raw,ssh
+    volumes:
+      - ./query_ip_allowlist.txt:/var/ts3server/query_ip_allowlist.txt
+    ports:
+      - "127.0.0.1::10022"
+      - "127.0.0.1::30033"  # file transfer data channel
+    healthcheck:
+      # raw stays enabled solely so this healthcheck can probe the query
+      # interface with the tools available in the image.
+      test: ["CMD-SHELL", "echo quit | nc localhost 10011 | grep -q TS3"]
+      interval: 5s
+      timeout: 5s
+      retries: 24
+
+  # Same TS3 image but WITHOUT the allowlist: connections arrive from the
+  # docker gateway IP and are flood-limited, so the flood/524 handling can
+  # be exercised against a real server (the allowlisted ones never 524).
+  ts3strict:
+    image: teamspeak:3.13
+    environment:
+      TS3SERVER_LICENSE: accept
+      TS3SERVER_QUERY_PROTOCOLS: raw,ssh
+    ports:
+      - "127.0.0.1::10022"
+    healthcheck:
+      test: ["CMD-SHELL", "echo quit | nc localhost 10011 | grep -q TS3"]
+      interval: 5s
+      timeout: 5s
+      retries: 24
+
+  ts6:
+    image: teamspeaksystems/teamspeak6-server:latest
+    environment:
+      TSSERVER_LICENSE_ACCEPTED: accept
+      TSSERVER_QUERY_SSH_ENABLED: "1"
+      TSSERVER_QUERY_ADMIN_PASSWORD: atsq-ci-password
+    volumes:
+      - ./query_ip_allowlist.txt:/var/tsserver/query_ip_allowlist.txt
+    ports:
+      - "127.0.0.1::10022"
+      - "127.0.0.1::30033"  # file transfer data channel

atsq-1.0.0a4/docker/query_ip_allowlist.txt

@@ -0,0 +1,3 @@
+127.0.0.1
+::1
+0.0.0.0/0