@7365admin1/layer-common 4.51.1 → 4.53.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/layer-common
 
+## 4.53.0
+
+### Minor Changes
+
+- 74aabc6: PadBot security robots on the HERO robot screens: Add robot labels the fields "AccessKey ID" / "AccessKey Secret" and picks the robot from the account; robot detail offers Start patrol / Resume patrol (brands with `patrolControl`), Live video (minted per click), Mark resolved on an alarm, an ALARM badge for security alerts, and a Patrol history panel. Pause / Resume now need the brand's `pauseResume`, Cancel its `pauseProcess` (no change for existing brands).
+
+## 4.52.0
+
+### Minor Changes
+
+- a983a42: Add / Edit robot: Ounitech credential fields read "AppID" / "Secret" (demo: "any value"); a Robot picker lists the robots the company credential covers (Find robots) so the serial is picked, and adding with no pair typed reuses the client's saved Ounitech credentials.
+
 ## 4.51.1
 
 ### Patch Changes
@@ -1551,11 +1563,11 @@
   `utils/console-tier.ts` + `composables/useConsoleTier.ts` mirror the server's
   own rule from two endpoints the console already calls, unprojected:
 
-                                                                                                                                                                                                                                GET /api/members/user/:user/app/admin    the Seven365 staff membership
-                                                                                                                                                                                                                                GET /api/roles/id/:role                  that membership's role document
+                                                                                                                                                                                                                                    GET /api/members/user/:user/app/admin    the Seven365 staff membership
+                                                                                                                                                                                                                                    GET /api/roles/id/:role                  that membership's role document
 
-                                                                                                                                                                                                                                owner  = member.type === "admin" && role.type === "admin" && role.default === true
-                                                                                                                                                                                                                                staff  = member.type === "admin" && role.type === "admin"
+                                                                                                                                                                                                                                    owner  = member.type === "admin" && role.type === "admin" && role.default === true
+                                                                                                                                                                                                                                    staff  = member.type === "admin" && role.type === "admin"
 
   `role.default` is the marker because it is the only property of a platform
   staff role no API caller can set - `role.controller.ts` validates create and

package/assets/css/robot-hero.css

@@ -757,7 +757,7 @@
 .hero .v-btn.hero-ghost { color: var(--hero-accent); padding-inline: 4px; }
 .hero .v-btn.hero-ghost:hover { background: color-mix(in srgb, var(--hero-accent) 10%, transparent); }
 
-.hero-faultbar { display: grid; grid-template-columns: auto 1fr auto; gap: 14px; align-items: center; padding: 12px 14px; border: 2px solid var(--hero-accent); }
+.hero-faultbar { display: grid; grid-template-columns: auto 1fr; grid-auto-flow: column; grid-auto-columns: auto; gap: 14px; align-items: center; padding: 12px 14px; border: 2px solid var(--hero-accent); }
 .hero-faultbar__code { font-family: var(--hero-font); font-weight: 800; color: var(--hero-accent); font-size: 18px; }
 .hero-faultbar__msg { font-weight: 600; }
 .hero-faultbar__since { opacity: 0.65; font-size: 12px; }
@@ -1234,3 +1234,6 @@ div.hero-editor__wp.hero-editor__sel, div.hero-editor__fid.hero-editor__sel { ou
   }
   .hero-cell__shimmer { display: none; }
 }
+
+/* PadBot security extras: live video button row under the facts. */
+.hero-detail__video { margin: 10px 0 4px; }

package/components/Robot/Detail.vue

@@ -27,7 +27,9 @@
       <div class="hero-faultbar__msg">{{ fault.message || fault.code }}</div>
       <div class="hero-faultbar__since">Since {{ faultSince }} · notified once</div>
     </div>
-    <span class="hero-faultbar__badge">FAULT</span>
+    <v-btn v-if="caps?.liveVideo === true && online" variant="outlined" size="small" :loading="videoBusy" @click="openVideo">Live video</v-btn>
+    <v-btn v-if="canResolve" variant="outlined" size="small" :loading="resolving" @click="resolveFault">Mark resolved</v-btn>
+    <span class="hero-faultbar__badge">{{ faultBadge(fault) }}</span>
   </div>
 
   <RobotNoMonitoring v-if="noInterface" :brand-name="brand" :model="live?.model || undefined" />
@@ -39,6 +41,9 @@
     </div>
   </div>
   <div v-if="notReported" class="hero-notreported">{{ notReported }}</div>
+  <div v-if="caps?.liveVideo === true && online && !fault" class="hero-detail__video">
+    <v-btn variant="outlined" :loading="videoBusy" @click="openVideo">Live video</v-btn>
+  </div>
 
   <div v-if="commands.length">
     <div class="hero-section__title">Command bar</div>
@@ -97,6 +102,8 @@
     </div>
   </div>
 
+  <RobotPatrolHistory v-if="robotType === 'security' && caps?.patrolHistory === true" :robot-id="robotId" />
+
   <v-dialog v-model="editOpen" width="520" persistent>
     <RobotForm
       v-if="editOpen && record"
@@ -136,6 +143,7 @@ import RobotViewOnlyNotice from "./ViewOnlyNotice.vue";
 import RobotLivePlan from "./LivePlan.vue";
 import RobotToast from "./Toast.vue";
 import RobotForm from "./Form.vue";
+import RobotPatrolHistory from "./PatrolHistory.vue";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import {
   brandName,
@@ -143,6 +151,7 @@ import {
   cleaningScheduleRows,
   commandBody,
   commandLabel,
+  faultBadge,
   headingDeg,
   isMoving,
   mergePose,
@@ -188,8 +197,19 @@ const emit = defineEmits<{
   status: [status: { connected: boolean }];
 }>();
 
-const { getRobot, getRobotBrands, getRobotPlans, getPatrolRoutes, sendRobotCommand, trackRobot, deleteRobot, getRobotMaps, getRobotMapImages } =
-  useRobots();
+const {
+  getRobot,
+  getRobotBrands,
+  getRobotPlans,
+  getPatrolRoutes,
+  sendRobotCommand,
+  trackRobot,
+  deleteRobot,
+  getRobotMaps,
+  getRobotMapImages,
+  getLiveVideo,
+  resolveRobotAlerts,
+} = useRobots();
 
 const record = ref<Record<string, any> | null>(null);
 const brands = ref<Array<Record<string, any>>>([]);
@@ -379,6 +399,42 @@ async function sendSpot() {
   }
 }
 
+/* ---- security-robot extras: live video (minted per click, never kept), resolve an alarm ---- */
+const videoBusy = ref(false);
+async function openVideo() {
+  // Opened before the await so the browser treats it as the click's own window.
+  const win = typeof window !== "undefined" ? window.open("", "_blank") : null;
+  videoBusy.value = true;
+  try {
+    const { url } = await getLiveVideo(props.robotId);
+    if (!/^https?:\/\//i.test(url)) throw new Error("The robot's cloud sent a video link this page cannot open.");
+    if (win) {
+      win.opener = null;
+      win.location.href = url;
+    } else toast.value = "Allow pop-ups to watch the robot's live video.";
+  } catch (e) {
+    win?.close();
+    toast.value = robotErrorMessage(e, "Could not open the live video.");
+  } finally {
+    videoBusy.value = false;
+  }
+}
+const canResolve = computed(
+  () => props.canCommand && caps.value?.resolveAlerts === true && faultBadge(fault.value) === "ALARM" && typeof fault.value?.code === "string",
+);
+const resolving = ref(false);
+async function resolveFault() {
+  resolving.value = true;
+  try {
+    const res = await resolveRobotAlerts(props.robotId, String(fault.value?.code ?? ""));
+    toast.value = res?.resolved ? `Marked resolved · ${res.resolved} alert${res.resolved === 1 ? "" : "s"}` : "Nothing open to resolve.";
+  } catch (e) {
+    toast.value = robotErrorMessage(e, "Could not mark the alert resolved.");
+  } finally {
+    resolving.value = false;
+  }
+}
+
 /* ---- edit / remove ---- */
 function onSaved() {
   editOpen.value = false;

package/components/Robot/Form.vue

@@ -2,7 +2,10 @@
   <!--
     Add / edit robot (HERO README §8): a 520px dialog - Name · Type (only when
     the account presents both types) · Brand (filtered by type; each option
-    shows its capability) · Site · App key · Token (password fields), the
+    shows its capability) · Site · App key · Token (password fields; named in
+    the brand's own words - Ounitech: AppID · Secret), Robot (Ounitech: pick the
+    serial from the company account; with no pair typed, the client's saved
+    pair is reused server-side), the
     credentials note with the brand's capability, Cancel / Save robot.
 
     Credentials are write-only: the stored pair never reaches the browser, so
@@ -46,7 +49,7 @@
         </select>
       </div>
       <div class="hero-field">
-        <label :for="`${uid}-key`">App key</label>
+        <label :for="`${uid}-key`">{{ labels.key }}</label>
         <input
           :id="`${uid}-key`"
           v-model="appKey"
@@ -59,7 +62,7 @@
         />
       </div>
       <div class="hero-field">
-        <label :for="`${uid}-token`">Token</label>
+        <label :for="`${uid}-token`">{{ labels.token }}</label>
         <input
           :id="`${uid}-token`"
           v-model="appToken"
@@ -71,6 +74,18 @@
           :disabled="saving"
         />
       </div>
+      <!-- One company credential covers many robots: pick the machine by serial. -->
+      <div v-if="discoverable" class="hero-field hero-form-grid__full">
+        <label :for="`${uid}-serial`">Robot</label>
+        <div class="d-flex ga-2 align-center">
+          <select :id="`${uid}-serial`" v-model="robotSn" class="hero-input" :disabled="saving || !found.length">
+            <option value="">{{ found.length ? "Choose the robot" : robotSn || findHint }}</option>
+            <option v-if="robotSn && !found.some((o) => o.value === robotSn)" :value="robotSn">{{ robotSn }}</option>
+            <option v-for="o in found" :key="o.value" :value="o.value" :disabled="o.disabled">{{ o.label }}</option>
+          </select>
+          <v-btn variant="outlined" :loading="finding" :disabled="saving || (!editing && !site)" @click="find">Find robots</v-btn>
+        </div>
+      </div>
     </div>
     <div class="hero-dialog__note">{{ credentialsNote(credentialsEncrypted) }} Capability: {{ note }}</div>
     <div v-if="error" class="hero-notice hero-notice--error" role="alert">{{ error }}</div>
@@ -93,6 +108,7 @@ import {
   type TRobotType,
 } from "../../utils/robot-display";
 import { credentialsNote } from "../../utils/robot-floorplan";
+import { credentialLabels, credentialMissingMessage, discoveredRobotOptions } from "../../utils/robot-credential-form";
 
 const props = withDefaults(
   defineProps<{
@@ -119,7 +135,7 @@ const emit = defineEmits<{
   "update:client": [org: string];
 }>();
 
-const { createRobot, updateRobot, getRobotBrands } = useRobots();
+const { createRobot, updateRobot, getRobotBrands, discoverRobots } = useRobots();
 const uid = useId();
 const titleId = `${uid}-title`;
 const editing = computed(() => !!props.robot?._id);
@@ -133,6 +149,23 @@ const org = ref(props.organization);
 const site = ref(String(props.robot?.site?._id ?? props.site ?? ""));
 const appKey = ref("");
 const appToken = ref("");
+const savedSn = String(props.robot?.robotSn ?? "");
+const robotSn = ref(savedSn);
+const found = ref<Array<{ value: string; label: string; disabled: boolean }>>([]);
+const finding = ref(false);
+const labels = computed(() => credentialLabels(brand.value));
+const typed = computed(() => !!appKey.value.trim() && !!appToken.value.trim());
+// Ounitech / PadBot: one credential pair per company account, so the robot is picked from its list.
+const discoverable = computed(() => brand.value === "ounitech" || brand.value === "padbot");
+const findHint = computed(() =>
+  editing.value || typed.value
+    ? "Press Find robots"
+    : `Press Find robots to use this client's saved ${labels.value.key} and ${labels.value.token}, or enter them first`,
+);
+watch([brand, site], () => {
+  found.value = [];
+  if (!editing.value) robotSn.value = "";
+});
 const saving = ref(false);
 const error = ref("");
 
@@ -184,15 +217,47 @@ onMounted(async () => {
   }
 });
 
+async function find() {
+  error.value = "";
+  if (!!appKey.value.trim() !== !!appToken.value.trim()) {
+    return void (error.value = `Enter both the ${labels.value.key} and the ${labels.value.token}.`);
+  }
+  finding.value = true;
+  try {
+    const pair = typed.value ? { appKey: appKey.value.trim(), appToken: appToken.value.trim() } : null;
+    const body = pair
+      ? { site: site.value, brand: brand.value, ...pair }
+      : editing.value
+        ? { robot: String(props.robot!._id) }
+        : { site: site.value, brand: brand.value };
+    const res = await discoverRobots(body);
+    found.value = discoveredRobotOptions(res?.items);
+    const free = found.value.filter((o) => !o.disabled);
+    if (!found.value.length) error.value = "No robots are on this account.";
+    else if (!robotSn.value && free.length === 1) robotSn.value = free[0]!.value;
+  } catch (e) {
+    found.value = [];
+    error.value = robotErrorMessage(e, "Could not list the robots.");
+  } finally {
+    finding.value = false;
+  }
+}
+
 async function submit() {
   error.value = "";
   if (!name.value.trim()) return void (error.value = "Give the robot a name.");
-  const creds = credentialPatch(appKey.value, appToken.value, editing.value);
-  if (!creds.ok) return void (error.value = creds.message);
+  // Adding with no pair typed = reuse this client's saved one; needs the picked robot.
+  const useSaved = !editing.value && discoverable.value && !appKey.value.trim() && !appToken.value.trim();
+  if (useSaved && !robotSn.value) {
+    return void (error.value = `Enter the ${labels.value.key} and ${labels.value.token}, or press Find robots to use this client's saved ones and pick the robot.`);
+  }
+  const creds = useSaved ? ({ ok: true, body: {} } as const) : credentialPatch(appKey.value, appToken.value, editing.value);
+  if (!creds.ok) return void (error.value = credentialMissingMessage(labels.value, editing.value));
+  const serial = robotSn.value && robotSn.value !== savedSn ? { robotSn: robotSn.value } : {};
   saving.value = true;
   try {
     if (editing.value) {
-      await updateRobot(String(props.robot!._id), { name: name.value.trim(), ...creds.body });
+      await updateRobot(String(props.robot!._id), { name: name.value.trim(), ...creds.body, ...serial });
       emit("saved", name.value.trim());
     } else {
       if (!brand.value) throw new Error("Choose the robot's brand.");
@@ -201,8 +266,8 @@ async function submit() {
         name: name.value.trim(),
         brand: brand.value,
         type: type.value,
-        appKey: creds.body.appKey!,
-        appToken: creds.body.appToken!,
+        ...(useSaved ? { useClientCredentials: true } : { appKey: creds.body.appKey!, appToken: creds.body.appToken! }),
+        ...serial,
         metadata: { orgId: org.value, siteId: site.value },
       });
       emit("created", { name: name.value.trim(), site: site.value });

package/components/Robot/PatrolHistory.vue

@@ -0,0 +1,100 @@
+<template>
+  <!--
+    Patrol history (brands with `patrolHistory`, e.g. PadBot): the robot's past
+    patrols from its own cloud, newest first; a row opens what was captured at
+    each checkpoint. Read only; photo links open the brand's image.
+  -->
+  <div class="hero-patrolhist">
+    <div class="hero-aside__head">
+      <span class="hero-aside__title">Patrol history</span>
+      <span class="hero-aside__hint">route · result · time · distance · alerts</span>
+    </div>
+    <div v-if="error" class="hero-sched__empty">{{ error }}</div>
+    <div v-else-if="loaded && !rows.length" class="hero-sched__empty">No patrols recorded yet.</div>
+    <template v-for="r in rows" :key="r.key">
+      <button type="button" class="hero-sched__row hero-patrolhist__row" :aria-expanded="open === r.key" @click="toggle(r.key)">
+        <b>{{ r.when }}</b><span>{{ r.route }} · <span :class="`hero-patrolhist__${r.tone}`">{{ r.result }}</span></span><span>{{ r.detail }}</span>
+      </button>
+      <div v-if="open === r.key" class="hero-patrolhist__visits">
+        <div v-if="visitsLoading" class="hero-sched__empty">Loading checkpoints…</div>
+        <div v-else-if="!visits.length" class="hero-sched__empty">No checkpoint captures for this patrol.</div>
+        <div v-for="(v, i) in visits" :key="i" class="hero-patrolhist__visit">
+          <b>{{ v.checkpoint || "Checkpoint" }}</b>
+          <span>{{ v.skipped ? "Skipped" : activityWhen(v.at, now) }}</span>
+          <span v-if="v.centerTempC !== null">{{ v.centerTempC }}°C (max {{ v.maxTempC ?? "—" }}°C)</span>
+          <a v-if="safeUrl(v.imageUrl)" :href="safeUrl(v.imageUrl)" target="_blank" rel="noopener noreferrer">Photo</a>
+          <a v-if="safeUrl(v.thermalImageUrl)" :href="safeUrl(v.thermalImageUrl)" target="_blank" rel="noopener noreferrer">Thermal</a>
+        </div>
+      </div>
+    </template>
+    <div v-if="pages > 1" class="hero-patrolhist__foot">
+      <v-btn variant="text" size="small" :disabled="page <= 1" @click="load(page - 1)">Newer</v-btn>
+      <span>Page {{ page }} of {{ pages }}</span>
+      <v-btn variant="text" size="small" :disabled="page >= pages" @click="load(page + 1)">Older</v-btn>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { activityWhen, patrolRecordRow, robotErrorMessage } from "../../utils/robot-display";
+
+const props = defineProps<{ robotId: string }>();
+const { getPatrolHistory, getPatrolVisits } = useRobots();
+
+const items = ref<any[]>([]);
+const page = ref(1);
+const pages = ref(0);
+const loaded = ref(false);
+const error = ref("");
+const open = ref("");
+const visits = ref<any[]>([]);
+const visitsLoading = ref(false);
+const now = Date.now();
+const rows = computed(() => items.value.map((r) => patrolRecordRow(r, now)));
+
+/** Only http(s) links from the brand are rendered. */
+const safeUrl = (u: unknown) => (typeof u === "string" && /^https?:\/\//i.test(u) ? u : "");
+
+async function load(p = 1) {
+  error.value = "";
+  try {
+    const res = await getPatrolHistory(props.robotId, { page: p, limit: 10 });
+    items.value = res?.items ?? [];
+    pages.value = res?.pages ?? 0;
+    page.value = p;
+  } catch (e) {
+    error.value = robotErrorMessage(e, "Could not load the patrol history.");
+  } finally {
+    loaded.value = true;
+  }
+}
+
+async function toggle(key: string) {
+  if (open.value === key) return void (open.value = "");
+  open.value = key;
+  visits.value = [];
+  visitsLoading.value = true;
+  try {
+    visits.value = (await getPatrolVisits(props.robotId, key))?.items ?? [];
+  } catch {
+    visits.value = [];
+  } finally {
+    visitsLoading.value = false;
+  }
+}
+
+watch(() => props.robotId, () => load(1), { immediate: true });
+</script>
+
+<style scoped>
+.hero-patrolhist { margin-top: 20px; }
+.hero-patrolhist__row { width: 100%; text-align: left; background: none; border: 0; cursor: pointer; color: inherit; font: inherit; }
+.hero-patrolhist__visits { padding: 4px 0 8px 16px; }
+.hero-patrolhist__visit { display: flex; flex-wrap: wrap; gap: 12px; padding: 4px 0; font-size: 12px; }
+.hero-patrolhist__visit a { color: inherit; text-decoration: underline; }
+.hero-patrolhist__foot { display: flex; align-items: center; gap: 8px; font-size: 12px; margin-top: 6px; }
+.hero-patrolhist__success { color: rgb(var(--v-theme-success)); }
+.hero-patrolhist__warning { color: rgb(var(--v-theme-warning)); }
+.hero-patrolhist__info { color: rgb(var(--v-theme-info)); }
+</style>

package/composables/useRobots.ts

@@ -86,8 +86,10 @@ export default function useRobots() {
   function createRobot(payload: {
     name: string;
     brand?: string;
-    appKey: string;
-    appToken: string;
+    /** Omitted with `useClientCredentials` - the server copies the client's saved pair. */
+    appKey?: string;
+    appToken?: string;
+    useClientCredentials?: boolean;
     type?: "cleaning" | "security";
     robotSn?: string;
     metadata: { orgId: string; siteId: string; administratorId?: string };
@@ -111,6 +113,19 @@ export default function useRobots() {
     });
   }
 
+  /**
+   * The robots a company credential covers (Ounitech: one AppID/Secret per
+   * company), for the serial picker. Pass a typed pair, a saved robot's id
+   * (`robot`, when editing), or just the site to use the client's saved pair.
+   * POST so a typed secret never goes in a URL; the answer holds no credential.
+   */
+  function discoverRobots(body: { site?: string; brand?: string; robot?: string; appKey?: string; appToken?: string }) {
+    return useNuxtApp().$api<{ items: Array<{ robotSn: string; name: string; online: boolean; statusName: string; added: boolean }> }>(
+      "/api/robots/discover",
+      { method: "POST", body },
+    );
+  }
+
   /** Remove a robot. It stops listing and answering; the record is kept. */
   function deleteRobot(id: string) {
     return useNuxtApp().$api<Record<string, any>>(`/api/robots/${id}`, {
@@ -258,7 +273,7 @@ export default function useRobots() {
       | { kind: "full"; cleanTimes?: number; modeFlag?: number; subModeFlag?: number; levelFlag?: number }
       | { kind: "area"; areas: string[]; cleanTimes?: number; modeFlag?: number; subModeFlag?: number; levelFlag?: number }
       | { kind: "spot"; points: Array<{ x: number; y: number }>; cleanTimes?: number; modeFlag?: number; subModeFlag?: number; levelFlag?: number }
-      | { kind: "pause" | "resume" | "cancel" }
+      | { kind: "pause" | "resume" | "cancel" | "patrol-resume" }
       | { kind: "navigate"; x: number; y: number; theta?: number }
       | { kind: "relocalize"; floorNo: number; x: number; y: number; theta: number },
   ) {
@@ -268,6 +283,42 @@ export default function useRobots() {
     );
   }
 
+  /* ---------------------------------------- security-robot extras (brand capability-gated) */
+
+  /** `liveVideo`: the robot's camera URL, minted now (valid until `expiresAt`). Open it; never store it. */
+  function getLiveVideo(id: string) {
+    return useNuxtApp().$api<{ url: string; expiresAt: string | null }>(`/api/robots/${id}/live-video`, {
+      method: "POST",
+      query: { appSlug },
+      body: {},
+    });
+  }
+
+  /** `resolveAlerts`: mark the robot's open alerts (of one code, or all) resolved in the brand's system. */
+  function resolveRobotAlerts(id: string, code?: string) {
+    return useNuxtApp().$api<{ resolved: number }>(`/api/robots/${id}/alerts/resolve`, {
+      method: "POST",
+      query: { appSlug },
+      body: code ? { code } : {},
+    });
+  }
+
+  /** `patrolHistory`: past patrols, newest first. */
+  function getPatrolHistory(id: string, { page = 1, limit = 10 } = {}) {
+    return useNuxtApp().$api<{ items: any[]; total: number; pages: number }>(`/api/robots/${id}/patrol-history`, {
+      method: "GET",
+      query: { appSlug, page, limit },
+    });
+  }
+
+  /** `patrolHistory`: one past patrol's checkpoint visits. */
+  function getPatrolVisits(id: string, recordId: string, { page = 1, limit = 50 } = {}) {
+    return useNuxtApp().$api<{ items: any[]; total: number; pages: number }>(
+      `/api/robots/${id}/patrol-history/${encodeURIComponent(recordId)}`,
+      { method: "GET", query: { appSlug, page, limit } },
+    );
+  }
+
   /* ---------------------------------------- building maps and lifts */
 
   /**
@@ -498,10 +549,15 @@ export default function useRobots() {
     createRobot,
     updateRobot,
     deleteRobot,
+    discoverRobots,
     getRobotState,
     getRobotMaps,
     getRobotMapImages,
     getRobotPlans,
     sendRobotCommand,
+    getLiveVideo,
+    resolveRobotAlerts,
+    getPatrolHistory,
+    getPatrolVisits,
   };
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.51.1",
+  "version": "4.53.0",
   "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-credential-form.ts

@@ -0,0 +1,42 @@
+/**
+ * Add / Edit robot: the credential fields in each brand's own words, and the
+ * company-account robot picker. Kept out of `robot-display.ts` because that file
+ * is vendored into the mobile apps, which have no Add robot.
+ */
+
+/**
+ * Ounitech issues an "AppID" and a "Secret" (one pair per company - vendor
+ * answer of 2026-09-26); the stored fields are still `appKey` / `appToken`.
+ * The demo brand accepts anything.
+ */
+export function credentialLabels(brand: unknown): { key: string; token: string } {
+  if (brand === "ounitech") return { key: "AppID", token: "Secret" };
+  // PadBot issues an AccessKey ID + AccessKey Secret per account (API v4.0 §2.1).
+  if (brand === "padbot") return { key: "AccessKey ID", token: "AccessKey Secret" };
+  if (brand === "demo") return { key: "App key (any value)", token: "Token (any value)" };
+  return { key: "App key", token: "Token" };
+}
+
+/** "Enter the AppID and the Secret ..." - `credentialPatch`'s refusal, in the brand's words. */
+export function credentialMissingMessage(labels: { key: string; token: string }, editing: boolean): string {
+  return editing
+    ? `Enter both the ${labels.key} and the ${labels.token} to replace them, or leave both empty.`
+    : `Enter the ${labels.key} and the ${labels.token} from the brand portal.`;
+}
+
+/**
+ * Discovered robots as picker options: "Lobby Q3 · OT-SN-A", marking ones this
+ * client already added (disabled - one serial, one record) and offline ones.
+ */
+export function discoveredRobotOptions(
+  items: Array<{ robotSn?: unknown; name?: unknown; online?: unknown; added?: unknown }> | null | undefined,
+): Array<{ value: string; label: string; disabled: boolean }> {
+  return (items ?? [])
+    .filter((r) => typeof r?.robotSn === "string" && r.robotSn)
+    .map((r) => {
+      const sn = String(r.robotSn);
+      const name = typeof r.name === "string" && r.name.trim() ? `${r.name.trim()} · ${sn}` : sn;
+      const tags = [r.added === true ? "already added" : "", r.online === false ? "offline" : ""].filter(Boolean);
+      return { value: sn, label: tags.length ? `${name} (${tags.join(", ")})` : name, disabled: r.added === true };
+    });
+}

package/utils/robot-display.ts

@@ -286,8 +286,10 @@ const COMMAND_NEEDS: Readonly<Record<string, string>> = {
   area: "startProcess",
   spot: "spotClean",
   return: "sendToDock",
-  pause: "pauseProcess",
-  resume: "pauseProcess",
+  // Pause / resume = pausing a robot mid-way; cancel = stopping the job. Split
+  // so a brand that can stop but not pause (PadBot) shows Cancel with no Pause.
+  pause: "pauseResume",
+  resume: "pauseResume",
   cancel: "pauseProcess",
   navigate: "navigateToPoint",
   relocalize: "relocalize",
@@ -383,7 +385,8 @@ export type TRobotCommandKind =
   | "resume"
   | "cancel"
   | "navigate"
-  | "relocalize";
+  | "relocalize"
+  | "patrol-resume";
 
 /**
  * The command bar's buttons, in bar order; each needs `COMMAND_NEEDS[kind]`.
@@ -398,6 +401,7 @@ const COMMANDS: ReadonlyArray<{ kind: TRobotCommandKind; label: string }> = [
   { kind: "cancel", label: "Cancel" },
   { kind: "navigate", label: "Go to point" },
   { kind: "relocalize", label: "Set position" },
+  { kind: "patrol-resume", label: "Resume patrol" },
 ];
 
 export type TRobotCommand = { kind: TRobotCommandKind; label: string; primary: boolean };
@@ -409,7 +413,9 @@ export type TRobotCommand = { kind: TRobotCommandKind; label: string; primary: b
  *  - role: only a Manager (`canCommand`, i.e. the app's command permission);
  *  - online: only a robot confirmed online (`online === true`);
  *  - context: Pause only while working, Resume only while paused;
- *  - type: a security robot has no cleaning jobs, so no Clean all / Clean area.
+ *  - type: a security robot has no cleaning jobs, so no Clean all / Clean area -
+ *    but a brand with `patrolControl` gets Start patrol (the default route) and
+ *    Resume patrol (while it is not already patrolling).
  *
  * Returns [] whenever the bar should not render at all.
  */
@@ -422,13 +428,20 @@ export function visibleCommands(input: {
 } | null | undefined): TRobotCommand[] {
   if (!input || input.canCommand !== true || input.online !== true) return [];
   const caps = input.capabilities ?? {};
+  const patrol = input.type === "security" && caps.patrolControl === true;
   return COMMANDS.filter((c) => {
+    if (c.kind === "patrol-resume") return patrol && input.mode !== "WORKING" && input.mode !== "IN_TRANSIT";
     if (caps[COMMAND_NEEDS[c.kind]!] !== true) return false;
     if (c.kind === "pause" && input.mode !== "WORKING") return false;
     if (c.kind === "resume" && input.mode !== "PAUSED") return false;
-    if ((c.kind === "full" || c.kind === "area") && input.type === "security") return false;
+    if (c.kind === "full" && input.type === "security") return patrol;
+    if (c.kind === "area" && input.type === "security") return false;
     return true;
-  }).map((c) => ({ kind: c.kind, label: c.label, primary: c.kind === "full" }));
+  }).map((c) => ({
+    kind: c.kind,
+    label: c.kind === "full" && input.type === "security" ? "Start patrol" : c.label,
+    primary: c.kind === "full",
+  }));
 }
 
 /**
@@ -947,6 +960,7 @@ export function optimisticMode(kind: unknown, mode: unknown): string {
     case "area":
     case "spot":
     case "resume":
+    case "patrol-resume":
       return "WORKING";
     case "return":
       return "CHARGING_CYCLE";
@@ -1184,6 +1198,28 @@ export function activityRow(entry: Record<string, any> | null | undefined, now:
  * type; option shows capability"): only brands that make that class (a brand
  * declaring no `types` makes cleaning robots), as "Ounitech · Basic control".
  */
+/** "Open alarm" / "Machine fault" badge for the fault bar: a security robot's alarm is something it SAW. */
+export function faultBadge(fault: { code?: unknown; alarm?: unknown } | null | undefined): "ALARM" | "FAULT" {
+  return fault?.alarm === true || (typeof fault?.code === "string" && fault.code.startsWith("ALARM-")) ? "ALARM" : "FAULT";
+}
+
+/** One past patrol as a row: "Completed · 1 min 41 s · 19.9 m · 1 alert". */
+export function patrolRecordRow(r: Record<string, any> | null | undefined, now: number = Date.now()) {
+  const RESULT: Record<string, string> = { completed: "Completed", partial: "Partly completed", failed: "Failed", "in-progress": "In progress" };
+  const secs = typeof r?.durationS === "number" && Number.isFinite(r.durationS) ? Math.max(0, Math.round(r.durationS)) : null;
+  const dur = secs === null ? "—" : secs >= 60 ? `${Math.floor(secs / 60)} min ${secs % 60} s` : `${secs} s`;
+  const dist = typeof r?.distanceM === "number" && Number.isFinite(r.distanceM) ? `${Math.round(r.distanceM * 10) / 10} m` : "—";
+  const alerts = Number(r?.alarmCount) || 0;
+  return {
+    key: String(r?.id ?? ""),
+    when: activityWhen(r?.startedAt, now),
+    route: String(r?.routeName || "Patrol"),
+    result: RESULT[String(r?.result)] ?? "Unknown",
+    tone: (r?.result === "completed" ? "success" : r?.result === "in-progress" ? "info" : "warning") as THeroTone,
+    detail: `${dur} · ${dist} · ${alerts === 1 ? "1 alert" : `${alerts} alerts`}`,
+  };
+}
+
 export function brandOptions(
   brands: Array<Record<string, any>> | null | undefined,
   type: unknown,