@codyswann/lisa 1.40.0 → 1.42.0

package/expo/copy-overwrite/.claude/skills/ops-browser-uat/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: ops-browser-uat
+description: Browser-based user acceptance testing via Playwright MCP tools. Logs into the application, navigates through features, and captures visual proof with screenshots.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Browser UAT
+
+Perform browser-based user acceptance testing using Playwright MCP tools.
+
+**Argument**: `$ARGUMENTS` — scenario and environment (e.g., `smoke-test dev`, `login staging`, `player-detail dev`, `custom production /path`)
+
+## Prerequisites
+
+1. **Load Playwright MCP tools** — use `ToolSearch` to search for `playwright browser` and load all browser tools.
+2. **Verify target environment is up** — curl check the frontend URL before launching the browser.
+3. **For localhost** — ensure the frontend is running on port 8081.
+
+## Discovery
+
+Before running any scenario, read these project files to discover configuration:
+
+1. **`e2e/constants.ts`** — environment URLs, test credentials (phone, OTP), timeouts, viewports
+2. **`e2e/selectors.ts`** — all `data-testid` values organized by feature area
+3. **`e2e/fixtures/auth.fixture.ts`** — exact login/logout flow to replicate via MCP tools
+4. **`playwright.config.ts`** — video/trace recording config, test directory
+
+## Authentication Procedure
+
+Replicate the login flow from `e2e/fixtures/auth.fixture.ts` using Playwright MCP tools. Read the file to get the exact steps, which typically follow this pattern:
+
+### Login
+
+1. `browser_navigate` to `{BASE_URL}/signin`
+2. `browser_snapshot` to discover page elements
+3. `browser_fill_form` — fill the phone input (discover placeholder text from auth fixture)
+4. Wait for form validation debounce (typically 500ms)
+5. `browser_click` — click the "Next" button
+6. `browser_wait_for` — wait for URL to contain `confirm-code` (timeout from constants)
+7. `browser_snapshot` to discover OTP input
+8. `browser_fill_form` — fill the OTP input (discover testid from selectors, value from constants)
+9. `browser_wait_for` — wait for URL to NOT contain `confirm-code`
+10. `browser_take_screenshot` — capture login proof
+
+### Dismiss Error Overlay
+
+Expo's development error overlay may appear. Dismiss it:
+
+1. `browser_evaluate` with script:
+   ```javascript
+   document.getElementById('error-overlay')?.remove();
+   document.querySelectorAll('[id*="error"]').forEach(el => el.remove());
+   ```
+2. `browser_press_key` — press "Escape" as backup
+
+### Check if Logged In
+
+```javascript
+// browser_evaluate
+localStorage.getItem("@authData") !== null
+```
+
+### Logout
+
+Discover the menu button and sign-out flow from `e2e/selectors.ts` and `e2e/fixtures/auth.fixture.ts`:
+
+1. `browser_click` — menu button element (discover testid from selectors)
+2. `browser_click` — element with text "Sign Out"
+3. `browser_wait_for` — URL contains `signin`
+
+## Selector Reference
+
+Read `e2e/selectors.ts` to get the complete `data-testid` reference for the project. The selectors object is organized by feature area (auth, nav, home sections, player detail, etc.).
+
+Use `[data-testid="{TESTID}"]` to target elements in Playwright MCP tools.
+
+## Built-in UAT Scenarios
+
+### 1. smoke-test
+
+Full app walkthrough. Read `e2e/selectors.ts` to identify which sections and elements to verify:
+
+1. **Login** (auth procedure above)
+2. **Home screen** — verify key sections exist using selectors from the project
+3. **Feature pages** — navigate to 2-3 key routes and verify content loads
+4. **Logout** → verify redirect to signin
+5. Screenshot at each step
+
+### 2. login
+
+Just the login flow with screenshot proof.
+
+### 3. home-screen
+
+Login → verify all home screen sections have data. Screenshot each section.
+
+### 4. custom
+
+Login → navigate to user-specified URL → interact as instructed → screenshot.
+
+## Proof Recording
+
+At each verification point:
+
+1. `browser_take_screenshot` — visual proof of current state
+2. `browser_console_messages` — check for JavaScript errors
+3. `browser_network_requests` — monitor for failed API calls (4xx, 5xx)
+
+## Output Format
+
+Report UAT results as a table:
+
+| Step | Action | Status | Notes |
+|------|--------|--------|-------|
+| 1 | Navigate to /signin | PASS | Page loaded in 1.2s |
+| 2 | Enter phone number | PASS | Input accepted |
+| 3 | Click Next | PASS | Navigated to /confirm-code |
+| 4 | Enter OTP | PASS | OTP accepted |
+| 5 | Verify home screen | PASS | All sections present |
+| 6 | Logout | PASS | Redirected to /signin |
+
+Include total PASS/FAIL count and any JS errors or failed network requests observed.

package/expo/copy-overwrite/.claude/skills/ops-check-logs/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: ops-check-logs
+description: Check application logs from local processes, browser console, React Native device logs, or remote AWS CloudWatch. Supports log tailing, filtering, and error searching across all platforms.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Check Logs
+
+View and search logs across all platforms and environments.
+
+**Argument**: `$ARGUMENTS` — target and optional filter (e.g., `dev errors`, `staging api`, `local`, `browser`, `device ios`, `production {function}`)
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Discovery
+
+1. Read backend `package.json` to discover `logs:*`, `logs:watch:*`, and `aws:signin:*` scripts
+2. Extract function names from `logs:{env}` scripts (typically set via `FUNCTION_NAME` env var)
+3. Read `.env.{environment}` to find Sentry DSN for error correlation
+
+## Local Process Logs
+
+Local services run in foreground processes. Their logs are captured in the terminal where they were started.
+
+- **Frontend**: stdout from `bun start:local` or `bun start:dev` (Metro bundler)
+- **Backend**: stdout from `IS_OFFLINE=true bun run start:local` (Serverless Offline)
+
+If services were started via the `ops-run-local` skill with `run_in_background`, check the background task output file.
+
+## Browser Console Logs (Expo Web)
+
+For inspecting JavaScript errors, warnings, and `console.log` output in the browser at runtime.
+
+### Via Playwright MCP Tools (automated)
+
+Use when you need to capture browser logs programmatically during UAT or debugging.
+
+1. **Load Playwright tools** — use `ToolSearch` to search for `playwright browser`.
+
+2. **Navigate to the app**:
+   - `browser_navigate` to the target URL (discover from `e2e/constants.ts` or `.env.*` files)
+
+3. **Capture console messages**:
+   - `browser_console_messages` — returns all `console.log`, `console.warn`, `console.error` output
+
+4. **Check for failed network requests**:
+   - `browser_network_requests` — shows all HTTP requests including 4xx/5xx failures
+
+5. **Run custom JS to inspect state**:
+   - `browser_evaluate` with script: `JSON.stringify(performance.getEntriesByType('resource').filter(r => r.duration > 1000).map(r => ({name: r.name, duration: r.duration})))`
+
+### Via Browser DevTools (manual)
+
+When a developer is debugging interactively:
+
+1. Open the app in Chrome (`http://localhost:8081`)
+2. Open Chrome DevTools: `Cmd+Option+I` (macOS) or `F12`
+3. **Console tab** — JS errors, warnings, and log output
+4. **Network tab** — failed API requests (filter by `4xx` or `5xx`)
+5. **Performance tab** — runtime performance profiling
+
+## React Native Device Logs
+
+For inspecting logs on iOS and Android devices/simulators when running the native app.
+
+### React Native DevTools (primary — press `j`)
+
+The modern debugging tool for Expo apps (React Native 0.76+):
+
+1. Start the app: `bun start:local` or `bun start:dev`
+2. Press `j` in the Metro terminal to open React Native DevTools
+3. Available tabs:
+   - **Console** — interactive JS console connected to the app
+   - **Sources** — set breakpoints, step through code
+   - **Network** — inspect fetch requests and media loads
+   - **Memory** — heap snapshots and memory profiling
+
+### Expo Developer Menu (press `m`)
+
+Press `m` in the Metro terminal to open the Developer Menu on the connected device:
+- Toggle performance monitor (RAM, JS heap, Views, FPS)
+- Toggle element inspector
+- Open JS debugger
+- Reload app
+
+### iOS Logs
+
+```bash
+# Via Expo CLI (logs appear in Metro terminal automatically)
+# Just run the app — console.log output streams to the terminal
+
+# Via Xcode Console (native-level logs)
+# Open Xcode > Devices and Simulators (Shift+Cmd+2) > Open Console
+
+# Via macOS Console app (simulator logs)
+# Open Console.app > filter by process name
+```
+
+### Android Logs
+
+```bash
+# Via Expo CLI (logs appear in Metro terminal automatically)
+# Just run the app — console.log output streams to the terminal
+
+# Via adb logcat (native-level logs, verbose)
+adb logcat *:E  # Errors only
+adb logcat -s ReactNativeJS  # React Native JS logs only
+adb logcat -s ReactNativeJS:V *:S  # JS logs verbose, suppress everything else
+
+# Via Android Studio Logcat
+# Open Android Studio > View > Tool Windows > Logcat
+# Filter by package name or "ReactNativeJS"
+```
+
+### Production Crash Logs (Device)
+
+For production crash investigation on native platforms:
+- **iOS**: Xcode Crashes Organizer (TestFlight/App Store builds)
+- **Android**: Google Play Console > Crashes section
+- **Both**: Sentry captures JS-level crashes — use `ops-monitor-errors` skill
+
+## Remote Logs (CloudWatch via Serverless Framework)
+
+Discover available log scripts from the backend `package.json` (matching `logs:*` and `logs:watch:*`).
+
+### Prerequisites
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run aws:signin:{env}
+```
+
+### View Recent Logs
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+FUNCTION_NAME={fn} bun run logs:{env}
+```
+
+### Tail Logs (follow mode)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+FUNCTION_NAME={fn} bun run logs:watch:{env}
+```
+
+## Remote Logs (AWS CLI — Advanced Filtering)
+
+For more advanced filtering, use the AWS CLI directly. Discover the AWS profile from backend `package.json` `aws:signin:*` scripts.
+
+### Discover Log Groups
+
+```bash
+aws logs describe-log-groups \
+  --profile {aws-profile} \
+  --region us-east-1 \
+  --query 'logGroups[].logGroupName' \
+  --output text | tr '\t' '\n'
+```
+
+### Filter for Errors (last 30 minutes)
+
+```bash
+aws logs filter-log-events \
+  --profile {aws-profile} \
+  --region us-east-1 \
+  --log-group-name "{log-group}" \
+  --start-time $(date -v-30M +%s000) \
+  --filter-pattern "ERROR" \
+  --query 'events[].message' \
+  --output text
+```
+
+### Tail Live Logs
+
+```bash
+aws logs tail "{log-group}" \
+  --profile {aws-profile} \
+  --region us-east-1 \
+  --follow \
+  --since 10m
+```
+
+## EAS Build Logs
+
+For frontend build issues:
+
+```bash
+# List recent builds
+eas build:list --limit 5
+
+# View specific build details
+eas build:view {build-id}
+```
+
+## Output Format
+
+Report log findings as:
+
+| Source | Timestamp | Level | Context | Message |
+|--------|-----------|-------|---------|---------|
+| CloudWatch | 2024-01-15T10:30:00Z | ERROR | api | Connection timeout to RDS |
+| Browser | — | ERROR | console | TypeError: Cannot read property 'name' |
+| Device | — | WARN | ReactNativeJS | VirtualizedList: missing keys |
+
+Include a summary of findings: total errors, warnings, and any patterns observed.

package/expo/copy-overwrite/.claude/skills/ops-db-ops/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: ops-db-ops
+description: Database migrations, reverts, schema generation, and GraphQL codegen for Expo + serverless backend projects. Operates on the backend (TypeORM) and frontend (GraphQL code generation).
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Database Operations
+
+Manage database migrations, schema generation, and GraphQL code generation.
+
+**Argument**: `$ARGUMENTS` — operation (`migrate`, `revert`, `generate`, `schema`, `codegen`) and optional environment (default: `dev`)
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Safety
+
+**CRITICAL**: Never run migrations or reverts against production without explicit human confirmation.
+
+## Discovery
+
+Read the backend `package.json` to discover available migration and schema scripts:
+- `migration:run:*` — run pending migrations
+- `migration:revert:*` — revert last migration
+- `migration:generate:*` — generate new migration from entity changes
+- `migration:create` — create empty migration
+- `generate:sql-schema*` — regenerate SQL schema for MCP
+- `aws:signin:*` — AWS credential scripts
+
+Read the frontend `package.json` to discover codegen scripts:
+- `fetch:graphql:schema:*` — fetch GraphQL schema
+- `generate:types:*` — generate TypeScript types
+
+## AWS Prerequisite
+
+All database operations (except `codegen`) require AWS credentials. Run the backend's AWS signin script first:
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run aws:signin:{env}
+```
+
+## Operations
+
+### migrate (run pending migrations)
+
+**Local database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:run:local
+```
+
+**Remote database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:run:remote:local
+```
+
+### revert (undo last migration)
+
+**Local database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:revert:local
+```
+
+**Remote database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:revert:remote:local
+```
+
+### generate (create new migration from entity changes)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+NAME={migration_name} bun run migration:generate:{env}
+```
+
+### create (create empty migration)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+NAME={migration_name} bun run migration:create
+```
+
+### schema (regenerate SQL schema for MCP)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run generate:sql-schema
+```
+
+### codegen (regenerate GraphQL types in frontend)
+
+1. **Fetch schema**:
+   ```bash
+   bun run fetch:graphql:schema:{env}
+   ```
+
+2. **Generate types**:
+   ```bash
+   bun run generate:types:{env}
+   ```
+
+**Note**: The backend must be running (locally or deployed) for schema fetching to work.
+
+## Output Format
+
+Report operation result:
+
+| Operation | Environment | Target | Status | Details |
+|-----------|-------------|--------|--------|---------|
+| migrate | dev | local DB | SUCCESS | 2 migrations applied |
+| codegen | dev | frontend | SUCCESS | Types regenerated |

package/expo/copy-overwrite/.claude/skills/ops-deploy/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: ops-deploy
+description: Deploy Expo frontend (EAS Update/Build) or serverless backend (Serverless Framework) to dev, staging, or production environments.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Deploy
+
+Deploy the application to remote environments.
+
+**Argument**: `$ARGUMENTS` — environment (`dev`, `staging`, `production`) and optional target (`frontend`, `backend`, `both`; default: `both`)
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Safety
+
+**CRITICAL**: Production deployments require explicit human confirmation before proceeding. Always ask for confirmation when `$ARGUMENTS` contains `production`.
+
+## Discovery
+
+1. Read backend `package.json` to discover `deploy:*`, `aws:signin:*` scripts
+2. Read frontend `package.json` to discover available scripts
+3. Read `.env.{environment}` files to find GraphQL URLs for post-deploy verification
+
+## CI/CD Path (Preferred)
+
+The standard deployment path is via CI/CD — pushing to environment branches triggers auto-deploy. Manual deployment instructions below are for when CI/CD is not suitable.
+
+## Frontend Deployment
+
+### EAS Update (OTA — over-the-air JavaScript update)
+
+Use for JS-only changes (no native module changes).
+
+1. Verify EAS CLI:
+   ```bash
+   eas whoami
+   ```
+   If not authenticated: `eas login`
+
+2. Copy environment file:
+   ```bash
+   cp .env.{environment} .env
+   ```
+
+3. Deploy OTA update:
+   ```bash
+   STAGE={env} NODE_OPTIONS="--max-old-space-size=8192" eas update --auto --channel={env} --message="Manual update"
+   ```
+
+4. Verify deployment:
+   ```bash
+   eas update:list --branch {env} --limit 3
+   ```
+
+### EAS Build (Native binary — only when `app.config.ts` or native modules change)
+
+1. ```bash
+   eas build --platform all --non-interactive --no-wait --profile={profile}
+   ```
+
+2. Check build status:
+   ```bash
+   eas build:list --limit 5
+   ```
+
+## Backend Deployment
+
+### Full Deploy (Serverless Framework)
+
+1. AWS signin (discover script name from backend `package.json`):
+   ```bash
+   cd "${BACKEND_DIR:-../backend-v2}"
+   bun run aws:signin:{env}
+   ```
+
+2. Deploy all functions:
+   ```bash
+   cd "${BACKEND_DIR:-../backend-v2}"
+   bun run deploy:{env}
+   ```
+
+3. Verify (use the GraphQL URL from `.env.{environment}`):
+   ```bash
+   curl -sf {graphql-url} -X POST \
+     -H "Content-Type: application/json" \
+     -d '{"query":"{ __typename }"}' \
+     -w "\nHTTP %{http_code} in %{time_total}s\n"
+   ```
+
+### Single Function Deploy
+
+Discover available function names from backend `package.json` `deploy:function:*` scripts:
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+FUNCTION_NAME={fn} bun run deploy:function:{env}
+```
+
+## Post-Deploy Verification
+
+After any deployment:
+
+1. **Health check** the deployed environment (use `ops-verify-health` skill)
+2. **Check logs** for errors in the first 5 minutes (use `ops-check-logs` skill)
+3. **Monitor Sentry** for new issues (use `ops-monitor-errors` skill)
+4. **Run browser UAT smoke test** against the deployed environment (use `ops-browser-uat` skill)
+
+Report deployment result as a table:
+
+| Target | Environment | Method | Status | Verification |
+|--------|-------------|--------|--------|-------------|
+| Frontend | dev | EAS Update | SUCCESS/FAIL | URL responds |
+| Backend | dev | Serverless | SUCCESS/FAIL | GraphQL responds |

package/expo/copy-overwrite/.claude/skills/ops-monitor-errors/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: ops-monitor-errors
+description: Monitor Sentry for unresolved errors in frontend and backend projects. Supports filtering by project, environment, and time range.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Monitor Errors
+
+Monitor Sentry for errors in the application.
+
+**Argument**: `$ARGUMENTS` — project (`frontend`, `backend`, `all`; default: `all`) and optional time range (default: `1h`)
+
+## Discovery
+
+Discover Sentry configuration from:
+1. `.sentryclirc` — org and project names
+2. `.env.*` files — `EXPO_PUBLIC_SENTRY_DSN` for DSN
+3. `package.json` — `@sentry/react-native` (frontend) or `@sentry/node` (backend) for project type
+
+## Sentry CLI
+
+### List Unresolved Issues
+
+```bash
+sentry-cli issues list \
+  --org {org} \
+  --project {project}
+```
+
+### Filter by Environment
+
+```bash
+sentry-cli issues list \
+  --org {org} \
+  --project {project} \
+  --query "is:unresolved environment:{env}"
+```
+
+### Post-Deploy Check (new issues since deploy)
+
+```bash
+sentry-cli issues list \
+  --org {org} \
+  --project {project} \
+  --query "is:unresolved firstSeen:-{time}"
+```
+
+Where `{time}` is a Sentry duration like `1h`, `30m`, `24h`.
+
+## Sentry API (Fallback)
+
+If `sentry-cli` is not installed or not authenticated, use the API directly:
+
+### List Unresolved Issues
+
+```bash
+curl -sf "https://sentry.io/api/0/projects/{org}/{project}/issues/?query=is:unresolved&sort=date" \
+  -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" | \
+  jq '.[] | {id: .id, title: .title, count: .count, userCount: .userCount, firstSeen: .firstSeen, lastSeen: .lastSeen}'
+```
+
+### Filter by Environment
+
+```bash
+curl -sf "https://sentry.io/api/0/projects/{org}/{project}/issues/?query=is:unresolved+environment:{env}&sort=date" \
+  -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" | \
+  jq '.[] | {id: .id, title: .title, count: .count, userCount: .userCount}'
+```
+
+## Post-Deploy Workflow
+
+After any deployment:
+
+1. Wait 5 minutes for errors to surface
+2. Check for new unresolved issues in the deployed environment
+3. Assess severity: are these new regressions or pre-existing?
+4. Report findings with severity assessment
+
+## Output Format
+
+Report errors as a table:
+
+| Issue ID | Title | Events | Users | First Seen | Severity |
+|----------|-------|--------|-------|------------|----------|
+| 12345 | TypeError: Cannot read property 'name' | 42 | 15 | 5m ago | HIGH |
+| 12346 | Network request failed | 3 | 2 | 2h ago | MEDIUM |
+
+### Severity Classification
+
+| Severity | Criteria |
+|----------|----------|
+| CRITICAL | > 100 events or > 50 users in last hour |
+| HIGH | > 10 events or > 5 users, appeared after deploy |
+| MEDIUM | Recurring issue, < 10 events |
+| LOW | < 3 events, no user impact |
+
+Include summary: total unresolved issues, new since last deploy, and recommendation (proceed / investigate / rollback).