qualia-framework 2.1.0

package/framework/skills/deploy-verify/scripts/canary-check.sh

@@ -0,0 +1,206 @@
+#!/bin/bash
+# canary-check.sh — Post-deploy canary health check
+# Compares live metrics against stored baseline, flags regressions
+# after 2 consecutive failures.
+#
+# Usage: canary-check.sh <URL> [--project-dir /path] [--update-baseline]
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# ─── Parse args ──────────────────────────────────────────────
+URL=""
+PROJECT_DIR=""
+UPDATE_BASELINE=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --project-dir) PROJECT_DIR="$2"; shift 2 ;;
+    --update-baseline) UPDATE_BASELINE=true; shift ;;
+    -*) echo "Unknown option: $1"; exit 1 ;;
+    *) URL="${1%/}"; shift ;;
+  esac
+done
+
+if [[ -z "$URL" ]]; then
+  echo '{"status":"FAIL","detail":"No URL provided"}'
+  exit 1
+fi
+
+PROJECT_DIR="${PROJECT_DIR:-$(pwd)}"
+BASELINE_FILE="$PROJECT_DIR/.planning/canary-baseline.json"
+
+# Failure tracking file keyed by URL hash
+URL_HASH=$(echo -n "$URL" | md5sum | cut -d' ' -f1)
+FAILURE_FILE="/tmp/.canary-failures-${URL_HASH}"
+
+# ─── Colors ──────────────────────────────────────────────────
+C_RESET="\033[0m"
+C_GREEN="\033[32m"
+C_YELLOW="\033[33m"
+C_RED="\033[31m"
+C_BOLD="\033[1m"
+C_DIM="\033[2m"
+
+# ─── Collect current metrics ────────────────────────────────
+# Metric 1: HTTP status
+CURRENT_HTTP=$(curl -sL -o /dev/null -w "%{http_code}" --max-time 15 "$URL" 2>/dev/null || echo "000")
+
+# Metric 2: Page load time (median of 3 measurements, in ms)
+LOAD_TIMES=()
+for i in 1 2 3; do
+  t=$(curl -sL -o /dev/null -w "%{time_total}" --max-time 15 "$URL" 2>/dev/null || echo "99")
+  ms=$(echo "$t * 1000" | bc 2>/dev/null | cut -d. -f1)
+  LOAD_TIMES+=("${ms:-9999}")
+done
+IFS=$'\n' SORTED_TIMES=($(sort -n <<<"${LOAD_TIMES[*]}")); unset IFS
+CURRENT_LOAD_MS=${SORTED_TIMES[1]}
+
+# Metric 3: Console error count (reuse existing check-console-errors.js)
+CONSOLE_RESULT=$(node "$SCRIPT_DIR/check-console-errors.js" "$URL" 2>/dev/null || echo '{"status":"SKIP","errors":[]}')
+CURRENT_CONSOLE_ERRORS=$(echo "$CONSOLE_RESULT" | jq '.errors | length' 2>/dev/null || echo "0")
+
+# ─── Update baseline mode ───────────────────────────────────
+if $UPDATE_BASELINE; then
+  mkdir -p "$(dirname "$BASELINE_FILE")"
+  cat > "$BASELINE_FILE" <<BEOF
+{
+  "url": "$URL",
+  "captured_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "http_status": $CURRENT_HTTP,
+  "console_error_count": $CURRENT_CONSOLE_ERRORS,
+  "load_time_ms": $CURRENT_LOAD_MS,
+  "consecutive_failures": 0
+}
+BEOF
+  echo -e "${C_GREEN}Canary baseline saved to $BASELINE_FILE${C_RESET}"
+  echo -e "  HTTP: $CURRENT_HTTP | Load: ${CURRENT_LOAD_MS}ms | Console errors: $CURRENT_CONSOLE_ERRORS"
+  # Reset failure counter
+  rm -f "$FAILURE_FILE"
+  exit 0
+fi
+
+# ─── Load baseline ──────────────────────────────────────────
+if [[ ! -f "$BASELINE_FILE" ]]; then
+  echo -e "${C_YELLOW}No canary baseline found at $BASELINE_FILE${C_RESET}"
+  echo -e "${C_YELLOW}Creating initial baseline from current metrics...${C_RESET}"
+  # Auto-create baseline on first run
+  mkdir -p "$(dirname "$BASELINE_FILE")"
+  cat > "$BASELINE_FILE" <<BEOF
+{
+  "url": "$URL",
+  "captured_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "http_status": $CURRENT_HTTP,
+  "console_error_count": $CURRENT_CONSOLE_ERRORS,
+  "load_time_ms": $CURRENT_LOAD_MS,
+  "consecutive_failures": 0
+}
+BEOF
+  echo -e "${C_GREEN}Baseline created. Next canary run will compare against this.${C_RESET}"
+  rm -f "$FAILURE_FILE"
+  exit 0
+fi
+
+BASELINE_HTTP=$(jq -r '.http_status' "$BASELINE_FILE")
+BASELINE_CONSOLE=$(jq -r '.console_error_count' "$BASELINE_FILE")
+BASELINE_LOAD=$(jq -r '.load_time_ms' "$BASELINE_FILE")
+
+# ─── Compare against baseline (relative thresholds) ─────────
+REGRESSIONS=()
+LOAD_THRESHOLD=$((BASELINE_LOAD * 2))
+
+# Check 1: HTTP status mismatch
+if [[ "$CURRENT_HTTP" != "$BASELINE_HTTP" ]]; then
+  REGRESSIONS+=("HTTP status: baseline=${BASELINE_HTTP}, current=${CURRENT_HTTP}")
+fi
+
+# Check 2: Console errors increased (any new errors vs baseline count)
+if [[ "$CURRENT_CONSOLE_ERRORS" -gt "$BASELINE_CONSOLE" ]]; then
+  NEW_ERRORS=$((CURRENT_CONSOLE_ERRORS - BASELINE_CONSOLE))
+  REGRESSIONS+=("Console errors: baseline=${BASELINE_CONSOLE}, current=${CURRENT_CONSOLE_ERRORS} (+${NEW_ERRORS} new)")
+fi
+
+# Check 3: Load time exceeds 2x baseline
+if [[ "$CURRENT_LOAD_MS" -gt "$LOAD_THRESHOLD" ]]; then
+  REGRESSIONS+=("Load time: baseline=${BASELINE_LOAD}ms, current=${CURRENT_LOAD_MS}ms (threshold: ${LOAD_THRESHOLD}ms)")
+fi
+
+# ─── Consecutive failure tracking ────────────────────────────
+PREV_FAILURES=0
+if [[ -f "$FAILURE_FILE" ]]; then
+  PREV_FAILURES=$(cat "$FAILURE_FILE" 2>/dev/null || echo "0")
+fi
+
+# ─── Output ──────────────────────────────────────────────────
+echo ""
+echo -e "${C_BOLD}──────────────────────────────────────────────────────${C_RESET}"
+echo -e "  ${C_BOLD}CANARY CHECK${C_RESET} — T+2min post-deploy"
+echo -e "  URL: ${URL}"
+echo -e "  Baseline: $(jq -r '.captured_at' "$BASELINE_FILE")"
+echo -e "${C_BOLD}──────────────────────────────────────────────────────${C_RESET}"
+echo ""
+
+# Metric comparison table
+printf "  %-20s %-12s %-12s %-12s\n" "Metric" "Baseline" "Current" "Status"
+printf "  %-20s %-12s %-12s %-12s\n" "────────────────────" "────────────" "────────────" "────────────"
+
+# HTTP row
+if [[ "$CURRENT_HTTP" == "$BASELINE_HTTP" ]]; then
+  printf "  %-20s %-12s %-12s ${C_GREEN}%-12s${C_RESET}\n" "HTTP Status" "$BASELINE_HTTP" "$CURRENT_HTTP" "OK"
+else
+  printf "  %-20s %-12s %-12s ${C_RED}%-12s${C_RESET}\n" "HTTP Status" "$BASELINE_HTTP" "$CURRENT_HTTP" "REGRESSION"
+fi
+
+# Console errors row
+if [[ "$CURRENT_CONSOLE_ERRORS" -le "$BASELINE_CONSOLE" ]]; then
+  printf "  %-20s %-12s %-12s ${C_GREEN}%-12s${C_RESET}\n" "Console Errors" "$BASELINE_CONSOLE" "$CURRENT_CONSOLE_ERRORS" "OK"
+else
+  printf "  %-20s %-12s %-12s ${C_RED}%-12s${C_RESET}\n" "Console Errors" "$BASELINE_CONSOLE" "$CURRENT_CONSOLE_ERRORS" "REGRESSION"
+fi
+
+# Load time row
+if [[ "$CURRENT_LOAD_MS" -le "$LOAD_THRESHOLD" ]]; then
+  printf "  %-20s %-12s %-12s ${C_GREEN}%-12s${C_RESET}\n" "Load Time (ms)" "$BASELINE_LOAD" "$CURRENT_LOAD_MS" "OK (<${LOAD_THRESHOLD}ms)"
+else
+  printf "  %-20s %-12s %-12s ${C_RED}%-12s${C_RESET}\n" "Load Time (ms)" "$BASELINE_LOAD" "$CURRENT_LOAD_MS" "REGRESSION (>${LOAD_THRESHOLD}ms)"
+fi
+
+echo ""
+
+if [[ ${#REGRESSIONS[@]} -eq 0 ]]; then
+  # All good — reset failure counter
+  echo "0" > "$FAILURE_FILE"
+  echo -e "  ${C_GREEN}CANARY PASS${C_RESET} — All metrics within baseline thresholds"
+  echo ""
+  exit 0
+fi
+
+# Regressions detected — increment failure counter
+CONSECUTIVE=$((PREV_FAILURES + 1))
+echo "$CONSECUTIVE" > "$FAILURE_FILE"
+
+if [[ "$CONSECUTIVE" -ge 2 ]]; then
+  # 2+ consecutive failures — FLAG REGRESSION
+  echo -e "  ${C_RED}${C_BOLD}CANARY ALERT — REGRESSION DETECTED${C_RESET}"
+  echo -e "  ${C_RED}Consecutive failures: ${CONSECUTIVE}${C_RESET}"
+  echo ""
+  for reg in "${REGRESSIONS[@]}"; do
+    echo -e "  ${C_RED}  - ${reg}${C_RESET}"
+  done
+  echo ""
+  echo -e "  ${C_DIM}Action: Investigate regressions. If false alarm, update baseline:${C_RESET}"
+  echo -e "  ${C_DIM}  bash $SCRIPT_DIR/canary-check.sh $URL --update-baseline${C_RESET}"
+  echo ""
+  exit 1
+else
+  # First failure — note but do NOT alert
+  echo -e "  ${C_YELLOW}CANARY WARN — Regression detected (1st occurrence, not alerting)${C_RESET}"
+  echo -e "  ${C_YELLOW}Will alert if next canary also fails.${C_RESET}"
+  echo ""
+  for reg in "${REGRESSIONS[@]}"; do
+    echo -e "  ${C_YELLOW}  - ${reg}${C_RESET}"
+  done
+  echo ""
+  exit 0
+fi

package/framework/skills/deploy-verify/scripts/check-console-errors.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+// check-console-errors.js — Detect client-side JS errors via Playwright headless browser
+// Usage: node check-console-errors.js <URL>
+// Output: JSON { "status": "PASS|WARN|FAIL", "errors": [...], "detail": "..." }
+
+const url = process.argv[2];
+if (!url) {
+  console.log(JSON.stringify({ status: "FAIL", errors: [], detail: "No URL provided" }));
+  process.exit(1);
+}
+
+// Known benign error patterns (third-party, browser extensions, etc.)
+const BENIGN_PATTERNS = [
+  /third.?party/i,
+  /gtag/i,
+  /analytics/i,
+  /fbq/i,
+  /hotjar/i,
+  /intercom/i,
+  /clarity/i,
+  /sentry/i,
+  /Failed to load resource.*favicon/i,
+  /ERR_BLOCKED_BY_CLIENT/i, // ad blockers
+  /net::ERR_FAILED.*chrome-extension/i,
+  /ResizeObserver loop/i,
+  /Loading chunk.*failed/i, // sometimes transient
+];
+
+// Critical error patterns — these always mean FAIL
+const CRITICAL_PATTERNS = [
+  /TypeError/,
+  /ReferenceError/,
+  /SyntaxError/,
+  /ChunkLoadError/,
+  /Unhandled/i,
+  /NEXT_/,
+  /Internal Server Error/i,
+  /500/,
+  /Cannot read propert/i,
+  /is not defined/i,
+  /is not a function/i,
+  /Hydration/i,
+];
+
+async function run() {
+  let chromium;
+  try {
+    // Try to import playwright
+    const pw = require('playwright');
+    chromium = pw.chromium;
+  } catch {
+    try {
+      const pw = require('playwright-core');
+      chromium = pw.chromium;
+    } catch {
+      console.log(JSON.stringify({
+        status: "SKIP",
+        errors: [],
+        detail: "Playwright not available — install with: npm i -g playwright"
+      }));
+      process.exit(0);
+    }
+  }
+
+  const errors = [];
+  const warnings = [];
+  let browser;
+
+  try {
+    browser = await chromium.launch({
+      headless: true,
+      args: ['--no-sandbox', '--disable-setuid-sandbox'],
+    });
+    const page = await browser.newPage();
+
+    // Collect console errors
+    page.on('console', msg => {
+      if (msg.type() === 'error') {
+        errors.push(msg.text());
+      }
+    });
+
+    // Collect page-level errors (uncaught exceptions)
+    page.on('pageerror', err => {
+      errors.push(err.message || String(err));
+    });
+
+    // Navigate with timeout
+    await page.goto(url, {
+      waitUntil: 'networkidle',
+      timeout: 30000,
+    });
+
+    // Give a brief extra moment for any late errors
+    await page.waitForTimeout(2000);
+
+    await browser.close();
+    browser = null;
+
+    // Classify errors
+    const criticalErrors = [];
+    const benignErrors = [];
+
+    for (const err of errors) {
+      const isBenign = BENIGN_PATTERNS.some(p => p.test(err));
+      const isCritical = CRITICAL_PATTERNS.some(p => p.test(err));
+
+      if (isCritical && !isBenign) {
+        criticalErrors.push(err);
+      } else {
+        benignErrors.push(err);
+      }
+    }
+
+    if (criticalErrors.length > 0) {
+      console.log(JSON.stringify({
+        status: "FAIL",
+        errors: criticalErrors,
+        benign: benignErrors.length,
+        detail: `${criticalErrors.length} critical error(s): ${criticalErrors[0].substring(0, 120)}`,
+      }));
+    } else if (benignErrors.length > 0) {
+      console.log(JSON.stringify({
+        status: "WARN",
+        errors: benignErrors,
+        benign: benignErrors.length,
+        detail: `${benignErrors.length} non-critical error(s) (third-party/benign)`,
+      }));
+    } else {
+      console.log(JSON.stringify({
+        status: "PASS",
+        errors: [],
+        detail: "No console errors detected",
+      }));
+    }
+  } catch (err) {
+    if (browser) await browser.close().catch(() => {});
+    console.log(JSON.stringify({
+      status: "FAIL",
+      errors: [err.message],
+      detail: `Browser check failed: ${err.message.substring(0, 120)}`,
+    }));
+    process.exit(1);
+  }
+}
+
+run();

package/framework/skills/deploy-verify/scripts/check-cwv.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+// check-cwv.js — Core Web Vitals via Google PageSpeed Insights API
+// Usage: node check-cwv.js <URL>
+// Output: JSON { "status": "PASS|WARN|FAIL|SKIP", "metrics": {...}, "detail": "..." }
+//
+// Thresholds (Google standards):
+//   LCP: < 2.5s PASS, 2.5-4s WARN, > 4s FAIL
+//   CLS: < 0.1 PASS, 0.1-0.25 WARN, > 0.25 FAIL
+//   INP: < 200ms PASS, 200-500ms WARN, > 500ms FAIL
+
+const url = process.argv[2];
+if (!url) {
+  console.log(JSON.stringify({ status: "FAIL", metrics: {}, detail: "No URL provided" }));
+  process.exit(1);
+}
+
+const THRESHOLDS = {
+  LCP: { good: 2500, poor: 4000, unit: "ms", label: "Largest Contentful Paint" },
+  CLS: { good: 0.1, poor: 0.25, unit: "", label: "Cumulative Layout Shift" },
+  INP: { good: 200, poor: 500, unit: "ms", label: "Interaction to Next Paint" },
+};
+
+function classify(metric, value) {
+  const t = THRESHOLDS[metric];
+  if (value <= t.good) return "PASS";
+  if (value <= t.poor) return "WARN";
+  return "FAIL";
+}
+
+function formatValue(metric, value) {
+  const t = THRESHOLDS[metric];
+  if (metric === "CLS") return value.toFixed(2);
+  if (metric === "LCP") return `${(value / 1000).toFixed(1)}s`;
+  return `${Math.round(value)}${t.unit}`;
+}
+
+async function run() {
+  const apiUrl = `https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=${encodeURIComponent(url)}&strategy=mobile&category=performance`;
+
+  try {
+    const response = await fetch(apiUrl, { signal: AbortSignal.timeout(60000) });
+
+    if (!response.ok) {
+      console.log(JSON.stringify({
+        status: "SKIP",
+        metrics: {},
+        detail: `PageSpeed API returned ${response.status} — skipping CWV check`,
+      }));
+      process.exit(0);
+    }
+
+    const data = await response.json();
+
+    // Extract metrics from field data (CrUX) first, fall back to lab data
+    const metrics = {};
+    let worstStatus = "PASS";
+
+    // Try CrUX (field) data first — more representative of real users
+    const fieldMetrics = data.loadingExperience?.metrics || {};
+
+    // LCP
+    if (fieldMetrics.LARGEST_CONTENTFUL_PAINT_MS) {
+      metrics.LCP = fieldMetrics.LARGEST_CONTENTFUL_PAINT_MS.percentile;
+    } else {
+      // Fall back to Lighthouse lab data
+      const lcpAudit = data.lighthouseResult?.audits?.['largest-contentful-paint'];
+      if (lcpAudit) metrics.LCP = lcpAudit.numericValue;
+    }
+
+    // CLS
+    if (fieldMetrics.CUMULATIVE_LAYOUT_SHIFT_SCORE) {
+      metrics.CLS = fieldMetrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.percentile / 100;
+    } else {
+      const clsAudit = data.lighthouseResult?.audits?.['cumulative-layout-shift'];
+      if (clsAudit) metrics.CLS = clsAudit.numericValue;
+    }
+
+    // INP
+    if (fieldMetrics.INTERACTION_TO_NEXT_PAINT) {
+      metrics.INP = fieldMetrics.INTERACTION_TO_NEXT_PAINT.percentile;
+    } else if (fieldMetrics.EXPERIMENTAL_INTERACTION_TO_NEXT_PAINT) {
+      metrics.INP = fieldMetrics.EXPERIMENTAL_INTERACTION_TO_NEXT_PAINT.percentile;
+    }
+    // INP has no Lighthouse lab equivalent — skip if no field data
+
+    // Build result
+    const results = {};
+    const parts = [];
+
+    for (const [metric, value] of Object.entries(metrics)) {
+      const status = classify(metric, value);
+      const formatted = formatValue(metric, value);
+      const icon = status === "PASS" ? "✓" : status === "WARN" ? "⚠" : "✗";
+      results[metric] = { value, formatted, status };
+      parts.push(`${metric}: ${formatted} ${icon}`);
+
+      // Track worst status
+      if (status === "FAIL") worstStatus = "FAIL";
+      else if (status === "WARN" && worstStatus !== "FAIL") worstStatus = "WARN";
+    }
+
+    if (Object.keys(metrics).length === 0) {
+      console.log(JSON.stringify({
+        status: "SKIP",
+        metrics: {},
+        detail: "No CWV data available (site may lack sufficient traffic for CrUX data)",
+      }));
+    } else {
+      // Also include overall performance score
+      const perfScore = data.lighthouseResult?.categories?.performance?.score;
+      if (perfScore !== undefined) {
+        results.performanceScore = Math.round(perfScore * 100);
+        parts.push(`Score: ${results.performanceScore}`);
+      }
+
+      console.log(JSON.stringify({
+        status: worstStatus,
+        metrics: results,
+        detail: parts.join("  "),
+      }));
+    }
+  } catch (err) {
+    if (err.name === 'TimeoutError' || err.code === 'ABORT_ERR') {
+      console.log(JSON.stringify({
+        status: "SKIP",
+        metrics: {},
+        detail: "PageSpeed API timed out (60s) — skipping CWV check",
+      }));
+    } else {
+      console.log(JSON.stringify({
+        status: "SKIP",
+        metrics: {},
+        detail: `PageSpeed API error: ${err.message?.substring(0, 100)}`,
+      }));
+    }
+  }
+}
+
+run();

package/framework/skills/deploy-verify/scripts/project-detect.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# project-detect.sh — Auto-detect project from current directory
+# Returns JSON: {"name":"...","supabase_ref":"...","hosting":"..."}
+#
+# Usage: source project-detect.sh  (sets PROJECT_NAME, SUPABASE_REF, HOSTING)
+#    or: bash project-detect.sh     (prints JSON)
+
+CONTEXT_FILE="$HOME/.claude/knowledge/qualia-context.md"
+CWD="${1:-$(pwd)}"
+DIR_NAME=$(basename "$CWD")
+
+# Normalize common directory structures
+# ~/Projects/Live-Projects/vero → vero
+# ~/Projects/aiagents/sofiatesting → sofiatesting
+# ~/Projects/voice/under → under
+# ~/Projects/websites/qualia → qualia (ERP)
+PROJECT_NAME="$DIR_NAME"
+
+# Known project → Supabase ref mapping (from qualia-context.md)
+declare -A SUPABASE_REFS=(
+  ["aquador"]="hznpuxplqgszbacxzbhv"
+  ["maud"]="vspyxscitcuwnrhchskl"
+  ["vero"]="zskfdlqyzhkzefafqkpx"
+  ["aibossbrainz"]="esymbjpzjjkffpfqukxw"
+  ["mpm"]="llherorsfgbdyqkrrlpc"
+  ["Zaid"]="uoqiwidqlsoamtugioik"
+  ["dababneh"]="toovladeybmlyzblqtbl"
+  ["faris"]="lrgwxcqqnhxvvrruepcv"
+  ["Hammah"]="ctcikdcjhxxqogwvtzrc"
+  ["sofiatesting"]="vceeheaxcrhmpqueudqx"
+  ["timo"]="qgaqvkmqterlljbegniu"
+  ["under"]="vvppyijxpgeeijiozlve"
+)
+
+# Known project → hosting mapping
+declare -A HOSTING_MAP=(
+  ["armenius"]="cloudflare"
+)
+
+SUPABASE_REF="${SUPABASE_REFS[$PROJECT_NAME]:-}"
+HOSTING="${HOSTING_MAP[$PROJECT_NAME]:-vercel}"
+
+# Also try to read from .env.local if no hardcoded ref
+if [[ -z "$SUPABASE_REF" ]]; then
+  for env_file in "$CWD/.env.local" "$CWD/.env"; do
+    if [[ -f "$env_file" ]]; then
+      # Extract ref from NEXT_PUBLIC_SUPABASE_URL=https://XXX.supabase.co
+      ref=$(grep -oP 'NEXT_PUBLIC_SUPABASE_URL=https://\K[^.]+' "$env_file" 2>/dev/null)
+      if [[ -n "$ref" ]]; then
+        SUPABASE_REF="$ref"
+        break
+      fi
+    fi
+  done
+fi
+
+# Detect external dependencies from env files
+DEPS=""
+for env_file in "$CWD/.env.local" "$CWD/.env"; do
+  if [[ -f "$env_file" ]]; then
+    # Read variable names only (not values) — security safe
+    grep -oP '^[A-Z_]+(?==)' "$env_file" 2>/dev/null | while read -r var; do
+      case "$var" in
+        VAPI_*|NEXT_PUBLIC_VAPI_*) echo "vapi" ;;
+        OPENROUTER_*) echo "openrouter" ;;
+        ELEVEN_LABS_*|ELEVENLABS_*) echo "elevenlabs" ;;
+        RETELL_*) echo "retell" ;;
+        STRIPE_*|NEXT_PUBLIC_STRIPE_*) echo "stripe" ;;
+        TELNYX_*) echo "telnyx" ;;
+      esac
+    done | sort -u
+    break
+  fi
+done > /tmp/deploy-verify-deps 2>/dev/null
+DEPS=$(cat /tmp/deploy-verify-deps 2>/dev/null | tr '\n' ',' | sed 's/,$//')
+rm -f /tmp/deploy-verify-deps
+
+# If sourced, export variables
+if [[ "${BASH_SOURCE[0]}" != "${0}" ]]; then
+  export PROJECT_NAME SUPABASE_REF HOSTING DEPS
+else
+  # If run directly, print JSON
+  echo "{\"name\":\"$PROJECT_NAME\",\"supabase_ref\":\"$SUPABASE_REF\",\"hosting\":\"$HOSTING\",\"deps\":\"$DEPS\"}"
+fi