fix: Build args format for version info + schema-tolerant routes

CI/CD: - Fix build_args format in woodpecker CI (comma-separated, not YAML list) - This fixes "unknown" SHA/version showing on remote deployments Backend schema-tolerant fixes (graceful fallbacks when tables missing): - users.ts: Check which columns exist before querying - worker-registry.ts: Return empty result if table doesn't exist - task-service.ts: Add tableExists() helper, handle missing tables/views - proxies.ts: Return totalProxies in test-all response Frontend fixes: - Proxies: Use total from response for accurate progress display - SEO PagesTab: Dim Generate button when no AI provider active 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-10 09:53:21 -07:00
parent 9647f94f89
commit 249d3c1b7f
9 changed files with 161 additions and 42 deletions
--- a/backend/src/routes/proxies.ts
+++ b/backend/src/routes/proxies.ts
@@ -183,8 +183,8 @@ router.post('/test-all', requireRole('superadmin', 'admin'), async (req, res) =>
      return res.status(400).json({ error: 'Concurrency must be between 1 and 50' });
    }

-    const jobId = await createProxyTestJob(mode, concurrency);
-    res.json({ jobId, mode, concurrency, message: `Proxy test job started (mode: ${mode}, concurrency: ${concurrency})` });
+    const { jobId, totalProxies } = await createProxyTestJob(mode, concurrency);
+    res.json({ jobId, total: totalProxies, mode, concurrency, message: `Proxy test job started (mode: ${mode}, concurrency: ${concurrency})` });
  } catch (error: any) {
    console.error('Error starting proxy test job:', error);
    res.status(500).json({ error: error.message || 'Failed to start proxy test job' });
@@ -195,8 +195,8 @@ router.post('/test-all', requireRole('superadmin', 'admin'), async (req, res) =>
 router.post('/test-failed', requireRole('superadmin', 'admin'), async (req, res) => {
  try {
    const concurrency = parseInt(req.query.concurrency as string) || 10;
-    const jobId = await createProxyTestJob('failed', concurrency);
-    res.json({ jobId, mode: 'failed', concurrency, message: 'Retesting failed proxies...' });
+    const { jobId, totalProxies } = await createProxyTestJob('failed', concurrency);
+    res.json({ jobId, total: totalProxies, mode: 'failed', concurrency, message: 'Retesting failed proxies...' });
  } catch (error: any) {
    console.error('Error starting failed proxy test:', error);
    res.status(500).json({ error: error.message || 'Failed to start proxy test job' });
--- a/backend/src/routes/users.ts
+++ b/backend/src/routes/users.ts
@@ -14,23 +14,36 @@ router.get('/', async (req: AuthRequest, res) => {
  try {
    const { search, domain } = req.query;

-    let query = `
-      SELECT id, email, role, first_name, last_name, phone, domain, created_at, updated_at
-      FROM users
-      WHERE 1=1
-    `;
+    // Check which columns exist (schema-tolerant)
+    const columnsResult = await pool.query(`
+      SELECT column_name FROM information_schema.columns
+      WHERE table_name = 'users' AND column_name IN ('first_name', 'last_name', 'phone', 'domain')
+    `);
+    const existingColumns = new Set(columnsResult.rows.map((r: any) => r.column_name));
+
+    // Build column list based on what exists
+    const selectCols = ['id', 'email', 'role', 'created_at', 'updated_at'];
+    if (existingColumns.has('first_name')) selectCols.push('first_name');
+    if (existingColumns.has('last_name')) selectCols.push('last_name');
+    if (existingColumns.has('phone')) selectCols.push('phone');
+    if (existingColumns.has('domain')) selectCols.push('domain');
+
+    let query = `SELECT ${selectCols.join(', ')} FROM users WHERE 1=1`;
    const params: any[] = [];
    let paramIndex = 1;

-    // Search by email, first_name, or last_name
+    // Search by email (and optionally first_name, last_name if they exist)
    if (search && typeof search === 'string') {
-      query += ` AND (email ILIKE $${paramIndex} OR first_name ILIKE $${paramIndex} OR last_name ILIKE $${paramIndex})`;
+      const searchClauses = ['email ILIKE $' + paramIndex];
+      if (existingColumns.has('first_name')) searchClauses.push('first_name ILIKE $' + paramIndex);
+      if (existingColumns.has('last_name')) searchClauses.push('last_name ILIKE $' + paramIndex);
+      query += ` AND (${searchClauses.join(' OR ')})`;
      params.push(`%${search}%`);
      paramIndex++;
    }

-    // Filter by domain
-    if (domain && typeof domain === 'string') {
+    // Filter by domain (if column exists)
+    if (domain && typeof domain === 'string' && existingColumns.has('domain')) {
      query += ` AND domain = $${paramIndex}`;
      params.push(domain);
      paramIndex++;
@@ -50,8 +63,22 @@ router.get('/', async (req: AuthRequest, res) => {
 router.get('/:id', async (req: AuthRequest, res) => {
  try {
    const { id } = req.params;
+
+    // Check which columns exist (schema-tolerant)
+    const columnsResult = await pool.query(`
+      SELECT column_name FROM information_schema.columns
+      WHERE table_name = 'users' AND column_name IN ('first_name', 'last_name', 'phone', 'domain')
+    `);
+    const existingColumns = new Set(columnsResult.rows.map((r: any) => r.column_name));
+
+    const selectCols = ['id', 'email', 'role', 'created_at', 'updated_at'];
+    if (existingColumns.has('first_name')) selectCols.push('first_name');
+    if (existingColumns.has('last_name')) selectCols.push('last_name');
+    if (existingColumns.has('phone')) selectCols.push('phone');
+    if (existingColumns.has('domain')) selectCols.push('domain');
+
    const result = await pool.query(`
-      SELECT id, email, role, first_name, last_name, phone, domain, created_at, updated_at
+      SELECT ${selectCols.join(', ')}
      FROM users
      WHERE id = $1
    `, [id]);
--- a/backend/src/routes/worker-registry.ts
+++ b/backend/src/routes/worker-registry.ts
@@ -273,6 +273,29 @@ router.post('/deregister', async (req: Request, res: Response) => {
 */
 router.get('/workers', async (req: Request, res: Response) => {
  try {
+    // Check if worker_registry table exists
+    const tableCheck = await pool.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables
+        WHERE table_name = 'worker_registry'
+      ) as exists
+    `);
+
+    if (!tableCheck.rows[0].exists) {
+      // Return empty result if table doesn't exist yet
+      return res.json({
+        success: true,
+        workers: [],
+        summary: {
+          active_count: 0,
+          idle_count: 0,
+          offline_count: 0,
+          total_count: 0,
+          active_roles: 0
+        }
+      });
+    }
+
    const { status, role, include_terminated = 'false' } = req.query;

    let whereClause = include_terminated === 'true' ? 'WHERE 1=1' : "WHERE status != 'terminated'";
--- a/backend/src/services/proxyTestQueue.ts
+++ b/backend/src/services/proxyTestQueue.ts
@@ -39,7 +39,12 @@ export async function cleanupOrphanedJobs(): Promise<void> {

 export type ProxyTestMode = 'all' | 'failed' | 'inactive';

-export async function createProxyTestJob(mode: ProxyTestMode = 'all', concurrency: number = DEFAULT_CONCURRENCY): Promise<number> {
+export interface CreateJobResult {
+  jobId: number;
+  totalProxies: number;
+}
+
+export async function createProxyTestJob(mode: ProxyTestMode = 'all', concurrency: number = DEFAULT_CONCURRENCY): Promise<CreateJobResult> {
  // Check for existing running jobs first
  const existingJob = await getActiveProxyTestJob();
  if (existingJob) {
@@ -79,7 +84,7 @@ export async function createProxyTestJob(mode: ProxyTestMode = 'all', concurrenc
    console.error(`❌ Proxy test job ${jobId} failed:`, err);
  });

-  return jobId;
+  return { jobId, totalProxies };
 }

 export async function getProxyTestJob(jobId: number): Promise<ProxyTestJob | null> {
--- a/backend/src/tasks/task-service.ts
+++ b/backend/src/tasks/task-service.ts
@@ -10,6 +10,17 @@

 import { pool } from '../db/pool';

+// Helper to check if a table exists
+async function tableExists(tableName: string): Promise<boolean> {
+  const result = await pool.query(`
+    SELECT EXISTS (
+      SELECT FROM information_schema.tables
+      WHERE table_name = $1
+    ) as exists
+  `, [tableName]);
+  return result.rows[0].exists;
+}
+
 export type TaskRole =
  | 'store_discovery'
  | 'entry_point_discovery'
@@ -270,6 +281,11 @@ class TaskService {
   * List tasks with filters
   */
  async listTasks(filter: TaskFilter = {}): Promise<WorkerTask[]> {
+    // Return empty list if table doesn't exist
+    if (!await tableExists('worker_tasks')) {
+      return [];
+    }
+
    const conditions: string[] = [];
    const params: (string | number | string[])[] = [];
    let paramIndex = 1;
@@ -323,21 +339,41 @@ class TaskService {
   * Get capacity metrics for all roles
   */
  async getCapacityMetrics(): Promise<CapacityMetrics[]> {
-    const result = await pool.query(
-      `SELECT * FROM v_worker_capacity`
-    );
-    return result.rows as CapacityMetrics[];
+    // Return empty metrics if worker_tasks table doesn't exist
+    if (!await tableExists('worker_tasks')) {
+      return [];
+    }
+
+    try {
+      const result = await pool.query(
+        `SELECT * FROM v_worker_capacity`
+      );
+      return result.rows as CapacityMetrics[];
+    } catch {
+      // View may not exist
+      return [];
+    }
  }

  /**
   * Get capacity metrics for a specific role
   */
  async getRoleCapacity(role: TaskRole): Promise<CapacityMetrics | null> {
-    const result = await pool.query(
-      `SELECT * FROM v_worker_capacity WHERE role = $1`,
-      [role]
-    );
-    return (result.rows[0] as CapacityMetrics) || null;
+    // Return null if worker_tasks table doesn't exist
+    if (!await tableExists('worker_tasks')) {
+      return null;
+    }
+
+    try {
+      const result = await pool.query(
+        `SELECT * FROM v_worker_capacity WHERE role = $1`,
+        [role]
+      );
+      return (result.rows[0] as CapacityMetrics) || null;
+    } catch {
+      // View may not exist
+      return null;
+    }
  }

  /**
@@ -463,12 +499,6 @@ class TaskService {
   * Get task counts by status for dashboard
   */
  async getTaskCounts(): Promise<Record<TaskStatus, number>> {
-    const result = await pool.query(
-      `SELECT status, COUNT(*) as count
-       FROM worker_tasks
-       GROUP BY status`
-    );
-
    const counts: Record<TaskStatus, number> = {
      pending: 0,
      claimed: 0,
@@ -478,6 +508,17 @@ class TaskService {
      stale: 0,
    };

+    // Return empty counts if table doesn't exist
+    if (!await tableExists('worker_tasks')) {
+      return counts;
+    }
+
+    const result = await pool.query(
+      `SELECT status, COUNT(*) as count
+       FROM worker_tasks
+       GROUP BY status`
+    );
+
    for (const row of result.rows) {
      const typedRow = row as { status: TaskStatus; count: string };
      counts[typedRow.status] = parseInt(typedRow.count, 10);