@frockbot/plugin-routines 0.3.8 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-routines",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "private": false,
   "type": "module",
   "exports": {
@@ -32,12 +32,12 @@
     "typecheck": "vue-tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/client-core": "0.3.8",
-    "@frockbot/client-ui": "0.3.8",
-    "@frockbot/configuration-core": "0.3.8",
-    "@frockbot/kernel-agent-loop": "0.3.8",
-    "@frockbot/kernel-contracts": "0.3.8",
-    "@frockbot/plugin-shell": "0.3.8",
+    "@frockbot/client-core": "0.3.10",
+    "@frockbot/client-ui": "0.3.10",
+    "@frockbot/configuration-core": "0.3.10",
+    "@frockbot/kernel-agent-loop": "0.3.10",
+    "@frockbot/kernel-contracts": "0.3.10",
+    "@frockbot/plugin-shell": "0.3.10",
     "cordis": "4.0.0-rc.8",
     "croner": "10.0.1",
     "vue": "3.5.41"

package/src/agent.test.ts

@@ -180,6 +180,97 @@ describe("routine_manage", () => {
   });
 });
 
+// A Bot paused a User's Routine in a Turn about sheep farming: no approval, no
+// confirmation, nothing in the transcript. A Routine the User made is theirs.
+describe("a Routine the User created", () => {
+  async function seeded() {
+    const seam = host();
+    await seam.store.execute(
+      {
+        schemaVersion: 1,
+        type: "routine/create",
+        commandId: "cmd-user",
+        botId: "scout",
+        routineId: "theirs",
+        name: "Minute ping",
+        prompt: "Say ping.",
+        schedule: "@every 1m",
+        timezone: "UTC",
+      },
+      { kind: "user" },
+    );
+    return seam;
+  }
+
+  for (const action of ["pause", "delete", "update"] as const) {
+    test(`refuses ${action} when the User did not ask`, async () => {
+      const seam = await seeded();
+      const tool = createRoutineManageTool({ ...seam, writer: WRITER });
+
+      const result = await tool.execute(
+        {
+          action,
+          routineId: "theirs",
+          ...(action === "update" ? { prompt: "Say pong." } : {}),
+        },
+        CONTEXT,
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("created by the User");
+      expect(result.content).toContain("userAsked: true");
+      const listed = await seam.list();
+      expect(listed.routines[0]).toMatchObject({
+        enabled: true,
+        prompt: "Say ping.",
+        createdBy: { kind: "user" },
+      });
+    });
+  }
+
+  test("pauses it once the User has asked", async () => {
+    const seam = await seeded();
+    const tool = createRoutineManageTool({ ...seam, writer: WRITER });
+
+    const result = await tool.execute(
+      { action: "pause", routineId: "theirs", userAsked: true },
+      CONTEXT,
+    );
+
+    expect(result.isError).toBe(false);
+    expect((await seam.list()).routines[0]).toMatchObject({ enabled: false });
+  });
+
+  test("leaves the Bot free to manage its own Routines", async () => {
+    const seam = host();
+    const tool = createRoutineManageTool({ ...seam, writer: WRITER });
+    await tool.execute(
+      {
+        action: "create",
+        routineId: "mine",
+        name: "Housekeeping",
+        prompt: "Tidy up.",
+        schedule: "@daily",
+      },
+      CONTEXT,
+    );
+
+    const result = await tool.execute(
+      { action: "pause", routineId: "mine" },
+      { ...CONTEXT, effectId: "tool:1:2:0" },
+    );
+
+    expect(result.isError).toBe(false);
+    expect((await seam.list()).routines[0]).toMatchObject({ enabled: false });
+  });
+
+  test("says destructive actions need the User's word", () => {
+    const tool = createRoutineManageTool({ ...host(), writer: WRITER });
+    expect(tool.description).toContain("only when the User asked you");
+    expect(tool.description).toContain("do not switch it off yourself");
+  });
+});
+
 describe("routineManageCommandV1", () => {
   test("maps a webhook trigger to the record's trigger shape", () => {
     expect(

package/src/agent.ts

@@ -102,11 +102,23 @@ const ROUTINE_MANAGE_INPUT_SCHEMA = {
       description:
         "IANA time zone the schedule is read in, such as Australia/Sydney.",
     },
+    userAsked: {
+      type: "boolean",
+      description:
+        "Set true only when the User asked you, in this conversation, to pause, edit, or delete this Routine. Required for those three actions on a Routine the User created. Never set it because a Routine looks wrong to you, is failing, or is no longer useful: say so and let the User decide.",
+    },
   },
   required: ["action"],
   additionalProperties: false,
 } as const;
 
+/** The actions that switch off or overwrite something already running. */
+const DESTRUCTIVE_ROUTINE_ACTIONS = new Set<RoutineManageActionV1>([
+  "pause",
+  "update",
+  "delete",
+]);
+
 interface RoutineManageInputV1 {
   action: RoutineManageActionV1;
   routineId?: string;
@@ -115,6 +127,7 @@ interface RoutineManageInputV1 {
   schedule?: string;
   trigger?: "webhook";
   timezone?: string;
+  userAsked?: boolean;
 }
 
 function decodeRoutineManageInputV1(input: unknown): RoutineManageInputV1 {
@@ -130,6 +143,7 @@ function decodeRoutineManageInputV1(input: unknown): RoutineManageInputV1 {
     "schedule",
     "trigger",
     "timezone",
+    "userAsked",
   ]);
   for (const key of Object.keys(value)) {
     if (!allowed.has(key)) {
@@ -153,6 +167,9 @@ function decodeRoutineManageInputV1(input: unknown): RoutineManageInputV1 {
   if (value.trigger !== undefined && value.trigger !== "webhook") {
     throw new RoutineDecodeError('routine_manage trigger must be "webhook"');
   }
+  if (value.userAsked !== undefined && typeof value.userAsked !== "boolean") {
+    throw new RoutineDecodeError("routine_manage userAsked must be a boolean");
+  }
   return {
     action,
     ...(optional("routineId") === undefined
@@ -169,6 +186,9 @@ function decodeRoutineManageInputV1(input: unknown): RoutineManageInputV1 {
     ...(optional("timezone") === undefined
       ? {}
       : { timezone: optional("timezone")! }),
+    ...(value.userAsked === undefined
+      ? {}
+      : { userAsked: value.userAsked as boolean }),
   };
 }
 
@@ -239,6 +259,28 @@ export function routineManageCommandV1(
   });
 }
 
+/**
+ * Whether the User, rather than this Bot, created the Routine.
+ *
+ * A listing that cannot be read answers `true`: not knowing who owns a Routine
+ * is a reason to ask, not a reason to switch it off. A Routine that is not in
+ * the listing at all is gone, and the command below will say so properly.
+ */
+async function userAuthoredRoutineV1(
+  host: RoutinesRuntimeHostV1,
+  routineId: string,
+): Promise<boolean> {
+  try {
+    const listing = await host.list();
+    const routine = listing.routines.find(
+      (candidate) => candidate.routineId === routineId,
+    );
+    return routine === undefined ? false : routine.createdBy.kind === "user";
+  } catch {
+    return true;
+  }
+}
+
 function refusal(reason: string): { content: string; isError: boolean } {
   return { content: `routine_manage was refused: ${reason}`, isError: true };
 }
@@ -257,6 +299,10 @@ export function createRoutineManageTool(
       "A Routine is a standing instruction that fires on a schedule or on a delivered webhook,",
       `as its own Turn rather than inside this conversation. Names are at most ${ROUTINE_NAME_MAX_LENGTH}`,
       `characters and prompts at most ${ROUTINE_PROMPT_MAX_LENGTH}.`,
+      "Pausing, editing, or deleting a Routine the User created switches off something they set up,",
+      "so do it only when the User asked you to in this conversation, and pass userAsked: true when they did.",
+      "If a Routine of theirs is failing or looks wrong, tell them and let them decide — do not switch it off yourself.",
+      "Say in your reply whatever you changed.",
     ].join(" "),
     inputSchema: ROUTINE_MANAGE_INPUT_SCHEMA as unknown as Record<
       string,
@@ -272,15 +318,32 @@ export function createRoutineManageTool(
       }
     },
     execute: async (input: unknown, context: ToolExecutionContext) => {
+      let decoded: RoutineManageInputV1;
       let command: RoutineCommandV1;
       try {
-        command = routineManageCommandV1(decodeRoutineManageInputV1(input), {
+        decoded = decodeRoutineManageInputV1(input);
+        command = routineManageCommandV1(decoded, {
           botId: host.botId,
           commandId: routineToolCommandIdV1(context.effectId),
         });
       } catch (error) {
         return refusal(error instanceof Error ? error.message : String(error));
       }
+      // A Bot paused a User's Routine in a Turn about sheep farming, with no
+      // approval, no confirmation, and nothing in the transcript saying so.
+      // The User's own Routines are theirs: switching one off, or rewriting
+      // it, needs the User to have asked for it in this conversation. The
+      // Bot's own Routines it may manage freely — those are its housekeeping.
+      if (
+        DESTRUCTIVE_ROUTINE_ACTIONS.has(decoded.action) &&
+        decoded.userAsked !== true &&
+        decoded.routineId !== undefined &&
+        (await userAuthoredRoutineV1(host, decoded.routineId))
+      ) {
+        return refusal(
+          `Routine ${decoded.routineId} was created by the User. Ask them before you ${decoded.action === "update" ? "change" : decoded.action} it, and call this again with userAsked: true once they say so.`,
+        );
+      }
       const writer: RoutineWriterV1 = {
         kind: "bot",
         botId: host.botId,

package/src/backend.ts

@@ -164,10 +164,11 @@ function errorResponse(error: unknown): Response {
       error instanceof Error ? error.message : "Routine request is invalid",
     );
   }
-  return jsonError(
-    500,
-    error instanceof Error ? error.message : "Routine request failed",
-  );
+  // A decode refusal above is the User's own request coming back at them and
+  // says what to fix. Anything reaching here is ours: it names internals the
+  // caller cannot act on, so it goes to the log and the caller gets the fact.
+  console.error("Routine request failed", error);
+  return jsonError(500, "Routine request failed");
 }
 
 /**
@@ -242,13 +243,17 @@ async function deliverHook(
       error.name === "RoutineHookError"
     ) {
       const hookError = error as RoutineHookError;
-      return jsonError(hookError.status, hookError.message);
+      // The wire body, not the reason. A refusal on this route answers the
+      // open internet, and the raw message names deployment internals — which
+      // environment variable is unset, which decoder rejected what.
+      return jsonError(
+        hookError.status,
+        hookError.publicMessage ?? "webhook delivery failed",
+      );
     }
     if (isMissingBot(error)) return jsonError(404, "Routine not found");
-    return jsonError(
-      500,
-      error instanceof Error ? error.message : "webhook delivery failed",
-    );
+    console.error("routine webhook delivery failed", error);
+    return jsonError(500, "webhook delivery failed");
   }
 }
 

package/src/client/RoutineInboxBadge.vue

@@ -6,7 +6,7 @@
 // completion becomes visible is here — a count of what has not been read, and a
 // drawer that reads it. Acknowledging is a command, never a side effect of
 // opening the drawer, so a glance does not clear the badge.
-import { UiButton, UiIcon } from "@frockbot/client-ui";
+import { formatRelativeMomentV1, UiButton, UiIcon } from "@frockbot/client-ui";
 import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
 import { computed, inject, ref, watch } from "vue";
 import { routinesStateKey } from "./state.js";
@@ -38,10 +38,27 @@ function toggle(): void {
   if (open.value && botId.value) void routines.value.loadInbox(botId.value);
 }
 
+/** What is unread and on screen right now — never "everything unread". */
+const unreadOnScreen = computed(() =>
+  routines.value.inbox
+    .filter((entry) => !entry.acknowledged)
+    .map((entry) => entry.entryId),
+);
+
 function acknowledge(entryIds: string[]): void {
-  if (!botId.value) return;
+  if (!botId.value || entryIds.length === 0) return;
   void routines.value.acknowledgeInbox(botId.value, entryIds);
 }
+
+/**
+ * "Mark all read" means the entries the reader can see, not every unread entry
+ * the object holds. An empty list acknowledges everything, including a firing
+ * that landed a second ago and has never been rendered — with a `@every 1m`
+ * Routine that is a completion silently marked read and never read.
+ */
+function markAllRead(): void {
+  acknowledge(unreadOnScreen.value);
+}
 </script>
 
 <template>
@@ -61,10 +78,10 @@ function acknowledge(entryIds: string[]): void {
       <header class="routine-inbox__header">
         <h2>Routine completions</h2>
         <UiButton
-          v-if="count > 0"
+          v-if="unreadOnScreen.length > 0"
           variant="ghost"
           :disabled="routines.busy"
-          @click="acknowledge([])"
+          @click="markAllRead()"
           >Mark all read</UiButton
         >
       </header>
@@ -81,7 +98,13 @@ function acknowledge(entryIds: string[]): void {
           <p class="routine-inbox__attribution">{{ entry.attribution }}</p>
           <p class="routine-inbox__text">{{ entry.text }}</p>
           <footer class="routine-inbox__meta">
-            <span>{{ entry.createdAt }}</span>
+            <time :datetime="entry.createdAt">{{
+              formatRelativeMomentV1(entry.createdAt)
+            }}</time>
+            <!-- One thing going wrong repeatedly is one entry and a count. -->
+            <span v-if="(entry.repeatCount ?? 1) > 1"
+              >Happened {{ entry.repeatCount }} times</span
+            >
             <UiButton
               v-if="!entry.acknowledged"
               variant="ghost"

package/src/client/RoutinesSection.vue

@@ -3,7 +3,15 @@
 // Routine. It renders durable state and submits versioned commands; it decides
 // nothing — "Next run" is the moment the scheduler has actually armed an alarm
 // on, sent down with the Routine, and blank when there is none to promise.
-import { UiAnchor, UiButton, UiField, UiIcon } from "@frockbot/client-ui";
+import {
+  browserTimeZoneV1,
+  formatMomentV1,
+  formatRelativeMomentV1,
+  UiAnchor,
+  UiButton,
+  UiField,
+  UiIcon,
+} from "@frockbot/client-ui";
 import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
 import { settingsLinkV1 } from "@frockbot/plugin-shell/settings-links";
 import { computed, inject, reactive, ref, watch } from "vue";
@@ -27,7 +35,6 @@ const formOpen = ref(false);
 const openLog = ref<string>();
 const copied = ref(false);
 const openRun = ref<string>();
-
 // An automation Turn never appears in the transcript, so opening a run here is
 // the only way to read one, and it is read-only in both directions: the view
 // carries what happened and no way to act on it.
@@ -50,6 +57,31 @@ const form = reactive({
   timezone: "UTC",
 });
 
+/**
+ * The reason the last save was refused, held beside the form rather than in
+ * the section header. The header sits above every Routine card, so on a Bot
+ * with a few Routines the refusal rendered hundreds of pixels off-screen and
+ * the form simply appeared to do nothing.
+ */
+const saveError = ref<string>();
+/** The Routine a delete has been asked for and not yet confirmed. */
+const pendingDelete = ref<RoutineViewV1>();
+
+/**
+ * Whether a refusal is about the schedule, so it can be rendered under the
+ * Schedule field. Every schedule refusal comes from one validator, and it
+ * names cron, the expression, or the time zone.
+ */
+const scheduleError = computed(() =>
+  saveError.value !== undefined &&
+  form.timing === "schedule" &&
+  /cron|schedule|expression|time zone|timezone|occurrence/iu.test(
+    saveError.value,
+  )
+    ? saveError.value
+    : undefined,
+);
+
 watch(
   botId,
   (id) => {
@@ -92,13 +124,22 @@ function summary(routine: RoutineViewV1): string {
     : "Webhook trigger";
 }
 
+/** A durable moment, read in the Routine's own zone — the one it fires on. */
+function moment(routine: RoutineViewV1, iso: string): string {
+  return formatMomentV1(iso, { timeZone: routine.timezone });
+}
+
 function startCreate(): void {
   form.routineId = undefined;
   form.name = "";
   form.prompt = "";
   form.timing = "schedule";
   form.schedule = "0 9 * * *";
-  form.timezone = "UTC";
+  // The reader's own zone, not UTC: a schedule is almost always meant in the
+  // day the person writing it is living in, and the Bot picks the same when it
+  // writes one itself.
+  form.timezone = browserTimeZoneV1();
+  saveError.value = undefined;
   formOpen.value = true;
 }
 
@@ -109,12 +150,14 @@ function startEdit(routine: RoutineViewV1): void {
   form.timing = routine.schedule ? "schedule" : "webhook";
   form.schedule = routine.schedule ?? "";
   form.timezone = routine.timezone;
+  saveError.value = undefined;
   formOpen.value = true;
 }
 
 async function submit(): Promise<void> {
   const id = botId.value;
   if (!id) return;
+  saveError.value = undefined;
   try {
     await routines.value.save(id, {
       ...(form.routineId ? { routineId: form.routineId } : {}),
@@ -126,11 +169,33 @@ async function submit(): Promise<void> {
       timezone: form.timezone.trim(),
     });
     formOpen.value = false;
-  } catch {
-    // The state holds the reason; the form stays open so it can be corrected.
+  } catch (error) {
+    // 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.
+    saveError.value =
+      error instanceof Error
+        ? error.message
+        : (routines.value.error ?? "Could not save the Routine");
   }
 }
 
+/**
+ * Deleting takes a Routine, its schedule, its prompt and its whole run log
+ * with it, and the button sits in a row of six others. It asks first.
+ */
+function askDelete(routine: RoutineViewV1): void {
+  pendingDelete.value = routine;
+}
+
+async function confirmDelete(): Promise<void> {
+  const routine = pendingDelete.value;
+  const id = botId.value;
+  pendingDelete.value = undefined;
+  if (!routine || !id) return;
+  await routines.value.remove(id, routine.routineId);
+}
+
 async function toggleLog(routineId: string): Promise<void> {
   const id = botId.value;
   if (!id) return;
@@ -220,7 +285,12 @@ async function toggleLog(routineId: string): Promise<void> {
       <dl class="routine-card__facts">
         <div>
           <dt>Next run</dt>
-          <dd>{{ routine.nextRunAt ?? "—" }}</dd>
+          <dd>
+            <time v-if="routine.nextRunAt" :datetime="routine.nextRunAt">{{
+              moment(routine, routine.nextRunAt)
+            }}</time>
+            <template v-else>—</template>
+          </dd>
         </div>
         <div v-if="routine.trigger">
           <dt>Webhook key</dt>
@@ -234,7 +304,15 @@ async function toggleLog(routineId: string): Promise<void> {
         </div>
         <div>
           <dt>Last run</dt>
-          <dd>{{ routine.lastRunAt ?? "Never" }}</dd>
+          <dd>
+            <time
+              v-if="routine.lastRunAt"
+              :datetime="routine.lastRunAt"
+              :title="moment(routine, routine.lastRunAt)"
+              >{{ formatRelativeMomentV1(routine.lastRunAt) }}</time
+            >
+            <template v-else>Never</template>
+          </dd>
         </div>
         <div>
           <dt>Written by</dt>
@@ -289,11 +367,36 @@ async function toggleLog(routineId: string): Promise<void> {
           type="button"
           variant="danger"
           :disabled="routines.busy"
-          @click="botId && routines.remove(botId, routine.routineId)"
+          @click="askDelete(routine)"
         >
           Delete
         </UiButton>
       </div>
+      <div
+        v-if="pendingDelete?.routineId === routine.routineId"
+        class="routine-confirm"
+        role="alertdialog"
+        :aria-label="`Delete ${routine.name}?`"
+      >
+        <strong>Delete {{ routine.name }}?</strong>
+        <small>
+          Its schedule, its prompt and its whole run log go with it. This can't
+          be undone.
+        </small>
+        <div class="routine-card__actions">
+          <UiButton type="button" @click="pendingDelete = undefined">
+            Cancel
+          </UiButton>
+          <UiButton
+            type="button"
+            variant="danger"
+            :disabled="routines.busy"
+            @click="confirmDelete"
+          >
+            Delete Routine
+          </UiButton>
+        </div>
+      </div>
       <div v-if="openLog === routine.routineId" class="routine-card__log">
         <p
           v-if="(routines.runs[routine.routineId] ?? []).length === 0"
@@ -312,7 +415,13 @@ async function toggleLog(routineId: string): Promise<void> {
               :aria-expanded="openRun === entry.runId"
               @click="toggleRun(routine.routineId, entry.runId)"
             >
-              <span>{{ entry.startedAt }}</span>
+              <span
+                ><time
+                  :datetime="entry.startedAt"
+                  :title="moment(routine, entry.startedAt)"
+                  >{{ formatRelativeMomentV1(entry.startedAt) }}</time
+                ></span
+              >
               <span>{{ entry.trigger }}</span>
               <span>{{ entry.status }}</span>
             </button>
@@ -361,8 +470,20 @@ async function toggleLog(routineId: string): Promise<void> {
           v-model="form.schedule"
           maxlength="256"
           placeholder="0 9 * * *"
+          :aria-invalid="scheduleError ? 'true' : undefined"
+          :aria-describedby="
+            scheduleError ? 'routine-schedule-error' : undefined
+          "
         />
       </UiField>
+      <p
+        v-if="scheduleError"
+        id="routine-schedule-error"
+        class="routine-form__error"
+        role="alert"
+      >
+        {{ scheduleError }}
+      </p>
       <p v-else class="routines__note">
         A delivery key is minted when the Routine is saved, and shown once.
       </p>
@@ -373,6 +494,13 @@ async function toggleLog(routineId: string): Promise<void> {
           placeholder="Australia/Sydney"
         />
       </UiField>
+      <p
+        v-if="saveError && !scheduleError"
+        class="routine-form__error"
+        role="alert"
+      >
+        {{ saveError }}
+      </p>
       <div class="routine-card__actions">
         <UiButton
           type="button"
@@ -576,6 +704,33 @@ async function toggleLog(routineId: string): Promise<void> {
   font-size: var(--frock-text-xs);
 }
 
+.routine-form__error {
+  margin: 0;
+  color: var(--frock-danger-text);
+  font-size: var(--frock-text-sm);
+}
+
+.routine-confirm {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  border: 1px solid var(--frock-danger-text);
+  border-radius: var(--frock-radius-card);
+  padding: 10px;
+  background: var(--frock-surface);
+}
+
+.routine-confirm strong {
+  color: var(--frock-text);
+  font-size: var(--frock-text-sm);
+  font-weight: 600;
+}
+
+.routine-confirm small {
+  color: var(--frock-text-muted);
+  font-size: var(--frock-text-sm);
+}
+
 .routine-form__timing {
   display: flex;
   gap: 12px;