diff --git a/server/src/creators/report-creator.js b/server/src/creators/report-creator.js
index c827b4d7c..3176f34a9 100644
--- a/server/src/creators/report-creator.js
+++ b/server/src/creators/report-creator.js
@@ -1,238 +1,238 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual';
 
 import bots from 'lib/facts/bots';
 import {
   filterRawEntryInfosByCalendarQuery,
   serverEntryInfosObject,
 } from 'lib/shared/entry-utils';
 import { messageTypes } from 'lib/types/message-types';
 import {
   type ReportCreationRequest,
   type ReportCreationResponse,
   type ThreadInconsistencyReportCreationRequest,
   type EntryInconsistencyReportCreationRequest,
   type UserInconsistencyReportCreationRequest,
   reportTypes,
 } from 'lib/types/report-types';
 import { values } from 'lib/utils/objects';
 import {
   sanitizeReduxReport,
   type ReduxCrashReport,
 } from 'lib/utils/sanitization';
 
 import { dbQuery, SQL } from '../database/database';
 import { fetchUsername } from '../fetchers/user-fetchers';
 import { handleAsyncPromise } from '../responders/handlers';
 import { createBotViewer } from '../session/bots';
 import type { Viewer } from '../session/viewer';
-import { getAppURLFacts } from '../utils/urls';
+import { getSquadCalURLFacts } from '../utils/urls';
 import createIDs from './id-creator';
 import createMessages from './message-creator';
 
-const { baseDomain, basePath } = getAppURLFacts();
+const { baseDomain, basePath } = getSquadCalURLFacts();
 const { commbot } = bots;
 
 async function createReport(
   viewer: Viewer,
   request: ReportCreationRequest,
 ): Promise<?ReportCreationResponse> {
   const shouldIgnore = await ignoreReport(viewer, request);
   if (shouldIgnore) {
     return null;
   }
   const [id] = await createIDs('reports', 1);
   let type, report, time;
   if (request.type === reportTypes.THREAD_INCONSISTENCY) {
     ({ type, time, ...report } = request);
     time = time ? time : Date.now();
   } else if (request.type === reportTypes.ENTRY_INCONSISTENCY) {
     ({ type, time, ...report } = request);
   } else if (request.type === reportTypes.MEDIA_MISSION) {
     ({ type, time, ...report } = request);
   } else if (request.type === reportTypes.USER_INCONSISTENCY) {
     ({ type, time, ...report } = request);
   } else {
     ({ type, ...report } = request);
     time = Date.now();
     const redactedReduxReport: ReduxCrashReport = sanitizeReduxReport({
       preloadedState: report.preloadedState,
       currentState: report.currentState,
       actions: report.actions,
     });
     report = {
       ...report,
       ...redactedReduxReport,
     };
   }
   const row = [
     id,
     viewer.id,
     type,
     request.platformDetails.platform,
     JSON.stringify(report),
     time,
   ];
   const query = SQL`
     INSERT INTO reports (id, user, type, platform, report, creation_time)
     VALUES ${[row]}
   `;
   await dbQuery(query);
   handleAsyncPromise(sendSquadbotMessage(viewer, request, id));
   return { id };
 }
 
 async function sendSquadbotMessage(
   viewer: Viewer,
   request: ReportCreationRequest,
   reportID: string,
 ): Promise<void> {
   const canGenerateMessage = getSquadbotMessage(request, reportID, null);
   if (!canGenerateMessage) {
     return;
   }
   const username = await fetchUsername(viewer.id);
   const message = getSquadbotMessage(request, reportID, username);
   if (!message) {
     return;
   }
   const time = Date.now();
   await createMessages(createBotViewer(commbot.userID), [
     {
       type: messageTypes.TEXT,
       threadID: commbot.staffThreadID,
       creatorID: commbot.userID,
       time,
       text: message,
     },
   ]);
 }
 
 async function ignoreReport(
   viewer: Viewer,
   request: ReportCreationRequest,
 ): Promise<boolean> {
   // The below logic is to avoid duplicate inconsistency reports
   if (
     request.type !== reportTypes.THREAD_INCONSISTENCY &&
     request.type !== reportTypes.ENTRY_INCONSISTENCY
   ) {
     return false;
   }
   const { type, platformDetails, time } = request;
   if (!time) {
     return false;
   }
   const { platform } = platformDetails;
   const query = SQL`
     SELECT id
     FROM reports
     WHERE user = ${viewer.id} AND type = ${type}
       AND platform = ${platform} AND creation_time = ${time}
   `;
   const [result] = await dbQuery(query);
   return result.length !== 0;
 }
 
 function getSquadbotMessage(
   request: ReportCreationRequest,
   reportID: string,
   username: ?string,
 ): ?string {
   const name = username ? username : '[null]';
   const { platformDetails } = request;
   const { platform, codeVersion } = platformDetails;
   const platformString = codeVersion ? `${platform} v${codeVersion}` : platform;
   if (request.type === reportTypes.ERROR) {
     return (
       `${name} got an error :(\n` +
       `using ${platformString}\n` +
       `${baseDomain}${basePath}download_error_report/${reportID}`
     );
   } else if (request.type === reportTypes.THREAD_INCONSISTENCY) {
     const nonMatchingThreadIDs = getInconsistentThreadIDsFromReport(request);
     const nonMatchingString = [...nonMatchingThreadIDs].join(', ');
     return (
       `system detected inconsistency for ${name}!\n` +
       `using ${platformString}\n` +
       `occurred during ${request.action.type}\n` +
       `thread IDs that are inconsistent: ${nonMatchingString}`
     );
   } else if (request.type === reportTypes.ENTRY_INCONSISTENCY) {
     const nonMatchingEntryIDs = getInconsistentEntryIDsFromReport(request);
     const nonMatchingString = [...nonMatchingEntryIDs].join(', ');
     return (
       `system detected inconsistency for ${name}!\n` +
       `using ${platformString}\n` +
       `occurred during ${request.action.type}\n` +
       `entry IDs that are inconsistent: ${nonMatchingString}`
     );
   } else if (request.type === reportTypes.USER_INCONSISTENCY) {
     const nonMatchingUserIDs = getInconsistentUserIDsFromReport(request);
     const nonMatchingString = [...nonMatchingUserIDs].join(', ');
     return (
       `system detected inconsistency for ${name}!\n` +
       `using ${platformString}\n` +
       `occurred during ${request.action.type}\n` +
       `user IDs that are inconsistent: ${nonMatchingString}`
     );
   } else if (request.type === reportTypes.MEDIA_MISSION) {
     const mediaMissionJSON = JSON.stringify(request.mediaMission);
     const success = request.mediaMission.result.success
       ? 'media mission success!'
       : 'media mission failed :(';
     return `${name} ${success}\n` + mediaMissionJSON;
   } else {
     return null;
   }
 }
 
 function findInconsistentObjectKeys<O>(
   first: { +[id: string]: O },
   second: { +[id: string]: O },
 ): Set<string> {
   const nonMatchingIDs = new Set();
   for (const id in first) {
     if (!_isEqual(first[id])(second[id])) {
       nonMatchingIDs.add(id);
     }
   }
   for (const id in second) {
     if (!first[id]) {
       nonMatchingIDs.add(id);
     }
   }
   return nonMatchingIDs;
 }
 
 function getInconsistentThreadIDsFromReport(
   request: ThreadInconsistencyReportCreationRequest,
 ): Set<string> {
   const { pushResult, beforeAction } = request;
   return findInconsistentObjectKeys(beforeAction, pushResult);
 }
 
 function getInconsistentEntryIDsFromReport(
   request: EntryInconsistencyReportCreationRequest,
 ): Set<string> {
   const { pushResult, beforeAction, calendarQuery } = request;
   const filteredBeforeAction = filterRawEntryInfosByCalendarQuery(
     serverEntryInfosObject(values(beforeAction)),
     calendarQuery,
   );
   const filteredAfterAction = filterRawEntryInfosByCalendarQuery(
     serverEntryInfosObject(values(pushResult)),
     calendarQuery,
   );
   return findInconsistentObjectKeys(filteredBeforeAction, filteredAfterAction);
 }
 
 function getInconsistentUserIDsFromReport(
   request: UserInconsistencyReportCreationRequest,
 ): Set<string> {
   const { beforeStateCheck, afterStateCheck } = request;
   return findInconsistentObjectKeys(beforeStateCheck, afterStateCheck);
 }
 
 export default createReport;
diff --git a/server/src/fetchers/upload-fetchers.js b/server/src/fetchers/upload-fetchers.js
index c13f54ed4..098d7e368 100644
--- a/server/src/fetchers/upload-fetchers.js
+++ b/server/src/fetchers/upload-fetchers.js
@@ -1,121 +1,121 @@
 // @flow
 
 import type { Media } from 'lib/types/media-types';
 import { ServerError } from 'lib/utils/errors';
 
 import { dbQuery, SQL } from '../database/database';
 import type { Viewer } from '../session/viewer';
-import { getAppURLFacts } from '../utils/urls';
+import { getSquadCalURLFacts } from '../utils/urls';
 
-const { baseDomain, basePath } = getAppURLFacts();
+const { baseDomain, basePath } = getSquadCalURLFacts();
 
 type UploadInfo = {
   content: Buffer,
   mime: string,
 };
 async function fetchUpload(
   viewer: Viewer,
   id: string,
   secret: string,
 ): Promise<UploadInfo> {
   const query = SQL`
     SELECT content, mime
     FROM uploads
     WHERE id = ${id} AND secret = ${secret}
   `;
   const [result] = await dbQuery(query);
 
   if (result.length === 0) {
     throw new ServerError('invalid_parameters');
   }
   const [row] = result;
   const { content, mime } = row;
   return { content, mime };
 }
 
 async function fetchUploadChunk(
   id: string,
   secret: string,
   pos: number,
   len: number,
 ): Promise<UploadInfo> {
   // We use pos + 1 because SQL is 1-indexed whereas js is 0-indexed
   const query = SQL`
     SELECT SUBSTRING(content, ${pos + 1}, ${len}) AS content, mime
     FROM uploads
     WHERE id = ${id} AND secret = ${secret}
   `;
   const [result] = await dbQuery(query);
 
   if (result.length === 0) {
     throw new ServerError('invalid_parameters');
   }
   const [row] = result;
   const { content, mime } = row;
   return {
     content,
     mime,
   };
 }
 
 // Returns total size in bytes.
 async function getUploadSize(id: string, secret: string): Promise<number> {
   const query = SQL`
     SELECT LENGTH(content) AS length
     FROM uploads
     WHERE id = ${id} AND secret = ${secret}
   `;
   const [result] = await dbQuery(query);
 
   if (result.length === 0) {
     throw new ServerError('invalid_parameters');
   }
 
   const [row] = result;
   const { length } = row;
   return length;
 }
 
 function getUploadURL(id: string, secret: string): string {
   return `${baseDomain}${basePath}upload/${id}/${secret}`;
 }
 
 function mediaFromRow(row: Object): Media {
   const { uploadType: type, uploadSecret: secret } = row;
   const { width, height, loop } = row.uploadExtra;
   const id = row.uploadID.toString();
   const dimensions = { width, height };
   const uri = getUploadURL(id, secret);
   if (type === 'photo') {
     return { id, type: 'photo', uri, dimensions };
   } else if (loop) {
     // $FlowFixMe add thumbnailID, thumbnailURI once they're in DB
     return { id, type: 'video', uri, dimensions, loop };
   } else {
     // $FlowFixMe add thumbnailID, thumbnailURI once they're in DB
     return { id, type: 'video', uri, dimensions };
   }
 }
 
 async function fetchMedia(
   viewer: Viewer,
   mediaIDs: $ReadOnlyArray<string>,
 ): Promise<$ReadOnlyArray<Media>> {
   const query = SQL`
     SELECT id AS uploadID, secret AS uploadSecret,
       type AS uploadType, extra AS uploadExtra
     FROM uploads
     WHERE id IN (${mediaIDs}) AND uploader = ${viewer.id} AND container IS NULL
   `;
   const [result] = await dbQuery(query);
   return result.map(mediaFromRow);
 }
 
 export {
   fetchUpload,
   fetchUploadChunk,
   getUploadSize,
   getUploadURL,
   mediaFromRow,
   fetchMedia,
 };
diff --git a/server/src/responders/website-responders.js b/server/src/responders/website-responders.js
index 4b437f312..0569d87bb 100644
--- a/server/src/responders/website-responders.js
+++ b/server/src/responders/website-responders.js
@@ -1,339 +1,339 @@
 // @flow
 
 import html from 'common-tags/lib/html';
 import type { $Response, $Request } from 'express';
 import fs from 'fs';
 import _keyBy from 'lodash/fp/keyBy';
 import * as React from 'react';
 import ReactDOMServer from 'react-dom/server';
 import { Provider } from 'react-redux';
 import { Route, StaticRouter } from 'react-router';
 import { createStore, type Store } from 'redux';
 import { promisify } from 'util';
 
 import { daysToEntriesFromEntryInfos } from 'lib/reducers/entry-reducer';
 import { freshMessageStore } from 'lib/reducers/message-reducer';
 import { mostRecentlyReadThread } from 'lib/selectors/thread-selectors';
 import { mostRecentMessageTimestamp } from 'lib/shared/message-utils';
 import { threadHasPermission } from 'lib/shared/thread-utils';
 import { defaultWebEnabledApps } from 'lib/types/enabled-apps';
 import { defaultCalendarFilters } from 'lib/types/filter-types';
 import { defaultNumberPerThread } from 'lib/types/message-types';
 import { defaultEnabledReports } from 'lib/types/report-types';
 import { defaultConnectionInfo } from 'lib/types/socket-types';
 import { threadPermissions } from 'lib/types/thread-types';
 import type { CurrentUserInfo } from 'lib/types/user-types';
 import { currentDateInTimeZone } from 'lib/utils/date-utils';
 import { ServerError } from 'lib/utils/errors';
 import { promiseAll } from 'lib/utils/promises';
 import { reducer } from 'web/redux/redux-setup';
 import type { AppState, Action } from 'web/redux/redux-setup';
 import getTitle from 'web/title/getTitle';
 import { navInfoFromURL } from 'web/url-utils';
 
 import { fetchEntryInfos } from '../fetchers/entry-fetchers';
 import { fetchMessageInfos } from '../fetchers/message-fetchers';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers';
 import {
   fetchCurrentUserInfo,
   fetchKnownUserInfos,
 } from '../fetchers/user-fetchers';
 import { setNewSession } from '../session/cookies';
 import { Viewer } from '../session/viewer';
 import { streamJSON, waitForStream } from '../utils/json-stream';
-import { getAppURLFacts } from '../utils/urls';
+import { getSquadCalURLFacts } from '../utils/urls';
 
-const { basePath, baseDomain } = getAppURLFacts();
+const { basePath, baseDomain } = getSquadCalURLFacts();
 const { renderToNodeStream } = ReactDOMServer;
 
 const baseURL = basePath.replace(/\/$/, '');
 const baseHref = baseDomain + baseURL;
 
 const access = promisify(fs.access);
 const googleFontsURL =
   'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
 const localFontsURL = 'fonts/local-fonts.css';
 async function getFontsURL() {
   try {
     await access(localFontsURL);
     return localFontsURL;
   } catch {
     return googleFontsURL;
   }
 }
 
 type AssetInfo = { jsURL: string, fontsURL: string, cssInclude: string };
 let assetInfo: ?AssetInfo = null;
 async function getAssetInfo() {
   if (assetInfo) {
     return assetInfo;
   }
   if (process.env.NODE_ENV === 'development') {
     const fontsURL = await getFontsURL();
     assetInfo = {
       jsURL: 'http://localhost:8080/dev.build.js',
       fontsURL,
       cssInclude: '',
     };
     return assetInfo;
   }
   // $FlowFixMe web/dist doesn't always exist
   const { default: assets } = await import('web/dist/assets');
   assetInfo = {
     jsURL: `compiled/${assets.browser.js}`,
     fontsURL: googleFontsURL,
     cssInclude: html`
       <link
         rel="stylesheet"
         type="text/css"
         href="compiled/${assets.browser.css}"
       />
     `,
   };
   return assetInfo;
 }
 
 let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
 async function getWebpackCompiledRootComponentForSSR() {
   if (webpackCompiledRootComponent) {
     return webpackCompiledRootComponent;
   }
   try {
     // $FlowFixMe web/dist doesn't always exist
     const webpackBuild = await import('web/dist/app.build.cjs');
     webpackCompiledRootComponent = webpackBuild.default.default;
     return webpackCompiledRootComponent;
   } catch {
     throw new Error(
       'Could not load app.build.cjs. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 async function websiteResponder(
   viewer: Viewer,
   req: $Request,
   res: $Response,
 ): Promise<void> {
   const appPromise = getWebpackCompiledRootComponentForSSR();
 
   let initialNavInfo;
   try {
     initialNavInfo = navInfoFromURL(req.url, {
       now: currentDateInTimeZone(viewer.timeZone),
     });
   } catch (e) {
     throw new ServerError(e.message);
   }
 
   const calendarQuery = {
     startDate: initialNavInfo.startDate,
     endDate: initialNavInfo.endDate,
     filters: defaultCalendarFilters,
   };
   const messageSelectionCriteria = { joinedThreads: true };
   const initialTime = Date.now();
 
   const assetInfoPromise = getAssetInfo();
   const threadInfoPromise = fetchThreadInfos(viewer);
   const messageInfoPromise = fetchMessageInfos(
     viewer,
     messageSelectionCriteria,
     defaultNumberPerThread,
   );
   const entryInfoPromise = fetchEntryInfos(viewer, [calendarQuery]);
   const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
   const userInfoPromise = fetchKnownUserInfos(viewer);
 
   const sessionIDPromise = (async () => {
     if (viewer.loggedIn) {
       await setNewSession(viewer, calendarQuery, initialTime);
     }
     return viewer.sessionID;
   })();
 
   const threadStorePromise = (async () => {
     const { threadInfos } = await threadInfoPromise;
     return { threadInfos };
   })();
   const messageStorePromise = (async () => {
     const [
       { threadInfos },
       { rawMessageInfos, truncationStatuses },
     ] = await Promise.all([threadInfoPromise, messageInfoPromise]);
     const { messageStore: freshStore } = freshMessageStore(
       rawMessageInfos,
       truncationStatuses,
       mostRecentMessageTimestamp(rawMessageInfos, initialTime),
       threadInfos,
     );
     return freshStore;
   })();
   const entryStorePromise = (async () => {
     const { rawEntryInfos } = await entryInfoPromise;
     return {
       entryInfos: _keyBy('id')(rawEntryInfos),
       daysToEntries: daysToEntriesFromEntryInfos(rawEntryInfos),
       lastUserInteractionCalendar: initialTime,
     };
   })();
   const userStorePromise = (async () => {
     const userInfos = await userInfoPromise;
     return { userInfos, inconsistencyReports: [] };
   })();
 
   const navInfoPromise = (async () => {
     const [{ threadInfos }, messageStore] = await Promise.all([
       threadInfoPromise,
       messageStorePromise,
     ]);
     const finalNavInfo = initialNavInfo;
 
     const requestedActiveChatThreadID = finalNavInfo.activeChatThreadID;
     if (
       requestedActiveChatThreadID &&
       !threadHasPermission(
         threadInfos[requestedActiveChatThreadID],
         threadPermissions.VISIBLE,
       )
     ) {
       finalNavInfo.activeChatThreadID = null;
     }
 
     if (!finalNavInfo.activeChatThreadID) {
       const mostRecentThread = mostRecentlyReadThread(
         messageStore,
         threadInfos,
       );
       if (mostRecentThread) {
         finalNavInfo.activeChatThreadID = mostRecentThread;
       }
     }
 
     return finalNavInfo;
   })();
 
   const { jsURL, fontsURL, cssInclude } = await assetInfoPromise;
 
   // prettier-ignore
   res.write(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>${getTitle(0)}</title>
         <base href="${basePath}" />
         <link rel="stylesheet" type="text/css" href="${fontsURL}" />
         ${cssInclude}
         <link
           rel="apple-touch-icon"
           sizes="180x180"
           href="apple-touch-icon.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="32x32"
           href="favicon-32x32.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="16x16"
           href="favicon-16x16.png"
         />
         <link rel="manifest" href="site.webmanifest" />
         <link rel="mask-icon" href="safari-pinned-tab.svg" color="#b91d47" />
         <meta name="apple-mobile-web-app-title" content="Comm" />
         <meta name="application-name" content="Comm" />
         <meta name="msapplication-TileColor" content="#b91d47" />
         <meta name="theme-color" content="#b91d47" />
       </head>
       <body>
         <div id="react-root">
   `);
 
   const statePromises = {
     navInfo: navInfoPromise,
     currentUserInfo: ((currentUserInfoPromise: any): Promise<CurrentUserInfo>),
     sessionID: sessionIDPromise,
     entryStore: entryStorePromise,
     threadStore: threadStorePromise,
     userStore: userStorePromise,
     messageStore: messageStorePromise,
     updatesCurrentAsOf: initialTime,
     loadingStatuses: {},
     calendarFilters: defaultCalendarFilters,
     // We can use paths local to the <base href> on web
     urlPrefix: '',
     windowDimensions: { width: 0, height: 0 },
     baseHref,
     connection: {
       ...defaultConnectionInfo('web', viewer.timeZone),
       actualizedCalendarQuery: calendarQuery,
     },
     watchedThreadIDs: [],
     lifecycleState: 'active',
     enabledApps: defaultWebEnabledApps,
     reportStore: {
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     },
     nextLocalID: 0,
     timeZone: viewer.timeZone,
     userAgent: viewer.userAgent,
     cookie: undefined,
     deviceToken: undefined,
     dataLoaded: viewer.loggedIn,
     windowActive: true,
   };
 
   const [stateResult, App] = await Promise.all([
     promiseAll(statePromises),
     appPromise,
   ]);
   const state: AppState = { ...stateResult };
   const store: Store<AppState, Action> = createStore(reducer, state);
 
   const routerContext = {};
   const reactStream = renderToNodeStream(
     <Provider store={store}>
       <StaticRouter
         location={req.url}
         basename={baseURL}
         context={routerContext}
       >
         <Route path="*" component={App} />
       </StaticRouter>
     </Provider>,
   );
   if (routerContext.url) {
     throw new ServerError('URL modified during server render!');
   }
   reactStream.pipe(res, { end: false });
   await waitForStream(reactStream);
   res.write(html`
     </div>
     <script>
       var preloadedState =
   `);
 
   const filteredStatePromises = {
     ...statePromises,
     timeZone: null,
     userAgent: null,
   };
   const jsonStream = streamJSON(res, filteredStatePromises);
   await waitForStream(jsonStream);
   res.end(html`
     ;
           var baseURL = "${baseURL}";
         </script>
         <script src="${jsURL}"></script>
       </body>
     </html>
   `);
 }
 
 export { websiteResponder };
diff --git a/server/src/session/cookies.js b/server/src/session/cookies.js
index 73f24beb1..d8e706e60 100644
--- a/server/src/session/cookies.js
+++ b/server/src/session/cookies.js
@@ -1,809 +1,809 @@
 // @flow
 
 import crypto from 'crypto';
 import type { $Response, $Request } from 'express';
 import invariant from 'invariant';
 import bcrypt from 'twin-bcrypt';
 import url from 'url';
 
 import { hasMinCodeVersion } from 'lib/shared/version-utils';
 import type { Shape } from 'lib/types/core';
 import type { Platform, PlatformDetails } from 'lib/types/device-types';
 import type { CalendarQuery } from 'lib/types/entry-types';
 import {
   type ServerSessionChange,
   cookieLifetime,
   cookieSources,
   type CookieSource,
   cookieTypes,
   sessionIdentifierTypes,
   type SessionIdentifierType,
 } from 'lib/types/session-types';
 import type { InitialClientSocketMessage } from 'lib/types/socket-types';
 import type { UserInfo } from 'lib/types/user-types';
 import { values } from 'lib/utils/objects';
 import { promiseAll } from 'lib/utils/promises';
 
 import createIDs from '../creators/id-creator';
 import { createSession } from '../creators/session-creator';
 import { dbQuery, SQL } from '../database/database';
 import { deleteCookie } from '../deleters/cookie-deleters';
 import { handleAsyncPromise } from '../responders/handlers';
 import { clearDeviceToken } from '../updaters/device-token-updaters';
 import { updateThreadMembers } from '../updaters/thread-updaters';
 import { assertSecureRequest } from '../utils/security-utils';
-import { getAppURLFacts } from '../utils/urls';
+import { getSquadCalURLFacts } from '../utils/urls';
 import { Viewer } from './viewer';
 import type { AnonymousViewerData, UserViewerData } from './viewer';
 
-const { baseDomain, basePath, https } = getAppURLFacts();
+const { baseDomain, basePath, https } = getSquadCalURLFacts();
 
 function cookieIsExpired(lastUsed: number) {
   return lastUsed + cookieLifetime <= Date.now();
 }
 
 type SessionParameterInfo = {
   isSocket: boolean,
   sessionID: ?string,
   sessionIdentifierType: SessionIdentifierType,
   ipAddress: string,
   userAgent: ?string,
 };
 
 type FetchViewerResult =
   | { type: 'valid', viewer: Viewer }
   | InvalidFetchViewerResult;
 
 type InvalidFetchViewerResult =
   | {
       type: 'nonexistant',
       cookieName: ?string,
       cookieSource: ?CookieSource,
       sessionParameterInfo: SessionParameterInfo,
     }
   | {
       type: 'invalidated',
       cookieName: string,
       cookieID: string,
       cookieSource: CookieSource,
       sessionParameterInfo: SessionParameterInfo,
       platformDetails: ?PlatformDetails,
       deviceToken: ?string,
     };
 
 async function fetchUserViewer(
   cookie: string,
   cookieSource: CookieSource,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   const [cookieID, cookiePassword] = cookie.split(':');
   if (!cookieID || !cookiePassword) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.USER,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   const query = SQL`
     SELECT hash, user, last_used, platform, device_token, versions
     FROM cookies
     WHERE id = ${cookieID} AND user IS NOT NULL
   `;
   const [[result], allSessionInfo] = await Promise.all([
     dbQuery(query),
     fetchSessionInfo(sessionParameterInfo, cookieID),
   ]);
   if (result.length === 0) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.USER,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   let sessionID = null,
     sessionInfo = null;
   if (allSessionInfo) {
     ({ sessionID, ...sessionInfo } = allSessionInfo);
   }
 
   const cookieRow = result[0];
   let platformDetails = null;
   if (cookieRow.versions) {
     platformDetails = {
       platform: cookieRow.platform,
       codeVersion: cookieRow.versions.codeVersion,
       stateVersion: cookieRow.versions.stateVersion,
     };
   } else {
     platformDetails = { platform: cookieRow.platform };
   }
   const deviceToken = cookieRow.device_token;
 
   if (
     !bcrypt.compareSync(cookiePassword, cookieRow.hash) ||
     cookieIsExpired(cookieRow.last_used)
   ) {
     return {
       type: 'invalidated',
       cookieName: cookieTypes.USER,
       cookieID,
       cookieSource,
       sessionParameterInfo,
       platformDetails,
       deviceToken,
     };
   }
   const userID = cookieRow.user.toString();
   const viewer = new Viewer({
     isSocket: sessionParameterInfo.isSocket,
     loggedIn: true,
     id: userID,
     platformDetails,
     deviceToken,
     userID,
     cookieSource,
     cookieID,
     cookiePassword,
     sessionIdentifierType: sessionParameterInfo.sessionIdentifierType,
     sessionID,
     sessionInfo,
     isScriptViewer: false,
     ipAddress: sessionParameterInfo.ipAddress,
     userAgent: sessionParameterInfo.userAgent,
   });
   return { type: 'valid', viewer };
 }
 
 async function fetchAnonymousViewer(
   cookie: string,
   cookieSource: CookieSource,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   const [cookieID, cookiePassword] = cookie.split(':');
   if (!cookieID || !cookiePassword) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.ANONYMOUS,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   const query = SQL`
     SELECT last_used, hash, platform, device_token, versions
     FROM cookies
     WHERE id = ${cookieID} AND user IS NULL
   `;
   const [[result], allSessionInfo] = await Promise.all([
     dbQuery(query),
     fetchSessionInfo(sessionParameterInfo, cookieID),
   ]);
   if (result.length === 0) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.ANONYMOUS,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   let sessionID = null,
     sessionInfo = null;
   if (allSessionInfo) {
     ({ sessionID, ...sessionInfo } = allSessionInfo);
   }
 
   const cookieRow = result[0];
   let platformDetails = null;
   if (cookieRow.platform && cookieRow.versions) {
     platformDetails = {
       platform: cookieRow.platform,
       codeVersion: cookieRow.versions.codeVersion,
       stateVersion: cookieRow.versions.stateVersion,
     };
   } else if (cookieRow.platform) {
     platformDetails = { platform: cookieRow.platform };
   }
   const deviceToken = cookieRow.device_token;
 
   if (
     !bcrypt.compareSync(cookiePassword, cookieRow.hash) ||
     cookieIsExpired(cookieRow.last_used)
   ) {
     return {
       type: 'invalidated',
       cookieName: cookieTypes.ANONYMOUS,
       cookieID,
       cookieSource,
       sessionParameterInfo,
       platformDetails,
       deviceToken,
     };
   }
   const viewer = new Viewer({
     isSocket: sessionParameterInfo.isSocket,
     loggedIn: false,
     id: cookieID,
     platformDetails,
     deviceToken,
     cookieSource,
     cookieID,
     cookiePassword,
     sessionIdentifierType: sessionParameterInfo.sessionIdentifierType,
     sessionID,
     sessionInfo,
     isScriptViewer: false,
     ipAddress: sessionParameterInfo.ipAddress,
     userAgent: sessionParameterInfo.userAgent,
   });
   return { type: 'valid', viewer };
 }
 
 type SessionInfo = {
   +sessionID: ?string,
   +lastValidated: number,
   +lastUpdate: number,
   +calendarQuery: CalendarQuery,
 };
 async function fetchSessionInfo(
   sessionParameterInfo: SessionParameterInfo,
   cookieID: string,
 ): Promise<?SessionInfo> {
   const { sessionID } = sessionParameterInfo;
   const session = sessionID !== undefined ? sessionID : cookieID;
   if (!session) {
     return null;
   }
   const query = SQL`
     SELECT query, last_validated, last_update
     FROM sessions
     WHERE id = ${session} AND cookie = ${cookieID}
   `;
   const [result] = await dbQuery(query);
   if (result.length === 0) {
     return null;
   }
   return {
     sessionID,
     lastValidated: result[0].last_validated,
     lastUpdate: result[0].last_update,
     calendarQuery: result[0].query,
   };
 }
 
 // This function is meant to consume a cookie that has already been processed.
 // That means it doesn't have any logic to handle an invalid cookie, and it
 // doesn't update the cookie's last_used timestamp.
 async function fetchViewerFromCookieData(
   req: $Request,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   let viewerResult;
   const { user, anonymous } = req.cookies;
   if (user) {
     viewerResult = await fetchUserViewer(
       user,
       cookieSources.HEADER,
       sessionParameterInfo,
     );
   } else if (anonymous) {
     viewerResult = await fetchAnonymousViewer(
       anonymous,
       cookieSources.HEADER,
       sessionParameterInfo,
     );
   } else {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: null,
       sessionParameterInfo,
     };
   }
 
   // We protect against CSRF attacks by making sure that on web,
   // non-GET requests cannot use a bare cookie for session identification
   if (viewerResult.type === 'valid') {
     const { viewer } = viewerResult;
     invariant(
       req.method === 'GET' ||
         viewer.sessionIdentifierType !== sessionIdentifierTypes.COOKIE_ID ||
         viewer.platform !== 'web',
       'non-GET request from web using sessionIdentifierTypes.COOKIE_ID',
     );
   }
 
   return viewerResult;
 }
 
 async function fetchViewerFromRequestBody(
   body: mixed,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   if (!body || typeof body !== 'object') {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: null,
       sessionParameterInfo,
     };
   }
   const cookiePair = body.cookie;
   if (cookiePair === null || cookiePair === '') {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: cookieSources.BODY,
       sessionParameterInfo,
     };
   }
   if (!cookiePair || typeof cookiePair !== 'string') {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: null,
       sessionParameterInfo,
     };
   }
   const [type, cookie] = cookiePair.split('=');
   if (type === cookieTypes.USER && cookie) {
     return await fetchUserViewer(
       cookie,
       cookieSources.BODY,
       sessionParameterInfo,
     );
   } else if (type === cookieTypes.ANONYMOUS && cookie) {
     return await fetchAnonymousViewer(
       cookie,
       cookieSources.BODY,
       sessionParameterInfo,
     );
   }
   return {
     type: 'nonexistant',
     cookieName: null,
     cookieSource: null,
     sessionParameterInfo,
   };
 }
 
 function getSessionParameterInfoFromRequestBody(
   req: $Request,
 ): SessionParameterInfo {
   const body = (req.body: any);
   let sessionID =
     body.sessionID !== undefined || req.method !== 'GET'
       ? body.sessionID
       : null;
   if (sessionID === '') {
     sessionID = null;
   }
   const sessionIdentifierType =
     req.method === 'GET' || sessionID !== undefined
       ? sessionIdentifierTypes.BODY_SESSION_ID
       : sessionIdentifierTypes.COOKIE_ID;
   const ipAddress = req.get('X-Forwarded-For');
   invariant(ipAddress, 'X-Forwarded-For header missing');
   return {
     isSocket: false,
     sessionID,
     sessionIdentifierType,
     ipAddress,
     userAgent: req.get('User-Agent'),
   };
 }
 
 async function fetchViewerForJSONRequest(req: $Request): Promise<Viewer> {
   assertSecureRequest(req);
   const sessionParameterInfo = getSessionParameterInfoFromRequestBody(req);
   let result = await fetchViewerFromRequestBody(req.body, sessionParameterInfo);
   if (
     result.type === 'nonexistant' &&
     (result.cookieSource === null || result.cookieSource === undefined)
   ) {
     result = await fetchViewerFromCookieData(req, sessionParameterInfo);
   }
   return await handleFetchViewerResult(result);
 }
 
 const webPlatformDetails = { platform: 'web' };
 async function fetchViewerForHomeRequest(req: $Request): Promise<Viewer> {
   assertSecureRequest(req);
   const sessionParameterInfo = getSessionParameterInfoFromRequestBody(req);
   const result = await fetchViewerFromCookieData(req, sessionParameterInfo);
   return await handleFetchViewerResult(result, webPlatformDetails);
 }
 
 async function fetchViewerForSocket(
   req: $Request,
   clientMessage: InitialClientSocketMessage,
 ): Promise<?Viewer> {
   assertSecureRequest(req);
   const { sessionIdentification } = clientMessage.payload;
   const { sessionID } = sessionIdentification;
   const ipAddress = req.get('X-Forwarded-For');
   invariant(ipAddress, 'X-Forwarded-For header missing');
   const sessionParameterInfo = {
     isSocket: true,
     sessionID,
     sessionIdentifierType:
       sessionID !== undefined
         ? sessionIdentifierTypes.BODY_SESSION_ID
         : sessionIdentifierTypes.COOKIE_ID,
     ipAddress,
     userAgent: req.get('User-Agent'),
   };
 
   let result = await fetchViewerFromRequestBody(
     clientMessage.payload.sessionIdentification,
     sessionParameterInfo,
   );
   if (
     result.type === 'nonexistant' &&
     (result.cookieSource === null || result.cookieSource === undefined)
   ) {
     result = await fetchViewerFromCookieData(req, sessionParameterInfo);
   }
   if (result.type === 'valid') {
     return result.viewer;
   }
 
   const promises = {};
   if (result.cookieSource === cookieSources.BODY) {
     // We initialize a socket's Viewer after the WebSocket handshake, since to
     // properly initialize the Viewer we need a bunch of data, but that data
     // can't be sent until after the handshake. Consequently, by the time we
     // know that a cookie may be invalid, we are no longer communicating via
     // HTTP, and have no way to set a new cookie for HEADER (web) clients.
     const platformDetails =
       result.type === 'invalidated' ? result.platformDetails : null;
     const deviceToken =
       result.type === 'invalidated' ? result.deviceToken : null;
     promises.anonymousViewerData = createNewAnonymousCookie({
       platformDetails,
       deviceToken,
     });
   }
   if (result.type === 'invalidated') {
     promises.deleteCookie = deleteCookie(result.cookieID);
   }
   const { anonymousViewerData } = await promiseAll(promises);
 
   if (!anonymousViewerData) {
     return null;
   }
 
   return createViewerForInvalidFetchViewerResult(result, anonymousViewerData);
 }
 
 async function handleFetchViewerResult(
   result: FetchViewerResult,
   inputPlatformDetails?: PlatformDetails,
 ) {
   if (result.type === 'valid') {
     return result.viewer;
   }
 
   let platformDetails = inputPlatformDetails;
   if (!platformDetails && result.type === 'invalidated') {
     platformDetails = result.platformDetails;
   }
   const deviceToken = result.type === 'invalidated' ? result.deviceToken : null;
 
   const [anonymousViewerData] = await Promise.all([
     createNewAnonymousCookie({ platformDetails, deviceToken }),
     result.type === 'invalidated' ? deleteCookie(result.cookieID) : null,
   ]);
 
   return createViewerForInvalidFetchViewerResult(result, anonymousViewerData);
 }
 
 function createViewerForInvalidFetchViewerResult(
   result: InvalidFetchViewerResult,
   anonymousViewerData: AnonymousViewerData,
 ): Viewer {
   // If a null cookie was specified in the request body, result.cookieSource
   // will still be BODY here. The only way it would be null or undefined here
   // is if there was no cookie specified in either the body or the header, in
   // which case we default to returning the new cookie in the response header.
   const cookieSource =
     result.cookieSource !== null && result.cookieSource !== undefined
       ? result.cookieSource
       : cookieSources.HEADER;
   const viewer = new Viewer({
     ...anonymousViewerData,
     cookieSource,
     sessionIdentifierType: result.sessionParameterInfo.sessionIdentifierType,
     isSocket: result.sessionParameterInfo.isSocket,
     ipAddress: result.sessionParameterInfo.ipAddress,
     userAgent: result.sessionParameterInfo.userAgent,
   });
   viewer.sessionChanged = true;
 
   // If cookieName is falsey, that tells us that there was no cookie specified
   // in the request, which means we can't be invalidating anything.
   if (result.cookieName) {
     viewer.cookieInvalidated = true;
     viewer.initialCookieName = result.cookieName;
   }
 
   return viewer;
 }
 
 const domainAsURL = new url.URL(baseDomain);
 function addSessionChangeInfoToResult(
   viewer: Viewer,
   res: $Response,
   result: Object,
 ) {
   let threadInfos = {},
     userInfos = {};
   if (result.cookieChange) {
     ({ threadInfos, userInfos } = result.cookieChange);
   }
   let sessionChange;
   if (viewer.cookieInvalidated) {
     sessionChange = ({
       cookieInvalidated: true,
       threadInfos,
       userInfos: (values(userInfos).map(a => a): UserInfo[]),
       currentUserInfo: {
         id: viewer.cookieID,
         anonymous: true,
       },
     }: ServerSessionChange);
   } else {
     sessionChange = ({
       cookieInvalidated: false,
       threadInfos,
       userInfos: (values(userInfos).map(a => a): UserInfo[]),
     }: ServerSessionChange);
   }
   if (viewer.cookieSource === cookieSources.BODY) {
     sessionChange.cookie = viewer.cookiePairString;
   } else {
     addActualHTTPCookie(viewer, res);
   }
   if (viewer.sessionIdentifierType === sessionIdentifierTypes.BODY_SESSION_ID) {
     sessionChange.sessionID = viewer.sessionID ? viewer.sessionID : null;
   }
   result.cookieChange = sessionChange;
 }
 
 type AnonymousCookieCreationParams = Shape<{
   +platformDetails: ?PlatformDetails,
   +deviceToken: ?string,
 }>;
 const defaultPlatformDetails = {};
 
 // The result of this function should not be passed directly to the Viewer
 // constructor. Instead, it should be passed to viewer.setNewCookie. There are
 // several fields on AnonymousViewerData that are not set by this function:
 // sessionIdentifierType, cookieSource, ipAddress, and userAgent. These
 // parameters all depend on the initial request. If the result of this function
 // is passed to the Viewer constructor directly, the resultant Viewer object
 // will throw whenever anybody attempts to access the relevant properties.
 async function createNewAnonymousCookie(
   params: AnonymousCookieCreationParams,
 ): Promise<AnonymousViewerData> {
   const { platformDetails, deviceToken } = params;
   const { platform, ...versions } = platformDetails || defaultPlatformDetails;
   const versionsString =
     Object.keys(versions).length > 0 ? JSON.stringify(versions) : null;
 
   const time = Date.now();
   const cookiePassword = crypto.randomBytes(32).toString('hex');
   const cookieHash = bcrypt.hashSync(cookiePassword);
   const [[id]] = await Promise.all([
     createIDs('cookies', 1),
     deviceToken ? clearDeviceToken(deviceToken) : undefined,
   ]);
 
   const cookieRow = [
     id,
     cookieHash,
     null,
     platform,
     time,
     time,
     deviceToken,
     versionsString,
   ];
   const query = SQL`
     INSERT INTO cookies(id, hash, user, platform, creation_time, last_used,
       device_token, versions)
     VALUES ${[cookieRow]}
   `;
   await dbQuery(query);
   return {
     loggedIn: false,
     id,
     platformDetails,
     deviceToken,
     cookieID: id,
     cookiePassword,
     sessionID: undefined,
     sessionInfo: null,
     cookieInsertedThisRequest: true,
     isScriptViewer: false,
   };
 }
 
 type UserCookieCreationParams = {
   platformDetails: PlatformDetails,
   deviceToken?: ?string,
 };
 
 // The result of this function should never be passed directly to the Viewer
 // constructor. Instead, it should be passed to viewer.setNewCookie. There are
 // several fields on UserViewerData that are not set by this function:
 // sessionID, sessionIdentifierType, cookieSource, and ipAddress. These
 // parameters all depend on the initial request. If the result of this function
 // is passed to the Viewer constructor directly, the resultant Viewer object
 // will throw whenever anybody attempts to access the relevant properties.
 async function createNewUserCookie(
   userID: string,
   params: UserCookieCreationParams,
 ): Promise<UserViewerData> {
   const { platformDetails, deviceToken } = params;
   const { platform, ...versions } = platformDetails || defaultPlatformDetails;
   const versionsString =
     Object.keys(versions).length > 0 ? JSON.stringify(versions) : null;
 
   const time = Date.now();
   const cookiePassword = crypto.randomBytes(32).toString('hex');
   const cookieHash = bcrypt.hashSync(cookiePassword);
   const [[cookieID]] = await Promise.all([
     createIDs('cookies', 1),
     deviceToken ? clearDeviceToken(deviceToken) : undefined,
   ]);
 
   const cookieRow = [
     cookieID,
     cookieHash,
     userID,
     platform,
     time,
     time,
     deviceToken,
     versionsString,
   ];
   const query = SQL`
     INSERT INTO cookies(id, hash, user, platform, creation_time, last_used,
       device_token, versions)
     VALUES ${[cookieRow]}
   `;
   await dbQuery(query);
   return {
     loggedIn: true,
     id: userID,
     platformDetails,
     deviceToken,
     userID,
     cookieID,
     sessionID: undefined,
     sessionInfo: null,
     cookiePassword,
     cookieInsertedThisRequest: true,
     isScriptViewer: false,
   };
 }
 
 // This gets called after createNewUserCookie and from websiteResponder. If the
 // Viewer's sessionIdentifierType is COOKIE_ID then the cookieID is used as the
 // session identifier; otherwise, a new ID is created for the session.
 async function setNewSession(
   viewer: Viewer,
   calendarQuery: CalendarQuery,
   initialLastUpdate: number,
 ): Promise<void> {
   if (viewer.sessionIdentifierType !== sessionIdentifierTypes.COOKIE_ID) {
     const [sessionID] = await createIDs('sessions', 1);
     viewer.setSessionID(sessionID);
   }
   await createSession(viewer, calendarQuery, initialLastUpdate);
 }
 
 async function extendCookieLifespan(cookieID: string) {
   const time = Date.now();
   const query = SQL`
     UPDATE cookies SET last_used = ${time} WHERE id = ${cookieID}
   `;
   await dbQuery(query);
 }
 
 function addCookieToJSONResponse(
   viewer: Viewer,
   res: $Response,
   result: Object,
   expectCookieInvalidation: boolean,
 ) {
   if (expectCookieInvalidation) {
     viewer.cookieInvalidated = false;
   }
   if (!viewer.getData().cookieInsertedThisRequest) {
     handleAsyncPromise(extendCookieLifespan(viewer.cookieID));
   }
   if (viewer.sessionChanged) {
     addSessionChangeInfoToResult(viewer, res, result);
   } else if (viewer.cookieSource !== cookieSources.BODY) {
     addActualHTTPCookie(viewer, res);
   }
 }
 
 function addCookieToHomeResponse(viewer: Viewer, res: $Response) {
   if (!viewer.getData().cookieInsertedThisRequest) {
     handleAsyncPromise(extendCookieLifespan(viewer.cookieID));
   }
   addActualHTTPCookie(viewer, res);
 }
 
 const cookieOptions = {
   domain: domainAsURL.hostname,
   path: basePath,
   httpOnly: true,
   secure: https,
   maxAge: cookieLifetime,
   sameSite: 'Strict',
 };
 function addActualHTTPCookie(viewer: Viewer, res: $Response) {
   res.cookie(viewer.cookieName, viewer.cookieString, cookieOptions);
   if (viewer.cookieName !== viewer.initialCookieName) {
     res.clearCookie(viewer.initialCookieName, cookieOptions);
   }
 }
 
 async function setCookiePlatform(
   viewer: Viewer,
   platform: Platform,
 ): Promise<void> {
   const newPlatformDetails = { ...viewer.platformDetails, platform };
   viewer.setPlatformDetails(newPlatformDetails);
   const query = SQL`
     UPDATE cookies
     SET platform = ${platform}
     WHERE id = ${viewer.cookieID}
   `;
   await dbQuery(query);
 }
 
 async function setCookiePlatformDetails(
   viewer: Viewer,
   platformDetails: PlatformDetails,
 ): Promise<void> {
   if (
     hasMinCodeVersion(platformDetails, 70) &&
     !hasMinCodeVersion(viewer.platformDetails, 70)
   ) {
     await updateThreadMembers(viewer);
   }
 
   viewer.setPlatformDetails(platformDetails);
   const { platform, ...versions } = platformDetails;
   const versionsString =
     Object.keys(versions).length > 0 ? JSON.stringify(versions) : null;
   const query = SQL`
     UPDATE cookies
     SET platform = ${platform}, versions = ${versionsString}
     WHERE id = ${viewer.cookieID}
   `;
   await dbQuery(query);
 }
 
 export {
   fetchViewerForJSONRequest,
   fetchViewerForHomeRequest,
   fetchViewerForSocket,
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
   extendCookieLifespan,
   addCookieToJSONResponse,
   addCookieToHomeResponse,
   setCookiePlatform,
   setCookiePlatformDetails,
 };
diff --git a/server/src/utils/security-utils.js b/server/src/utils/security-utils.js
index 9686c25bb..e17777e71 100644
--- a/server/src/utils/security-utils.js
+++ b/server/src/utils/security-utils.js
@@ -1,15 +1,15 @@
 // @flow
 
 import type { $Request } from 'express';
 
-import { getAppURLFacts } from './urls';
+import { getSquadCalURLFacts } from './urls';
 
-const { https } = getAppURLFacts();
+const { https } = getSquadCalURLFacts();
 
 function assertSecureRequest(req: $Request) {
   if (https && req.get('X-Forwarded-SSL') !== 'on') {
     throw new Error('insecure request');
   }
 }
 
 export { assertSecureRequest };
diff --git a/server/src/utils/urls.js b/server/src/utils/urls.js
index 92c9681a9..6ab8df9fd 100644
--- a/server/src/utils/urls.js
+++ b/server/src/utils/urls.js
@@ -1,33 +1,51 @@
 // @flow
 
-import appURLFacts from '../../facts/app_url';
+import commAppURLFacts from '../../facts/commapp_url';
 import landingURLFacts from '../../facts/landing_url';
+import squadCalURLFacts from '../../facts/squadcal_url';
 import baseURLFacts from '../../facts/url';
 
 type GlobalURLFacts = {
   +baseRoutePath: string,
 };
 
 function getGlobalURLFacts(): GlobalURLFacts {
   return baseURLFacts;
 }
 
-type AppURLFacts = {
+export type AppURLFacts = {
   +baseDomain: string,
   +basePath: string,
   +https: boolean,
 };
 type LandingURLFacts = {
   ...AppURLFacts,
   +baseRoutePath: string,
 };
 
-function getAppURLFacts(): AppURLFacts {
-  return appURLFacts;
+function getSquadCalURLFacts(): AppURLFacts {
+  return squadCalURLFacts;
+}
+
+function getCommAppURLFacts(): AppURLFacts {
+  return commAppURLFacts;
+}
+
+function getAppURLFactsFromRequestURL(url: string): AppURLFacts {
+  const commURLFacts = getCommAppURLFacts();
+  return url.startsWith(commURLFacts.basePath)
+    ? commURLFacts
+    : getSquadCalURLFacts();
 }
 
 function getLandingURLFacts(): LandingURLFacts {
   return landingURLFacts;
 }
 
-export { getGlobalURLFacts, getAppURLFacts, getLandingURLFacts };
+export {
+  getGlobalURLFacts,
+  getSquadCalURLFacts,
+  getCommAppURLFacts,
+  getLandingURLFacts,
+  getAppURLFactsFromRequestURL,
+};