@in-the-loop-labs/pair-review 2.3.3 → 2.4.1

package/src/routes/github-collections.js

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * GitHub Collections Routes
+ *
+ * Handles endpoints for PR collections:
+ * - Review Requests: PRs where the user's review is requested
+ * - My PRs: PRs authored by the user
+ */
+
+const express = require('express');
+const { query, run, withTransaction } = require('../database');
+const { GitHubClient } = require('../github/client');
+const { getGitHubToken } = require('../config');
+const logger = require('../utils/logger');
+
+const router = express.Router();
+
+/**
+ * Get cached review request PRs.
+ */
+router.get('/api/github/review-requests', async (req, res) => {
+  try {
+    const db = req.app.get('db');
+    const rows = await query(db, 'SELECT owner, repo, number, title, author, updated_at, html_url, state, fetched_at FROM github_pr_cache WHERE collection = ? ORDER BY updated_at DESC', ['review-requests']);
+
+    const fetchedAt = rows.length > 0 ? rows[0].fetched_at : null;
+    res.json({ success: true, prs: rows, fetched_at: fetchedAt });
+  } catch (error) {
+    logger.error('Failed to fetch review requests:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch review requests' });
+  }
+});
+
+/**
+ * Refresh review request PRs from GitHub.
+ */
+router.post('/api/github/review-requests/refresh', async (req, res) => {
+  try {
+    const config = req.app.get('config');
+    const githubToken = getGitHubToken(config);
+    if (!githubToken) {
+      return res.status(401).json({ success: false, error: 'GitHub token not configured' });
+    }
+
+    const db = req.app.get('db');
+    const client = new GitHubClient(githubToken);
+    const user = await client.getAuthenticatedUser();
+    const prs = await client.searchPullRequests(`is:pr is:open user-review-requested:${user.login}`);
+
+    await withTransaction(db, async () => {
+      await run(db, 'DELETE FROM github_pr_cache WHERE collection = ?', ['review-requests']);
+      for (const pr of prs) {
+        await run(db,
+          'INSERT INTO github_pr_cache (owner, repo, number, title, author, updated_at, html_url, state, collection) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+          [pr.owner, pr.repo, pr.number, pr.title, pr.author, pr.updated_at, pr.html_url, pr.state, 'review-requests']
+        );
+      }
+    });
+
+    const rows = await query(db, 'SELECT owner, repo, number, title, author, updated_at, html_url, state, fetched_at FROM github_pr_cache WHERE collection = ? ORDER BY updated_at DESC', ['review-requests']);
+    const fetchedAt = rows.length > 0 ? rows[0].fetched_at : null;
+    res.json({ success: true, prs: rows, fetched_at: fetchedAt });
+  } catch (error) {
+    if (error.status === 401 || error.status === 403) {
+      return res.status(401).json({ success: false, error: 'GitHub token is invalid or expired' });
+    }
+    logger.error('Failed to refresh review requests:', error);
+    res.status(500).json({ success: false, error: 'Failed to refresh review requests' });
+  }
+});
+
+/**
+ * Get cached user's own PRs.
+ */
+router.get('/api/github/my-prs', async (req, res) => {
+  try {
+    const db = req.app.get('db');
+    const rows = await query(db, 'SELECT owner, repo, number, title, author, updated_at, html_url, state, fetched_at FROM github_pr_cache WHERE collection = ? ORDER BY updated_at DESC', ['my-prs']);
+
+    const fetchedAt = rows.length > 0 ? rows[0].fetched_at : null;
+    res.json({ success: true, prs: rows, fetched_at: fetchedAt });
+  } catch (error) {
+    logger.error('Failed to fetch my PRs:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch my PRs' });
+  }
+});
+
+/**
+ * Refresh user's own PRs from GitHub.
+ */
+router.post('/api/github/my-prs/refresh', async (req, res) => {
+  try {
+    const config = req.app.get('config');
+    const githubToken = getGitHubToken(config);
+    if (!githubToken) {
+      return res.status(401).json({ success: false, error: 'GitHub token not configured' });
+    }
+
+    const db = req.app.get('db');
+    const client = new GitHubClient(githubToken);
+    const user = await client.getAuthenticatedUser();
+    const prs = await client.searchPullRequests(`is:pr is:open author:${user.login}`);
+
+    await withTransaction(db, async () => {
+      await run(db, 'DELETE FROM github_pr_cache WHERE collection = ?', ['my-prs']);
+      for (const pr of prs) {
+        await run(db,
+          'INSERT INTO github_pr_cache (owner, repo, number, title, author, updated_at, html_url, state, collection) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+          [pr.owner, pr.repo, pr.number, pr.title, pr.author, pr.updated_at, pr.html_url, pr.state, 'my-prs']
+        );
+      }
+    });
+
+    const rows = await query(db, 'SELECT owner, repo, number, title, author, updated_at, html_url, state, fetched_at FROM github_pr_cache WHERE collection = ? ORDER BY updated_at DESC', ['my-prs']);
+    const fetchedAt = rows.length > 0 ? rows[0].fetched_at : null;
+    res.json({ success: true, prs: rows, fetched_at: fetchedAt });
+  } catch (error) {
+    if (error.status === 401 || error.status === 403) {
+      return res.status(401).json({ success: false, error: 'GitHub token is invalid or expired' });
+    }
+    logger.error('Failed to refresh my PRs:', error);
+    res.status(500).json({ success: false, error: 'Failed to refresh my PRs' });
+  }
+});
+
+module.exports = router;

package/src/routes/mcp.js

@@ -21,6 +21,7 @@ const {
   broadcastProgress,
   createProgressCallback
 } = require('./shared');
+const { safeParseJson } = require('../utils/safe-parse-json');
 
 // All valid tier values: canonical tiers + aliases (for Zod enum validation)
 const ALL_TIER_VALUES = /** @type {[string, ...string[]]} */ ([...TIERS, ...Object.keys(TIER_ALIASES)]);
@@ -428,7 +429,7 @@ function createMCPServer(db, options = {}) {
               type: s.type,
               ai_confidence: s.ai_confidence,
               status: s.status,
-              reasoning: s.reasoning ? JSON.parse(s.reasoning) : null,
+              reasoning: safeParseJson(s.reasoning),
             }))
           }, null, 2)
         }]

package/src/routes/pr.js

@@ -24,6 +24,7 @@ const Analyzer = require('../ai/analyzer');
 const { v4: uuidv4 } = require('uuid');
 const fs = require('fs').promises;
 const path = require('path');
+const { getGitHubToken } = require('../config');
 const logger = require('../utils/logger');
 const { buildDiffLineSet } = require('../utils/diff-annotator');
 const { broadcastReviewEvent } = require('../events/review-events');
@@ -37,6 +38,7 @@ const {
   createProgressCallback,
   parseEnabledLevels
 } = require('./shared');
+const { safeParseJson } = require('../utils/safe-parse-json');
 const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
 const { TIERS, TIER_ALIASES, VALID_TIERS, resolveTier } = require('../ai/prompts/config');
 const analysesRouter = require('./analyses');
@@ -199,7 +201,7 @@ router.get('/api/pr/:owner/:repo/:number', async (req, res) => {
     let pendingDraft = null;
     if (review) {
       const config = req.app.get('config');
-      const githubToken = config?.github_token || req.app.get('githubToken');
+      const githubToken = getGitHubToken(config || {}) || req.app.get('githubToken');
 
       if (githubToken) {
         try {
@@ -527,7 +529,7 @@ router.get('/api/pr/:owner/:repo/:number/github-drafts', async (req, res) => {
     }
 
     // Initialize GitHub client and check for pending drafts on GitHub
-    const githubToken = config.github_token || req.app.get('githubToken');
+    const githubToken = getGitHubToken(config) || req.app.get('githubToken');
     if (!githubToken) {
       return res.status(500).json({
         error: 'GitHub token not configured. Please check your ~/.pair-review/config.json'
@@ -1803,4 +1805,166 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
   }
 });
 
+/**
+ * Get shareable review data for a PR
+ * Returns PR metadata, diff, and AI analysis results in a single payload
+ * for consumption by external share sites.
+ *
+ * NOTE: Intentionally PR-only. Sharing requires a stable PR reference
+ * (owner/repo/number) that external consumers can resolve. Local mode
+ * reviews operate on uncommitted changes with no such reference.
+ */
+router.get('/api/pr/:owner/:repo/:number/share', async (req, res) => {
+  try {
+    const { owner, repo, number } = req.params;
+    const prNumber = parseInt(number);
+
+    if (isNaN(prNumber) || prNumber <= 0) {
+      return res.status(400).json({ error: 'Invalid pull request number' });
+    }
+
+    const repository = normalizeRepository(owner, repo);
+    const db = req.app.get('db');
+
+    // Get PR metadata
+    const prMetadata = await queryOne(db, `
+      SELECT id, pr_number, repository, title, author, base_branch, head_branch, pr_data
+      FROM pr_metadata
+      WHERE pr_number = ? AND repository = ? COLLATE NOCASE
+    `, [prNumber, repository]);
+
+    if (!prMetadata) {
+      return res.status(404).json({
+        error: `Pull request #${prNumber} not found in repository ${repository}`
+      });
+    }
+
+    // Parse PR data for diff and SHAs
+    let prData = {};
+    try {
+      prData = prMetadata.pr_data ? JSON.parse(prMetadata.pr_data) : {};
+    } catch (parseError) {
+      logger.warn('Error parsing PR data JSON for share:', parseError.message);
+    }
+
+    // Get review record
+    const reviewRepo = new ReviewRepository(db);
+    const review = await reviewRepo.getReviewByPR(prNumber, repository);
+
+    // Build changed files list
+    // changed_files may use 'insertions' (from git diff) or 'additions' (from GitHub API)
+    const changedFiles = (prData.changed_files || []).map(f => ({
+      path: f.file,
+      additions: f.insertions ?? f.additions ?? 0,
+      deletions: f.deletions ?? 0
+    }));
+
+    // Get the authenticated user (who is sharing)
+    let sharedBy = null;
+    try {
+      const config = req.app.get('config') || {};
+      const githubToken = getGitHubToken(config);
+      if (githubToken) {
+        const githubClient = new GitHubClient(githubToken);
+        const user = await githubClient.getAuthenticatedUser();
+        sharedBy = user.login;
+      }
+    } catch (authError) {
+      logger.warn('Could not get authenticated user for share:', authError.message);
+    }
+
+    // Build response payload
+    const payload = {
+      owner,
+      repo,
+      prNumber,
+      title: prMetadata.title || '',
+      author: prMetadata.author || '',
+      baseBranch: prMetadata.base_branch || '',
+      headBranch: prMetadata.head_branch || '',
+      baseSha: prData.base_sha || '',
+      headSha: prData.head_sha || '',
+      diff: prData.diff || '',
+      changedFiles,
+      sharedBy,
+      run: null,
+      suggestions: []
+    };
+
+    // If we have a review, get the analysis run and its suggestions
+    // Supports optional runId query param for specific run selection
+    if (review) {
+      const analysisRunRepo = new AnalysisRunRepository(db);
+      const requestedRunId = req.query.runId;
+      let targetRun = null;
+
+      if (requestedRunId) {
+        // Specific run requested - fetch it directly
+        targetRun = await analysisRunRepo.getById(requestedRunId);
+        // Verify it belongs to this review and is completed
+        if (!targetRun || targetRun.review_id !== review.id || targetRun.status !== 'completed') {
+          targetRun = null;
+        }
+      }
+
+      // If no specific run requested or it wasn't found/valid, fall back to the most recently completed run
+      if (!targetRun) {
+        const runs = await analysisRunRepo.getByReviewId(review.id);
+        targetRun = runs.find(r => r.status === 'completed') || null;
+      }
+
+      if (targetRun) {
+        payload.run = {
+          id: targetRun.id,
+          provider: targetRun.provider || null,
+          model: targetRun.model || null,
+          tier: targetRun.tier || null,
+          summary: targetRun.summary || null,
+          completedAt: targetRun.completed_at || null,
+          duration: targetRun.started_at && targetRun.completed_at
+            ? new Date(targetRun.completed_at).getTime() - new Date(targetRun.started_at).getTime()
+            : null,
+          customInstructions: targetRun.custom_instructions || targetRun.request_instructions || null
+        };
+
+        // Get suggestions for this run
+        const rows = await query(db, `
+          SELECT
+            id, file, line_start, line_end, side, type, title, body,
+            suggestion_text, ai_confidence, reasoning, status, is_file_level
+          FROM comments
+          WHERE review_id = ?
+            AND source = 'ai'
+            AND ai_run_id = ?
+            AND ai_level IS NULL
+            AND (is_raw = 0 OR is_raw IS NULL)
+            AND status IN ('active', 'adopted')
+          ORDER BY file, line_start
+        `, [review.id, targetRun.id]);
+
+        payload.suggestions = rows.map(row => ({
+          id: row.id,
+          file: row.file,
+          lineStart: row.line_start,
+          lineEnd: row.line_end,
+          side: row.side || 'RIGHT',
+          type: row.type || 'comment',
+          title: row.title || '',
+          body: row.body || '',
+          suggestionText: row.suggestion_text || '',
+          confidence: row.ai_confidence != null ? row.ai_confidence : null,
+          reasoning: safeParseJson(row.reasoning, []),
+          status: row.status,
+          isFileLevel: row.is_file_level === 1
+        }));
+      }
+    }
+
+    res.json(payload);
+  } catch (error) {
+    logger.error('Error generating share data:', error);
+    res.status(500).json({ error: 'Failed to generate share data' });
+  }
+});
+
 module.exports = router;

package/src/routes/reviews.js

@@ -20,6 +20,7 @@ const simpleGit = require('simple-git');
 const { GitWorktreeManager } = require('../git/worktree');
 const { normalizeRepository } = require('../utils/paths');
 const { resolveFormat, formatAdoptedComment: formatComment } = require('../utils/comment-formatter');
+const { safeParseJson } = require('../utils/safe-parse-json');
 
 const router = express.Router();
 
@@ -568,7 +569,7 @@ router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, r
 
       return {
         ...row,
-        reasoning: row.reasoning ? JSON.parse(row.reasoning) : null,
+        reasoning: safeParseJson(row.reasoning),
         formattedBody
       };
     });

package/src/routes/shared.js

@@ -231,16 +231,34 @@ function createProgressCallback(analysisId) {
         }
       }
 
-      currentStatus.levels[levelKey].streamEvent = evt;
-      // Propagate voiceId so council progress modal can identify active voice
-      if (progressUpdate.voiceId) {
-        currentStatus.levels[levelKey].voiceId = progressUpdate.voiceId;
-      }
-      // Propagate consolidation step so frontend can identify active consolidation child
-      if (consolidationMatch) {
-        currentStatus.levels[levelKey].consolidationStep = `L${consolidationMatch[1]}`;
-      } else if (level === 'orchestration') {
-        currentStatus.levels[levelKey].consolidationStep = 'orchestration';
+      // Per-voice orchestration streams: store in voices map, not shared state.
+      // This prevents per-reviewer orchestration (within each voice's analysis)
+      // from overwriting the shared consolidation streamEvent/consolidationStep.
+      const isPerVoiceOrchestration = (level === 'orchestration' || consolidationMatch) && progressUpdate.voiceId;
+      if (isPerVoiceOrchestration) {
+        if (!currentStatus.levels[levelKey].voices) {
+          currentStatus.levels[levelKey].voices = {};
+        }
+        if (!currentStatus.levels[levelKey].voices[progressUpdate.voiceId]) {
+          currentStatus.levels[levelKey].voices[progressUpdate.voiceId] = { status: 'running' };
+        }
+        currentStatus.levels[levelKey].voices[progressUpdate.voiceId].streamEvent = evt;
+      // Levels 1-3: stream events are stored in the shared levels[n].streamEvent field
+      // with voiceId as a routing discriminator (only one voice streams per level at a time).
+      // Level 4 is different (handled above) because it has both per-voice orchestration
+      // AND shared cross-voice consolidation, requiring separate storage paths.
+      } else {
+        currentStatus.levels[levelKey].streamEvent = evt;
+        // Propagate voiceId so council progress modal can identify active voice
+        if (progressUpdate.voiceId) {
+          currentStatus.levels[levelKey].voiceId = progressUpdate.voiceId;
+        }
+        // Propagate consolidation step so frontend can identify active consolidation child
+        if (consolidationMatch) {
+          currentStatus.levels[levelKey].consolidationStep = `L${consolidationMatch[1]}`;
+        } else if (level === 'orchestration') {
+          currentStatus.levels[levelKey].consolidationStep = 'orchestration';
+        }
       }
       activeAnalyses.set(analysisId, currentStatus);
 
@@ -295,48 +313,51 @@ function createProgressCallback(analysisId) {
     // Both maps must be preserved across updates since each progress event only
     // reports on a single step or voice at a time.
     if (level === 'orchestration' || consolidationMatch) {
-      const step = consolidationMatch ? `L${consolidationMatch[1]}` : 'orchestration';
-      // Preserve existing consolidation steps when updating level 4
-      const existing = currentStatus.levels[4] || {};
-      const steps = { ...(existing.steps || {}) };
-      steps[step] = {
-        status: progressUpdate.status || 'running',
-        progress: progressUpdate.progress || (consolidationMatch ? 'Consolidating...' : 'Finalizing results...')
-      };
-      // Derive the top-level consolidation status from the aggregate of step statuses
-      // so that a single step completing doesn't mark the whole phase as completed
-      const stepStatuses = Object.values(steps).map(s => s.status);
-      const derivedStatus = stepStatuses.every(s => s === 'completed') ? 'completed'
-        : stepStatuses.some(s => s === 'failed') ? 'failed'
-        : stepStatuses.some(s => s === 'running') ? 'running'
-        : progressUpdate.status || 'running';
-      // Preserve existing per-voice orchestration states when rebuilding level 4
-      const existingVoices = existing.voices ? { ...existing.voices } : undefined;
-      currentStatus.levels[4] = {
-        status: derivedStatus,
-        progress: progressUpdate.progress || (consolidationMatch ? 'Consolidating...' : 'Finalizing results...'),
-        streamEvent: existing.streamEvent,
-        consolidationStep: step,
-        steps,
-        voices: existingVoices
-      };
-
-      // Track per-voice orchestration state (voice-centric council mode):
-      // When a voiceId is present, store per-voice status in levels[4].voices
-      // so the frontend can update individual reviewer's consolidation row.
+      // Per-voice orchestration updates (voiceId present): only update the per-voice
+      // entry in levels[4].voices. Do NOT touch the shared consolidation state (steps,
+      // consolidationStep, streamEvent, top-level progress). This prevents per-reviewer
+      // orchestration (within each voice's analysis) from being confused with the
+      // overall cross-voice or cross-level consolidation.
       if (progressUpdate.voiceId) {
-        if (!currentStatus.levels[4].voices) {
-          currentStatus.levels[4].voices = {};
-        }
-        currentStatus.levels[4].voices[progressUpdate.voiceId] = {
+        const existing = currentStatus.levels[4] || {};
+        const existingVoices = existing.voices ? { ...existing.voices } : {};
+        const prev = existingVoices[progressUpdate.voiceId] || {};
+        const voiceStatus = progressUpdate.status || 'running';
+        existingVoices[progressUpdate.voiceId] = voiceStatus === 'running'
+          ? { ...prev, status: voiceStatus, progress: progressUpdate.progress || 'Consolidating...' }
+          : { status: voiceStatus, progress: progressUpdate.progress || 'Consolidating...' };
+        currentStatus.levels[4] = {
+          ...existing,
+          voices: existingVoices,
+          voiceId: progressUpdate.voiceId
+        };
+      } else {
+        // Shared consolidation update (no voiceId): update steps map and derive
+        // aggregate status. This is the cross-level or cross-voice consolidation.
+        const step = consolidationMatch ? `L${consolidationMatch[1]}` : 'orchestration';
+        const existing = currentStatus.levels[4] || {};
+        const steps = { ...(existing.steps || {}) };
+        steps[step] = {
           status: progressUpdate.status || 'running',
-          progress: progressUpdate.progress || 'Consolidating...'
+          progress: progressUpdate.progress || (consolidationMatch ? 'Consolidating...' : 'Finalizing results...')
+        };
+        // Derive the top-level consolidation status from the aggregate of step statuses
+        // so that a single step completing doesn't mark the whole phase as completed
+        const stepStatuses = Object.values(steps).map(s => s.status);
+        const derivedStatus = stepStatuses.every(s => s === 'completed') ? 'completed'
+          : stepStatuses.some(s => s === 'failed') ? 'failed'
+          : stepStatuses.some(s => s === 'running') ? 'running'
+          : progressUpdate.status || 'running';
+        // Preserve existing per-voice orchestration states when rebuilding level 4
+        const existingVoices = existing.voices ? { ...existing.voices } : undefined;
+        currentStatus.levels[4] = {
+          status: derivedStatus,
+          progress: progressUpdate.progress || (consolidationMatch ? 'Consolidating...' : 'Finalizing results...'),
+          streamEvent: existing.streamEvent,
+          consolidationStep: step,
+          steps,
+          voices: existingVoices
         };
-        // Last-writer-wins: reflects whichever voice reported most recently.
-        // Intentional — mirrors levels 1-3 behavior (line ~334) and the frontend
-        // uses per-voice detail from the `voices` map, not this top-level field.
-        // This field exists for backward compat with single-model progress routing.
-        currentStatus.levels[4].voiceId = progressUpdate.voiceId;
       }
     }
 

package/src/server.js

@@ -5,6 +5,7 @@ const { loadConfig, getGitHubToken, resolveDbName, warnIfDevModeWithoutDbName }
 const { initializeDatabase, getDatabaseStatus, queryOne, run } = require('./database');
 const { normalizeRepository } = require('./utils/paths');
 const { applyConfigOverrides, checkAllProviders } = require('./ai');
+const { checkAllChatProviders } = require('./chat/chat-providers');
 const logger = require('./utils/logger');
 const { attachWebSocket, closeAll: closeAllWS } = require('./ws');
 
@@ -161,6 +162,25 @@ async function startServer(sharedDb = null) {
     // Middleware
     app.use(requestLogger);
     app.use(express.json());
+
+    // CORS middleware for share endpoints
+    // Allows configured external origins to fetch share data
+    const shareAllowedOrigins = config.share?.allowed_origins || [];
+    if (shareAllowedOrigins.length > 0) {
+      app.use('/api/pr/:owner/:repo/:number/share', (req, res, next) => {
+        const origin = req.headers.origin;
+        if (origin && shareAllowedOrigins.includes(origin)) {
+          res.setHeader('Access-Control-Allow-Origin', origin);
+          res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+          res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+          res.setHeader('Vary', 'Origin');
+        }
+        if (req.method === 'OPTIONS') {
+          return res.sendStatus(204);
+        }
+        next();
+      });
+    }
     
     // Static files with cache control headers
     // In dev_mode, all caching is disabled to avoid stale resources during development
@@ -261,10 +281,11 @@ async function startServer(sharedDb = null) {
     const councilRoutes = require('./routes/councils');
     const chatRoutes = require('./routes/chat');
     const contextFilesRoutes = require('./routes/context-files');
+    const githubCollectionsRoutes = require('./routes/github-collections');
 
     // Initialize chat session manager
     const ChatSessionManager = require('./chat/session-manager');
-    chatSessionManager = new ChatSessionManager(db);
+    chatSessionManager = new ChatSessionManager(db, config.chat_providers || {});
     app.chatSessionManager = chatSessionManager;
 
     // Mount specific routes first to ensure they match before general PR routes
@@ -278,6 +299,7 @@ async function startServer(sharedDb = null) {
     app.use('/', localRoutes);
     app.use('/', setupRoutes);
     app.use('/', mcpRoutes);
+    app.use('/', githubCollectionsRoutes);
     app.use('/', prRoutes);
     
     // Error handling middleware
@@ -299,7 +321,11 @@ async function startServer(sharedDb = null) {
     // condition where the frontend fetches config before the cache is populated)
     const defaultProvider = config.default_provider || 'claude';
     try {
+      // Sequential: checkAllProviders must finish first because it populates
+      // the AI provider availability cache that checkAllChatProviders reads
+      // (e.g. the pi chat provider calls getCachedAvailability('pi')).
       await checkAllProviders(defaultProvider);
+      await checkAllChatProviders();
     } catch (err) {
       console.warn('Provider availability check failed:', err.message);
     }

package/src/utils/safe-parse-json.js

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Safely parse JSON with a fallback value.
+ * Useful for database columns that may contain malformed JSON.
+ *
+ * @param {string|null|undefined} str - The JSON string to parse
+ * @param {*} [fallback=null] - Value to return if parsing fails
+ * @returns {*} Parsed JSON value or the fallback
+ */
+function safeParseJson(str, fallback = null) {
+  if (str == null) return fallback;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return fallback;
+  }
+}
+
+module.exports = { safeParseJson };