@juspay/shooter 1.0.0 → 1.2.0

package/src/generated/types/index.ts

@@ -1,6 +1,12 @@
+export * from './JWT';
 export * from './APN';
-export * from './Apn';
 export * from './CLI';
-export * from './Cli';
-export * from './JWT';
 export * from './Terminal';
+export * from './Sessions';
+export * from './API';
+export * from './WsProtocol';
+export * from './Holder';
+export * from './OpenCode';
+export * from './Notification';
+export * from './Client';
+export * from './Config';

package/src/lib/env.ts

@@ -0,0 +1,29 @@
+// Side-effect module: loads .env before any other imports.
+// Must be imported first in server.ts.
+//
+// Resolution order:
+// 1. $SHOOTER_HOME/.env  (if SHOOTER_HOME is set and file exists)
+// 2. .env in cwd         (dotenv default)
+// 3. ~/.shooter/.env     (final fallback — setup.cjs writes here)
+import { config } from 'dotenv';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const shooterHome = process.env.SHOOTER_HOME || '';
+const envPath = shooterHome ? join(shooterHome, '.env') : undefined;
+
+if (envPath && existsSync(envPath)) {
+  // 1. SHOOTER_HOME/.env
+  config({ path: envPath });
+} else {
+  // 2. .env in cwd (dotenv default — only populates vars not already set)
+  config();
+
+  // 3. ~/.shooter/.env as final fallback
+  const fallbackPath = join(homedir(), '.shooter', '.env');
+  if (existsSync(fallbackPath)) {
+    // override: false ensures cwd .env values take precedence
+    config({ override: false, path: fallbackPath });
+  }
+}

package/src/lib/modules/client/common/cache.ts

@@ -1,10 +1,18 @@
 /**
  * Shared sessionStorage cache helpers.
  *
- * Default TTL is 30 seconds. Callers may override per-call.
+ * Default TTL is 5 seconds. Callers may override per-call.
  */
 
-const DEFAULT_TTL_MS = 30_000;
+const DEFAULT_TTL_MS = 5_000;
+
+export function clearCache(key: string): void {
+  try {
+    sessionStorage.removeItem(key);
+  } catch {
+    // ignore
+  }
+}
 
 export function getCached(key: string, ttlMs: number = DEFAULT_TTL_MS): unknown {
   try {

package/src/lib/modules/client/common/config-guard.ts

@@ -1,10 +1,11 @@
 /**
  * Type guard for ShooterConfig objects stored in localStorage.
  *
- * The stricter variant (used on the config page) validates that apiKey
- * and deviceToken are strings. The simpler variant only checks key
- * presence. This implementation uses the stricter check so all
- * consumers benefit from the extra safety.
+ * Validates that the required apiKey field is a non-empty string.
+ * All other fields (deviceToken, serverUrl, lastUpdated) are nullable
+ * in the generated ShooterConfig type, so any parsed object with a
+ * valid apiKey is treated as a full ShooterConfig (missing nullable
+ * fields default to null at runtime).
  */
 
 import type { ShooterConfig } from '$lib/types/config';
@@ -14,5 +15,36 @@ export function isShooterConfig(value: unknown): value is ShooterConfig {
     return false;
   }
   const obj = value as Record<string, unknown>;
-  return typeof obj.apiKey === 'string' && typeof obj.deviceToken === 'string';
+  if (typeof obj.apiKey !== 'string' || obj.apiKey.length === 0) {
+    return false;
+  }
+  // Validate nullable fields are string | null | undefined (reject numbers, booleans, etc.)
+  if (
+    obj.deviceToken !== undefined &&
+    obj.deviceToken !== null &&
+    typeof obj.deviceToken !== 'string'
+  ) {
+    return false;
+  }
+  if (obj.serverUrl !== undefined && obj.serverUrl !== null && typeof obj.serverUrl !== 'string') {
+    return false;
+  }
+  if (
+    obj.lastUpdated !== undefined &&
+    obj.lastUpdated !== null &&
+    typeof obj.lastUpdated !== 'string'
+  ) {
+    return false;
+  }
+  // Normalize nullable fields so the value satisfies ShooterConfig at runtime
+  if (obj.deviceToken === undefined) {
+    obj.deviceToken = null;
+  }
+  if (obj.serverUrl === undefined) {
+    obj.serverUrl = null;
+  }
+  if (obj.lastUpdated === undefined) {
+    obj.lastUpdated = null;
+  }
+  return true;
 }

package/src/lib/modules/client/common/error.ts

@@ -0,0 +1,10 @@
+/** Extract a human-readable message from an unknown thrown value. */
+export function toErrorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === 'string') {
+    return err;
+  }
+  return String(err);
+}

package/src/lib/modules/client/common/index.ts

@@ -1,12 +1,13 @@
+// Shared client utilities
+export { clearCache, getCached, setCache } from './cache';
 export { default as Card } from './Card.svelte';
+export { isShooterConfig } from './config-guard';
 export { default as EmptyState } from './EmptyState.svelte';
-export { default as Icon } from './Icon.svelte';
-export { default as StatusBadge } from './StatusBadge.svelte';
+export { toErrorMessage } from './error';
 
-// Shared client utilities
-export { getCached, setCache } from './cache';
-export { isShooterConfig } from './config-guard';
+export { default as Icon } from './Icon.svelte';
 export { renderMarkdown } from './markdown';
 export { hasScanner, isNativeBridge, scanQR } from './native-bridge';
+export { default as StatusBadge } from './StatusBadge.svelte';
 export { formatRelativeTime } from './time';
 export { getToolDescription } from './tool-title';

package/src/lib/modules/client/common/markdown.ts

@@ -14,10 +14,31 @@ marked.setOptions({
   gfm: true,
 });
 
+// Memoize rendered markdown to avoid re-parsing identical strings
+const markdownCache = new Map<string, string>();
+const MAX_CACHE_SIZE = 500;
+
 export function renderMarkdown(text: string): string {
   if (!text) {
     return '';
   }
+
+  const cached = markdownCache.get(text);
+  if (cached !== undefined) {
+    return cached;
+  }
+
   const html = marked.parse(text) as string;
-  return DOMPurify.sanitize(html);
+  const result = DOMPurify.sanitize(html);
+
+  // Evict oldest entry when cache is full
+  if (markdownCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = markdownCache.keys().next().value;
+    if (firstKey !== undefined) {
+      markdownCache.delete(firstKey);
+    }
+  }
+  markdownCache.set(text, result);
+
+  return result;
 }

package/src/lib/modules/client/common/native-bridge.ts

@@ -8,34 +8,23 @@
  * resolving scanner/picker promises using its own callback registry.
  */
 
+/** True when the native bridge exposes a QR scanner */
+export function hasScanner(): boolean {
+  return getScanFn() !== null;
+}
+
 /** True when the page is running inside a native WebView with a bridge */
 export function isNativeBridge(): boolean {
-  if (typeof window === 'undefined') return false;
+  if (typeof window === 'undefined') {
+    return false;
+  }
   // iOS injects window.ShooterBridge, Android injects window.ShooterNativeBridge
   return (
     (typeof window.ShooterBridge === 'object' && window.ShooterBridge !== null) ||
-    (typeof (window as any).ShooterNativeBridge === 'object' && (window as any).ShooterNativeBridge !== null)
+    (typeof window.ShooterNativeBridge === 'object' && window.ShooterNativeBridge !== null)
   );
 }
 
-/** Get the scanner.scan function from whichever bridge exists */
-function getScanFn(): (() => Promise<string>) | null {
-  if (typeof window === 'undefined') return null;
-  // Check iOS bridge first, then Android
-  if (typeof window.ShooterBridge?.scanner?.scan === 'function') {
-    return () => window.ShooterBridge!.scanner!.scan();
-  }
-  if (typeof (window as any).ShooterNativeBridge?.scanner?.scan === 'function') {
-    return () => (window as any).ShooterNativeBridge.scanner.scan();
-  }
-  return null;
-}
-
-/** True when the native bridge exposes a QR scanner */
-export function hasScanner(): boolean {
-  return getScanFn() !== null;
-}
-
 /**
  * Invoke the native QR scanner.
  * Returns the scanned string on success, throws on cancel/error.
@@ -48,3 +37,22 @@ export async function scanQR(): Promise<string> {
   }
   return scan();
 }
+
+/** Get the scanner.scan function from whichever bridge exists */
+function getScanFn(): (() => Promise<string>) | null {
+  if (typeof window === 'undefined') {
+    return null;
+  }
+  // Check iOS bridge first, then Android.
+  // Capture the scanner object (not the bare function) to preserve `this` binding
+  // when the native side implements scan() as a method on the scanner object.
+  const iosScanner = window.ShooterBridge?.scanner;
+  if (iosScanner && typeof iosScanner.scan === 'function') {
+    return () => iosScanner.scan();
+  }
+  const androidScanner = window.ShooterNativeBridge?.scanner;
+  if (androidScanner && typeof androidScanner.scan === 'function') {
+    return () => androidScanner.scan();
+  }
+  return null;
+}

package/src/lib/modules/client/common/time.ts

@@ -6,17 +6,19 @@
  */
 
 export function formatRelativeTime(ts: string): string {
-  const diff = Date.now() - new Date(ts).getTime();
+  if (!ts) {return '';}
+  const date = new Date(ts);
+  if (isNaN(date.getTime())) {return '';}
+  const diff = Date.now() - date.getTime();
+  if (diff < 0) {return 'just now';}
   const mins = Math.floor(diff / 60000);
-  if (mins < 1) {
-    return 'just now';
-  }
-  if (mins < 60) {
-    return `${mins}m ago`;
-  }
+  if (mins < 1) {return 'just now';}
+  if (mins < 60) {return `${mins}m ago`;}
   const hrs = Math.floor(mins / 60);
-  if (hrs < 24) {
-    return `${hrs}h ago`;
-  }
-  return `${Math.floor(hrs / 24)}d ago`;
+  if (hrs < 24) {return `${hrs}h ago`;}
+  const days = Math.floor(hrs / 24);
+  if (days < 7) {return `${days}d ago`;}
+  if (days < 30) {return `${Math.floor(days / 7)}w ago`;}
+  if (days < 365) {return `${Math.floor(days / 30)}mo ago`;}
+  return `${Math.floor(days / 365)}y ago`;
 }