@runuai/host 0.9.13 → 0.9.42

package/scripts/agent/task-down.sh

@@ -14,8 +14,15 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 [ "$#" -eq 1 ] || emit_err "BAD_ARGS" "usage: task-down <taskId>" "args"
 
 task_id="$1"
+# Make the ASCII security grammar independent of the operator's collation.
+export LC_ALL=C
+if [ "${#task_id}" -gt 128 ] ||
+   [[ ! "$task_id" =~ ^[a-z0-9][a-z0-9_-]*$ ]]; then
+  emit_err "BAD_ARGS" "invalid task id" "task identity validation"
+fi
 UAI_TASK_ID="$task_id"
 setup_err_trap
+validate_task_runtime_selection
 
 step "TASK_NOT_FOUND" "read task row"
 # Teardown must never depend on bookkeeping: a broken/missing command
@@ -26,51 +33,150 @@ task_json=$(db_get_task "$task_id" 2>/dev/null) || task_json="[]"
 row_count=$(jq 'length' <<<"$task_json" 2>/dev/null) || row_count=0
 if [ "$row_count" -lt 1 ]; then
   log "task row unavailable — tearing down by derived names"
-  worktree_path=""
-  compose_project="$(compose_project_for_task "$task_id")"
 else
-  worktree_path=$(jq -r '.[0].worktree_path // ""' <<<"$task_json")
-  compose_project=$(jq -r '.[0].compose_project // ""' <<<"$task_json")
-fi
-# A task-up failure can leave an error row with compose_project=NULL while its
-# conventionally named container still exists. Bookkeeping must never suppress
-# teardown; the compose project is deterministic from the task id.
-[ -n "$compose_project" ] || compose_project=$(compose_project_for_task "$task_id")
-
-# task_dir falls back to the derived path when the row's worktree_path is
-# missing (e.g. crashed before persisting).
-task_dir="$worktree_path"
-if [ -z "$task_dir" ]; then
-  task_dir="$UAI_WORKSPACE_ROOT/tasks/$task_id"
+  UAI_RETRY_STATUS=$(jq -r '.[0].status // ""' <<<"$task_json")
 fi
+# Persisted runtime paths are recovery hints, never deletion authority. A
+# corrupt row must not aim compose/rm outside this exact task identity.
+compose_project=$(compose_project_for_task "$task_id")
+task_dir="$UAI_WORKSPACE_ROOT/tasks/$task_id"
 
 # -----------------------------------------------------------------------------
 # 1. Compose stack.
 # -----------------------------------------------------------------------------
 
-step "COMPOSE_DOWN_FAILED" "docker compose down -v --rmi local"
-if [ -n "$task_dir" ] && [ -f "$task_dir/.uai/docker-compose.yml" ]; then
-  docker compose -p "$compose_project" -f "$task_dir/.uai/docker-compose.yml" \
-    down -v --rmi local --remove-orphans >/dev/null 2>&1 || true
+if [ "$TASK_RUNTIME_MODE" = "apple-container" ]; then
+  step "COMPOSE_DOWN_FAILED" "remove task container"
+  app_container=$(apple_app_container_for_task "$task_id")
+  derived_image="uai-task-${task_id}"
+  # Ownership proof before destruction (review 2026-08-18 rounds 5+6): every
+  # container Uai creates carries com.uai.task=<id>. Destruction requires the
+  # inspect response to prove EXACT identity — exactly one record, whose
+  # top-level id is the requested name, carrying the exact label — the same
+  # response-confusion discipline recovery applies. A container merely
+  # OCCUPYING the reserved name, or a confused/multi-record answer, is not
+  # authority to delete anything.
+  if existing_json=$(crt inspect "$app_container" 2>/dev/null); then
+    existing_ok=$(printf '%s' "$existing_json" \
+      | jq -r --arg name "$app_container" --arg tid "$task_id" '
+          if (type == "array" and length == 1
+              and (.[0] | type == "object")
+              and .[0].id == $name
+              and ((.[0].configuration.labels["com.uai.task"] // "") == $tid))
+          then "ok" else "mismatch" end' 2>/dev/null) \
+      || existing_ok="mismatch"
+    if [ "$existing_ok" != "ok" ]; then
+      emit_err "COMPOSE_DOWN_FAILED" \
+        "A container named $app_container exists but could not be proven as this task's own (exact identity + ownership label); Uai will not delete a container it cannot prove it owns. Remove or rename it, then retry." \
+        "remove task container"
+    fi
+    crt stop --time 10 "$app_container" >/dev/null 2>&1 || true
+    crt delete --force "$app_container" >/dev/null 2>&1 || true
+  fi
+  # A derived image is task-private; removing it mirrors `down --rmi local`.
+  crt image delete "$derived_image" >/dev/null 2>&1 || true
+  # Destruction is not best-effort: prove the container is gone before the
+  # writable Git data below is deleted or success is reported. A CLI failure
+  # that does not name this container as not-found proves nothing — the
+  # workspace and its Git data must survive until absence is confirmed. The
+  # Apple runtime has no per-task networks, sidecars, or anonymous volumes.
+  if crt inspect "$app_container" >/dev/null 2>&1; then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "task runtime resources remain after teardown" \
+      "container verification after cleanup"
+  fi
+  if ! apple_container_proven_absent "$app_container"; then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "could not verify task container removal; refusing to delete the task workspace" \
+      "container verification after cleanup"
+  fi
 else
-  # Fallback: tear down by project name only.
-  docker compose -p "$compose_project" down -v --rmi local --remove-orphans >/dev/null 2>&1 || true
-fi
-# `compose down` is intentionally best-effort because an already-absent
-# stack can make a config-less fallback fail. Destruction itself is not
-# best-effort: before deleting the worktree or reporting success, prove that
-# no container remains under the stable compose project name.
-remaining_containers=""
-if ! remaining_containers=$(docker ps -aq \
-  --filter "label=com.docker.compose.project=$compose_project"); then
-  emit_err "COMPOSE_DOWN_FAILED" \
-    "could not verify teardown for compose project $compose_project" \
-    "docker ps after compose down"
-fi
-if [ -n "$remaining_containers" ]; then
-  emit_err "COMPOSE_DOWN_FAILED" \
-    "compose project $compose_project still has containers after teardown" \
-    "docker ps after compose down"
+  step "COMPOSE_DOWN_FAILED" "docker compose down -v --rmi local"
+  if [ ! -L "$task_dir" ] && [ -f "$task_dir/.uai/docker-compose.yml" ]; then
+    docker compose -p "$compose_project" -f "$task_dir/.uai/docker-compose.yml" \
+      down -v --rmi local --remove-orphans >/dev/null 2>&1 || true
+  else
+    # Fallback: tear down by project name only.
+    docker compose -p "$compose_project" down -v --rmi local --remove-orphans >/dev/null 2>&1 || true
+  fi
+  # `compose down` is intentionally best-effort because an already-absent
+  # stack can make a config-less fallback fail. Destruction itself is not
+  # best-effort: before deleting the worktree or reporting success, prove that
+  # no task-owned container/network/volume remains under exact labels.
+  preview_containers=""
+  if ! preview_containers=$(docker ps -aq \
+    --filter "label=com.runuai.preview-sidecar.task=$task_id"); then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "could not verify preview teardown for task $task_id" \
+      "docker ps after preview teardown"
+  fi
+  if [ -n "$preview_containers" ]; then
+    # Docker ids contain no whitespace; intentional splitting passes each exact
+    # id as its own argv entry.
+    # shellcheck disable=SC2086
+    docker rm -f $preview_containers >/dev/null 2>&1 || \
+      emit_err "COMPOSE_DOWN_FAILED" "could not remove task preview sidecars" "docker rm previews"
+  fi
+
+  remaining_containers=""
+  if ! remaining_containers=$(docker ps -aq \
+    --filter "label=com.docker.compose.project=$compose_project"); then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "could not verify teardown for compose project $compose_project" \
+      "docker ps after compose down"
+  fi
+  if [ -n "$remaining_containers" ]; then
+    # shellcheck disable=SC2086
+    docker rm -f $remaining_containers >/dev/null 2>&1 || \
+      emit_err "COMPOSE_DOWN_FAILED" "could not remove compose containers" "docker rm after compose down"
+  fi
+
+  remaining_networks=""
+  if ! remaining_networks=$(docker network ls -q \
+    --filter "label=com.docker.compose.project=$compose_project"); then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "could not verify compose networks for $compose_project" \
+      "docker network ls after compose down"
+  fi
+  if [ -n "$remaining_networks" ]; then
+    # shellcheck disable=SC2086
+    docker network rm $remaining_networks >/dev/null 2>&1 || \
+      emit_err "COMPOSE_DOWN_FAILED" "could not remove compose networks" "docker network rm"
+  fi
+
+  remaining_volumes=""
+  if ! remaining_volumes=$(docker volume ls -q \
+    --filter "label=com.docker.compose.project=$compose_project"); then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "could not verify compose volumes for $compose_project" \
+      "docker volume ls after compose down"
+  fi
+  if [ -n "$remaining_volumes" ]; then
+    # shellcheck disable=SC2086
+    docker volume rm $remaining_volumes >/dev/null 2>&1 || \
+      emit_err "COMPOSE_DOWN_FAILED" "could not remove compose volumes" "docker volume rm"
+  fi
+
+  # Re-query every exact label. A successful remove command is not itself proof,
+  # and a failed query is unknown rather than empty.
+  verified_previews=""
+  verified_containers=""
+  verified_networks=""
+  verified_volumes=""
+  if ! verified_previews=$(docker ps -aq --filter "label=com.runuai.preview-sidecar.task=$task_id") ||
+     ! verified_containers=$(docker ps -aq --filter "label=com.docker.compose.project=$compose_project") ||
+     ! verified_networks=$(docker network ls -q --filter "label=com.docker.compose.project=$compose_project") ||
+     ! verified_volumes=$(docker volume ls -q --filter "label=com.docker.compose.project=$compose_project"); then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "could not verify task runtime cleanup" \
+      "docker label verification after cleanup"
+  fi
+  if [ -n "$verified_previews" ] || [ -n "$verified_containers" ] ||
+     [ -n "$verified_networks" ] || [ -n "$verified_volumes" ]; then
+    emit_err "COMPOSE_DOWN_FAILED" \
+      "task runtime resources remain after teardown" \
+      "docker label verification after cleanup"
+  fi
 fi
 
 # -----------------------------------------------------------------------------
@@ -80,10 +186,12 @@ fi
 # that retired `repo.git` path is never trusted by task-up again.
 # -----------------------------------------------------------------------------
 
-if [ -n "$task_dir" ] && [ -d "$task_dir" ]; then
+if [ -e "$task_dir" ] || [ -L "$task_dir" ]; then
   step "WORKTREE_REMOVE_FAILED" "rm -rf task dir"
   rm -rf "$task_dir"
 fi
+[ ! -e "$task_dir" ] && [ ! -L "$task_dir" ] || \
+  emit_err "WORKTREE_REMOVE_FAILED" "task directory remains after teardown" "task dir verification"
 
 # -----------------------------------------------------------------------------
 # 3. Persist final state.

package/scripts/agent/task-status.sh

@@ -17,6 +17,8 @@ UAI_TASK_ID="$task_id"
 setup_err_trap
 
 step "TASK_NOT_FOUND" "read task row"
+validate_task_runtime_selection
+
 task_json=$(db_get_task "$task_id")
 [ "$(jq 'length' <<<"$task_json")" -ge 1 ] \
   || emit_err "TASK_NOT_FOUND" "no such task: $task_id" "read task row"
@@ -24,11 +26,25 @@ task_json=$(db_get_task "$task_id")
 compose_project=$(jq -r '.[0].compose_project // ""' <<<"$task_json")
 worktree_path=$(jq -r '.[0].worktree_path // ""' <<<"$task_json")
 
-# Containers running under this compose project, JSON array of names.
+# Containers running under this task, JSON array of names.
 step "DOCKER_PS_FAILED" "docker ps"
 containers_json="[]"
-if [ -n "$compose_project" ]; then
-  raw=$(docker ps --filter "label=com.docker.compose.project=$compose_project" --format '{{.Names}}' || true)
+if [ "$TASK_RUNTIME_MODE" = "apple-container" ]; then
+  # Absence (inspect exit 1) is a definitive "not running" answer, never an
+  # unknown-state error; only a live "running" state lists the container.
+  apple_app=$(apple_app_container_for_task "$task_id")
+  apple_state=$(crt inspect "$apple_app" 2>/dev/null \
+    | jq -r '.[0].status.state // empty' 2>/dev/null) || apple_state=""
+  if [ "$apple_state" = "running" ]; then
+    containers_json=$(jq -nc --arg n "$apple_app" '[$n]')
+  fi
+elif [ -n "$compose_project" ]; then
+  if ! raw=$(docker ps --filter "label=com.docker.compose.project=$compose_project" --format '{{.Names}}'); then
+    jq -nc \
+      --arg m "docker ps did not answer; runtime state is unknown" \
+      '{ok:false,error:{code:"DOCKER_PS_FAILED",message:$m,step:"docker ps"}}' >&2
+    exit 1
+  fi
   if [ -n "$raw" ]; then
     containers_json=$(printf '%s\n' "$raw" | jq -R . | jq -sc .)
   fi