Fixing root user conflict.

The apt repo at packages.microsoft.com/repos/vscode does not publish amd64
and arm64 .deb packages atomically, so the arm64 build in CI could pick up
an older VS Code version than amd64 when both platforms build in the same run.

Switch to downloading the .deb directly from
update.code.visualstudio.com/latest/linux-deb-{arch}/stable, the canonical
"always latest" endpoint, and resolve dependencies via apt-get install -f.

Also add an explicit docker/setup-qemu-action step to the workflow so arm64
emulation is version-pinned rather than relying on the runner's default
binfmt registration.

.github/workflows/main-workflow.yml

@@ -8,23 +8,46 @@ jobs:
   docker:
     runs-on: ubuntu-latest
     steps:
-      -
-        name: Checkout
+      - name: Checkout
         uses: actions/checkout@v2
-      -
-        name: Set up Docker Buildx
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v1
-      -
-        name: Login to DockerHub
+
+      # 🔑 Login to DockerHub
+      - name: Login to DockerHub
         uses: docker/login-action@v1 
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      -
-        name: Build and push
+
+      # 🔑 Login to Gitea Registry
+      - name: Login to Gitea Registry
+        uses: docker/login-action@v1
+        with:
+          registry: gitea.p-lao.com
+          username: aleleba
+          password: ${{ secrets.GITEA_API_TOKEN }}
+
+      # 🚀 Build and push to BOTH registries
+      - name: Build and push
         uses: docker/build-push-action@v2
         with:
           context: .
           push: true
-          tags: aleleba/vscode:latest
           platforms: linux/amd64,linux/arm64
+          tags: |
+            aleleba/vscode:latest
+            gitea.p-lao.com/aleleba/vscode:latest
+
+      - name: Trigger workflow in Gitea
+        if: success()
+        run: |
+          curl -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_API_TOKEN }}" \
+            -H "Content-Type: application/json" \
+            https://gitea.p-lao.com/api/v1/repos/aleleba/vscode-server/actions/workflows/main-workflow.yml/dispatches \
+            -d '{"ref":"master","inputs":{"image":"gitea.p-lao.com/aleleba/vscode-server:latest"}}'

Dockerfile

@@ -29,13 +29,16 @@ RUN curl -sL https://aka.ms/DevTunnelCliInstall | bash
 
 #Instalando VSCode
 RUN ARCH="$(dpkg --print-architecture)" \
+    && case "${ARCH}" in \
+         amd64) VSCODE_ARCH="x64" ;; \
+         arm64) VSCODE_ARCH="arm64" ;; \
+         *) echo "Unsupported architecture: ${ARCH}" >&2; exit 1 ;; \
+       esac \
+    && curl -fsSL "https://update.code.visualstudio.com/latest/linux-deb-${VSCODE_ARCH}/stable" -o /tmp/vscode.deb \
+    && (sudo dpkg -i /tmp/vscode.deb || true) \
     && sudo apt-get update \
-    && sudo apt-get install -y gnupg2 \
-    && sudo apt-get install -y software-properties-common \
-    && sudo wget -q https://packages.microsoft.com/keys/microsoft.asc -O- | sudo apt-key add - \
-    && sudo add-apt-repository "deb [arch=${ARCH}] https://packages.microsoft.com/repos/vscode stable main" \
-    && sudo apt-get update \
-    && sudo DEBIAN_FRONTEND=noninteractive apt-get install -y code
+    && sudo DEBIAN_FRONTEND=noninteractive apt-get install -f -y \
+    && rm -f /tmp/vscode.deb
 
 #Making home writable
 RUN sudo chmod -R a+rwX /home

entrypoint.sh

@@ -5,6 +5,17 @@ if [[ -z "${HOME_USER-}" ]]; then
     HOME_USER="vscode"
 fi
 
+# Detectar UID/GID del volumen montado en /home/${HOME_USER} (si ya existe),
+# permitir override explícito vía HOST_UID/HOST_GID, y por defecto usar 1000.
+DETECTED_UID=$(stat -c '%u' "/home/${HOME_USER}" 2>/dev/null || echo 1000)
+DETECTED_GID=$(stat -c '%g' "/home/${HOME_USER}" 2>/dev/null || echo 1000)
+# Descartar UID/GID 0 (root) detectados del mount: es metadata espuria
+# de bind mounts (p.ej. WSL2/Docker Desktop), no un UID/GID real de host.
+[ "$DETECTED_UID" = "0" ] && DETECTED_UID=1000
+[ "$DETECTED_GID" = "0" ] && DETECTED_GID=1000
+TARGET_UID="${HOST_UID:-$DETECTED_UID}"
+TARGET_GID="${HOST_GID:-$DETECTED_GID}"
+
 if ! grep -q "HOME_USER=" /etc/environment; then
   sudo bash -c "echo HOME_USER=$HOME_USER >> /etc/environment"
 fi
@@ -48,6 +59,13 @@ sed 's/^USER_ENV_//' |
 # Append the result to /usr/bin/.bashrc
 while IFS= read -r line
 do
+  # Ensure the user's home directory exists before writing .bashrc
+  if [ ! -d "/home/${HOME_USER}" ]; then
+    sudo mkdir -p "/home/${HOME_USER}"
+    sudo chown root:root "/home/${HOME_USER}"
+    sudo chmod 755 "/home/${HOME_USER}"
+  fi
+
   # Check if the current user is root
   if [ "$(id -u)" = "0" ]; then
     echo "" >> /usr/bin/.bashrc
@@ -59,8 +77,9 @@ do
 done
 
 USER="$HOME_USER"
-if ! id -u $HOME_USER > /dev/null 2>&1; then
-  sudo adduser --disabled-password --gecos "" --uid 1000 ${HOME_USER}
+if ! id -u "$HOME_USER" > /dev/null 2>&1; then
+  sudo groupadd -g "${TARGET_GID}" "${HOME_USER}" 2>/dev/null || true
+  sudo adduser --disabled-password --gecos "" --uid "${TARGET_UID}" --gid "${TARGET_GID}" "${HOME_USER}"
   sudo echo "$HOME_USER ALL=(ALL) NOPASSWD:ALL" | sudo tee -a /etc/sudoers.d/nopasswd > /dev/null
 
   # Creating .vscode folder if it doesn't exist
@@ -70,13 +89,35 @@ if ! id -u $HOME_USER > /dev/null 2>&1; then
 
   # Changing the property of the directory /home/${HOME_USER}/.vscode
   sudo chown -R ${HOME_USER} /home/${HOME_USER}/.vscode
+else
+  # Usuario ya existe (imagen/volumen reusado) — resincronizar UID/GID
+  # SOLO si el operador lo pidió explícitamente vía HOST_UID/HOST_GID.
+  # No usar la detección automática del mount acá: en reinicios repetidos
+  # es una señal poco confiable (ver metadata GID 0 de bind mounts en
+  # WSL2/Docker Desktop) y causaba un groupmod fallido en cada arranque.
+  if [[ -n "${HOST_UID-}" || -n "${HOST_GID-}" ]]; then
+    CURRENT_UID=$(id -u "${HOME_USER}")
+    CURRENT_GID=$(id -g "${HOME_USER}")
+    CURRENT_GROUP=$(id -gn "${HOME_USER}")
+
+    if [ "$CURRENT_UID" != "$TARGET_UID" ] || [ "$CURRENT_GID" != "$TARGET_GID" ]; then
+      if [ "$CURRENT_GID" != "$TARGET_GID" ]; then
+        sudo groupmod -g "${TARGET_GID}" "${CURRENT_GROUP}"
+      fi
+      if [ "$CURRENT_UID" != "$TARGET_UID" ]; then
+        sudo usermod -u "${TARGET_UID}" "${HOME_USER}"
+      fi
+      sudo find / -xdev \( -user "${CURRENT_UID}" -o -group "${CURRENT_GID}" \) \
+        -exec chown -h "${TARGET_UID}:${TARGET_GID}" {} + 2>/dev/null || true
+    fi
+  fi
 fi
 
 # Then execute entrypoint.sh
 if [ "$HOME_USER" != "$(whoami)" ]; then
   exec sudo -u $HOME_USER bash -c "source /etc/environment; /usr/bin/entrypoint.sh"
 else
-  sudo chown -R ${HOME_USER} /home/${HOME_USER}
+  sudo find "/home/${HOME_USER}" -xdev -exec chown "${HOME_USER}" {} + 2>/dev/null || true
   if [ -d "/home/${HOME_USER}/.ssh" ]; then
     sudo chmod 755 /home/${HOME_USER}/.ssh
     sudo chmod -R 600 /home/${HOME_USER}/.ssh/*
@@ -111,7 +152,12 @@ fi
 
 # Find .sh files in /usr/bin/custom-scripts and execute them in order
 for script in $(find /usr/bin/custom-scripts -name "*.sh" | sort); do
-  chmod +x $script
+  # Ensure the script is executable
+  if [ ! -x $script ]; then
+    sudo chmod +x $script
+  fi
+
+  # Execute the script as the configured user
   if [[ $script == *"sudo"* ]]; then
     sudo -u $HOME_USER bash -c "source /etc/environment; sudo $script"
   else
@@ -119,6 +165,7 @@ for script in $(find /usr/bin/custom-scripts -name "*.sh" | sort); do
   fi
 done
 
+
 #Creating extensions folder
 if [ ! -d "/home/${HOME_USER}/.config/Code" ]; then
   sudo mkdir -p /home/${HOME_USER}/.config/Code
@@ -146,7 +193,7 @@ if [ -f "/home/extensions.json" ]; then
     # Loop through the extensions and process each element
     for extension in $extensions; do
         echo "Installing extension: $extension"
-        sudo su ${HOME_USER} -c "code --install-extension $extension"
+        sudo su ${HOME_USER} -c "code --install-extension $extension --force"
     done
     sudo cp -R /home/${HOME_USER}/.vscode/* /home/${HOME_USER}/.vscode-server
     sudo cp -R /home/${HOME_USER}/.vscode/* /home/${HOME_USER}/.vscode-server-insiders
@@ -157,47 +204,8 @@ else
     echo "File extensions.json not found"
 fi
 
-# Check if CLI directory exists and has content
-if [ -d "/home/${HOME_USER}/.vscode/cli" ] && [ "$(ls -A /home/${HOME_USER}/.vscode/cli 2>/dev/null)" ]; then
-    # CLI directory exists and has content, extract token and tunnel information
-    
-    # Extract token from token.json if it exists
-    TOKEN_FILE="/home/${HOME_USER}/.vscode/cli/token.json"
-    if [ -f "$TOKEN_FILE" ]; then
-        TOKEN=$(cat "$TOKEN_FILE" | tr -d '\n')
-    else
-        TOKEN=""
-    fi
-    
-    # Extract id and cluster from code_tunnel.json if it exists
-    TUNNEL_FILE="/home/${HOME_USER}/.vscode/cli/code_tunnel.json"
-    if [ -f "$TUNNEL_FILE" ]; then
-        if command -v jq &> /dev/null; then
-            # Use jq if available
-            ID=$(jq -r '.id' "$TUNNEL_FILE")
-            CLUSTER=$(jq -r '.cluster' "$TUNNEL_FILE")
-        else
-            # Fallback to grep and cut if jq is not available
-            ID=$(grep -o '"id"[^,}]*' "$TUNNEL_FILE" | cut -d'"' -f4)
-            CLUSTER=$(grep -o '"cluster"[^,}]*' "$TUNNEL_FILE" | cut -d'"' -f4)
-        fi
-        TUNNEL_ID="${ID}.${CLUSTER}"
-    else
-        TUNNEL_ID=""
-    fi
-    
-    # Create tunnel with extracted values if available
-    if [ -n "$TOKEN" ] && [ -n "$TUNNEL_ID" ]; then
-        sudo su ${HOME_USER} -c "code tunnel --name ${VSCODE_TUNNEL_NAME} --tunnel-id ${TUNNEL_ID}--host-token ${TOKEN}"
-    else
-        # Fallback to simpler command if values couldn't be extracted
-        sudo su ${HOME_USER} -c "code tunnel --name ${VSCODE_TUNNEL_NAME}"
-    fi
+if [[ -v VSCODE_TUNNEL_NAME && -n "${VSCODE_TUNNEL_NAME}" ]]; then
+    sudo su ${HOME_USER} -c "code tunnel --accept-server-license-terms --name ${VSCODE_TUNNEL_NAME}"
 else
-    # No CLI directory or empty, use normal startup
-    if [[ -v VSCODE_TUNNEL_NAME && -n "${VSCODE_TUNNEL_NAME}" ]]; then
-        sudo su ${HOME_USER} -c "code tunnel --accept-server-license-terms --name ${VSCODE_TUNNEL_NAME}"
-    else
-        sudo su ${HOME_USER} -c "code tunnel --accept-server-license-terms"
-    fi
+    sudo su ${HOME_USER} -c "code tunnel --accept-server-license-terms"
 fi

readme.md

@@ -16,6 +16,7 @@ The following environment variables can be set when running the Docker container
 
 - `HOME_USER`: The username of the user running the container. This is used to set the correct permissions on files created in the container.
 - `VSCODE_TUNNEL_NAME`: The name of the SSH tunnel used by Visual Studio Code to connect to the container.
+- `HOST_UID` / `HOST_GID` (optional): Force the `HOME_USER` account to use a specific UID/GID instead of the default `1000`. This only applies the first time the user is created: if not set, the container will try to auto-detect the UID/GID from an existing `/home/${HOME_USER}` mount (useful when bind-mounting a host directory owned by a non-1000 user); if that can't be detected either (or the mount reports UID/GID `0`, which some bind mount setups do), it falls back to `1000`. If the container is restarted/reused and the user already exists, its UID/GID is only resynced (`usermod`/`groupmod`, with files re-owned accordingly) when `HOST_UID`/`HOST_GID` are explicitly set — auto-detection from the mount is not used to resync an existing user, since mount metadata can be unreliable across restarts.
 
 ### Custom Environment Variables
 
@@ -39,15 +40,6 @@ docker run -it -e HOME_USER=custom-home-user -e GLOBAL_ENV_MY_GLOBAL_VARIABLE=my
 ```
 In this example, MY_GLOBAL_VARIABLE will be set to my_global_value in the /etc/environment file.
 
-### Persistent VS Code Tunnel
-
-You can maintain the VS Code tunnel configuration between container restarts by adding a volume mount to `/home/${HOME_USER}/.vscode/cli`. When this volume is mounted and the container restarts, it will use `code tunnel restart` to reconnect using the existing tunnel configuration instead of creating a new one.
-
-Example:
-```bash
-docker run -it -e HOME_USER=custom-home-user -e VSCODE_TUNNEL_NAME=vscode-ssh-remote-server -v /path/to/vscode-cli:/home/custom-home-user/.vscode/cli -v /path/to/extensions.json:/home/extensions.json aleleba/vscode
-```
-
 ### Adding VSCode Extensions
 
 To add VSCode extensions to the container, create a JSON file with an array of objects containing the extension details you want to install, the only Mandatory field is uniqueIdentifier and follow this structure. For example:
@@ -184,6 +176,8 @@ RUN echo 'source ~/.nvm/nvm.sh' >> ~/.bashrc
 
 > **Note:** If you are using this image as a base image in a Dockerfile, ensure that the value of `HOME_USER` is the same as the one you will use when creating the container. This is necessary to ensure that all configurations and packages are installed in the correct user directory.
 
+> **Note:** The `--uid 1000` in the example above is just illustrative. If you run the final container with `HOST_UID`/`HOST_GID` set (or with `/home/${HOME_USER}` bind-mounted from a host directory owned by another user), `entrypoint.sh` will resync this user's UID/GID at container start.
+
 > **Note:** To grant access to the server, please log into https://github.com/login/device and use the code XXXX-XXXX. You can view the container logs to get the code.
 
 ## Contributing

version.txt

@@ -1 +1 @@
-3.2.4
+3.2.25