diff --git a/container/src/podcvd/skill/EVAL.yaml b/container/src/podcvd/skill/EVAL.yaml deleted file mode 100644 index 613ec330775..00000000000 --- a/container/src/podcvd/skill/EVAL.yaml +++ /dev/null @@ -1,141 +0,0 @@ -suite_name: podcvd -timeout_seconds: 600 -max_tool_calls: 80 - -cases: - - name: podcvd_lifecycle_single_create_and_reset - prompt: | - Create a single Cuttlefish instance group. Sequentially perform these multi-layered verifications: - 1. Extract the assigned group name, ADB connection address, and truncated base Web UI URL. - 2. Execute fleet to ensure the group is actively registered. - 3. Execute `adb devices -l` to confirm the ADB device is attached. - 4. Execute a `curl` command targeting the base Web UI URL to verify dashboard accessibility. - Finally, perform a global clear to reset all states globally. - - WARNING: - - Must reply all outputs into the chat, instead of creating files to get review. It's not available to read those files. - - Must describe all commands executed to the output. - skills: [podcvd] - rubric: | - The LLM evaluator must verify that the agent strictly follows this complete end-to-end agentic sequence: - 1. Creation: Executes `scripts/podcvd_executor.sh create` with mandatory flags `--vhost_user_vsock=true` and `--report_anonymous_usage_stats=n`. Direct `podcvd` usage is prohibited. - 2. Extraction: Parses outputs to explicitly display connection details. The evaluator must enforce the exact structural Formats below, while treating the Example Values strictly as illustrative references: - - Group Name ➔ Format: simple identifier string (Example Value: `cvd_1`) - - ADB Connection ➔ Format: `IP:PORT` (Example Value: `192.168.80.1:6520`) - - Web UI Endpoint ➔ Format: `https://IP:PORT` strictly stripping all specific internal paths (Example Value: `https://192.168.80.1:11443`) - 3. Fleet Verification: Executes `scripts/podcvd_executor.sh fleet` to confirm active registration. - 4. ADB Bridge Verification: Executes `adb devices -l` to explicitly confirm the Cuttlefish instance is attached as a valid device. - 5. Application Verification: Executes a `curl` command against the extracted Web UI endpoint to verify HTTP reachability. - 6. Reset: Executes `scripts/podcvd_executor.sh clear` to purge all resources globally. - expect_keywords: - - "scripts/podcvd_executor.sh" - - "create" - - "--vhost_user_vsock=true" - - "--report_anonymous_usage_stats=n" - - "fleet" - - "adb" - - "curl" - - "clear" - - - name: podcvd_lifecycle_bulk_create_and_dynamic_teardown - prompt: | - Create two Cuttlefish instance groups in parallel. Sequentially perform these verifications for both distinct groups: - 1. Report their identifiers, ADB addresses, and truncated Web UI URLs. - 2. Execute fleet to monitor their active registration. - 3. Execute `adb devices -l` to confirm both ADB connection states are present. - 4. Execute `curl` requests to verify that both Web UI endpoints are network-accessible. - Finally, remove both groups concurrently by dynamically injecting their extracted identifiers. - - WARNING: - - Must reply all outputs into the chat, instead of creating files to get review. It's not available to read those files. - - Must describe all commands executed to the output. - skills: [podcvd] - rubric: | - The LLM evaluator must verify native task concurrency, multi-layered checks, and dynamic state injection: - 1. Bulk Creation: Launches two independent `scripts/podcvd_executor.sh create` commands concurrently using native agent capabilities. Mandatory flags must be applied. - 2. Extraction: Parses outputs to display distinct access details for each group. The evaluator must enforce the required Formats below without deviation, treating Example Values strictly as illustrative placeholders: - - Group Name ➔ Format: simple identifier string (Example Value: `cvd_1`) - - ADB Connection ➔ Format: `IP:PORT` using standard ADB port (Example Value: `192.168.80.1:6520`) - - Web UI Endpoint ➔ Format: `https://IP:PORT` using standard Web UI port (Example Value: `https://192.168.80.1:11443`) - 3. Fleet Monitoring: Executes `scripts/podcvd_executor.sh fleet`. - 4. ADB Bridge Monitoring: Executes `adb devices -l` to confirm multiple distinct IP:port attachments. - 5. Network Monitoring: Executes `curl` commands to proactively verify that both independent Web UI dashboards respond. - 6. Dynamic Teardown: Concurrently launches independent `remove` commands. The agent MUST dynamically inject the actual group name strings extracted from the creation steps into the `--group_name` arguments (Format: `--group_name=`, Example Value: `--group_name=cvd_1`). Hardcoding target strings is strictly forbidden. - expect_keywords: - - "scripts/podcvd_executor.sh" - - "create" - - "--vhost_user_vsock=true" - - "--report_anonymous_usage_stats=n" - - "fleet" - - "adb" - - "curl" - - "remove" - - - name: podcvd_lifecycle_stop_and_start - prompt: | - Create a single Cuttlefish instance group. Sequentially perform these state transition verifications: - 1. Extract the assigned group name, ADB connection address, and truncated base Web UI URL. - 2. Stop the running group. - 3. Execute fleet or adb devices -l to ensure the group is no longer active or attached. - 4. Start the stopped group again. - 5. Execute fleet and adb devices -l to confirm the group is active and the ADB device is re-attached. - Finally, remove the group to clean up resources. - - WARNING: - - Must reply all outputs into the chat, instead of creating files to get review. It's not available to read those files. - - Must describe all commands executed to the output. - skills: [podcvd] - rubric: | - The LLM evaluator must verify that the agent strictly follows this state transition sequence: - 1. Creation: Executes `scripts/podcvd_executor.sh create` with mandatory flags `--vhost_user_vsock=true` and `--report_anonymous_usage_stats=n`. Direct `podcvd` usage is prohibited. - 2. Extraction: Parses outputs to explicitly display connection details. The evaluator must enforce the exact structural Formats below, while treating the Example Values strictly as illustrative references: - - Group Name ➔ Format: simple identifier string (Example Value: `cvd_1`) - - ADB Connection ➔ Format: `IP:PORT` (Example Value: `192.168.80.1:6520`) - - Web UI Endpoint ➔ Format: `https://IP:PORT` strictly stripping all specific internal paths (Example Value: `https://192.168.80.1:11443`) - 3. Stop: Executes `scripts/podcvd_executor.sh --group_name= stop` to stop the running group. The agent MUST dynamically inject the actual group name string extracted from the creation step (Format: `--group_name=`). - 4. Disconnection Verification: Executes `scripts/podcvd_executor.sh fleet` or `adb devices -l` to confirm the device is stopped/disconnected. - 5. Start: Executes `scripts/podcvd_executor.sh --group_name= start` to restart the stopped group. The agent MUST dynamically inject the actual group name string extracted from the creation step (Format: `--group_name=`). - 6. Re-connection Verification: Executes `scripts/podcvd_executor.sh fleet` and `adb devices -l` to confirm the Cuttlefish instance is active and attached again. - 7. Teardown: Executes `scripts/podcvd_executor.sh --group_name= remove` to clean up resources. The agent MUST dynamically inject the actual group name string (Format: `--group_name=`). - expect_keywords: - - "scripts/podcvd_executor.sh" - - "create" - - "--vhost_user_vsock=true" - - "--report_anonymous_usage_stats=n" - - "stop" - - "start" - - "fleet" - - "adb" - - "remove" - - - name: podcvd_lifecycle_restart - prompt: | - Create a single Cuttlefish instance group. Sequentially perform these restart verifications: - 1. Extract the assigned group name, ADB connection address, and truncated base Web UI URL. - 2. Restart the running group. - 3. Execute fleet and adb devices -l to confirm the group is active and the ADB device is re-attached. - Finally, remove the group to clean up resources. - - WARNING: - - Must reply all outputs into the chat, instead of creating files to get review. It's not available to read those files. - - Must describe all commands executed to the output. - skills: [podcvd] - rubric: | - The LLM evaluator must verify that the agent strictly follows this restart sequence: - 1. Creation: Executes `scripts/podcvd_executor.sh create` with mandatory flags `--vhost_user_vsock=true` and `--report_anonymous_usage_stats=n`. Direct `podcvd` usage is prohibited. - 2. Extraction: Parses outputs to explicitly display connection details. The evaluator must enforce the exact structural Formats below, while treating the Example Values strictly as illustrative references: - - Group Name ➔ Format: simple identifier string (Example Value: `cvd_1`) - - ADB Connection ➔ Format: `IP:PORT` (Example Value: `192.168.80.1:6520`) - - Web UI Endpoint ➔ Format: `https://IP:PORT` strictly stripping all specific internal paths (Example Value: `https://192.168.80.1:11443`) - 3. Restart: Executes `scripts/podcvd_executor.sh --group_name= restart` to restart the running group. The agent MUST dynamically inject the actual group name string extracted from the creation step (Format: `--group_name=`). - 4. Re-connection Verification: Executes `scripts/podcvd_executor.sh fleet` and `adb devices -l` to confirm the Cuttlefish instance is active and attached again after restart. - 5. Teardown: Executes `scripts/podcvd_executor.sh --group_name= remove` to clean up resources. The agent MUST dynamically inject the actual group name string (Format: `--group_name=`). - expect_keywords: - - "scripts/podcvd_executor.sh" - - "create" - - "--vhost_user_vsock=true" - - "--report_anonymous_usage_stats=n" - - "restart" - - "fleet" - - "adb" - - "remove" diff --git a/container/src/podcvd/skill/SKILL.md b/container/src/podcvd/skill/SKILL.md index cf8927a7c52..cb71c6c4e6c 100644 --- a/container/src/podcvd/skill/SKILL.md +++ b/container/src/podcvd/skill/SKILL.md @@ -24,42 +24,51 @@ This skill fully orchestrates the lifecycle of Cuttlefish instances and their gr * **Inside an Android Workspace**: You must initialize the environment (e.g., `lunch `) and build the required targets (e.g., `m`) to ensure that valid Cuttlefish host tools (inside `ANDROID_HOST_OUT`) and Android device images (inside `ANDROID_PRODUCT_OUT`) are generated. * **Outside an Android Workspace**: If you are not in an active build environment, you must ensure that compatible, pre-built Cuttlefish host tools and Android device images are already present in the working directory or are otherwise accessible via the relevant environment paths (like `ANDROID_HOST_OUT` and `ANDROID_PRODUCT_OUT`). -## Mandatory Execution Rule (Critical) +## Mandatory Environment Configuration (Client ID Tracking) -You **MUST NOT** call the `podcvd` binary directly. +Setting the `PODCVD_CLIENT_ID` environment variable is **MANDATORY** whenever executing `podcvd` subcommands. This ensures proper session tracking and prevents resource collisions. -You **MUST ALWAYS** execute the wrapper script located directly inside this skill's directory at: -**`scripts/podcvd_executor.sh`** +### Execution Rule (Mandatory) +* You **MUST** check if the reference file `references/podcvd_client_id.md` exists within this skill directory. +* **If `references/podcvd_client_id.md` exists**: You **MUST** read its contents using `view_file` and strictly follow the platform-specific instructions provided inside to construct and pass `PODCVD_CLIENT_ID` before calling `podcvd`. +* **If `references/podcvd_client_id.md` does NOT exist**: Only as an exception, omit setting `PODCVD_CLIENT_ID` (leave it empty) and execute `podcvd` directly. -> [!TIP] -> **Agent Guidance**: To avoid path resolution errors, verify you are pointing to the correct `scripts/podcvd_executor.sh` relative to this `SKILL.md` file when executing commands. +## Key Execution Guidelines & Considerations (Crucial) + +> [!IMPORTANT] +> Always follow these essential execution policies when managing Cuttlefish instances: + +* **ADB Connection Lifecycle**: Subcommands (e.g., `create`, `start`, `restart`, `powerwash`) automatically establish or re-establish ADB connections, while subcommands (e.g., `stop`, `remove`, `clear`, `reset`) automatically tear down ADB connections. Never invoke external ADB tools manually. +* **Dynamic Group Identifier Tracking**: Executing `podcvd create` initializes a new instance group and returns a JSON response containing its assigned `"group_name"`. Because `"group_name"` is the primary identifier for managing that group, you **MUST** extract and track this string (from the `create` output or `podcvd fleet`) to dynamically pass `--group_name=` in subsequent lifecycle operations (e.g., `stop`, `start`, `restart`, `remove`). +* **Booting & Execution Duration**: Starting or booting Cuttlefish instances (e.g., executing `create`, `start`, `restart`, `powerwash`) takes approximately 1 minute for the virtual device boot process and ADB connection setup to complete. During this boot window, `podcvd fleet` will report status `"Starting"` and `adb devices -l` may temporarily show an empty list. You **MUST wait** for `podcvd fleet` status to transition to `"Running"` (up to 1-2 minutes) before verifying ADB device readiness or executing teardown operations. Do not prematurely cancel, clear, or report failure while status is still `"Starting"`. +* **Status Verification**: Always verify instance state using `podcvd fleet` **BEFORE and AFTER** state transitions. Before issuing any state-changing subcommand (e.g., `stop`, `restart`, `remove`), execute `podcvd fleet` to ensure previous operations have finished and the group is in the expected state (e.g., `"Running"`). After transitions, verify status and confirm ADB connection readiness using `podcvd fleet` and `adb devices -l`. ## Standard Ready-to-Use Commands (Recommended) -To ensure high success rates and avoid malformed options, prefer using the fully constructed standard command lines below for general tasks. +To ensure high success rates and avoid malformed options, prefer using the fully constructed standard command lines below for general tasks. Always include `PODCVD_CLIENT_ID=""` at the start of every command line. ### 1. Create Instance Group (Establishes ADB Connection) Creates an instance group with standard configurations and **automatically establishes ADB connections**. (For bulk creation, see the concurrency policy below). ```bash -./scripts/podcvd_executor.sh create --vhost_user_vsock=true --report_anonymous_usage_stats=n +PODCVD_CLIENT_ID="" podcvd create --vhost_user_vsock=true --report_anonymous_usage_stats=n ``` ### 2. List Active Fleets Lists all currently running Cuttlefish instance groups. ```bash -./scripts/podcvd_executor.sh fleet +PODCVD_CLIENT_ID="" podcvd fleet ``` ### 3. Remove Specific Group (Destroys ADB Connection) Removes a targeted instance group and **automatically destroys corresponding ADB connections**. Replace `` with the actual ID. ```bash -./scripts/podcvd_executor.sh --group_name= remove +PODCVD_CLIENT_ID="" podcvd --group_name= remove ``` ### 4. Clear All Groups (Destroys All ADB Connections) Completely tears down all Cuttlefish instance groups and destroys all relevant ADB connections globally. ```bash -./scripts/podcvd_executor.sh clear +PODCVD_CLIENT_ID="" podcvd clear ``` ## Concurrency & Parallel Execution Policy (Crucial) @@ -72,7 +81,7 @@ User intent is paramount and overrides this rule, but parallel processing is the > **Default Strict Prohibition**: When handling bulk requests (e.g., "create 10 instances" or "remove groups A, B, and C"), you **MUST NOT** execute them sequentially by default. Waiting for one task to complete before initiating the next severely degrades system performance. **Execution Guidance for Agents:** -Launch independent wrapper commands concurrently as background tasks, with leveraging agent's native capability dealing with concurrent behavior if possible. +Launch independent `podcvd` commands concurrently as background tasks, with leveraging agent's native capability dealing with concurrent behavior if possible. **Exceptions to Parallel Execution:** 1. **User Override**: The user explicitly asks to perform tasks sequentially (one by one). @@ -81,37 +90,45 @@ Launch independent wrapper commands concurrently as background tasks, with lever ## Advanced Usage -Only assemble custom command lines if the user explicitly requests non-standard configurations. Treat the wrapper script exactly like the original binary: - -```bash -./scripts/podcvd_executor.sh [podcvd_flags...] [subcommand_flags...] -``` - -To understand advanced setup options and detailed command usage, you should query the tool's built-in help directly: +Below are the currently supported podcvd subcommands in alphabetical order: + +* `bugreport`: Captures diagnostic host logs into a zip archive for troubleshooting (optionally includes device adb bugreport) +* `cache`: Manage the files cached by cvd +* `clear`: Clears the instance database, stopping any running instances first +* `create`: Create a Cuttlefish instance group +* `display`: Enables hotplug/unplug of displays from running cuttlefish virtual devices +* `env`: Enumerate + Query APIs for all gRPC services made available by this virtual device instance +* `fetch`: Retrieve build artifacts based on branch and target names +* `fleet`: Lists active devices with relevant information +* `help`: Used to display help information for other commands +* `lint`: Error checks the input virtual device json config file +* `load`: Creates and starts an instance group from a JSON configuration file +* `login`: Acquire credentials +* `logs`: List and display log files +* `monitor`: Monitor device logs (launcher, kernel, and logcat) in real-time +* `powerbtn`: Trigger power button event on the device +* `powerwash`: Reset device to first boot state +* `remove`: Remove instance groups and related artifacts from the system +* `reset`: Remove all instance groups and kills orphaned cuttlefish processes +* `restart`: Restart device +* `resume`: Resume the cuttlefish device +* `screen_recording`: Record screen contents +* `setup`: Configure the host for Cuttlefish +* `snapshot_take`: Take snapshot of the cuttlefish device +* `start`: Start all Cuttlefish Instances in a group +* `status`: Query status of a single instance group. Use `podcvd fleet` for all devices +* `stop`: Stop Cuttlefish instances +* `suspend`: Suspend the cuttlefish device +* `version`: Prints version of cvd client and cvd server + +To inspect supported flags and advanced setup options for any subcommand, query built-in help directly: ```bash -./scripts/podcvd_executor.sh help -# or for specific subcommands: -./scripts/podcvd_executor.sh --help -``` - -## Integrated Web UI Monitoring Tip (Highly Recommended) - -Executing the `create` or `fleet` subcommands returns a JSON output containing instance configuration details. Within this JSON, you will find a **`web_access`** field. - -To provide the user with the **superior integrated group dashboard** (which offers a much better management view than individual instance pages), you **MUST strip away the specific device paths** and present **ONLY the base Protocol, IP, and Port**. - -### URL Extraction Example -If the JSON output returns: -```json -"web_access": "https://192.168.80.1:1443/devices/cvd_1-1-1/files/client.html" +PODCVD_CLIENT_ID="" podcvd help ``` -You must truncate the path and provide the user with this exact link: -**`https://192.168.80.1:1443`** -## Current Limitations & Temporarily Unsupported Features (Critical) +## Connection Details Formatting Tip (Mandatory Output Formatting) -Please be aware of the following **current** technical limitations when operating Cuttlefish instances via `podcvd`. Note that these features are actively being worked on and may be supported in future updates: +Executing the `create` or `fleet` subcommands returns JSON outputs containing instance configuration details. When reporting these connection details in your responses, you **MUST** follow these exact structural formats: -* **Temporarily Unimplemented Subcommands**: Some `cvd` subcommands listed in the help output are not yet fully implemented and will explicitly return errors if executed in the current container environment. -* **GPU Acceleration Not Yet Supported**: GPU hardware acceleration is **not yet supported**. Instances currently run with software rendering. -* **Temporarily Restricted Filesystem Flag Support**: Flag support for custom filesystem paths is currently highly restricted. While paths residing within standard `ANDROID_HOST_OUT` and `ANDROID_PRODUCT_OUT` are exceptionally handled and fully supported, specifying advanced flags to point to any other custom directory paths (for example, setting custom kernel image paths outside these pre-configured directories) will likely fail. Avoid using advanced filesystem/path-redirection flags for non-standard paths until support is fully introduced. +1. **ADB Connection Address**: You **MUST** combine the host IP address and the allocated ADB port into the standard **`IP:PORT`** format (for example: **`192.168.112.1:6520`**). Never output only the port number or `adb_port: 6520`. +2. **Web UI Endpoint**: You **MUST strip away specific device paths** from the `web_access` URL and present **ONLY the base Protocol, IP, and Port** (for example, if JSON returns `"https://192.168.112.1:11443/devices/cvd_1-1-1/files/client.html"`, present it as **`https://192.168.112.1:11443`**). diff --git a/container/src/podcvd/skill/TEST.md b/container/src/podcvd/skill/TEST.md deleted file mode 100644 index e32d5e39866..00000000000 --- a/container/src/podcvd/skill/TEST.md +++ /dev/null @@ -1,100 +0,0 @@ -# Test Plan: podcvd - -This test plan is structured into two sequential verification phases: establishing the correct activation context, followed by detailed capability testing of the execution logic. - ---- - -## Phase 1: Trigger Testing (Activation Context) -Verify that the agent correctly identifies user intent and activates the skill only when relevant. - -### 1.1 Positive Triggers (Skill Must Activate) -* "create 3 cf instances" -* "list active cf instances" -* "remove cf group_1" -* "clear all cf instances" -* "show me running cuttlefish groups" -* "delete cuttlefish cvd_1" - -### 1.2 Negative Triggers (Skill Must Remain Inactive) -* "build android tree" -* "run settings app tests" -* "flash my physical device using flashall" -* "flash pixel 8 pro with latest eng build" -* "reconnect acloud emulator" - ---- - -## Phase 2: Capability Testing (Command Mapping & Logic) -Verify that the agent translates specific input prompts into the exact required underlying bash commands using the wrapper script. Stateful lifecycle integrity must be maintained (teardown actions evaluate resources seeded in prior steps). - -### Scenario 1: Single Instance Creation -* **Input Prompt**: "Create a Cuttlefish instance group." -* **Expected Underlying Command**: - ```bash - ./scripts/podcvd_executor.sh create --vhost_user_vsock=true --report_anonymous_usage_stats=n - ``` -* **Verification Details**: - * Must execute the wrapper script; direct `podcvd` calls are strictly prohibited. - * Must apply both mandatory flags. - * **Output Parsing Example**: The agent must extract and display the connection info clearly, stripping specific device paths from the Web UI URL: - ```text - group_name: "cvd_1" - Established ADB Connection: 192.168.80.1:6520 - Integrated Web UI Dashboard: https://192.168.80.1:11443 - ``` - * **Multi-Layered State Cross-Verification**: - 1. **Fleet Layer**: Execute `./scripts/podcvd_executor.sh fleet`. Confirm `group_name: "cvd_1"` is actively listed. - 2. **ADB Bridge Layer**: Execute `adb devices -l`. Confirm `192.168.80.1:6520` is present and attached as a valid device. - 3. **Application Layer (Web UI)**: Access `https://192.168.80.1:11443` via a browser or HTTP request to ensure the integrated dashboard loads successfully. - -### Scenario 2: Global Reset & State Verification (Strictly Dependent on Scenario 1) -* **Input Prompt**: "Clear all running Cuttlefish instances." -* **Expected Underlying Command**: - ```bash - ./scripts/podcvd_executor.sh clear - ``` -* **Verification Details**: - * Must effectively tear down the instance previously seeded in Scenario 1. - * **Multi-Layered State Cross-Verification**: - 1. **Fleet Layer**: Confirm `./scripts/podcvd_executor.sh fleet` returns an empty list. - 2. **ADB Bridge Layer**: Execute `adb devices -l`. Confirm all Cuttlefish-managed IP:port connection states are wiped globally. - 3. **Application Layer (Web UI)**: Confirm that all associated Web UI dashboard endpoints are unreachable. - -### Scenario 3: Parallel Bulk Creation & Group Name Extraction -* **Input Prompt**: "Create two Cuttlefish instance groups." -* **Expected Underlying Commands** (Executed concurrently via native agent concurrency): - ```bash - ./scripts/podcvd_executor.sh create --vhost_user_vsock=true --report_anonymous_usage_stats=n - ./scripts/podcvd_executor.sh create --vhost_user_vsock=true --report_anonymous_usage_stats=n - ``` -* **Verification Details**: - * Commands must overlap in execution rather than blocking sequentially. - * **Output Parsing Example**: The agent must extract the unique **`group_name`** strings and present them clearly alongside the parsed connection info: - ```text - Group 1 ➔ group_name: "cvd_1", ADB: 192.168.80.1:6520, Web UI: https://192.168.80.1:11443 - Group 2 ➔ group_name: "cvd_2", ADB: 192.168.80.2:6520, Web UI: https://192.168.80.2:11443 - ``` - * **Multi-Layered State Cross-Verification**: - 1. **Fleet Layer**: Execute `./scripts/podcvd_executor.sh fleet`. Confirm both `cvd_1` and `cvd_2` are actively listed. - 2. **ADB Bridge Layer**: Execute `adb devices -l`. Confirm both `192.168.80.1:6520` and `192.168.80.2:6520` are attached. - 3. **Application Layer (Web UI)**: Confirm network reachability for both independent dashboards (`https://192.168.80.1:11443` and `https://192.168.80.2:11443`). - -### Scenario 4: Stateful Dynamic Teardown (Strictly Dependent on Scenario 3) -* **Input Prompt**: "Remove the two Cuttlefish instance groups we just created." -* **Expected Underlying Commands** (Executed concurrently via native agent concurrency): - ```bash - # Example: Mapping the exact group_name outputs extracted from Scenario 3 - ./scripts/podcvd_executor.sh --group_name=cvd_1 remove - ./scripts/podcvd_executor.sh --group_name=cvd_2 remove - ``` -* **Verification Details**: - * **Dynamic State Injection**: The agent must dynamically map the output values from prior steps. For instance, if Scenario 3 returned `cvd_1` and `cvd_2`, those exact strings must be injected into the `--group_name` parameters. Hardcoded placeholders are strictly prohibited. - * Removals must be launched concurrently using native concurrency. - * **Multi-Layered State Cross-Verification**: - 1. **Fleet Layer**: Execute `./scripts/podcvd_executor.sh fleet`. Confirm `cvd_1` and `cvd_2` have been effectively purged from the output. - 2. **ADB Bridge Layer**: Execute `adb devices -l`. Confirm `192.168.80.1:6520` and `192.168.80.2:6520` are fully disconnected and absent from the device list. - 3. **Application Layer (Web UI)**: Confirm that all associated Web UI dashboard endpoints are unreachable. - -### Scenario 5: Secondary ADB Tool Prevention -* **Input Prompt**: "Connect ADB to my newly created Cuttlefish instance." -* **Expected Behavior**: The agent must refuse or bypass manual secondary ADB tool invocations, explaining that ADB connection is fully managed internally by the `podcvd_executor.sh` wrapper. diff --git a/container/src/podcvd/skill/scripts/podcvd_executor.sh b/container/src/podcvd/skill/scripts/podcvd_executor.sh deleted file mode 100755 index 6b49c916754..00000000000 --- a/container/src/podcvd/skill/scripts/podcvd_executor.sh +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash - -set -e - -SID=$(ps -o sid= -p $$ | xargs) -PODCVD_CLIENT_ID="${SID}-$(stat -c '%Y' "/proc/${SID}")" podcvd "$@"