unoverse 0.1.32 → 0.1.34

package/bin/unoverse.mjs

@@ -103,26 +103,36 @@ switch (cmd) {
     break;
 
   case "update": {
-    // Refresh the repo-local authoring skill alongside the CLI, when we are in a
-    // universe. It is a copy by necessity (Claude Code discovers .claude/skills off
-    // disk), so the CLI's own update is what keeps it current.
+    // ONE update: the CLI from npm, then everything the CLI is responsible for keeping
+    // current — the repo-local authoring skill and, in a universe, the platform images.
+    // Those two steps run via `_postupdate` in the NEWLY installed binary, not this
+    // process: this file is being replaced mid-command, and copying the skill from the
+    // old install would pin it one release behind forever.
+    const r = spawnSync("npm", ["install", "-g", "unoverse@latest"], { stdio: "inherit" });
+    if (r.status === 0) {
+      const v = spawnSync("unoverse", ["-v"], { encoding: "utf8" }).stdout?.trim();
+      console.log(`\n  ✓ unoverse is now ${v || "up to date"}`);
+      spawnSync("unoverse", ["_postupdate"], { stdio: "inherit" });
+    } else {
+      console.log(`\n  ✗ global install failed (permissions?). Try:\n\n    sudo npm install -g unoverse@latest\n    npx unoverse@latest    # or skip the global install entirely\n`);
+    }
+    process.exit(r.status ?? 0);
+  }
+
+  case "_postupdate": {
+    // Runs AS the new version, in the developer's cwd. Outside a universe there is
+    // nothing to refresh, and silence is the right answer.
     if (UNIVERSE) {
       const skillSrc = join(dirname(fileURLToPath(import.meta.url)), "../operator/skills/unoverse-create");
       if (existsSync(skillSrc)) {
         const { cpSync, mkdirSync } = await import("node:fs");
         mkdirSync(join(UNIVERSE.root, ".claude/skills"), { recursive: true });
         cpSync(skillSrc, join(UNIVERSE.root, ".claude/skills/unoverse-create"), { recursive: true });
-        console.log("  ✓ authoring skill refreshed (.claude/skills/unoverse-create)");
+        console.log("  ✓ authoring skill refreshed");
       }
+      operator(UNIVERSE, ["refresh-images"]);
     }
-    const r = spawnSync("npm", ["install", "-g", "unoverse@latest"], { stdio: "inherit" });
-    if (r.status === 0) {
-      const v = spawnSync("unoverse", ["-v"], { encoding: "utf8" }).stdout?.trim();
-      console.log(`\n  ✓ unoverse is now ${v || "up to date"}\n`);
-    } else {
-      console.log(`\n  ✗ global install failed (permissions?). Try:\n\n    sudo npm install -g unoverse@latest\n    npx unoverse@latest    # or skip the global install entirely\n`);
-    }
-    process.exit(r.status ?? 0);
+    process.exit(0);
   }
 
   // `urls` stays as an alias: it shipped in 0.1.4/0.1.5 and is in people's fingers.

package/operator/lib/init.sh

@@ -5,6 +5,49 @@
 # (`npm i -g unoverse`); symlinking a per-project bash script into /usr/local/bin was the
 # second CLI we set out to delete.
 
+# ── The image download, as an experience ─────────────────────────────────────
+#
+# The pull starts the moment the token is accepted, so the minute spent answering
+# questions is also the minute the images arrive. NOTHING writes to the terminal
+# asynchronously — a progress bar racing a readline prompt corrupts what the developer
+# is typing. The background half writes one line of STATE to a temp file; the wizard
+# prints a status line synchronously between question groups, where output composes
+# with input; the end of setup attaches with docker's own bars for whatever remains.
+PULL_STATE=""
+start_background_pull() {
+  PULL_STATE=$(mktemp)
+  (
+    imgs=$(docker compose -f "$ROOT/docker-compose.yml" config --images 2>/dev/null | sort -u)
+    total=$(printf '%s\n' "$imgs" | grep -c .)
+    n=0
+    for img in $imgs; do
+      short="${img##*/}"; short="${short%%:*}"
+      if docker image inspect "$img" >/dev/null 2>&1; then
+        n=$((n+1)); echo "$n $total ready $short" > "$PULL_STATE"; continue
+      fi
+      echo "$n $total pulling $short" > "$PULL_STATE"
+      docker pull "$img" >/dev/null 2>&1
+      n=$((n+1)); echo "$n $total pulled $short" > "$PULL_STATE"
+    done
+    echo "$total $total done -" > "$PULL_STATE"
+  ) &
+}
+
+# One dim line, printed only when the wizard is printing anyway. Never a redraw.
+pull_status_line() {
+  [ -n "$PULL_STATE" ] && [ -s "$PULL_STATE" ] || return 0
+  local n total verb what
+  read -r n total verb what < "$PULL_STATE" 2>/dev/null || return 0
+  if [ "$verb" = "done" ]; then
+    echo -e "  ${GREEN}⬇${NC} ${DIM}platform images: all $total downloaded${NC}"
+  elif [ "$verb" = "pulling" ]; then
+    echo -e "  ${CYAN}⬇${NC} ${DIM}platform images: $n of $total · pulling $what…${NC}"
+  else
+    echo -e "  ${CYAN}⬇${NC} ${DIM}platform images: $n of $total${NC}"
+  fi
+  echo ""
+}
+
 # First-run detection
 check_first_run() {
   if [ ! -f "$ROOT/.env" ]; then
@@ -115,6 +158,18 @@ cmd_init() {
     done
   fi
 
+  # THE DOWNLOAD STARTS NOW (see the block at the top of this file).
+  if [ "$DOCKER_OK" = "1" ]; then
+    if echo "$DOCR_TOKEN" | docker login "$DOCR_REGISTRY" -u "$DOCR_TOKEN" --password-stdin >/dev/null 2>&1; then
+      start_background_pull
+      echo ""
+      echo -e "  ${CYAN}⬇${NC} ${DIM}Platform images are downloading in the background while you configure${NC}"
+      echo ""
+    else
+      warn "Registry login failed with this token. Images will not pull until it is fixed"
+    fi
+  fi
+
   # A DEFAULT, because "from your admin" is meaningless when you are the admin. The
   # platform ships no database (docker-compose has no postgres), so this points at one
   # you run. Enter takes the conventional local one.
@@ -144,6 +199,7 @@ cmd_init() {
     fi
   fi
 
+  pull_status_line
   # Redis, current values as defaults
   local rd
   rd=$(_env_cur REDIS_HOST); rd="${rd:-host.docker.internal}"
@@ -174,7 +230,7 @@ cmd_init() {
   # a deployed universe ("there is no auth-off deployment"), and the platform enforces it
   # rather than trusting this wizard: authConfig.ts refuses to start with auth off when
   # NODE_ENV=production. So answering "no" here cannot produce an unprotected deployment.
-  echo ""
+  pull_status_line
   local cur_auth idp_prompt
   cur_auth=$(_env_cur AUTH_ENABLED)
   idp_prompt="[y/N]"
@@ -243,6 +299,7 @@ cmd_init() {
   ok "Redis namespace: ${BOLD}${REDIS_NAMESPACE}${NC}"
 
   # OpenAI (for Memory Server)
+  pull_status_line
   local cur_oai
   cur_oai=$(_env_cur OPENAI_API_KEY)
   # NOT just the memory server: compose hands this to the unoverse service itself —
@@ -297,21 +354,15 @@ ENVEOF
 
   ok ".env created"
 
-  # Registry login and the image pull both need a daemon. Without one the token is
-  # already written to .env, so `unoverse start` does this on its first run.
+  # Attach to the background pull started when the token was accepted: layers already
+  # down show as complete, the rest stream docker's progress bars. Without a daemon the
+  # token is in .env, and `unoverse start` pulls on its first run.
   if [ "$DOCKER_OK" = "1" ]; then
-    echo ""
-    echo -e "  Logging in to DigitalOcean Container Registry..."
-    if echo "$DOCR_TOKEN" | docker login "$DOCR_REGISTRY" -u "$DOCR_TOKEN" --password-stdin &>/dev/null; then
-      ok "Logged in to DOCR"
-    else
-      fail "DOCR login failed. Check your token"
-      exit 1
-    fi
-    cmd_pull
+    pull_missing_images
+    [ -n "$PULL_STATE" ] && rm -f "$PULL_STATE"
   else
     echo ""
-    info "Skipped the registry login and image pull. ${BOLD}unoverse start${NC} does both once Docker is up"
+    info "Skipped the image download. ${BOLD}unoverse start${NC} does it once Docker is up"
   fi
 
   # Install to PATH

package/operator/lib/start.sh

@@ -33,6 +33,24 @@ check_docker_file_sharing() {
   return 0
 }
 
+# Pull whatever images are missing, VISIBLY. docker's own per-layer progress bars are the
+# loading indication — a developer staring at a silent screen while gigabytes download
+# assumes the tool is hung. Exists because init used to call cmd_pull (deleted with
+# update.sh), so nothing pulled and nothing printed, and start buried compose's pull
+# inside a log file.
+pull_missing_images() {
+  local img missing=""
+  for img in $(docker compose -f "$ROOT/docker-compose.yml" config --images 2>/dev/null | sort -u); do
+    docker image inspect "$img" >/dev/null 2>&1 || missing="$missing $img"
+  done
+  [ -n "$missing" ] || return 0
+  echo ""
+  info "Pulling platform images (first run — a few minutes, progress below)..."
+  echo ""
+  docker compose -f "$ROOT/docker-compose.yml" --env-file "$ROOT/.env" pull     || { fail "Image pull failed. Check the registry token (re-run unoverse create to change it)"; exit 1; }
+  echo ""
+}
+
 cmd_start() {
   # Login to registry if DOCR_TOKEN is set
   local docr_token
@@ -44,6 +62,8 @@ cmd_start() {
   # `start --pull` refreshes the images first. This is where refreshing a LOCAL universe
   # lives now: `update` is the CLI's word and means only the CLI, wherever you type it.
   # A server is refreshed by `unoverse deploy` from your machine, not on the box.
+  pull_missing_images
+
   if [ "${1:-}" = "--pull" ]; then
     info "Pulling the latest images..."
     docker compose -f "$ROOT/docker-compose.yml" pull || { fail "Image pull failed"; exit 1; }

package/operator/operator.sh

@@ -64,6 +64,22 @@ case "${1:-}" in
   check)     cmd_check && cmd_db_verify && cmd_doctor ;;
   dev)       cmd_dev ;;
   ground)    shift; cmd_ground "$@" ;;
+  refresh-images)
+    # internal: `unoverse update` runs this after updating the CLI. Pull newer images
+    # if the registry has them, and recreate only what is already running — an update
+    # never boots a stopped universe.
+    if [ ! -f "$ROOT/.env" ]; then
+      : # unconfigured: nothing to refresh
+    elif ! docker info >/dev/null 2>&1; then
+      info "Docker is not running. Images refresh on the next unoverse start"
+    else
+      info "Checking for newer platform images..."
+      docker compose -f "$ROOT/docker-compose.yml" --env-file "$ROOT/.env" pull || warn "image check failed (network/registry?)"
+      if [ -n "$(docker compose -f "$ROOT/docker-compose.yml" ps -q 2>/dev/null)" ]; then
+        docker compose -f "$ROOT/docker-compose.yml" --env-file "$ROOT/.env" up -d --remove-orphans >/dev/null 2>&1 \
+          && ok "Running services moved to the new images"
+      fi
+    fi ;;
   deploy)
     # `deploy marketplace` is PLATFORM-OWNER only: it publishes the marketplace package
     # to npm, which a starter developer never does (they INSTALL from the marketplace).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "The Unoverse front door — create a Studio project, a universe, or a client app, and launch Studio.",
   "license": "SEE LICENSE IN README.md",
   "type": "module",