@juspay/shooter 1.5.0 → 1.6.1

package/src/{generated/types → lib/types/generated}/WsProtocol.ts

@@ -1845,13 +1845,265 @@ export function decodeEventSessionEnded(rawInput: unknown): EventSessionEnded |
   return null;
 }
 
+/**
+ * @type { EventToolStarted }
+ * @description A tool execution has started
+ */
+export type EventToolStarted = {
+  /**
+   * @type { string }
+   * @memberof EventToolStarted
+   */
+  type: string;
+  /**
+   * @description Name of the tool being executed
+   * @type { string }
+   * @memberof EventToolStarted
+   */
+  tool: string;
+  /**
+   * @description Command being executed (for Bash tool)
+   * @type { string }
+   * @memberof EventToolStarted
+   */
+  command: string | null;
+  /**
+   * @description File path being operated on
+   * @type { string }
+   * @memberof EventToolStarted
+   */
+  filePath: string | null;
+  /**
+   * @description Associated terminal identifier
+   * @type { string }
+   * @memberof EventToolStarted
+   */
+  terminalId: string | null;
+};
+
+export function decodeEventToolStarted(rawInput: unknown): EventToolStarted | null {
+  if (isJSON(rawInput)) {
+    const decodedType = decodeString(rawInput['type']);
+    const decodedTool = decodeString(rawInput['tool']);
+    const decodedCommand = decodeString(rawInput['command']);
+    const decodedFilePath = decodeString(rawInput['filePath']);
+    const decodedTerminalId = decodeString(rawInput['terminalId']);
+
+    if (decodedType === null || decodedTool === null) {
+      return null;
+    }
+
+    return {
+      type: decodedType,
+      tool: decodedTool,
+      command: decodedCommand,
+      filePath: decodedFilePath,
+      terminalId: decodedTerminalId,
+    };
+  }
+  return null;
+}
+
+/**
+ * @type { EventToolCompleted }
+ * @description A tool execution has completed
+ */
+export type EventToolCompleted = {
+  /**
+   * @type { string }
+   * @memberof EventToolCompleted
+   */
+  type: string;
+  /**
+   * @description Name of the tool that completed
+   * @type { string }
+   * @memberof EventToolCompleted
+   */
+  tool: string;
+  /**
+   * @description Whether the tool execution succeeded
+   * @type { boolean }
+   * @memberof EventToolCompleted
+   */
+  success: boolean;
+  /**
+   * @description Associated terminal identifier
+   * @type { string }
+   * @memberof EventToolCompleted
+   */
+  terminalId: string | null;
+};
+
+export function decodeEventToolCompleted(rawInput: unknown): EventToolCompleted | null {
+  if (isJSON(rawInput)) {
+    const decodedType = decodeString(rawInput['type']);
+    const decodedTool = decodeString(rawInput['tool']);
+    const decodedSuccess = decodeBoolean(rawInput['success']);
+    const decodedTerminalId = decodeString(rawInput['terminalId']);
+
+    if (decodedType === null || decodedTool === null || decodedSuccess === null) {
+      return null;
+    }
+
+    return {
+      type: decodedType,
+      tool: decodedTool,
+      success: decodedSuccess,
+      terminalId: decodedTerminalId,
+    };
+  }
+  return null;
+}
+
+/**
+ * @type { EventToolFailed }
+ * @description A tool execution has failed
+ */
+export type EventToolFailed = {
+  /**
+   * @type { string }
+   * @memberof EventToolFailed
+   */
+  type: string;
+  /**
+   * @description Name of the tool that failed
+   * @type { string }
+   * @memberof EventToolFailed
+   */
+  tool: string;
+  /**
+   * @description Error message
+   * @type { string }
+   * @memberof EventToolFailed
+   */
+  error: string;
+  /**
+   * @description Associated terminal identifier
+   * @type { string }
+   * @memberof EventToolFailed
+   */
+  terminalId: string | null;
+};
+
+export function decodeEventToolFailed(rawInput: unknown): EventToolFailed | null {
+  if (isJSON(rawInput)) {
+    const decodedType = decodeString(rawInput['type']);
+    const decodedTool = decodeString(rawInput['tool']);
+    const decodedError = decodeString(rawInput['error']);
+    const decodedTerminalId = decodeString(rawInput['terminalId']);
+
+    if (decodedType === null || decodedTool === null || decodedError === null) {
+      return null;
+    }
+
+    return {
+      type: decodedType,
+      tool: decodedTool,
+      error: decodedError,
+      terminalId: decodedTerminalId,
+    };
+  }
+  return null;
+}
+
+/**
+ * @type { EventAgentIdle }
+ * @description The AI agent is idle and waiting
+ */
+export type EventAgentIdle = {
+  /**
+   * @type { string }
+   * @memberof EventAgentIdle
+   */
+  type: string;
+  /**
+   * @description Optional idle message
+   * @type { string }
+   * @memberof EventAgentIdle
+   */
+  message: string | null;
+  /**
+   * @description Associated terminal identifier
+   * @type { string }
+   * @memberof EventAgentIdle
+   */
+  terminalId: string | null;
+};
+
+export function decodeEventAgentIdle(rawInput: unknown): EventAgentIdle | null {
+  if (isJSON(rawInput)) {
+    const decodedType = decodeString(rawInput['type']);
+    const decodedMessage = decodeString(rawInput['message']);
+    const decodedTerminalId = decodeString(rawInput['terminalId']);
+
+    if (decodedType === null) {
+      return null;
+    }
+
+    return {
+      type: decodedType,
+      message: decodedMessage,
+      terminalId: decodedTerminalId,
+    };
+  }
+  return null;
+}
+
+/**
+ * @type { EventAgentQuestion }
+ * @description The AI agent has a question for the user
+ */
+export type EventAgentQuestion = {
+  /**
+   * @type { string }
+   * @memberof EventAgentQuestion
+   */
+  type: string;
+  /**
+   * @description The question being asked
+   * @type { string }
+   * @memberof EventAgentQuestion
+   */
+  message: string;
+  /**
+   * @description Associated terminal identifier
+   * @type { string }
+   * @memberof EventAgentQuestion
+   */
+  terminalId: string | null;
+};
+
+export function decodeEventAgentQuestion(rawInput: unknown): EventAgentQuestion | null {
+  if (isJSON(rawInput)) {
+    const decodedType = decodeString(rawInput['type']);
+    const decodedMessage = decodeString(rawInput['message']);
+    const decodedTerminalId = decodeString(rawInput['terminalId']);
+
+    if (decodedType === null || decodedMessage === null) {
+      return null;
+    }
+
+    return {
+      type: decodedType,
+      message: decodedMessage,
+      terminalId: decodedTerminalId,
+    };
+  }
+  return null;
+}
+
 export type ShooterEvent =
   | CShooterEventEventTerminalCreated
   | CShooterEventEventTerminalExited
   | CShooterEventEventPermissionRequested
   | CShooterEventEventPermissionResolved
   | CShooterEventEventSessionStarted
-  | CShooterEventEventSessionEnded;
+  | CShooterEventEventSessionEnded
+  | CShooterEventEventToolStarted
+  | CShooterEventEventToolCompleted
+  | CShooterEventEventToolFailed
+  | CShooterEventEventAgentIdle
+  | CShooterEventEventAgentQuestion;
 
 export function decodeShooterEvent(rawInput: unknown): ShooterEvent | null {
   const result: ShooterEvent | null =
@@ -1860,7 +2112,12 @@ export function decodeShooterEvent(rawInput: unknown): ShooterEvent | null {
     decodeCShooterEventEventPermissionRequested(rawInput) ??
     decodeCShooterEventEventPermissionResolved(rawInput) ??
     decodeCShooterEventEventSessionStarted(rawInput) ??
-    decodeCShooterEventEventSessionEnded(rawInput);
+    decodeCShooterEventEventSessionEnded(rawInput) ??
+    decodeCShooterEventEventToolStarted(rawInput) ??
+    decodeCShooterEventEventToolCompleted(rawInput) ??
+    decodeCShooterEventEventToolFailed(rawInput) ??
+    decodeCShooterEventEventAgentIdle(rawInput) ??
+    decodeCShooterEventEventAgentQuestion(rawInput);
 
   return result;
 }
@@ -1967,6 +2224,91 @@ export function decodeCShooterEventEventSessionEnded(
   return new CShooterEventEventSessionEnded(result);
 }
 
+export class CShooterEventEventToolStarted {
+  data: EventToolStarted;
+  constructor(data: EventToolStarted) {
+    this.data = data;
+  }
+}
+
+export function decodeCShooterEventEventToolStarted(
+  rawInput: unknown
+): CShooterEventEventToolStarted | null {
+  const result = decodeEventToolStarted(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new CShooterEventEventToolStarted(result);
+}
+
+export class CShooterEventEventToolCompleted {
+  data: EventToolCompleted;
+  constructor(data: EventToolCompleted) {
+    this.data = data;
+  }
+}
+
+export function decodeCShooterEventEventToolCompleted(
+  rawInput: unknown
+): CShooterEventEventToolCompleted | null {
+  const result = decodeEventToolCompleted(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new CShooterEventEventToolCompleted(result);
+}
+
+export class CShooterEventEventToolFailed {
+  data: EventToolFailed;
+  constructor(data: EventToolFailed) {
+    this.data = data;
+  }
+}
+
+export function decodeCShooterEventEventToolFailed(
+  rawInput: unknown
+): CShooterEventEventToolFailed | null {
+  const result = decodeEventToolFailed(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new CShooterEventEventToolFailed(result);
+}
+
+export class CShooterEventEventAgentIdle {
+  data: EventAgentIdle;
+  constructor(data: EventAgentIdle) {
+    this.data = data;
+  }
+}
+
+export function decodeCShooterEventEventAgentIdle(
+  rawInput: unknown
+): CShooterEventEventAgentIdle | null {
+  const result = decodeEventAgentIdle(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new CShooterEventEventAgentIdle(result);
+}
+
+export class CShooterEventEventAgentQuestion {
+  data: EventAgentQuestion;
+  constructor(data: EventAgentQuestion) {
+    this.data = data;
+  }
+}
+
+export function decodeCShooterEventEventAgentQuestion(
+  rawInput: unknown
+): CShooterEventEventAgentQuestion | null {
+  const result = decodeEventAgentQuestion(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new CShooterEventEventAgentQuestion(result);
+}
+
 /**
  * @type { Ticket }
  * @description Short-lived single-use ticket for authenticating WebSocket upgrade requests

package/src/lib/types/index.ts

@@ -0,0 +1,28 @@
+// Type barrel — the ONLY import source for types in this project.
+// All source files must use: import type { Foo } from '$lib/types';
+
+export type * from './activity';
+export type * from './apn';
+export type * from './cli';
+export type * from './common';
+export type * from './dashboard';
+export * from './generated';
+export type * from './neurolink';
+export type * from './server';
+
+export type * from './sessions';
+// Explicit re-exports to resolve conflicts between generated types and the
+// hand-written sessions.ts versions. The generated Sessions module exports
+// wrapper-class variants (CMessagePartTextPart, etc.) with `type: string`
+// instead of string-literal discriminated unions. The sessions.ts versions
+// are the ones callers actually need.
+export type {
+  ConversationMessage,
+  MessagePart,
+  TextPart,
+  ThinkingPart,
+  ToolResultPart,
+  ToolUsePart,
+} from './sessions';
+export type * from './terminal-client';
+export type * from './ws';

package/src/lib/types/neurolink.ts

@@ -0,0 +1,4 @@
+// NeuroLink AI provider types.
+
+/** Supported AI provider identifiers. */
+export type ProviderId = 'anthropic' | 'google-ai' | 'litellm' | 'mistral' | 'openai';

package/src/lib/types/server.ts

@@ -0,0 +1,93 @@
+// Server module types — extracted from terminal/ module files.
+// All terminal server-side type/interface definitions live here.
+//
+// Names are prefixed to avoid collisions with generated types in the
+// barrel (e.g. generated/Holder.ts exports IncomingMessage, OutgoingMessage,
+// WatchedFile; generated/OpenCode.ts exports WatchState).
+
+import type { FSWatcher } from 'chokidar';
+import type WebSocket from 'ws';
+
+import type { HolderClient } from '../modules/server/terminal/holder-client';
+import type { ConversationMessage } from './sessions';
+
+// ── holder-client types ─────────────────────────────────────────────
+
+/** Messages received from the holder process (local ndjson protocol). */
+export type HolderIncomingMessage =
+  | { active: boolean; type: 'activity' }
+  | { code: null | number; signal: null | string; type: 'exit' }
+  | { data: string; type: 'output' }
+  | { data: string; type: 'scrollback' }
+  | { exitCode: null | number; exited: boolean; pid: number; type: 'info' }
+  | { path: string; type: 'cwd' };
+
+/** Messages sent to the holder process (local ndjson protocol). */
+export type HolderOutgoingMessage =
+  | { cols: number; rows: number; type: 'resize' }
+  | { data: string; type: 'input' }
+  | { signal?: string; type: 'kill' };
+
+// ── pty-manager types ───────────────────────────────────────────────
+
+/**
+ * Callback invoked when new JSONL entries are parsed from a watched file.
+ */
+export type OnNewEntries = (entries: ConversationMessage[]) => void;
+
+export interface OpenCodeWatchState {
+  callbacks: Set<(messages: ConversationMessage[]) => void>;
+  /** Set of message IDs we have already emitted, to avoid duplicates. */
+  emittedMessageIds: Set<string>;
+  /** Map of part ID to last-seen time_updated, to detect in-place updates. */
+  emittedPartUpdatedAt: Map<string, number>;
+  intervalHandle: ReturnType<typeof setInterval>;
+  /** Highest time_created we have seen for messages (milliseconds). */
+  lastMessageTime: number;
+  /** Highest time_updated we have seen for parts (milliseconds). */
+  lastPartTime: number;
+  sessionId: string;
+}
+
+// ── session-watcher types ───────────────────────────────────────────
+
+export interface PtyManagedTerminal {
+  args: string[];
+  clients: Set<WebSocket>;
+  cols: number;
+  command: string;
+  createdAt: Date;
+  currentCwd: null | string;
+  cwd: string;
+  exitCode: null | number;
+  exitedAt: Date | null;
+  holderPid: number;
+  id: string;
+  isActive: boolean;
+  openCodeNoopCb: ((messages: ConversationMessage[]) => void) | null;
+  openCodeSessionId: null | string;
+  outputBuffers: Map<WebSocket, PtyOutputBuffer>;
+  pid: number;
+  pollTimer: null | ReturnType<typeof setInterval>;
+  pty: HolderClient;
+  rows: number;
+  scrollback: string;
+  sessionFile: null | string;
+  socketPath: string;
+  status: 'exited' | 'running';
+  watcherOffset: number;
+}
+
+export interface PtyOutputBuffer {
+  data: string[];
+  size: number;
+}
+
+// ── opencode-watcher types ──────────────────────────────────────────
+
+export interface SessionWatchedFile {
+  callbacks: Set<OnNewEntries>;
+  filePath: string;
+  offset: number;
+  watcher: FSWatcher;
+}

package/src/lib/types/sessions.ts

@@ -0,0 +1,59 @@
+// Session and conversation types for Claude Code and OpenCode JSONL parsing.
+// Local interfaces kept here because the generated MessagePart uses wrapper
+// classes and `type: string` instead of the string-literal discriminated unions
+// required at runtime.
+
+import type { MessageRole } from './generated';
+
+/** Internal structure from ~/.claude/sessions/<PID>.json */
+export interface ClaudeSessionFile {
+  cwd: string;
+  entrypoint: string;
+  kind: string;
+  pid: number;
+  sessionId: string;
+  startedAt: number;
+}
+
+export interface ConversationMessage {
+  id: string;
+  parts: MessagePart[];
+  role: MessageRole;
+  timestamp: string;
+}
+
+export interface DetectedProcess {
+  command: 'claude' | 'opencode';
+  cwd: string;
+  kind: string;
+  pid: number;
+  projectPath: string;
+  sessionId: string;
+  startedAt: number;
+}
+
+export type MessagePart = TextPart | ThinkingPart | ToolResultPart | ToolUsePart;
+
+export interface TextPart {
+  content: string;
+  type: 'text';
+}
+
+export interface ThinkingPart {
+  content: string;
+  type: 'thinking';
+}
+
+export interface ToolResultPart {
+  isError: boolean;
+  output: string;
+  toolUseId: string;
+  type: 'tool_result';
+}
+
+export interface ToolUsePart {
+  id: string;
+  input: Record<string, unknown>;
+  toolName: string;
+  type: 'tool_use';
+}

package/src/lib/types/terminal-client.ts

@@ -0,0 +1,132 @@
+import type { FitAddon } from '@xterm/addon-fit';
+import type { Terminal } from '@xterm/xterm';
+
+import type { CreateTerminalResponse } from './generated';
+import type { ConversationMessage, MessagePart, ToolUsePart } from './sessions';
+
+// --- ChatView types ---
+
+export interface ChatViewProps {
+  connectionState?: 'connected' | 'connecting' | 'disconnected' | 'idle' | 'reconnecting';
+  messages: ConversationMessage[];
+  newestFirst?: boolean;
+  onCancel?: () => void;
+  onSendInput?: (text: string) => void;
+  sendDisabled?: boolean;
+  sessionEnded?: boolean;
+  showHeader?: boolean;
+  showInput?: boolean;
+}
+
+export interface Command {
+  action: () => void;
+  label: string;
+}
+
+export interface CommandPaletteProps {
+  commands: Command[];
+  onClose: () => void;
+  open?: boolean;
+}
+
+// --- CommandPalette types ---
+
+export interface ConfigPageData {
+  activeProvider: string;
+  aiProviders: Record<string, boolean>;
+}
+
+export interface ConnectionStatusProps {
+  onretry?: () => void;
+  status: 'connected' | 'disconnected' | 'reconnecting';
+}
+
+// --- ConnectionStatus types ---
+
+export type GroupedPart = MessagePart | ToolGroup;
+
+// --- LaunchSheet types ---
+
+export interface LaunchSheetProps {
+  apiKey: string;
+  onClose: () => void;
+  onLaunch: (response: CreateTerminalResponse) => void;
+  open: boolean;
+}
+
+export interface LayoutData {
+  aiProviders: Record<string, boolean>;
+  neurolinkProvider: string;
+}
+
+// --- QuickKeys types ---
+
+export interface Preset {
+  args: string[];
+  command: string;
+  label: string;
+}
+
+export interface QuickKey {
+  escape: string;
+  label: string;
+}
+
+// --- ShortcutsHelp types ---
+
+export interface QuickKeysProps {
+  onKey: (key: string) => void;
+}
+
+// --- keyboard-shortcuts types ---
+
+export interface ShortcutManagerOptions {
+  onHelp: () => void;
+}
+
+// --- xterm-wrapper types ---
+
+export interface ShortcutsHelpProps {
+  onClose: () => void;
+  open: boolean;
+}
+
+export interface TerminalInstance {
+  dispose: () => void;
+  fitAddon: FitAddon | null;
+  sendInput: (data: string) => void;
+  term: Terminal;
+}
+
+// --- Route-level types ---
+
+export interface TerminalOptions {
+  apiKey?: string;
+  container: HTMLElement;
+  fontSize?: number;
+  getTicket: () => Promise<string>;
+  onActivity?: (active: boolean) => void;
+  onCwd?: (path: string) => void;
+  onDisconnect?: () => void;
+  onExit?: (code: number) => void;
+  onReconnect?: () => void;
+  terminalId?: string;
+  wsUrl: string;
+}
+
+export interface ToolGroup {
+  groupId: string;
+  summary: string;
+  tools: ToolUsePart[];
+  type: 'tool_group';
+}
+
+/** Shape of inbound WebSocket messages received by the terminal client. */
+export interface WsTerminalInboundMessage {
+  active?: boolean;
+  bytes?: number;
+  code?: number;
+  data?: string;
+  path?: string;
+  type: string;
+}