@spacemade/ui 0.0.1

package/app.sh

@@ -0,0 +1,806 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCHEMA_FILE="${APPSTUDIO_SCHEMA_FILE:-${OSIRAX_SCHEMA_FILE:-${ROOT_DIR}/appstudio.schema.json}}"
+UI_PACKAGE="${SPACEMADE_UI_PACKAGE:-${OSIRAX_UI_PACKAGE:-@spacemade/ui}}"
+API_PACKAGE="${SPACEMADE_API_PACKAGE:-${OSIRAX_API_PACKAGE:-@spacemade/api}}"
+CLI_BIN="${SPACEMADE_CLI_BIN:-${OSIRAX_CLI_BIN:-spacemade}}"
+UI_PATH="${SPACEMADE_UI_PATH:-${OSIRAX_UI_PATH:-${OSIRAX_CORE_PATH:-}}}"
+API_PATH="${SPACEMADE_API_PATH:-${OSIRAX_API_PATH:-}}"
+
+usage() {
+  cat <<'EOFUSAGE'
+Usage: ./app.sh <command> [args]
+
+Bootstrap:
+  init [--name <name>] [--force]  Create the lightweight app skeleton and base schema
+  schema [--name <name>] [--force] Create only appstudio.schema.json
+  edit-schema                    Open the schema in $EDITOR
+  install                        Install UI/API packages, or link local paths when set
+  link-core [path]               Symlink local UI/API checkouts into node_modules
+  generate [--force] [schema]     Generate the app from the schema
+  bootstrap [--name <name>]       Run init, install, and generate
+  doctor                         Check local Node/NPM and bootstrap files
+  help                           Show this help output
+
+Package overrides:
+  SPACEMADE_UI_PACKAGE=@spacemade/ui
+  SPACEMADE_API_PACKAGE=@spacemade/api
+  SPACEMADE_CLI_BIN=spacemade
+  APPSTUDIO_SCHEMA_FILE=./appstudio.schema.json
+  SPACEMADE_UI_PATH=../appstudio
+  SPACEMADE_API_PATH=../appstudio/api
+EOFUSAGE
+}
+
+die() {
+  echo "$*" >&2
+  exit 1
+}
+
+has_command() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+require_command() {
+  has_command "$1" || die "Missing required command: $1"
+}
+
+sanitize_name() {
+  local value="${1:-}"
+  value="$(printf '%s' "$value" | tr '[:upper:]' '[:lower:]')"
+  value="$(printf '%s' "$value" | sed -E 's/[^a-z0-9._-]+/-/g; s/^-+//; s/-+$//')"
+
+  if [[ -z "$value" ]]; then
+    value="appstudio-app"
+  fi
+
+  printf '%s' "$value"
+}
+
+default_app_name() {
+  sanitize_name "$(basename "$ROOT_DIR")"
+}
+
+parse_name_and_force() {
+  APP_NAME="$(default_app_name)"
+  FORCE="false"
+
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --name)
+        [[ -n "${2:-}" ]] || die "Missing value for --name"
+        APP_NAME="$(sanitize_name "$2")"
+        shift 2
+        ;;
+      --force)
+        FORCE="true"
+        shift
+        ;;
+      *)
+        die "Unknown option: $1"
+        ;;
+    esac
+  done
+}
+
+ensure_dir() {
+  mkdir -p "$1"
+}
+
+write_file() {
+  local file_path="$1"
+  local contents="$2"
+
+  ensure_dir "$(dirname "$file_path")"
+
+  if [[ "$FORCE" != "true" && -f "$file_path" ]]; then
+    echo "skip ${file_path#"$ROOT_DIR"/}"
+    return
+  fi
+
+  printf '%s\n' "$contents" > "$file_path"
+  echo "write ${file_path#"$ROOT_DIR"/}"
+}
+
+write_package_json() {
+  local file_path="${ROOT_DIR}/package.json"
+  local schema_script_path="./$(basename "$SCHEMA_FILE")"
+
+  write_file "$file_path" "{
+  \"name\": \"${APP_NAME}\",
+  \"version\": \"0.1.0\",
+  \"private\": true,
+  \"scripts\": {
+    \"dev\": \"${CLI_BIN} dev\",
+    \"dev:api\": \"cd api && npm run dev\",
+    \"build\": \"${CLI_BIN} build\",
+    \"build:api\": \"cd api && npm run build\",
+    \"start\": \"${CLI_BIN} start\",
+    \"start:api\": \"cd api && npm run start\",
+    \"generate\": \"${CLI_BIN} generate ${schema_script_path}\"
+  },
+  \"dependencies\": {},
+  \"devDependencies\": {}
+}"
+}
+
+write_gitignore() {
+  write_file "${ROOT_DIR}/.gitignore" "node_modules
+.next
+dist
+build
+.env
+.env.local
+*.tsbuildinfo
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*"
+}
+
+write_env_example() {
+  write_file "${ROOT_DIR}/.env.example" "NEXT_PUBLIC_APP_NAME=${APP_NAME}
+NEXT_PUBLIC_APP_BASE_PATH=/admin
+NEXT_PUBLIC_API_URL=http://localhost:3001
+APP_ENV=dev
+APP_PORT=3000
+API_PORT=3001
+SITE_URL=http://localhost:3000
+DB_HOST=127.0.0.1
+DB_NAME=
+DB_USER=
+DB_PASSWORD=
+DB_ROOT_PASSWORD=
+DB_PORT=3306
+REDIS_HOST=127.0.0.1
+REDIS_PORT=6379
+REDIS_TLS=false
+REDIS_TOKEN=
+SESSION_SECRET=
+TOKEN_ENCRYPT_VECTOR=
+TOKEN_PEPPER=
+TOKEN_PREFIX=tok_
+TOKEN_BYTE_LENGTH=32"
+}
+
+random_hex() {
+  local bytes="$1"
+  node -e "process.stdout.write(require('node:crypto').randomBytes(Number(process.argv[1])).toString('hex'))" "$bytes"
+}
+
+write_runtime_env() {
+  local docker_env="${ROOT_DIR}/.env"
+  local app_env="${ROOT_DIR}/.env.local"
+  local api_env="${ROOT_DIR}/api/.env.local"
+
+  if [[ -f "$docker_env" || -f "$app_env" || -f "$api_env" ]]; then
+    if [[ -f "$docker_env" && -f "$app_env" && -f "$api_env" ]]; then
+      echo "skip .env"
+      echo "skip .env.local"
+      echo "skip api/.env.local"
+      return
+    fi
+
+    die "Runtime environment is incomplete. Keep or remove .env, .env.local, and api/.env.local together."
+  fi
+
+  require_command node
+
+  local db_name="${APP_NAME//-/_}"
+  local db_user="${db_name}_user"
+  local db_password="$(random_hex 24)"
+  local db_root_password="$(random_hex 24)"
+  local session_secret="$(random_hex 32)"
+  local token_encrypt_vector="$(random_hex 32)"
+  local token_pepper="$(random_hex 32)"
+
+  ensure_dir "$(dirname "$api_env")"
+
+  printf '%s\n' "APP_ENV=dev
+APP_PORT=3000
+API_PORT=3001
+NEXT_PUBLIC_APP_NAME=${APP_NAME}
+NEXT_PUBLIC_APP_BASE_PATH=/admin
+NEXT_PUBLIC_API_URL=http://localhost:3001
+SITE_URL=http://localhost:3000
+DB_HOST=mysql
+DB_NAME=${db_name}
+DB_USER=${db_user}
+DB_PASSWORD=${db_password}
+DB_ROOT_PASSWORD=${db_root_password}
+DB_PORT=3306
+REDIS_HOST=redis
+REDIS_PORT=6379
+REDIS_TLS=false
+REDIS_TOKEN=
+SESSION_SECRET=${session_secret}
+TOKEN_ENCRYPT_VECTOR=${token_encrypt_vector}
+TOKEN_PEPPER=${token_pepper}
+TOKEN_PREFIX=tok_
+TOKEN_BYTE_LENGTH=32" > "$docker_env"
+
+  printf '%s\n' "NEXT_PUBLIC_APP_NAME=${APP_NAME}
+NEXT_PUBLIC_APP_BASE_PATH=/admin
+NEXT_PUBLIC_API_URL=http://localhost:3001
+APP_ENV=dev" > "$app_env"
+
+  printf '%s\n' "APP_ENV=dev
+SITE_URL=http://localhost:3000
+DB_HOST=127.0.0.1
+DB_NAME=${db_name}
+DB_USER=${db_user}
+DB_PASSWORD=${db_password}
+DB_PORT=3306
+REDIS_HOST=127.0.0.1
+REDIS_PORT=6379
+REDIS_TLS=false
+REDIS_TOKEN=
+SESSION_SECRET=${session_secret}
+TOKEN_ENCRYPT_VECTOR=${token_encrypt_vector}
+TOKEN_PEPPER=${token_pepper}
+TOKEN_PREFIX=tok_
+TOKEN_BYTE_LENGTH=32" > "$api_env"
+
+  echo "write .env"
+  echo "write .env.local"
+  echo "write api/.env.local"
+}
+
+write_docker_compose() {
+  write_file "${ROOT_DIR}/docker-compose.yml" "services:
+  app:
+    build:
+      context: .
+      dockerfile: devops/docker/Dockerfile.app
+      target: dev
+    command: npm run dev
+    env_file:
+      - .env
+    ports:
+      - \"3000:3000\"
+    volumes:
+      - .:/app
+      - app_node_modules:/app/node_modules
+    depends_on:
+      - api
+  api:
+    build:
+      context: .
+      dockerfile: devops/docker/Dockerfile.api
+      target: dev
+    command: npm run dev:api
+    env_file:
+      - .env
+    ports:
+      - \"3001:3001\"
+    volumes:
+      - .:/app
+      - api_node_modules:/app/node_modules
+    depends_on:
+      - mysql
+      - redis
+  mysql:
+    image: mysql:8.4
+    env_file:
+      - .env
+    environment:
+      MYSQL_DATABASE: \"\${DB_NAME}\"
+      MYSQL_USER: \"\${DB_USER}\"
+      MYSQL_PASSWORD: \"\${DB_PASSWORD}\"
+      MYSQL_ROOT_PASSWORD: \"\${DB_ROOT_PASSWORD}\"
+    ports:
+      - \"\${DB_PORT}:3306\"
+    volumes:
+      - mysql_data:/var/lib/mysql
+  redis:
+    image: redis:7-alpine
+    ports:
+      - \"\${REDIS_PORT}:6379\"
+    volumes:
+      - redis_data:/data
+
+volumes:
+  app_node_modules:
+  api_node_modules:
+  mysql_data:
+  redis_data:"
+}
+
+write_docker_files() {
+  write_file "${ROOT_DIR}/devops/docker/Dockerfile.app" "FROM node:20-slim AS base
+
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN if [ -f package-lock.json ]; then npm ci; else npm install; fi
+COPY . .
+
+FROM base AS dev
+EXPOSE 3000
+CMD [\"npm\", \"run\", \"dev\"]
+
+FROM base AS builder
+RUN npm run build
+
+FROM node:20-slim AS prod
+ENV NODE_ENV=production
+WORKDIR /app
+COPY --from=builder /app ./
+EXPOSE 3000
+CMD [\"npm\", \"run\", \"start\"]"
+
+  write_file "${ROOT_DIR}/devops/docker/Dockerfile.api" "FROM node:20-slim AS base
+
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN if [ -f package-lock.json ]; then npm ci; else npm install; fi
+COPY api/package.json api/package-lock.json* ./api/
+RUN cd api && if [ -f package-lock.json ]; then npm ci; else npm install; fi
+COPY . .
+
+FROM base AS dev
+EXPOSE 3001
+CMD [\"npm\", \"run\", \"dev:api\"]
+
+FROM base AS builder
+RUN npm run build:api
+
+FROM node:20-slim AS prod
+ENV NODE_ENV=production
+WORKDIR /app
+COPY --from=builder /app ./
+EXPOSE 3001
+CMD [\"npm\", \"run\", \"start:api\"]"
+
+  write_file "${ROOT_DIR}/devops/docker/entrypoint/app-docker-entrypoint.sh" "#!/usr/bin/env sh
+set -e
+exec \"\$@\""
+
+  write_file "${ROOT_DIR}/devops/docker/entrypoint/api-docker-entrypoint.sh" "#!/usr/bin/env sh
+set -e
+exec \"\$@\""
+}
+
+write_cloudformation() {
+  write_file "${ROOT_DIR}/devops/cloudformation/app.yml" "AWSTemplateFormatVersion: '2010-09-09'
+Description: App Studio generated application placeholder stack
+
+Parameters:
+  AppName:
+    Type: String
+    Default: ${APP_NAME}
+  AppImage:
+    Type: String
+    Default: replace-me
+  ApiImage:
+    Type: String
+    Default: replace-me
+
+Resources:
+  AppStudioPlaceholder:
+    Type: AWS::CloudFormation::WaitConditionHandle
+
+Outputs:
+  AppName:
+    Value: !Ref AppName
+  AppImage:
+    Value: !Ref AppImage
+  ApiImage:
+    Value: !Ref ApiImage"
+}
+
+write_product_pipeline() {
+  write_file "${ROOT_DIR}/bitbucket-pipelines.yml" "image: atlassian/default-image:5
+
+definitions:
+  services:
+    docker:
+      memory: 3072
+  steps:
+    - step: &build-images
+        name: Build Docker images
+        caches:
+          - docker
+        services:
+          - docker
+        script:
+          - export DOCKER_BUILDKIT=0
+          - docker build --tag \"\$DOCKER_REPO-app:pull-request\" --file ./devops/docker/Dockerfile.app --target prod .
+          - docker build --tag \"\$DOCKER_REPO-api:pull-request\" --file ./devops/docker/Dockerfile.api --target prod .
+    - step: &publish-images
+        name: Publish Docker images
+        caches:
+          - docker
+        services:
+          - docker
+        script:
+          - test -n \"\$DOCKER_REPO\"
+          - test -n \"\$DOCKER_HUB_USER\"
+          - test -n \"\$DOCKER_HUB_PASSWORD\"
+          - export VERSION=\"\${BITBUCKET_TAG#v}\"
+          - echo \"\$DOCKER_HUB_PASSWORD\" | docker login -u \"\$DOCKER_HUB_USER\" --password-stdin
+          - docker build --tag \"\$DOCKER_REPO-app:\$VERSION\" --tag \"\$DOCKER_REPO-app:latest\" --file ./devops/docker/Dockerfile.app --target prod .
+          - docker build --tag \"\$DOCKER_REPO-api:\$VERSION\" --tag \"\$DOCKER_REPO-api:latest\" --file ./devops/docker/Dockerfile.api --target prod .
+          - docker push \"\$DOCKER_REPO-app:\$VERSION\"
+          - docker push \"\$DOCKER_REPO-app:latest\"
+          - docker push \"\$DOCKER_REPO-api:\$VERSION\"
+          - docker push \"\$DOCKER_REPO-api:latest\"
+    - step: &deploy-cloudformation
+        name: Deploy CloudFormation
+        image:
+          name: amazon/aws-cli:2.15.57
+          entrypoint: [\"\"]
+        script:
+          - test -n \"\$APP_STACK_NAME\"
+          - test -n \"\$DOCKER_REPO\"
+          - export VERSION=\"\${BITBUCKET_TAG#v}\"
+          - aws cloudformation deploy --stack-name \"\$APP_STACK_NAME\" --template-file devops/cloudformation/app.yml --capabilities CAPABILITY_NAMED_IAM --parameter-overrides AppName=${APP_NAME} AppImage=\"\$DOCKER_REPO-app:\$VERSION\" ApiImage=\"\$DOCKER_REPO-api:\$VERSION\"
+
+pipelines:
+  pull-requests:
+    '**':
+      - step: *build-images
+  tags:
+    v*:
+      - step: *publish-images
+      - step: *deploy-cloudformation"
+}
+
+write_schema() {
+  write_file "$SCHEMA_FILE" "{
+  \"schemaVersion\": 1,
+  \"app\": {
+    \"name\": \"${APP_NAME}\",
+    \"title\": \"${APP_NAME}\",
+    \"basePath\": \"/admin\"
+  },
+  \"packages\": {
+    \"ui\": \"${UI_PACKAGE}\",
+    \"api\": \"${API_PACKAGE}\",
+    \"cli\": \"${CLI_BIN}\"
+  },
+  \"core\": {
+    \"api\": true,
+    \"ui\": true,
+    \"domains\": [
+      \"auth\",
+      \"users\",
+      \"orgs\",
+      \"projects\",
+      \"providers\",
+      \"billing\",
+      \"admin\"
+    ]
+  },
+  \"modules\": [],
+  \"resources\": []
+}"
+}
+
+write_skeleton() {
+  ensure_dir "${ROOT_DIR}/src"
+  ensure_dir "${ROOT_DIR}/api"
+  ensure_dir "${ROOT_DIR}/modules"
+  write_file "${ROOT_DIR}/src/.gitkeep" ""
+  write_file "${ROOT_DIR}/api/.gitkeep" ""
+  write_file "${ROOT_DIR}/modules/.gitkeep" ""
+}
+
+write_deployment_skeleton() {
+  write_docker_compose
+  write_docker_files
+  write_cloudformation
+  write_product_pipeline
+}
+
+init_app() {
+  parse_name_and_force "$@"
+
+  write_package_json
+  write_gitignore
+  write_env_example
+  write_runtime_env
+  write_schema
+  write_skeleton
+  write_deployment_skeleton
+
+  echo ""
+  echo "Base app skeleton ready."
+  echo "Next: edit ${SCHEMA_FILE#"$ROOT_DIR"/}, then run ./app.sh install and ./app.sh generate."
+}
+
+schema() {
+  parse_name_and_force "$@"
+  write_schema
+}
+
+edit_schema() {
+  if [[ ! -f "$SCHEMA_FILE" ]]; then
+    FORCE="false"
+    APP_NAME="$(default_app_name)"
+    write_schema
+  fi
+
+  local editor="${EDITOR:-}"
+
+  if [[ -z "$editor" ]]; then
+    echo "No EDITOR is set. Edit ${SCHEMA_FILE#"$ROOT_DIR"/} manually."
+    return
+  fi
+
+  "$editor" "$SCHEMA_FILE"
+}
+
+install_packages() {
+  require_command npm
+
+  cd "$ROOT_DIR"
+
+  if [[ ! -f package.json ]]; then
+    FORCE="false"
+    APP_NAME="$(default_app_name)"
+    write_package_json
+  fi
+
+  if maybe_link_packages; then
+    return
+  fi
+
+  echo "install ${UI_PACKAGE}"
+  npm install "$UI_PACKAGE"
+
+  echo "install ${API_PACKAGE}"
+  npm install "$API_PACKAGE"
+}
+
+is_package_checkout() {
+  local candidate_path="${1:-}"
+  local package_name="${2:-}"
+
+  [[ -f "${candidate_path}/package.json" ]] || return 1
+  grep -q "\"name\"[[:space:]]*:[[:space:]]*\"${package_name}\"" "${candidate_path}/package.json"
+}
+
+resolve_ui_path() {
+  local requested_path="${1:-${UI_PATH}}"
+
+  if [[ -n "$requested_path" ]]; then
+    (cd "$requested_path" && pwd)
+    return
+  fi
+
+  local candidate
+  for candidate in "${ROOT_DIR}/../appstudio" "${ROOT_DIR}/../osirax" "${ROOT_DIR}/../spacemade-ui" "${ROOT_DIR}/../ui" "${ROOT_DIR}"; do
+    if is_package_checkout "$candidate" "@spacemade/ui"; then
+      (cd "$candidate" && pwd)
+      return
+    fi
+  done
+
+  return 1
+}
+
+resolve_api_path() {
+  local requested_path="${1:-${API_PATH}}"
+
+  if [[ -n "$requested_path" ]]; then
+    (cd "$requested_path" && pwd)
+    return
+  fi
+
+  local ui_path
+  if ui_path="$(resolve_ui_path "")"; then
+    if is_package_checkout "${ui_path}/api" "@spacemade/api"; then
+      (cd "${ui_path}/api" && pwd)
+      return
+    fi
+  fi
+
+  local candidate
+  for candidate in "${ROOT_DIR}/../appstudio/api" "${ROOT_DIR}/../osirax/api" "${ROOT_DIR}/../spacemade-api" "${ROOT_DIR}/../api"; do
+    if is_package_checkout "$candidate" "@spacemade/api"; then
+      (cd "$candidate" && pwd)
+      return
+    fi
+  done
+
+  return 1
+}
+
+link_package() {
+  local package_name="${1:-}"
+  local package_path="${2:-}"
+  local package_leaf="${package_name##*/}"
+
+  is_package_checkout "$package_path" "$package_name" || die "${package_path} is not a ${package_name} checkout"
+
+  local scope_dir="${ROOT_DIR}/node_modules/@spacemade"
+  local link_path="${scope_dir}/${package_leaf}"
+
+  mkdir -p "$scope_dir"
+
+  if [[ -L "$link_path" ]]; then
+    rm "$link_path"
+  elif [[ -e "$link_path" ]]; then
+    die "${link_path} already exists and is not a symlink"
+  fi
+
+  ln -s "$package_path" "$link_path"
+  echo "linked ${link_path#"$ROOT_DIR"/} -> ${package_path}"
+}
+
+link_cli_bin() {
+  local bin_dir="${ROOT_DIR}/node_modules/.bin"
+  local bin_path="${bin_dir}/${CLI_BIN}"
+
+  mkdir -p "$bin_dir"
+
+  if [[ -L "$bin_path" ]]; then
+    rm "$bin_path"
+  elif [[ -e "$bin_path" ]]; then
+    die "${bin_path} already exists and is not a symlink"
+  fi
+
+  ln -s "../@spacemade/ui/scripts/spacemade.mjs" "$bin_path"
+}
+
+link_api_dependencies() {
+  local api_path="${1:-}"
+  local source_node_modules="${api_path}/node_modules"
+  local app_api_dir="${ROOT_DIR}/api"
+  local app_api_node_modules="${app_api_dir}/node_modules"
+
+  if [[ ! -d "$source_node_modules" ]]; then
+    return
+  fi
+
+  mkdir -p "$app_api_dir"
+
+  if [[ -L "$app_api_node_modules" ]]; then
+    rm "$app_api_node_modules"
+  elif [[ -e "$app_api_node_modules" ]]; then
+    return
+  fi
+
+  ln -s "$source_node_modules" "$app_api_node_modules"
+  echo "linked ${app_api_node_modules#"$ROOT_DIR"/} -> ${source_node_modules}"
+}
+
+link_core() {
+  local requested_ui_path="${1:-}"
+  local ui_path
+  local api_path
+  local legacy_core_path="${ROOT_DIR}/node_modules/@spacemade/core"
+
+  ui_path="$(resolve_ui_path "$requested_ui_path")" || die "Missing local UI path. Example: SPACEMADE_UI_PATH=../appstudio ./app.sh install"
+  if [[ -z "$API_PATH" && -d "${ui_path}/api" && -f "${ui_path}/api/package.json" ]]; then
+    api_path="$(cd "${ui_path}/api" && pwd)"
+  else
+    api_path="$(resolve_api_path "")" || die "Missing local API path. Example: SPACEMADE_API_PATH=../appstudio/api ./app.sh install"
+  fi
+
+  link_package "@spacemade/ui" "$ui_path"
+  link_package "@spacemade/api" "$api_path"
+  link_cli_bin
+  link_api_dependencies "$api_path"
+
+  if [[ -L "$legacy_core_path" ]]; then
+    rm "$legacy_core_path"
+    echo "removed legacy ${legacy_core_path#"$ROOT_DIR"/}"
+  fi
+}
+
+maybe_link_packages() {
+  if [[ -n "$UI_PATH" || -n "$API_PATH" ]]; then
+    link_core "$UI_PATH"
+    return 0
+  fi
+
+  if [[ -d "${ROOT_DIR}/node_modules/@spacemade/ui" && -d "${ROOT_DIR}/node_modules/@spacemade/api" ]]; then
+    return 0
+  fi
+
+  local detected_ui_path
+  if detected_ui_path="$(resolve_ui_path "")"; then
+    link_core "$detected_ui_path"
+    return 0
+  fi
+
+  return 1
+}
+
+install_generated_api_dependencies() {
+  if [[ ! -f "${ROOT_DIR}/api/package.json" || -d "${ROOT_DIR}/api/node_modules" ]]; then
+    return
+  fi
+
+  echo "install generated API dependencies"
+  (cd "${ROOT_DIR}/api" && npm install)
+}
+
+generate_app() {
+  require_command npm
+
+  local force_arg=""
+  local schema_path="$SCHEMA_FILE"
+
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --force)
+        force_arg="--force"
+        shift
+        ;;
+      *)
+        schema_path="$1"
+        shift
+        ;;
+    esac
+  done
+
+  [[ -f "$schema_path" ]] || die "Schema not found: $schema_path"
+
+  cd "$ROOT_DIR"
+  maybe_link_packages || die "Spacemade packages are not installed. Run ./app.sh install before generation."
+
+  if [[ -n "$force_arg" ]]; then
+    npx "$CLI_BIN" generate "$schema_path" "$force_arg"
+  else
+    npx "$CLI_BIN" generate "$schema_path"
+  fi
+
+  install_generated_api_dependencies
+}
+
+bootstrap() {
+  init_app "$@"
+  install_packages
+  generate_app
+}
+
+doctor() {
+  echo "root: ${ROOT_DIR}"
+  echo "schema: ${SCHEMA_FILE}"
+  echo "ui package: ${UI_PACKAGE}"
+  echo "api package: ${API_PACKAGE}"
+  echo "cli: ${CLI_BIN}"
+  echo ""
+
+  if has_command node; then
+    echo "node: $(node --version)"
+  else
+    echo "node: missing"
+  fi
+
+  if has_command npm; then
+    echo "npm: $(npm --version)"
+  else
+    echo "npm: missing"
+  fi
+
+  [[ -f "${ROOT_DIR}/package.json" ]] && echo "package.json: found" || echo "package.json: missing"
+  [[ -f "$SCHEMA_FILE" ]] && echo "schema: found" || echo "schema: missing"
+}
+
+main() {
+  local command_name="${1:-help}"
+  shift || true
+
+  case "$command_name" in
+    init) init_app "$@" ;;
+    schema) schema "$@" ;;
+    edit-schema) edit_schema ;;
+    install) install_packages ;;
+    link-core) link_core "$@" ;;
+    generate) generate_app "$@" ;;
+    bootstrap) bootstrap "$@" ;;
+    doctor) doctor ;;
+    help|-h|--help) usage ;;
+    *)
+      echo "Unknown command: $command_name" >&2
+      usage
+      exit 1
+      ;;
+  esac
+}
+
+main "$@"