Polish native controls

.gitea/workflows/android.yaml

@@ -1,160 +1,67 @@
-name: Android APK
+name: Gitea Android APK
 
-on:
-  push:
-    branches:
-      - main
-    tags:
-      - "v*"
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      publish_release:
-        description: "Create or update a GitHub Release"
-        required: true
-        default: "false"
-        type: choice
-        options:
-          - "false"
-          - "true"
-
-permissions:
-  contents: write
+on: [push]
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    env:
-      PUBLISH_RELEASE: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') || inputs.publish_release == 'true' }}
-
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set version
-        shell: bash
-        run: |
-          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
-            VERSION_NAME="${GITHUB_REF_NAME#v}"
-          else
-            VERSION_NAME="0.1.${GITHUB_RUN_NUMBER}"
-          fi
-          VERSION_CODE=$((1000 + GITHUB_RUN_NUMBER))
-          echo "VERSION_NAME=${VERSION_NAME}" >> "${GITHUB_ENV}"
-          echo "VERSION_CODE=${VERSION_CODE}" >> "${GITHUB_ENV}"
-
-      - name: Set up JDK
-        uses: actions/setup-java@v4
-        with:
-          distribution: temurin
-          java-version: "17"
-
-      - name: Set up Android SDK
-        uses: android-actions/setup-android@v3
-
-      - name: Install Android packages
-        shell: bash
-        run: sdkmanager "platforms;android-35" "build-tools;35.0.0" "platform-tools"
-
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          gradle-version: "8.10.2"
-
-      - name: Configure signing
-        id: signing
-        shell: bash
-        env:
-          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
-          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
-          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
-          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
-        run: |
-          if [[ -z "${ANDROID_KEYSTORE_BASE64}" ]]; then
-            echo "signed=false" >> "${GITHUB_OUTPUT}"
-            exit 0
-          fi
-          echo "${ANDROID_KEYSTORE_BASE64}" | base64 -d > release.jks
-          {
-            echo "storeFile=release.jks"
-            echo "storePassword=${ANDROID_KEYSTORE_PASSWORD}"
-            echo "keyAlias=${ANDROID_KEY_ALIAS}"
-            echo "keyPassword=${ANDROID_KEY_PASSWORD}"
-          } > signing.properties
-          echo "signed=true" >> "${GITHUB_OUTPUT}"
-
       - name: Build APK
-        shell: bash
+        env:
+          CLONE_TOKEN: ${{ secrets.TMUX_GITEA_TOKEN }}
         run: |
-          if [[ "${{ steps.signing.outputs.signed }}" == "true" ]]; then
-            BUILD_TASK=":app:assembleRelease"
-          else
-            BUILD_TASK=":app:assembleDebug"
+          set -eu
+
+          if ! command -v git >/dev/null 2>&1 || ! command -v curl >/dev/null 2>&1 || ! command -v unzip >/dev/null 2>&1; then
+            apt-get update
+            apt-get install -y git curl unzip
           fi
-          gradle "${BUILD_TASK}" \
+          if ! command -v java >/dev/null 2>&1; then
+            apt-get update
+            apt-get install -y openjdk-17-jdk-headless
+          fi
+          java -version
+
+          WORKDIR="${PWD}/source"
+          rm -rf "${WORKDIR}"
+          SERVER_URL="${GITHUB_SERVER_URL:-https://gitea.neatcn.com}"
+          REPOSITORY="${GITHUB_REPOSITORY:-tmux/tmux-browser-android}"
+          AUTH_SERVER_URL="$(printf '%s' "${SERVER_URL}" | sed "s#https://#https://gouki:${CLONE_TOKEN}@#")"
+          git clone "${AUTH_SERVER_URL}/${REPOSITORY}.git" "${WORKDIR}"
+          cd "${WORKDIR}"
+          git checkout "${GITHUB_SHA:-main}"
+
+          export GRADLE_HOME="${PWD}/.ci/gradle-8.10.2"
+          mkdir -p .ci
+          if [ ! -x "${GRADLE_HOME}/bin/gradle" ]; then
+            curl -fsSL -o .ci/gradle.zip https://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+            unzip -q .ci/gradle.zip -d .ci
+          fi
+          export PATH="${GRADLE_HOME}/bin:${PATH}"
+
+          export ANDROID_HOME="${PWD}/.ci/android-sdk"
+          export ANDROID_SDK_ROOT="${ANDROID_HOME}"
+          export CMDLINE_TOOLS="${ANDROID_HOME}/cmdline-tools/latest"
+          if [ ! -x "${CMDLINE_TOOLS}/bin/sdkmanager" ]; then
+            mkdir -p "${ANDROID_HOME}/cmdline-tools"
+            curl -fsSL -o .ci/android-tools.zip https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
+            unzip -q .ci/android-tools.zip -d "${ANDROID_HOME}/cmdline-tools"
+            mv "${ANDROID_HOME}/cmdline-tools/cmdline-tools" "${CMDLINE_TOOLS}"
+          fi
+          export PATH="${CMDLINE_TOOLS}/bin:${ANDROID_HOME}/platform-tools:${PATH}"
+
+          yes | sdkmanager --licenses >/dev/null || true
+          sdkmanager "platforms;android-35" "build-tools;35.0.0" "platform-tools"
+
+          VERSION_NAME="0.1.${GITHUB_RUN_NUMBER:-0}"
+          VERSION_CODE=$((2000 + ${GITHUB_RUN_NUMBER:-0}))
+          gradle :app:assembleDebug \
             -PversionCode="${VERSION_CODE}" \
             -PversionName="${VERSION_NAME}" \
-            -PrepoSlug="${GITHUB_REPOSITORY}"
+            -PrepoSlug="neatstudio/tmux-browser-android"
 
-      - name: Prepare artifacts
-        shell: bash
-        run: |
           mkdir -p release
           APK_PATH="$(find app/build/outputs/apk -name '*.apk' | sort | tail -n 1)"
-          cp "${APK_PATH}" "release/tmux-android.apk"
-          cp "${APK_PATH}" "release/tmux-android-${VERSION_NAME}.apk"
-          SHA256="$(sha256sum release/tmux-android.apk | awk '{print $1}')"
-          APK_URL="https://github.com/${GITHUB_REPOSITORY}/releases/latest/download/tmux-android.apk"
-          RELEASE_PAGE_URL="https://github.com/${GITHUB_REPOSITORY}/releases/latest"
-          cat > release/latest.json << JSON
-          {
-            "versionCode": ${VERSION_CODE},
-            "versionName": "${VERSION_NAME}",
-            "apkUrl": "${APK_URL}",
-            "sha256": "${SHA256}",
-            "releasePageUrl": "${RELEASE_PAGE_URL}",
-            "minSdk": 26
-          }
-          JSON
-
-      - name: Upload workflow artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tmux-android-${{ env.VERSION_NAME }}
-          path: |
-            release/tmux-android.apk
-            release/tmux-android-${{ env.VERSION_NAME }}.apk
-            release/latest.json
-
-      - name: Require signing for release publishing
-        if: env.PUBLISH_RELEASE == 'true' && steps.signing.outputs.signed != 'true'
-        shell: bash
-        run: |
-          echo "Release publishing requires ANDROID_KEYSTORE_BASE64 and signing secrets." >&2
-          exit 1
-
-      - name: Publish GitHub Release
-        if: env.PUBLISH_RELEASE == 'true'
-        shell: bash
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
-            TAG="${GITHUB_REF_NAME}"
-          else
-            TAG="v${VERSION_NAME}"
-            git config user.name "github-actions[bot]"
-            git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-            git tag -f "${TAG}"
-            git push -f origin "${TAG}"
-          fi
-
-          if gh release view "${TAG}" >/dev/null 2>&1; then
-            gh release upload "${TAG}" release/tmux-android.apk release/latest.json --clobber
-          else
-            gh release create "${TAG}" release/tmux-android.apk release/latest.json \
-              --latest \
-              --title "tmux Android ${VERSION_NAME}" \
-              --notes "Android APK for tmux-ui remote testing."
-          fi
-
+          cp "${APK_PATH}" release/tmux-android-gitea.apk
+          ls -lh release/tmux-android-gitea.apk
+          sha256sum release/tmux-android-gitea.apk

README.md

@@ -9,6 +9,8 @@ APIs directly:
 - server URL management for Tailscale `100.x.y.z:3000` APIs
 - quick server selectors for `100.89.0.2`, `100.89.0.4`, `100.89.0.9`,
   `100.89.0.11`, and `100.89.0.116`
+- one-tap probe for the preset Tailscale APIs, showing health/version and
+  session counts
 - native tmux session list
 - create, rename, send command, split pane, select pane, kill pane, pin, mute,
   and kill session through HTTP API
@@ -18,7 +20,8 @@ APIs directly:
 - native API action center for health, server status, timeline, preferences,
   kanban projects, group messages, hook events, image file/URL upload, image
   preview info, and native image preview display
-- mobile soft-key row for tmux-oriented input
+- mobile soft-key row for tmux-oriented input, including tmux prefix, detach,
+  new window, previous/next window, Ctrl keys, arrows, page keys, and paste
 - automatic update checks against a GitHub Release manifest
 - APK download, SHA-256 verification, and installer handoff
 
@@ -77,10 +80,13 @@ Publish a test build by pushing a `v*` tag. That creates a GitHub Release with:
 ```text
 https://github.com/neatstudio/tmux-browser-android/releases/latest/download/tmux-android.apk
 https://github.com/neatstudio/tmux-browser-android/releases/latest/download/latest.json
-https://gitea.neatcn.com/tmux/tmux-browser-android/releases/latest/download/tmux-android.apk
-https://gitea.neatcn.com/tmux/tmux-browser-android/releases/latest/download/latest.json
 ```
 
+Those GitHub links are the primary public install/update channel. Gitea releases
+are mirrored as a second public source. This Gitea instance does not support the
+GitHub-style `/releases/latest/download/...` URL, so the app uses the Gitea
+Release API as the stable Gitea update entrypoint.
+
 Plain branch builds only create Actions artifacts; they are useful for CI
 verification, but releases are the stable download/update channel.
 
@@ -93,10 +99,15 @@ incompatible package.
 
 The terminal screen connects to `/ws/terminal` and sends the upstream protocol
 messages unchanged: `attach`, `input`, `resize`, `scroll`, and `clear-history`.
-The first Android UI renders terminal output as basic monospace text with ANSI
-escape filtering. It is enough for shell-oriented remote testing, but it is not
-yet a complete xterm-compatible renderer for full-screen TUIs such as `vim` or
-`top`.
+The first Android UI renders terminal output as monospace text with basic ANSI
+SGR color support. The terminal view stays bottom-aligned when output is short,
+auto-scrolls as data arrives, and adjusts its bottom inset when the soft keyboard
+opens. It is enough for shell-oriented remote testing, but it is not yet a
+complete xterm-compatible renderer for full-screen TUIs such as `vim` or `top`.
+
+The terminal toolbar and shortcut row include tmux prefix helpers. The app sends
+the same control bytes a keyboard would send, for example `Ctrl+B`, `Ctrl+B d`,
+`Ctrl+B c`, `Ctrl+B n`, and `Ctrl+B p`.
 
 All app features are native Android controls. Complex server objects such as
 kanban projects, preferences, timeline events, group messages, and image metadata
@@ -126,13 +137,32 @@ The default update manifest is:
 https://github.com/neatstudio/tmux-browser-android/releases/latest/download/latest.json
 ```
 
-The Gitea mirror is:
+The public manual APK download is:
 
 ```text
-https://gitea.neatcn.com/tmux/tmux-browser-android/releases/latest/download/latest.json
+https://github.com/neatstudio/tmux-browser-android/releases/latest/download/tmux-android.apk
 ```
 
 The app tries the selected update source first, then falls back to the GitHub
-and Gitea mirrors.
+manifest and the Gitea release API. The Gitea API endpoint is:
 
-The workflow uploads both the APK and `latest.json` to each release.
+```text
+https://gitea.neatcn.com/api/v1/repos/tmux/tmux-browser-android/releases/latest
+```
+
+Gitea tag-specific assets are also public, for example:
+
+```text
+https://gitea.neatcn.com/tmux/tmux-browser-android/releases/download/v0.1.7/latest.json
+https://gitea.neatcn.com/tmux/tmux-browser-android/releases/download/v0.1.7/tmux-android.apk
+```
+
+In the app:
+
+- Tap `Update` on the main screen to check `latest.json`, download the APK,
+  verify SHA-256, and open Android's installer.
+- Open `More` -> `Open APK download` to download the current public APK in a
+  browser.
+- Open `More` -> `Permissions / update status` to see the installed version,
+  update manifest, APK URL, install permission state, and a `Check update`
+  button.

app/build.gradle.kts

@@ -5,13 +5,17 @@ plugins {
 }
 
 val repoSlug = providers.gradleProperty("repoSlug")
-    .orElse("neatstudio/tmux-android")
+    .orElse("neatstudio/tmux-browser-android")
 val defaultServerUrl = providers.gradleProperty("defaultServerUrl")
     .orElse("http://100.89.0.116:3000")
 val defaultUpdateUrl = providers.gradleProperty("defaultUpdateUrl")
     .orElse("https://github.com/${repoSlug.get()}/releases/latest/download/latest.json")
 val defaultGiteaUpdateUrl = providers.gradleProperty("defaultGiteaUpdateUrl")
-    .orElse("https://gitea.neatcn.com/tmux/tmux-browser-android/releases/latest/download/latest.json")
+    .orElse("https://gitea.neatcn.com/api/v1/repos/tmux/tmux-browser-android/releases/latest")
+val defaultApkUrl = providers.gradleProperty("defaultApkUrl")
+    .orElse("https://github.com/${repoSlug.get()}/releases/latest/download/tmux-android.apk")
+val defaultReleasePageUrl = providers.gradleProperty("defaultReleasePageUrl")
+    .orElse("https://github.com/${repoSlug.get()}/releases/latest")
 
 val signingProps = Properties()
 val signingFile = rootProject.file("signing.properties")
@@ -33,6 +37,8 @@ android {
         buildConfigField("String", "DEFAULT_SERVER_URL", "\"${defaultServerUrl.get()}\"")
         buildConfigField("String", "DEFAULT_UPDATE_URL", "\"${defaultUpdateUrl.get()}\"")
         buildConfigField("String", "DEFAULT_GITEA_UPDATE_URL", "\"${defaultGiteaUpdateUrl.get()}\"")
+        buildConfigField("String", "DEFAULT_APK_URL", "\"${defaultApkUrl.get()}\"")
+        buildConfigField("String", "DEFAULT_RELEASE_PAGE_URL", "\"${defaultReleasePageUrl.get()}\"")
     }
 
     buildFeatures {

app/src/main/java/com/neatstudio/tmuxandroid/MainActivity.java

@@ -3,6 +3,7 @@ package com.neatstudio.tmuxandroid;
 import android.Manifest;
 import android.app.Activity;
 import android.app.AlertDialog;
+import android.content.ActivityNotFoundException;
 import android.content.ClipData;
 import android.content.ClipboardManager;
 import android.content.Context;
@@ -13,15 +14,23 @@ import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Color;
 import android.graphics.Typeface;
+import android.graphics.drawable.GradientDrawable;
+import android.graphics.drawable.StateListDrawable;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.provider.Settings;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
 import android.text.InputType;
+import android.text.style.BackgroundColorSpan;
+import android.text.style.ForegroundColorSpan;
+import android.text.style.StyleSpan;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowInsets;
+import android.view.WindowManager;
 import android.view.inputmethod.EditorInfo;
 import android.widget.Button;
 import android.widget.EditText;
@@ -98,6 +107,7 @@ public final class MainActivity extends Activity {
             getWindow().setStatusBarColor(Color.rgb(17, 20, 24));
             getWindow().setNavigationBarColor(Color.rgb(17, 20, 24));
         }
+        getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
         api = new SessionApiClient(getServerUrl());
         setContentView(createRoot());
         updateManager = new UpdateManager(this, prefs, new UpdateManager.Callback() {
@@ -130,8 +140,8 @@ public final class MainActivity extends Activity {
         statusText.setTextColor(Color.rgb(210, 215, 224));
         statusText.setTextSize(12);
         statusText.setGravity(Gravity.CENTER_VERTICAL);
-        statusText.setPadding(dp(8), 0, dp(8), 0);
-        statusText.setBackgroundColor(Color.rgb(29, 34, 41));
+        statusText.setPadding(dp(10), 0, dp(10), 0);
+        statusText.setBackground(rounded(Color.rgb(22, 27, 34), 0, Color.TRANSPARENT, 0));
         statusText.setSingleLine(true);
         setStatus("Ready");
         applySystemBarInsets(root);
@@ -140,11 +150,15 @@ public final class MainActivity extends Activity {
 
     private void applySystemBarInsets(View view) {
         view.setOnApplyWindowInsetsListener((target, insets) -> {
+            int bottom = insets.getSystemWindowInsetBottom();
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                bottom = Math.max(bottom, insets.getInsets(WindowInsets.Type.ime()).bottom);
+            }
             target.setPadding(
                     0,
                     insets.getSystemWindowInsetTop(),
                     0,
-                    insets.getSystemWindowInsetBottom()
+                    bottom
             );
             return insets;
         });
@@ -202,6 +216,7 @@ public final class MainActivity extends Activity {
         urlField.setImeOptions(EditorInfo.IME_ACTION_GO);
         urlField.setText(getServerUrl());
         urlField.setSelectAllOnFocus(true);
+        styleInput(urlField);
         urlField.setOnEditorActionListener((view, actionId, event) -> {
             if (actionId == EditorInfo.IME_ACTION_GO) {
                 saveServerAndRefresh();
@@ -302,8 +317,11 @@ public final class MainActivity extends Activity {
     private View sessionRow(SessionSummary session) {
         LinearLayout row = new LinearLayout(this);
         row.setOrientation(LinearLayout.VERTICAL);
-        row.setPadding(dp(10), dp(10), dp(10), dp(10));
-        row.setBackgroundColor(Color.rgb(29, 34, 41));
+        row.setPadding(dp(12), dp(11), dp(12), dp(11));
+        row.setBackground(rounded(Color.rgb(27, 33, 40), 8, Color.rgb(45, 54, 64), 1));
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            row.setElevation(dp(1));
+        }
 
         TextView title = new TextView(this);
         title.setText(session.name);
@@ -393,13 +411,18 @@ public final class MainActivity extends Activity {
         root.addView(createTerminalTopBar(sessionName), matchWrap());
 
         terminalScroll = new ScrollView(this);
+        terminalScroll.setFillViewport(true);
+        terminalScroll.setBackgroundColor(Color.rgb(4, 7, 10));
         terminalText = new TextView(this);
         terminalText.setTextColor(Color.rgb(230, 235, 242));
-        terminalText.setTextSize(12);
+        terminalText.setTextSize(13);
         terminalText.setTypeface(Typeface.MONOSPACE);
-        terminalText.setTextIsSelectable(true);
-        terminalText.setPadding(dp(8), dp(8), dp(8), dp(8));
-        terminalText.setBackgroundColor(Color.BLACK);
+        terminalText.setIncludeFontPadding(false);
+        terminalText.setLineSpacing(0, 1.05f);
+        terminalText.setGravity(Gravity.BOTTOM | Gravity.START);
+        terminalText.setTextIsSelectable(false);
+        terminalText.setPadding(dp(10), dp(10), dp(10), dp(10));
+        terminalText.setBackgroundColor(Color.rgb(4, 7, 10));
         terminalScroll.addView(terminalText, new ScrollView.LayoutParams(
                 ViewGroup.LayoutParams.MATCH_PARENT,
                 ViewGroup.LayoutParams.WRAP_CONTENT
@@ -446,6 +469,7 @@ public final class MainActivity extends Activity {
     private void showMainActions() {
         String[] items = {
                 "Health",
+                "Probe Tailscale APIs",
                 "Server status",
                 "Timeline",
                 "Preferences",
@@ -463,6 +487,7 @@ public final class MainActivity extends Activity {
                 "Upload image URL",
                 "Image preview info",
                 "Open image preview",
+                "Open APK download",
                 "Update source",
                 "Permissions / update status"
         };
@@ -474,60 +499,66 @@ public final class MainActivity extends Activity {
                             showRaw("Health", () -> api.health());
                             break;
                         case 1:
-                            showRaw("Server status", () -> api.serverStatus());
+                            probeServerProfiles();
                             break;
                         case 2:
-                            showRaw("Timeline", () -> api.timeline(50));
+                            showRaw("Server status", () -> api.serverStatus());
                             break;
                         case 3:
-                            showRaw("Preferences", () -> api.preferences());
+                            showRaw("Timeline", () -> api.timeline(50));
                             break;
                         case 4:
-                            showRaw("All session details", () -> api.sessionsAll());
+                            showRaw("Preferences", () -> api.preferences());
                             break;
                         case 5:
-                            showRaw("Pane details", () -> api.sessionsPanes());
+                            showRaw("All session details", () -> api.sessionsAll());
                             break;
                         case 6:
-                            showRaw("Kanban projects", () -> api.kanbanProjects());
+                            showRaw("Pane details", () -> api.sessionsPanes());
                             break;
                         case 7:
-                            promptCreateKanbanProject();
+                            showRaw("Kanban projects", () -> api.kanbanProjects());
                             break;
                         case 8:
-                            promptDeleteKanbanProject();
+                            promptCreateKanbanProject();
                             break;
                         case 9:
-                            promptRemoveKanbanSession();
+                            promptDeleteKanbanProject();
                             break;
                         case 10:
-                            promptGroupMessages();
+                            promptRemoveKanbanSession();
                             break;
                         case 11:
-                            promptSendGroupMessage();
+                            promptGroupMessages();
                             break;
                         case 12:
-                            promptScanGroupMessage();
+                            promptSendGroupMessage();
                             break;
                         case 13:
-                            promptPostHookEvent();
+                            promptScanGroupMessage();
                             break;
                         case 14:
-                            promptUploadImageFile();
+                            promptPostHookEvent();
                             break;
                         case 15:
-                            promptUploadImageUrl();
+                            promptUploadImageFile();
                             break;
                         case 16:
-                            promptImagePreviewInfo();
+                            promptUploadImageUrl();
                             break;
                         case 17:
-                            promptOpenImagePreview();
+                            promptImagePreviewInfo();
                             break;
                         case 18:
-                            showUpdateSourcePicker();
+                            promptOpenImagePreview();
                             break;
                         case 19:
+                            openExternalUrl(BuildConfig.DEFAULT_APK_URL);
+                            break;
+                        case 20:
+                            showUpdateSourcePicker();
+                            break;
+                        case 21:
                             showPermissionsAndUpdateStatus();
                             break;
                         default:
@@ -615,7 +646,12 @@ public final class MainActivity extends Activity {
                 "Page up",
                 "Page down",
                 "Session status",
-                "Send command"
+                "Send command",
+                "Tmux prefix",
+                "Detach tmux client",
+                "New tmux window",
+                "Next tmux window",
+                "Previous tmux window"
         };
         new AlertDialog.Builder(this)
                 .setTitle(sessionName)
@@ -650,6 +686,21 @@ public final class MainActivity extends Activity {
                         case 6:
                             promptSendCommand(sessionName);
                             break;
+                        case 7:
+                            sendTerminalInput("\u0002");
+                            break;
+                        case 8:
+                            sendTerminalInput("\u0002d");
+                            break;
+                        case 9:
+                            sendTerminalInput("\u0002c");
+                            break;
+                        case 10:
+                            sendTerminalInput("\u0002n");
+                            break;
+                        case 11:
+                            sendTerminalInput("\u0002p");
+                            break;
                         default:
                             break;
                     }
@@ -671,6 +722,7 @@ public final class MainActivity extends Activity {
         inputField.setHint("type command or text");
         inputField.setImeOptions(EditorInfo.IME_ACTION_SEND);
         inputField.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
+        styleInput(inputField);
         inputField.setOnEditorActionListener((view, actionId, event) -> {
             if (actionId == EditorInfo.IME_ACTION_SEND) {
                 sendLine();
@@ -914,12 +966,28 @@ public final class MainActivity extends Activity {
 
     private void showPermissionsAndUpdateStatus() {
         StringBuilder text = new StringBuilder();
+        text.append("Installed app: ")
+                .append(BuildConfig.VERSION_NAME)
+                .append(" (")
+                .append(BuildConfig.VERSION_CODE)
+                .append(")\n");
         text.append("Server: ").append(getServerUrl()).append('\n');
-        text.append("Selected update manifest: ")
+        text.append('\n');
+        text.append("Manual APK download:\n")
+                .append(BuildConfig.DEFAULT_APK_URL)
+                .append('\n');
+        text.append("Release page:\n")
+                .append(BuildConfig.DEFAULT_RELEASE_PAGE_URL)
+                .append('\n');
+        text.append('\n');
+        text.append("In-app update:\n");
+        text.append("Tap Update. The app reads latest.json, downloads the APK, verifies SHA-256, then opens Android's installer.\n");
+        text.append("Selected manifest:\n")
                 .append(prefs.getString("update_url", BuildConfig.DEFAULT_UPDATE_URL))
                 .append('\n');
-        text.append("GitHub mirror: ").append(BuildConfig.DEFAULT_UPDATE_URL).append('\n');
-        text.append("Gitea mirror: ").append(BuildConfig.DEFAULT_GITEA_UPDATE_URL).append('\n');
+        text.append("GitHub primary manifest:\n").append(BuildConfig.DEFAULT_UPDATE_URL).append('\n');
+        text.append("Gitea public mirror API:\n").append(BuildConfig.DEFAULT_GITEA_UPDATE_URL).append('\n');
+        text.append('\n');
         text.append("Network: manifest permission, no runtime grant required\n");
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             text.append("Install unknown apps: ")
@@ -942,10 +1010,18 @@ public final class MainActivity extends Activity {
                 .setMessage(text.toString())
                 .setNegativeButton("Close", null)
                 .setNeutralButton("Install permission", (dialog, which) -> openInstallPermissionSettings())
-                .setPositiveButton("Notify permission", (dialog, which) -> requestNotificationPermission())
+                .setPositiveButton("Check update", (dialog, which) -> updateManager.check(true))
                 .show();
     }
 
+    private void openExternalUrl(String url) {
+        try {
+            startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url)));
+        } catch (ActivityNotFoundException error) {
+            showMessage("No app can open URL");
+        }
+    }
+
     private void showUpdateSourcePicker() {
         String[] items = {
                 "GitHub: " + BuildConfig.DEFAULT_UPDATE_URL,
@@ -971,6 +1047,36 @@ public final class MainActivity extends Activity {
         showMessage("Update source: " + url);
     }
 
+    private void probeServerProfiles() {
+        progressBar.setVisibility(View.VISIBLE);
+        setStatus("Probing Tailscale APIs...");
+        executor.execute(() -> {
+            StringBuilder text = new StringBuilder();
+            for (String url : SERVER_PROFILES) {
+                text.append(url).append('\n');
+                try {
+                    SessionApiClient client = new SessionApiClient(url);
+                    JSONObject health = new JSONObject(client.health());
+                    List<SessionSummary> sessions = client.getSessions();
+                    text.append("  ok: true\n");
+                    text.append("  version: ")
+                            .append(health.optString("version", "unknown"))
+                            .append(" ")
+                            .append(health.optString("commit", ""))
+                            .append('\n');
+                    text.append("  sessions: ").append(sessions.size()).append('\n');
+                } catch (Exception error) {
+                    text.append("  failed: ").append(error.getMessage()).append('\n');
+                }
+                text.append('\n');
+            }
+            runOnUiThread(() -> {
+                progressBar.setVisibility(View.GONE);
+                showTextDialog("Tailscale APIs", text.toString());
+            });
+        });
+    }
+
     private void openInstallPermissionSettings() {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
             showMessage("Install permission is allowed on this Android version");
@@ -1113,6 +1219,7 @@ public final class MainActivity extends Activity {
         input.setSingleLine(true);
         input.setText(value);
         input.setSelectAllOnFocus(true);
+        styleInput(input);
         form.addView(title);
         form.addView(input, new LinearLayout.LayoutParams(
                 ViewGroup.LayoutParams.MATCH_PARENT,
@@ -1140,6 +1247,13 @@ public final class MainActivity extends Activity {
         addSoftKey(row, "^A", "\u0001");
         addSoftKey(row, "^E", "\u0005");
         addSoftKey(row, "^V", "\u0016");
+        addSoftKey(row, "^Z", "\u001a");
+        addSoftKey(row, "^\\", "\u001c");
+        addSoftKey(row, "Tmux", "\u0002");
+        addSoftKey(row, "Detach", "\u0002d");
+        addSoftKey(row, "NewWin", "\u0002c");
+        addSoftKey(row, "NextWin", "\u0002n");
+        addSoftKey(row, "PrevWin", "\u0002p");
         addSoftKey(row, "Left", "\u001b[D");
         addSoftKey(row, "Down", "\u001b[B");
         addSoftKey(row, "Up", "\u001b[A");
@@ -1240,14 +1354,118 @@ public final class MainActivity extends Activity {
         if (terminalBuffer.length() > MAX_TERMINAL_CHARS) {
             terminalBuffer.delete(0, terminalBuffer.length() - MAX_TERMINAL_CHARS);
         }
-        terminalText.setText(stripAnsiForBasicView(terminalBuffer.toString()));
+        terminalText.setText(renderAnsiForTerminal(terminalBuffer.toString()));
         terminalScroll.post(() -> terminalScroll.fullScroll(View.FOCUS_DOWN));
     }
 
-    private String stripAnsiForBasicView(String text) {
-        return text
-                .replaceAll("\u001B\\[[0-?]*[ -/]*[@-~]", "")
-                .replace("\r", "");
+    private CharSequence renderAnsiForTerminal(String text) {
+        SpannableStringBuilder output = new SpannableStringBuilder();
+        int fg = Color.rgb(230, 235, 242);
+        int bg = Color.TRANSPARENT;
+        boolean bold = false;
+        int index = 0;
+        while (index < text.length()) {
+            char item = text.charAt(index);
+            if (item == '\r') {
+                index++;
+                continue;
+            }
+            if (item == '\u001b' && index + 1 < text.length() && text.charAt(index + 1) == '[') {
+                int end = findAnsiEnd(text, index + 2);
+                if (end == -1) {
+                    break;
+                }
+                char command = text.charAt(end);
+                if (command == 'm') {
+                    int[] state = applySgr(text.substring(index + 2, end), fg, bg, bold);
+                    fg = state[0];
+                    bg = state[1];
+                    bold = state[2] == 1;
+                }
+                index = end + 1;
+                continue;
+            }
+
+            int start = output.length();
+            output.append(item);
+            int finish = output.length();
+            output.setSpan(new ForegroundColorSpan(fg), start, finish, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            if (bg != Color.TRANSPARENT) {
+                output.setSpan(new BackgroundColorSpan(bg), start, finish, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+            if (bold) {
+                output.setSpan(new StyleSpan(Typeface.BOLD), start, finish, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+            index++;
+        }
+        return output;
+    }
+
+    private int findAnsiEnd(String text, int start) {
+        for (int index = start; index < text.length(); index++) {
+            char item = text.charAt(index);
+            if (item >= '@' && item <= '~') {
+                return index;
+            }
+        }
+        return -1;
+    }
+
+    private int[] applySgr(String params, int fg, int bg, boolean bold) {
+        if (params.isEmpty()) {
+            params = "0";
+        }
+        String[] parts = params.split(";");
+        for (String part : parts) {
+            int value;
+            try {
+                value = part.isEmpty() ? 0 : Integer.parseInt(part);
+            } catch (NumberFormatException ignored) {
+                continue;
+            }
+            if (value == 0) {
+                fg = Color.rgb(230, 235, 242);
+                bg = Color.TRANSPARENT;
+                bold = false;
+            } else if (value == 1) {
+                bold = true;
+            } else if (value == 22) {
+                bold = false;
+            } else if (value == 39) {
+                fg = Color.rgb(230, 235, 242);
+            } else if (value == 49) {
+                bg = Color.TRANSPARENT;
+            } else if ((value >= 30 && value <= 37) || (value >= 90 && value <= 97)) {
+                fg = ansiColor(value, false);
+            } else if ((value >= 40 && value <= 47) || (value >= 100 && value <= 107)) {
+                bg = ansiColor(value, true);
+            }
+        }
+        return new int[]{fg, bg, bold ? 1 : 0};
+    }
+
+    private int ansiColor(int code, boolean background) {
+        int base = background ? (code >= 100 ? code - 100 : code - 40) : (code >= 90 ? code - 90 : code - 30);
+        boolean bright = code >= 90;
+        switch (base) {
+            case 0:
+                return bright ? Color.rgb(80, 88, 100) : Color.rgb(33, 38, 45);
+            case 1:
+                return bright ? Color.rgb(255, 123, 114) : Color.rgb(248, 81, 73);
+            case 2:
+                return bright ? Color.rgb(86, 211, 100) : Color.rgb(63, 185, 80);
+            case 3:
+                return bright ? Color.rgb(234, 179, 8) : Color.rgb(210, 153, 34);
+            case 4:
+                return bright ? Color.rgb(121, 192, 255) : Color.rgb(88, 166, 255);
+            case 5:
+                return bright ? Color.rgb(210, 168, 255) : Color.rgb(188, 140, 255);
+            case 6:
+                return bright ? Color.rgb(86, 211, 219) : Color.rgb(57, 197, 187);
+            case 7:
+            default:
+                return bright ? Color.rgb(240, 246, 252) : Color.rgb(201, 209, 217);
+        }
     }
 
     private void saveServerAndRefresh() {
@@ -1295,11 +1513,15 @@ public final class MainActivity extends Activity {
     private Button toolbarButton(String label, View.OnClickListener listener) {
         Button button = new Button(this);
         button.setText(label);
+        button.setTextColor(Color.rgb(235, 241, 248));
         button.setTextSize(12);
         button.setAllCaps(false);
+        button.setTypeface(Typeface.DEFAULT_BOLD);
         button.setMinWidth(0);
         button.setMinimumWidth(0);
-        button.setPadding(dp(8), 0, dp(8), 0);
+        button.setPadding(dp(10), 0, dp(10), 0);
+        button.setBackground(buttonBackground());
+        button.setGravity(Gravity.CENTER);
         button.setOnClickListener(listener);
         LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
                 ViewGroup.LayoutParams.WRAP_CONTENT,
@@ -1310,6 +1532,33 @@ public final class MainActivity extends Activity {
         return button;
     }
 
+    private void styleInput(EditText input) {
+        input.setTextColor(Color.rgb(240, 246, 252));
+        input.setHintTextColor(Color.rgb(139, 148, 158));
+        input.setTextSize(14);
+        input.setSingleLine(true);
+        input.setPadding(dp(10), 0, dp(10), 0);
+        input.setBackground(rounded(Color.rgb(12, 17, 23), 8, Color.rgb(48, 58, 70), 1));
+    }
+
+    private StateListDrawable buttonBackground() {
+        StateListDrawable states = new StateListDrawable();
+        states.addState(new int[]{android.R.attr.state_pressed}, rounded(Color.rgb(64, 78, 94), 8, Color.rgb(91, 108, 128), 1));
+        states.addState(new int[]{android.R.attr.state_focused}, rounded(Color.rgb(48, 61, 76), 8, Color.rgb(98, 128, 164), 1));
+        states.addState(new int[]{}, rounded(Color.rgb(34, 43, 53), 8, Color.rgb(55, 66, 80), 1));
+        return states;
+    }
+
+    private GradientDrawable rounded(int color, int radiusDp, int strokeColor, int strokeDp) {
+        GradientDrawable drawable = new GradientDrawable();
+        drawable.setColor(color);
+        drawable.setCornerRadius(dp(radiusDp));
+        if (strokeDp > 0) {
+            drawable.setStroke(dp(strokeDp), strokeColor);
+        }
+        return drawable;
+    }
+
     private void addSoftKey(LinearLayout row, String label, String sequence) {
         addSoftButton(row, label, view -> sendTerminalInput(sequence));
     }

app/src/main/java/com/neatstudio/tmuxandroid/UpdateManager.java

@@ -10,6 +10,7 @@ import android.os.Build;
 import android.provider.Settings;
 import android.widget.Toast;
 
+import org.json.JSONArray;
 import org.json.JSONObject;
 
 import java.io.BufferedInputStream;
@@ -103,6 +104,9 @@ final class UpdateManager {
     private ReleaseInfo fetchReleaseInfo(String manifestUrl) throws Exception {
         String json = readText(manifestUrl);
         JSONObject root = new JSONObject(json);
+        if (root.has("assets") && root.has("tag_name")) {
+            return fetchReleaseInfoFromReleaseApi(root);
+        }
         return new ReleaseInfo(
                 root.getInt("versionCode"),
                 root.optString("versionName", ""),
@@ -112,6 +116,40 @@ final class UpdateManager {
         );
     }
 
+    private ReleaseInfo fetchReleaseInfoFromReleaseApi(JSONObject release) throws Exception {
+        JSONArray assets = release.getJSONArray("assets");
+        String manifestUrl = findAssetUrl(assets, "latest.json");
+        String apkUrl = findAssetUrl(assets, "tmux-android.apk");
+        if (manifestUrl.isEmpty()) {
+            throw new IllegalStateException("Release has no latest.json");
+        }
+        ReleaseInfo info = fetchReleaseInfo(manifestUrl);
+        if (apkUrl.isEmpty()) {
+            return info;
+        }
+        return new ReleaseInfo(
+                info.versionCode,
+                info.versionName,
+                apkUrl,
+                info.sha256,
+                release.optString("html_url", info.releasePageUrl)
+        );
+    }
+
+    private String findAssetUrl(JSONArray assets, String name) {
+        for (int index = 0; index < assets.length(); index++) {
+            JSONObject asset = assets.optJSONObject(index);
+            if (asset == null || !name.equals(asset.optString("name"))) {
+                continue;
+            }
+            String url = asset.optString("browser_download_url", "");
+            if (!url.isEmpty()) {
+                return url;
+            }
+        }
+        return "";
+    }
+
     private String readText(String url) throws Exception {
         HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
         connection.setConnectTimeout(12000);

docs/android-client-notes.md

@@ -68,14 +68,15 @@ not kill a tmux session.
 
 Implemented now:
 
-- configurable base URL, defaulting to `http://127.0.0.1:3000`
+- configurable base URL, defaulting to `http://100.89.0.116:3000`
 - support for Tailscale URLs such as `http://100.x.y.z:3000`
 - native session list from `GET /api/sessions`
 - create, rename, command send, split, pane select, pane kill, pin, mute, and
   kill session through documented session/preference endpoints
 - basic live terminal through `/ws/terminal`
 - native event stream through `/ws/events`
-- bottom shortcut bar for `Esc`, `Tab`, `Ctrl+C`, arrows, page keys, and paste
+- bottom shortcut bar for `Esc`, `Tab`, `Ctrl+C`, `Ctrl+V`, arrows, page keys,
+  tmux prefix actions, and paste
 - shortcut delivery through the terminal WebSocket `input` message
 - native action center for health, server status, timeline, preferences, kanban
   projects, group messages, hook events, image file/URL upload, image preview