App Lab validation in main content lint workflow

.github/workflows/workflow-validate.yaml

@@ -9,6 +9,9 @@ on:
   pull_request:
     types: [opened, synchronize, ready_for_review, reopened]
 
+permissions:
+  contents: read
+
 jobs:
   spell_check:
     name: Spell Check
@@ -34,3 +37,39 @@ jobs:
         run: |
           cd scripts/validation
           ./content-lint.sh -p '../../content/hardware/'
+
+  validate_app_lab_markdown:
+    name: App Lab - Validate Markdown
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+      - name: Validate Markdown
+        run: npx markdownlint-cli "content/software/app-lab/**/*.md" --config "content/software/app-lab/.markdownlint.yaml" --ignore-path "content/software/app-lab/.markdownlintignore"
+
+  validate_app_lab_links:
+    name: App Lab - Validate Links
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - name: Validate Links
+        run: python3 scripts/validation/relative_links/relative_links.py validate content/software/app-lab
+
+  validate_app_lab_images:
+    name: App Lab - Validate Images
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - name: Validate Images
+        run: python3 scripts/validation/image_links/image_links.py validate content/software/app-lab

content/software/app-lab/.markdownlintignore

@@ -1 +1,5 @@
-tutorials/
+README.md
+7.cli/1.cli/
+8.integrations/1.companion-app/
+8.integrations/2.ai-models/
+9.release-notes/

content/software/app-lab/2.configure/1.config/config.md

@@ -50,10 +50,10 @@ Follow these steps to complete the setup:
 
 Arduino App Lab automatically manages the software ecosystem on your board to ensure you have the latest features, security patches, and performance improvements.
 
-If updates are available, Arduino App Lab will ask if you want to install the available updates: 
+If updates are available, Arduino App Lab will ask if you want to install the available updates:
 
-* Select **Install** to download and install the updates, or **Skip** if you don't want to update the board.
-* Select **Show update details** for additional information about the updates.
+- Select **Install** to download and install the updates, or **Skip** if you don't want to update the board.
+- Select **Show update details** for additional information about the updates.
 
 ![Reviewing software updates in Arduino App Lab](../../assets/configuration/updates/standard/ORIGINAL.png)
 

content/software/app-lab/3.getting-started/5.glossary/glossary.md

@@ -8,94 +8,125 @@ tags:
 ---
 
 ## ADB (Android Debug Bridge)
+
 A command-line tool used to access the board's Linux shell over a USB connection. It allows for file management and terminal access without a network connection.
 
 ## AI (Artificial Intelligence)
+
 The simulation of human intelligence by machines. In App Lab, AI models are typically deployed within **Bricks** to perform tasks like object detection or speech recognition locally on the board.
 
 ## API (Application Programming Interface)
+
 A set of rules allowing software entities to communicate. Bricks expose high-level APIs that allow Python scripts to access complex features like machine learning or hardware drivers.
 
 ## App
+
 An Arduino App is a modular software architecture that orchestrates multiple components into a single project. The core logic runs via high-level code (Python) on the board's Linux subsystem. Apps can also include an Arduino **Sketch** running on a microcontroller for precise hardware control, and **Bricks**—pre-built software components (like AI models or databases) running in isolated containers. Every App is defined by a project folder containing a mandatory `app.yaml` manifest and a `python/main.py` entry point. For more information, see [About Apps](../../apps/about-apps/).
 
 ## app.yaml
+
 The mandatory manifest file for every App. It stores metadata and configuration, such as the App's name, icon, and the list of Bricks used in the project.
 
 ## Arduino CLI
+
 The command-line tool that handles sketch compilation and library management. It serves as the underlying engine for managing the Arduino Sketch (C++) components of an App.
 
 ## Arduino App CLI
+
 A specialized command-line tool pre-installed on compatible boards. It automates the lifecycle of an App, including building, starting, and stopping services directly from the Linux terminal.
 
 ## Arduino App Lab
+
 The integrated development environment (IDE) designed for modular application development. It allows users to create, edit, and manage Apps through a graphical interface on a computer or directly on the board in **SBC Mode**.
 
 ## Arduino Flasher CLI
+
 A standalone utility used to "flash" or reset a board with a fresh Linux operating system image, returning it to its factory state.
 
 ## Arduino Router
+
 A background Linux service (`arduino-router`) that manages data traffic between the Linux processor and the microcontroller, enabling the **Bridge** connection.
 
 ## Brick
+
 A reusable building block that an app can include to provide a specific feature, such as a web interface, a camera pipeline, an AI model, storage, or cloud connectivity. Bricks expose a high-level API so apps can use their functionality without implementing it from scratch. For more information, see [About Bricks](../../bricks/about-bricks/).
 
 ## Bridge
+
 The communication mechanism that enables the Linux processor (MPU) and the microcontroller (MCU) to exchange data. It allows Python and C++ code to interact through **Remote Procedure Calls (RPC)**.
 
 ## Connected Mode
+
 A mode where the board is connected to a computer via USB-C. The Arduino App Lab software runs on the computer and communicates with the board to deploy and monitor Apps.
 
 ## Console
+
 The interface within App Lab used to view real-time logs. It displays deployment progress, Python output, and serial data from the microcontroller.
 
 ## EDL Mode (Emergency Download Mode)
+
 A low-level boot mode used when flashing a new Linux image to the board. It is required for the **Arduino Flasher CLI** to communicate with the hardware.
 
 ## GPIO (General Purpose Input/Output)
+
 Digital pins on the board that can be programmed as inputs or outputs to interact with external electronic components.
 
 ## Linux Image
+
 The operating system file that contains the customized Linux distribution and drivers required to run the board and App Lab.
 
 ## main.py
+
 The mandatory entry point for an Arduino App. It is a Python script running on the Linux subsystem that contains the high-level application logic and orchestrates any active Bricks or microcontroller sketches.
 
 ## MCU (Microcontroller Unit)
+
 The secondary processor on the board. It handles real-time tasks and hardware interaction, running independently but in coordination with the primary processor.
 
 ## ML (Machine Learning)
+
 A subset of AI focused on systems that learn from data. Developers can deploy ML models directly on the board using Bricks.
 
 ## MQTT (Message Queuing Telemetry Transport)
+
 A lightweight messaging protocol used for IoT communication. Apps can use MQTT to report sensor data or receive remote commands.
 
 ## MPU (Microprocessor Unit)
+
 The primary processor on the board. It runs the Linux OS and handles high-level logic, networking, and the App's Python scripts.
 
 ## Modulino
+
 A system of plug-and-play hardware modules (sensors and actuators) that connect to the board via a standardized I2C connector.
 
 ## Network Mode
+
 A wireless connection state where the board is accessed over a local Wi-Fi network. This allows for remote development and monitoring after an initial USB setup.
 
 ## QWIIC
+
 A standardized connection system for I2C peripherals. It allows users to connect compatible nodes and sensors to the board without soldering.
 
 ## README.md
+
 An optional Markdown file located in an App's root directory. It provides human-readable documentation and instructions that are displayed within the Arduino App Lab interface.
 
 ## RPC (Remote Procedure Call)
+
 The protocol underlying the **Bridge**, allowing a program on one processor (e.g., MPU) to execute code on another (e.g., MCU) as if it were a local function.
 
 ## SBC Mode (Single-Board Computer)
+
 A standalone mode where the board acts as a computer. This requires connecting a monitor, keyboard, and mouse directly to the board via a USB-C hub.
 
 ## Sketch
+
 The Arduino/C++ code (`sketch.ino`) that runs on the board's microcontroller (MCU).
 
 ## SSH (Secure Shell)
+
 A secure network protocol used to access the board's Linux terminal remotely.
 
 ## Zephyr OS
+
 The Real-Time Operating System (RTOS) that runs on the microcontroller (MCU) to handle low-level tasks and bridge communication.

content/software/app-lab/4.apps/1.about-apps/about-apps.md

@@ -9,7 +9,7 @@ tags:
   - Arduino
 ---
 
-An **Arduino App** is a modular software architecture that orchestrates multiple components into a single functional unit. Unlike a traditional Arduino sketch, the core of an App is high-level **Python** logic running on the board's Linux subsystem. 
+An **Arduino App** is a modular software architecture that orchestrates multiple components into a single functional unit. Unlike a traditional Arduino sketch, the core of an App is high-level **Python** logic running on the board's Linux subsystem.
 
 While an App is fundamentally a Python application, it is highly extensible. You can enhance it by adding **Bricks** (pre-built modular components like AI models or databases) and, on supported dual-processor boards, an optional **C++ sketch** for real-time hardware control.
 

content/software/app-lab/5.bricks/1.about-bricks/about-bricks.md

@@ -14,6 +14,7 @@ tags:
 ## How Bricks Help You
 
 Bricks save time by handling heavy infrastructure tasks in the background. For example:
+
 - **AI & Vision:** Use a Brick to add object detection or face recognition without setting up complex machine learning libraries yourself.
 - **Web Dashboards:** Add a Web UI Brick to create a custom dashboard that you can control from your phone or computer.
 - **Cloud & Storage:** Use Bricks to connect to the Arduino Cloud or store sensor data in a local database.