create-caspian-app 0.2.0-beta.35 → 0.2.0-beta.36

package/dist/settings/bs-config.ts

@@ -13,6 +13,7 @@ import { componentMap } from "./component-map.js";
 import { createServer } from "net";
 import chalk from "chalk";
 import { networkInterfaces } from "os";
+import caspianConfig from "../caspian.config.json";
 
 const { __dirname } = getFileMeta();
 const bs: BrowserSyncInstance = browserSync.create();
@@ -24,14 +25,48 @@ let lastChangedFile: string | null = null;
 let pythonPort = 0;
 let bsPort = 0;
 
-function getAvailablePort(startPort: number): Promise<number> {
+function getReservedPorts(): Set<number> {
+  const reservedPorts = new Set<number>();
+
+  if (!caspianConfig.mcp) {
+    return reservedPorts;
+  }
+
+  const mcpSpecPath = join(__dirname, "..", "src", "lib", "mcp", "fastmcp.json");
+  if (!existsSync(mcpSpecPath)) {
+    return reservedPorts;
+  }
+
+  try {
+    const mcpSpec = JSON.parse(readFileSync(mcpSpecPath, "utf-8"));
+    const reservedPort = Number(mcpSpec?.deployment?.port);
+
+    if (Number.isInteger(reservedPort) && reservedPort > 0) {
+      reservedPorts.add(reservedPort);
+    }
+  } catch {
+    // Ignore malformed local MCP config and fall back to dynamic allocation.
+  }
+
+  return reservedPorts;
+}
+
+function getAvailablePort(
+  startPort: number,
+  reservedPorts: Set<number> = new Set(),
+): Promise<number> {
   return new Promise((resolve) => {
+    if (reservedPorts.has(startPort)) {
+      resolve(getAvailablePort(startPort + 1, reservedPorts));
+      return;
+    }
+
     const server = createServer();
     server.listen(startPort, () => {
       server.close(() => resolve(startPort));
     });
     server.on("error", () => {
-      resolve(getAvailablePort(startPort + 1));
+      resolve(getAvailablePort(startPort + 1, reservedPorts));
     });
   });
 }
@@ -134,8 +169,10 @@ const publicPipeline = new DebouncedWorker(
 );
 
 (async () => {
-  bsPort = await getAvailablePort(5090);
-  pythonPort = await getAvailablePort(bsPort + 10);
+  const reservedPorts = getReservedPorts();
+
+  bsPort = await getAvailablePort(5090, reservedPorts);
+  pythonPort = await getAvailablePort(5200, reservedPorts);
 
   updateRouteFilesCache();
 

package/dist/settings/restart-mcp.ts

@@ -1,5 +1,6 @@
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { isAbsolute, join } from "path";
+import { createServer } from "net";
 import caspianConfig from "../caspian.config.json";
 import { createRestartableProcess, onExit } from "./utils.js";
 
@@ -36,11 +37,79 @@ function getServerSpec(): string | null {
   return null;
 }
 
-function buildArgs(serverSpec: string): string[] {
+function getServerSpecPath(serverSpec: string): string | null {
+  if (serverSpec.startsWith("http://") || serverSpec.startsWith("https://")) {
+    return null;
+  }
+
+  return isAbsolute(serverSpec) ? serverSpec : join(projectRoot, serverSpec);
+}
+
+function readDeploymentConfig(serverSpec: string): Record<string, unknown> {
+  const serverSpecPath = getServerSpecPath(serverSpec);
+  if (!serverSpecPath || !existsSync(serverSpecPath)) {
+    return {};
+  }
+
+  try {
+    const rawConfig = JSON.parse(readFileSync(serverSpecPath, "utf-8"));
+    if (rawConfig && typeof rawConfig === "object") {
+      const deployment = rawConfig.deployment;
+      if (deployment && typeof deployment === "object") {
+        return deployment as Record<string, unknown>;
+      }
+    }
+  } catch {
+    // Ignore malformed specs and allow FastMCP to validate them.
+  }
+
+  return {};
+}
+
+function getPreferredHost(serverSpec: string): string {
+  return (
+    process.env.MCP_HOST?.trim() ||
+    String(readDeploymentConfig(serverSpec).host || "").trim() ||
+    "127.0.0.1"
+  );
+}
+
+function getPreferredPort(serverSpec: string): number | null {
+  const rawPort =
+    process.env.MCP_PORT?.trim() ||
+    String(readDeploymentConfig(serverSpec).port || "").trim();
+
+  if (!rawPort) {
+    return null;
+  }
+
+  const port = Number(rawPort);
+  if (!Number.isInteger(port) || port <= 0) {
+    return null;
+  }
+
+  return port;
+}
+
+function findAvailablePort(startPort: number, host: string): Promise<number> {
+  return new Promise((resolve) => {
+    const server = createServer();
+
+    server.listen(startPort, host, () => {
+      server.close(() => resolve(startPort));
+    });
+
+    server.on("error", () => {
+      resolve(findAvailablePort(startPort + 1, host));
+    });
+  });
+}
+
+function buildArgs(serverSpec: string, portOverride?: string): string[] {
   const args = ["run", serverSpec, "--no-banner"];
   const transport = process.env.MCP_TRANSPORT?.trim();
   const host = process.env.MCP_HOST?.trim();
-  const port = process.env.MCP_PORT?.trim();
+  const port = portOverride || process.env.MCP_PORT?.trim();
   const path = process.env.MCP_PATH?.trim();
   const logLevel = process.env.MCP_LOG_LEVEL?.trim();
 
@@ -133,12 +202,24 @@ if (!serverSpec) {
   process.exit(0);
 }
 
+const preferredHost = getPreferredHost(serverSpec);
+const preferredPort = getPreferredPort(serverSpec);
+const resolvedPort = preferredPort
+  ? await findAvailablePort(preferredPort, preferredHost)
+  : null;
+
+if (preferredPort && resolvedPort && preferredPort !== resolvedPort) {
+  console.log(
+    `[mcp] Port ${preferredPort} is unavailable on ${preferredHost}, using ${resolvedPort} instead.`,
+  );
+}
+
 const handleMcpOutput = createMcpOutputHandler();
 
 const runner = createRestartableProcess({
   name: "mcp",
   cmd: fastMcpCommand,
-  args: buildArgs(serverSpec),
+  args: buildArgs(serverSpec, resolvedPort ? String(resolvedPort) : undefined),
   startMessage: "[mcp] Starting MCP server...",
   onStdout: createLineHandler(handleMcpOutput),
   onStderr: createLineHandler(handleMcpOutput),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-caspian-app",
-  "version": "0.2.0-beta.35",
+  "version": "0.2.0-beta.36",
   "description": "Scaffold a new Caspian project (FastAPI-powered reactive Python framework).",
   "main": "dist/index.js",
   "type": "module",