@7365admin1/layer-common 4.97.1-staging.573 → 4.97.1-staging.574

package/components/Robot/Setup.vue

@@ -56,6 +56,7 @@
   </div>
   <RobotSiteFleetCore :site="site" />
   <RobotSiteSharedSpace :site="site" editable />
+  <RobotSiteOps :site="site" />
 </template>
 
 <script setup lang="ts">
@@ -64,6 +65,7 @@ import RobotFleetCoreButton from "./FleetCoreButton.vue";
 import RobotSiteFloors from "./SiteFloors.vue";
 import RobotSiteFleetCore from "./SiteFleetCore.vue";
 import RobotSiteSharedSpace from "./SiteSharedSpace.vue";
+import RobotSiteOps from "./SiteOps.vue";
 import useRobotBuilding from "../../composables/useRobotBuilding";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import { robotSetupSteps, setupProgress, STATUS_TEXT, type TSetupStatus, type TSetupTarget } from "../../utils/robot-setup";

package/components/Robot/SiteAlerts.vue

@@ -15,6 +15,11 @@
     <span class="hero-head__spacer" />
     <span class="hero-note">Each occurrence notified once</span>
   </div>
+  <!-- A security robot's alarm: the site's cameras next to the robot's own live view (open the robot). -->
+  <div v-if="camerasPath && hasAlarm" class="hero-notice hero-notice--panel" role="status">
+    A robot raised an alarm. Open the robot for its photo and live view, and
+    <NuxtLink :to="camerasPath">the site's camera wall</NuxtLink> for the cameras nearby.
+  </div>
 
   <div v-if="error && !items.length" class="hero-notice" role="alert">{{ error }}</div>
   <div v-else-if="error" class="hero-notice" role="status">Reconnecting… the alerts show their last reading.</div>
@@ -46,8 +51,10 @@ const props = withDefaults(
     backToNetwork?: boolean;
     limit?: number;
     pollMs?: number;
+    /** The host app's camera wall for this site (empty = no link). */
+    camerasPath?: string;
   }>(),
-  { siteName: "", clientName: "", backToNetwork: false, limit: 25, pollMs: 10000 },
+  { siteName: "", clientName: "", backToNetwork: false, limit: 25, pollMs: 10000, camerasPath: "" },
 );
 const emit = defineEmits<{
   open: [robotId: string];
@@ -57,6 +64,7 @@ const emit = defineEmits<{
 
 const { getSiteFaults } = useRobots();
 const items = ref<any[]>([]);
+const hasAlarm = computed(() => items.value.some((f) => String(f?.code ?? "").startsWith("ALARM-")));
 const total = ref(0);
 const faults = ref(0);
 const page = ref(1);

package/components/Robot/SiteDispatch.vue

@@ -0,0 +1,83 @@
+<template>
+  <!--
+    "SEND THE BEST ROBOT" (fleet operations 2.2): for people who may command robots at the site. A patrol or a clean
+    -> the server picks the right kind of robot that is online, free, fault-free and charged (the most charged wins)
+    and says why every other robot was not chosen. Sending needs the site's Dispatch switch (Seven365); without it the
+    choice is shown and nothing starts. Server: POST /api/robots/sites/:site/dispatch.
+  -->
+  <div v-if="canCommand" class="sdp">
+    <v-btn v-for="j in jobs" :key="j" size="small" variant="outlined" @click="ask(j)">Best robot for a {{ j }}</v-btn>
+    <v-dialog v-model="open" width="520">
+      <v-card>
+        <v-card-title class="hero-title">Best robot for a {{ job }}</v-card-title>
+        <v-card-text class="sdp__body">
+          <div v-if="busy === 'ask'" class="hero-muted">Checking the robots…</div>
+          <div v-else-if="answer" role="status" data-test="dispatch-line">{{ dispatchLine(answer, job) }}</div>
+          <ul v-if="answer?.reasons?.length" class="sdp__list">
+            <li v-for="r in answer.reasons" :key="r.id" class="hero-muted">{{ r.name }} {{ r.reason }}</li>
+          </ul>
+          <div v-if="error" class="hero-notice hero-notice--error" role="alert">{{ error }}</div>
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer />
+          <v-btn variant="text" @click="open = false">Close</v-btn>
+          <v-btn v-if="answer?.chosen && !answer?.sent" color="primary" variant="flat" :loading="busy === 'send'" :disabled="!!busy" @click="send">
+            Send {{ answer.chosen.name }}
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { robotErrorMessage } from "../../utils/robot-display";
+import { dispatchLine } from "../../utils/robot-fleet-ops";
+
+const props = withDefaults(defineProps<{ site: string; type?: string; canCommand?: boolean }>(), { type: "", canCommand: false });
+const emit = defineEmits<{ sent: [] }>();
+const { dispatchSiteRobot } = useRobots();
+
+// The page shows one robot type at a time: offer that type's job (both when the page does not say).
+const jobs = computed<Array<"patrol" | "clean">>(() => (props.type === "security" ? ["patrol"] : props.type === "cleaning" ? ["clean"] : ["patrol", "clean"]));
+const open = ref(false);
+const job = ref<"patrol" | "clean">("patrol");
+const answer = ref<any>(null);
+const busy = ref<"" | "ask" | "send">("");
+const error = ref("");
+
+async function ask(j: "patrol" | "clean") {
+  job.value = j;
+  answer.value = null;
+  error.value = "";
+  open.value = true;
+  busy.value = "ask";
+  try {
+    answer.value = await dispatchSiteRobot(props.site, { job: j, dryRun: true });
+  } catch (e) {
+    error.value = robotErrorMessage(e, "Could not check the robots.");
+  } finally {
+    busy.value = "";
+  }
+}
+
+async function send() {
+  error.value = "";
+  busy.value = "send";
+  try {
+    answer.value = await dispatchSiteRobot(props.site, { job: job.value, dryRun: false });
+    emit("sent");
+  } catch (e) {
+    error.value = robotErrorMessage(e, "The robot was not sent.");
+  } finally {
+    busy.value = "";
+  }
+}
+</script>
+
+<style scoped>
+.sdp { display: flex; flex-wrap: wrap; gap: 6px; }
+.sdp__body { display: grid; gap: 8px; }
+.sdp__list { margin: 0; padding-left: 18px; font-size: 13px; }
+</style>

package/components/Robot/SiteEmergency.vue

@@ -0,0 +1,164 @@
+<template>
+  <!--
+    ROBOT EMERGENCY for one site (fleet operations 1.5, 2026-10-19). Everyone at the site sees the red line while
+    it is on. People who may command robots here get the Emergency button: a preview of what each robot will do,
+    then Start; and End. Stop needs no switch; "send every robot to its charger" only when Seven365 switched it on.
+    Server: GET/POST/DELETE /api/robots/sites/:site/emergency (starts audited; refused starts while on).
+  -->
+  <section class="sem" aria-label="Robot emergency">
+    <div v-if="banner" class="sem__banner" role="alert" data-test="emergency-banner">
+      <span>{{ banner }}</span>
+      <v-btn v-if="canCommand" size="small" variant="flat" color="white" :loading="busy === 'end'" :disabled="!!busy" @click="end">End emergency</v-btn>
+    </div>
+    <v-btn v-else-if="canCommand" size="small" color="error" variant="flat" prepend-icon="mdi-alert-octagon" data-test="emergency-open" @click="openDialog">
+      Emergency
+    </v-btn>
+    <div v-if="message" class="hero-muted" role="status">{{ message }}</div>
+
+    <v-dialog v-model="open" width="560">
+      <v-card>
+        <v-card-title class="hero-title">Robot emergency - this site</v-card-title>
+        <v-card-text class="sem__body">
+          <v-radio-group v-model="mode" hide-details density="compact" @update:model-value="preview">
+            <v-radio value="stop" label="Stop every robot where it is" />
+            <v-radio value="return" :disabled="!canReturn" :label="canReturn ? 'Send every robot to its charger' : 'Send every robot to its charger (switched off for this site)'" />
+          </v-radio-group>
+          <v-text-field v-model="reason" density="compact" variant="outlined" label="Reason (optional)" maxlength="200" hide-details />
+          <div class="hero-kicker">{{ result ? "What happened" : "What will happen" }}</div>
+          <div v-if="busy === 'preview'" class="hero-muted">Checking the robots…</div>
+          <ul class="sem__list">
+            <li v-for="(l, i) in lines" :key="i" :class="`hero-tone--${TONE[l.tone]}`">{{ l.text }}</li>
+          </ul>
+          <p class="hero-muted sem__note">
+            While emergency mode is on no robot at this site may start - from iService365, HERO Fleet Core or a schedule
+            (a robot that starts by itself is stopped again). Stop, return and the robot's own emergency stop always work.
+            A robot iService365 cannot stop must be stopped by hand.
+          </p>
+          <div v-if="error" class="hero-notice hero-notice--error" role="alert">{{ error }}</div>
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer />
+          <v-btn variant="text" @click="open = false">{{ result ? "Close" : "Cancel" }}</v-btn>
+          <v-btn v-if="!result" color="error" variant="flat" :loading="busy === 'start'" :disabled="!!busy" data-test="emergency-start" @click="start">
+            Start emergency
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
+import { robotErrorMessage } from "../../utils/robot-display";
+import { emergencyBanner, emergencyStepLine, type TSiteEmergency } from "../../utils/robot-fleet-ops";
+
+const props = withDefaults(defineProps<{ site: string; canCommand?: boolean }>(), { canCommand: false });
+const { getSiteEmergency, startSiteEmergency, endSiteEmergency } = useRobots();
+const TONE = { ok: "success", warn: "warning", neutral: "neutral" } as const;
+
+const emergency = ref<TSiteEmergency>(null);
+const canReturn = ref(false);
+const open = ref(false);
+const mode = ref<"stop" | "return">("stop");
+const reason = ref("");
+const steps = ref<any[]>([]);
+const result = ref(false);
+const busy = ref<"" | "preview" | "start" | "end">("");
+const error = ref("");
+const message = ref("");
+const now = ref(Date.now());
+
+const banner = computed(() => emergencyBanner(emergency.value, now.value));
+const lines = computed(() => steps.value.map((s) => emergencyStepLine(s, result.value)));
+
+async function load() {
+  now.value = Date.now();
+  try {
+    const res = await getSiteEmergency(props.site);
+    emergency.value = res.emergency;
+    canReturn.value = res.canReturn === true;
+  } catch {
+    // An older server has no emergency route: show nothing rather than a wrong state.
+  }
+}
+
+async function preview() {
+  error.value = "";
+  result.value = false;
+  busy.value = "preview";
+  try {
+    steps.value = (await startSiteEmergency(props.site, { mode: mode.value, dryRun: true })).robots ?? [];
+  } catch (e) {
+    steps.value = [];
+    error.value = robotErrorMessage(e, "Could not check the robots.");
+  } finally {
+    busy.value = "";
+  }
+}
+
+function openDialog() {
+  mode.value = "stop";
+  reason.value = message.value = "";
+  open.value = true;
+  preview();
+}
+
+async function start() {
+  error.value = "";
+  busy.value = "start";
+  try {
+    const res = await startSiteEmergency(props.site, { mode: mode.value, reason: reason.value.trim() });
+    steps.value = res.robots ?? [];
+    result.value = true;
+    await load();
+  } catch (e) {
+    error.value = robotErrorMessage(e, "Could not start emergency mode.");
+  } finally {
+    busy.value = "";
+  }
+}
+
+async function end() {
+  busy.value = "end";
+  message.value = "";
+  try {
+    await endSiteEmergency(props.site);
+    message.value = "Emergency mode ended - robots may be started again.";
+    await load();
+  } catch (e) {
+    message.value = robotErrorMessage(e, "Could not end emergency mode.");
+  } finally {
+    busy.value = "";
+  }
+}
+
+let timer: ReturnType<typeof setInterval> | undefined;
+onMounted(() => {
+  timer = setInterval(load, 10_000);
+  load();
+});
+onBeforeUnmount(() => clearInterval(timer));
+watch(() => props.site, load);
+</script>
+
+<style scoped>
+.sem { margin: 8px 0; display: grid; gap: 6px; justify-items: start; }
+.sem__banner {
+  width: 100%;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  justify-content: space-between;
+  padding: 8px 12px;
+  border-radius: 6px;
+  background: rgb(var(--v-theme-error));
+  color: rgb(var(--v-theme-on-error));
+  font-weight: 600;
+  overflow-wrap: anywhere;
+}
+.sem__body { display: grid; gap: 10px; }
+.sem__list { margin: 0; padding-left: 18px; font-size: 13px; }
+.sem__note { font-size: 12px; margin: 0; }
+</style>

package/components/Robot/SiteFleet.vue

@@ -16,6 +16,10 @@
 
   <RobotSummaryStrip :key="`${site}:${type}`" class="hero-summary--six" :cells="cells" label="Site summary" />
   <RobotSiteSharedSpace :key="`ss:${site}`" :site="site" />
+  <div class="hero-fleetops">
+    <RobotSiteEmergency :key="`sos:${site}`" :site="site" :can-command="canCommand" />
+    <RobotSiteDispatch :site="site" :type="type" :can-command="canCommand" />
+  </div>
 
   <div class="hero-split">
     <div class="hero-split__main hero-split__main--fleet">
@@ -81,12 +85,16 @@
       />
     </aside>
   </div>
+  <RobotSiteKpis :key="`kpi:${site}`" :site="site" />
 </template>
 
 <script setup lang="ts">
 import { computed, onBeforeUnmount, ref, watch } from "vue";
 import RobotSummaryStrip from "./SummaryStrip.vue";
 import RobotSiteSharedSpace from "./SiteSharedSpace.vue";
+import RobotSiteEmergency from "./SiteEmergency.vue";
+import RobotSiteDispatch from "./SiteDispatch.vue";
+import RobotSiteKpis from "./SiteKpis.vue";
 import RobotTable from "./Table.vue";
 import RobotStatusChip from "./StatusChip.vue";
 import RobotBattery from "./Battery.vue";
@@ -120,11 +128,13 @@ const props = withDefaults(
     canSetup?: boolean;
     /** Show "‹ Network" (Super Admin drilled in). */
     backToNetwork?: boolean;
+    /** May command robots here: the Emergency and "Best robot" buttons (the server judges again at the site). */
+    canCommand?: boolean;
     /** Bumped by the parent to reload (after add / edit / remove). */
     reloadKey?: number;
     limit?: number;
   }>(),
-  { siteName: "", clientName: "", type: "cleaning", canSetup: false, backToNetwork: false, reloadKey: 0, limit: 25 },
+  { siteName: "", clientName: "", type: "cleaning", canSetup: false, backToNetwork: false, canCommand: false, reloadKey: 0, limit: 25 },
 );
 const emit = defineEmits<{
   open: [robot: any];
@@ -309,3 +319,7 @@ watch(
   { immediate: true },
 );
 </script>
+
+<style scoped>
+.hero-fleetops { display: flex; flex-wrap: wrap; gap: 8px; align-items: flex-start; }
+</style>

package/components/Robot/SiteKpis.vue

@@ -0,0 +1,117 @@
+<template>
+  <!--
+    SITE ROBOT PERFORMANCE (fleet operations 3.1 / 3.3): availability, faults, work hours and utilisation, m² cleaned,
+    patrol rounds - per robot and for the site - from the robots' own records, plus a CSV report for the client.
+    A dash = no record (never shown as 0). Server: GET /api/robots/sites/:site/kpis?days=&format=csv.
+  -->
+  <details class="skp" @toggle="onToggle">
+    <summary class="hero-kicker skp__sum">Performance &amp; report</summary>
+    <div class="skp__bar">
+      <v-btn-toggle v-model="days" density="compact" mandatory variant="outlined" @update:model-value="load">
+        <v-btn :value="1" size="small">1 day</v-btn>
+        <v-btn :value="7" size="small">7 days</v-btn>
+        <v-btn :value="30" size="small">30 days</v-btn>
+      </v-btn-toggle>
+      <v-btn size="small" variant="outlined" prepend-icon="mdi-download" :loading="downloading" @click="download">CSV report</v-btn>
+    </div>
+    <div v-if="loading" class="hero-muted">Reading the robots' records…</div>
+    <div v-else-if="error" class="hero-notice hero-notice--error" role="alert">{{ error }}</div>
+    <template v-else-if="data">
+      <div class="skp__cells">
+        <div><b>{{ kpi(data.site.availabilityPct, "%") }}</b><span>Availability</span></div>
+        <div><b>{{ kpi(data.site.utilisationPct, "%") }}</b><span>Utilisation</span></div>
+        <div><b>{{ kpi(data.site.faults) }}</b><span>Machine faults</span></div>
+        <div><b>{{ kpi(data.site.alarms) }}</b><span>Alarms</span></div>
+        <div><b>{{ kpi(data.site.m2Cleaned, " m²") }}</b><span>Cleaned</span></div>
+        <div><b>{{ kpi(data.site.patrolRounds) }}</b><span>Patrol rounds</span></div>
+      </div>
+      <div class="skp__scroll">
+        <table class="skp__table">
+          <thead>
+            <tr><th>Robot</th><th>Availability</th><th>Faults / 100 h</th><th>Work h</th><th>Utilisation</th><th>m² · jobs</th><th>Patrols done</th></tr>
+          </thead>
+          <tbody>
+            <tr v-for="r in data.robots" :key="r.id">
+              <td>{{ r.name }}</td>
+              <td>{{ kpi(r.availabilityPct, "%") }}</td>
+              <td>{{ kpi(r.faultsPer100h) }}</td>
+              <td>{{ kpi(r.workHours) }}</td>
+              <td>{{ kpi(r.utilisationPct, "%") }}</td>
+              <td>{{ kpi(r.m2Cleaned) }} · {{ kpi(r.jobs) }}</td>
+              <td>{{ r.patrolRounds === null ? "-" : `${r.patrolsCompleted}/${r.patrolRounds}` }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+      <p v-for="(n, i) in data.notes" :key="i" class="hero-muted skp__note">{{ n }}</p>
+    </template>
+  </details>
+</template>
+
+<script setup lang="ts">
+import { ref, watch } from "vue";
+import { robotErrorMessage } from "../../utils/robot-display";
+import { kpi } from "../../utils/robot-fleet-ops";
+
+const props = defineProps<{ site: string }>();
+const { getSiteKpis, getSiteKpisCsv } = useRobots();
+
+const days = ref(7);
+const data = ref<any>(null);
+const loading = ref(false);
+const downloading = ref(false);
+const error = ref("");
+const shown = ref(false);
+
+async function load() {
+  if (!shown.value) return;
+  loading.value = true;
+  error.value = "";
+  try {
+    data.value = await getSiteKpis(props.site, days.value);
+  } catch (e) {
+    error.value = robotErrorMessage(e, "Could not read the robots' records.");
+  } finally {
+    loading.value = false;
+  }
+}
+
+// Read only when opened: the figures come from each robot's own cloud records.
+function onToggle(e: Event) {
+  shown.value = (e.target as HTMLDetailsElement).open;
+  if (shown.value && !data.value) load();
+}
+
+async function download() {
+  downloading.value = true;
+  try {
+    const blob = await getSiteKpisCsv(props.site, days.value);
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `robot-report-${days.value}d.csv`;
+    a.click();
+    URL.revokeObjectURL(url);
+  } catch (e) {
+    error.value = robotErrorMessage(e, "Could not make the report.");
+  } finally {
+    downloading.value = false;
+  }
+}
+
+watch(() => props.site, () => { data.value = null; load(); });
+</script>
+
+<style scoped>
+.skp { margin: 12px 0; padding: 8px 12px; background: var(--hero-surface); box-shadow: var(--hero-shadow-sm); }
+.skp__sum { cursor: pointer; }
+.skp__bar { display: flex; flex-wrap: wrap; gap: 8px; margin: 8px 0; }
+.skp__cells { display: grid; grid-template-columns: repeat(auto-fit, minmax(110px, 1fr)); gap: 8px; margin-bottom: 8px; }
+.skp__cells div { display: grid; }
+.skp__cells b { font-size: 18px; }
+.skp__cells span { font-size: 12px; opacity: 0.75; }
+.skp__scroll { overflow-x: auto; }
+.skp__table { width: 100%; border-collapse: collapse; font-size: 13px; }
+.skp__table th, .skp__table td { text-align: left; padding: 4px 6px; border-bottom: 1px solid rgba(var(--v-border-color), var(--v-border-opacity)); white-space: nowrap; }
+.skp__note { font-size: 12px; margin: 4px 0 0; }
+</style>

package/components/Robot/SiteOps.vue

@@ -0,0 +1,117 @@
+<template>
+  <!--
+    FLEET OPERATIONS FOR THIS SITE (Seven365 Super Admin, Setup; market benchmark 2026-10-19). The five switches -
+    all OFF by default = today's behaviour; the ones that drive a robot say so - and the site timetable: every
+    robot's own schedule side by side, with the times two robots would move together.
+    Server: GET/PUT /api/robots/sites/:site/ops, GET /api/robots/sites/:site/timetable (audited saves).
+  -->
+  <section class="sop" aria-labelledby="sop-title">
+    <h3 id="sop-title" class="hero-title sop__title">Fleet operations</h3>
+    <div v-if="loadError" class="hero-notice hero-notice--error" role="alert">{{ loadError }}</div>
+    <template v-else-if="loaded">
+      <div v-for="s in FLEET_OPS_SWITCHES" :key="s.key" class="sop__row">
+        <v-switch v-model="ops[s.key]" color="primary" density="compact" hide-details inset :label="s.label" />
+        <p class="hero-muted sop__help">
+          <b v-if="s.moves">Drives a robot - switch on only after the on-site test.</b>
+          {{ s.help }}
+        </p>
+      </div>
+      <div class="sop__act">
+        <v-btn size="small" color="primary" variant="flat" :loading="saving" :disabled="saving || !changed" @click="save">Save</v-btn>
+      </div>
+      <div v-if="message" class="hero-muted" role="status">{{ message }}</div>
+      <div v-if="error" class="hero-notice hero-notice--error" role="alert">{{ error }}</div>
+
+      <div class="hero-kicker sop__tt">Site timetable (the robots' own schedules)</div>
+      <v-btn size="small" variant="outlined" :loading="ttBusy" @click="loadTimetable">{{ timetable ? "Read again" : "Read the schedules" }}</v-btn>
+      <template v-if="timetable">
+        <div v-for="(o, i) in timetable.overlaps" :key="`o${i}`" class="hero-notice" role="alert">{{ o.message }}</div>
+        <div v-if="!timetable.overlaps.length && timetable.slots.length" class="hero-muted">No two robots are scheduled at the same time.</div>
+        <ul class="sop__list">
+          <li v-for="(s, i) in timetable.slots" :key="i">{{ slotLine(s) }}</li>
+        </ul>
+        <div v-if="!timetable.slots.length" class="hero-muted">No schedule found (cleaning schedules in the robot's cloud, patrols run at the same time on two or more days).</div>
+        <div v-for="u in timetable.unread" :key="u.name" class="hero-muted">{{ u.name }}: could not be read ({{ u.reason }})</div>
+        <div class="hero-muted sop__help">Times in {{ timetable.timezone }}. A schedule started by the robot's own cloud is not refused by iService365 - the guard alerts (and, when switched on above, stops the security robot) if two robots move at once.</div>
+      </template>
+      <div v-if="ttError" class="hero-notice hero-notice--error" role="alert">{{ ttError }}</div>
+    </template>
+    <div v-else class="hero-muted">Checking…</div>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed, reactive, ref, watch } from "vue";
+import { robotErrorMessage } from "../../utils/robot-display";
+import { FLEET_OPS_SWITCHES, slotLine } from "../../utils/robot-fleet-ops";
+
+const props = defineProps<{ site: string }>();
+const { getSiteOps, saveSiteOps, getSiteTimetable } = useRobots();
+
+const loaded = ref(false);
+const loadError = ref("");
+const version = ref(0);
+const ops = reactive<Record<string, boolean>>({});
+const saved = ref<Record<string, boolean>>({});
+const saving = ref(false);
+const message = ref("");
+const error = ref("");
+const timetable = ref<any>(null);
+const ttBusy = ref(false);
+const ttError = ref("");
+
+const changed = computed(() => FLEET_OPS_SWITCHES.some((s) => !!ops[s.key] !== !!saved.value[s.key]));
+
+async function load() {
+  loadError.value = "";
+  try {
+    const res = await getSiteOps(props.site);
+    version.value = res.version;
+    saved.value = { ...res.ops };
+    for (const s of FLEET_OPS_SWITCHES) ops[s.key] = res.ops?.[s.key] === true;
+    loaded.value = true;
+  } catch (e) {
+    loadError.value = robotErrorMessage(e, "Could not read the fleet operations settings.");
+  }
+}
+
+async function save() {
+  error.value = message.value = "";
+  saving.value = true;
+  try {
+    const body: Record<string, boolean | number> = { version: version.value };
+    for (const s of FLEET_OPS_SWITCHES) body[s.key] = !!ops[s.key];
+    await saveSiteOps(props.site, body);
+    message.value = "Saved.";
+    await load();
+  } catch (e) {
+    error.value = robotErrorMessage(e, "Could not save.");
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function loadTimetable() {
+  ttError.value = "";
+  ttBusy.value = true;
+  try {
+    timetable.value = await getSiteTimetable(props.site);
+  } catch (e) {
+    ttError.value = robotErrorMessage(e, "Could not read the schedules.");
+  } finally {
+    ttBusy.value = false;
+  }
+}
+
+watch(() => props.site, () => { loaded.value = false; timetable.value = null; load(); }, { immediate: true });
+</script>
+
+<style scoped>
+.sop { margin-top: 16px; padding: 12px; background: var(--hero-surface); box-shadow: var(--hero-shadow-sm); display: grid; gap: 6px; }
+.sop__title { font-size: 16px; }
+.sop__row { display: grid; gap: 2px; }
+.sop__help { font-size: 12px; margin: 0 0 4px; }
+.sop__act { display: flex; gap: 6px; }
+.sop__tt { margin-top: 10px; }
+.sop__list { margin: 0; padding-left: 18px; font-size: 13px; }
+</style>

package/components/Robot/SiteScreen.vue

@@ -81,6 +81,7 @@
         v-else-if="view === 'alerts'"
         :key="`alerts:${site}`"
         :site="site"
+        :cameras-path="camerasPath"
         :site-name="siteName || names.siteName"
         :client-name="clientName || names.clientName"
         :back-to-network="backToNetwork"
@@ -105,6 +106,7 @@
         :client-name="clientName"
         :type="type"
         :can-setup="canSetup && superAdmin"
+        :can-command="canCommand"
         :back-to-network="backToNetwork"
         :reload-key="reloadKey"
         @open="(r) => emit('open', String(r._id))"
@@ -171,6 +173,8 @@ const props = withDefaults(
     superAdmin?: boolean;
     hideHeader?: boolean;
     backToNetwork?: boolean;
+    /** The host app's camera wall for this site: an alarm on the Alerts page links to it (fleet operations 2.6). */
+    camerasPath?: string;
   }>(),
   {
     siteName: "",
@@ -187,6 +191,7 @@ const props = withDefaults(
     canDelete: false,
     superAdmin: false,
     hideHeader: false,
+    camerasPath: "",
     backToNetwork: false,
   },
 );

package/composables/useRobots.ts

@@ -669,6 +669,42 @@ export default function useRobots() {
     return useNuxtApp().$api<{ key: string; keyVersion: number }>(`${sitePath(site)}/fleet-core/relay-key`, { method: "POST", query: { appSlug } });
   }
 
+  /*
+   * Fleet operations (market benchmark, 2026-10-19): the site's switches and
+   * timetable (Super Admin), its emergency (status: anyone at the site; start /
+   * end: robot command right at the site), best-robot dispatch and KPIs.
+   */
+  function getSiteOps(site: string) {
+    return useNuxtApp().$api<{ version: number; ops: Record<string, boolean>; emergency: any }>(`${sitePath(site)}/ops`, { query: { appSlug } });
+  }
+  function saveSiteOps(site: string, body: Record<string, boolean | number>) {
+    return useNuxtApp().$api<{ version: number }>(`${sitePath(site)}/ops`, { method: "PUT", query: { appSlug }, body });
+  }
+  function getSiteTimetable(site: string) {
+    return useNuxtApp().$api<Record<string, any>>(`${sitePath(site)}/timetable`, { query: { appSlug } });
+  }
+  function getSiteEmergency(site: string) {
+    return useNuxtApp().$api<{ emergency: { active: boolean; mode: string; reason: string; at: string } | null; canReturn: boolean }>(
+      `${sitePath(site)}/emergency`,
+      { query: { appSlug } },
+    );
+  }
+  function startSiteEmergency(site: string, body: { mode: "stop" | "return"; reason?: string; dryRun?: boolean }) {
+    return useNuxtApp().$api<Record<string, any>>(`${sitePath(site)}/emergency`, { method: "POST", query: { appSlug }, body });
+  }
+  function endSiteEmergency(site: string) {
+    return useNuxtApp().$api<Record<string, any>>(`${sitePath(site)}/emergency`, { method: "DELETE", query: { appSlug } });
+  }
+  function dispatchSiteRobot(site: string, body: { job: "patrol" | "clean"; dryRun: boolean }) {
+    return useNuxtApp().$api<Record<string, any>>(`${sitePath(site)}/dispatch`, { method: "POST", query: { appSlug }, body });
+  }
+  function getSiteKpis(site: string, days: number) {
+    return useNuxtApp().$api<Record<string, any>>(`${sitePath(site)}/kpis`, { query: { appSlug, days } });
+  }
+  function getSiteKpisCsv(site: string, days: number) {
+    return useNuxtApp().$api<Blob>(`${sitePath(site)}/kpis`, { query: { appSlug, days, format: "csv" }, responseType: "blob" } as any);
+  }
+
   return {
     getSiteFloors,
     saveSiteFloors,
@@ -677,6 +713,15 @@ export default function useRobots() {
     getSiteFleetCore,
     saveSiteFleetCore,
     createSiteRelayKey,
+    getSiteOps,
+    saveSiteOps,
+    getSiteTimetable,
+    getSiteEmergency,
+    startSiteEmergency,
+    endSiteEmergency,
+    dispatchSiteRobot,
+    getSiteKpis,
+    getSiteKpisCsv,
     emergencyStopRobot,
     releaseEmergencyStopRobot,
     getRobotSetup,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.97.1-staging.573",
+  "version": "4.97.1-staging.574",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/utils/robot-fleet-ops.ts

@@ -0,0 +1,80 @@
+/**
+ * Robots - fleet operations (core `/api/robots/sites/:site/{ops,emergency,dispatch,kpis,timetable}`,
+ * market benchmark 2026-10-19). The words the screens show, as pure functions.
+ */
+
+/** The site switches (Super Admin, Setup). Every one is OFF by default = today's behaviour. */
+export const FLEET_OPS_SWITCHES = [
+  {
+    key: "vendorStartHold",
+    label: "Stop a robot started outside iService365",
+    help: "When two robots move at once (one started from its own app, schedule or button), stop the security robot where it is. Staff and the site are always told, switch on or off.",
+    moves: false,
+  },
+  {
+    key: "emergencyReturn",
+    label: "Emergency may send every robot to its charger",
+    help: "Adds \"Send every robot to its charger\" to the site's Emergency button. This DRIVES robots - switch on only after the on-site test. Emergency stop never needs a switch.",
+    moves: true,
+  },
+  {
+    key: "alarmIncidents",
+    label: "Robot alarms open an incident report",
+    help: "A security robot's alarm (smoke, intrusion, door open) opens one pending incident report for the guards to check and complete.",
+    moves: false,
+  },
+  {
+    key: "dispatch",
+    label: "\"Send the best robot\" may start the robot",
+    help: "Without it the site sees which robot would be chosen and why, but nothing is started.",
+    moves: true,
+  },
+  {
+    key: "lowBatteryReturn",
+    label: "Send a low-battery robot to its charger",
+    help: "An idle robot at or below the low-battery mark is driven to its charger (never during an emergency). The alert is sent either way.",
+    moves: true,
+  },
+] as const;
+
+export type TFleetOpsKey = (typeof FLEET_OPS_SWITCHES)[number]["key"];
+
+export type TSiteEmergency = { active: boolean; mode: string; reason?: string; at?: string } | null | undefined;
+
+/** The red line at the top of the site page while an emergency is on; null when there is none. */
+export function emergencyBanner(e: TSiteEmergency, now: number = Date.now()): string | null {
+  if (!e?.active) return null;
+  const what = e.mode === "return" ? "every robot was sent to its charger" : "every robot was stopped";
+  const t = e.at ? Date.parse(e.at) : NaN;
+  const ago = Number.isFinite(t) ? ` ${Math.max(0, Math.round((now - t) / 60_000))} min ago` : "";
+  return `EMERGENCY MODE${e.reason ? ` - ${e.reason}` : ""}: ${what}${ago}. No robot may start until it is ended.`;
+}
+
+export type TEmergencyStep = { name: string; kind?: string | null; sent?: boolean; note?: string; error?: string };
+
+/** One robot's line in the preview / result list. */
+export function emergencyStepLine(s: TEmergencyStep, done: boolean): { text: string; tone: "ok" | "warn" | "neutral" } {
+  const needsPerson = (s.kind && done && !s.sent) || (!s.kind && /cannot be stopped|offline|refused/.test(s.note ?? ""));
+  const verb = !done && s.kind ? { cancel: "will be stopped", pause: "will be paused", return: "will be sent to its charger" }[s.kind] : "";
+  const text = `${s.name}: ${verb || s.note || ""}${s.error ? ` (${s.error})` : ""}`;
+  return { text, tone: needsPerson ? "warn" : s.kind && (s.sent || !done) ? "ok" : "neutral" };
+}
+
+/** A KPI figure: blank stays a dash, never 0 (no record is not "zero"). */
+export function kpi(v: unknown, unit = ""): string {
+  return typeof v === "number" && Number.isFinite(v) ? `${v}${unit}` : "-";
+}
+
+/** The dispatch answer in one sentence. */
+export function dispatchLine(r: { chosen?: { name: string; battery: number } | null; sent?: boolean } | null | undefined, job: "patrol" | "clean"): string {
+  if (!r) return "";
+  if (!r.chosen) return `No robot can take a ${job} now - see the reasons below.`;
+  return r.sent ? `${r.chosen.name} was sent on a ${job}.` : `${r.chosen.name} would be sent (battery ${r.chosen.battery}%).`;
+}
+
+/** Timetable slot in words: "Mon, Wed 10:00-11:30 · Q3 · Cleaning schedule in the Ounitech cloud". */
+const DAYS = ["", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+export function slotLine(s: { robotName: string; days: number[]; start: string; end: string; source: string; enabled?: boolean }): string {
+  const days = s.days.length === 7 ? "Every day" : s.days.map((d) => DAYS[d] ?? String(d)).join(", ");
+  return `${days} ${s.start}-${s.end} · ${s.robotName} · ${s.source}${s.enabled === false ? " (switched off)" : ""}`;
+}