@juspay/shooter 1.0.0

package/src/lib/modules/server/cli/index.ts

@@ -0,0 +1,79 @@
+import type { Options as CLIOptions } from '$generated/types';
+
+export { CLIRunner, createRunner, sleep } from './runner';
+export type { ExitCallback, OutputCallback } from './runner';
+
+// Types generated by type-crafter
+export type { CLIOptions };
+
+// Types not yet generated by type-crafter (contain $ref/arrays)
+// TODO: Remove these once type-crafter generates them
+export interface CLICommand {
+  args: string[];
+  name: string;
+  options: CLIOptions;
+}
+
+export interface CLIResult {
+  error: null | string;
+  exitCode: number;
+  output: null | string;
+  success: boolean;
+}
+
+export interface CLIRunnerConfig {
+  args: null | string[];
+  cols: null | number;
+  command: string;
+  cwd: null | string;
+  rows: null | number;
+  useLoginShell: boolean | null;
+}
+
+const DEFAULT_OPTIONS: CLIOptions = {
+  dryRun: false,
+  timeout: null,
+  verbose: false,
+};
+
+export function createCommand(name: string, args: string[] = []): CLICommand {
+  return {
+    args,
+    name,
+    options: { ...DEFAULT_OPTIONS },
+  };
+}
+
+export function createErrorResult(error: string, exitCode = 1): CLIResult {
+  return {
+    error,
+    exitCode,
+    output: null,
+    success: false,
+  };
+}
+
+export function createSuccessResult(output: string): CLIResult {
+  return {
+    error: null,
+    exitCode: 0,
+    output,
+    success: true,
+  };
+}
+
+export function formatCommand(command: CLICommand): string {
+  const parts = [command.name, ...command.args];
+  return parts.join(' ');
+}
+
+export function withOptions(command: CLICommand, options: Partial<CLIOptions>): CLICommand {
+  return {
+    ...command,
+    options: {
+      dryRun: options.dryRun !== undefined ? options.dryRun : command.options.dryRun,
+      timeout: options.timeout !== undefined ? options.timeout : command.options.timeout,
+      verbose: options.verbose !== undefined ? options.verbose : command.options.verbose,
+    },
+  };
+}

package/src/lib/modules/server/cli/runner.ts

@@ -0,0 +1,162 @@
+import pty, { type IPty } from 'node-pty';
+
+import type { CLIRunnerConfig } from './index';
+
+export type ExitCallback = (code: number, signal?: number) => void;
+export type OutputCallback = (data: string) => void;
+
+interface InternalConfig {
+  args: string[];
+  cols: number;
+  command: string;
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  rows: number;
+  useLoginShell: boolean;
+}
+
+export class CLIRunner {
+  private config: InternalConfig;
+  private onExitCallback: ExitCallback | null = null;
+  private onOutputCallback: null | OutputCallback = null;
+  private process: IPty | null = null;
+
+  constructor(config: CLIRunnerConfig) {
+    this.config = {
+      args: config.args ?? [],
+      cols: config.cols ?? 80,
+      command: config.command,
+      cwd: config.cwd ?? process.cwd(),
+      env: process.env,
+      rows: config.rows ?? 30,
+      useLoginShell: config.useLoginShell ?? true,
+    };
+  }
+
+  ctrlC(): this {
+    return this.write('\x03');
+  }
+
+  ctrlD(): this {
+    return this.write('\x04');
+  }
+
+  ctrlZ(): this {
+    return this.write('\x1a');
+  }
+
+  enter(): this {
+    return this.write('\r');
+  }
+
+  escape(): this {
+    return this.write('\x1b');
+  }
+
+  isRunning(): boolean {
+    return this.process !== null;
+  }
+
+  moveDown(): this {
+    return this.write('\x1b[B');
+  }
+
+  moveLeft(): this {
+    return this.write('\x1b[D');
+  }
+
+  moveRight(): this {
+    return this.write('\x1b[C');
+  }
+
+  moveUp(): this {
+    return this.write('\x1b[A');
+  }
+
+  onExit(callback: ExitCallback): this {
+    this.onExitCallback = callback;
+    return this;
+  }
+
+  onOutput(callback: OutputCallback): this {
+    this.onOutputCallback = callback;
+    return this;
+  }
+
+  resize(cols: number, rows: number): this {
+    this.process?.resize(cols, rows);
+    return this;
+  }
+
+  space(): this {
+    return this.write(' ');
+  }
+
+  start(): this {
+    if (this.process) {
+      throw new Error('Process already running');
+    }
+
+    const { args, cols, command, cwd, env, rows, useLoginShell } = this.config;
+
+    if (useLoginShell) {
+      const shell = process.env.SHELL || '/bin/zsh';
+      const shellEscape = (arg: string): string => `'${arg.replace(/'/g, "'\\''")}'`;
+      const fullCommand = [command, ...args].map(shellEscape).join(' ');
+      this.process = pty.spawn(shell, ['-l', '-c', fullCommand], {
+        cols,
+        cwd,
+        env,
+        name: 'xterm-color',
+        rows,
+      });
+    } else {
+      this.process = pty.spawn(command, args, {
+        cols,
+        cwd,
+        env,
+        name: 'xterm-color',
+        rows,
+      });
+    }
+
+    this.process.onData((data) => {
+      this.onOutputCallback?.(data);
+    });
+
+    this.process.onExit(({ exitCode, signal }) => {
+      this.onExitCallback?.(exitCode, signal);
+      this.process = null;
+    });
+
+    return this;
+  }
+
+  stop(): void {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+  }
+
+  tab(): this {
+    return this.write('\t');
+  }
+
+  type(text: string): this {
+    return this.write(text);
+  }
+
+  write(data: string): this {
+    this.process?.write(data);
+    return this;
+  }
+}
+
+export function createRunner(config: CLIRunnerConfig): CLIRunner {
+  return new CLIRunner(config);
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/lib/modules/server/fcm/fcm-service.ts

@@ -0,0 +1,72 @@
+import admin from 'firebase-admin';
+
+import type { NotificationPayload } from '../apn/types.js';
+
+let app: admin.app.App | null = null;
+
+export function isFCMConfigured(): boolean {
+  return !!(
+    process.env.FCM_PROJECT_ID &&
+    process.env.FCM_CLIENT_EMAIL &&
+    process.env.FCM_PRIVATE_KEY
+  );
+}
+
+export async function sendFCMNotification(
+  deviceToken: string,
+  payload: NotificationPayload
+): Promise<{ error?: string; messageId?: string; success: boolean }> {
+  try {
+    const fcmApp = getApp();
+
+    // Use DATA-ONLY messages (not notification messages)
+    // This is critical: notification messages are auto-displayed by Android
+    // and cannot have custom action buttons. Data messages always reach
+    // onMessageReceived() giving the app full control.
+    const message: admin.messaging.Message = {
+      android: {
+        priority: 'high', // Ensures delivery even in Doze mode
+        ttl: 300000, // 5 minutes TTL (matches pending request expiry)
+      },
+      data: {
+        body: payload.body || payload.message || '',
+        category: payload.category ? String(payload.category) : (payload.data?.category ? String(payload.data.category) : ''),
+        project: payload.data?.project ? String(payload.data.project) : '',
+        requestId: payload.data?.requestId ? String(payload.data.requestId) : '',
+        source: payload.data?.source ? String(payload.data.source) : '',
+        timestamp: new Date().toISOString(),
+        title: payload.title,
+        toolInput: payload.data?.toolInput ? JSON.stringify(payload.data.toolInput) : '',
+        toolName: payload.data?.toolName ? String(payload.data.toolName) : '',
+        type: payload.data?.type ? String(payload.data.type) : '',
+      },
+      token: deviceToken,
+    };
+
+    const messageId = await admin.messaging(fcmApp).send(message);
+    return { messageId, success: true };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('[FCM] Send failed:', errorMessage);
+    return { error: errorMessage, success: false };
+  }
+}
+
+function getApp(): admin.app.App {
+  if (!app) {
+    const projectId = process.env.FCM_PROJECT_ID;
+    const clientEmail = process.env.FCM_CLIENT_EMAIL;
+    const privateKey = process.env.FCM_PRIVATE_KEY?.replace(/\\n/g, '\n');
+
+    if (!projectId || !clientEmail || !privateKey) {
+      throw new Error(
+        'FCM not configured: missing FCM_PROJECT_ID, FCM_CLIENT_EMAIL, or FCM_PRIVATE_KEY'
+      );
+    }
+
+    app = admin.initializeApp({
+      credential: admin.credential.cert({ clientEmail, privateKey, projectId }),
+    });
+  }
+  return app;
+}

package/src/lib/modules/server/sessions/jsonl-parser.ts

@@ -0,0 +1,197 @@
+/**
+ * Shared JSONL parsing utilities for Claude Code session files.
+ *
+ * Both the REST API (jsonl-reader.ts) and the live file watcher
+ * (session-watcher.ts) use these functions to convert raw JSONL lines
+ * into ConversationMessage objects. Keeping one canonical parser
+ * eliminates drift between the two code paths.
+ */
+
+import type { ConversationMessage, MessagePart } from './types';
+
+/**
+ * Internal event types that should be skipped during parsing.
+ * These are control/metadata entries that don't represent conversation content.
+ */
+export const SKIP_EVENT_TYPES = new Set([
+  'system',
+  'config',
+  'summary',
+  'result',
+  'heartbeat',
+  'metadata',
+]);
+
+/**
+ * Parse a single assistant content block into a MessagePart.
+ */
+export function parseAssistantBlock(block: Record<string, unknown>): MessagePart | null {
+  if (!block || typeof block !== 'object') {
+    return null;
+  }
+
+  switch (block.type) {
+    case 'text':
+      return { content: (block.text as string) || '', type: 'text' };
+    case 'thinking':
+      return { content: (block.thinking as string) || '', type: 'thinking' };
+    case 'tool_use':
+      return {
+        id: (block.id as string) || '',
+        input: (block.input as Record<string, unknown>) || {},
+        toolName: (block.name as string) || 'Unknown',
+        type: 'tool_use',
+      };
+    default:
+      return null;
+  }
+}
+
+/**
+ * Parse a single JSONL line into zero or more ConversationMessage entries.
+ *
+ * For assistant entries, partial accumulation is handled by the caller
+ * using the assistantTurns map. When an assistant entry includes a
+ * stop_reason, the accumulated turn is flushed into assistantCompleted.
+ */
+export function parseJsonlLine(
+  line: string,
+  assistantTurns: Map<string, { parts: MessagePart[]; timestamp: string }>,
+  messageIndex: number
+): { assistantCompleted: ConversationMessage[]; messages: ConversationMessage[] } {
+  const messages: ConversationMessage[] = [];
+  const assistantCompleted: ConversationMessage[] = [];
+
+  const entry = JSON.parse(line);
+  const entryType = entry.type;
+
+  // Skip known internal event types that don't represent conversation content
+  if (SKIP_EVENT_TYPES.has(entryType)) {
+    return { assistantCompleted, messages };
+  }
+
+  if (entryType === 'user') {
+    const msg = entry.message;
+    if (!msg?.content) {
+      return { assistantCompleted, messages };
+    }
+
+    const parts: MessagePart[] = [];
+    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+
+    for (const block of content) {
+      if (typeof block === 'string') {
+        parts.push({ content: block, type: 'text' });
+      } else if (block.type === 'text') {
+        parts.push({ content: block.text || '', type: 'text' });
+      } else if (block.type === 'tool_result') {
+        let output = '';
+        if (typeof block.content === 'string') {
+          output = block.content;
+        } else if (Array.isArray(block.content)) {
+          output = block.content
+            .filter((c: { type: string }) => c.type === 'text')
+            .map((c: { text: string }) => c.text)
+            .join('\n');
+        }
+        if (entry.toolUseResult?.content) {
+          const trc = entry.toolUseResult.content;
+          if (typeof trc === 'string') {
+            output = trc;
+          } else if (Array.isArray(trc)) {
+            output = trc
+              .filter((c: { type: string }) => c.type === 'text')
+              .map((c: { text: string }) => c.text)
+              .join('\n');
+          }
+        }
+        parts.push({
+          isError: block.is_error || false,
+          output: output.slice(0, 2000),
+          toolUseId: block.tool_use_id || '',
+          type: 'tool_result',
+        });
+      }
+    }
+
+    if (parts.length > 0 && parts.some((p) => p.type === 'text')) {
+      messages.push({
+        id: entry.uuid || `user-${messageIndex}`,
+        parts: parts.filter((p) => p.type === 'text'),
+        role: 'user',
+        timestamp: entry.timestamp || '',
+      });
+    }
+
+    const toolResults = parts.filter((p) => p.type === 'tool_result');
+    if (toolResults.length > 0) {
+      messages.push({
+        id: `tool-result-${entry.uuid || messageIndex}`,
+        parts: toolResults,
+        role: 'system',
+        timestamp: entry.timestamp || '',
+      });
+    }
+  } else if (entryType === 'assistant') {
+    const msg = entry.message;
+    if (!msg?.content) {
+      return { assistantCompleted, messages };
+    }
+
+    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+    const msgId = msg.id || entry.uuid;
+
+    for (const block of content) {
+      const part = parseAssistantBlock(block);
+      if (!part) {
+        continue;
+      }
+
+      if (!assistantTurns.has(msgId)) {
+        assistantTurns.set(msgId, { parts: [], timestamp: entry.timestamp || '' });
+      }
+      assistantTurns.get(msgId)!.parts.push(part);
+    }
+
+    if (msg.stop_reason) {
+      const turn = assistantTurns.get(msgId);
+      if (turn && turn.parts.length > 0) {
+        assistantCompleted.push({
+          id: msgId,
+          parts: turn.parts,
+          role: 'assistant',
+          timestamp: turn.timestamp,
+        });
+        assistantTurns.delete(msgId);
+      }
+    }
+  }
+
+  return { assistantCompleted, messages };
+}
+
+/**
+ * Parse raw JSONL text into ConversationMessage entries.
+ * Handles multi-entry assistant turns that span multiple JSONL lines.
+ */
+export function parseJsonlText(
+  text: string,
+  assistantTurns: Map<string, { parts: MessagePart[]; timestamp: string }>,
+  startIndex: number
+): ConversationMessage[] {
+  const lines = text.split('\n').filter((line) => line.trim());
+  const allMessages: ConversationMessage[] = [];
+  let idx = startIndex;
+
+  for (const line of lines) {
+    try {
+      const { assistantCompleted, messages } = parseJsonlLine(line, assistantTurns, idx);
+      allMessages.push(...messages, ...assistantCompleted);
+      idx++;
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return allMessages;
+}