@seflless/ghosttown 1.6.0 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seflless/ghosttown",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "Web-based terminal emulator using Ghostty's VT100 parser via WebAssembly",
   "type": "module",
   "main": "./dist/ghostty-web.umd.cjs",

package/src/cli.js

@@ -512,8 +512,8 @@ function getNextDisplayNumber() {
 }
 
 /**
- * Check if the background server is running and get its port
- * @returns {{ running: boolean, port: number | null }}
+ * Check if the background server is running and get its port and protocol
+ * @returns {{ running: boolean, port: number | null, useHttp: boolean }}
  */
 function getServerStatus() {
   try {
@@ -525,22 +525,42 @@ function getServerStatus() {
     const isRunning = output.split('\n').includes(SERVER_SESSION_NAME);
 
     if (!isRunning) {
-      return { running: false, port: null };
+      return { running: false, port: null, useHttp: false };
     }
 
     // Get the port from tmux environment
+    let port = 8080;
     try {
       const envOutput = execSync(`tmux show-environment -t ${SERVER_SESSION_NAME} GHOSTTOWN_PORT`, {
         encoding: 'utf8',
         stdio: ['pipe', 'pipe', 'pipe'],
       });
-      const port = Number.parseInt(envOutput.split('=')[1], 10);
-      return { running: true, port: Number.isNaN(port) ? 8080 : port };
+      const parsedPort = Number.parseInt(envOutput.split('=')[1], 10);
+      if (!Number.isNaN(parsedPort)) {
+        port = parsedPort;
+      }
     } catch (e) {
-      return { running: true, port: 8080 }; // Default port
+      // Use default port
     }
+
+    // Get the protocol from tmux environment (default to HTTPS if not set)
+    let useHttp = false;
+    try {
+      const envOutput = execSync(
+        `tmux show-environment -t ${SERVER_SESSION_NAME} GHOSTTOWN_USE_HTTP`,
+        {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }
+      );
+      useHttp = envOutput.split('=')[1]?.trim() === '1';
+    } catch (e) {
+      // Use default (HTTPS)
+    }
+
+    return { running: true, port, useHttp };
   } catch (err) {
-    return { running: false, port: null };
+    return { running: false, port: null, useHttp: false };
   }
 }
 
@@ -1083,8 +1103,9 @@ function killAllSessions() {
 /**
  * Start the server in the background using a tmux session
  * @param {number} port - Port to listen on
+ * @param {boolean} useHttp - Use HTTP instead of HTTPS (default: false, meaning HTTPS is used)
  */
-function startServerInBackground(port = 8080) {
+function startServerInBackground(port = 8080, useHttp = false) {
   // Check if tmux is installed
   if (!checkTmuxInstalled()) {
     printTmuxInstallHelp();
@@ -1141,24 +1162,34 @@ function startServerInBackground(port = 8080) {
       stdio: 'pipe',
     });
 
+    // Set the protocol environment variable in the tmux session
+    execSync(
+      `tmux set-environment -t ${SERVER_SESSION_NAME} GHOSTTOWN_USE_HTTP ${useHttp ? '1' : '0'}`,
+      {
+        stdio: 'pipe',
+      }
+    );
+
     // Disable status bar for cleaner look
     execSync(`tmux set-option -t ${SERVER_SESSION_NAME} status off`, { stdio: 'pipe' });
 
-    // Run the server with background mode flag
+    // Run the server with background mode flag (add --http if needed)
+    const httpFlag = useHttp ? ' --http' : '';
     execSync(
-      `tmux send-keys -t ${SERVER_SESSION_NAME} 'node "${gtPath}" --server-background -p ${port}' Enter`,
+      `tmux send-keys -t ${SERVER_SESSION_NAME} 'node "${gtPath}" --server-background -p ${port}${httpFlag}' Enter`,
       { stdio: 'pipe' }
     );
 
     // Get local IPs for display
     const localIPs = getLocalIPs();
+    const protocol = useHttp ? 'http' : 'https';
 
     console.log('');
     console.log(`   ${BOLD_YELLOW}Ghosttown server started!${RESET}`);
     console.log('');
-    console.log(`     ${CYAN}Open:${RESET} ${BEIGE}http://localhost:${port}${RESET}`);
+    console.log(`     ${CYAN}Open:${RESET} ${BEIGE}${protocol}://localhost:${port}${RESET}`);
     if (localIPs.length > 0) {
-      console.log(`  ${CYAN}Network:${RESET} ${BEIGE}http://${localIPs[0]}:${port}${RESET}`);
+      console.log(`  ${CYAN}Network:${RESET} ${BEIGE}${protocol}://${localIPs[0]}:${port}${RESET}`);
     }
     console.log('');
     console.log(`   ${CYAN}To stop:${RESET}  ${BEIGE}gt stop${RESET}`);
@@ -1238,12 +1269,13 @@ function showServerStatus() {
   if (status.running) {
     const localIPs = getLocalIPs();
     const port = status.port || 8080;
+    const protocol = status.useHttp ? 'http' : 'https';
 
     console.log(`   ${GREEN}Server is running${RESET}`);
     console.log('');
-    console.log(`     ${CYAN}Open:${RESET} ${BEIGE}http://localhost:${port}${RESET}`);
+    console.log(`     ${CYAN}Open:${RESET} ${BEIGE}${protocol}://localhost:${port}${RESET}`);
     if (localIPs.length > 0) {
-      console.log(`  ${CYAN}Network:${RESET} ${BEIGE}http://${localIPs[0]}:${port}${RESET}`);
+      console.log(`  ${CYAN}Network:${RESET} ${BEIGE}${protocol}://${localIPs[0]}:${port}${RESET}`);
     }
     console.log('');
     console.log(`   ${DIM}To stop: gt stop${RESET}`);
@@ -1496,15 +1528,13 @@ Examples:
 Aliases:
   This CLI can also be invoked as 'gt' or 'ght'.
 `);
-      handled = true;
-      break;
+      process.exit(0);
     }
 
     // Handle version flag
     if (arg === '-v' || arg === '--version') {
       console.log(VERSION);
-      handled = true;
-      break;
+      process.exit(0);
     }
 
     // Handle list command
@@ -1569,20 +1599,28 @@ Aliases:
 
     // Handle start command
     else if (arg === 'start') {
-      // Check for -p flag after 'start'
+      // Parse remaining args after 'start' for -p and --http flags
       let startPort = 8080;
-      if (args[i + 1] === '-p' || args[i + 1] === '--port') {
-        const portArg = args[i + 2];
-        if (portArg) {
-          startPort = Number.parseInt(portArg, 10);
-          if (Number.isNaN(startPort) || startPort < 1 || startPort > 65535) {
-            console.error(`Error: Invalid port number: ${portArg}`);
-            process.exit(1);
+      let startUseHttp = false;
+      const remainingArgs = args.slice(i + 1);
+      for (let j = 0; j < remainingArgs.length; j++) {
+        const subArg = remainingArgs[j];
+        if (subArg === '-p' || subArg === '--port') {
+          const portArg = remainingArgs[j + 1];
+          if (portArg) {
+            startPort = Number.parseInt(portArg, 10);
+            if (Number.isNaN(startPort) || startPort < 1 || startPort > 65535) {
+              console.error(`Error: Invalid port number: ${portArg}`);
+              process.exit(1);
+            }
           }
+          j++; // Skip the port value
+        } else if (subArg === '--http') {
+          startUseHttp = true;
         }
       }
       handled = true;
-      startServerInBackground(startPort);
+      startServerInBackground(startPort, startUseHttp);
       // startServerInBackground exits, so this won't be reached
     }
 

package/src/cli.test.ts

@@ -0,0 +1,75 @@
+/**
+ * CLI tests
+ *
+ * Tests for the ghosttown CLI command-line interface.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = join(fileURLToPath(import.meta.url), '..');
+const CLI_PATH = join(__dirname, '..', 'bin', 'gt.js');
+
+/**
+ * Run the CLI with given arguments and return stdout/stderr/exit code
+ */
+function runCli(args: string[]): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve) => {
+    const proc = spawn('node', [CLI_PATH, ...args], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      resolve({ stdout, stderr, code: code ?? 1 });
+    });
+  });
+}
+
+describe('CLI', () => {
+  describe('version flag', () => {
+    test('-v should print version and exit', async () => {
+      const result = await runCli(['-v']);
+      expect(result.code).toBe(0);
+      expect(result.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+      expect(result.stderr).toBe('');
+    });
+
+    test('--version should print version and exit', async () => {
+      const result = await runCli(['--version']);
+      expect(result.code).toBe(0);
+      expect(result.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+      expect(result.stderr).toBe('');
+    });
+  });
+
+  describe('help flag', () => {
+    test('-h should print help and exit', async () => {
+      const result = await runCli(['-h']);
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('Usage: ghosttown');
+      expect(result.stdout).toContain('--version');
+      expect(result.stdout).toContain('--help');
+      expect(result.stderr).toBe('');
+    });
+
+    test('--help should print help and exit', async () => {
+      const result = await runCli(['--help']);
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('Usage: ghosttown');
+      expect(result.stderr).toBe('');
+    });
+  });
+});