@juspay/shooter 1.0.0

package/src/routes/api/notify/+server.ts

@@ -0,0 +1,418 @@
+import { env } from '$env/dynamic/private';
+import { LibraryAPNsService } from '$lib/modules/server/apn/library-apns';
+import { addNotification, getNotifications } from '$lib/modules/server/apn/notification-history';
+import { createPendingRequest } from '$lib/modules/server/apn/pending-requests';
+import { validateAuth } from '$lib/modules/server/auth';
+import { isFCMConfigured, sendFCMNotification } from '$lib/modules/server/fcm/fcm-service.js';
+import { json } from '@sveltejs/kit';
+
+import type { RequestHandler } from './$types';
+
+interface FilterResult {
+  reason: string;
+  send: boolean;
+}
+
+interface NotificationData {
+  [key: string]: unknown;
+  category?: string;
+  files?: string;
+  project?: string;
+  source?: string;
+  tool?: string;
+}
+
+interface NotificationRequest {
+  data?: NotificationData;
+  message: string;
+  title: string;
+  waitForResponse?: boolean;
+}
+
+// Singleton APNs client - reuses HTTP/2 connection across requests
+let apnsSingleton: LibraryAPNsService | null = null;
+function getAPNsClient(): LibraryAPNsService {
+  if (!apnsSingleton) {
+    apnsSingleton = new LibraryAPNsService();
+  }
+  return apnsSingleton;
+}
+
+// NOTIFICATION DEDUPLICATION CACHE
+const notificationCache = new Map<string, number>();
+const DEDUP_WINDOW = 10000; // 10 seconds deduplication window
+
+// 🎯 INTELLIGENT NOTIFICATION FILTERING
+function intelligentNotificationFilter(
+  title: string,
+  message: string,
+  data?: NotificationData
+): FilterResult {
+  const source = data?.source || 'unknown';
+
+  // Check for duplicate notifications first
+  if (isDuplicateNotification(title, message, data)) {
+    return {
+      reason: 'Duplicate notification within 10-second window',
+      send: false,
+    };
+  }
+
+  // Always allow smart completion detector notifications (both old and new naming)
+  if (source === 'smart-completion-detector' || source === 'shooter-completion-detector') {
+    return {
+      reason: 'Smart completion detector - completion or intervention needed',
+      send: true,
+    };
+  }
+
+  // Always allow Stop hook completion notifications
+  if (source === 'stop-hook') {
+    return {
+      reason: 'Stop hook completion notification - session finished',
+      send: true,
+    };
+  }
+
+  // Filter out only very specific spam patterns to be less restrictive
+  const spamPatterns = [
+    /PreToolUse/i, // Any PreToolUse notifications
+    /PostToolUse/i, // Any PostToolUse notifications
+    /^(Read|Write|Edit|Bash)\s+Starting\s*\|\s*\w+$/i, // Only basic tool starting patterns
+    /^unknown\s*\|\s*\w+$/i, // Only "unknown | projectname" exactly
+  ];
+
+  const isSpam = spamPatterns.some((pattern) => pattern.test(title) || pattern.test(message));
+
+  if (isSpam) {
+    return {
+      reason: 'Filtered spam notification from old hook system',
+      send: false,
+    };
+  }
+
+  // Allow explicit completion/intervention notifications
+  const importantPatterns = [
+    /session complete/i,
+    /intervention needed/i,
+    /error/i,
+    /failed/i,
+    /blocked/i,
+    /attention/i,
+  ];
+
+  const isImportant = importantPatterns.some(
+    (pattern) => pattern.test(title) || pattern.test(message)
+  );
+
+  if (isImportant) {
+    return {
+      reason: 'Important notification - completion or intervention',
+      send: true,
+    };
+  }
+
+  // Default: allow all notifications unless explicitly filtered
+  return {
+    reason: 'General notification - allowing by default',
+    send: true,
+  };
+}
+
+function isDuplicateNotification(title: string, message: string, data?: NotificationData): boolean {
+  const key = `${title}|${message}|${data?.category || 'unknown'}`;
+  const now = Date.now();
+
+  if (notificationCache.has(key)) {
+    const lastSent = notificationCache.get(key)!;
+    if (now - lastSent < DEDUP_WINDOW) {
+      return true; // Duplicate within time window
+    }
+  }
+
+  // Clean up old entries
+  for (const [k, v] of notificationCache.entries()) {
+    if (now - v > DEDUP_WINDOW) {
+      notificationCache.delete(k);
+    }
+  }
+
+  // Do NOT record here — caller must call recordNotification() after
+  // successful delivery to avoid cache poisoning on send failure.
+  return false;
+}
+
+/** Record a notification key in the dedup cache after successful delivery. */
+function recordNotification(title: string, message: string, data?: NotificationData): void {
+  const key = `${title}|${message}|${data?.category || 'unknown'}`;
+  notificationCache.set(key, Date.now());
+}
+
+export const POST: RequestHandler = async ({ request }) => {
+  try {
+    // Use singleton APNs client to reuse HTTP/2 connection
+    const apnsClient = getAPNsClient();
+
+    // Validate API key using timing-safe comparison
+    const authError = validateAuth(request);
+    if (authError) return authError;
+
+    // Parse request body
+    const body = (await request.json()) as NotificationRequest;
+    const { data, message, title, waitForResponse } = body;
+
+    if (!title || !message) {
+      return json({ error: 'Title and message are required' }, { status: 400 });
+    }
+
+    // Smart notification filtering
+    const requestId = Math.random().toString(36).substring(2, 15);
+    const dataRequestId = typeof data?.requestId === 'string' ? data.requestId : undefined;
+    const canonicalRequestId = dataRequestId || requestId;
+    const shouldSendNotification = intelligentNotificationFilter(title, message, data);
+
+    if (!shouldSendNotification.send) {
+      addNotification({
+        category: data?.category,
+        data: data as Record<string, unknown>,
+        error: shouldSendNotification.reason,
+        id: canonicalRequestId,
+        message,
+        project: data?.project,
+        source: data?.source,
+        status: 'filtered',
+        timestamp: new Date().toISOString(),
+        title,
+        tool: data?.tool,
+      });
+
+      return json({
+        message: 'Notification filtered (not sent)',
+        reason: shouldSendNotification.reason,
+        success: true,
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    // Build notification payload (shared between APNs and FCM)
+    const payload = {
+      badge: 1,
+      body: message,
+      category: waitForResponse ? 'CLAUDE_PERMISSION' : undefined,
+      data: {
+        ...data,
+        requestId: canonicalRequestId,
+        source: 'modern-apns-api',
+        timestamp: new Date().toISOString(),
+        waitForResponse: waitForResponse || false,
+      },
+      message: null,
+      sound: 'default' as const,
+      title,
+    };
+
+    // Platform-based routing: Android (FCM) or iOS (APNs)
+    const platform = env.DEVICE_PLATFORM || 'ios';
+
+    if (platform === 'android') {
+      // --- FCM (Android) path ---
+      if (!isFCMConfigured()) {
+        return json(
+          {
+            details: 'Missing FCM_PROJECT_ID, FCM_CLIENT_EMAIL, or FCM_PRIVATE_KEY environment variables',
+            error: 'FCM not configured',
+          },
+          { status: 500 }
+        );
+      }
+
+      const androidToken = (env.ANDROID_DEVICE_TOKEN || env.DEVICE_TOKEN)?.trim();
+
+      if (!androidToken) {
+        return json(
+          {
+            details: 'ANDROID_DEVICE_TOKEN or DEVICE_TOKEN environment variable is missing',
+            error: 'No device token configured',
+          },
+          { status: 500 }
+        );
+      }
+
+      const fcmResult = await sendFCMNotification(androidToken, payload);
+
+      if (fcmResult.success) {
+        // Record in dedup cache only after successful delivery
+        recordNotification(title, message, data);
+
+        if (waitForResponse) {
+          createPendingRequest(canonicalRequestId, {
+            sessionId: (data?.sessionId as string) || '',
+            toolInput: (data?.toolInput as Record<string, unknown>) || {},
+            toolName: (data?.toolName as string) || '',
+          });
+        }
+
+        addNotification({
+          category: data?.category,
+          data: data as Record<string, unknown>,
+          id: canonicalRequestId,
+          message,
+          project: data?.project,
+          source: data?.source,
+          status: 'sent',
+          timestamp: new Date().toISOString(),
+          title,
+          tool: data?.tool,
+        });
+
+        return json({
+          message: 'Notification sent successfully',
+          requestId: canonicalRequestId,
+          result: { messageId: fcmResult.messageId },
+          success: true,
+          timestamp: new Date().toISOString(),
+        });
+      } else {
+        console.error(`[notify] FCM delivery failed: ${fcmResult.error}`);
+
+        addNotification({
+          category: data?.category,
+          data: data as Record<string, unknown>,
+          error: fcmResult.error,
+          id: canonicalRequestId,
+          message,
+          project: data?.project,
+          source: data?.source,
+          status: 'failed',
+          timestamp: new Date().toISOString(),
+          title,
+          tool: data?.tool,
+        });
+
+        return json(
+          {
+            details: fcmResult.error,
+            error: 'Failed to send notification',
+            requestId: canonicalRequestId,
+            timestamp: new Date().toISOString(),
+          },
+          { status: 500 }
+        );
+      }
+    } else {
+      // --- APNs (iOS) path ---
+      if (!apnsClient.isConfigured()) {
+        return json(
+          {
+            details: 'Missing APNS_KEY, APNS_KEY_ID, or APNS_TEAM_ID environment variables',
+            error: 'APNs client not configured',
+          },
+          { status: 500 }
+        );
+      }
+
+      const deviceToken = env.DEVICE_TOKEN?.trim();
+
+      if (!deviceToken) {
+        return json(
+          {
+            details: 'DEVICE_TOKEN environment variable is missing',
+            error: 'No device token configured',
+          },
+          { status: 500 }
+        );
+      }
+
+      try {
+        const result = await apnsClient.sendNotification(deviceToken, payload);
+
+        // Record in dedup cache only after successful delivery
+        recordNotification(title, message, data);
+
+        // If this is a bidirectional permission request, store it for polling
+        // only after confirming APNs delivery succeeded
+        if (waitForResponse) {
+          createPendingRequest(canonicalRequestId, {
+            sessionId: (data?.sessionId as string) || '',
+            toolInput: (data?.toolInput as Record<string, unknown>) || {},
+            toolName: (data?.toolName as string) || '',
+          });
+        }
+
+        addNotification({
+          category: data?.category,
+          data: data as Record<string, unknown>,
+          id: canonicalRequestId,
+          message,
+          project: data?.project,
+          source: data?.source,
+          status: 'sent',
+          timestamp: new Date().toISOString(),
+          title,
+          tool: data?.tool,
+        });
+
+        return json({
+          message: 'Notification sent successfully',
+          requestId: canonicalRequestId,
+          result,
+          success: true,
+          timestamp: new Date().toISOString(),
+        });
+      } catch (notificationError) {
+        const err = notificationError as Error;
+        console.error(`[notify] APNs delivery failed: ${err.message}`);
+
+        addNotification({
+          category: data?.category,
+          data: data as Record<string, unknown>,
+          error: err.message,
+          id: canonicalRequestId,
+          message,
+          project: data?.project,
+          source: data?.source,
+          status: 'failed',
+          timestamp: new Date().toISOString(),
+          title,
+          tool: data?.tool,
+        });
+
+        return json(
+          {
+            details: err.message,
+            error: 'Failed to send notification',
+            requestId: canonicalRequestId,
+            timestamp: new Date().toISOString(),
+          },
+          { status: 500 }
+        );
+      }
+    }
+  } catch (error) {
+    const err = error as Error;
+    console.error('Notification error:', err);
+    return json(
+      {
+        details: err.message,
+        error: 'Failed to send notification',
+        timestamp: new Date().toISOString(),
+      },
+      { status: 500 }
+    );
+  }
+};
+
+export const GET: RequestHandler = ({ request, url }) => {
+  // Validate API key using timing-safe comparison
+  const authError = validateAuth(request);
+  if (authError) return authError;
+
+  const limit = parseInt(url.searchParams.get('limit') || '50');
+  const notifications = getNotifications(limit);
+
+  return json({
+    count: notifications.length,
+    notifications,
+    timestamp: new Date().toISOString(),
+  });
+};

package/src/routes/api/qr-config/+server.ts

@@ -0,0 +1,45 @@
+import { env } from '$env/dynamic/private';
+import { validateAuth } from '$lib/modules/server/auth';
+import { json } from '@sveltejs/kit';
+import QRCode from 'qrcode';
+
+import type { RequestHandler } from './$types';
+
+export const GET: RequestHandler = async ({ request }) => {
+	const authError = validateAuth(request);
+	if (authError) {
+		return authError;
+	}
+
+	const apiKey = env.API_KEY?.trim();
+	if (!apiKey) {
+		return json({ error: 'API_KEY not configured on server' }, { status: 500 });
+	}
+
+	// Derive the server URL from the incoming request's Host header so the QR
+	// code always points to the right address (works behind tunnels, proxies, etc.)
+	const proto = request.headers.get('x-forwarded-proto') || 'http';
+	const host = request.headers.get('x-forwarded-host') || request.headers.get('host') || 'localhost:3000';
+	const serverUrl = `${proto}://${host}`;
+
+	const configPayload = JSON.stringify({ apiKey, serverUrl });
+
+	try {
+		const dataUrl = await QRCode.toDataURL(configPayload, {
+			color: {
+				dark: '#ededed',
+				light: '#0a0a0a',
+			},
+			errorCorrectionLevel: 'M',
+			margin: 2,
+			type: 'image/png',
+			width: 280,
+		});
+
+		return json({ dataUrl, serverUrl });
+	} catch (error) {
+		const err = error as Error;
+		console.error('[qr-config] QR generation failed:', err.message);
+		return json({ error: 'Failed to generate QR code' }, { status: 500 });
+	}
+};

package/src/routes/api/response/+server.ts

@@ -0,0 +1,73 @@
+import { cleanup, getDecision, setDecision } from '$lib/modules/server/apn/pending-requests';
+import { validateAuth } from '$lib/modules/server/auth';
+import { json } from '@sveltejs/kit';
+
+import type { RequestHandler } from './$types';
+
+// POST /api/response — iOS app sends the user's decision
+export const POST: RequestHandler = async ({ request }) => {
+  cleanup();
+
+  const authError = validateAuth(request);
+  if (authError) {return authError;}
+
+  let body: { decision?: string; requestId?: string };
+  try {
+    body = (await request.json()) as { decision?: string; requestId?: string };
+  } catch {
+    return json({ error: 'Invalid JSON in request body' }, { status: 400 });
+  }
+
+  try {
+    const { decision, requestId } = body;
+
+    if (!requestId || !decision) {
+      return json({ error: 'requestId and decision are required' }, { status: 400 });
+    }
+
+    if (decision !== 'allow' && decision !== 'deny') {
+      return json({ error: 'decision must be "allow" or "deny"' }, { status: 400 });
+    }
+
+    const found = setDecision(requestId, decision);
+    if (!found) {
+      return json({ error: 'Request not found or expired' }, { status: 404 });
+    }
+
+    console.log(`[response] Decision received: ${decision} for request ${requestId}`);
+
+    return json({
+      message: 'Decision recorded',
+      success: true,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (error) {
+    const err = error as Error;
+    return json({ details: err.message, error: 'Failed to process response' }, { status: 500 });
+  }
+};
+
+// GET /api/response?requestId=xxx — notifier.cjs polls for a decision
+export const GET: RequestHandler = ({ request, url }) => {
+  cleanup();
+
+  const authErr = validateAuth(request);
+  if (authErr) {return authErr;}
+
+  const requestId = url.searchParams.get('requestId');
+  if (!requestId) {
+    return json({ error: 'requestId query parameter is required' }, { status: 400 });
+  }
+
+  const result = getDecision(requestId);
+
+  if (result.status === 'not_found') {
+    return json({ error: 'Request not found or expired' }, { status: 404 });
+  }
+
+  return json({
+    decision: result.decision ?? null,
+    status: result.status,
+    timestamp: new Date().toISOString(),
+  });
+};

package/src/routes/api/sessions/+server.ts

@@ -0,0 +1,120 @@
+import type { ProjectGroup } from '$lib/modules/server/sessions/types';
+
+import { validateAuth } from '$lib/modules/server/auth';
+import {
+  getSessionConversation,
+  listProjectsWithSessions,
+} from '$lib/modules/server/sessions/jsonl-reader';
+import {
+  getOpenCodeConversation,
+  listOpenCodeProjects,
+} from '$lib/modules/server/sessions/opencode-reader';
+import { json } from '@sveltejs/kit';
+
+import type { RequestHandler } from './$types';
+
+// Server-side cache for merged projects (30s TTL)
+let cachedProjects: null | ProjectGroup[] = null;
+let cacheTimestamp = 0;
+const CACHE_TTL_MS = 30_000;
+
+function getMergedProjects(): ProjectGroup[] {
+  const now = Date.now();
+  if (cachedProjects && now - cacheTimestamp < CACHE_TTL_MS) {
+    return cachedProjects;
+  }
+
+  const claudeProjects = listProjectsWithSessions();
+  const openCodeProjects = listOpenCodeProjects();
+  const projectsByPath = new Map<string, ProjectGroup>();
+
+  for (const p of claudeProjects) {
+    projectsByPath.set(p.fullPath, { ...p });
+  }
+
+  for (const op of openCodeProjects) {
+    const existing = projectsByPath.get(op.fullPath);
+    if (existing) {
+      existing.sessions.push(...op.sessions);
+      existing.sessions.sort(
+        (a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime()
+      );
+      existing.sessionCount = existing.sessions.length;
+      existing.lastModified = existing.sessions[0]?.modified || existing.lastModified;
+      existing.name = existing.name.replace(' (OpenCode)', '');
+    } else {
+      op.name = op.name.replace(' (OpenCode)', '');
+      projectsByPath.set(op.fullPath, { ...op });
+    }
+  }
+
+  cachedProjects = [...projectsByPath.values()].sort(
+    (a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+  );
+  cacheTimestamp = now;
+  return cachedProjects;
+}
+
+export const GET: RequestHandler = ({ request, url }) => {
+  const authError = validateAuth(request);
+  if (authError) {return authError;}
+
+  const sessionId = url.searchParams.get('id');
+
+  if (sessionId) {
+    const projectId = url.searchParams.get('project') || '';
+    const offset = parseInt(url.searchParams.get('offset') || '0');
+    const limit = parseInt(url.searchParams.get('limit') || '100');
+
+    // Resolve short project ID to full path for the readers
+    const allProjects = getMergedProjects();
+    const matchedProject = projectId ? allProjects.find((p) => p.id === projectId) : undefined;
+
+    // Try Claude Code first (pass the encoded dir name for filesystem lookup)
+    const claudeProjectDir = matchedProject
+      ? matchedProject.fullPath.replace(/\//g, '-')
+      : undefined;
+    let messages = getSessionConversation(sessionId, offset, limit, claudeProjectDir);
+
+    // If Claude Code reader found nothing, try OpenCode
+    if (messages.length === 0) {
+      messages = getOpenCodeConversation(sessionId, offset, limit);
+    }
+    let sessionInfo = null;
+    for (const project of allProjects) {
+      if (projectId && project.id !== projectId) {
+        continue;
+      }
+      const found = project.sessions.find((s) => s.id === sessionId);
+      if (found) {
+        sessionInfo = found;
+        break;
+      }
+    }
+
+    if (!sessionInfo) {
+      return json({ error: 'Session not found' }, { status: 404 });
+    }
+
+    return json({
+      messages,
+      session: sessionInfo,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  const allProjects = getMergedProjects();
+
+  const limit = parseInt(url.searchParams.get('limit') || '0');
+  const offset = parseInt(url.searchParams.get('offset') || '0');
+
+  const total = allProjects.length;
+  const paginatedProjects = limit > 0 ? allProjects.slice(offset, offset + limit) : allProjects;
+
+  return json({
+    count: allProjects.reduce((sum, p) => sum + p.sessionCount, 0),
+    projects: paginatedProjects,
+    timestamp: new Date().toISOString(),
+    total,
+  });
+};