@7365admin1/layer-common 4.52.0 → 4.54.0

package/components/Robot/ManualDrive.vue

@@ -0,0 +1,128 @@
+<template>
+  <!--
+    Manual control (Manager only, PADBOT_MANUAL_DRIVE on the server). Hold a
+    button to move; letting go stops. The server forwards motion only while
+    this screen's heartbeat keeps arriving and stops the robot the moment it
+    does not - closing, hiding the tab or losing the connection all stop it.
+  -->
+  <div class="hero-dialog hero-drive" role="dialog" aria-labelledby="hero-drive-title" tabindex="-1" @keydown="onKey" @keyup="onKeyUp">
+    <div id="hero-drive-title" class="hero-dialog__title">Manual control · {{ name }}</div>
+    <div v-if="starting" class="hero-muted">Starting manual control…</div>
+    <div v-else-if="ended" class="hero-notice" role="alert">{{ ended }}</div>
+    <template v-else>
+      <div class="hero-dialog__body">Hold a button to move. Let go and the robot stops. {{ speedLimitText(limits) }}.</div>
+      <button type="button" class="hero-drive__stop" @click="client?.stop()">STOP</button>
+      <div class="hero-drive__pad" aria-label="Drive">
+        <span />
+        <button type="button" v-bind="hold('forward')">▲ Forward</button>
+        <span />
+        <button type="button" v-bind="hold('left')">◀ Turn left</button>
+        <span />
+        <button type="button" v-bind="hold('right')">Turn right ▶</button>
+        <span />
+        <button type="button" v-bind="hold('back')">▼ Back</button>
+        <span />
+      </div>
+      <div class="hero-drive__head" aria-label="Head">
+        <span class="hero-muted">Head</span>
+        <button type="button" @click="client?.look('left')">Look left</button>
+        <button type="button" @click="client?.look('right')">Look right</button>
+        <button type="button" @click="client?.look('up')">Look up</button>
+        <button type="button" @click="client?.look('down')">Look down</button>
+        <button type="button" @click="client?.look('centre')">Centre</button>
+      </div>
+    </template>
+    <div class="hero-dialog__actions">
+      <v-btn variant="outlined" @click="close">Close</v-btn>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { onBeforeUnmount, onMounted, ref } from "vue";
+import { createDriveClient, speedLimitText, type TDriveDirection, type TDriveLimits } from "../../utils/robot-control";
+import { robotErrorMessage } from "../../utils/robot-display";
+
+const props = defineProps<{ robotId: string; name?: string }>();
+const emit = defineEmits<{ close: [] }>();
+const { startDrive, driveSignal } = useRobots();
+
+const starting = ref(true);
+const ended = ref("");
+const limits = ref<TDriveLimits | null>(null);
+let client: ReturnType<typeof createDriveClient> | null = null;
+
+const release = () => client?.release();
+function hold(dir: TDriveDirection) {
+  return {
+    onPointerdown: (e: PointerEvent) => {
+      (e.target as HTMLElement).setPointerCapture?.(e.pointerId);
+      client?.press(dir);
+    },
+    onPointerup: release,
+    onPointerleave: release,
+    onPointercancel: release,
+    onBlur: release,
+    onContextmenu: (e: Event) => {
+      e.preventDefault();
+      release();
+    },
+  };
+}
+const KEYS: Record<string, TDriveDirection> = { ArrowUp: "forward", ArrowDown: "back", ArrowLeft: "left", ArrowRight: "right" };
+function onKey(e: KeyboardEvent) {
+  if (e.key === " ") {
+    e.preventDefault();
+    client?.stop();
+  } else if (KEYS[e.key] && !e.repeat) {
+    e.preventDefault();
+    client?.press(KEYS[e.key]!);
+  }
+}
+function onKeyUp(e: KeyboardEvent) {
+  if (KEYS[e.key]) release();
+}
+
+const finish = () => client?.end();
+const onHidden = () => {
+  if (document.visibilityState === "hidden") finish();
+};
+function close() {
+  finish();
+  emit("close");
+}
+
+onMounted(async () => {
+  document.addEventListener("visibilitychange", onHidden);
+  window.addEventListener("pagehide", finish);
+  window.addEventListener("beforeunload", finish);
+  window.addEventListener("blur", release);
+  try {
+    const res = await startDrive(props.robotId);
+    const l = res?.limits ?? {};
+    limits.value = {
+      maxLinear: Number(l.maxLinear) || 0.3,
+      maxAngular: Number(l.maxAngular) || 30,
+      heartbeatMs: Math.min(100, Number(l.heartbeatMs) || 100),
+      headPan: Array.isArray(l.headPan) ? l.headPan : [-90, 90],
+      headTilt: Array.isArray(l.headTilt) ? l.headTilt : [-15, 30],
+    };
+    client = createDriveClient({
+      send: (body, opts) => driveSignal(props.robotId, res.session, body, opts),
+      limits: limits.value,
+      onEnd: (reason) => (ended.value = reason || "Manual control ended."),
+    });
+  } catch (e) {
+    ended.value = robotErrorMessage(e, "Manual control could not start.");
+  } finally {
+    starting.value = false;
+  }
+});
+onBeforeUnmount(() => {
+  finish();
+  document.removeEventListener("visibilitychange", onHidden);
+  window.removeEventListener("pagehide", finish);
+  window.removeEventListener("beforeunload", finish);
+  window.removeEventListener("blur", release);
+});
+</script>

package/components/Robot/MiniMap.vue

@@ -33,7 +33,8 @@
         :key="r.id"
         type="button"
         class="hero-bot"
-        :title="r.name"
+        :class="{ 'hero-bot--stale': r.stale }"
+        :title="r.stale ? `${r.name} · ${r.seen}` : r.name"
         :style="{ left: r.left, top: r.top, transition: `left ${tickMs}ms linear, top ${tickMs}ms linear`, '--hero-bot': toneColor(r) }"
         @click="emit('open', r.id)"
       >

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/components/Robot/PointPicker.vue

@@ -0,0 +1,33 @@
+<template>
+  <!-- Go to point / Set position: the robot's own saved points, per map. -->
+  <div class="hero-dialog" role="dialog" aria-labelledby="hero-pick-title">
+    <div id="hero-pick-title" class="hero-dialog__title">{{ kind === "navigate" ? "Go to point" : "Set position" }}</div>
+    <div v-if="kind === 'relocalize'" class="hero-dialog__body">Only points on the floor the robot reports are listed.</div>
+    <div v-if="!groups.length" class="hero-muted">No saved points{{ kind === "relocalize" ? " on the robot's current floor" : "" }}.</div>
+    <div v-for="g in groups" :key="g.mapId" class="hero-pick__group">
+      <div class="hero-aside__title">{{ g.title }}</div>
+      <button v-for="p in g.points" :key="p.targetPointId" type="button" class="hero-pick__point" :aria-pressed="chosen === p" @click="chosen = p">
+        {{ p.name }} <span class="hero-dim">{{ p.type }}</span>
+      </button>
+    </div>
+    <div v-if="chosen && kind === 'relocalize'" class="hero-notice">
+      Only do this when the robot is standing at {{ chosen.name }} right now - it tells the robot where it is.
+    </div>
+    <div class="hero-dialog__actions">
+      <v-btn variant="outlined" @click="emit('close')">Cancel</v-btn>
+      <v-btn color="primary" variant="flat" :disabled="!chosen" @click="chosen && emit('pick', chosen)">
+        {{ kind === "navigate" ? `Send to ${chosen?.name ?? "point"}` : `Robot is at ${chosen?.name ?? "point"}` }}
+      </v-btn>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import type { TSavedPoint, TSavedPointGroup } from "../../utils/robot-display";
+
+const props = defineProps<{ kind: "navigate" | "relocalize"; groups: TSavedPointGroup[]; floorNo?: number | null }>();
+const emit = defineEmits<{ close: []; pick: [point: TSavedPoint] }>();
+const chosen = ref<TSavedPoint | null>(null);
+const groups = computed(() => (props.kind === "relocalize" ? props.groups.filter((g) => g.floorNo !== null && g.floorNo === props.floorNo) : props.groups));
+</script>

package/composables/useRobots.ts

@@ -273,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 },
   ) {
@@ -283,6 +283,81 @@ 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, quality: "hd" | "smooth" = "smooth") {
+    return useNuxtApp().$api<{ url: string; expiresAt: string | null }>(`/api/robots/${id}/live-video`, {
+      method: "POST",
+      query: { appSlug },
+      body: { quality },
+    });
+  }
+
+  /** Manual control (Manager only): open a drive session. 400 carries the plain reason it cannot start. */
+  function startDrive(id: string) {
+    return useNuxtApp().$api<{ session: string; limits: Record<string, any> }>(`/api/robots/${id}/drive`, {
+      method: "POST",
+      query: { appSlug },
+      body: { action: "start" },
+    });
+  }
+
+  /**
+   * One signal on an open drive session (beat / move / stop / head / end).
+   * Plain `fetch` so the page-closing "end" can go out with `keepalive`;
+   * never throws - answers `{ ok, status, message }`.
+   */
+  async function driveSignal(id: string, session: string, body: Record<string, unknown>, opts: { keepalive?: boolean } = {}) {
+    const base = useRuntimeConfig().public?.apiBase ?? "";
+    const query = appSlug ? `?appSlug=${encodeURIComponent(appSlug)}` : "";
+    try {
+      const res = await fetch(`${base}/api/robots/${id}/drive/${encodeURIComponent(session)}${query}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        credentials: "include",
+        keepalive: opts.keepalive === true,
+        body: JSON.stringify(body),
+      });
+      let message = "";
+      if (!res.ok) {
+        try {
+          message = String((await res.json())?.message ?? "");
+        } catch {
+          /* no body */
+        }
+      }
+      return { ok: res.ok, status: res.status, message };
+    } catch {
+      return { ok: false, status: 0, message: "" };
+    }
+  }
+
+  /** `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 */
 
   /**
@@ -519,5 +594,11 @@ export default function useRobots() {
     getRobotMapImages,
     getRobotPlans,
     sendRobotCommand,
+    getLiveVideo,
+    startDrive,
+    driveSignal,
+    resolveRobotAlerts,
+    getPatrolHistory,
+    getPatrolVisits,
   };
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.52.0",
+  "version": "4.54.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-control.ts

@@ -0,0 +1,159 @@
+/**
+ * Web-only robot controls: the live-view player's URL handling and the
+ * manual-drive client. Not part of the mobile-synced `robot-display.ts`
+ * (mobile has no live view or manual control - parity exception, like map
+ * editing, decision 81).
+ */
+
+/* ============================================================ live view */
+
+export type TVideoKind = "hls" | "video" | "flv" | "rtmp" | "page" | "bad";
+
+/**
+ * What kind of stream URL the robot's cloud handed us.
+ * ponytail: no hls.js / mpegts.js yet - the real PadBot URL type is unknown;
+ * HLS plays natively where the browser can (Safari), FLV and HLS elsewhere
+ * get "Open in new tab". Add the player library once a real URL is seen.
+ */
+export function liveVideoKind(url: unknown): TVideoKind {
+  if (typeof url !== "string") return "bad";
+  if (/^rtmps?:\/\//i.test(url)) return "rtmp";
+  if (!/^https?:\/\//i.test(url)) return "bad";
+  const path = url.split(/[?#]/)[0]!.toLowerCase();
+  if (path.endsWith(".m3u8")) return "hls";
+  if (path.endsWith(".flv")) return "flv";
+  if (/\.(mp4|webm)$/.test(path)) return "video";
+  return "page";
+}
+
+/** When to ask for a fresh URL: 30 s before it expires (never sooner than 5 s); null when it does not expire. */
+export function remintDelayMs(expiresAt: unknown, now: number = Date.now()): number | null {
+  const t = typeof expiresAt === "string" ? Date.parse(expiresAt) : NaN;
+  if (!Number.isFinite(t)) return null;
+  return Math.max(5_000, t - now - 30_000);
+}
+
+/* ======================================================== manual drive */
+
+export type TDriveLimits = {
+  maxLinear: number;
+  maxAngular: number;
+  heartbeatMs: number;
+  commandMaxMs?: number;
+  headPan: [number, number];
+  headTilt: [number, number];
+};
+export type TDriveDirection = "forward" | "back" | "left" | "right";
+export type TDriveSend = (body: Record<string, unknown>, opts?: { keepalive?: boolean }) => Promise<{ ok: boolean; status: number; message: string }>;
+
+/** Chassis vector for a held direction, at the server's cap (left turn = positive angular speed). */
+export function driveVector(dir: TDriveDirection, limits: Pick<TDriveLimits, "maxLinear" | "maxAngular">) {
+  if (dir === "forward") return { lv: limits.maxLinear, av: 0 };
+  if (dir === "back") return { lv: -limits.maxLinear, av: 0 };
+  return { lv: 0, av: dir === "left" ? limits.maxAngular : -limits.maxAngular };
+}
+
+/** "Speed limited to 0.3 m/s". */
+export const speedLimitText = (limits: Pick<TDriveLimits, "maxLinear"> | null | undefined) =>
+  limits && Number.isFinite(limits.maxLinear) ? `Speed limited to ${limits.maxLinear} m/s` : "";
+
+const MOVE_REPEAT_MS = 500;
+
+/**
+ * The screen side of a drive session: a heartbeat every `heartbeatMs` for as
+ * long as the dialog is open, a move on press and every 500 ms while held, a
+ * stop on release. Any refused signal ends the session (the server has
+ * already stopped the robot) and `onEnd` gets the server's words.
+ */
+export function createDriveClient(o: {
+  send: TDriveSend;
+  limits: TDriveLimits;
+  onEnd: (reason: string) => void;
+  setInterval?: typeof setInterval;
+  clearInterval?: typeof clearInterval;
+}) {
+  const si = o.setInterval ?? setInterval;
+  const ci = o.clearInterval ?? clearInterval;
+  let seq = 0;
+  let ended = false;
+  let held: TDriveDirection | null = null;
+  let moveTimer: ReturnType<typeof setInterval> | null = null;
+  const head = { pan: 0, tilt: 0 };
+
+  const post = (body: Record<string, unknown>, opts?: { keepalive?: boolean }) => {
+    if (ended) return;
+    const signal = { seq: ++seq, ...body };
+    void o.send(signal, opts).then((r) => {
+      if (!r.ok && body.action !== "end") end(r.message || (r.status ? "Manual control ended." : "Manual control ended: connection lost."), false);
+    });
+  };
+  const beatTimer = si(() => post({ action: "beat" }), o.limits.heartbeatMs);
+  post({ action: "beat" });
+
+  function clearMove() {
+    if (moveTimer) ci(moveTimer);
+    moveTimer = null;
+  }
+  function end(reason = "", tellServer = true) {
+    if (ended) return;
+    clearMove();
+    ci(beatTimer);
+    if (tellServer) post({ action: "end" }, { keepalive: true });
+    ended = true;
+    held = null;
+    o.onEnd(reason);
+  }
+  return {
+    press(dir: TDriveDirection) {
+      if (ended) return;
+      held = dir;
+      clearMove();
+      const send = () => held && post({ action: "move", ...driveVector(held, o.limits) });
+      send();
+      moveTimer = si(send, MOVE_REPEAT_MS);
+    },
+    release() {
+      if (ended || !held) return;
+      held = null;
+      clearMove();
+      post({ action: "stop" });
+    },
+    /** The big STOP: always sends, held or not. */
+    stop() {
+      held = null;
+      clearMove();
+      post({ action: "stop" });
+    },
+    look(dir: "left" | "right" | "up" | "down" | "centre", step = 15) {
+      if (dir === "centre") {
+        head.pan = head.tilt = 0;
+        return post({ action: "head", axis: "reset" });
+      }
+      const clamp = (v: number, [lo, hi]: [number, number]) => Math.max(lo, Math.min(hi, v));
+      if (dir === "left" || dir === "right") {
+        head.pan = clamp(head.pan + (dir === "left" ? step : -step), o.limits.headPan);
+        return post({ action: "head", axis: "pan", angle: head.pan });
+      }
+      head.tilt = clamp(head.tilt + (dir === "up" ? step : -step), o.limits.headTilt);
+      post({ action: "head", axis: "tilt", angle: head.tilt });
+    },
+    end: (reason = "") => end(reason, true),
+    get ended() {
+      return ended;
+    },
+    get held() {
+      return held;
+    },
+  };
+}
+
+/* ======================================================== alert photos */
+
+/** "Photo" / "Thermal photo" links for a fault that carries the robot's pictures (http/https only). */
+export function faultPhotos(fault: { imageUrl?: unknown; thermalImageUrl?: unknown } | null | undefined): Array<{ label: string; url: string }> {
+  const ok = (v: unknown): v is string => typeof v === "string" && /^https?:\/\//i.test(v);
+  return [
+    ...(ok(fault?.imageUrl) ? [{ label: "Photo", url: fault!.imageUrl as string }] : []),
+    ...(ok(fault?.thermalImageUrl) ? [{ label: "Thermal photo", url: fault!.thermalImageUrl as string }] : []),
+  ];
+}

package/utils/robot-credential-form.ts

@@ -11,6 +11,8 @@
  */
 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" };
 }