@juspay/shooter 1.16.0 → 1.18.0

package/src/lib/modules/server/sessions/registry.ts

@@ -0,0 +1,178 @@
+/**
+ * Provider registry — the single place that knows every AI-agent provider.
+ *
+ * Inspired by wesm/agentsview's AgentDef registry: instead of branching on
+ * `command === 'claude'` across ~14 call sites, the session API, the connect
+ * route, and the terminal allowlist all derive from this list. Adding a
+ * provider is one entry here (+ its reader) rather than edits everywhere.
+ *
+ * Detection (process-detector) and live watching (server.ts adapter) stay
+ * provider-specific because their mechanisms differ too much to unify cheaply.
+ */
+
+import type { ConversationMessage, ProjectGroup, ProviderDef } from '$lib/types';
+
+import { getAmpConversation, listAmpProjects } from './amp-reader';
+import { getCodexConversation, listCodexProjects } from './codex-reader';
+import { getCopilotConversation, listCopilotProjects } from './copilot-reader';
+import { getCursorConversation, listCursorProjects } from './cursor-reader';
+import { getGeminiConversation, listGeminiProjects } from './gemini-reader';
+import { getSessionConversation, listProjectsWithSessions } from './jsonl-reader';
+import { getOpenCodeConversation, listOpenCodeProjects } from './opencode-reader';
+import { getQwenConversation, listQwenProjects } from './qwen-reader';
+
+/**
+ * Every AI-agent provider, in merge order. `claude-code` MUST stay first: its
+ * projects seed the merge map so the canonical (decoded) project path/name wins
+ * over other providers' guesses.
+ */
+export const PROVIDERS: ProviderDef[] = [
+  {
+    command: 'claude',
+    getConversation: (id, offset, limit) => getSessionConversation(id, offset, limit),
+    isAI: true,
+    label: 'Claude Code',
+    listProjects: listProjectsWithSessions,
+    resumeArgs: (id) => ['--resume', id],
+    source: 'claude-code',
+  },
+  {
+    command: 'opencode',
+    getConversation: getOpenCodeConversation,
+    isAI: true,
+    label: 'OpenCode',
+    listProjects: listOpenCodeProjects,
+    nameSuffix: ' (OpenCode)',
+    resumeArgs: (id) => ['--session', id],
+    source: 'opencode',
+  },
+  {
+    command: 'codex',
+    getConversation: getCodexConversation,
+    isAI: true,
+    label: 'Codex',
+    listProjects: listCodexProjects,
+    resumeArgs: (id) => ['resume', id],
+    source: 'codex',
+  },
+  {
+    command: 'gemini',
+    getConversation: getGeminiConversation,
+    isAI: true,
+    label: 'Gemini',
+    listProjects: listGeminiProjects,
+    resumeArgs: () => [], // Gemini CLI has no session-resume flag
+    source: 'gemini',
+  },
+  {
+    command: 'qwen',
+    getConversation: getQwenConversation,
+    isAI: true,
+    label: 'Qwen',
+    listProjects: listQwenProjects,
+    resumeArgs: () => [],
+    source: 'qwen',
+  },
+  {
+    command: 'cursor-agent',
+    getConversation: getCursorConversation,
+    isAI: true,
+    label: 'Cursor',
+    listProjects: listCursorProjects,
+    resumeArgs: () => [],
+    source: 'cursor',
+  },
+  {
+    command: 'copilot',
+    getConversation: getCopilotConversation,
+    isAI: true,
+    label: 'Copilot',
+    listProjects: listCopilotProjects,
+    resumeArgs: () => [],
+    source: 'copilot',
+  },
+  {
+    command: 'amp',
+    getConversation: getAmpConversation,
+    isAI: true,
+    label: 'Amp',
+    listProjects: listAmpProjects,
+    resumeArgs: () => [],
+    source: 'amp',
+  },
+];
+
+/** AI-agent binary names (for AI_COMMANDS-style checks). */
+export const AI_COMMANDS: string[] = PROVIDERS.filter((p) => p.isAI).map((p) => p.command);
+
+/** All provider binary names (for the terminal allowlist + connect validation). */
+export const PROVIDER_COMMANDS: string[] = PROVIDERS.map((p) => p.command);
+
+/** Resolve a session's conversation across providers (Claude first, with its project dir). */
+export function getProviderConversation(
+  sessionId: string,
+  offset: number,
+  limit: number,
+  claudeProjectDir?: string
+): ConversationMessage[] {
+  const claude = getSessionConversation(sessionId, offset, limit, claudeProjectDir);
+  if (claude.length > 0) {
+    return claude;
+  }
+  for (const provider of PROVIDERS) {
+    if (provider.source === 'claude-code') {
+      continue;
+    }
+    try {
+      const messages = provider.getConversation(sessionId, offset, limit);
+      if (messages.length > 0) {
+        return messages;
+      }
+    } catch {
+      // a failing provider reader must not break resolution — try the next
+    }
+  }
+  return [];
+}
+
+/** Merge every provider's projects, deduplicating by absolute path. */
+export function listAllProviderProjects(): ProjectGroup[] {
+  const byPath = new Map<string, ProjectGroup>();
+  for (const provider of PROVIDERS) {
+    let groups: ProjectGroup[];
+    try {
+      groups = provider.listProjects();
+    } catch {
+      continue; // a broken provider must not take down the whole listing
+    }
+    for (const group of groups) {
+      try {
+        const name =
+          provider.nameSuffix && typeof group.name === 'string'
+            ? group.name.replace(provider.nameSuffix, '')
+            : group.name;
+        const existing = byPath.get(group.fullPath);
+        if (existing) {
+          existing.sessions.push(...group.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;
+        } else {
+          byPath.set(group.fullPath, { ...group, name });
+        }
+      } catch {
+        // skip a malformed group rather than dropping the rest of the provider
+      }
+    }
+  }
+  return [...byPath.values()].sort(
+    (a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+  );
+}
+
+/** Resume args for a launched command (e.g. `codex resume <id>`). */
+export function resumeArgsForCommand(command: string, sessionId: string): string[] {
+  return PROVIDERS.find((p) => p.command === command)?.resumeArgs(sessionId) ?? [];
+}

package/src/lib/modules/server/terminal/codex-watcher.ts

@@ -15,6 +15,7 @@ import { watch as chokidarWatch } from 'chokidar';
 import * as fs from 'fs';
 
 import { CodexStreamParser, parseCodexRollout } from '../sessions/codex-parser';
+import { readBoundedRolloutText } from '../sessions/codex-reader';
 
 /** Flush the open run after this many ms without a write. */
 const IDLE_FLUSH_MS = 1500;
@@ -28,7 +29,9 @@ class CodexWatcher {
       return [];
     }
     try {
-      return parseCodexRollout(fs.readFileSync(filePath, 'utf-8')).messages;
+      // Bounded read — rollout files can be hundreds of MB; this is called on
+      // every WS session connection (mirrors getCodexConversation).
+      return parseCodexRollout(readBoundedRolloutText(filePath)).messages;
     } catch (error) {
       console.error(`[codex-watcher] Failed to read history for ${filePath}:`, error);
       return [];

package/src/lib/modules/server/terminal/generic-session-watcher.ts

@@ -0,0 +1,163 @@
+/**
+ * GenericSessionWatcher — live tailing for the five read-only providers
+ * (cursor, copilot, qwen, gemini, amp).
+ *
+ * The byte-offset watchers (claude/codex) and the SQLite poller (opencode)
+ * each understand one wire format. These five providers store sessions in
+ * heterogeneous shapes — per-turn JSONL for some, a single rewritten JSON
+ * document for others — so a byte-incremental reader would need five bespoke
+ * parsers. Instead this watcher re-parses the whole file on each change via
+ * the shared `parseReadOnlyProviderFile` dispatch and emits only messages
+ * whose ID it has not delivered before. That makes it correct for both
+ * append-only and whole-document-rewrite formats with one code path.
+ *
+ * The public surface (getHistory + ref-counted subscribe) matches
+ * SessionWatcherLike, so the server's session-watcher adapter can route to it
+ * by path without any handler changes.
+ */
+
+import type { ConversationMessage, GenericWatchedFile, OnNewEntries } from '$lib/types';
+
+import { watch as chokidarWatch } from 'chokidar';
+
+import { parseReadOnlyProviderFile } from '../sessions/provider-paths';
+
+class GenericSessionWatcher {
+  private watched = new Map<string, GenericWatchedFile>();
+
+  /** Re-read the whole file and return the full parsed conversation. */
+  getHistory(filePath: string): ConversationMessage[] {
+    return parseReadOnlyProviderFile(filePath);
+  }
+
+  /** Stop watching a single file and release its chokidar handle. */
+  stop(filePath: string): void {
+    const watched = this.watched.get(filePath);
+    if (!watched) {
+      return;
+    }
+    void watched.watcher.close();
+    this.watched.delete(filePath);
+    console.log(`[generic-watcher] Stopped watching: ${filePath}`);
+  }
+
+  /** Stop watching every file. */
+  stopAll(): void {
+    for (const [filePath] of this.watched) {
+      this.stop(filePath);
+    }
+  }
+
+  /**
+   * Subscribe to new messages for a file. Adds the callback to an existing
+   * watcher when one is present (ref-counted), otherwise starts a chokidar
+   * watch. Returns an unsubscribe function that tears the watcher down once
+   * the last subscriber leaves — identical lifecycle to SessionWatcher.
+   */
+  subscribe(filePath: string, onNewEntries: OnNewEntries): () => void {
+    const existing = this.watched.get(filePath);
+    if (existing) {
+      existing.callbacks.add(onNewEntries);
+      return () => {
+        this.removeCallback(filePath, onNewEntries);
+      };
+    }
+
+    // Seed the emitted set with everything already in the file so the first
+    // change only surfaces genuinely new messages — history is sent separately
+    // via getHistory, mirroring the byte watchers' initial-offset behaviour.
+    const emittedMessageIds = new Set<string>();
+    try {
+      for (const msg of parseReadOnlyProviderFile(filePath)) {
+        emittedMessageIds.add(msg.id);
+      }
+    } catch (error) {
+      // Degrade gracefully: an unreadable/racy file at subscribe time must not
+      // prevent watching — the first change will just re-surface what's there.
+      console.error(`[generic-watcher] Failed to seed ${filePath}:`, error);
+    }
+
+    const watcher = chokidarWatch(filePath, {
+      awaitWriteFinish: { pollInterval: 100, stabilityThreshold: 200 },
+      ignoreInitial: true,
+      usePolling: false,
+    });
+
+    const watched: GenericWatchedFile = {
+      callbacks: new Set([onNewEntries]),
+      emittedMessageIds,
+      filePath,
+      watcher,
+    };
+
+    const onChange = (): void => {
+      this.readNew(watched);
+    };
+    watcher.on('add', onChange);
+    watcher.on('change', onChange);
+    watcher.on('error', (error) => {
+      console.error(`[generic-watcher] Error watching ${filePath}:`, error);
+    });
+
+    this.watched.set(filePath, watched);
+    console.log(`[generic-watcher] Watching: ${filePath} (seeded ${emittedMessageIds.size} msgs)`);
+
+    return () => {
+      this.removeCallback(filePath, onNewEntries);
+    };
+  }
+
+  /** Legacy fire-and-forget API matching SessionWatcher.watch(). */
+  watch(filePath: string, onNewEntries: OnNewEntries): void {
+    this.subscribe(filePath, onNewEntries);
+  }
+
+  /**
+   * Re-parse the file and deliver any messages whose ID has not been emitted.
+   * If a rewrite drops the count below what we have seen (truncation/reset),
+   * the new IDs simply won't match, so nothing spurious is sent.
+   */
+  private readNew(watched: GenericWatchedFile): void {
+    let messages: ConversationMessage[];
+    try {
+      messages = parseReadOnlyProviderFile(watched.filePath);
+    } catch (error) {
+      console.error(`[generic-watcher] Failed to re-read ${watched.filePath}:`, error);
+      return;
+    }
+
+    const fresh = messages.filter((msg) => !watched.emittedMessageIds.has(msg.id));
+    if (fresh.length === 0) {
+      return;
+    }
+    for (const msg of fresh) {
+      watched.emittedMessageIds.add(msg.id);
+    }
+    for (const cb of watched.callbacks) {
+      try {
+        cb(fresh);
+      } catch (cbError) {
+        console.error('[generic-watcher] Callback error:', cbError);
+      }
+    }
+  }
+
+  /** Remove one callback; stop watching when none remain. */
+  private removeCallback(filePath: string, onNewEntries: OnNewEntries): void {
+    const watched = this.watched.get(filePath);
+    if (!watched) {
+      return;
+    }
+    watched.callbacks.delete(onNewEntries);
+    if (watched.callbacks.size === 0) {
+      this.stop(filePath);
+    }
+  }
+}
+
+// Single shared instance across module loaders (matches sessionWatcher).
+const GW_GLOBAL_KEY = '__shooter_generic_session_watcher';
+export const genericSessionWatcher: GenericSessionWatcher =
+  ((globalThis as Record<string, unknown>)[GW_GLOBAL_KEY] as GenericSessionWatcher) ||
+  new GenericSessionWatcher();
+(globalThis as Record<string, unknown>)[GW_GLOBAL_KEY] = genericSessionWatcher;

package/src/lib/modules/server/terminal/pty-manager.ts

@@ -13,6 +13,10 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 import { findCodexRolloutForCwd } from '../sessions/codex-reader';
+import {
+  discoverReadOnlyProviderSessionFile,
+  readOnlySourceForCommand,
+} from '../sessions/provider-paths';
 import { broadcastEvent } from '../ws/server.js';
 import { HolderClient } from './holder-client';
 import { openCodeWatcher } from './opencode-watcher';
@@ -1005,6 +1009,53 @@ class PtyManager {
         5 * 60 * 1000
       );
     }
+
+    // For the read-only providers (cursor/copilot/qwen/gemini/amp): poll their
+    // store for a session started after launch and matching this cwd, then set
+    // sessionFile to that path. The WS adapter routes it to the generic watcher
+    // by its provider-root path, giving the same live-tail the JSONL watchers
+    // provide for Claude/Codex.
+    const readOnlySource = readOnlySourceForCommand(command);
+    if (readOnlySource) {
+      const launchTime = terminal.createdAt.getTime();
+      terminal.pollTimer = setInterval(() => {
+        if (terminal.status === 'exited' || terminal.sessionFile) {
+          if (terminal.pollTimer) {
+            clearInterval(terminal.pollTimer);
+            terminal.pollTimer = null;
+          }
+          return;
+        }
+        try {
+          const file = discoverReadOnlyProviderSessionFile(
+            readOnlySource,
+            cwd,
+            launchTime,
+            Date.now()
+          );
+          if (file) {
+            terminal.sessionFile = file;
+            if (terminal.pollTimer) {
+              clearInterval(terminal.pollTimer);
+              terminal.pollTimer = null;
+            }
+            terminalStore.update(id, { sessionFile: file });
+          }
+        } catch {
+          // ignore filesystem errors
+        }
+      }, 2000);
+
+      setTimeout(
+        () => {
+          if (terminal.pollTimer) {
+            clearInterval(terminal.pollTimer);
+            terminal.pollTimer = null;
+          }
+        },
+        5 * 60 * 1000
+      );
+    }
   }
 
   /** Wire up all HolderClient callbacks (activity, CWD, output, exit, disconnect). */

package/src/lib/modules/server/ws/session-handler.ts

@@ -22,6 +22,8 @@ import type { WebSocket } from 'ws';
 import * as fs from 'fs';
 import * as path from 'path';
 
+import { findCodexRolloutById } from '../sessions/codex-reader';
+
 // ── Module-level references ──────────────────────────────────────────
 
 let _ptyManager: null | PtyManagerLike = null;
@@ -171,34 +173,36 @@ function conversationToLive(msg: ConversationMessage): ServerMessage[] {
  * Returns the absolute path if found, or null.
  */
 function findJsonlFileForSession(sessionId: string): null | string {
-  const claudeProjectsDir = path.join(process.env.HOME || '', '.claude', 'projects');
-
-  if (!fs.existsSync(claudeProjectsDir)) {
+  // Reject anything that could traverse out of the session directories before
+  // it is interpolated into a filesystem path.
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) {
     return null;
   }
 
-  try {
-    const projectDirs = fs.readdirSync(claudeProjectsDir);
-    for (const dir of projectDirs) {
-      const fullDir = path.join(claudeProjectsDir, dir);
-      try {
-        if (!fs.statSync(fullDir).isDirectory()) {
+  const claudeProjectsDir = path.join(process.env.HOME || '', '.claude', 'projects');
+  if (fs.existsSync(claudeProjectsDir)) {
+    try {
+      for (const dir of fs.readdirSync(claudeProjectsDir)) {
+        const fullDir = path.join(claudeProjectsDir, dir);
+        try {
+          if (!fs.statSync(fullDir).isDirectory()) {
+            continue;
+          }
+        } catch {
           continue;
         }
-      } catch {
-        continue;
-      }
-
-      const jsonlPath = path.join(fullDir, `${sessionId}.jsonl`);
-      if (fs.existsSync(jsonlPath)) {
-        return jsonlPath;
+        const jsonlPath = path.join(fullDir, `${sessionId}.jsonl`);
+        if (fs.existsSync(jsonlPath)) {
+          return jsonlPath;
+        }
       }
+    } catch {
+      // Ignore filesystem errors
     }
-  } catch {
-    // Ignore filesystem errors
   }
 
-  return null;
+  // Fall back to an external Codex session: ~/.codex/sessions/**/rollout-*-<id>.jsonl
+  return findCodexRolloutById(sessionId);
 }
 
 // ── Helpers ──────────────────────────────────────────────────────────
@@ -218,7 +222,17 @@ function findTerminalBySessionUuid(uuid: string): ManagedTerminal | undefined {
   // module-level _ptyManagerFull reference if available.
   if (_ptyManagerFull) {
     for (const t of _ptyManagerFull.list()) {
-      if (t.sessionFile?.includes(`${uuid}.jsonl`)) {
+      // Match across every provider's file naming so a running non-Claude
+      // agent can be reached (and replied to) by its session UUID:
+      //   claude/cursor/qwen: <uuid>.jsonl ; codex: -<uuid>.jsonl ;
+      //   copilot: <uuid>.jsonl OR <uuid>/events.jsonl ; amp: T-<uuid>.json ;
+      //   opencode: bare session id.
+      if (
+        t.sessionFile?.includes(`${uuid}.jsonl`) ||
+        t.sessionFile?.endsWith(`/${uuid}/events.jsonl`) ||
+        t.sessionFile?.endsWith(`/T-${uuid}.json`) ||
+        t.openCodeSessionId === uuid
+      ) {
         return _ptyManager.getTerminal(t.id);
       }
     }

package/src/lib/theme.css

@@ -526,6 +526,38 @@
   --pill-cursor: inherit;
 }
 
+/* Additional providers reuse the existing colour families (cosmetic only). */
+.pill-source-qwen {
+  --pill-background: var(--ds-red-100);
+  --pill-color: var(--ds-red-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-red-100);
+  --pill-hover-color: var(--ds-red-900);
+  --pill-cursor: inherit;
+}
+
+.pill-source-cursor {
+  --pill-background: var(--ds-blue-100);
+  --pill-color: var(--ds-blue-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-blue-100);
+  --pill-hover-color: var(--ds-blue-900);
+  --pill-cursor: inherit;
+}
+
+.pill-source-copilot,
+.pill-source-amp {
+  --pill-background: var(--ds-amber-100);
+  --pill-color: var(--ds-amber-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-amber-100);
+  --pill-hover-color: var(--ds-amber-900);
+  --pill-cursor: inherit;
+}
+
 /* ===== Icon Sizes ===== */
 .icon-14 {
   --icon-width: 14px;

package/src/lib/types/gemini.ts

@@ -0,0 +1,100 @@
+// Gemini CLI session types (hand-written: the on-disk formats are
+// provider-specific and not worth round-tripping through the YAML codegen).
+// Gemini CLI stores user messages in ~/.gemini/tmp/<projectHash>/logs.json
+// and full conversation records in
+// ~/.gemini/tmp/<projectHash>/chats/session-*.json (newer versions only).
+
+// ---------------------------------------------------------------------------
+// logs.json — user-messages-only format (all versions)
+// ---------------------------------------------------------------------------
+
+/** Union of all part shapes that appear in a ConversationRecord message. */
+export type GeminiContentPart = GeminiFunctionCallPart | GeminiTextPart | GeminiThoughtPart;
+
+// ---------------------------------------------------------------------------
+// chats/session-*.json — full ConversationRecord (newer versions)
+// ---------------------------------------------------------------------------
+
+/** Full conversation record stored in chats/session-*.json. */
+export interface GeminiConversationRecord {
+  directories?: string[];
+  kind?: 'main' | 'subagent';
+  lastUpdated: string;
+  messages: GeminiMessageRecord[];
+  projectHash: string;
+  sessionId: string;
+  startTime: string;
+  summary?: string;
+}
+
+/** Inline function-call part from the Google GenAI SDK. */
+export interface GeminiFunctionCallPart {
+  functionCall: {
+    args: Record<string, unknown>;
+    id?: string;
+    name: string;
+  };
+}
+
+/** A single entry in ~/.gemini/tmp/<projectHash>/logs.json. */
+export interface GeminiLogEntry {
+  message: string;
+  messageId: number;
+  sessionId: string;
+  timestamp: string;
+  type: 'user';
+}
+
+/** A single message record in a full ConversationRecord. */
+export type GeminiMessageRecord =
+  | {
+      content: GeminiContentPart[] | string;
+      id: string;
+      thoughts?: GeminiThoughtSummary[];
+      timestamp: string;
+      toolCalls?: GeminiToolCallRecord[];
+      type: 'gemini';
+    }
+  | {
+      content: GeminiContentPart[] | string;
+      id: string;
+      timestamp: string;
+      type: 'error' | 'info' | 'user' | 'warning';
+    };
+
+/** Contents of ~/.gemini/projects.json (present only in newer gemini-cli). */
+export type GeminiProjectsJson = Record<string, string>;
+
+/** Plain-text content part from the Google GenAI SDK. */
+export interface GeminiTextPart {
+  text: string;
+  thought?: false;
+}
+
+/** Inline thinking/reasoning part from the Google GenAI SDK. */
+export interface GeminiThoughtPart {
+  text: string;
+  thought: true;
+}
+
+/** A thought-summary entry attached to a 'gemini'-type message. */
+export interface GeminiThoughtSummary {
+  summary?: string;
+  timestamp: string;
+}
+
+// ---------------------------------------------------------------------------
+// projects.json — project slug → absolute path registry (newer versions)
+// ---------------------------------------------------------------------------
+
+/** A single tool-call record attached to a 'gemini'-type message. */
+export interface GeminiToolCallRecord {
+  args: Record<string, unknown>;
+  description?: string;
+  displayName?: string;
+  id: string;
+  name: string;
+  result?: unknown;
+  status: 'cancelled' | 'error' | 'pending' | 'success';
+  timestamp: string;
+}

package/src/lib/types/generated/Sessions.ts

@@ -14,7 +14,15 @@ import {
  * @type { SessionSource }
  * @description Source tool that produced the session
  */
-export type SessionSource = 'claude-code' | 'opencode' | 'codex' | 'gemini';
+export type SessionSource =
+  | 'claude-code'
+  | 'opencode'
+  | 'codex'
+  | 'gemini'
+  | 'qwen'
+  | 'cursor'
+  | 'copilot'
+  | 'amp';
 
 export function decodeSessionSource(rawInput: unknown): SessionSource | null {
   switch (rawInput) {
@@ -22,6 +30,10 @@ export function decodeSessionSource(rawInput: unknown): SessionSource | null {
     case 'opencode':
     case 'codex':
     case 'gemini':
+    case 'qwen':
+    case 'cursor':
+    case 'copilot':
+    case 'amp':
       return rawInput;
   }
   return null;
@@ -33,6 +45,10 @@ export function _decodeSessionSource(rawInput: unknown): SessionSource | undefin
     case 'opencode':
     case 'codex':
     case 'gemini':
+    case 'qwen':
+    case 'cursor':
+    case 'copilot':
+    case 'amp':
       return rawInput;
   }
   return;