@juspay/shooter 1.0.0

package/scripts/test-runner.ts

@@ -0,0 +1,243 @@
+/**
+ * Test script for CLIRunner
+ * Run with: npx tsx scripts/test-runner.ts
+ */
+
+import pty, { type IPty } from 'node-pty';
+
+interface ExitCallback {
+  (code: number, signal?: number): void;
+}
+
+interface OutputCallback {
+  (data: string): void;
+}
+
+interface RunnerConfig {
+  args?: string[];
+  cols?: number;
+  command: string;
+  cwd?: string;
+  rows?: number;
+  useLoginShell?: boolean;
+}
+
+class CLIRunner {
+  private config: Required<Omit<RunnerConfig, 'useLoginShell'>> & {
+    useLoginShell: boolean;
+    env: NodeJS.ProcessEnv;
+  };
+  private onExitCallback: null | ExitCallback = null;
+  private onOutputCallback: null | OutputCallback = null;
+  private process: IPty | null = null;
+
+  constructor(config: RunnerConfig) {
+    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,
+    };
+  }
+
+  onExit(callback: ExitCallback): this {
+    this.onExitCallback = callback;
+    return this;
+  }
+
+  onOutput(callback: OutputCallback): this {
+    this.onOutputCallback = callback;
+    return this;
+  }
+
+  start(): this {
+    if (this.process) {
+      throw new Error('Process already running');
+    }
+
+    const { command, args, cwd, env, cols, 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;
+  }
+
+  ctrlC(): this {
+    return this.write('\x03');
+  }
+
+  ctrlD(): this {
+    return this.write('\x04');
+  }
+
+  enter(): this {
+    return this.write('\r');
+  }
+
+  isRunning(): boolean {
+    return this.process !== null;
+  }
+
+  stop(): void {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+  }
+
+  type(text: string): this {
+    return this.write(text);
+  }
+
+  write(data: string): this {
+    this.process?.write(data);
+    return this;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Test with echo command
+async function testWithEcho() {
+  console.log('=== Testing CLIRunner with echo ===\n');
+
+  const runner = new CLIRunner({
+    command: 'echo',
+    args: ['Hello from CLIRunner!'],
+    useLoginShell: false,
+  });
+
+  runner.onOutput((data) => {
+    process.stdout.write(`📤 Output: ${data}`);
+  });
+
+  runner.onExit((code) => {
+    console.log(`\n✅ Process exited with code ${code}`);
+  });
+
+  runner.start();
+  await sleep(1000);
+}
+
+// Test with interactive bash
+async function testWithBash() {
+  console.log('\n=== Testing CLIRunner with bash ===\n');
+
+  const runner = new CLIRunner({
+    command: 'bash',
+    useLoginShell: false,
+  });
+
+  runner.onOutput((data) => {
+    process.stdout.write(data);
+  });
+
+  runner.onExit((code) => {
+    console.log(`\n✅ Bash exited with code ${code}`);
+  });
+
+  runner.start();
+
+  await sleep(500);
+  runner.type('echo "Hello from bash!"');
+  runner.enter();
+
+  await sleep(500);
+  runner.type('pwd');
+  runner.enter();
+
+  await sleep(500);
+  runner.type('exit');
+  runner.enter();
+
+  await sleep(1000);
+}
+
+// Test with node REPL
+async function testWithNode() {
+  console.log('\n=== Testing CLIRunner with node REPL ===\n');
+
+  const runner = new CLIRunner({
+    command: 'node',
+    useLoginShell: false,
+  });
+
+  runner.onOutput((data) => {
+    process.stdout.write(data);
+  });
+
+  runner.onExit((code) => {
+    console.log(`\n✅ Node exited with code ${code}`);
+  });
+
+  runner.start();
+
+  await sleep(500);
+  runner.type('console.log("Hello from Node REPL!")');
+  runner.enter();
+
+  await sleep(300);
+  runner.type('2 + 2');
+  runner.enter();
+
+  await sleep(300);
+  runner.type('const msg = "CLIRunner works!"');
+  runner.enter();
+
+  await sleep(300);
+  runner.type('msg');
+  runner.enter();
+
+  await sleep(300);
+  runner.ctrlD(); // Exit node
+
+  await sleep(500);
+}
+
+async function main() {
+  try {
+    await testWithEcho();
+    await testWithBash();
+    await testWithNode();
+    console.log('\n✅ All tests completed!');
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/vercel-env-commands.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+# Vercel Environment Variable Setup Commands
+# Run these commands if you have Vercel CLI installed
+
+echo "🔧 Vercel Environment Variable Setup Commands"
+echo "=============================================="
+echo ""
+echo "If you have Vercel CLI installed, run these commands:"
+echo ""
+
+echo "# 1. API Authentication"
+echo "vercel env add API_KEY"
+echo "# Enter: YOUR_API_KEY_HERE (from .env file)"
+echo ""
+
+echo "# 2. APNs Key ID"
+echo "vercel env add APNS_KEY_ID"
+echo "# Enter: YOUR_APNS_KEY_ID_HERE (from .env file)"
+echo ""
+
+echo "# 3. APNs Team ID"
+echo "vercel env add APNS_TEAM_ID"
+echo "# Enter: YOUR_APNS_TEAM_ID_HERE (from .env file)"
+echo ""
+
+echo "# 4. APNs Bundle ID"
+echo "vercel env add APNS_BUNDLE_ID"
+echo "# Enter: YOUR_BUNDLE_ID_HERE (from .env file)"
+echo ""
+
+echo "# 5. APNs Private Key (Base64)"
+echo "vercel env add APNS_KEY_BASE64"
+echo "# Enter: YOUR_BASE64_APNS_KEY_HERE (extract from .env between BEGIN/END PRIVATE KEY)"
+echo ""
+
+echo "# 6. Device Token (Optional)"
+echo "vercel env add DEVICE_TOKEN"
+echo "# Enter: YOUR_DEVICE_TOKEN_HERE (from iOS app or .env file)"
+echo ""
+
+echo "# 7. Environment"
+echo "vercel env add NODE_ENV"
+echo "# Enter: production"
+echo ""
+
+echo "# 8. Redeploy after adding variables"
+echo "vercel --prod"
+echo ""
+
+echo "📋 Manual Setup (if CLI not available):"
+echo "1. Go to https://vercel.com/dashboard"
+echo "2. Select your 'shooter' project"
+echo "3. Go to Settings > Environment Variables"
+echo "4. Add each variable with values shown above"
+echo "5. Redeploy the application"
+echo ""
+
+echo "🧪 Test after setup:"
+echo "./tests/test-production.sh"

package/server.ts

@@ -0,0 +1,139 @@
+// Custom server entry point — run with `npx tsx server.ts`.
+// Wraps the SvelteKit build output with a WebSocket server for terminal I/O,
+// live session streaming, and a global event bus. NOT compiled by SvelteKit.
+
+// Load .env into process.env before anything else (adapter-node reads process.env at runtime).
+import 'dotenv/config';
+
+import { createServer, type Server } from 'http';
+import { WebSocketServer, type WebSocket } from 'ws';
+
+import { handler } from './build/handler.js';
+import { validateTicket } from './src/lib/modules/server/ws/ticket-store.js';
+import { setupWebSocketHandlers } from './src/lib/modules/server/ws/server.js';
+import { startKeepalive, stopKeepalive } from './src/lib/modules/server/ws/keepalive.js';
+import { setPtyManager as setTerminalHandlerPtyManager } from './src/lib/modules/server/ws/terminal-handler.js';
+import {
+	setPtyManager as setSessionHandlerPtyManager,
+	setSessionWatcher,
+} from './src/lib/modules/server/ws/session-handler.js';
+import { ptyManager } from './src/lib/modules/server/terminal/pty-manager.js';
+import { sessionWatcher } from './src/lib/modules/server/terminal/session-watcher.js';
+import { openCodeWatcher } from './src/lib/modules/server/terminal/opencode-watcher.js';
+import type { ConversationMessage } from './src/lib/modules/server/sessions/types.js';
+
+// ── Adapters ─────────────────────────────────────────────────────────
+// The WS handlers define their own duck-typed interfaces (PtyManagerLike,
+// SessionWatcherLike) that differ slightly from the real singletons'
+// public APIs. Thin adapters bridge the gap without modifying either side.
+
+/** Adapt PtyManager (`.get()`) to the handlers' expected `.getTerminal()`. */
+const ptyManagerAdapter = {
+	getTerminal(id: string) {
+		return ptyManager.get(id) ?? undefined;
+	},
+	attach(id: string, ws: WebSocket) {
+		return ptyManager.attach(id, ws);
+	},
+	detach(id: string, ws: WebSocket) {
+		return ptyManager.detach(id, ws);
+	},
+};
+
+/**
+ * Adapt SessionWatcher (`.watch()` + `.getHistory()`) to the session
+ * handler's expected `.subscribe()` + `.getHistory()` interface.
+ *
+ * Both watchers now deliver ConversationMessage[] — the adapter just
+ * routes to the correct watcher based on the session key format.
+ */
+const sessionWatcherAdapter = {
+	getHistory(sessionFile: string) {
+		// Check if this is an OpenCode session ID (not a file path)
+		if (!sessionFile.includes('/') && !sessionFile.includes('.jsonl')) {
+			return openCodeWatcher.getHistory(sessionFile);
+		}
+		return sessionWatcher.getHistory(sessionFile);
+	},
+	subscribe(sessionFile: string, callback: Parameters<typeof sessionWatcher.watch>[1]) {
+		if (!sessionFile.includes('/') && !sessionFile.includes('.jsonl')) {
+			openCodeWatcher.watch(sessionFile, callback as (messages: ConversationMessage[]) => void);
+			return () => openCodeWatcher.stop(sessionFile, callback as (messages: ConversationMessage[]) => void);
+		}
+		sessionWatcher.watch(sessionFile, callback);
+		return () => sessionWatcher.stop(sessionFile);
+	},
+};
+
+// ── Wire singletons into WebSocket handlers ──────────────────────────
+
+// The adapters bridge the gap between the real singletons' public APIs and
+// the duck-typed interfaces expected by each WS handler.
+setTerminalHandlerPtyManager(ptyManagerAdapter);
+setSessionHandlerPtyManager(ptyManagerAdapter);
+setSessionWatcher(sessionWatcherAdapter);
+
+// Recover persisted terminals before accepting connections
+await ptyManager.reconnectAll();
+
+// ── HTTP server wrapping SvelteKit ───────────────────────────────────
+
+const server: Server = createServer(handler);
+
+// ── WebSocket server (noServer mode — we handle upgrades manually) ───
+
+const wss = new WebSocketServer({ noServer: true });
+
+server.on('upgrade', (request, socket, head) => {
+	const url = new URL(request.url || '', `http://${request.headers.host}`);
+	const ticket = url.searchParams.get('ticket');
+
+	if (!validateTicket(ticket)) {
+		socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+		socket.destroy();
+		return;
+	}
+
+	// Delegate routing to the WS server module which inspects the pathname
+	// and dispatches to terminal, session, or events handlers.
+	setupWebSocketHandlers(wss, request, socket, head);
+});
+
+// ── Start keepalive pings (30s interval, keeps Cloudflare Tunnel alive) ──
+
+startKeepalive();
+
+// ── Listen ───────────────────────────────────────────────────────────
+
+const port = parseInt(process.env.PORT || '3000', 10);
+
+server.listen(port, () => {
+	console.log(`Shooter server running on http://localhost:${port}`);
+});
+
+// ── Graceful shutdown ────────────────────────────────────────────────
+
+function shutdown(signal: string): void {
+	console.log(`\n${signal} received — shutting down…`);
+
+	stopKeepalive();
+	ptyManager.disconnectAll();
+	sessionWatcher.stopAll();
+	openCodeWatcher.stopAll();
+
+	wss.close(() => {
+		server.close(() => {
+			console.log('Shooter server stopped.');
+			process.exit(0);
+		});
+	});
+
+	// Force exit if graceful shutdown takes too long (10 seconds)
+	setTimeout(() => {
+		console.error('Graceful shutdown timed out — forcing exit.');
+		process.exit(1);
+	}, 10_000).unref();
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));