bump version to alpha release

* skip  "alwaysStrict": true

* bump to 3.3.2

* remove all new ts check to be sure

.github/workflows/build_cli.yml

@@ -0,0 +1,53 @@
+name: Ontime CLI build
+
+on:
+  push:
+    tags: [ "*" ]
+  workflow_dispatch:
+
+jobs:
+  build_cli:
+    permissions:
+      id-token: write
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18.18.2
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 8
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build project packages
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+        run: pnpm build
+
+      - name: Copy server
+        run: mkdir -p apps/cli/server && cp apps/server/dist/index.cjs apps/cli/server/index.cjs
+      
+      - name: Copy client
+        run: cp -R apps/client/build apps/cli/client
+
+      - name: Copy external
+        run: cp -R apps/server/src/external apps/cli/external
+      
+      - name: Publish to NPM
+        run: pnpm publish --access public --no-git-checks
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+        working-directory: ./apps/cli

DEVELOPMENT.md

@@ -81,6 +81,9 @@ From the project root, run the following commands
 
 The build distribution assets will be at `.apps/electron/dist`
 
+Note: The MacOS build will only work in CI, locally it will fail due to notarisation issues.
+Use the `turbo dist-mac:local` command to build a MacOS distribution locally.
+
 ## DOCKER
 
 Ontime provides a docker-compose file to aid with building and running docker images.

apps/cli/.eslintrc

@@ -0,0 +1,16 @@
+{
+  "parserOptions": {
+    "sourceType": "module"
+  },
+  "env": {
+    "browser": true,
+    "node": true
+  },
+  "extends": [
+    "eslint:recommended"
+  ],
+  "plugins": [],
+  "rules": {
+    "@typescript-eslint/no-var-requires": "off"
+  }
+}

apps/cli/.gitignore

@@ -0,0 +1,3 @@
+server
+external
+client

apps/cli/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "endOfLine": "lf",
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "jsxSingleQuote": true,
+  "printWidth": 120
+}

apps/cli/README.md

@@ -0,0 +1,44 @@
+# Ontime CLI
+
+![Ontime](https://github.com/cpvalente/ontime/blob/9e63261b350e5b7b61c7ffb17c9e75a6c5a8c711/.github/aux-images/editor.png)
+> Ontime is an application for managing rundown and event timers.
+
+Congratulations! You got this far into Ontime's rabbit hole and want to manage your installation.
+
+The CLI tool is a fast and lightweight way of installing Ontime and is perfect for self-hosting and headless installs.
+
+## Getting started
+
+### Prerequisites
+You will need to have installed the correct version of node.js
+Please check [the app engines declaration](https://github.com/cpvalente/ontime/blob/master/package.json) for the correct version.
+
+### Running Ontime
+To get Ontime running, all you need to do is install it in your system using your package manager of choice:
+
+Install globally in your system 
+```bash
+npm install -g @getontime/cli
+```
+
+... and run using the installed script
+```bash
+ontime
+```
+
+Or install and run ontime (the installation here is temporary for the duration of the session)
+```bash
+npx install @getontime/cli
+```
+
+## Links
+- [Ontime's repository](https://github.com/cpvalente/ontime)
+- [Ontime's documentation](https://docs.getontime.no/)
+- [Ontime's website](https://getontime.no/)
+
+## Sponsoring
+You can help the development of this project or say thank you with a one time donation. \
+See the [terms of donations](https://github.com/cpvalente/ontime/blob/master/SPONSOR.md)
+
+[![](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86)](https://github.com/sponsors/cpvalente)
+[![](https://img.shields.io/static/v1?label=Buy%20me%20a%20coffee&message=%E2%9D%A4&logo=buymeacoffee&color=%23fe8e86)](https://www.buymeacoffee.com/cpvalente)

apps/cli/main.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+// NOTE: for now the following needs to be in place: ./server/index.cjs, ./client, ./external
+
+const ontimeServer = require('./server/index.cjs');
+const { initAssets, startServer, startIntegrations, shutdown } = ontimeServer;
+
+async function startOntime() {
+  await initAssets();
+
+  await startServer();
+
+  await startIntegrations();
+}
+
+startOntime();
+
+process.on(['SIGHUP', 'SIGINT', 'SIGTERM'], () => {
+  shutdown();
+});

apps/cli/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@getontime/cli",
+    "version": "3.4.0-alpha-timeline",
+    "author": "Carlos Valente",
+    "description": "Time keeping for live events",
+    "repository": "https://github.com/cpvalente/ontime",
+    "keywords": [
+        "lighdev",
+        "ontime",
+        "timer"
+    ],
+    "license": "AGPL-3.0-only",
+    "main": "main.js",
+    "bin": {
+        "ontime": "main.js"
+    },
+    "files": [
+        "client",
+        "external",
+        "server"
+    ],
+    "devDependencies": {
+        "eslint": "^8.53.0",
+        "eslint-config-prettier": "^9.0.0",
+        "prettier": "^3.0.3"
+    }
+}

apps/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime-ui",
-  "version": "3.1.1",
+  "version": "3.4.0-alpha-timeline",
   "private": true,
   "type": "module",
   "dependencies": {
@@ -70,13 +70,13 @@
     "@types/react": "^18.0.26",
     "@types/react-dom": "^18.0.10",
     "@types/testing-library__jest-dom": "^5.14.5",
-    "@typescript-eslint/eslint-plugin": "^6.10.0",
-    "@typescript-eslint/parser": "^6.10.0",
+    "@typescript-eslint/eslint-plugin": "^v7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
     "@vitejs/plugin-react": "^4.2.1",
-    "eslint": "^8.53.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-jest": "^27.6.0",
-    "eslint-plugin-prettier": "^5.0.1",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-jest": "^28.6.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-react": "^7.32.0",
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-simple-import-sort": "^8.0.0",
@@ -84,7 +84,7 @@
     "jsdom": "^21.1.0",
     "ontime-types": "workspace:*",
     "ontime-utils": "workspace:*",
-    "prettier": "^3.0.3",
+    "prettier": "^3.3.1",
     "sass": "^1.57.1",
     "typescript": "^5.4.3",
     "vite": "^5.2.11",

apps/client/src/App.tsx

@@ -4,16 +4,15 @@ import { QueryClientProvider } from '@tanstack/react-query';
 import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
 
 import ErrorBoundary from './common/components/error-boundary/ErrorBoundary';
+import IdentifyOverlay from './common/components/identify-overlay/IdentifyOverlay';
 import { AppContextProvider } from './common/context/AppContext';
 import { ontimeQueryClient } from './common/queryClient';
-import { socketClientName } from './common/stores/connectionName';
 import { connectSocket } from './common/utils/socket';
 import theme from './theme/theme';
 import { TranslationProvider } from './translation/TranslationProvider';
 import AppRouter from './AppRouter';
 
-const preferredClientName = socketClientName.getState().name;
-connectSocket(preferredClientName);
+connectSocket();
 
 function App() {
   return (
@@ -24,11 +23,15 @@ function App() {
             <div className='App'>
               <ErrorBoundary>
                 <TranslationProvider>
+                  <IdentifyOverlay />
                   <AppRouter />
                 </TranslationProvider>
               </ErrorBoundary>
               <ReactQueryDevtools initialIsOpen={false} />
             </div>
+            <ErrorBoundary>
+              <div id='identify-portal' />
+            </ErrorBoundary>
           </BrowserRouter>
         </AppContextProvider>
       </QueryClientProvider>

apps/client/src/AppRouter.tsx

@@ -1,6 +1,7 @@
 import { lazy, Suspense } from 'react';
 import { Navigate, Route, Routes } from 'react-router-dom';
 
+import { useClientPath } from './common/hooks/useClientPath';
 import Log from './features/log/Log';
 import withPreset from './features/PresetWrapper';
 import withData from './features/viewers/ViewWrapper';
@@ -16,6 +17,7 @@ const Countdown = lazy(() => import('./features/viewers/countdown/Countdown'));
 
 const Backstage = lazy(() => import('./features/viewers/backstage/Backstage'));
 const Public = lazy(() => import('./features/viewers/public/Public'));
+const Timeline = lazy(() => import('./features/timeline/TimelinePage'));
 const Lower = lazy(() => import('./features/viewers/lower-thirds/LowerThird'));
 const StudioClock = lazy(() => import('./features/viewers/studio/StudioClock'));
 
@@ -25,6 +27,7 @@ const SClock = withPreset(withData(ClockView));
 const SCountdown = withPreset(withData(Countdown));
 const SBackstage = withPreset(withData(Backstage));
 const SPublic = withPreset(withData(Public));
+const STimeline = withPreset(withData(Timeline));
 const SLowerThird = withPreset(withData(Lower));
 const SStudio = withPreset(withData(StudioClock));
 
@@ -34,6 +37,9 @@ const TimerControl = lazy(() => import('./features/control/playback/TimerControl
 const MessageControl = lazy(() => import('./features/control/message/MessageControlExport'));
 
 export default function AppRouter() {
+  // handle client path changes
+  useClientPath();
+
   return (
     <Suspense fallback={null}>
       <Routes>
@@ -56,6 +62,8 @@ export default function AppRouter() {
 
         <Route path='/op' element={<Operator />} />
 
+        <Route path='/timeline' element={<STimeline />} />
+
         {/*/!* Protected Routes *!/*/}
         <Route path='/editor' element={<Editor />} />
         <Route path='/cuesheet' element={<Cuesheet />} />

apps/client/src/common/api/constants.ts

@@ -11,6 +11,7 @@ export const RUNTIME = ['runtimeStore'];
 export const SHEET_STATE = ['sheetState'];
 export const URL_PRESETS = ['urlpresets'];
 export const VIEW_SETTINGS = ['viewSettings'];
+export const CLIENT_LIST = ['clientList'];
 
 // resolve location
 const location = window.location;

apps/client/src/common/api/db.ts

@@ -11,8 +11,8 @@ const dbPath = `${apiEntryUrl}/db`;
 /**
  * HTTP request to the current DB
  */
-async function getDb(fileName?: string): Promise<AxiosResponse<DatabaseModel>> {
-  return axios.post(`${dbPath}/download/`, { fileName });
+async function getDb(filename: string): Promise<AxiosResponse<DatabaseModel>> {
+  return axios.post(`${dbPath}/download/`, { filename });
 }
 
 /**
@@ -123,7 +123,7 @@ export async function renameProject(filename: string, newFilename: string): Prom
   const url = `${dbPath}/${filename}/rename`;
   const decodedUrl = decodeURIComponent(url);
   const res = await axios.put(decodedUrl, {
-    newFilename,
+    filename: newFilename,
   });
   return res.data;
 }

apps/client/src/common/components/client-modal/ClientModal.module.scss

@@ -0,0 +1,6 @@
+.buttonSection {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: $element-spacing;
+  margin-top: -$element-spacing;
+}

apps/client/src/common/components/client-modal/RedirectClientModal.tsx

@@ -0,0 +1,69 @@
+import { useState } from 'react';
+import {
+  Button,
+  Input,
+  InputGroup,
+  InputLeftAddon,
+  Modal,
+  ModalBody,
+  ModalCloseButton,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  ModalOverlay,
+} from '@chakra-ui/react';
+
+import { setClientRemote } from '../../hooks/useSocket';
+
+import style from './ClientModal.module.scss';
+
+interface RedirectClientModalProps {
+  id: string;
+  name?: string;
+  path?: string;
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+export function RedirectClientModal(props: RedirectClientModalProps) {
+  const { id, isOpen, name = '', path: currentPath = '', onClose } = props;
+  const [path, setPath] = useState(currentPath);
+
+  const { setRedirect } = setClientRemote;
+
+  const handleRedirect = () => {
+    if (path !== currentPath && path !== '') {
+      setRedirect({ target: id, redirect: path });
+    }
+    onClose();
+  };
+
+  const host = `${window.location.origin}/`;
+  const canSubmit = path !== currentPath && path !== '';
+
+  return (
+    <Modal isOpen={isOpen} onClose={onClose} variant='ontime'>
+      <ModalOverlay />
+      <ModalContent>
+        <ModalHeader>Redirect: {name}</ModalHeader>
+        <ModalCloseButton />
+        <ModalBody>
+          <InputGroup variant='ontime-filled' size='md'>
+            <InputLeftAddon>{host}</InputLeftAddon>
+            <Input placeholder='minimal?key=0000ffff' value={path} onChange={(event) => setPath(event.target.value)} />
+          </InputGroup>
+        </ModalBody>
+        <ModalFooter>
+          <div className={style.buttonSection}>
+            <Button size='md' variant='ontime-subtle' onClick={onClose}>
+              Cancel
+            </Button>
+            <Button size='md' variant='ontime-filled' onClick={handleRedirect} isDisabled={!canSubmit}>
+              Submit
+            </Button>
+          </div>
+        </ModalFooter>
+      </ModalContent>
+    </Modal>
+  );
+}

apps/client/src/common/components/client-modal/RenameClientModal.tsx

@@ -0,0 +1,68 @@
+import { useState } from 'react';
+import {
+  Button,
+  Input,
+  Modal,
+  ModalBody,
+  ModalCloseButton,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  ModalOverlay,
+} from '@chakra-ui/react';
+
+import { setClientRemote } from '../../hooks/useSocket';
+
+import style from './ClientModal.module.scss';
+
+interface RenameClientModalProps {
+  id: string;
+  name?: string;
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+export function RenameClientModal(props: RenameClientModalProps) {
+  const { id, name: currentName = '', isOpen, onClose } = props;
+  const [name, setName] = useState(currentName);
+
+  const { setClientName } = setClientRemote;
+
+  const handleRename = () => {
+    if (name !== currentName && name !== '') {
+      setClientName({ target: id, rename: name });
+    }
+    onClose();
+  };
+
+  const canSubmit = name !== currentName && name !== '';
+
+  return (
+    <Modal isOpen={isOpen} onClose={onClose} variant='ontime'>
+      <ModalOverlay />
+      <ModalContent>
+        <ModalHeader>Rename: {currentName}</ModalHeader>
+        <ModalCloseButton />
+        <ModalBody>
+          <Input
+            variant='ontime-filled'
+            size='md'
+            placeholder='new name'
+            value={name}
+            onChange={(event) => setName(event.target.value)}
+          />
+        </ModalBody>
+        <ModalFooter>
+          <div className={style.buttonSection}>
+            <Button size='md' variant='ontime-subtle' onClick={onClose}>
+              Cancel
+            </Button>
+            <Button size='md' variant='ontime-filled' onClick={handleRename} isDisabled={!canSubmit}>
+              Submit
+            </Button>
+          </div>
+        </ModalFooter>
+      </ModalContent>
+    </Modal>
+  );
+}

apps/client/src/common/components/identify-overlay/IdentifyOverlay.module.scss

@@ -0,0 +1,34 @@
+.overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  margin: 0;
+  width: 100vw;
+  height: 100vh;
+  padding: 0;
+  box-sizing: border-box;
+
+  border: 10px solid $ui-white;
+  background-color: $ui-black;
+
+  color: $ui-white;
+  display: grid;
+  place-content: center;
+  text-align: center;
+  z-index: 100;
+  cursor: pointer;
+}
+
+.name {
+  font-weight: 600;
+  margin-top: -10vh;
+  line-height: 1em;
+  font-size: 12vw;
+  text-transform: uppercase;
+}
+
+.message {
+  color: $label-gray;
+  line-height: 2em;
+  font-size: 3vw;
+}

apps/client/src/common/components/identify-overlay/IdentifyOverlay.tsx

@@ -0,0 +1,64 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
+import { MILLIS_PER_MINUTE } from 'ontime-utils';
+
+import { setClientRemote } from '../../hooks/useSocket';
+import { useClientStore } from '../../stores/clientStore';
+
+import style from './IdentifyOverlay.module.scss';
+
+export default function IdentifyOverlay() {
+  const clients = useClientStore((store) => store.clients);
+  const id = useClientStore((store) => store.id);
+  const showOverlay = clients[id]?.identify;
+
+  if (!showOverlay) {
+    return null;
+  }
+
+  const portalRoot = document.getElementById('identify-portal');
+
+  if (!portalRoot) {
+    return null;
+  }
+  return createPortal(<Overlay />, portalRoot);
+}
+
+function Overlay() {
+  const clients = useClientStore((store) => store.clients);
+  const id = useClientStore((store) => store.id);
+  const name = useClientStore((store) => store.name);
+
+  const timerRef = useRef<NodeJS.Timeout | null>(null);
+
+  const { setIdentify } = setClientRemote;
+  const showOverlay = clients[id]?.identify;
+
+  const handleClose = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+    }
+
+    setIdentify({ target: id, identify: false });
+  }, [id, setIdentify]);
+
+  // start a timer that will close the overlay after some time
+  useEffect(() => {
+    if (showOverlay) {
+      timerRef.current = setTimeout(handleClose, MILLIS_PER_MINUTE);
+    }
+    return () => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, [showOverlay, id, setIdentify, handleClose]);
+
+    console.log('here2');
+  return (
+    <div className={style.overlay} data-testid='identify-overlay' onClick={handleClose}>
+      <div className={style.name}>{name}</div>
+      <div className={style.message}>Click to close</div>
+    </div>
+  );
+}

apps/client/src/common/components/multi-part-progress-bar/MultiPartProgressBar.scss

@@ -7,10 +7,6 @@ $progress-bar-br: 3px;
   position: relative;
   width: 100%;
   height: $progress-bar-size;
-  border-radius: $progress-bar-br;
-  background-color: var(--timer-progress-bg-override, $viewer-card-bg-color);
-  display: flex;
-  overflow: hidden;
 
   &--hidden {
     display: none;
@@ -18,31 +14,42 @@ $progress-bar-br: 3px;
   }
 }
 
+.multiprogress-bar__bg {
+  position: absolute;
+  inset: 0;
+  overflow: hidden;
+  border-radius: var(--progress-bar-br, $progress-bar-br);
+
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-end;
+}
+
 .multiprogress-bar__indicator {
   position: absolute;
-  height: inherit;
-  background-color: black;
+  inset: 0;
+  margin: -1px;
+  margin-left: 0;
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-end;
+}
+
+.multiprogress-bar__indicator-bar {
+  background-color: var(--background-color-override, $ui-black);
   opacity: 0.8;
   transition: 1s linear;
   transition-property: width;
-  right: 0;
+
+  .multiprogress-bar--ignore-css-override & {
+    background-color: $ui-black;
+  }
 }
 
 .multiprogress-bar__bg-normal {
-  position: absolute;
-  height: inherit;
-  right: 0;
-  width: 100%;
-}
-
-.multiprogress-bar__bg-warning {
-  position: absolute;
-  height: inherit;
-  right: 0;
+  flex: 1;
 }
 
 .multiprogress-bar__bg-danger {
-  position: absolute;
-  height: inherit;
-  right: 0;
-}
+  flex-shrink: 0;
+}

apps/client/src/common/components/multi-part-progress-bar/MultiPartProgressBar.tsx

@@ -13,31 +13,51 @@ interface MultiPartProgressBar {
   danger?: MaybeNumber;
   dangerColor: string;
   hidden?: boolean;
+  ignoreCssOverride?: boolean;
   className?: string;
 }
 
 export default function MultiPartProgressBar(props: MultiPartProgressBar) {
-  const { now, complete, normalColor, warning, warningColor, danger, dangerColor, hidden, className = '' } = props;
+  const {
+    now,
+    complete,
+    normalColor,
+    warning,
+    warningColor,
+    danger,
+    dangerColor,
+    hidden,
+    ignoreCssOverride,
+    className = '',
+  } = props;
 
   const percentRemaining = complete === 0 ? 0 : 100 - clamp(100 - (Math.max(now ?? 0, 0) * 100) / complete, 0, 100);
 
   const dangerWidth = danger ? clamp((danger / complete) * 100, 0, 100) : 0;
-  const warningWidth = warning ? clamp((warning / complete) * 100, 0, 100) : 0;
+  const warningWidth = warning ? clamp((warning / complete) * 100 - dangerWidth, 0, 100) : 0;
 
   return (
-    <div className={`multiprogress-bar ${hidden ? 'multiprogress-bar--hidden' : ''} ${className}`}>
+    <div
+      className={`multiprogress-bar ${hidden ? 'multiprogress-bar--hidden' : ''} ${
+        ignoreCssOverride ? 'multiprogress-bar--ignore-css-override' : ''
+      } ${className}`}
+    >
       {now !== null && (
         <>
-          <div className='multiprogress-bar__bg-normal' style={{ backgroundColor: normalColor }} />
-          <div
-            className='multiprogress-bar__bg-warning'
-            style={{ width: `${warningWidth}%`, backgroundColor: warningColor }}
-          />
-          <div
-            className='multiprogress-bar__bg-danger'
-            style={{ width: `${dangerWidth}%`, backgroundColor: dangerColor }}
-          />
-          <div className='multiprogress-bar__indicator' style={{ width: `${percentRemaining}%` }} />
+          <div className='multiprogress-bar__bg'>
+            <div className='multiprogress-bar__bg-normal' style={{ backgroundColor: normalColor }} />
+            <div
+              className='multiprogress-bar__bg-warning'
+              style={{ width: `${warningWidth}%`, backgroundColor: warningColor }}
+            />
+            <div
+              className='multiprogress-bar__bg-danger'
+              style={{ width: `${dangerWidth}%`, backgroundColor: dangerColor }}
+            />
+          </div>
+          <div className='multiprogress-bar__indicator'>
+            <div className='multiprogress-bar__indicator-bar' style={{ width: `${percentRemaining}%` }} />
+          </div>
         </>
       )}
     </div>

apps/client/src/common/components/navigation-menu/NavigationMenu.tsx

@@ -19,10 +19,10 @@ import { IoSwapVertical } from '@react-icons/all-files/io5/IoSwapVertical';
 
 import { navigatorConstants } from '../../../viewerConfig';
 import useClickOutside from '../../hooks/useClickOutside';
+import { useClientStore } from '../../stores/clientStore';
 import { useViewOptionsStore } from '../../stores/viewOptions';
 import { isKeyEnter } from '../../utils/keyEvent';
-
-import RenameClientModal from './rename-client-modal/RenameClientModal';
+import { RenameClientModal } from '../client-modal/RenameClientModal';
 
 import style from './NavigationMenu.module.scss';
 
@@ -34,8 +34,10 @@ interface NavigationMenuProps {
 function NavigationMenu(props: NavigationMenuProps) {
   const { isOpen, onClose } = props;
 
-  const { isOpen: isRenameOpen, onOpen: onRenameOpen, onClose: onRenameClose } = useDisclosure();
+  const id = useClientStore((store) => store.id);
+  const name = useClientStore((store) => store.name);
 
+  const { isOpen: isOpenRename, onOpen: onRenameOpen, onClose: onCloseRename } = useDisclosure();
   const { fullscreen, toggle } = useFullscreen();
   const { toggleMirror } = useViewOptionsStore();
 
@@ -45,7 +47,7 @@ function NavigationMenu(props: NavigationMenuProps) {
 
   return createPortal(
     <div id='navigation-menu-portal' ref={menuRef}>
-      <RenameClientModal isOpen={isRenameOpen} onClose={onRenameClose} />
+      <RenameClientModal id={id} name={name} isOpen={isOpenRename} onClose={onCloseRename} />
       <Drawer placement='left' onClose={onClose} isOpen={isOpen} variant='ontime' data-testid='navigation__menu'>
         <DrawerOverlay />
         <DrawerContent>

apps/client/src/common/components/navigation-menu/rename-client-modal/RenameClientModal.tsx

@@ -1,71 +0,0 @@
-import { useEffect, useState } from 'react';
-import {
-  Button,
-  Input,
-  Modal,
-  ModalBody,
-  ModalCloseButton,
-  ModalContent,
-  ModalHeader,
-  ModalOverlay,
-} from '@chakra-ui/react';
-
-import { setClientName } from '../../../hooks/useSocket';
-import { useSocketClientName } from '../../../stores/connectionName';
-
-interface RenameClientModalProps {
-  isOpen: boolean;
-  onClose: () => void;
-}
-
-export default function RenameClientModal({ isOpen, onClose }: RenameClientModalProps) {
-  const { name: clientName, persistName } = useSocketClientName();
-  const [newName, setNewName] = useState(clientName);
-
-  useEffect(() => {
-    setNewName(clientName);
-  }, [isOpen, clientName]);
-
-  const handleRename = async () => {
-    if (newName) {
-      setClientName(newName);
-      persistName(newName);
-      onClose();
-    }
-  };
-
-  return (
-    <Modal
-      isOpen={isOpen}
-      onClose={onClose}
-      size='sm'
-      closeOnOverlayClick={false}
-      motionPreset='slideInBottom'
-      scrollBehavior='inside'
-      preserveScrollBarGap
-      variant='ontime'
-    >
-      <ModalOverlay />
-      <ModalContent>
-        <ModalHeader>Rename client</ModalHeader>
-        <ModalCloseButton />
-        <ModalBody>
-          <Input
-            placeholder='Connection must have a name'
-            defaultValue={newName}
-            onChange={(e) => setNewName(e.target.value)}
-            variant='ontime-filled'
-          />
-          <Button
-            isDisabled={newName === clientName || !newName}
-            onClick={handleRename}
-            width='100%'
-            variant='ontime-filled'
-          >
-            Save
-          </Button>
-        </ModalBody>
-      </ModalContent>
-    </Modal>
-  );
-}

apps/client/src/common/components/view-params-editor/ParamInput.tsx

@@ -1,5 +1,18 @@
+import { useState } from 'react';
 import { useSearchParams } from 'react-router-dom';
-import { Input, InputGroup, InputLeftElement, Select, Switch } from '@chakra-ui/react';
+import {
+  Button,
+  Input,
+  InputGroup,
+  InputLeftElement,
+  Menu,
+  MenuButton,
+  MenuItemOption,
+  MenuList,
+  MenuOptionGroup,
+  Select,
+  Switch,
+} from '@chakra-ui/react';
 
 import { isStringBoolean } from '../../../features/viewers/common/viewUtils';
 
@@ -34,6 +47,10 @@ export default function ParamInput(props: EditFormInputProps) {
     );
   }
 
+  if (type === 'multi-option') {
+    return <MultiOption paramField={paramField} />;
+  }
+
   if (type === 'boolean') {
     const defaultCheckedValue = isStringBoolean(searchParams.get(id)) || defaultValue;
 
@@ -70,3 +87,47 @@ export default function ParamInput(props: EditFormInputProps) {
     </InputGroup>
   );
 }
+
+interface EditFormMultiOptionProps {
+  paramField: ParamField & { type: 'multi-option' };
+}
+
+function MultiOption(props: EditFormMultiOptionProps) {
+  const [searchParams] = useSearchParams();
+  const { paramField } = props;
+  const { id, defaultValue } = paramField;
+
+  const optionFromParams = (searchParams.get(id) ?? '').toLocaleLowerCase();
+  const defaultOptionValue = optionFromParams || defaultValue?.toLocaleLowerCase() || '';
+
+  const [paramState, setParamState] = useState<string>(defaultOptionValue);
+
+  return (
+    <>
+      <input name={id} hidden readOnly value={paramState} />
+      <Menu isLazy closeOnSelect={false} variant='ontime-on-dark'>
+        <MenuButton as={Button} variant='ontime-subtle-white' position='relative' width='fit-content' fontWeight={400}>
+          {paramField.title}
+        </MenuButton>
+        <MenuList>
+          <MenuOptionGroup
+            type='checkbox'
+            value={paramState.split('_')}
+            onChange={(value) => {
+              setParamState(typeof value === 'object' ? value.filter((v) => v !== '').join('_') : value);
+            }}
+          >
+            {Object.values(paramField.values).map((option) => {
+              const { value, label } = option;
+              return (
+                <MenuItemOption value={value} key={value}>
+                  {label}
+                </MenuItemOption>
+              );
+            })}
+          </MenuOptionGroup>
+        </MenuList>
+      </Menu>
+    </>
+  );
+}

apps/client/src/common/components/view-params-editor/ViewParamsEditor.tsx

@@ -40,6 +40,7 @@ interface EditFormDrawerProps {
   paramFields: ParamField[];
 }
 
+// TODO: this is a good candidate for memoisation, but needs the paramFields to be stable
 export default function ViewParamsEditor({ paramFields }: EditFormDrawerProps) {
   const [searchParams, setSearchParams] = useSearchParams();
   const { isOpen, onClose, onOpen } = useDisclosure();

apps/client/src/common/components/view-params-editor/constants.ts

@@ -1,12 +1,10 @@
 import { CustomFields } from 'ontime-types';
 
-import { capitaliseFirstLetter } from '../../../features/viewers/common/viewUtils';
-
-import { ParamField } from './types';
+import { type ParamField } from './types';
 
 const makeOptionsFromCustomFields = (customFields: CustomFields, additionalOptions?: Record<string, string>) => {
-  const customFieldOptions = Object.keys(customFields).reduce((acc, key) => {
-    return { ...acc, [`custom-${key}`]: `Custom: ${capitaliseFirstLetter(key)}` };
+  const customFieldOptions = Object.entries(customFields).reduce((acc, [key, value]) => {
+    return { ...acc, [`custom-${key}`]: `Custom: ${value.label}` };
   }, additionalOptions ?? {});
   return customFieldOptions;
 };
@@ -111,6 +109,7 @@ export const getClockOptions = (timeFormat: string): ParamField[] => [
 ];
 
 export const getTimerOptions = (timeFormat: string, customFields: CustomFields): ParamField[] => {
+  const mainOptions = makeOptionsFromCustomFields(customFields, { title: 'Title' });
   const secondaryOptions = makeOptionsFromCustomFields(customFields, { note: 'Note' });
   return [
     getTimeOption(timeFormat),
@@ -123,6 +122,14 @@ export const getTimerOptions = (timeFormat: string, customFields: CustomFields):
       type: 'boolean',
       defaultValue: false,
     },
+    {
+      id: 'main',
+      title: 'Main text',
+      description: 'Select the data source for the main text',
+      type: 'option',
+      values: mainOptions,
+      defaultValue: 'Title',
+    },
     {
       id: 'secondary-src',
       title: 'Secondary text',
@@ -455,8 +462,8 @@ export const getStudioClockOptions = (timeFormat: string): ParamField[] => [
 export const getOperatorOptions = (customFields: CustomFields, timeFormat: string): ParamField[] => {
   const fieldOptions = makeOptionsFromCustomFields(customFields, { title: 'Title', note: 'Note' });
 
-  const customFieldSelect = Object.keys(customFields).reduce((acc, key) => {
-    return { ...acc, [key]: `Custom: ${capitaliseFirstLetter(key)}` };
+  const customFieldSelect = Object.entries(customFields).reduce((acc, [key, field]) => {
+    return { ...acc, [key]: { value: key, label: field.label, colour: field.colour } };
   }, {});
 
   return [
@@ -488,9 +495,8 @@ export const getOperatorOptions = (customFields: CustomFields, timeFormat: strin
       id: 'subscribe',
       title: 'Highlight Field',
       description: 'Choose a custom field to highlight',
-      type: 'option',
+      type: 'multi-option',
       values: customFieldSelect,
-      defaultValue: '',
     },
     {
       id: 'shouldEdit',
@@ -503,3 +509,7 @@ export const getOperatorOptions = (customFields: CustomFields, timeFormat: strin
 };
 
 export const getCountdownOptions = (timeFormat: string): ParamField[] => [getTimeOption(timeFormat), hideTimerSeconds];
+
+export const getProgressOptions = (timeFormat: string): ParamField[] => {
+  return [getTimeOption(timeFormat)];
+};

apps/client/src/common/components/view-params-editor/types.ts

@@ -9,8 +9,15 @@ type OptionsField = {
   values: Record<string, string>;
   defaultValue?: string;
 };
+
+type MultiOptionsField = {
+  type: 'multi-option';
+  values: Record<string, { value: string; label: string; colour: string }>;
+  defaultValue?: string;
+};
+
 type StringField = { type: 'string'; defaultValue?: string; prefix?: string; placeholder?: string };
 type NumberField = { type: 'number'; defaultValue?: number; prefix?: string; placeholder?: string };
 type BooleanField = { type: 'boolean'; defaultValue: boolean };
 
-export type ParamField = BaseField & (StringField | BooleanField | NumberField | OptionsField);
+export type ParamField = BaseField & (StringField | BooleanField | NumberField | OptionsField | MultiOptionsField);

apps/client/src/common/hooks/useClientPath.ts

@@ -0,0 +1,34 @@
+import { useEffect } from 'react';
+import { useLocation, useNavigate } from 'react-router-dom';
+
+import { useClientStore } from '../stores/clientStore';
+import { socketSendJson } from '../utils/socket';
+
+export const useClientPath = () => {
+  const navigate = useNavigate();
+  const { pathname, search } = useLocation();
+  const redirect = useClientStore((store) => store.redirect);
+  const setRedirect = useClientStore((store) => store.setRedirect);
+
+  // notify of client path changes
+  useEffect(() => {
+    //remove leading '/' from path
+    const fullPath = (pathname.startsWith('/') ? pathname.slice(1) : pathname) + search;
+    socketSendJson('set-client-path', fullPath);
+  }, [pathname, search]);
+
+  // navigate to new path when received from server
+  useEffect(() => {
+    if (redirect === '') {
+      return;
+    }
+
+    // clear redirect
+    setRedirect('');
+
+    // navigate if there is a path change
+    if (redirect !== pathname + search) {
+      navigate(redirect);
+    }
+  }, [navigate, pathname, redirect, search, setRedirect]);
+};

apps/client/src/common/hooks/useSocket.ts

@@ -3,6 +3,12 @@ import { RuntimeStore, SimpleDirection, SimplePlayback } from 'ontime-types';
 import { useRuntimeStore } from '../stores/runtime';
 import { socketSendJson } from '../utils/socket';
 
+export const setClientRemote = {
+  setIdentify: (payload: { target: string; identify: boolean }) => socketSendJson('client', payload),
+  setRedirect: (payload: { target: string; redirect: string }) => socketSendJson('client', payload),
+  setClientName: (payload: { target: string; rename: string }) => socketSendJson('client', payload),
+};
+
 export const useRundownEditor = () => {
   const featureSelector = (state: RuntimeStore) => ({
     playback: state.timer.playback,

apps/client/src/common/stores/clientStore.ts

@@ -0,0 +1,82 @@
+import { ClientList } from 'ontime-types';
+import { create } from 'zustand';
+
+interface ClientStore {
+  name?: string;
+  setName: (newValue: string) => void;
+
+  id: string;
+  setId: (newValue: string) => void;
+
+  redirect: string;
+  setRedirect: (newValue: string) => void;
+
+  clients: ClientList;
+  setClients: (clients: ClientList) => void;
+}
+
+const clientNameKey = 'ontime-client-name';
+
+function persistNameInStorage(newValue: string) {
+  localStorage.setItem(clientNameKey, newValue);
+}
+
+export const useClientStore = create<ClientStore>((set) => ({
+  name: localStorage.getItem(clientNameKey) ?? undefined,
+  setName: (name: string) =>
+    set(() => {
+      persistNameInStorage(name);
+      return { name };
+    }),
+
+  id: '',
+  setId: (id) => set({ id }),
+
+  redirect: '',
+  setRedirect: (redirect: string) => set({ redirect }),
+
+  clients: {},
+  setClients: (clients: ClientList) => set({ clients }),
+}));
+
+/**
+ * Allows getting client name (outside react)
+ */
+export function getClientName(): string | undefined {
+  return useClientStore.getState().name;
+}
+
+/**
+ * Allows updating current client name (outside react)
+ */
+export function setClientName(name: string): void {
+  useClientStore.getState().setName(name);
+}
+
+/**
+ * Allows updating current client name (outside react)
+ */
+export function setClientId(id: string): void {
+  useClientStore.getState().setId(id);
+}
+
+/**
+ * Allows getting client name (outside react)
+ */
+export function getClientId(): string | undefined {
+  return useClientStore.getState().id;
+}
+
+/**
+ * Allows updating redirect (outside react)
+ */
+export function setClientRedirect(path: string): void {
+  useClientStore.getState().setRedirect(path);
+}
+
+/**
+ * Allows setting clients (outside react)
+ */
+export function setClients(clients: ClientList): void {
+  return useClientStore.getState().setClients(clients);
+}

apps/client/src/common/stores/connectionName.ts

@@ -1,26 +0,0 @@
-import { useStore } from 'zustand';
-import { createStore } from 'zustand/vanilla';
-
-interface SocketClientNameState {
-  name?: string;
-  setName: (newValue: string) => void;
-  persistName: (newValue: string) => void;
-}
-
-const clientNameKey = 'ontime-client-name';
-
-function persistKeyToStorage(newValue: string) {
-  localStorage.setItem(clientNameKey, newValue);
-}
-
-export const socketClientName = createStore<SocketClientNameState>((set) => ({
-  name: localStorage.getItem(clientNameKey) ?? undefined,
-  setName: (newValue: string) => set(() => ({ name: newValue })),
-  persistName: (newValue: string) =>
-    set(() => {
-      persistKeyToStorage(newValue);
-      return { name: newValue };
-    }),
-}));
-
-export const useSocketClientName = () => useStore(socketClientName);

apps/client/src/common/utils/socket.ts

@@ -1,21 +1,31 @@
 import { Log, RuntimeStore } from 'ontime-types';
 
-import { isProduction, RUNTIME, websocketUrl } from '../api/constants';
+import { CLIENT_LIST, isProduction, RUNTIME, websocketUrl } from '../api/constants';
 import { ontimeQueryClient } from '../queryClient';
-import { socketClientName } from '../stores/connectionName';
+import {
+  getClientId,
+  getClientName,
+  setClientId,
+  setClientName,
+  setClientRedirect,
+  setClients,
+} from '../stores/clientStore';
 import { addLog } from '../stores/logger';
 import { patchRuntime, runtimeStore } from '../stores/runtime';
 
 export let websocket: WebSocket | null = null;
 let reconnectTimeout: NodeJS.Timeout | null = null;
 const reconnectInterval = 1000;
+
 export let shouldReconnect = true;
 export let hasConnected = false;
 export let reconnectAttempts = 0;
 
-export const connectSocket = (preferredClientName?: string) => {
+export const connectSocket = () => {
   websocket = new WebSocket(websocketUrl);
 
+  const preferredClientName = getClientName();
+
   websocket.onopen = () => {
     clearTimeout(reconnectTimeout as NodeJS.Timeout);
     hasConnected = true;
@@ -24,6 +34,9 @@ export const connectSocket = (preferredClientName?: string) => {
     if (preferredClientName) {
       socketSendJson('set-client-name', preferredClientName);
     }
+
+    socketSendJson('set-client-type', 'ontime');
+    socketSendJson('set-client-path', location.pathname);
   };
 
   websocket.onclose = () => {
@@ -54,10 +67,48 @@ export const connectSocket = (preferredClientName?: string) => {
       }
 
       switch (type) {
-        case 'client-name': {
-          socketClientName.getState().setName(payload);
+        case 'client-id': {
+          if (typeof payload === 'string') {
+            setClientId(payload);
+          }
           break;
         }
+
+        case 'client-name': {
+          if (typeof payload === 'string') {
+            setClientName(payload);
+          }
+          break;
+        }
+
+        case 'client-rename': {
+          if (typeof payload === 'object') {
+            const id = getClientId();
+            if (payload.target && payload.target === id) {
+              setClientName(payload.name);
+            }
+          }
+          break;
+        }
+
+        case 'client-redirect': {
+          if (typeof payload === 'object') {
+            const id = getClientId();
+            if (payload.target && payload.target === id) {
+              setClientRedirect(payload.path);
+            }
+          }
+          break;
+        }
+
+        case 'client-list': {
+          setClients(payload);
+          if (!isProduction) {
+            ontimeQueryClient.setQueryData(CLIENT_LIST, payload);
+          }
+          break;
+        }
+
         case 'ontime-log': {
           addLog(payload as Log);
           break;

apps/client/src/common/utils/time.ts

@@ -95,3 +95,25 @@ export const formatTime = (
   const isNegative = milliseconds < 0;
   return `${isNegative ? '-' : ''}${display}`;
 };
+
+/**
+ * Handles case for formatting a duration time
+ * @param duration
+ * @returns
+ */
+export function formatDuration(duration: number): string {
+  if (duration === 0) {
+    return '0h 0m';
+  }
+
+  const hours = Math.floor(duration / 3600000);
+  const minutes = Math.floor((duration % 3600000) / 60000);
+  let result = '';
+  if (hours > 0) {
+    result += `${hours}h `;
+  }
+  if (minutes > 0) {
+    result += `${minutes}m`;
+  }
+  return result;
+}

apps/client/src/features/app-settings/AppSettings.tsx

@@ -3,10 +3,11 @@ import { ErrorBoundary } from '@sentry/react';
 import { useKeyDown } from '../../common/hooks/useKeyDown';
 
 import AboutPanel from './panel/about-panel/AboutPanel';
+import ClientControlPanel from './panel/client-control-panel/ClientControlPanel';
 import FeatureSettingsPanel from './panel/feature-settings-panel/FeatureSettingsPanel';
 import GeneralPanel from './panel/general-panel/GeneralPanel';
 import IntegrationsPanel from './panel/integrations-panel/IntegrationsPanel';
-import LogPanel from './panel/log-panel/LogPanel';
+import NetworkLogPanel from './panel/network-panel/NetworkLogPanel';
 import ProjectPanel from './panel/project-panel/ProjectPanel';
 import ShutdownPanel from './panel/shutdown-panel/ShutdownPanel';
 import SourcesPanel from './panel/sources-panel/SourcesPanel';
@@ -30,8 +31,9 @@ export default function AppSettings() {
           {panel === 'feature_settings' && <FeatureSettingsPanel location={location} />}
           {panel === 'sources' && <SourcesPanel />}
           {panel === 'integrations' && <IntegrationsPanel location={location} />}
+          {panel === 'client_control' && <ClientControlPanel />}
           {panel === 'about' && <AboutPanel />}
-          {panel === 'log' && <LogPanel />}
+          {panel === 'network' && <NetworkLogPanel location={location} />}
           {panel === 'shutdown' && <ShutdownPanel />}
         </PanelContent>
       </ErrorBoundary>

apps/client/src/features/app-settings/panel/Panel.module.scss

@@ -73,12 +73,12 @@ $inner-padding: 1rem;
     top: 0;
     z-index: 3;
     box-shadow: 0 1px $white-10;
+    background-color: $gray-1350;
   }
 
   th {
     font-weight: 400;
     color: $gray-400;
-    background-color: $gray-1350;
     white-space: nowrap;
     text-transform: capitalize;
   }

apps/client/src/features/app-settings/panel/client-control-panel/ClientControlPanel.module.scss

@@ -0,0 +1,24 @@
+.fullWidth {
+  width: 100%;
+}
+
+.actionButtons {
+  display: flex;
+  gap: $element-spacing;
+}
+
+.halfWidth {
+  width: 50%;
+  white-space: nowrap;
+}
+
+.pathList {
+  width: 100%;
+}
+
+.badgeList {
+  width: 100%;
+  * {
+    margin-right: $element-spacing;
+  }
+}

apps/client/src/features/app-settings/panel/client-control-panel/ClientControlPanel.tsx

@@ -0,0 +1,15 @@
+import * as Panel from '../PanelUtils';
+
+import ClientList from './ClientList';
+
+export default function ClientControlPanel() {
+  return (
+    <Panel.Section>
+      <Panel.Card>
+        <Panel.SubHeader>Manage clients</Panel.SubHeader>
+        <Panel.Divider />
+        <ClientList />
+      </Panel.Card>
+    </Panel.Section>
+  );
+}

apps/client/src/features/app-settings/panel/client-control-panel/ClientList.tsx

@@ -0,0 +1,147 @@
+import { useState } from 'react';
+import { Badge, Button, useDisclosure } from '@chakra-ui/react';
+
+import { RedirectClientModal } from '../../../../common/components/client-modal/RedirectClientModal';
+import { RenameClientModal } from '../../../../common/components/client-modal/RenameClientModal';
+import { setClientRemote } from '../../../../common/hooks/useSocket';
+import { useClientStore } from '../../../../common/stores/clientStore';
+import * as Panel from '../PanelUtils';
+
+import style from './ClientControlPanel.module.scss';
+
+export default function ClientList() {
+  const id = useClientStore((store) => store.id);
+  const clients = useClientStore((store) => store.clients);
+  const { isOpen: isOpenRedirect, onOpen: onOpenRedirect, onClose: onCloseRedirect } = useDisclosure();
+  const { isOpen: isOpenRename, onOpen: onOpenRename, onClose: onCloseRename } = useDisclosure();
+  const { setIdentify } = setClientRemote;
+
+  const [targetId, setTargetId] = useState('');
+
+  const openRename = (targetId: string) => {
+    setTargetId(targetId);
+    onOpenRename();
+  };
+
+  const openRedirect = (targetId: string) => {
+    setTargetId(targetId);
+    onOpenRedirect();
+  };
+
+  const ontimeClients = Object.entries(clients).filter(([_, { type }]) => type === 'ontime');
+  const otherClients = Object.entries(clients).filter(([_, { type }]) => type !== 'ontime');
+
+  const targetClient = clients[targetId];
+
+  return (
+    <>
+      {isOpenRedirect && (
+        <RedirectClientModal
+          id={targetId}
+          name={targetClient?.name}
+          path={targetClient?.path}
+          isOpen={isOpenRedirect}
+          onClose={onCloseRedirect}
+        />
+      )}
+      {isOpenRename && (
+        <RenameClientModal id={targetId} name={targetClient?.name} isOpen={isOpenRename} onClose={onCloseRename} />
+      )}
+      <Panel.Section>
+        <Panel.Title>Ontime Clients ({ontimeClients.length})</Panel.Title>
+        <Panel.Table>
+          <thead>
+            <tr>
+              <td className={style.fullWidth}>Client Name (Connection ID)</td>
+              <td className={style.fullWidth}>Path</td>
+              <td />
+            </tr>
+          </thead>
+          <tbody>
+            {ontimeClients.map(([key, client]) => {
+              const { identify, name, path } = client;
+              const isCurrent = id === key;
+              return (
+                <tr key={key}>
+                  <td className={style.badgeList}>
+                    <Badge variant='outline' size='xs'>
+                      {key}
+                    </Badge>
+                    {isCurrent && (
+                      <Badge variant='outline' colorScheme='yellow' size='xs'>
+                        self
+                      </Badge>
+                    )}
+                    {name}
+                  </td>
+                  {isCurrent ? <td /> : <td className={style.pathList}>{path}</td>}
+                  <td className={style.actionButtons}>
+                    <Button
+                      size='xs'
+                      className={`${identify ? style.blink : ''}`}
+                      isDisabled={isCurrent}
+                      variant={identify ? 'ontime-filled' : 'ontime-subtle'}
+                      data-testid={isCurrent ? '' : 'not-self-identify'}
+                      onClick={() => {
+                        setIdentify({ target: key, identify: !identify });
+                      }}
+                    >
+                      Identify
+                    </Button>
+                    <Button
+                      size='xs'
+                      variant='ontime-subtle'
+                      data-testid={isCurrent ? '' : 'not-self-rename'}
+                      onClick={() => openRename(key)}
+                    >
+                      Rename
+                    </Button>
+
+                    <Button
+                      size='xs'
+                      variant='ontime-subtle'
+                      isDisabled={isCurrent}
+                      data-testid={isCurrent ? '' : 'not-self-redirect'}
+                      onClick={() => openRedirect(key)}
+                    >
+                      Redirect
+                    </Button>
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </Panel.Table>
+      </Panel.Section>
+      <Panel.Divider />
+      <Panel.Section>
+        <Panel.Title>Other Clients ({otherClients.length})</Panel.Title>
+        <Panel.Table>
+          <thead>
+            <tr>
+              <td className={style.halfWidth}>Client Name (Connection ID)</td>
+              <td className={style.halfWidth}>Client type</td>
+            </tr>
+          </thead>
+          <tbody>
+            {otherClients.map(([key, client]) => {
+              const { name, type } = client;
+
+              return (
+                <tr key={key}>
+                  <td className={style.badgeList}>
+                    <Badge variant='outline' size='sx'>
+                      {key}
+                    </Badge>
+                    {name}
+                  </td>
+                  <td>{type}</td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </Panel.Table>
+      </Panel.Section>
+    </>
+  );
+}

apps/client/src/features/app-settings/panel/feature-settings-panel/custom-fields/CustomFieldForm.tsx

@@ -67,7 +67,7 @@ export default function CustomFieldForm(props: CustomFieldsFormProps) {
   return (
     <form onSubmit={handleSubmit(setupSubmit)} className={style.fieldForm}>
       <div className={style.column}>
-        <Panel.Description>Label</Panel.Description>
+        <Panel.Description>Label (only alphanumeric characters are allowed)</Panel.Description>
         {errors.label && <Panel.Error>{errors.label.message}</Panel.Error>}
         <Input
           {...register('label', {

apps/client/src/features/app-settings/panel/general-panel/GeneralPanelForm.tsx

@@ -153,6 +153,7 @@ export default function GeneralPanelForm() {
                 <option value='pt'>Portuguese</option>
                 <option value='es'>Spanish</option>
                 <option value='sv'>Swedish</option>
+		<option value='pl'>Polish</option>
               </Select>
             </Panel.ListItem>
           </Panel.ListGroup>

apps/client/src/features/app-settings/panel/integrations-panel/integrationUtils.ts

@@ -14,4 +14,6 @@ export const cycles: CycleLabel[] = [
   { id: 5, label: 'Every second', value: 'onClock' },
   { id: 5, label: 'On Timer Update', value: 'onUpdate' },
   { id: 6, label: 'On Finish', value: 'onFinish' },
+  { id: 7, label: 'On Warning', value: 'onWarning' },
+  { id: 8, label: 'On Danger', value: 'onDanger' },
 ];

apps/client/src/features/app-settings/panel/log-panel/LogPanel.tsx

@@ -1,17 +0,0 @@
-import * as Panel from '../PanelUtils';
-
-import LogExport from './LogExport';
-import InfoNif from './NetworkInterfaces';
-
-export default function LogPanel() {
-  return (
-    <>
-      <Panel.Header>Log</Panel.Header>
-      <Panel.Section>
-        <Panel.Paragraph>Ontime is streaming on the following network interfaces</Panel.Paragraph>
-      </Panel.Section>
-      <InfoNif />
-      <LogExport />
-    </>
-  );
-}

apps/client/src/features/app-settings/panel/network-panel/NetworkLogExport.tsx

@@ -6,7 +6,7 @@ import { handleLinks } from '../../../../common/utils/linkUtils';
 import Log from '../../../log/Log';
 import * as Panel from '../PanelUtils';
 
-import style from './LogExport.module.scss';
+import style from './NetworkLogExport.module.scss';
 
 export default function LogExport() {
   const extract = (event: MouseEvent) => {

apps/client/src/features/app-settings/panel/network-panel/NetworkLogPanel.tsx

@@ -0,0 +1,28 @@
+import useScrollIntoView from '../../../../common/hooks/useScrollIntoView';
+import { PanelBaseProps } from '../../settingsStore';
+import ClientControlPanel from '../client-control-panel/ClientControlPanel';
+import * as Panel from '../PanelUtils';
+
+import InfoNif from './NetworkInterfaces';
+import LogExport from './NetworkLogExport';
+
+export default function NetworkLogPanel({ location }: PanelBaseProps) {
+  const clientsRef = useScrollIntoView<HTMLDivElement>('clients', location);
+  const logRef = useScrollIntoView<HTMLDivElement>('log', location);
+
+  return (
+    <>
+      <Panel.Header>Network</Panel.Header>
+      <Panel.Section>
+        <Panel.Paragraph>Ontime is streaming on the following network interfaces</Panel.Paragraph>
+      </Panel.Section>
+      <InfoNif />
+      <div ref={logRef}>
+        <LogExport />
+      </div>
+      <div ref={clientsRef}>
+        <ClientControlPanel />
+      </div>
+    </>
+  );
+}

apps/client/src/features/app-settings/panel/project-panel/ProjectCreateForm.tsx

@@ -50,7 +50,8 @@ export default function ProjectCreateForm(props: ProjectCreateFromProps) {
   const handleSubmitCreate = async (values: ProjectCreateFormValues) => {
     try {
       setError(null);
-      const filename = values.title?.trim();
+
+      const filename = values.title ?? 'untitled';
 
       await createProject({
         ...values,

apps/client/src/features/app-settings/panel/sources-panel/SourcesPanel.module.scss

@@ -1,5 +1,5 @@
 .uploadSection,
-.successSection {
+.finishSection {
   margin-top: 1rem;
   display: flex;
   padding: 3rem 1rem;
@@ -15,12 +15,18 @@
   gap: 2rem;
 }
 
-.successSection {
-  color: $green-500;
+.finishSection {
   font-size: 1.5rem;
   text-align: center;
   flex-direction: column;
   gap: 1rem;
+
+  .error {
+    color: $red-500;
+  }
+  .success {
+    color: $green-500;
+  }
 }
 
 .buttonRow {

apps/client/src/features/app-settings/panel/sources-panel/SourcesPanel.tsx

@@ -134,11 +134,20 @@ export default function SourcesPanel() {
     await exportRundown(sheetId, importMap);
   };
 
+  const resetFlow = () => {
+    setImportFlow('none');
+    setRundown(null);
+    setHasFile('none');
+    setWorksheets(null);
+    setCustomFields(null);
+    setError('');
+  };
+
   const isExcelFlow = importFlow === 'excel';
   const isGSheetFlow = importFlow === 'gsheet';
   const isAuthenticated = authenticationStatus === 'authenticated';
   const showInput = importFlow === 'none';
-  const showSuccess = importFlow === 'finished';
+  const showCompleted = importFlow === 'finished';
   const showAuth = isGSheetFlow && !isAuthenticated;
   const showImportMap = (isGSheetFlow && isAuthenticated) || (isExcelFlow && hasFile === 'done');
   const showReview = rundown !== null && customFields !== null;
@@ -189,10 +198,18 @@ export default function SourcesPanel() {
               </div>
             </>
           )}
-          {showSuccess && (
-            <div className={style.successSection}>
-              <span>Import successful</span>
-              <Button variant='ontime-filled' size='sm' onClick={() => setImportFlow('none')}>
+          {showCompleted && (
+            <div className={style.finishSection}>
+              {error ? (
+                <span key='finish__error' className={style.error}>
+                  Import failed
+                </span>
+              ) : (
+                <span key='finish__success' className={style.success}>
+                  Import successful
+                </span>
+              )}
+              <Button variant='ontime-filled' size='sm' onClick={resetFlow}>
                 Return
               </Button>
             </div>
@@ -200,6 +217,7 @@ export default function SourcesPanel() {
           {showAuth && <GSheetSetup onCancel={cancelGSheetFlow} />}
           {showImportMap && !showReview && (
             <ImportMapForm
+              hasErrors={Boolean(error)}
               isSpreadsheet={isExcelFlow}
               onCancel={cancelImportMap}
               onSubmitExport={handleSubmitExport}

apps/client/src/features/app-settings/panel/sources-panel/import-map/ImportMapForm.tsx

@@ -15,14 +15,15 @@ import { convertToImportMap, getPersistedOptions, NamedImportMap, persistImportM
 import style from '../SourcesPanel.module.scss';
 
 interface ImportMapFormProps {
-  isSpreadsheet?: boolean;
+  hasErrors: boolean;
+  isSpreadsheet: boolean;
   onCancel: () => void;
   onSubmitExport: (importMap: ImportMap) => Promise<void>;
   onSubmitImport: (importMap: ImportMap) => Promise<void>;
 }
 
 export default function ImportMapForm(props: ImportMapFormProps) {
-  const { isSpreadsheet, onCancel, onSubmitExport, onSubmitImport } = props;
+  const { hasErrors, isSpreadsheet, onCancel, onSubmitExport, onSubmitImport } = props;
   const namedImportMap = getPersistedOptions();
   const { revoke } = useGoogleSheet();
   const {
@@ -78,7 +79,7 @@ export default function ImportMapForm(props: ImportMapFormProps) {
   const isLoading = Boolean(loading);
   const canSubmitSpreadsheet = isSpreadsheet && !isLoading;
   const canSubmitGSheet = !isLoading;
-  const canSubmit = isValid && (canSubmitSpreadsheet || canSubmitGSheet);
+  const canSubmit = !hasErrors && isValid && (canSubmitSpreadsheet || canSubmitGSheet);
 
   return (
     <Panel.Section as='form' id='import-map'>

apps/client/src/features/app-settings/settingsStore.ts

@@ -50,7 +50,21 @@ export const settingPanels: Readonly<SettingsOption[]> = [
       { id: 'integrations__http', label: 'HTTP settings' },
     ],
   },
-  { id: 'log', label: 'Log', split: true },
+  {
+    id: 'network',
+    label: 'Network',
+    split: true,
+    secondary: [
+      {
+        id: 'network__log',
+        label: 'Application log',
+      },
+      {
+        id: 'network__clients',
+        label: 'Manage clients',
+      },
+    ],
+  },
   {
     id: 'about',
     label: 'About',

apps/client/src/features/control/playback/playback-timer/PlaybackTimer.tsx

@@ -43,7 +43,7 @@ export default function PlaybackTimer(props: PropsWithChildren<PlaybackTimerProp
   const finish = millisToString(expectedFinish);
 
   const isRolling = playback === Playback.Roll;
-  const isWaiting = timer.secondaryTimer !== null && timer.secondaryTimer > 0 && timer.current === null;
+  const isWaiting = timer.phase === TimerPhase.Pending;
   const isOvertime = timer.phase === TimerPhase.Overtime;
   const hasAddedTime = Boolean(timer.addedTime);
 

apps/client/src/features/cuesheet/Cuesheet.module.scss

@@ -47,11 +47,13 @@ $table-header-font-size: calc(1rem - 3px);
   position: sticky;
   top: 0;
   z-index: 10;
-  background-color: $gray-1300;
 
   font-size: $table-header-font-size;
   color: $gray-700;
-  font-weight: 400;
+
+  th {
+      background-color: $gray-1300;
+  }
 }
 
 .eventRow {

apps/client/src/features/cuesheet/Cuesheet.tsx

@@ -1,5 +1,4 @@
-import { useCallback, useEffect, useRef } from 'react';
-import { useLocalStorage } from '@mantine/hooks';
+import { useCallback, useRef } from 'react';
 import { ColumnDef, flexRender, getCoreRowModel, useReactTable } from '@tanstack/react-table';
 import Color from 'color';
 import { isOntimeBlock, isOntimeDelay, isOntimeEvent, OntimeRundown, OntimeRundownEntry } from 'ontime-types';
@@ -13,7 +12,7 @@ import DelayRow from './cuesheet-table-elements/DelayRow';
 import EventRow from './cuesheet-table-elements/EventRow';
 import CuesheetTableSettings from './cuesheet-table-settings/CuesheetTableSettings';
 import { useCuesheetSettings } from './store/CuesheetSettings';
-import { initialColumnOrder } from './cuesheetCols';
+import useColumnManager from './useColumnManager';
 
 import style from './Cuesheet.module.scss';
 
@@ -27,23 +26,20 @@ interface CuesheetProps {
 export default function Cuesheet({ data, columns, handleUpdate, selectedId }: CuesheetProps) {
   const { followSelected, showSettings, showDelayBlock, showPrevious, showIndexColumn } = useCuesheetSettings();
 
-  const [columnVisibility, setColumnVisibility] = useLocalStorage({ key: 'table-hidden', defaultValue: {} });
-  const [columnOrder, saveColumnOrder] = useLocalStorage<string[]>({
-    key: 'table-order',
-    defaultValue: initialColumnOrder,
-  });
-  const [columnSizing, setColumnSizing] = useLocalStorage({ key: 'table-sizes', defaultValue: {} });
+  const {
+    columnVisibility,
+    columnOrder,
+    columnSizing,
+    resetColumnOrder,
+    setColumnVisibility,
+    saveColumnOrder,
+    setColumnSizing,
+  } = useColumnManager(columns);
 
   const selectedRef = useRef<HTMLTableRowElement | null>(null);
   const tableContainerRef = useRef<HTMLDivElement | null>(null);
   useFollowComponent({ followRef: selectedRef, scrollRef: tableContainerRef, doFollow: followSelected });
 
-  // keep column order in sync with columns
-  useEffect(() => {
-    const order = columns.map((col) => col.id as string);
-    saveColumnOrder(order);
-  }, [columns, saveColumnOrder]);
-
   const table = useReactTable({
     data,
     columns,
@@ -61,10 +57,6 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId }: Cu
     getCoreRowModel: getCoreRowModel(),
   });
 
-  const resetColumnOrder = () => {
-    saveColumnOrder(initialColumnOrder);
-  };
-
   const setAllVisible = () => {
     table.toggleAllColumnsVisible(true);
   };

apps/client/src/features/cuesheet/cuesheet-progress/CuesheetProgress.tsx

@@ -19,6 +19,7 @@ export default function CuesheetProgress() {
       danger={timeDanger}
       dangerColor={data!.dangerColor}
       className={styles.progressOverride}
+      ignoreCssOverride
     />
   );
 }

apps/client/src/features/cuesheet/cuesheetCols.tsx

@@ -117,5 +117,3 @@ export function makeCuesheetColumns(customFields: CustomFields): ColumnDef<Ontim
     ...dynamicCustomFields,
   ];
 }
-
-export const initialColumnOrder: string[] = makeCuesheetColumns({}).map((column) => column.id as string);

apps/client/src/features/cuesheet/useColumnManager.tsx

@@ -0,0 +1,46 @@
+import { useCallback, useEffect } from 'react';
+import { useLocalStorage } from '@mantine/hooks';
+import { ColumnDef } from '@tanstack/react-table';
+import { OntimeRundownEntry } from 'ontime-types';
+
+export default function useColumnManager(columns: ColumnDef<OntimeRundownEntry>[]) {
+  const [columnVisibility, setColumnVisibility] = useLocalStorage({ key: 'table-hidden', defaultValue: {} });
+  const [columnOrder, saveColumnOrder] = useLocalStorage<string[]>({
+    key: 'table-order',
+    defaultValue: columns.map((col) => col.id as string),
+  });
+  const [columnSizing, setColumnSizing] = useLocalStorage({ key: 'table-sizes', defaultValue: {} });
+
+  // if the columns change, we update the dataset
+  useEffect(() => {
+    let shouldReplace = false;
+    const newColumns: string[] = [];
+
+    // iterate through columns to see if there are new ids
+    columns.forEach((column) => {
+      const columnnId = column.id as string;
+      if (!shouldReplace && !columnOrder.includes(columnnId)) {
+        shouldReplace = true;
+      }
+      newColumns.push(columnnId);
+    });
+
+    if (shouldReplace) {
+      saveColumnOrder(newColumns);
+    }
+  }, [columnOrder, columns, saveColumnOrder]);
+
+  const resetColumnOrder = useCallback(() => {
+    saveColumnOrder(columns.map((col) => col.id as string));
+  }, [columns, saveColumnOrder]);
+
+  return {
+    columnVisibility,
+    columnOrder,
+    columnSizing,
+    resetColumnOrder,
+    setColumnVisibility,
+    saveColumnOrder,
+    setColumnSizing,
+  };
+}

apps/client/src/features/operator/Operator.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useSearchParams } from 'react-router-dom';
-import { CustomField, CustomFields, isOntimeEvent, OntimeEvent, SupportedEvent } from 'ontime-types';
+import { isOntimeEvent, OntimeEvent, SupportedEvent } from 'ontime-types';
 import { getFirstEventNormal, getLastEventNormal } from 'ontime-utils';
 
 import Empty from '../../common/components/state/Empty';
@@ -27,11 +27,9 @@ import style from './Operator.module.scss';
 
 const selectedOffset = 50;
 
+export type Subscribed = { id: string; label: string; colour: string; value: string }[];
 type TitleFields = Pick<OntimeEvent, 'title'>;
-export type EditEvent = Pick<OntimeEvent, 'id' | 'cue'> & { fieldLabel?: string; fieldValue: string };
-export type PartialEdit = EditEvent & {
-  field: keyof CustomFields;
-};
+export type EditEvent = Pick<OntimeEvent, 'id' | 'cue'> & { subscriptions: Subscribed };
 
 export default function Operator() {
   const { data, status } = useRundown();
@@ -45,7 +43,7 @@ export default function Operator() {
   const { data: settings } = useSettings();
 
   const [showEditPrompt, setShowEditPrompt] = useState(false);
-  const [editEvent, setEditEvent] = useState<PartialEdit | null>(null);
+  const [editEvent, setEditEvent] = useState<EditEvent | null>(null);
 
   const [lockAutoScroll, setLockAutoScroll] = useState(false);
   const selectedRef = useRef<HTMLDivElement | null>(null);
@@ -102,16 +100,9 @@ export default function Operator() {
     debouncedHandleScroll();
   };
 
-  const handleEdit = useCallback(
-    (event: EditEvent) => {
-      const field = searchParams.get('subscribe') as keyof CustomField | null;
-
-      if (field) {
-        setEditEvent({ ...event, field });
-      }
-    },
-    [searchParams],
-  );
+  const handleEdit = useCallback((event: EditEvent) => {
+    setEditEvent({ ...event });
+  }, []);
 
   const missingData = !data || !customFields || !projectData;
   const isLoading = status === 'pending' || customFieldStatus === 'pending' || projectDataStatus === 'pending';
@@ -122,8 +113,13 @@ export default function Operator() {
 
   // get fields which the user subscribed to
   const shouldEdit = searchParams.get('shouldEdit');
-  const subscribe = searchParams.get('subscribe') as keyof CustomFields;
-  const canEdit = shouldEdit && subscribe;
+
+  const subscriptions = (searchParams.get('subscribe') ?? '')
+    .toLocaleLowerCase()
+    .split('_')
+    .filter((value) => Object.hasOwn(customFields, value));
+
+  const canEdit = shouldEdit && subscriptions;
 
   const main = searchParams.get('main') as keyof TitleFields | null;
   const secondary = searchParams.get('secondary');
@@ -171,9 +167,14 @@ export default function Operator() {
               return null;
             }
 
-            const mainField = main ? entry?.[main] || entry.title : entry.title;
+            const mainField = main ? getPropertyValue(entry, main) ?? '' : entry.title;
             const secondaryField = getPropertyValue(entry, secondary) ?? '';
-            const subscribedData = entry.custom[subscribe];
+            const subscribedData = subscriptions
+              ? subscriptions.map((id) => {
+                  const { label, colour } = customFields[id];
+                  return { id, label, colour, value: entry.custom[id] };
+                })
+              : null;
 
             return (
               <OperatorEvent
@@ -189,7 +190,6 @@ export default function Operator() {
                 delay={entry.delay}
                 isSelected={isSelected}
                 subscribed={subscribedData}
-                subscribeLabel={subscribe}
                 isPast={isPast}
                 selectedRef={isSelected ? selectedRef : undefined}
                 onLongPress={canEdit ? handleEdit : () => undefined}

apps/client/src/features/operator/edit-modal/EditModal.tsx

@@ -1,48 +1,69 @@
 import { useRef, useState } from 'react';
 import { Button, Textarea } from '@chakra-ui/react';
+import { OntimeEvent } from 'ontime-types';
 
 import { useEventAction } from '../../../common/hooks/useEventAction';
-import type { PartialEdit } from '../Operator';
+import type { EditEvent } from '../Operator';
 
 import style from './EditModal.module.scss';
 
 interface EditModalProps {
-  event: PartialEdit;
+  event: EditEvent;
   onClose: () => void;
 }
 
 export default function EditModal(props: EditModalProps) {
   const { event, onClose } = props;
 
-  const { updateCustomField } = useEventAction();
+  const { updateEvent } = useEventAction();
   const [loading, setLoading] = useState(false);
-  const inputRef = useRef<HTMLTextAreaElement | null>(null);
+  const inputRef = useRef<HTMLTextAreaElement[]>(new Array<HTMLTextAreaElement>());
 
   const handleSave = async () => {
+    if (!inputRef.current) return;
     setLoading(true);
-    const newValue = inputRef.current?.value;
-    if (newValue === undefined) {
-      return;
+
+    const patchObject: Partial<OntimeEvent> = { id: event.id };
+
+    inputRef.current.forEach((element) => {
+      if (element.dataset.field && element.defaultValue != element.value) {
+        if (patchObject.custom) {
+          patchObject.custom[element.dataset.field] = element.value;
+        } else {
+          Object.assign(patchObject, { custom: { [element.dataset.field]: element.value } });
+        }
+      }
+    });
+
+    if (patchObject.custom) {
+      await updateEvent(patchObject);
     }
 
-    await updateCustomField(event.id, event.field, newValue);
     setLoading(false);
     onClose();
   };
 
-  const fieldLabel = event?.fieldLabel ?? event.field;
-
   return (
     <div className={style.editModal}>
-      <div>{`Editing field ${fieldLabel} in cue ${event.cue}`}</div>
-      <Textarea
-        ref={inputRef}
-        variant='ontime-filled'
-        placeholder={`Add value for ${fieldLabel} field`}
-        defaultValue={event.fieldValue}
-        isDisabled={loading}
-        resize='none'
-      />
+      <div>{`Editing fields in cue ${event.cue}`}</div>
+      {event.subscriptions.map((field) => {
+        return (
+          <div key={field.label}>
+            <label>{field.label}</label>
+            <Textarea
+              ref={(element) => {
+                if (element) inputRef.current.push(element);
+              }}
+              variant='ontime-filled'
+              placeholder={`Add value for ${field.label} field`}
+              defaultValue={field.value}
+              data-field={field.id}
+              isDisabled={loading}
+              resize='none'
+            />
+          </div>
+        );
+      })}
       <div className={style.buttonRow}>
         <Button variant='ontime-subtle' onClick={onClose} isDisabled={loading}>
           Cancel

apps/client/src/features/operator/operator-event/OperatorEvent.module.scss

@@ -20,9 +20,9 @@
   grid-template-rows: auto auto auto;
   column-gap: 0.5rem;
   grid-template-areas:
-  "binder main      schedule"
-  "binder secondary running"
-  "binder fields    fields";
+    'binder main      schedule'
+    'binder secondary running'
+    'binder fields    fields';
 
   &.subscribed {
     background-color: $gray-1250;
@@ -30,7 +30,7 @@
 
   &.running {
     border-top: 1px solid $gray-1300;
-    background-color: var(--operator-running-bg-override, $red-700);
+    background-color: var(--operator-running-bg-override, $active-red);
   }
 
   &.past {
@@ -93,16 +93,25 @@
   font-weight: 400;
   color: $ui-black;
   margin: 0.25rem 0;
+  display: flex;
+  flex-wrap: wrap;
 
   .field {
     font-weight: 600;
     padding: 0 0.25rem;
-    background-color: var(--operator-highlight-override, $orange-600);
-    margin-right: 0.5rem;
+    margin-right: 0.25rem;
+  }
+
+  .noColour {
+    outline: 0.15rem solid var(--operator-highlight-override, $ui-white);
+    outline-offset: -0.15rem;
+    padding-right: 0.3rem;
+    color: $ui-white;
   }
 
   .value {
-    color: $orange-500;
+    color: var(--operator-highlight-override, $ui-white);
+    margin-right: 1rem;
   }
 }
 

apps/client/src/features/operator/operator-event/OperatorEvent.tsx

@@ -6,7 +6,7 @@ import { useTimer } from '../../../common/hooks/useSocket';
 import { cx, getAccessibleColour } from '../../../common/utils/styleUtils';
 import ClockTime from '../../viewers/common/clock-time/ClockTime';
 import RunningTime from '../../viewers/common/running-time/RunningTime';
-import type { EditEvent } from '../Operator';
+import type { EditEvent, Subscribed } from '../Operator';
 
 import style from './OperatorEvent.module.scss';
 
@@ -21,8 +21,7 @@ interface OperatorEventProps {
   duration: number;
   delay?: number;
   isSelected: boolean;
-  subscribed?: string;
-  subscribeLabel: string;
+  subscribed: Subscribed | null;
   isPast: boolean;
   selectedRef?: RefObject<HTMLDivElement>;
   onLongPress: (event: EditEvent) => void;
@@ -47,7 +46,6 @@ function OperatorEvent(props: OperatorEventProps) {
     delay,
     isSelected,
     subscribed,
-    subscribeLabel: subscribedAlias,
     isPast,
     selectedRef,
     onLongPress,
@@ -56,7 +54,9 @@ function OperatorEvent(props: OperatorEventProps) {
   const handleLongPress = (event?: SyntheticEvent) => {
     // we dont have an event out of useLongPress
     event?.preventDefault();
-    onLongPress({ id, cue, fieldLabel: subscribedAlias, fieldValue: subscribed ?? '' });
+    if (subscribed) {
+      onLongPress({ id, cue, subscriptions: subscribed });
+    }
   };
 
   const mouseHandlers = useLongPress(handleLongPress, { threshold: 800 });
@@ -89,12 +89,22 @@ function OperatorEvent(props: OperatorEventProps) {
       </span>
 
       <div className={style.fields}>
-        {subscribed && (
-          <>
-            <span className={style.field}>{subscribedAlias}</span>
-            <span className={style.value}>{subscribed}</span>
-          </>
-        )}
+        {subscribed &&
+          subscribed
+            .filter((field) => field.value)
+            .map((field) => {
+              const fieldClasses = cx([style.field, !field.colour ? style.noColour : null]);
+              return (
+                <div key={field.id}>
+                  <span className={fieldClasses} style={{ backgroundColor: field.colour }}>
+                    {field.label}
+                  </span>
+                  <span className={style.value} style={{ color: field.colour }}>
+                    {field.value}
+                  </span>
+                </div>
+              );
+            })}
       </div>
     </div>
   );

apps/client/src/features/operator/status-bar/StatusBar.module.scss

@@ -105,5 +105,5 @@
 }
 
 .progressOverride {
-  border-radius: 0;
+  --progress-bar-br: 0;
 }

apps/client/src/features/operator/status-bar/StatusBarProgress.tsx

@@ -24,6 +24,7 @@ export default function StatusBarProgress(props: StatusBarProgressProps) {
       danger={timeDanger}
       dangerColor={viewSettings.dangerColor}
       className={styles.progressOverride}
+      ignoreCssOverride
     />
   );
 }

apps/client/src/features/timeline/Timeline/Timeline.module.scss

@@ -0,0 +1,72 @@
+$timeline-entry-height: 20px;
+
+.timeline {
+  flex: 1;
+}
+
+.timelineEvents {
+  position: relative;
+}
+
+.entryIndicator {
+  position: absolute;
+  background-color: var(--color, $ui-white);
+  height: $timeline-entry-height;
+}
+
+.entryContent {
+  position: absolute;
+  margin-top: $timeline-entry-height;
+  padding-top: var(--top, 0);
+  border-left: 2px solid var(--color, $ui-white);
+
+  color: $ui-white;
+
+  white-space: nowrap;
+
+  > div {
+    min-width: 100%;
+    padding-inline: 0.5em;
+    width: fit-content;
+    background-color: $ui-black;
+  }
+
+  &.lastElement {
+    border-left: none;
+    border-right: 2px solid var(--color, $ui-black);
+    text-align: right;
+
+    transform: translateX(-100%);
+  }
+}
+
+.start,
+.title {
+  font-weight: 600;
+}
+
+// for elapsed events, we can hide some stuff
+[data-status='finished'] {
+  color: $gray-500;
+  .status {
+    display: none
+  }
+}
+
+[data-status='live'] {
+  font-weight: 600;
+  color: $ui-white;
+
+  .status {
+    color: $active-red;
+  }
+}
+
+[data-status='future'] {
+  font-weight: 600;
+  color: $gray-300;
+
+  .status {
+    color: $green-500;
+  }
+}

apps/client/src/features/timeline/Timeline/Timeline.tsx

@@ -0,0 +1,121 @@
+import { memo } from 'react';
+import { useViewportSize } from '@mantine/hooks';
+import { isOntimeEvent, MaybeNumber } from 'ontime-types';
+import { dayInMs, getFirstEventNormal, getLastEventNormal, MILLIS_PER_HOUR } from 'ontime-utils';
+
+import useRundown from '../../../common/hooks-query/useRundown';
+
+import { type ProgressStatus, TimelineEntry } from './TimelineEntry';
+import { TimelineMarkers } from './TimelineMarkers';
+import { ProgressBar } from './TimelineProgressBar';
+import { getElementPosition, getEndHour, getEstimatedWidth, getLaneLevel, getStartHour } from './timelineUtils';
+
+import style from './Timeline.module.scss';
+
+export default memo(Timeline);
+
+function useTimeline() {
+  const { data } = useRundown();
+  if (data.revision === -1) {
+    return null;
+  }
+
+  const { firstEvent } = getFirstEventNormal(data.rundown, data.order);
+  const { lastEvent } = getLastEventNormal(data.rundown, data.order);
+  const firstStart = firstEvent?.timeStart ?? 0;
+  const lastEnd = lastEvent?.timeEnd ?? 0;
+  const normalisedLastEnd = lastEnd < firstStart ? lastEnd + dayInMs : lastEnd;
+
+  // timeline is padded to nearest hours (floor and ceil)
+  const startHour = getStartHour(firstStart) * MILLIS_PER_HOUR;
+  const endHour = getEndHour(normalisedLastEnd) * MILLIS_PER_HOUR;
+
+  return {
+    rundown: data.rundown,
+    order: data.order,
+    startHour,
+    endHour,
+  };
+}
+
+interface TimelineProps {
+  selectedEventId: string | null;
+}
+
+function Timeline(props: TimelineProps) {
+  const { selectedEventId } = props;
+  const { width: screenWidth } = useViewportSize();
+  const timelineData = useTimeline();
+
+  if (timelineData === null) {
+    return null;
+  }
+
+  const { rundown, order, startHour, endHour } = timelineData;
+
+  let hasTimelinePassedMidnight = false;
+  let previousEventStartTime: MaybeNumber = null;
+  let eventStatus: ProgressStatus = 'finished';
+  // a list of the right most element for each lane
+  const rightMostElements: Record<number, number> = {};
+
+  return (
+    <div className={style.timeline}>
+      <TimelineMarkers />
+      <div className={style.timelineEvents}>
+        {order.map((eventId) => {
+          // for now we dont render delays and blocks
+          const event = rundown[eventId];
+          if (!isOntimeEvent(event)) {
+            return null;
+          }
+
+          // keep track of progress of rundown
+          if (eventStatus === 'live') {
+            eventStatus = 'future';
+          }
+          if (eventId === selectedEventId) {
+            eventStatus = 'live';
+          }
+
+          // we need to offset the start to account for midnight
+          if (!hasTimelinePassedMidnight) {
+            hasTimelinePassedMidnight = previousEventStartTime !== null && event.timeStart < previousEventStartTime;
+          }
+          const normalisedStart = hasTimelinePassedMidnight ? event.timeStart + dayInMs : event.timeStart;
+          previousEventStartTime = normalisedStart;
+
+          const { left: elementLeftPosition, width: elementWidth } = getElementPosition(
+            startHour,
+            endHour,
+            normalisedStart,
+            event.duration,
+            screenWidth,
+          );
+          const estimatedRightPosition = elementLeftPosition + getEstimatedWidth(event.title);
+          const laneLevel = getLaneLevel(rightMostElements, elementLeftPosition);
+
+          if (rightMostElements[laneLevel] === undefined || rightMostElements[laneLevel] < estimatedRightPosition) {
+            rightMostElements[laneLevel] = estimatedRightPosition;
+          }
+
+          return (
+            <TimelineEntry
+              key={eventId}
+              colour={event.colour}
+              duration={event.duration}
+              isLast={eventId === order[order.length - 1]}
+              lane={laneLevel}
+              left={elementLeftPosition}
+              status={eventStatus}
+              start={event.timeStart}
+              title={event.title}
+              width={elementWidth}
+            />
+          );
+        })}
+      </div>
+      <ProgressBar startHour={startHour} endHour={endHour} />
+    </div>
+  );
+}

apps/client/src/features/timeline/Timeline/TimelineEntry.tsx

@@ -0,0 +1,78 @@
+import { useClock } from '../../../common/hooks/useSocket';
+import { cx } from '../../../common/utils/styleUtils';
+import { formatDuration, formatTime } from '../../../common/utils/time';
+
+import { getStatusLabel } from './timelineUtils';
+
+import style from './Timeline.module.scss';
+
+export type ProgressStatus = 'finished' | 'live' | 'future';
+
+interface TimelineEntry {
+  colour: string;
+  duration: number;
+  isLast: boolean;
+  lane: number;
+  left: number;
+  status: ProgressStatus;
+  start: number;
+  title: string;
+  width: number;
+}
+
+const laneHeight = 120;
+const formatOptions = {
+  format12: 'hh:mm a',
+  format24: 'HH:mm',
+};
+
+export function TimelineEntry(props: TimelineEntry) {
+  const { colour, duration, isLast, lane, left, status, start, title, width } = props;
+
+  const formattedStartTime = formatTime(start, formatOptions);
+  const formattedDuration = `Dur ${formatDuration(duration)}`;
+
+  const contentClasses = cx([style.entryContent, isLast && style.lastElement]);
+
+  return (
+    <>
+      <div
+        className={style.entryIndicator}
+        style={{
+          '--color': colour,
+          left: `${left}px`,
+          width: `${width}px`,
+        }}
+      />
+      <div
+        className={contentClasses}
+        data-status={status}
+        style={{
+          '--color': colour,
+          '--top': `${lane * laneHeight}px`,
+          zIndex: 5 - lane,
+          left: `${left}px`,
+        }}
+      >
+        <div className={style.start}>{formattedStartTime}</div>
+        <div className={style.title}>{title}</div>
+        <div className={style.duration}>{formattedDuration}</div>
+        <TimelineEntryStatus status={status} start={start} />
+      </div>
+    </>
+  );
+}
+
+interface TimelineEntryStatusProps {
+  status: ProgressStatus;
+  start: number;
+}
+// we isolate this component to avoid re-rendering too many elements
+function TimelineEntryStatus(props: TimelineEntryStatusProps) {
+  const { status, start } = props;
+  // TODO: account for offset instead of just using the clock
+  const { clock } = useClock();
+  const statusText = getStatusLabel(start - clock, status);
+
+  return <div className={style.status}>{statusText}</div>;
+}

apps/client/src/features/timeline/Timeline/TimelineMarkers.module.scss

@@ -0,0 +1,19 @@
+.markers {
+  width: 100%;
+  color: $ui-white;
+  background-color: $white-10;
+  display: flex;
+  height: 1rem;
+  line-height: 1rem;
+  font-size: calc(1rem - 2px);
+  justify-content: space-evenly;
+  text-align: center;
+
+  & > * {
+    flex-grow: 1;
+  }
+
+  :nth-child(odd) {
+    background-color: $white-20;
+  }
+}

apps/client/src/features/timeline/Timeline/TimelineMarkers.tsx

@@ -0,0 +1,23 @@
+import useRundown from '../../../common/hooks-query/useRundown';
+
+import { getTimelineSections } from './timelineUtils';
+
+import style from './TimelineMarkers.module.scss';
+
+export function TimelineMarkers() {
+  const { data } = useRundown();
+
+  if (data.revision === -1) {
+    return null;
+  }
+
+  const elements = getTimelineSections(data.rundown, data.order);
+
+  return (
+    <div className={style.markers}>
+      {elements.map((tag, index) => {
+        return <span key={index}>{tag}</span>;
+      })}
+    </div>
+  );
+}

apps/client/src/features/timeline/Timeline/TimelineProgressBar.module.scss

@@ -0,0 +1,8 @@
+.progressBar {
+  position: relative;
+  height: 100%;
+  border-right: 2px solid $active-red;
+
+  transition-duration: 0.3s;
+  transition-property: left;
+}

apps/client/src/features/timeline/Timeline/TimelineProgressBar.tsx

@@ -0,0 +1,19 @@
+import { useClock } from '../../../common/hooks/useSocket';
+
+import { getRelativePositionX } from './timelineUtils';
+
+import style from './TimelineProgressBar.module.scss';
+
+interface ProgressBarProps {
+  startHour: number;
+  endHour: number;
+}
+
+export function ProgressBar(props: ProgressBarProps) {
+  const { startHour, endHour } = props;
+  const { clock } = useClock();
+
+  const left = getRelativePositionX(startHour, endHour, clock);
+
+  return <div className={style.progressBar} style={{ width: `${left}%` }} />;
+}

apps/client/src/features/timeline/Timeline/__tests__/timelineUtils.test.ts

@@ -0,0 +1,84 @@
+import { dayInMs } from 'ontime-utils';
+
+import { getElementPosition, getLaneLevel } from '../timelineUtils';
+
+describe('getCSSPosition()', () => {
+  it('accounts for rundown with one event', () => {
+    const scheduleStart = 0;
+    const scheduleEnd = dayInMs;
+    const eventStart = 0;
+    const eventDuration = dayInMs;
+    const containerWidth = 100;
+
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(0);
+    expect(result.width).toBe(containerWidth);
+  });
+
+  it('accounts for an event that starts halfway and ends at end', () => {
+    const scheduleStart = 0;
+    const scheduleEnd = 100;
+    const eventStart = 50;
+    const eventDuration = 50;
+    const containerWidth = 100;
+
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(50);
+    expect(result.width).toBe(50);
+  });
+
+  it('accounts for an event that starts first and ends halfway', () => {
+    const scheduleStart = 0;
+    const scheduleEnd = 100;
+    const eventStart = 0;
+    const eventDuration = 50;
+    const containerWidth = 100;
+
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(0);
+    expect(result.width).toBe(50);
+  });
+
+  it('accounts for an event that is in the middle of the rundown', () => {
+    const scheduleStart = 7;
+    const scheduleEnd = 23;
+    const eventStart = 10;
+    const eventDuration = 1;
+    const containerWidth = 1000;
+
+    // 16 hour event, this gives 62.5px per hour
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(187.5); // 3 * 62.5
+    expect(result.width).toBe(62.5);
+  });
+});
+
+describe('getLaneLevel()', () => {
+  it('should place in lane 0 if there is no overlap', () => {
+    const rightMostElements = { 0: 50 };
+    const left = 60;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(0);
+  });
+
+  it('should place in next available lane if there is overlap', () => {
+    const rightMostElements = { 0: 150, 1: 100 };
+    const left = 120;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(1);
+  });
+
+  it('should create a new lane if all existing lanes are overlapped', () => {
+    const rightMostElements = { 0: 200, 1: 250 };
+    const left = 150;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(2);
+  });
+
+  it('should place in lane 0 if it is the first event', () => {
+    const rightMostElements = {};
+    const left = 0;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(0);
+  });
+});

apps/client/src/features/timeline/Timeline/timelineUtils.ts

@@ -0,0 +1,154 @@
+import { isOntimeEvent, MaybeString, NormalisedRundown, OntimeEvent } from 'ontime-types';
+import {
+  dayInMs,
+  getByEventId,
+  getFirstEvent,
+  getFirstEventNormal,
+  getLastEventNormal,
+  getNextEvent,
+  MILLIS_PER_HOUR,
+  millisToString,
+  removeSeconds,
+} from 'ontime-utils';
+
+import { clamp } from '../../../common/utils/math';
+import { formatDuration } from '../../../common/utils/time';
+
+import type { ProgressStatus } from './TimelineEntry';
+
+type CSSPosition = {
+  left: number;
+  width: number;
+};
+
+/**
+ * Calculates the position (in %) of an element relative to a schedule
+ */
+export function getRelativePositionX(scheduleStart: number, scheduleEnd: number, now: number): number {
+  return clamp(((now - scheduleStart) / (scheduleEnd - scheduleStart)) * 100, 0, 100);
+}
+
+/**
+ * Estimates the width of an element based on its content
+ */
+export function getEstimatedWidth(content: string): number {
+  // use 8 as minimum width to account for duration string
+  // 12 is a rough estimate of the width of a character at 15px font size
+  return Math.max(content.length, 8) * 12;
+}
+/**
+ * Calculates an absolute position of an element based on a schedule
+ */
+export function getElementPosition(
+  scheduleStart: number,
+  scheduleEnd: number,
+  eventStart: number,
+  eventDuration: number,
+  containerWidth: number,
+): CSSPosition {
+  // TODO: events that finish at midnight have lastEnd 0
+  const totalDuration = scheduleEnd - scheduleStart;
+  const width = (eventDuration * containerWidth) / totalDuration;
+  const left = ((eventStart - scheduleStart) * containerWidth) / totalDuration;
+
+  return { left, width };
+}
+
+export function getStartHour(startTime: number): number {
+  const hours = Math.floor(startTime / MILLIS_PER_HOUR);
+  return hours;
+}
+
+export function getEndHour(endTime: number): number {
+  const hours = Math.ceil(endTime / MILLIS_PER_HOUR);
+  return hours;
+}
+
+export function makeTimelineSections(firstHour: number, lastHour: number) {
+  const timelineSections = [];
+  for (let i = firstHour; i < lastHour; i++) {
+    timelineSections.push(removeSeconds(millisToString(i * MILLIS_PER_HOUR)));
+  }
+  return timelineSections;
+}
+
+// TODO: account for elapsed days
+export function getTimelineSections(rundown: NormalisedRundown, order: string[]): string[] {
+  if (order.length === 0) {
+    return [];
+  }
+  const { firstEvent } = getFirstEventNormal(rundown, order);
+  const { lastEvent } = getLastEventNormal(rundown, order);
+  const firstStart = firstEvent?.timeStart ?? 0;
+  const lastEnd = lastEvent?.timeEnd ?? 0;
+  const normalisedLastEnd = lastEnd < firstStart ? lastEnd + dayInMs : lastEnd;
+
+  const startHour = getStartHour(firstStart);
+  const endHour = getEndHour(normalisedLastEnd);
+
+  const elements = makeTimelineSections(startHour, endHour);
+  return elements;
+}
+
+const MAX_DEPTH = 5;
+
+/**
+ * Estimates the top offset for an element
+ */
+export function getLaneLevel(rightMostElements: Record<number, number>, left: number): number {
+  for (let checkLane = 0; checkLane < MAX_DEPTH; checkLane++) {
+    if (rightMostElements[checkLane] === undefined) {
+      return checkLane;
+    }
+    if (rightMostElements[checkLane] < left) {
+      return checkLane;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Returns a formatted label for a progress status
+ */
+export function getStatusLabel(timeToStart: number, status: ProgressStatus): string {
+  if (status === 'finished' || status === 'live') {
+    return status;
+  }
+
+  if (timeToStart < 0) {
+    return 'T - 0';
+  }
+
+  return `T - ${formatDuration(timeToStart)}`;
+}
+
+type UpcomingEvents = {
+  now: MaybeString;
+  next: MaybeString;
+  followedBy: MaybeString;
+};
+
+/**
+ * Returns upcoming events from current: now, next and followedBy
+ */
+export function getUpcomingEvents(events: OntimeEvent[], selectedId: MaybeString): UpcomingEvents {
+  if (events.length === 0) {
+    return { now: null, next: null, followedBy: null };
+  }
+
+  const nowEvent = selectedId ? getByEventId(events, selectedId) : getFirstEvent(events)?.firstEvent;
+
+  if (!isOntimeEvent(nowEvent)) {
+    return { now: null, next: null, followedBy: null };
+  }
+
+  const nextEvent = getNextEvent(events, nowEvent.id)?.nextEvent;
+  const followedByEvent = nextEvent ? getNextEvent(events, nextEvent.id)?.nextEvent : null;
+
+  // Return the titles, handling nulls appropriately
+  return {
+    now: nowEvent.title,
+    next: nextEvent ? nextEvent.title : null,
+    followedBy: followedByEvent ? followedByEvent.title : null,
+  };
+}

apps/client/src/features/timeline/TimelinePage.module.scss

@@ -0,0 +1,51 @@
+.progress {
+  width: 100vw;
+  height: 100vh;
+
+  background-color: $ui-black;
+  color: $ui-white;
+  text-transform: uppercase;
+
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.title {
+  padding-inline: 2rem;
+  text-align: left;
+  font-size: 3.5rem;
+}
+
+.sections {
+  padding-inline: 2rem;
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  row-gap: 1rem;
+  column-gap: 3rem;
+}
+
+.sectionTitle {
+  line-height: 1.2em;
+  font-size: 1.5rem;
+  text-transform: uppercase;
+}
+
+.sectionContent {
+  line-height: 1em;
+  font-size: 3rem;
+  text-transform: uppercase;
+  font-weight: 600;
+
+  &.now {
+    color: $green-500;
+  }
+
+  &.next {
+    color: $red-500;
+  }
+
+  &.subdue {
+    opacity: $opacity-disabled;
+  }
+}

apps/client/src/features/timeline/TimelinePage.tsx

@@ -0,0 +1,63 @@
+import { MaybeString, OntimeEvent, ProjectData, Settings } from 'ontime-types';
+
+import { getProgressOptions } from '../../common/components/view-params-editor/constants';
+import ViewParamsEditor from '../../common/components/view-params-editor/ViewParamsEditor';
+import { ViewExtendedTimer } from '../../common/models/TimeManager.type';
+import { cx } from '../../common/utils/styleUtils';
+import { formatTime, getDefaultFormat } from '../../common/utils/time';
+
+import Timeline from './Timeline/Timeline';
+import { getUpcomingEvents } from './Timeline/timelineUtils';
+
+import style from './TimelinePage.module.scss';
+
+interface TimelinePageProps {
+  backstageEvents: OntimeEvent[];
+  general: ProjectData;
+  selectedId: MaybeString;
+  settings: Settings | undefined;
+  time: ViewExtendedTimer;
+}
+
+export default function TimelinePage(props: TimelinePageProps) {
+  const { backstageEvents, general, selectedId, settings, time } = props;
+
+  const clock = formatTime(time.clock);
+  const { now, next, followedBy } = getUpcomingEvents(backstageEvents, selectedId);
+
+  // populate options
+  const defaultFormat = getDefaultFormat(settings?.timeFormat);
+  const progressOptions = getProgressOptions(defaultFormat);
+
+  return (
+    <div className={style.progress}>
+      <ViewParamsEditor paramFields={progressOptions} />
+      <div className={style.title}>{general.title}</div>
+      <div className={style.sections}>
+        <Section title='Time now' content={clock} category='now' />
+        <Section title='Next' content={next} category='next' />
+        <Section title='Current' content={now} category='now' />
+        <Section title='Followed by' content={followedBy} category='next' />
+      </div>
+      <Timeline selectedEventId={selectedId} />
+    </div>
+  );
+}
+
+interface SectionProps {
+  category: 'now' | 'next';
+  content: MaybeString;
+  title: string;
+}
+
+function Section(props: SectionProps) {
+  const { category, content, title } = props;
+
+  const contentClasses = cx([style.sectionContent, content != null ? style[category] : style.subdue]);
+  return (
+    <div>
+      <div className={style.sectionTitle}>{title}</div>
+      <div className={contentClasses}>{content ?? '-'}</div>
+    </div>
+  );
+}

apps/client/src/features/viewers/common/viewUtils.ts

@@ -53,10 +53,6 @@ export function getPropertyValue(event: OntimeEvent | null, property: MaybeStrin
   return event[property as keyof OntimeEvent] as string;
 }
 
-export function capitaliseFirstLetter(string: string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
 type FormattingOptions = {
   removeSeconds: boolean;
   removeLeadingZero: boolean;

apps/client/src/features/viewers/timer/Timer.tsx

@@ -106,6 +106,10 @@ export default function Timer(props: TimerProps) {
   const secondaryTextNow = getPropertyValue(eventNow, secondarySource);
   const secondaryTextNext = getPropertyValue(eventNext, secondarySource);
 
+  const main = searchParams.get('main');
+  const mainFieldNow = (main ? getPropertyValue(eventNow, main) : eventNow?.title) ?? '';
+  const mainFieldNext = (main ? getPropertyValue(eventNext, main) : eventNext?.title) ?? '';
+
   const showOverlay = pres.text !== '' && pres.visible;
   const isPlaying = time.playback !== Playback.Pause;
 
@@ -215,7 +219,7 @@ export default function Timer(props: TimerProps) {
                 animate='visible'
                 exit='exit'
               >
-                <TitleCard label='now' title={eventNow.title} secondary={secondaryTextNow} />
+                <TitleCard label='now' title={mainFieldNow} secondary={secondaryTextNow} />
               </motion.div>
             )}
           </AnimatePresence>
@@ -230,7 +234,7 @@ export default function Timer(props: TimerProps) {
                 animate='visible'
                 exit='exit'
               >
-                <TitleCard label='next' title={eventNext.title} secondary={secondaryTextNext} />
+                <TitleCard label='next' title={mainFieldNext} secondary={secondaryTextNext} />
               </motion.div>
             )}
           </AnimatePresence>

apps/client/src/theme/_ontimeStyles.scss

@@ -15,6 +15,7 @@ $ontime-color: #ff7597;
 $error-red: $red-500;
 $warning-orange: $orange-500;
 $opacity-disabled: 0.4;
+$active-red: $red-700;
 
 // playback colours
 $playback-start: $green-600;
@@ -37,7 +38,6 @@ $bg-container-onlight: $gray-100;
 $box-shadow-l1: rgba(0, 0, 0, 0.15) 0 3px 3px 0;
 $box-shadow-l2: rgba(0, 0, 0, 0.15) 0 3px 3px 0;
 $box-shadow-right: rgba(0, 0, 0, 0.15) 3px 0 3px 0;
-$large-bottom-drawer-shadow: rgba(0, 0, 0, 0.35) 0 3px 6px 6px;
 $large-top-drawer-shadow: rgba(0, 0, 0, 0.35) 0 1px 6px 3px;
 
 $modal-note-color: $gray-700;

apps/client/src/translation/TranslationProvider.tsx

@@ -8,6 +8,7 @@ import { langEs } from './languages/es';
 import { langFr } from './languages/fr';
 import { langIt } from './languages/it';
 import { langNo } from './languages/no';
+import { langPl } from './languages/pl';
 import { langPt } from './languages/pt';
 import { langSv } from './languages/sv';
 
@@ -20,6 +21,7 @@ const translationsList = {
   no: langNo,
   pt: langPt,
   sv: langSv,
+  pl: langPl,
 };
 
 interface TranslationContextValue {

apps/client/src/translation/languages/pl.ts

@@ -0,0 +1,21 @@
+import { TranslationObject } from './en';
+
+export const langPl: TranslationObject = {
+  'common.end_time': 'Czas zakończenia',
+  'common.expected_finish': 'Zakładany czas zakończenia',
+  'common.minutes': 'min',
+  'common.now': 'Teraz',
+  'common.next': 'Następnie',
+  'common.public_message': 'Wiadomość publiczna',
+  'common.start_time': 'Czas rozpoczęcia',
+  'common.stage_timer': 'Timer Scena',
+  'common.started_at': 'Rozpoczęte o',
+  'common.time_now': 'Aktualny czas',
+  'countdown.ended': 'Zakończone o',
+  'countdown.running': 'Trwa',
+  'countdown.select_event': 'Wybierz event który chcesz śledzić',
+  'countdown.to_start': 'Do rozpoczęcia',
+  'countdown.waiting': 'Oczekiwanie na start',
+  'countdown.overtime': 'ponad czasem',
+};
+

apps/client/src/viewerConfig.ts

@@ -4,6 +4,7 @@ export const navigatorConstants = [
   { url: '/minimal', label: 'Minimal Timer' },
   { url: '/backstage', label: 'Backstage' },
   { url: '/public', label: 'Public' },
+  { url: '/timeline', label: 'Timeline' },
   { url: '/lower', label: 'Lower Thirds' },
   { url: '/studio', label: 'Studio Clock' },
   { url: '/countdown', label: 'Countdown' },

apps/electron/electron.config.js

@@ -3,7 +3,7 @@ module.exports = {
     shutdownCode: 99,
   },
   reactAppUrl: {
-    development: (port = 4001) => `http://localhost:${port}`,
+    development: (port = 3000) => `http://localhost:${port}`,
     production: (port = 4001) => `http://localhost:${port}`,
   },
   server: {

apps/electron/main.js

@@ -30,6 +30,10 @@ let win;
 let splash;
 let tray = null;
 
+/**
+ * Coordinates the node process startup
+ * @returns {number} server port - the port at which the backend has been started at
+ */
 async function startBackend() {
   // in dev mode, we expect both UI and server to be running
   if (!isProduction) {
@@ -41,7 +45,7 @@ async function startBackend() {
 
   await initAssets();
 
-  const result = await startServer();
+  const result = await startServer(escalateError);
   loaded = result.message;
 
   await startIntegrations();
@@ -62,6 +66,9 @@ function showNotification(title, text) {
   }).show();
 }
 
+/**
+ * Terminate node service and close electron app
+ */
 function appShutdown() {
   // terminate node service
   (async () => {
@@ -76,16 +83,30 @@ function appShutdown() {
   app.quit();
 }
 
+/**
+ * Sets Ontime window in focus
+ */
 function bringToFront() {
   win.show();
   win.focus();
 }
 
+/**
+ * Coordinates the shutdown process
+ */
 function askToQuit() {
   bringToFront();
   win.send('user-request-shutdown');
 }
 
+/**
+ * Allows processes to escalate errors to be shown in electron
+ * @param {string} error
+ */
+function escalateError(error) {
+  dialog.showErrorBox('An unrecoverable error occurred', error);
+}
+
 // Ensure there isn't another instance of the app running already
 const lock = app.requestSingleInstanceLock();
 if (!lock) {
@@ -103,6 +124,9 @@ if (!lock) {
   });
 }
 
+/**
+ * Coordinates creation of electron windows (splash and main)
+ */
 function createWindow() {
   splash = new BrowserWindow({
     width: 333,
@@ -191,12 +215,16 @@ app.whenReady().then(() => {
       console.log('ERROR: Ontime failed to start', error);
     });
 
-  // recreate window if no others open
+  /**
+   * recreate window if no others open
+   */
   app.on('activate', () => {
     win.show();
   });
 
-  // Hide on close
+  /**
+   * Hide on close
+   */
   win.on('close', function (event) {
     event.preventDefault();
     if (!isQuitting) {
@@ -213,12 +241,11 @@ app.whenReady().then(() => {
   const trayMenuTemplate = getTrayMenu(bringToFront, askToQuit);
   const trayContextMenu = Menu.buildFromTemplate(trayMenuTemplate);
   tray.setContextMenu(trayContextMenu);
-
-  
 });
 
-
-// unregister shortcuts before quitting
+/**
+ * Unregister shortcuts before quitting
+ */
 app.once('will-quit', () => {
   globalShortcut.unregisterAll();
 });
@@ -235,7 +262,9 @@ ipcMain.on('shutdown', () => {
   appShutdown();
 });
 
-// Window manipulation
+/**
+ * Handles requests to set window properties
+ */
 ipcMain.on('set-window', (event, arg) => {
   switch (arg) {
     case 'show-dev':
@@ -246,7 +275,9 @@ ipcMain.on('set-window', (event, arg) => {
   }
 });
 
-// Open links external
+/**
+ * Handles requests to open external links
+ */
 ipcMain.on('send-to-link', (event, arg) => {
   shell.openExternal(arg);
 });

apps/electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime",
-  "version": "3.1.1",
+  "version": "3.4.0-alpha-timeline",
   "author": "Carlos Valente",
   "description": "Time keeping for live events",
   "repository": "https://github.com/cpvalente/ontime",
@@ -14,17 +14,18 @@
   "devDependencies": {
     "electron": "^28.3.3",
     "electron-builder": "^24.13.3",
-    "eslint": "^8.53.0",
-    "eslint-config-prettier": "^9.0.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
     "prettier": "^3.0.3"
   },
   "scripts": {
     "postinstall": "",
     "lint": "eslint . --quiet",
     "lint-staged": "eslint",
-    "dev:electron": "cross-env NODE_ENV=development electron .",
+    "dev": "cross-env NODE_ENV=development electron .",
     "dist-win": "electron-builder --publish=never --x64 --win",
     "dist-mac": "electron-builder --publish=never --mac",
+    "dist-mac:local": "electron-builder --publish=never --mac -c.mac.identity=null",
     "dist-linux": "electron-builder --publish=never --x64 --linux",
     "cleanup": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
   },

apps/server/package.json

@@ -2,7 +2,7 @@
   "name": "ontime-server",
   "type": "module",
   "main": "src/index.ts",
-  "version": "3.1.1",
+  "version": "3.4.0-alpha-timeline",
   "exports": "./src/index.js",
   "dependencies": {
     "@googleapis/sheets": "^5.0.5",
@@ -19,6 +19,7 @@
     "node-osc": "^9.0.2",
     "node-xlsx": "^0.23.0",
     "ontime-utils": "workspace:*",
+    "sanitize-filename": "^1.6.3",
     "steno": "^3.1.0",
     "ts-essentials": "^9.4.1",
     "ws": "^8.13.0"
@@ -31,14 +32,14 @@
     "@types/node-osc": "^6.0.2",
     "@types/websocket": "^1.0.5",
     "@types/ws": "^8.5.10",
-    "@typescript-eslint/eslint-plugin": "^6.10.0",
-    "@typescript-eslint/parser": "^6.10.0",
+    "@typescript-eslint/eslint-plugin": "^v7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
     "esbuild": "^0.19.10",
-    "eslint": "^8.53.0",
-    "eslint-plugin-prettier": "^5.0.1",
+    "eslint": "^8.56.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "nodemon": "^2.0.20",
     "ontime-types": "workspace:*",
-    "prettier": "^3.0.3",
+    "prettier": "^3.3.1",
     "server-timing": "^3.3.3",
     "shx": "^0.3.4",
     "ts-node": "^10.9.1",

apps/server/src/adapters/WebsocketAdapter.ts

@@ -14,7 +14,7 @@
  * Payload: adds necessary payload for the request to be completed
  */
 
-import { LogOrigin } from 'ontime-types';
+import { Client, LogOrigin } from 'ontime-types';
 
 import { WebSocket, WebSocketServer } from 'ws';
 import type { Server } from 'http';
@@ -24,6 +24,7 @@ import { IAdapter } from './IAdapter.js';
 import { eventStore } from '../stores/EventStore.js';
 import { logger } from '../classes/Logger.js';
 import { dispatchFromAdapter } from '../api-integration/integration.controller.js';
+import { generateId } from 'ontime-utils';
 
 let instance: SocketServer | null = null;
 
@@ -31,7 +32,7 @@ export class SocketServer implements IAdapter {
   private readonly MAX_PAYLOAD = 1024 * 256; // 256Kb
 
   private wss: WebSocketServer | null;
-  private readonly clientIds: Set<string>;
+  private readonly clients: Map<string, Client>;
 
   constructor() {
     if (instance) {
@@ -40,7 +41,7 @@ export class SocketServer implements IAdapter {
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias -- this logic is used to ensure singleton
     instance = this;
-    this.clientIds = new Set<string>();
+    this.clients = new Map<string, Client>();
     this.wss = null;
   }
 
@@ -48,9 +49,32 @@ export class SocketServer implements IAdapter {
     this.wss = new WebSocketServer({ path: '/ws', server, maxPayload: this.MAX_PAYLOAD });
 
     this.wss.on('connection', (ws) => {
-      let clientId = getRandomName();
-      this.clientIds.add(clientId);
-      logger.info(LogOrigin.Client, `${this.clientIds.size} Connections with new: ${clientId}`);
+      const clientId = generateId();
+
+      this.clients.set(clientId, {
+        type: 'unknown',
+        identify: false,
+        name: getRandomName(),
+        path: '',
+      });
+
+      logger.info(LogOrigin.Client, `${this.clients.size} Connections with new: ${clientId}`);
+
+      ws.send(
+        JSON.stringify({
+          type: 'client-id',
+          payload: clientId,
+        }),
+      );
+
+      ws.send(
+        JSON.stringify({
+          type: 'client-name',
+          payload: this.clients.get(clientId).name,
+        }),
+      );
+
+      this.sendClientList();
 
       // send store payload on connect
       ws.send(
@@ -60,18 +84,12 @@ export class SocketServer implements IAdapter {
         }),
       );
 
-      ws.send(
-        JSON.stringify({
-          type: 'client-name',
-          payload: clientId,
-        }),
-      );
-
       ws.on('error', console.error);
 
       ws.on('close', () => {
-        this.clientIds.delete(clientId);
-        logger.info(LogOrigin.Client, `${this.clientIds.size} Connections with disconnected: ${clientId}`);
+        this.clients.delete(clientId);
+        logger.info(LogOrigin.Client, `${this.clients.size} Connections with disconnected: ${clientId}`);
+        this.sendClientList();
       });
 
       ws.on('message', (data) => {
@@ -84,26 +102,44 @@ export class SocketServer implements IAdapter {
             ws.send(
               JSON.stringify({
                 type: 'client-name',
-                payload: clientId,
+                payload: this.clients.get(clientId).name,
               }),
             );
             return;
           }
 
+          if (type === 'set-client-type') {
+            if (payload && typeof payload == 'string') {
+              const previousData = this.clients.get(clientId);
+              this.clients.set(clientId, { ...previousData, type: payload });
+            }
+            this.sendClientList();
+            return;
+          }
+
+          if (type === 'set-client-path') {
+            if (payload && typeof payload == 'string') {
+              const previousData = this.clients.get(clientId);
+              previousData.path = payload;
+              this.clients.set(clientId, previousData);
+            }
+            this.sendClientList();
+            return;
+          }
+
           if (type === 'set-client-name') {
             if (payload) {
-              const previousName = clientId;
-              clientId = payload;
-              this.clientIds.delete(previousName);
-              this.clientIds.add(clientId);
-              logger.info(LogOrigin.Client, `Client ${previousName} renamed to ${clientId}`);
+              const previousData = this.clients.get(clientId);
+              logger.info(LogOrigin.Client, `Client ${previousData.name} renamed to ${payload}`);
+              this.clients.set(clientId, { ...previousData, name: payload });
+              ws.send(
+                JSON.stringify({
+                  type: 'client-name',
+                  payload: this.clients.get(clientId).name,
+                }),
+              );
             }
-            ws.send(
-              JSON.stringify({
-                type: 'client-name',
-                payload: clientId,
-              }),
-            );
+            this.sendClientList();
             return;
           }
 
@@ -135,17 +171,58 @@ export class SocketServer implements IAdapter {
     });
   }
 
-  // message is any serializable value
-  sendAsJson(message: unknown) {
-    this.wss?.clients.forEach((client) => {
-      try {
-        if (client.readyState === WebSocket.OPEN) {
-          client.send(JSON.stringify(message));
-        }
-      } catch (_) {
-        /** We do not handle this error */
-      }
+  private sendClientList(): void {
+    const payload = Object.fromEntries(this.clients.entries());
+    this.sendAsJson({ type: 'client-list', payload });
+  }
+
+  public getClientList(): string[] {
+    return Array.from(this.clients.keys());
+  }
+
+  public renameClient(target: string, name: string) {
+    const previousData = this.clients.get(target);
+    if (!previousData) {
+      throw new Error(`Client "${target}" not found`);
+    }
+    logger.info(LogOrigin.Client, `Client ${previousData.name} renamed to ${name}`);
+    this.clients.set(target, { ...previousData, name });
+    this.sendAsJson({
+      type: 'client-rename',
+      payload: { name, target },
     });
+    this.sendClientList();
+  }
+
+  public redirectClient(target: string, path: string) {
+    const previousData = this.clients.get(target);
+    if (!previousData) {
+      throw new Error(`Client "${target}" not found`);
+    }
+    this.sendAsJson({ type: 'client-redirect', payload: { target, path } });
+  }
+
+  public identifyClient(target: string, identify: boolean) {
+    const previousData = this.clients.get(target);
+    if (!previousData) {
+      throw new Error(`Client "${target}" not found`);
+    }
+    this.clients.set(target, { ...previousData, identify });
+    this.sendClientList();
+  }
+
+  // message is any serializable value
+  public sendAsJson(message: unknown) {
+    try {
+      const stringifiedMessage = JSON.stringify(message);
+      this.wss?.clients.forEach((client) => {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(stringifiedMessage);
+        }
+      });
+    } catch (_) {
+      /** We do not handle this error */
+    }
   }
 
   shutdown() {

apps/server/src/api-data/db/db.controller.ts

@@ -16,7 +16,6 @@ import { failEmptyObjects } from '../../utils/routerUtils.js';
 import { resolveDbDirectory, resolveProjectsDirectory } from '../../setup/index.js';
 
 import * as projectService from '../../services/project-service/ProjectService.js';
-import { ensureJsonExtension } from '../../utils/fileManagement.js';
 import { generateUniqueFileName } from '../../utils/generateUniqueFilename.js';
 import { appStateService } from '../../services/app-state-service/AppStateService.js';
 import { oscIntegration } from '../../services/integration-service/OscIntegration.js';
@@ -54,8 +53,7 @@ export async function patchPartialProjectFile(req: Request, res: Response<Databa
  */
 export async function createProjectFile(req: Request, res: Response<{ filename: string } | ErrorResponse>) {
   try {
-    const originalFilename = ensureJsonExtension(req.body.title || 'Untitled');
-    const filename = generateUniqueFileName(resolveProjectsDirectory, originalFilename);
+    const filename = generateUniqueFileName(resolveProjectsDirectory, req.body.filename);
     const errors = projectService.validateProjectFiles({ newFilename: filename });
 
     if (errors.length) {
@@ -71,7 +69,7 @@ export async function createProjectFile(req: Request, res: Response<{ filename:
       backstageInfo: req.body?.backstageInfo ?? '',
     };
 
-    projectService.createProjectFile(filename, newProjectData);
+    await projectService.createProjectFile(filename, newProjectData);
 
     res.status(200).send({
       filename,
@@ -83,29 +81,18 @@ export async function createProjectFile(req: Request, res: Response<{ filename:
 }
 
 /**
- * Utility function finds the correct project file to download
- */
-function selectProjectFile(fileName?: string) {
-  const projectsDirectory = resolveDbDirectory;
-  const fileToDownload = fileName ? ensureJsonExtension(fileName) : projectService.getProjectTitle();
-  const pathToFile = join(projectsDirectory, fileToDownload);
-
-  return { pathToFile, name: fileToDownload };
-}
-
-/**
- * Allows downloading of a optionally given project files
- * If no {filename} is provided, loaded file will be served
+ * Allows downloading of project files
  */
 export async function projectDownload(req: Request, res: Response) {
-  const { pathToFile, name } = selectProjectFile(req.body?.fileName);
+  const { filename } = req.body;
+  const pathToFile = join(resolveDbDirectory, filename);
 
   // Check if the file exists before attempting to download
   if (!existsSync(pathToFile)) {
-    return res.status(404).send({ message: `Project ${name} not found.` });
+    return res.status(404).send({ message: `Project ${filename} not found.` });
   }
 
-  res.download(pathToFile, name, (error) => {
+  res.download(pathToFile, filename, (error) => {
     if (error) {
       const message = getErrorMessage(error);
       res.status(500).send({ message });
@@ -228,7 +215,7 @@ export async function duplicateProjectFile(req: Request, res: Response<MessageRe
  */
 export async function renameProjectFile(req: Request, res: Response<MessageResponse | ErrorResponse>) {
   try {
-    const { newFilename } = req.body;
+    const { filename: newFilename } = req.body;
     const { filename } = req.params;
 
     const errors = projectService.validateProjectFiles({ filename, newFilename });

apps/server/src/api-data/db/db.router.ts

@@ -14,28 +14,25 @@ import {
 } from './db.controller.js';
 import { uploadProjectFile } from './db.middleware.js';
 import {
-  projectSanitiser,
-  sanitizeProjectFilename,
-  validateDownloadProject,
-  validateLoadProjectFile,
-  validatePatchProjectFile,
-  validateProjectDuplicate,
-  validateProjectRename,
+  validateNewProject,
+  validatePatchProject,
+  validateFilenameBody,
+  validateFilenameParam,
 } from './db.validation.js';
 
 export const router = express.Router();
 
-router.post('/download', validateDownloadProject, projectDownload);
+router.post('/download', validateFilenameBody, projectDownload);
 router.post('/upload', uploadProjectFile, postProjectFile);
 
-router.patch('/', validatePatchProjectFile, patchPartialProjectFile);
-router.post('/new', projectSanitiser, createProjectFile);
+router.patch('/', validatePatchProject, patchPartialProjectFile);
+router.post('/new', validateFilenameBody, validateNewProject, createProjectFile);
 
 router.get('/all', listProjects);
 
-router.post('/load', validateLoadProjectFile, sanitizeProjectFilename, loadProject);
-router.post('/:filename/duplicate', validateProjectDuplicate, sanitizeProjectFilename, duplicateProjectFile);
-router.put('/:filename/rename', validateProjectRename, sanitizeProjectFilename, renameProjectFile);
-router.delete('/:filename', sanitizeProjectFilename, deleteProjectFile);
+router.post('/load', validateFilenameBody, loadProject);
+router.post('/:filename/duplicate', validateFilenameParam, validateFilenameBody, duplicateProjectFile);
+router.put('/:filename/rename', validateFilenameParam, validateFilenameBody, renameProjectFile);
+router.delete('/:filename', validateFilenameParam, deleteProjectFile);
 
 router.get('/info', getInfo);

apps/server/src/api-data/db/db.validation.ts

@@ -1,9 +1,12 @@
 import { Request, Response, NextFunction } from 'express';
-import { body, validationResult } from 'express-validator';
-
+import { body, param, validationResult } from 'express-validator';
 import { ensureJsonExtension } from '../../utils/fileManagement.js';
+import sanitize from 'sanitize-filename';
 
-export const projectSanitiser = [
+/**
+ * @description Validates request for a new project.
+ */
+export const validateNewProject = [
   body('title').optional().isString().trim(),
   body('description').optional().isString().trim(),
   body('publicUrl').optional().isString().trim(),
@@ -19,18 +22,10 @@ export const projectSanitiser = [
   },
 ];
 
-export const sanitizeProjectFilename = (req: Request, _res: Response, next: NextFunction) => {
-  const { filename, newFilename } = req.body;
-  const { filename: projectName } = req.params;
-
-  req.body.filename = ensureJsonExtension(filename);
-  req.body.newFilename = ensureJsonExtension(newFilename);
-  req.params.filename = ensureJsonExtension(projectName);
-
-  next();
-};
-
-export const validatePatchProjectFile = [
+/**
+ * @description Validates request for pathing data in the project.
+ */
+export const validatePatchProject = [
   body('rundown').isArray().optional({ nullable: false }),
   body('project').isObject().optional({ nullable: false }),
   body('settings').isObject().optional({ nullable: false }),
@@ -47,31 +42,18 @@ export const validatePatchProjectFile = [
 ];
 
 /**
- * @description Validates the filename for loading a project file.
+ * @description Validates request with filename in the body.
  */
-export const validateLoadProjectFile = [
-  body('filename').exists().withMessage('Filename is required').isString().withMessage('Filename must be a string'),
-
-  (req: Request, res: Response, next: NextFunction) => {
-    const errors = validationResult(req);
-    if (!errors.isEmpty()) {
-      return res.status(422).json({ errors: errors.array() });
-    }
-    next();
-  },
-];
-
-/**
- * @description Validates the filenames for duplicating a project.
- */
-export const validateProjectDuplicate = [
-  body('newFilename')
+export const validateFilenameBody = [
+  body('filename')
     .exists()
-    .withMessage('New project filename is required')
     .isString()
-    .withMessage('New project filename must be a string')
-    .isLength({ min: 1, max: 255 })
-    .withMessage('New project filename must be between 1 and 255 characters'),
+    .trim()
+    .customSanitizer((input: string) => sanitize(input))
+    .withMessage('Failed to sanitize the filename')
+    .notEmpty()
+    .withMessage('Filename was empty or contained only invalid characters')
+    .customSanitizer((input: string) => ensureJsonExtension(input)),
 
   (req: Request, res: Response, next: NextFunction) => {
     const errors = validationResult(req);
@@ -84,32 +66,18 @@ export const validateProjectDuplicate = [
 ];
 
 /**
- * @description Validates the filenames for renaming a project.
+ * @description Validates request with filename in the params.
  */
-export const validateProjectRename = [
-  body('newFilename')
+export const validateFilenameParam = [
+  param('filename')
     .exists()
-    .withMessage('Duplicate project filename is required')
     .isString()
-    .withMessage('Duplicate project filename must be a string')
-    .isLength({ min: 1, max: 255 })
-    .withMessage('Duplicate project filename must be between 1 and 255 characters'),
-
-  (req: Request, res: Response, next: NextFunction) => {
-    const errors = validationResult(req);
-    if (!errors.isEmpty()) {
-      return res.status(422).json({ errors: errors.array() });
-    }
-
-    next();
-  },
-];
-
-/**
- * @description Validates a download request which can include an optional project name.
- */
-export const validateDownloadProject = [
-  body('fileName').isString().optional(),
+    .trim()
+    .customSanitizer((input: string) => sanitize(input))
+    .withMessage('Failed to sanitize the filename')
+    .notEmpty()
+    .withMessage('Filename was empty or contained only invalid characters')
+    .customSanitizer((input: string) => ensureJsonExtension(input)),
 
   (req: Request, res: Response, next: NextFunction) => {
     const errors = validationResult(req);

apps/server/src/api-integration/integration.controller.ts

@@ -10,6 +10,7 @@ import { eventStore } from '../stores/EventStore.js';
 import * as assert from '../utils/assert.js';
 import { isEmptyObject } from '../utils/parserUtils.js';
 import { parseProperty, updateEvent } from './integration.utils.js';
+import { socket } from '../adapters/WebsocketAdapter.js';
 import { throttle } from '../utils/throttle.js';
 import { willCauseRegeneration } from '../services/rundown-service/rundownCacheUtils.js';
 
@@ -240,6 +241,33 @@ const actionHandlers: Record<string, ActionHandler> = {
     }
     throw new Error('No matching method provided');
   },
+  /* Client */
+  client: (payload) => {
+    assert.isObject(payload);
+    if (!('target' in payload) || typeof payload.target != 'string') {
+      throw new Error('No or invalid client target');
+    }
+
+    if ('rename' in payload && typeof payload.rename == 'string') {
+      const { target, rename } = payload;
+      socket.renameClient(target, rename);
+      return { payload: 'success' };
+    }
+
+    if ('redirect' in payload && typeof payload.redirect == 'string') {
+      const { target, redirect } = payload;
+      socket.redirectClient(target, redirect);
+      return { payload: 'success' };
+    }
+
+    if ('identify' in payload && typeof payload.identify == 'boolean') {
+      const { target, identify } = payload;
+      socket.identifyClient(target, identify);
+      return { payload: 'success' };
+    }
+
+    throw new Error('No matching method provided');
+  },
 };
 
 /**

apps/server/src/app.ts

@@ -20,6 +20,7 @@ import {
   clearUploadfolder,
 } from './setup/index.js';
 import { ONTIME_VERSION } from './ONTIME_VERSION.js';
+import { consoleSuccess, consoleHighlight } from './utils/console.js';
 
 // Import Routers
 import { appRouter } from './api-data/index.js';
@@ -44,10 +45,13 @@ import { populateDemo } from './setup/loadDemo.js';
 import { getState } from './stores/runtimeState.js';
 import { initRundown } from './services/rundown-service/RundownService.js';
 import { generateCrashReport } from './utils/generateCrashReport.js';
+import { getNetworkInterfaces } from './utils/networkInterfaces.js';
 
-console.log(`Starting Ontime version ${ONTIME_VERSION}`);
+console.log('\n');
+consoleHighlight(`Starting Ontime version ${ONTIME_VERSION}`);
 
-if (!isProduction) {
+const canLog = isProduction;
+if (!canLog) {
   console.log(`Ontime running in ${environment} environment`);
   console.log(`Ontime directory at ${srcDirectory} `);
   console.log(`Ontime database at ${resolveDbPath}`);
@@ -56,7 +60,7 @@ if (!isProduction) {
 // Create express APP
 const app = express();
 if (process.env.NODE_ENV === 'development') {
-  // log more serever timings
+  // log server timings to requests
   app.use(serverTiming());
 }
 app.disable('x-powered-by');
@@ -151,18 +155,16 @@ export const initAssets = async () => {
 
 /**
  * Starts servers
- * @return {Promise<string>}
  */
-export const startServer = async () => {
+export const startServer = async (
+  escalateErrorFn?: (error: string) => void,
+): Promise<{ message: string; serverPort: number }> => {
   checkStart(OntimeStartOrder.InitServer);
 
   const { serverPort } = DataProvider.getSettings();
 
-  const returnMessage = `Ontime is listening on port ${serverPort}`;
-
   expressServer = http.createServer(app);
   socket.init(expressServer);
-  logger.info(LogOrigin.Server, returnMessage);
 
   /**
    * Module initialises the services and provides initial payload for the store
@@ -186,6 +188,9 @@ export const startServer = async () => {
     },
   });
 
+  // initialise logging service, escalateErrorFn is only exists in electron
+  logger.init(escalateErrorFn);
+
   // initialise rundown service
   const persistedRundown = DataProvider.getRundown();
   const persistedCustomFields = DataProvider.getCustomFields();
@@ -200,7 +205,17 @@ export const startServer = async () => {
   // eventStore set is a dependency of the services that publish to it
   messageService.init(eventStore.set.bind(eventStore));
 
-  expressServer.listen(serverPort, '0.0.0.0');
+  expressServer.listen(serverPort, '0.0.0.0', () => {
+    const nif = getNetworkInterfaces();
+    consoleSuccess(`Local: http://localhost:${serverPort}/editor`);
+    for (const key in nif) {
+      const address = nif[key].address;
+      consoleSuccess(`Network: http://${address}:${serverPort}/editor`);
+    }
+  });
+
+  const returnMessage = `Ontime is listening on port ${serverPort}`;
+  logger.info(LogOrigin.Server, returnMessage);
 
   return { message: returnMessage, serverPort };
 };
@@ -241,7 +256,7 @@ export const startIntegrations = async (config?: { osc: OSCSettings; http: HttpS
  * @return {Promise<void>}
  */
 export const shutdown = async (exitCode = 0) => {
-  console.log(`Ontime shutting down with code ${exitCode}`);
+  consoleHighlight(`Ontime shutting down with code ${exitCode}`);
 
   // clear the restore file if it was a normal exit
   // 0 means it was a SIGNAL
@@ -251,7 +266,6 @@ export const shutdown = async (exitCode = 0) => {
     await restoreService.clear();
   }
 
-  // TODO: Clear token
   expressServer?.close();
   runtimeService.shutdown();
   integrationService.shutdown();
@@ -260,19 +274,17 @@ export const shutdown = async (exitCode = 0) => {
   process.exit(exitCode);
 };
 
-process.on('exit', (code) => console.log(`Ontime shutdown with code: ${code}`));
+process.on('exit', (code) => consoleHighlight(`Ontime shutdown with code: ${code}`));
 
 process.on('unhandledRejection', async (error) => {
-  console.error('Error: unhandled rejection', error);
   generateCrashReport(error);
-  logger.error(LogOrigin.Server, `Error: unhandled rejection ${error}`);
+  logger.crash(LogOrigin.Server, `Uncaught exception | ${error}`);
   await shutdown(1);
 });
 
 process.on('uncaughtException', async (error) => {
-  console.error('Error: uncaught exception', error);
   generateCrashReport(error);
-  logger.error(LogOrigin.Server, `Error: uncaught exception ${error}`);
+  logger.crash(LogOrigin.Server, `Uncaught exception | ${error}`);
   await shutdown(1);
 });
 

apps/server/src/classes/Logger.ts

@@ -4,22 +4,33 @@ import { generateId, millisToString } from 'ontime-utils';
 import { clock } from '../services/Clock.js';
 import { isProduction } from '../setup/index.js';
 import { socket } from '../adapters/WebsocketAdapter.js';
+import { consoleSubdued, consoleRed } from '../utils/console.js';
 
 class Logger {
   private queue: Log[];
+  private escalateErrorFn: ((error: string) => void) | null;
+  private canLog = false;
 
   constructor() {
     this.queue = [];
+    this.escalateErrorFn = null;
+    this.canLog = !isProduction;
   }
 
   /**
    * Enabling setup logger after init
    */
-  init() {
+  init(escalateErrorFn?: (error: string) => void) {
+    // flush logs from queue
     this.queue.forEach((log) => {
       this._push(log);
     });
     this.queue = [];
+
+    // we only get this when running in electron
+    if (escalateErrorFn) {
+      this.escalateErrorFn = escalateErrorFn;
+    }
   }
 
   private addToQueue(log: Log) {
@@ -34,8 +45,12 @@ class Logger {
    * @param log
    */
   private _push(log: Log) {
-    if (!isProduction) {
-      console.log(`[${log.level}] \t ${log.origin} \t ${log.text}`);
+    if (this.canLog || log.level === LogLevel.Severe) {
+      if (log.level === LogLevel.Severe) {
+        consoleRed(`[${log.level}] \t ${log.origin} \t ${log.text}`);
+      } else {
+        consoleSubdued(`[${log.level}] \t ${log.origin} \t ${log.text}`);
+      }
     }
 
     try {
@@ -92,11 +107,20 @@ class Logger {
     this.emit(LogLevel.Error, origin, text);
   }
 
+  /**
+   * Utility to emit logging message of type SEVERE
+   * @param origin
+   * @param text
+   */
+  crash(origin: string, text: string) {
+    this.emit(LogLevel.Severe, origin, text);
+    this.escalateErrorFn?.(text);
+  }
+
   /**
    * Shutdown logger
    */
   shutdown() {
-    console.log('Shutting down logger');
     this.queue = [];
   }
 }

apps/server/src/classes/data-provider/__tests__/DataProvider.test.ts

@@ -1,4 +1,4 @@
-import { DatabaseModel, OntimeRundown, Settings, URLPreset } from 'ontime-types';
+import { DatabaseModel, OntimeRundown, Settings, URLPreset, ViewSettings } from 'ontime-types';
 import { safeMerge } from '../DataProvider.utils.js';
 
 describe('safeMerge', () => {
@@ -49,7 +49,7 @@ describe('safeMerge', () => {
   } as DatabaseModel;
 
   it('returns existing data if new data is not provided', () => {
-    const mergedData = safeMerge(existing, undefined);
+    const mergedData = safeMerge(existing, {});
     expect(mergedData).toEqual(existing);
   });
 
@@ -136,6 +136,7 @@ describe('safeMerge', () => {
       rundown: [],
       project: {
         title: '',
+        description: '',
         publicUrl: '',
         publicInfo: '',
         backstageUrl: '',
@@ -153,8 +154,9 @@ describe('safeMerge', () => {
       viewSettings: {
         overrideStyles: false,
         endMessage: '',
-      },
+      } as ViewSettings,
       urlPresets: [],
+      customFields: {},
       osc: {
         portIn: 8888,
         portOut: 9999,
@@ -163,6 +165,10 @@ describe('safeMerge', () => {
         enabledOut: false,
         subscriptions: [],
       },
+      http: {
+        enabledOut: false,
+        subscriptions: [],
+      },
     } as DatabaseModel;
 
     const newData = {

apps/server/src/index.ts

@@ -1,16 +1,22 @@
 /* eslint-disable no-console */
+import { consoleHighlight, consoleRed } from './utils/console.js';
 import { initAssets, startIntegrations, startServer } from './app.js';
 
 async function startOntime() {
   try {
-    console.log('Request: Initialise assets...');
+    console.log('\n');
+    consoleHighlight('Request: Initialise assets...');
     await initAssets();
-    console.log('Request: Start server...');
+
+    console.log('\n');
+    consoleHighlight('Request: Start server...');
     await startServer();
-    console.log('Request: Start integrations...');
+
+    console.log('\n');
+    consoleHighlight('Request: Start integrations...');
     await startIntegrations();
   } catch (error) {
-    console.log(`Request failed: ${error}`);
+    consoleRed(`Request failed: ${error}`);
   }
 }
 

apps/server/src/services/__tests__/timerUtils.test.ts

@@ -978,6 +978,32 @@ describe('getRollTimers()', () => {
     expect(state).toStrictEqual(expected);
   });
 
+  it('loads upcoming event while waiting to roll', () => {
+    const singleEventList: Partial<OntimeEvent>[] = [
+      {
+        id: '1',
+        timeStart: 72000000, // 20:00
+        timeEnd: 72010000, // 20:10
+        isPublic: true,
+      },
+    ];
+    const now = 6000; // 00:01
+    const expected = {
+      nowIndex: null,
+      nowId: null,
+      publicIndex: null,
+      nextIndex: 0,
+      publicNextIndex: 0,
+      timeToNext: 72000000 - now,
+      nextEvent: singleEventList[0],
+      nextPublicEvent: singleEventList[0],
+      currentEvent: null,
+      currentPublicEvent: null,
+    };
+    const state = getRollTimers(singleEventList as OntimeEvent[], now);
+    expect(state).toStrictEqual(expected);
+  });
+
   it('handles roll that goes over midnight', () => {
     const singleEventList: Partial<OntimeEvent>[] = [
       {
@@ -1890,4 +1916,44 @@ describe('getTimerPhase()', () => {
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Pending);
   });
+
+  it('#1042 identifies waiting to roll', () => {
+    const state = {
+      clock: 55691050,
+      eventNow: null,
+      publicEventNow: null,
+      eventNext: null,
+      publicEventNext: null,
+      runtime: {
+        selectedEventIndex: null,
+        numEvents: 1,
+        offset: null,
+        plannedStart: 55860000,
+        plannedEnd: 55880000,
+        actualStart: null,
+        expectedEnd: null,
+      },
+      timer: {
+        addedTime: 0,
+        current: null,
+        duration: null,
+        elapsed: 0,
+        expectedFinish: null,
+        finishedAt: null,
+        phase: 'none',
+        playback: 'roll',
+        secondaryTimer: 168950,
+        startedAt: null,
+      },
+      _timer: {
+        forceFinish: null,
+        totalDelay: 0,
+        pausedAt: null,
+        secondaryTarget: 55860000,
+      },
+    } as RuntimeState;
+
+    const phase = getTimerPhase(state);
+    expect(phase).toBe(TimerPhase.Pending);
+  });
 });

apps/server/src/services/integration-service/integrationUtils.test.ts

@@ -116,6 +116,18 @@ describe('parseNestedTemplate() -> stringToOSCArgs()', () => {
         test: '"string with space and {{not.so.easy}}"',
         expect: [{ type: 'string', value: 'string with space and data with space' }],
       },
+      {
+        test: '',
+        expect: [],
+      },
+      {
+        test: ' ',
+        expect: [],
+      },
+      {
+        test: '""',
+        expect: [{ type: 'string', value: '' }],
+      },
       {
         test: '"string with space and {{not.so.empty}}"',
         expect: [{ type: 'string', value: 'string with space and ' }],

apps/server/src/services/rundown-service/__tests__/rundownCache.test.ts

@@ -361,7 +361,7 @@ describe('remove() mutation', () => {
     ];
     const { newRundown } = remove({ eventIds: ['1', '2', '3'], persistedRundown: testRundown });
     expect(newRundown.length).toBe(3);
-    expect(newRundown.at(0).id).toBe('4');
+    expect(newRundown.at(0)?.id).toBe('4');
   });
 });
 
@@ -885,7 +885,7 @@ describe('custom fields', () => {
       };
 
       const customField = await editCustomField('sound', { label: 'Sound', type: 'string', colour: 'green' });
-      expect(customFieldChangelog).toStrictEqual({});
+      expect(customFieldChangelog).toStrictEqual(new Map());
 
       expect(customField).toStrictEqual(expected);
     });
@@ -931,9 +931,15 @@ describe('custom fields', () => {
         },
       };
 
+      // We need to flush all scheduled tasks for the generate function to settle
+      vi.useFakeTimers();
       const customField = await editCustomField('video', { label: 'AV', type: 'string', colour: 'red' });
       expect(customField).toStrictEqual(expectedAfter);
-      expect(customFieldChangelog).toStrictEqual({ video: 'av' });
+      expect(customFieldChangelog).toStrictEqual(new Map([['video', 'av']]));
+      await editCustomField('av', { label: 'video' });
+      vi.runAllTimers();
+      expect(customFieldChangelog).toStrictEqual(new Map());
+      vi.useRealTimers();
     });
   });
 
@@ -945,8 +951,8 @@ describe('custom fields', () => {
           type: 'string',
           colour: 'blue',
         },
-        av: {
-          label: 'AV',
+        video: {
+          label: 'video',
           type: 'string',
           colour: 'red',
         },

apps/server/src/services/rundown-service/__tests__/rundownCacheUtils.test.ts

@@ -96,7 +96,7 @@ describe('handleCustomField()', () => {
         label: 'sound',
       },
     } as CustomFields;
-    const customFieldChangelog = {};
+    const customFieldChangelog = new Map<string, string>();
 
     // @ts-expect-error -- partial event for testing
     const event: OntimeEvent = {
@@ -132,9 +132,7 @@ describe('handleCustomField()', () => {
       },
     } as CustomFields;
 
-    const customFieldChangelog = {
-      sound: 'video',
-    };
+    const customFieldChangelog = new Map([['sound', 'video']]);
 
     // @ts-expect-error -- partial event for testing
     const event: OntimeEvent = {
@@ -170,9 +168,7 @@ describe('handleCustomField()', () => {
       },
     } as CustomFields;
 
-    const customFieldChangelog = {
-      field1: 'newField1',
-    };
+    const customFieldChangelog = new Map([['field1', 'newField1']]);
 
     // @ts-expect-error -- partial event for testing
     const mutableEvent: OntimeEvent = {

apps/server/src/services/rundown-service/rundownCache.ts

@@ -47,7 +47,7 @@ let links: Record<EventID, EventID> = {};
  *  lighting: lx
  * }
  */
-export const customFieldChangelog = {};
+export const customFieldChangelog = new Map<string, string>();
 
 /**
  * Keep track of which custom fields are used.
@@ -141,6 +141,7 @@ export function generate(
   }
 
   isStale = false;
+  customFieldChangelog.clear();
   totalDelay = accumulatedDelay;
   if (lastEnd !== null && firstStart !== null) {
     totalDuration = getTotalDuration(firstStart, lastEnd, daySpan);
@@ -411,6 +412,7 @@ function invalidateIfUsed(label: CustomFieldLabel) {
   // schedule a non priority cache update
   setImmediate(() => {
     generate();
+    DataProvider.setRundown(persistedRundown);
   });
 }
 
@@ -459,7 +461,7 @@ export const editCustomField = async (key: string, newField: Partial<CustomField
   }
 
   const existingField = persistedCustomFields[key];
-  if (existingField.type !== newField.type) {
+  if (newField.type !== undefined && existingField.type !== newField.type) {
     throw new Error('Change of field type is not allowed');
   }
 
@@ -468,7 +470,7 @@ export const editCustomField = async (key: string, newField: Partial<CustomField
 
   if (key !== newKey) {
     delete persistedCustomFields[key];
-    customFieldChangelog[key] = newKey;
+    customFieldChangelog.set(key, newKey);
   }
 
   scheduleCustomFieldPersist(persistedCustomFields);

apps/server/src/services/rundown-service/rundownCacheUtils.ts

@@ -73,15 +73,15 @@ export function addToCustomAssignment(
  */
 export function handleCustomField(
   customFields: CustomFields,
-  customFieldChangelog: Record<string, string>,
+  customFieldChangelog: Map<string, string>,
   mutableEvent: OntimeEvent,
   assignedCustomFields: Record<string, string[]>,
 ) {
   for (const field in mutableEvent.custom) {
     // rename the property if it is in the changelog
-    if (field in customFieldChangelog) {
+    if (customFieldChangelog.has(field)) {
       const oldData = mutableEvent.custom[field];
-      const newLabel = customFieldChangelog[field];
+      const newLabel = customFieldChangelog.get(field);
 
       mutableEvent.custom[newLabel] = oldData;
       delete mutableEvent.custom[field];

apps/server/src/services/runtime-service/RuntimeService.ts

@@ -1,4 +1,13 @@
-import { EndAction, LogOrigin, MaybeNumber, OntimeEvent, Playback, RuntimeStore, TimerLifeCycle } from 'ontime-types';
+import {
+  EndAction,
+  LogOrigin,
+  MaybeNumber,
+  OntimeEvent,
+  Playback,
+  RuntimeStore,
+  TimerLifeCycle,
+  TimerPhase,
+} from 'ontime-types';
 import { millisToString, validatePlayback } from 'ontime-utils';
 
 import { deepEqual } from 'fast-equals';
@@ -76,7 +85,7 @@ class RuntimeService {
         integrationService.dispatch(TimerLifeCycle.onUpdate);
       });
 
-      this.lastIntegrationTimerValue = newState.timer.current;
+      this.lastIntegrationTimerValue = newState.timer.current ?? -1;
     }
 
     const shouldUpdateClock = getShouldClockUpdate(this.lastIntegrationClockUpdate, newState.clock);
@@ -93,6 +102,25 @@ class RuntimeService {
       const rundown = getPlayableEvents();
       this.eventTimer.roll(rundown);
     }
+
+    const timerPhaseChanged = RuntimeService.previousState.timer?.phase !== newState.timer.phase;
+
+    if (timerPhaseChanged) {
+      switch (newState.timer.phase) {
+        case TimerPhase.Warning:
+          process.nextTick(() => {
+            integrationService.dispatch(TimerLifeCycle.onWarning);
+          });
+          break;
+        case TimerPhase.Danger:
+          process.nextTick(() => {
+            integrationService.dispatch(TimerLifeCycle.onDanger);
+          });
+          break;
+        default:
+          break;
+      }
+    }
   }
 
   /** delay initialisation until we have a restore point */