@7365admin1/layer-common 4.35.1-staging.412 → 4.35.1-staging.414

package/components/Robot/CommandBar.vue

@@ -30,6 +30,8 @@ const props = defineProps<{
   online?: boolean;
   mode?: unknown;
   type?: string;
+  /** A patrol that can be carried on (Resume patrol shows only then). */
+  resumable?: boolean;
   /** The command in flight, if any. */
   busy?: TRobotCommandKind | null;
 }>();
@@ -42,6 +44,7 @@ const commands = computed(() =>
     online: props.online,
     mode: props.mode,
     type: props.type,
+    resumable: props.resumable,
   }),
 );
 </script>

package/components/Robot/Detail.vue

@@ -121,9 +121,13 @@
           :online="live?.ok === true && live.online === true"
           :mode="statusMode"
           :type="robotType"
+          :resumable="resumable"
           :busy="busy"
           @command="send"
         />
+        <div v-if="commandResult" class="hero-notice" :class="{ 'hero-notice--error': commandResult.warn }" role="status" aria-live="polite">
+          {{ commandResult.text }}
+        </div>
       </div>
       <RobotViewOnlyNotice v-if="!canCommand" />
     </section>
@@ -182,6 +186,18 @@
   <v-dialog v-model="confirmOpen" width="440">
     <div v-if="confirming" class="hero-dialog" role="alertdialog" aria-labelledby="hero-confirm-title">
       <div id="hero-confirm-title" class="hero-dialog__title">{{ confirming.text.title }}</div>
+      <v-select
+        v-if="confirming.routes?.length"
+        v-model="confirming.routeId"
+        :items="confirming.routes"
+        item-title="name"
+        item-value="id"
+        label="Patrol route"
+        density="compact"
+        hide-details
+        class="mb-2"
+        @update:model-value="pickRoute"
+      />
       <div class="hero-dialog__body">{{ confirming.text.body }}</div>
       <div class="hero-dialog__actions">
         <v-btn variant="outlined" @click="confirmOpen = false">Don't send</v-btn>
@@ -258,7 +274,11 @@ import {
   capabilityLabel,
   cleaningScheduleRows,
   commandBody,
+  COMMAND_WATCH_MS,
   commandConfirm,
+  commandOutcome,
+  patrolResumable,
+  patrolStartRoutes,
   commandLabel,
   faultBadge,
   headingDeg,
@@ -407,7 +427,7 @@ const makerApp = computed(() => (live.value?.ok ? live.value.profile?.makerApp :
 
 const online = computed(() => live.value?.ok === true && live.value.online === true);
 const commands = computed(() =>
-  visibleCommands({ capabilities: caps.value, canCommand: props.canCommand, online: online.value, mode: statusMode.value, type: robotType.value }),
+  visibleCommands({ capabilities: caps.value, canCommand: props.canCommand, online: online.value, mode: statusMode.value, type: robotType.value, resumable: resumable.value }),
 );
 
 /* ---- the plan ---- */
@@ -470,6 +490,7 @@ const unplacedRoutes = computed(() =>
 const runs = ref<any[]>([]);
 const runsLoaded = ref(false);
 const detected = computed(() => detectPatrolSchedule(runs.value, now.value));
+const resumable = computed(() => patrolResumable(runs.value));
 /** Newest first, 100 a page, until a page reaches 30 days back. ponytail: capped at 5 pages (500 runs); raise if a robot patrols more than ~16x a day. */
 async function loadRuns() {
   const since = Date.now() - 30 * 86_400_000;
@@ -559,22 +580,54 @@ watch([reportsPosition, online], ([r, o], old) => {
 
 /* ---- commands ---- */
 const busy = ref<TRobotCommandKind | "spot" | null>(null);
-async function run(kind: TRobotCommandKind | "spot", body: Record<string, unknown>) {
+/** The last command's real outcome, kept on screen (a toast vanishes in 2.6 s). */
+const commandResult = ref<{ text: string; warn: boolean } | null>(null);
+const watching = ref<{ kind: string; at: number; what?: string } | null>(null);
+watch([lastAt, now], () => {
+  const w = watching.value;
+  const at = lastAt.value?.getTime() ?? 0;
+  // Only a reading taken after the command was accepted counts (never the optimistic status).
+  if (!w || at <= w.at + 300) return;
+  const out = commandOutcome(w.kind, polled.value?.ok ? polled.value : null, Date.now() - w.at, { name: record.value?.name, what: w.what });
+  if (!out) return;
+  watching.value = null;
+  commandResult.value = { text: out.text, warn: !out.ok };
+  if (!out.ok) optimistic.value = null;
+});
+watch(
+  () => props.robotId,
+  () => {
+    commandResult.value = null;
+    watching.value = null;
+  },
+);
+async function run(kind: TRobotCommandKind | "spot", body: Record<string, unknown>, what?: string) {
   const name = record.value?.name ?? "the robot";
   const before = statusMode.value;
   busy.value = kind;
   optimistic.value = { mode: optimisticMode(kind, before), after: Number.POSITIVE_INFINITY };
-  const label = kind === "full" && robotType.value === "security" ? "Start patrol" : commandLabel(kind);
+  const label = (kind === "full" || kind === "area") && robotType.value === "security" ? "Start patrol" : commandLabel(kind);
   toast.value = `${label} → ${name} · sending…`;
+  commandResult.value = { text: `${label} → ${name} · sending…`, warn: false };
+  watching.value = null;
   try {
     await sendRobotCommand(props.robotId, body as any);
     // A poll already in flight may still carry the old status; wait past it.
     optimistic.value = optimistic.value ? { ...optimistic.value, after: Date.now() + 300 } : null;
-    toast.value = `${label} → ${name} · accepted. Its status updates here.`;
+    toast.value = `${label} → ${name} · accepted.`;
+    // Resume patrol follows the last run; re-read it once the robot has had time to act.
+    if (robotType.value === "security" && caps.value?.patrolHistory === true) setTimeout(loadRuns, 5000);
+    // "Accepted" is not "done": watch real readings for up to 30 s (commandOutcome).
+    const outcomeKind = body.kind === "go-to-point" ? "go-to-point" : kind;
+    if (commandOutcome(outcomeKind, { mode: "" }, COMMAND_WATCH_MS) !== null) {
+      watching.value = { kind: String(outcomeKind), at: Date.now(), what };
+      commandResult.value = { text: `${label} → ${name} · accepted. Waiting for the robot to move…`, warn: false };
+    } else commandResult.value = { text: `${label} → ${name} · accepted.`, warn: false };
     return true;
   } catch (e) {
     optimistic.value = null;
     toast.value = robotErrorMessage(e);
+    commandResult.value = { text: `${label} → ${name} · not sent: ${robotErrorMessage(e)}`, warn: true };
     return false;
   } finally {
     busy.value = null;
@@ -598,6 +651,20 @@ async function send(kind: TRobotCommandKind) {
       return;
     }
   }
+  // Start patrol (security): pick the route - the robot's own map's routes, first one preselected.
+  if (kind === "full" && robotType.value === "security") {
+    const routes = patrolStartRoutes(patrol.value?.routes, live.value?.mapId ?? null);
+    if (!routes.length && (patrol.value?.routes?.length ?? 0) > 0) {
+      commandResult.value = { text: `None of the robot's patrol routes are on ${currentMapLabel.value || "the map it is on"}. Move it to a route's map first.`, warn: true };
+      return;
+    }
+    if (routes.length) {
+      confirming.value = { kind: "area", body: {}, text: { title: "", body: "", action: "" }, routes, routeId: routes[0]!.id };
+      pickRoute(routes[0]!.id);
+      confirmOpen.value = true;
+      return;
+    }
+  }
   const body = commandBody(kind, live.value);
   if (!body) {
     toast.value = `${commandLabel(kind)}: the robot's position is not known yet.`;
@@ -608,11 +675,31 @@ async function send(kind: TRobotCommandKind) {
   confirmOpen.value = true;
 }
 const confirmOpen = ref(false);
-const confirming = ref<{ kind: TRobotCommandKind; body: Record<string, unknown>; text: { title: string; body: string; action: string } } | null>(null);
+const confirming = ref<{
+  kind: TRobotCommandKind;
+  body: Record<string, unknown>;
+  text: { title: string; body: string; action: string };
+  routes?: TPatrolRouteView[];
+  routeId?: string;
+  what?: string;
+} | null>(null);
+/** The route picked in Start patrol's confirm: its exact words, and the body naming it. */
+function pickRoute(id: unknown) {
+  const c = confirming.value;
+  const route = c?.routes?.find((r) => r.id === id);
+  if (!c || !route) return;
+  const stops = route.stops?.length ? route.stops : route.checkpoints.map((p) => p.name);
+  const map = currentMapLabel.value || "";
+  const name = route.name.replace(/ \(default\)$/, "");
+  c.routeId = route.id;
+  c.body = { kind: "area", areas: [route.id] };
+  c.what = /^patrol/i.test(name) ? name : `patrolling ${name}`;
+  c.text = commandConfirm("area", { type: "security", name: record.value?.name, route: { name, stops }, map });
+}
 function confirmSend() {
   const c = confirming.value;
   confirmOpen.value = false;
-  if (c) run(c.kind, c.body);
+  if (c) run(c.kind, c.body, c.what);
 }
 
 /** The robot's plan image size for its floor, for turning plan clicks into pixels. */
@@ -658,7 +745,7 @@ function onPick(p: TSavedPoint) {
     toast.value = "Set position: the robot must be on this map first.";
     return;
   }
-  run(kind, body);
+  run(kind, body, kind === "navigate" ? `going to ${p.name}` : undefined);
 }
 
 /* ---- security-robot extras: live view (minted per open, never kept), manual control, resolve an alarm ---- */

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.35.1-staging.412",
+  "version": "4.35.1-staging.414",
   "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

@@ -180,6 +180,24 @@ export function writeLivePref(storage: Pick<Storage, "setItem"> | undefined, on:
 /** hls.js errors that mean "this browser cannot decode the codec", not "the camera is down". */
 const CODEC_ERRORS = new Set(["manifestIncompatibleCodecsError", "bufferAddCodecError", "bufferIncompatibleCodecsError"]);
 
+/**
+ * hls.js live settings. The robot camera (EZVIZ via PadBot) serves plain HLS
+ * v3: 4 s segments, a 3-segment window, no LL-HLS parts. hls.js's default
+ * sits 3 segments (12 s) behind the newest picture and never catches up after
+ * a hiccup - the owner's "10-15 s delay". Now: 6 s behind (1.5 segments, so
+ * one late segment does not stall), play up to 1.2x to win back time lost to
+ * a hiccup, and jump forward if it ever falls 14 s behind.
+ * ponytail: a lower-latency protocol (FLV / WebRTC) is not offered by PadBot's
+ * §6.5 video API; ask PadBot if 6 s is still too slow.
+ */
+export const LIVE_HLS_CONFIG = {
+  enableWorker: true,
+  lowLatencyMode: false,
+  liveSyncDuration: 6,
+  liveMaxLatencyDuration: 14,
+  maxLiveSyncPlaybackRate: 1.2,
+} as const;
+
 /**
  * Plays one live-view URL into `video`. Returns a stop function that frees the
  * player and the connection.
@@ -286,7 +304,7 @@ export function startLivePlayer(
         video.addEventListener("error", noteDecode);
         let recoveries = 0;
         const Base = Hls.DefaultConfig?.loader;
-        const h = (hls = new Hls({ enableWorker: true, lowLatencyMode: false, ...(Base ? { fLoader: strayAudLoader(Base) } : {}) }));
+        const h = (hls = new Hls({ ...LIVE_HLS_CONFIG, ...(Base ? { fLoader: strayAudLoader(Base) } : {}) }));
         h.on("hlsError", (_e, data) => {
           noteDecode();
           if (!data.fatal) return;

package/utils/robot-display.ts

@@ -404,6 +404,9 @@ const COMMANDS: ReadonlyArray<{ kind: TRobotCommandKind; label: string }> = [
   { kind: "patrol-resume", label: "Resume patrol" },
 ];
 
+/** A job is in hand (something for Cancel to stop). */
+const ACTIVE: ReadonlySet<string> = new Set(["WORKING", "IN_TRANSIT", "PAUSED", "MANUAL"]);
+
 export type TRobotCommand = { kind: TRobotCommandKind; label: string; primary: boolean };
 
 /**
@@ -412,10 +415,12 @@ export type TRobotCommand = { kind: TRobotCommandKind; label: string; primary: b
  *  - brand: only commands its declared capabilities support;
  *  - 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;
+ *  - context: Pause only while working, Resume only while paused, Cancel only
+ *    while there is a job to stop (working, moving or paused);
  *  - 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).
+ *    but a brand with `patrolControl` gets Start patrol (a route picker) and
+ *    Resume patrol - only while a patrol is paused or its last run did not
+ *    finish (`resumable`), never "just in case".
  *
  * Returns [] whenever the bar should not render at all.
  */
@@ -425,16 +430,19 @@ export function visibleCommands(input: {
   online?: unknown;
   mode?: unknown;
   type?: unknown;
+  /** A patrol that can be carried on: the last run did not finish (in progress / partial / failed). */
+  resumable?: unknown;
 } | 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 (c.kind === "patrol-resume") return patrol && (input.mode === "PAUSED" || (input.resumable === true && 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" && input.type === "security") return patrol;
+    if (c.kind === "cancel" && !ACTIVE.has(String(input.mode))) return false;
+    if (c.kind === "full" && input.type === "security") return patrol && !ACTIVE.has(String(input.mode)); // one patrol at a time
     if (c.kind === "area" && input.type === "security") return false;
     return true;
   }).map((c) => ({
@@ -1645,14 +1653,21 @@ export function scheduleElsewhereText(type: unknown, brand: unknown, profile?: T
  */
 export function commandConfirm(
   kind: unknown,
-  input: { type?: unknown; name?: unknown; point?: unknown } = {},
+  input: { type?: unknown; name?: unknown; point?: unknown; route?: { name?: unknown; stops?: unknown } | null; map?: unknown } = {},
 ): { title: string; body: string; action: string } {
   const who = (typeof input.name === "string" && input.name) || "The robot";
   const at = typeof input.point === "string" && input.point ? input.point : "";
-  const label = kind === "full" && input.type === "security" ? "Start patrol" : commandLabel(kind);
+  const patrol = input.type === "security" && (kind === "full" || kind === "area");
+  const label = patrol ? "Start patrol" : commandLabel(kind);
+  const route = input.route && typeof input.route.name === "string" ? input.route : null;
+  const stops = Array.isArray(route?.stops) ? (route!.stops as unknown[]).filter((s) => typeof s === "string" && s) : [];
+  const onMap = typeof input.map === "string" && input.map ? ` on ${input.map}` : "";
+  const walk = route
+    ? `${who} walks "${route.name}" once${stops.length ? ` (${stops.join(" → ")})` : ""}${onMap}, then stops.`
+    : `${who} starts walking its default patrol route once.`;
   const body: Record<string, string> = {
-    full: input.type === "security" ? `${who} starts walking its default patrol route once.` : `${who} starts cleaning the whole floor it is on.`,
-    area: `${who} starts cleaning the chosen areas.`,
+    full: input.type === "security" ? walk : `${who} starts cleaning the whole floor it is on.`,
+    area: input.type === "security" ? walk : `${who} starts cleaning the chosen areas.`,
     return: `${who} stops what it is doing and drives back to its charger.`,
     pause: `${who} stops where it is and waits. Press Resume to carry on.`,
     resume: `${who} carries on with the job it paused.`,
@@ -1666,6 +1681,72 @@ export function commandConfirm(
   return { title: `${label}?`, body: body[String(kind)] ?? `${who}: ${label}.`, action: label };
 }
 
+/**
+ * Start patrol's route choices: the routes on the map the robot is on (a route
+ * on another map is refused by the server - the robot cannot walk it from
+ * here). Unknown current map, or routes that say no map: all of them. The
+ * default pick is the first (the server lists the walked / current-map /
+ * default route first).
+ */
+export function patrolStartRoutes(routes: TPatrolRouteView[] | null | undefined, currentMapId: unknown): TPatrolRouteView[] {
+  const all = (Array.isArray(routes) ? routes : []).filter((r) => r && typeof r.id === "string" && r.id);
+  if (typeof currentMapId !== "string" || !currentMapId) return all;
+  return all.filter((r) => !r.mapId || r.mapId === currentMapId);
+}
+
+/** Last patrol run not finished, so Resume patrol has something to carry on (PadBot §6.7 completionState 0/1/3). */
+export function patrolResumable(runs: Array<{ result?: unknown }> | null | undefined): boolean {
+  const r = Array.isArray(runs) ? runs[0]?.result : undefined;
+  return r === "in-progress" || r === "partial" || r === "failed";
+}
+
+/** How long after "accepted" we wait for the robot to show it acted. */
+export const COMMAND_WATCH_MS = 30_000;
+
+const GOING = ["WORKING", "IN_TRANSIT", "PAUSED"];
+const STARTED: Readonly<Record<string, ReadonlySet<string>>> = {
+  full: new Set(GOING),
+  area: new Set(GOING),
+  "patrol-resume": new Set(GOING),
+  "go-to-point": new Set(GOING),
+  navigate: new Set(GOING),
+  return: new Set([...GOING, "CHARGING_CYCLE", "CHARGED"]),
+};
+const RESTING = /^(Standing by|Charging|Charged|Working on a task)$/;
+
+/**
+ * What an accepted command actually did, from a reading taken AFTER it was
+ * sent (never the optimistic status). The robot cloud's "accepted" is not
+ * "done": PadBot answers code 0 and the robot may still not move.
+ *  - started: the robot shows it acted -> `${who} started ${what}.`
+ *  - still resting after COMMAND_WATCH_MS -> `${who} didn't start — <reason>`
+ *    (the robot's own words when it gave any, e.g. "Could not reach P2 (...)").
+ *  - otherwise: keep watching (null).
+ * Commands without a visible outcome (cancel, set position, pause) -> null.
+ */
+export function commandOutcome(
+  kind: unknown,
+  reading: { online?: unknown; mode?: unknown; statusName?: unknown; fault?: { message?: unknown } | null } | null | undefined,
+  elapsedMs: number,
+  input: { name?: unknown; what?: unknown } = {},
+): { ok: boolean; text: string } | null {
+  const started = STARTED[String(kind)];
+  if (!started || !reading) return null;
+  const who = (typeof input.name === "string" && input.name) || "The robot";
+  const what = typeof input.what === "string" && input.what ? input.what : kind === "return" ? "going back to its charger" : "moving";
+  if (typeof reading.mode === "string" && started.has(reading.mode)) return { ok: true, text: `${who} started ${what}.` };
+  if (elapsedMs < COMMAND_WATCH_MS) return null;
+  const said = typeof reading.statusName === "string" ? reading.statusName.split(" · ")[0]!.trim() : "";
+  const fault = typeof reading.fault?.message === "string" ? reading.fault.message : "";
+  const reason = reading.online === false ? "it stopped reporting" : fault || (said && !RESTING.test(said) ? said : "");
+  return {
+    ok: false,
+    text: reason
+      ? `${who} didn't start — ${reason}.`
+      : `${who} didn't start — the robot cloud accepted the command, but the robot is still ${said ? said.toLowerCase() : "idle"}. Check the robot or its maker's app.`,
+  };
+}
+
 /** The Brand column: "PadBot S2", "Demo S1 (simulated)", or just "Ounitech" when no model is reported. */
 export function brandModelText(
   brand: unknown,