mstro-app 0.1.47

package/server/utils/paths.ts

@@ -0,0 +1,45 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Path Utilities for Mstro Package
+ *
+ * Provides consistent path resolution for installed npm package.
+ * Works correctly whether running from source or installed globally.
+ */
+
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ES module equivalent of __dirname for this file
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Root directory of the mstro package installation.
+ * This is the directory containing package.json.
+ *
+ * Structure: /path/to/mstro/server/utils/paths.ts
+ * So we go up 2 levels: utils -> server -> mstro root
+ */
+export const MSTRO_ROOT = resolve(__dirname, '../..');
+
+/**
+ * Path to the MCP bouncer server script
+ */
+export const MCP_SERVER_PATH = resolve(MSTRO_ROOT, 'server/mcp/server.ts');
+
+/**
+ * Path to the MCP bouncer configuration template
+ */
+export const MCP_CONFIG_TEMPLATE_PATH = resolve(MSTRO_ROOT, 'mstro-bouncer-mcp.json');
+
+/**
+ * Path to the hooks directory
+ */
+export const HOOKS_DIR = resolve(MSTRO_ROOT, 'hooks');
+
+/**
+ * Path to the bouncer hook script
+ */
+export const BOUNCER_HOOK = resolve(HOOKS_DIR, 'bouncer.sh');

package/server/utils/port-manager.ts

@@ -0,0 +1,70 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Port Manager - Finds available ports for Mstro instances
+ *
+ * Handles port discovery when multiple Mstro instances run on the same machine.
+ * Tries a range of ports starting from the default until an available one is found.
+ */
+
+import { createServer } from 'node:net'
+
+const DEFAULT_PORT = 3001
+const MAX_PORT_ATTEMPTS = 10
+
+/**
+ * Check if a port is available
+ */
+async function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer()
+
+    server.once('error', (err: any) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false)
+      } else {
+        resolve(false)
+      }
+    })
+
+    server.once('listening', () => {
+      server.close()
+      resolve(true)
+    })
+
+    server.listen(port)
+  })
+}
+
+/**
+ * Find an available port starting from the default port
+ * Tries ports: 3001, 3002, 3003, ... up to 3010
+ */
+export async function findAvailablePort(startPort: number = DEFAULT_PORT): Promise<number> {
+  for (let i = 0; i < MAX_PORT_ATTEMPTS; i++) {
+    const port = startPort + i
+    const available = await isPortAvailable(port)
+
+    if (available) {
+      return port
+    }
+
+  }
+
+  throw new Error(`Could not find available port after ${MAX_PORT_ATTEMPTS} attempts (tried ${startPort}-${startPort + MAX_PORT_ATTEMPTS - 1})`)
+}
+
+/**
+ * Get the default port from environment or use 3001
+ */
+export function getDefaultPort(): number {
+  const envPort = process.env.PORT
+  if (envPort) {
+    const parsed = parseInt(envPort, 10)
+    if (!Number.isNaN(parsed) && parsed > 0 && parsed < 65536) {
+      return parsed
+    }
+  }
+  return DEFAULT_PORT
+}

package/server/utils/port.ts

@@ -0,0 +1,102 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Port utilities for finding available ports
+ *
+ * Convention: Frontend uses EVEN ports (3000, 3002, 3004...)
+ *             Backend uses ODD ports (3001, 3003, 3005...)
+ * This ensures they never compete for the same port.
+ */
+
+import { createServer } from 'node:net'
+
+/**
+ * Check if a port is available by trying to bind to it
+ * Uses '::' (IPv6 any) which also binds IPv4 on most systems,
+ * ensuring we detect servers listening on any interface.
+ */
+export function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer()
+
+    server.once('error', () => {
+      server.close()
+      resolve(false) // Port is in use
+    })
+
+    server.once('listening', () => {
+      server.close()
+      resolve(true) // Port is available
+    })
+
+    // Use '::' to bind on all interfaces (IPv4 + IPv6)
+    // This ensures we detect servers on any interface
+    server.listen(port, '::')
+  })
+}
+
+/**
+ * Check multiple ports in parallel and return the first available one
+ */
+export async function findFirstAvailablePort(ports: number[]): Promise<number | null> {
+  const results = await Promise.all(
+    ports.map(async (port) => ({ port, available: await isPortAvailable(port) }))
+  )
+  const available = results.find(r => r.available)
+  return available ? available.port : null
+}
+
+/**
+ * Find an available port starting from startPort
+ */
+export async function findAvailablePort(startPort: number, maxTries: number = 20): Promise<number> {
+  // Check all ports in parallel for speed
+  const ports = Array.from({ length: maxTries }, (_, i) => startPort + i)
+  const port = await findFirstAvailablePort(ports)
+  if (port !== null) {
+    return port
+  }
+  throw new Error(`No available ports found between ${startPort} and ${startPort + maxTries}`)
+}
+
+/**
+ * Find an available port pair for frontend and backend
+ * Frontend = EVEN port (3000, 3002, 3004...)
+ * Backend = ODD port (3001, 3003, 3005...)
+ *
+ * Checks all candidate ports in parallel for fast detection.
+ */
+export async function findAvailablePortPair(startPort: number = 3000, maxPairs: number = 20): Promise<{ frontend: number; backend: number }> {
+  // Ensure startPort is even
+  const basePort = startPort % 2 === 0 ? startPort : startPort + 1
+
+  // Generate all candidate pairs
+  const pairs: { frontend: number; backend: number }[] = []
+  for (let i = 0; i < maxPairs; i++) {
+    pairs.push({
+      frontend: basePort + (i * 2),      // 3000, 3002, 3004...
+      backend: basePort + (i * 2) + 1    // 3001, 3003, 3005...
+    })
+  }
+
+  // Check all ports in parallel (both frontend and backend ports)
+  const allPorts = pairs.flatMap(p => [p.frontend, p.backend])
+  const results = await Promise.all(
+    allPorts.map(async (port) => ({ port, available: await isPortAvailable(port) }))
+  )
+
+  // Build a set of available ports for O(1) lookup
+  const availablePorts = new Set(
+    results.filter(r => r.available).map(r => r.port)
+  )
+
+  // Find first pair where both ports are available
+  for (const pair of pairs) {
+    if (availablePorts.has(pair.frontend) && availablePorts.has(pair.backend)) {
+      return pair
+    }
+  }
+
+  throw new Error(`No available port pairs found starting from ${startPort}`)
+}