groove-dev 0.27.92 → 0.27.94

package/node_modules/mkdirp-classic/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "mkdirp-classic",
+  "version": "0.5.3",
+  "description": "Mirror of mkdirp 0.5.2",
+  "main": "index.js",
+  "dependencies": {},
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/mkdirp-classic.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/mkdirp-classic/issues"
+  },
+  "homepage": "https://github.com/mafintosh/mkdirp-classic"
+}

package/node_modules/moe-training/DEPLOY_CENTRAL_COMMAND.md

@@ -0,0 +1,413 @@
+# Central Command — AWS Deployment Guide
+
+Build guide for deploying the MoE Training Data ingest server on the groovedev.ai AWS instance.
+
+Last updated: 2026-04-23
+
+---
+
+## 1. What This Server Does
+
+Central Command receives Trajectory Envelopes from Groove desktop clients that have opted into training data sharing. It verifies cryptographic attestation (ECDH + HMAC), stores verified envelopes, stitches multi-chunk sessions, scores trajectories using a multiplier matrix, and credits contributors with points.
+
+All source code is in: `moe-training/server/`
+Shared utilities: `moe-training/shared/`
+
+---
+
+## 2. System Requirements
+
+- Node.js 20+ LTS (ES modules, native fetch)
+- build-essential + python3 (for compiling better-sqlite3 native bindings)
+- nginx (reverse proxy, SSL termination)
+- certbot (Let's Encrypt SSL for api.groovedev.ai)
+- PM2 (process manager) or systemd
+- 1GB+ RAM, 20GB+ disk (envelopes grow over time)
+
+---
+
+## 3. Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| GROOVE_CENTRAL_PORT | 8443 | Port the Express server listens on (behind nginx) |
+| NODE_ENV | production | Set to production for security defaults |
+
+The server does NOT need any API keys. It only receives data — it does not call any external APIs. The enrichment pipeline (LLM-as-a-Judge) is currently a stub and will need API keys when activated post-launch.
+
+---
+
+## 4. Directory Structure on Server
+
+```
+/opt/groove-central/
+  moe-training/
+    package.json
+    package-lock.json
+    server/            <-- the server code
+    shared/            <-- shared crypto/schema/constants
+    client/            <-- NOT needed on server, but harmless to include
+    data/              <-- created automatically on first run
+      sessions.db      <-- SQLite: ECDH session state, rate limiting
+      ledger.db        <-- SQLite: contributor points and balances
+      envelopes/       <-- JSONL envelope storage (daily rotation)
+        2026-04-26.jsonl
+        2026-04-27.jsonl
+```
+
+The data/ directory is created automatically by the server components on first request. SQLite databases use WAL mode for crash safety. File permissions: directories 0o700, files 0o600.
+
+---
+
+## 5. Dependencies
+
+```json
+{
+  "better-sqlite3": "^11.0.0",
+  "uuid": "^9.0.0",
+  "express": "^4.18.0"
+}
+```
+
+better-sqlite3 is a native C++ addon — it needs compilation tools:
+
+```bash
+sudo apt update
+sudo apt install -y build-essential python3 git
+```
+
+---
+
+## 6. Deployment Steps
+
+### 6a. Clone and Install
+
+```bash
+# Clone the repo (or scp the moe-training directory)
+cd /opt/groove-central
+git clone https://github.com/grooveai-dev/groove.git
+cd groove/moe-training
+
+# Install dependencies
+npm install --production
+```
+
+### 6b. Test the Server Locally
+
+```bash
+# Start the server
+GROOVE_CENTRAL_PORT=8443 node server/index.js
+
+# In another terminal, verify health
+curl http://localhost:8443/health
+# Expected: {"status":"ok","uptime":...}
+
+# Verify session endpoint
+curl -X POST http://localhost:8443/v1/sessions/open \
+  -H "Content-Type: application/json" \
+  -d '{"session_id":"test-1","public_key":"dGVzdA==","provider":"claude-code","model":"claude-opus-4-6","machine_fingerprint":"test","app_version_hash":"abc","groove_version":"0.27.77"}'
+# Expected: {"server_public_key":"..."}
+
+# Verify stats endpoint
+curl http://localhost:8443/v1/stats/summary
+# Expected: {"totalEnvelopes":0,...}
+
+# Kill the test server (Ctrl+C)
+```
+
+### 6c. PM2 Process Manager
+
+```bash
+# Install PM2 globally
+sudo npm install -g pm2
+
+# Create ecosystem config
+cat > /opt/groove-central/groove/moe-training/ecosystem.config.cjs << 'EOF'
+module.exports = {
+  apps: [{
+    name: 'groove-central',
+    script: 'server/index.js',
+    cwd: '/opt/groove-central/groove/moe-training',
+    env: {
+      NODE_ENV: 'production',
+      GROOVE_CENTRAL_PORT: 8443,
+    },
+    instances: 1,
+    max_memory_restart: '500M',
+    log_date_format: 'YYYY-MM-DD HH:mm:ss',
+    error_file: '/var/log/groove-central/error.log',
+    out_file: '/var/log/groove-central/access.log',
+    merge_logs: true,
+  }],
+};
+EOF
+
+# Create log directory
+sudo mkdir -p /var/log/groove-central
+sudo chown $USER:$USER /var/log/groove-central
+
+# Start with PM2
+pm2 start ecosystem.config.cjs
+
+# Save PM2 config for auto-restart on reboot
+pm2 save
+pm2 startup
+# (follow the instructions PM2 prints to enable startup hook)
+```
+
+### 6d. Nginx Reverse Proxy + SSL
+
+```nginx
+# /etc/nginx/sites-available/groove-central
+
+server {
+    listen 80;
+    server_name api.groovedev.ai;
+
+    # Certbot will add the redirect after SSL is set up
+    location / {
+        return 301 https://$host$request_uri;
+    }
+}
+
+server {
+    listen 443 ssl http2;
+    server_name api.groovedev.ai;
+
+    # SSL certs (managed by certbot)
+    ssl_certificate /etc/letsencrypt/live/api.groovedev.ai/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/api.groovedev.ai/privkey.pem;
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers HIGH:!aNULL:!MD5;
+
+    # Proxy to Node.js server
+    location /v1/ {
+        proxy_pass http://127.0.0.1:8443;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # Large envelopes (up to 5MB)
+        client_max_body_size 5m;
+
+        # Timeouts for stitching/scoring on SESSION_CLOSE
+        proxy_read_timeout 30s;
+        proxy_send_timeout 30s;
+    }
+
+    location /health {
+        proxy_pass http://127.0.0.1:8443;
+        proxy_http_version 1.1;
+    }
+
+    # Block everything else
+    location / {
+        return 404;
+    }
+}
+```
+
+```bash
+# Enable the site
+sudo ln -s /etc/nginx/sites-available/groove-central /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx
+
+# Get SSL certificate
+sudo certbot --nginx -d api.groovedev.ai
+```
+
+### 6e. DNS
+
+Point api.groovedev.ai to the AWS instance's public IP:
+- Type: A record
+- Name: api
+- Value: <AWS instance public IP>
+- TTL: 300
+
+If api.groovedev.ai already points to this instance for other services, add the /v1/ location block to the existing nginx config instead of creating a new server block.
+
+---
+
+## 7. API Endpoints
+
+All endpoints are under /v1/ (proxied through nginx).
+
+### Session Management
+
+POST /v1/sessions/open
+  Body: { session_id, public_key (base64), provider, model, machine_fingerprint, app_version_hash, groove_version }
+  Returns: { server_public_key (base64) }
+  Errors: 400 (missing fields), 429 (rate limited: 20 sessions/hour per fingerprint)
+
+POST /v1/sessions/close
+  Body: { session_id }
+  Returns: { closed: true }
+  Errors: 404 (unknown session)
+
+### Data Ingestion
+
+POST /v1/training/ingest
+  Body: Full Trajectory Envelope JSON (up to 5MB)
+  Returns: { accepted: true, envelope_id }
+  Errors: { accepted: false, reason: "..." }
+  Special: SESSION_CLOSE envelopes trigger stitching, scoring, and ledger credit
+
+### Statistics
+
+GET /v1/stats/summary
+  Returns: { totalEnvelopes, totalSteps, totalSessions, activeSessions, uniqueContributors, storageSizeMb, totalPointsAwarded }
+
+GET /v1/stats/daily?days=7
+  Returns: [{ date, envelopes, steps, sessions, points }, ...]
+
+GET /v1/stats/models
+  Returns: { "claude-opus-4-6": { sessions, steps, points, percentage }, ... }
+
+GET /v1/stats/providers
+  Returns: { "claude-code": { sessions, steps, points }, ... }
+
+GET /v1/stats/leaderboard?limit=10
+  Returns: [{ contributor_id (truncated), total_points, total_sessions }, ...]
+
+### Health
+
+GET /health
+  Returns: { status: "ok", uptime: seconds }
+
+---
+
+## 8. ECDH Handshake Flow
+
+This is how client (Groove daemon) and server authenticate:
+
+1. Client generates ephemeral ECDH keypair (prime256v1 curve)
+2. Client POSTs public key to /v1/sessions/open
+3. Server generates its own ECDH keypair, derives shared secret, stores session
+4. Server returns its public key
+5. Client derives the same shared secret (ECDH math)
+6. Every envelope is HMAC-SHA256 signed: HMAC(shared_secret, JSON(envelope) + sequence_number)
+7. Server verifies HMAC and sequence number on each ingest
+8. Sequence numbers are monotonically increasing — prevents replay attacks
+
+The shared secret NEVER crosses the wire. Both sides derive it independently from the key exchange. An attacker would need the server's ephemeral private key to forge envelopes.
+
+---
+
+## 9. Data Storage
+
+### SQLite Databases
+
+sessions.db — Active and closed session records
+  Columns: session_id, server_private_key, server_public_key, shared_secret, client_public_key, provider, model, machine_fingerprint, app_version_hash, groove_version, expected_sequence, status, created_at, closed_at
+  WAL mode enabled for concurrent reads
+
+ledger.db — Contributor points
+  Table credits: id, contributor_id, session_id, points, base_points, multiplier_breakdown (JSON), created_at
+  Table balances: contributor_id (PK), total_points, total_sessions, last_credit_at, trust_score
+  WAL mode enabled
+
+### JSONL Envelope Storage
+
+Location: ./data/envelopes/YYYY-MM-DD.jsonl
+One JSON object per line, daily rotation.
+Each line is a complete verified envelope (chunk or SESSION_CLOSE).
+
+Storage will grow linearly with usage. Estimate: ~1KB per envelope chunk, 5-10 chunks per session.
+At 100 sessions/day = ~1MB/day. At 10,000 sessions/day = ~100MB/day.
+
+---
+
+## 10. Scoring / Multiplier Matrix
+
+When a SESSION_CLOSE envelope arrives, the server stitches all chunks and scores:
+
+Base points: 1 per trajectory step
+
+Model multiplier (applied to all steps):
+  claude-opus-4-6, claude-opus-4-7: 5x
+  claude-sonnet-4-6: 3x
+  gpt-4.5, o3: 5x
+  o4-mini: 2x
+  gemini-2.5-pro: 3x
+  gemini-2.5-flash: 1.5x
+
+Quality multipliers (applied to relevant steps):
+  User corrections present: 10x on correction steps
+  Coordination events: 5x on coordination steps
+  Error recovery arcs: 3x on error+resolution steps
+  Heavy task complexity: 2x base
+  Session quality >= 80: 1.5x total
+
+---
+
+## 11. Monitoring
+
+Check server health:
+  curl https://api.groovedev.ai/health
+
+Check corpus stats:
+  curl https://api.groovedev.ai/v1/stats/summary
+
+Check daily growth:
+  curl https://api.groovedev.ai/v1/stats/daily?days=7
+
+Check active sessions:
+  curl https://api.groovedev.ai/v1/stats/summary | jq .activeSessions
+
+PM2 monitoring:
+  pm2 status
+  pm2 logs groove-central
+  pm2 monit
+
+---
+
+## 12. Backup Strategy
+
+Critical data to back up:
+  ./data/sessions.db — session keys (active sessions need this)
+  ./data/ledger.db — contributor points (this is money)
+  ./data/envelopes/ — raw training data (the product)
+
+Recommended: daily cron to rsync data/ to S3 or another volume.
+
+```bash
+# Example cron (add to crontab -e)
+0 3 * * * aws s3 sync /opt/groove-central/groove/moe-training/data/ s3://groove-training-backup/$(date +\%Y-\%m-\%d)/ --quiet
+```
+
+---
+
+## 13. Security Notes
+
+- The server accepts connections from any origin (CORS: *) because Groove clients connect from user machines worldwide
+- Rate limiting: max 20 sessions per machine fingerprint per hour (prevents session spam)
+- HMAC verification on every envelope prevents forged data
+- Sequence numbers prevent replay attacks
+- SQLite databases contain ECDH private keys — protect with filesystem permissions (0o600)
+- nginx should only expose /v1/ and /health paths — everything else returns 404
+- No authentication on stats endpoints (they show aggregate data only, no PII)
+
+---
+
+## 14. Future Additions (Not in This Build)
+
+- Enrichment pipeline: LLM-as-a-Judge for model fingerprinting and cognitive target classification (server/enrichment.js is a stub)
+- S3 migration: move envelope storage from local JSONL to S3 for durability
+- PostgreSQL migration: move from SQLite to PostgreSQL if concurrent write pressure increases
+- Merkle tree: daily hash of ledger for on-chain publication (Base L2)
+- Admin dashboard: web UI for monitoring corpus health, contributor activity, data quality
+
+---
+
+## 15. Quick Reference
+
+Start: pm2 start ecosystem.config.cjs
+Stop: pm2 stop groove-central
+Restart: pm2 restart groove-central
+Logs: pm2 logs groove-central
+Status: pm2 status
+Health: curl https://api.groovedev.ai/health
+Stats: curl https://api.groovedev.ai/v1/stats/summary

package/node_modules/moe-training/client/consent.js

@@ -0,0 +1,96 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import Database from 'better-sqlite3';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { CURRENT_CONSENT_VERSION } from '../shared/constants.js';
+
+export class ConsentManager {
+  constructor(dbPath) {
+    this._dbPath = dbPath || join(homedir(), '.groove', 'consent.db');
+    const dir = this._dbPath.replace(/[/\\][^/\\]+$/, '');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    this._db = new Database(this._dbPath);
+    this._db.pragma('journal_mode = WAL');
+    this._db.exec(`
+      CREATE TABLE IF NOT EXISTS consent_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        opted_in INTEGER NOT NULL,
+        consent_version TEXT NOT NULL,
+        metadata TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+  }
+
+  recordConsent(userId, optedIn, consentVersion, metadata) {
+    this._db.prepare(
+      'INSERT INTO consent_history (user_id, opted_in, consent_version, metadata) VALUES (?, ?, ?, ?)'
+    ).run(userId, optedIn ? 1 : 0, consentVersion, metadata ? JSON.stringify(metadata) : null);
+  }
+
+  isOptedIn(userId) {
+    const row = this._db.prepare(
+      'SELECT opted_in, consent_version FROM consent_history WHERE user_id = ? ORDER BY id DESC LIMIT 1'
+    ).get(userId);
+    if (!row) return false;
+    if (row.consent_version !== CURRENT_CONSENT_VERSION) return false;
+    return row.opted_in === 1;
+  }
+
+  revokeConsent(userId) {
+    this.recordConsent(userId, false, CURRENT_CONSENT_VERSION);
+  }
+
+  getOptedInCount() {
+    const row = this._db.prepare(`
+      SELECT COUNT(DISTINCT user_id) as cnt FROM consent_history ch1
+      WHERE opted_in = 1
+        AND consent_version = ?
+        AND id = (SELECT MAX(id) FROM consent_history ch2 WHERE ch2.user_id = ch1.user_id)
+    `).get(CURRENT_CONSENT_VERSION);
+    return row?.cnt || 0;
+  }
+
+  getConsentHistory(userId) {
+    const rows = this._db.prepare(
+      'SELECT * FROM consent_history WHERE user_id = ? ORDER BY id ASC'
+    ).all(userId);
+    return rows.map((r) => ({
+      ...r,
+      opted_in: r.opted_in === 1,
+      metadata: r.metadata ? JSON.parse(r.metadata) : null,
+    }));
+  }
+
+  close() {
+    this._db.close();
+  }
+
+  static getOrCreateUserId(userIdPath) {
+    const filePath = userIdPath || join(homedir(), '.groove', 'user_id');
+    const dir = filePath.replace(/[/\\][^/\\]+$/, '');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    if (existsSync(filePath)) {
+      return readFileSync(filePath, 'utf-8').trim();
+    }
+    const uid = randomUUID().replace(/-/g, '');
+    writeFileSync(filePath, uid, { mode: 0o600 });
+    return uid;
+  }
+
+  static isCaptureEnabled(userIdPath, dbPath) {
+    const filePath = userIdPath || join(homedir(), '.groove', 'user_id');
+    if (!existsSync(filePath)) return false;
+    const userId = readFileSync(filePath, 'utf-8').trim();
+    const manager = new ConsentManager(dbPath);
+    try {
+      return manager.isOptedIn(userId);
+    } finally {
+      manager.close();
+    }
+  }
+}

package/node_modules/moe-training/client/envelope-builder.js

@@ -0,0 +1,56 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { randomUUID } from 'node:crypto';
+import { CHUNK_SIZE } from '../shared/constants.js';
+
+export class EnvelopeBuilder {
+  constructor(sessionId, contributorId, metadata) {
+    this._sessionId = sessionId;
+    this._contributorId = contributorId;
+    this._metadata = metadata;
+    this._buffer = [];
+    this._chunkSequence = 0;
+  }
+
+  addStep(step) {
+    if (step.content && typeof step.content === 'string' && step.content.length > 10_000) {
+      step.content = step.content.slice(0, 10_000);
+    }
+    if (typeof step.token_count === 'number' && step.token_count > 100_000) {
+      step.token_count = 100_000;
+    }
+    this._buffer.push(step);
+    if (this._buffer.length >= CHUNK_SIZE) {
+      return this._buildEnvelope();
+    }
+    return null;
+  }
+
+  flush() {
+    if (this._buffer.length === 0) return null;
+    return this._buildEnvelope();
+  }
+
+  buildSessionClose(outcome) {
+    return {
+      envelope_id: `env_${randomUUID()}`,
+      session_id: this._sessionId,
+      type: 'SESSION_CLOSE',
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      outcome,
+    };
+  }
+
+  _buildEnvelope() {
+    const envelope = {
+      envelope_id: `env_${randomUUID()}`,
+      session_id: this._sessionId,
+      chunk_sequence: this._chunkSequence++,
+      contributor_id: this._contributorId,
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      metadata: { ...this._metadata },
+      trajectory_log: this._buffer.splice(0),
+    };
+    return envelope;
+  }
+}

package/node_modules/moe-training/client/index.js

@@ -0,0 +1,10 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export { TrajectoryCapture } from './trajectory-capture.js';
+export { ConsentManager } from './consent.js';
+export { PIIScrubber } from './scrubber.js';
+export { SessionAttestation } from './session-attestation.js';
+export { TransmissionQueue } from './transmission-queue.js';
+export { EnvelopeBuilder } from './envelope-builder.js';
+export { StepClassifier } from './step-classifier.js';
+export { getParser } from './parsers/index.js';

package/node_modules/moe-training/client/parsers/claude-code.js

@@ -0,0 +1,108 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { OBSERVATION_TRUNCATE_HEAD, OBSERVATION_TRUNCATE_TAIL } from '../../shared/constants.js';
+
+function truncateObservation(text) {
+  if (!text || typeof text !== 'string') return text;
+  const lines = text.split('\n');
+  if (lines.length <= OBSERVATION_TRUNCATE_HEAD + OBSERVATION_TRUNCATE_TAIL) return text;
+  const head = lines.slice(0, OBSERVATION_TRUNCATE_HEAD);
+  const tail = lines.slice(-OBSERVATION_TRUNCATE_TAIL);
+  const omitted = lines.length - OBSERVATION_TRUNCATE_HEAD - OBSERVATION_TRUNCATE_TAIL;
+  return [...head, `[... ${omitted} lines omitted ...]`, ...tail].join('\n');
+}
+
+export class ClaudeCodeParser {
+  constructor() {
+    this._pendingToolUse = new Map();
+  }
+
+  parseEvent(jsonEvent) {
+    if (!jsonEvent || !jsonEvent.type) return null;
+
+    if (jsonEvent.type === 'assistant') {
+      const contentBlocks = jsonEvent.message?.content;
+      if (!Array.isArray(contentBlocks)) return null;
+
+      const results = [];
+      for (const block of contentBlocks) {
+        if (block.type === 'text') {
+          results.push({
+            type: 'thought',
+            content: block.text || '',
+          });
+        } else if (block.type === 'tool_use') {
+          this._pendingToolUse.set(block.id, block);
+          results.push({
+            type: 'action',
+            tool: block.name,
+            arguments: block.input,
+            content: `Using ${block.name}`,
+          });
+        } else if (block.type === 'tool_result') {
+          const toolUse = this._pendingToolUse.get(block.tool_use_id);
+          if (toolUse) this._pendingToolUse.delete(block.tool_use_id);
+
+          const resultContent = Array.isArray(block.content)
+            ? block.content.map((c) => c.text || '').join('\n')
+            : (typeof block.content === 'string' ? block.content : '');
+
+          if (block.is_error) {
+            results.push({ type: 'error', content: resultContent, is_error: true });
+          } else {
+            results.push({
+              type: 'observation',
+              content: truncateObservation(resultContent),
+              is_error: false,
+            });
+          }
+        }
+      }
+
+      return results.length === 1 ? results[0] : results.length > 1 ? results : null;
+    }
+
+    if (jsonEvent.type === 'result') {
+      return {
+        type: 'resolution',
+        content: typeof jsonEvent.result === 'string' ? jsonEvent.result : JSON.stringify(jsonEvent.result),
+      };
+    }
+
+    return null;
+  }
+
+  extractTokens(jsonEvent) {
+    if (!jsonEvent) return null;
+    if (jsonEvent.type === 'assistant') {
+      const usage = jsonEvent.message?.usage;
+      if (!usage) return null;
+      return {
+        input: usage.input_tokens || 0,
+        output: usage.output_tokens || 0,
+        cacheRead: usage.cache_read_input_tokens || 0,
+        cacheCreation: usage.cache_creation_input_tokens || 0,
+      };
+    }
+    if (jsonEvent.type === 'result') {
+      return {
+        input: jsonEvent.total_input_tokens || 0,
+        output: jsonEvent.total_output_tokens || 0,
+        cacheRead: 0,
+        cacheCreation: 0,
+      };
+    }
+    return null;
+  }
+
+  extractSessionId(jsonEvent) {
+    return jsonEvent?.session_id || null;
+  }
+
+  extractModel(jsonEvent) {
+    if (jsonEvent?.type === 'assistant') {
+      return jsonEvent.message?.model || null;
+    }
+    return null;
+  }
+}