@frockbot/plugin-routines 0.3.11 → 0.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-routines",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "private": false,
   "type": "module",
   "exports": {
@@ -32,12 +32,12 @@
     "typecheck": "vue-tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/client-core": "0.3.11",
-    "@frockbot/client-ui": "0.3.11",
-    "@frockbot/configuration-core": "0.3.11",
-    "@frockbot/kernel-agent-loop": "0.3.11",
-    "@frockbot/kernel-contracts": "0.3.11",
-    "@frockbot/plugin-shell": "0.3.11",
+    "@frockbot/client-core": "0.3.12",
+    "@frockbot/client-ui": "0.3.12",
+    "@frockbot/configuration-core": "0.3.12",
+    "@frockbot/kernel-agent-loop": "0.3.12",
+    "@frockbot/kernel-contracts": "0.3.12",
+    "@frockbot/plugin-shell": "0.3.12",
     "cordis": "4.0.0-rc.8",
     "croner": "10.0.1",
     "vue": "3.5.41"
@@ -46,7 +46,7 @@
     "@types/bun": "1.4.0",
     "@types/node": "26.2.0",
     "@vitejs/plugin-vue": "6.0.8",
-    "typescript": "5.9.3",
+    "typescript": "npm:typescript-native-bridge@6.0.3-bridge.16.tsgo.7.0.2",
     "vite": "8.2.2",
     "vue-tsc": "3.3.10"
   },

package/src/client/RoutineInboxBadge.vue

@@ -67,6 +67,7 @@ function markAllRead(): void {
       type="button"
       class="routine-inbox__trigger"
       :aria-expanded="open"
+      :aria-label="`Routine completions${count > 0 ? ` (${badge} unread)` : ''}`"
       :title="`Routine completions${count > 0 ? ` (${badge} unread)` : ''}`"
       @click="toggle"
     >

package/src/client/RoutinesSection.vue

@@ -12,6 +12,10 @@ import {
   UiField,
   UiIcon,
 } from "@frockbot/client-ui";
+import {
+  presentClientFailureV1,
+  serverRefusalMessageV1,
+} from "@frockbot/client-core";
 import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
 import { settingsLinkV1 } from "@frockbot/plugin-shell/settings-links";
 import { computed, inject, reactive, ref, watch } from "vue";
@@ -173,10 +177,15 @@ async function submit(): Promise<void> {
     // The form stays open and holds the reason itself, beside the field that
     // caused it. The section header keeps its copy for the reader who scrolls
     // back up, but the form no longer refuses in silence.
+    //
+    // A refused save is the deployment explaining a rule it holds — which
+    // field is wrong and why — so its own sentence is what belongs here. A
+    // fault carries no such sentence, and the classified failure's short one
+    // is what a person can act on instead of a stack's worth of plumbing.
     saveError.value =
-      error instanceof Error
-        ? error.message
-        : (routines.value.error ?? "Could not save the Routine");
+      serverRefusalMessageV1(error) ??
+      routines.value.error ??
+      presentClientFailureV1(error, "save the Routine");
   }
 }
 
@@ -523,12 +532,24 @@ async function toggleLog(routineId: string): Promise<void> {
   gap: 12px;
 }
 
+/*
+ * The section head wraps rather than squeezing its own description. With the
+ * action fixed at its intrinsic width, the sentence was folded into a ~180px
+ * ribbon while a quarter of the panel sat empty beside it; below that basis
+ * the action takes its own line instead.
+ */
 .routines__header {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
   gap: 10px;
 }
 
+.routines__header > :deep(.ui-button),
+.routines__header > button {
+  margin-left: auto;
+}
+
 .routines__icon {
   display: grid;
   width: var(--frock-avatar-sm);
@@ -544,7 +565,7 @@ async function toggleLog(routineId: string): Promise<void> {
 .routines__intro {
   display: flex;
   min-width: 0;
-  flex: 1 1 auto;
+  flex: 1 1 14rem;
   flex-direction: column;
 }
 

package/src/client/index.ts

@@ -6,7 +6,10 @@
 // become an alternate authority." Every write here is one `POST` of one
 // versioned command with its own idempotency key, and every read is decoded at
 // the seam before a component sees it.
-import type { ClientPlugin } from "@frockbot/client-core";
+import {
+  serverRefusalMessageV1,
+  type ClientPlugin,
+} from "@frockbot/client-core";
 import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
 import { ref, watch } from "vue";
 import {
@@ -27,7 +30,17 @@ import {
 } from "./state.js";
 import { defineClientContribution } from "@frockbot/kernel-contracts/contributions";
 
+/*
+ * A refusal's own sentence first, then a presentable one.
+ *
+ * A validator that rejects a schedule says why in words meant for the person
+ * writing it — "cron expression ... must have five fields". That sentence is
+ * the answer, so it goes on screen unchanged. Anything else is plumbing, and
+ * `.message` on a classified failure is already the short sentence for it.
+ */
 function message(error: unknown, fallback: string): string {
+  const refusal = serverRefusalMessageV1(error);
+  if (refusal !== undefined) return refusal;
   return error instanceof Error ? error.message : fallback;
 }
 

package/src/inbox-store.ts

@@ -235,6 +235,26 @@ export function retainedPendingInputsV1(
   );
 }
 
+/**
+ * One stored inbox entry, or nothing when it cannot be read.
+ *
+ * The inbox is the only place a firing ever speaks, and it is read on a plain
+ * `GET`. Every other Routine record is decoded strictly, because a Routine that
+ * cannot be decoded must not be fired; an inbox entry is inert text already
+ * written, so the strictness buys nothing and costs the whole list. Exported so
+ * the tolerance is testable without a store.
+ */
+export function readableRoutineInboxEntryV1(
+  value: unknown,
+): RoutineInboxEntryV1 | undefined {
+  try {
+    return decodeRoutineInboxEntryV1(value);
+  } catch (error) {
+    if (error instanceof RoutineDecodeError) return undefined;
+    throw error;
+  }
+}
+
 export class RoutineInboxStore {
   readonly #storage: RoutineStorageV1;
   readonly #now: () => Date;
@@ -248,8 +268,15 @@ export class RoutineInboxStore {
   }
 
   /**
-   * Every inbox entry, newest first, trimmed to the retention bound first so a
-   * read is also the place the bound is enforced.
+   * Every inbox entry that still decodes, newest first, trimmed to the
+   * retention bound first so a read is also the place the bound is enforced.
+   *
+   * One unreadable row must not take the whole inbox with it. The decoder is
+   * exact — an entry a later version wrote with a field this one has never
+   * heard of is rejected as firmly as a corrupt one — so a single legacy row
+   * used to turn `GET …/routines/inbox` into a 500 and hide every completion
+   * beside it. A row nobody can read says nothing to anyone: it is skipped, and
+   * `#trimInbox` reclaims its space ahead of anything readable.
    */
   async list(): Promise<RoutineInboxEntryV1[]> {
     await this.#trimInbox();
@@ -257,9 +284,12 @@ export class RoutineInboxStore {
       prefix: ROUTINE_INBOX_PREFIX,
       limit: ROUTINE_INBOX_LIMIT,
     });
-    return [...stored.values()].map((value) =>
-      decodeRoutineInboxEntryV1(value),
-    );
+    const entries: RoutineInboxEntryV1[] = [];
+    for (const value of stored.values()) {
+      const entry = readableRoutineInboxEntryV1(value);
+      if (entry) entries.push(entry);
+    }
+    return entries;
   }
 
   /**
@@ -277,7 +307,12 @@ export class RoutineInboxStore {
       });
       let changed = 0;
       for (const [key, value] of stored.entries()) {
-        const entry = decodeRoutineInboxEntryV1(value);
+        // The same tolerance the read has: an entry that cannot be decoded
+        // cannot be shown either, so there is nothing here to mark read, and
+        // failing the whole command over it would leave the readable entries
+        // unacknowledged for good.
+        const entry = readableRoutineInboxEntryV1(value);
+        if (!entry) continue;
         if (entry.acknowledged) continue;
         if (wanted.size > 0 && !wanted.has(entry.entryId)) continue;
         await transaction.put(key, {
@@ -424,14 +459,9 @@ export class RoutineInboxStore {
     const acknowledged: string[] = [];
     const unread: string[] = [];
     for (const [key, value] of entries) {
-      let read = false;
-      try {
-        read = decodeRoutineInboxEntryV1(value).acknowledged;
-      } catch {
-        // An entry nothing can decode says nothing to anyone; it is the first
-        // thing worth reclaiming space from.
-        read = true;
-      }
+      // An entry nothing can decode says nothing to anyone; it is the first
+      // thing worth reclaiming space from.
+      const read = readableRoutineInboxEntryV1(value)?.acknowledged ?? true;
       (read ? acknowledged : unread).push(key);
     }
     for (const key of [...acknowledged, ...unread]) {

package/src/inbox.test.ts

@@ -8,12 +8,14 @@ import {
   subagentAttributionV1,
 } from "./inbox.js";
 import {
+  readableRoutineInboxEntryV1,
   retainedPendingInputsV1,
   RoutineInboxStore,
   routineTerminalRecordsV1,
 } from "./inbox-store.js";
 import { createMemoryRoutineStorageV1 } from "./testing.js";
 import {
+  routineInboxKeyV1,
   ROUTINE_INBOX_LIMIT,
   ROUTINE_INBOX_PREFIX,
   ROUTINE_PENDING_INPUT_LIMIT,
@@ -109,6 +111,62 @@ describe("the completion inbox", () => {
       true,
     );
   });
+
+  /*
+   * `GET /api/bots/:id/routines/inbox` answered 500 once in verification. The
+   * read decoded every stored row strictly, and the decoder rejects an unknown
+   * field as firmly as a corrupt one — so one row written by a later version, or
+   * one half-written row, hid every readable completion beside it behind an
+   * error. A row nobody can read is skipped instead.
+   */
+  test("a malformed entry is skipped rather than failing the whole read", async () => {
+    const store = storage();
+    await settle(store, { runId: "rf-good", responseText: "readable" });
+    // Three shapes of bad row: a field this version has never heard of, a
+    // required field missing, and a value that is not an object at all.
+    await store.put(routineInboxKeyV1(90), {
+      schemaVersion: 1,
+      entryId: "ri-rf-future",
+      runId: "rf-future",
+      routineId: "morning-brief",
+      text: "from a later version",
+      attribution: "Automation: Morning brief",
+      createdAt: NOW,
+      acknowledged: false,
+      severity: "urgent",
+    });
+    await store.put(routineInboxKeyV1(91), {
+      schemaVersion: 1,
+      entryId: "ri-rf-partial",
+      runId: "rf-partial",
+    });
+    await store.put(routineInboxKeyV1(92), "not an entry at all");
+
+    const inbox = new RoutineInboxStore(store);
+    const entries = await inbox.list();
+    expect(entries.map((entry) => entry.runId)).toEqual(["rf-good"]);
+    // Acknowledging is tolerant on the same terms: the readable entry is
+    // marked, and the unreadable rows neither break the command nor count.
+    expect(await inbox.acknowledge([])).toBe(1);
+    expect((await inbox.list())[0]!.acknowledged).toBe(true);
+  });
+
+  test("the tolerant decode keeps a readable entry and drops an unreadable one", () => {
+    expect(readableRoutineInboxEntryV1({ schemaVersion: 2 })).toBeUndefined();
+    expect(readableRoutineInboxEntryV1(undefined)).toBeUndefined();
+    expect(
+      readableRoutineInboxEntryV1({
+        schemaVersion: 1,
+        entryId: "ri-1",
+        runId: "rf-1",
+        routineId: "morning-brief",
+        text: "readable",
+        attribution: "Automation: Morning brief",
+        createdAt: NOW,
+        acknowledged: false,
+      })?.entryId,
+    ).toBe("ri-1");
+  });
 });
 
 describe("the pending-input queue", () => {