@7365admin1/layer-common 4.64.1 → 4.64.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @iservice365/layer-common
 
+## 4.64.2
+
+### Patch Changes
+
+- 5f0c221: Robot detail: after a command the line follows the robot ("Leaving the charger…", "On the way to P4…", "Arrived at P4", "Docking…", "Back on charger") instead of a false "didn't start"; says up front that undocking takes about 10 s, with a spinner while it follows; reads the robot every 1 s for a minute after a command (then every 4 s) so the status and map pin keep up; a note under the live view says the video is about 8 s behind and the map is real time.
+
 ## 4.64.1
 
 ### Patch Changes
@@ -1703,11 +1709,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

@@ -1284,6 +1284,7 @@ div.hero-editor__wp.hero-editor__sel, div.hero-editor__fid.hero-editor__sel { ou
 
 /* PadBot security extras: live video button row under the facts. */
 .hero-detail__video { margin: 10px 0 4px; }
+.hero-detail__lag { margin: 6px 0 0; font-size: 12px; }
 
 /* A kept (stale) reading: faded, no ping - never drawn as live (owner 2026-09-26). */
 .hero-bot--stale, .hero-me--stale { opacity: 0.45; }

package/components/Robot/Detail.vue

@@ -60,6 +60,7 @@
   <div v-if="!noInterface" class="hero-detail__main" :class="{ 'hero-detail__main--single': !hasCamera }">
     <section v-if="hasCamera" class="hero-detail__cam" aria-label="Camera">
       <RobotLiveView v-if="caps?.liveVideo === true" ref="livePanel" panel :robot-id="robotId" :name="record?.name" :offline="!online" />
+      <p v-if="caps?.liveVideo === true && reportsPosition" class="hero-muted hero-detail__lag">{{ VIDEO_LAG_NOTE }}</p>
       <div v-if="canDrive" class="hero-detail__video">
         <v-btn variant="outlined" @click="driveOpen = true">Manual control</v-btn>
       </div>
@@ -126,6 +127,7 @@
           @command="send"
         />
         <div v-if="commandResult" class="hero-notice" :class="{ 'hero-notice--error': commandResult.warn }" role="status" aria-live="polite">
+          <v-progress-circular v-if="watching" indeterminate size="14" width="2" class="mr-2" aria-hidden="true" />
           {{ commandResult.text }}
         </div>
       </div>
@@ -274,7 +276,11 @@ import {
   capabilityLabel,
   cleaningScheduleRows,
   commandBody,
+  COMMAND_FOLLOW_MS,
   COMMAND_WATCH_MS,
+  FAST_POLL_MS,
+  VIDEO_LAG_NOTE,
+  sentText,
   commandConfirm,
   commandOutcome,
   patrolResumable,
@@ -366,7 +372,9 @@ const brand = computed(() => brandName(record.value?.brand, brands.value));
 
 /* ---- live: the 4 s poll (swappable feed) + the per-robot position stream ---- */
 const ids = computed(() => (props.robotId ? [props.robotId] : []));
-const { states, connected, lastAt } = useRobotLive(ids, siteStatesFeed());
+// Every 4 s; every 1 s for a minute after a command, so the status and the map pin keep up with the robot.
+const fastUntil = ref(0);
+const { states, connected, lastAt } = useRobotLive(ids, siteStatesFeed(() => (Date.now() < fastUntil.value ? FAST_POLL_MS : 4000)));
 const polled = computed<TLiveRobotState | null>(() => states.value[props.robotId] ?? null);
 
 const lastPose = ref<{ event: any; at: number } | null>(null);
@@ -590,7 +598,8 @@ watch([lastAt, now], () => {
   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;
+  // Keep following (Leaving the charger… -> On the way to P4… -> Arrived at P4) until it is done.
+  if (out.done) watching.value = null;
   commandResult.value = { text: out.text, warn: !out.ok };
   if (!out.ok) optimistic.value = null;
 });
@@ -604,6 +613,7 @@ watch(
 async function run(kind: TRobotCommandKind | "spot", body: Record<string, unknown>, what?: string) {
   const name = record.value?.name ?? "the robot";
   const before = statusMode.value;
+  const docked = before === "CHARGED" || before === "CHARGING_CYCLE" || /At charger/.test(String(live.value?.ok ? live.value.statusName ?? "" : ""));
   busy.value = kind;
   optimistic.value = { mode: optimisticMode(kind, before), after: Number.POSITIVE_INFINITY };
   const label = (kind === "full" || kind === "area") && robotType.value === "security" ? "Start patrol" : commandLabel(kind);
@@ -621,7 +631,8 @@ async function run(kind: TRobotCommandKind | "spot", body: Record<string, unknow
     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 };
+      fastUntil.value = Date.now() + COMMAND_FOLLOW_MS;
+      commandResult.value = { text: sentText(docked), warn: false };
     } else commandResult.value = { text: `${label} → ${name} · accepted.`, warn: false };
     return true;
   } catch (e) {

package/composables/useRobotLive.ts

@@ -36,16 +36,25 @@ export type TRobotLiveFeed = {
  */
 export function robotPollingFeed(
   fetchStates: (ids: string[]) => Promise<{ items?: Array<Partial<TLiveRobotState> & { id: string }> }>,
-  intervalMs = 4000,
+  /** A number, or a function read before every wait (robot detail: 1 s for a minute after a command). */
+  intervalMs: number | (() => number) = 4000,
 ): TRobotLiveFeed {
+  const every = typeof intervalMs === "function" ? intervalMs : () => intervalMs;
   return {
     watch(ids, push, connected) {
       let stopped = false;
       let timer: ReturnType<typeof setTimeout> | undefined;
+      let lastTick = 0;
       const hidden = () => typeof document !== "undefined" && document.visibilityState === "hidden";
+      // Waits in 250 ms steps, so a shorter interval (a command just sent) starts at once.
+      const wait = () => {
+        if (stopped) return;
+        timer = setTimeout(() => (Date.now() - lastTick >= every() ? tick() : wait()), 250);
+      };
 
       async function tick() {
         if (stopped) return;
+        lastTick = Date.now();
         if (!hidden() && ids.length) {
           try {
             const res = await fetchStates(ids);
@@ -58,7 +67,7 @@ export function robotPollingFeed(
             connected(false);
           }
         }
-        if (!stopped) timer = setTimeout(tick, intervalMs);
+        wait();
       }
       // Coming back to the tab refreshes at once instead of waiting a tick.
       const onVisible = () => {
@@ -95,7 +104,7 @@ export function networkStatesFeed(intervalMs = 4000): TRobotLiveFeed {
  * The API checks every robot against its own site and narrows by the app's
  * `appSlug`, so a robot this screen may not see simply never arrives.
  */
-export function siteStatesFeed(intervalMs = 4000): TRobotLiveFeed {
+export function siteStatesFeed(intervalMs: number | (() => number) = 4000): TRobotLiveFeed {
   const appSlug = useRuntimeConfig().public?.appSlug as string | undefined;
   return robotPollingFeed(
     (ids) =>

package/package.json

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

@@ -1713,34 +1713,60 @@ const STARTED: Readonly<Record<string, ReadonlySet<string>>> = {
   return: new Set([...GOING, "CHARGING_CYCLE", "CHARGED"]),
 };
 const RESTING = /^(Standing by|Charging|Charged|Working on a task)$/;
+/** The robot got there: the line stops following. */
+const ARRIVED = /^(Arrived at|Back on charger)/;
+/** After a start, the line follows the robot's own words this long (then keeps the last). */
+export const COMMAND_FOLLOW_MS = 60_000;
+/** Robot detail reads the robot this often for COMMAND_FOLLOW_MS after a command (else every 4 s). */
+export const FAST_POLL_MS = 1000;
+/**
+ * Under the live view. Measured on prod 2026-09-27: the PadBot/EZVIZ picture
+ * is 7-10 s behind (4 s HLS segments upstream); the map pin comes from the
+ * position read / MQTT push and leads it.
+ */
+export const VIDEO_LAG_NOTE = "Video is about 8 s behind live; the map shows the robot's position in real time.";
+/** The line the moment the robot cloud accepts a moving command (the S2 takes 8-13 s to undock). */
+export function sentText(docked: boolean): string {
+  return docked ? "Sent to robot — it usually takes about 10 s to leave the charger." : "Sent to robot — waiting for it to move…";
+}
 
 /**
  * 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}.`
+ *  - started: the robot shows it acted -> what it is doing in its own words
+ *    (`${who}: Leaving the charger…`, `${who}: On the way to P4…`), else
+ *    `${who} started ${what}.`; `done` once it arrives ("Arrived at P4",
+ *    "Back on charger") or COMMAND_FOLLOW_MS has passed.
  *  - 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.
+ * The PadBot S2 drives with its navigation state idle; the API reads the
+ * charging state and the position instead, so "started" is real movement.
  */
 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 {
+): { ok: boolean; text: string; done: boolean } | 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() : "";
+  if (ARRIVED.test(said)) return { ok: true, text: `${who}: ${said}.`, done: true };
+  if (typeof reading.mode === "string" && started.has(reading.mode)) {
+    const doing = said && !RESTING.test(said) ? said : "";
+    return { ok: true, text: doing ? `${who}: ${doing}…` : `${who} started ${what}.`, done: elapsedMs >= COMMAND_FOLLOW_MS };
+  }
+  if (elapsedMs < COMMAND_WATCH_MS) return null;
   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,
+    done: true,
     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.`,