@aight-cool/aight-utils 0.1.15 → 0.1.17

package/index.ts

@@ -14,6 +14,7 @@ import { registerPushHook } from "./src/push-hook.js";
 import { registerHealth } from "./src/health.js";
 import { registerVersion } from "./src/version.js";
 import { registerGroupRpc } from "./src/groups.js";
+import { registerNotifPrefsRPC } from "./src/notif-prefs.js";
 
 const aightPlugin = {
   id: "aight-utils",
@@ -68,6 +69,7 @@ const aightPlugin = {
     registerHealth(api);
     registerVersion(api);
     registerGroupRpc(api);
+    registerNotifPrefsRPC(api);
 
     api.logger.info("[aight-utils] Plugin loaded");
   },

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "aight-utils",
   "name": "Aight App Utils",
   "description": "Aight App: Push notifications, Today items, config RPC, and agent bootstrap",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aight-cool/aight-utils",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "OpenClaw gateway plugin for Aight App: push notifications, Today items, config RPC, and agent bootstrap",
   "type": "module",
   "files": [

package/src/bootstrap.ts

@@ -256,7 +256,9 @@ export function registerBootstrap(api: OpenClawPluginApi) {
     api.logger.info(`[aight-utils] api.on type: ${typeof api.on}`);
     api.on("before_agent_start", (_event: unknown, ctx: { sessionKey?: string }) => {
       // Inject AIGHT.md context into every agent session
-      api.logger.info(`[aight-utils] Bootstrap: injecting AIGHT.md into session ${ctx?.sessionKey}`);
+      api.logger.info(
+        `[aight-utils] Bootstrap: injecting AIGHT.md into session ${ctx?.sessionKey}`,
+      );
       return { systemPrompt: AIGHT_MD };
     });
     api.logger.info("[aight-utils] Bootstrap hook registered (before_agent_start)");

package/src/notif-prefs.ts

@@ -0,0 +1,115 @@
+/**
+ * Notification Preferences — gateway-side storage for push suppression.
+ *
+ * The app syncs notification preferences here via RPC. The push hook
+ * checks these prefs before sending to the relay — if a category is
+ * muted, the push never leaves the user's machine.
+ *
+ * RPC methods:
+ *   aight.notif.setPrefs  — update preferences
+ *   aight.notif.getPrefs  — read current preferences
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { OpenClawPluginApi, GatewayRequestHandlerOptions } from "openclaw/plugin-sdk";
+
+// ── Types ──
+
+export interface NotifPrefs {
+  globalMute: boolean;
+  muteUntil: string | null;
+  agentReplies: boolean;
+  groupChat: boolean;
+  cron: boolean;
+}
+
+const DEFAULTS: NotifPrefs = {
+  globalMute: false,
+  muteUntil: null,
+  agentReplies: true,
+  groupChat: true,
+  cron: false,
+};
+
+// ── Storage ──
+
+const PREFS_DIR = path.join(os.homedir(), ".openclaw", "aight");
+const PREFS_FILE = path.join(PREFS_DIR, "notif-prefs.json");
+
+export function loadNotifPrefs(): NotifPrefs {
+  try {
+    if (!fs.existsSync(PREFS_FILE)) return { ...DEFAULTS };
+    const raw = fs.readFileSync(PREFS_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULTS, ...parsed };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+function saveNotifPrefs(prefs: NotifPrefs): void {
+  fs.mkdirSync(PREFS_DIR, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(PREFS_FILE, JSON.stringify(prefs, null, 2), "utf-8");
+}
+
+// ── Classification (matches app-side logic) ──
+
+export function classifySessionKey(sessionKey: string): "agentReplies" | "groupChat" | "cron" {
+  if (sessionKey.includes(":cron:")) return "cron";
+  if (sessionKey.includes(":group-chat:")) return "groupChat";
+  return "agentReplies";
+}
+
+/**
+ * Check if a push for this sessionKey should be sent.
+ */
+export function shouldSendPush(sessionKey: string): boolean {
+  if (!sessionKey) return true; // fail open
+
+  const prefs = loadNotifPrefs();
+
+  // Global mute
+  if (prefs.globalMute) {
+    if (!prefs.muteUntil) return false; // indefinite
+    const expiry = new Date(prefs.muteUntil).getTime();
+    if (Date.now() < expiry) return false;
+    // Mute expired — clear it
+    prefs.globalMute = false;
+    prefs.muteUntil = null;
+    saveNotifPrefs(prefs);
+  }
+
+  // Category check
+  const category = classifySessionKey(sessionKey);
+  return prefs[category];
+}
+
+// ── RPC Registration ──
+
+export function registerNotifPrefsRPC(api: OpenClawPluginApi) {
+  api.registerGatewayMethod("aight.notif.getPrefs", ({ respond }: GatewayRequestHandlerOptions) => {
+    respond(true, loadNotifPrefs());
+  });
+
+  api.registerGatewayMethod(
+    "aight.notif.setPrefs",
+    ({ params, respond }: GatewayRequestHandlerOptions) => {
+      const update = (params ?? {}) as Partial<NotifPrefs>;
+      const current = loadNotifPrefs();
+
+      if (typeof update.globalMute === "boolean") current.globalMute = update.globalMute;
+      if (typeof update.agentReplies === "boolean") current.agentReplies = update.agentReplies;
+      if (typeof update.groupChat === "boolean") current.groupChat = update.groupChat;
+      if (typeof update.cron === "boolean") current.cron = update.cron;
+      if (update.muteUntil !== undefined) current.muteUntil = update.muteUntil;
+
+      saveNotifPrefs(current);
+      api.logger.info(`[aight-utils] Notification prefs updated: ${JSON.stringify(current)}`);
+      respond(true, current);
+    },
+  );
+
+  api.logger.info("[aight-utils] Notification prefs RPC registered");
+}

package/src/push-hook.ts

@@ -4,8 +4,9 @@
 
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { getPluginConfig } from "./config.js";
-import { sendPush, loadTokens } from "./push.js";
+import { sendPush, loadTokens, unregisterToken } from "./push.js";
 import { loadGroupName } from "./groups.js";
+import { shouldSendPush } from "./notif-prefs.js";
 
 export function registerPushHook(api: OpenClawPluginApi) {
   try {
@@ -106,10 +107,18 @@ export function registerPushHook(api: OpenClawPluginApi) {
 
       const cleanBody = preview.trim().replace(/\n+/g, " ").trim();
 
+      // ── Notification preference gate ──
+      // Check if this category is muted — if so, don't send the push at all.
+      const sk_ = ctx.sessionKey ?? "";
+      if (!shouldSendPush(sk_)) {
+        api.logger.info(`[aight-utils] Push suppressed by notification prefs: ${sk_}`);
+        return;
+      }
+
       for (const device of tokens) {
         if (!device.sendKey) continue;
         try {
-          await sendPush(
+          const pushResult = await sendPush(
             device.deviceId,
             {
               title: pushTitle.trim(),
@@ -119,6 +128,23 @@ export function registerPushHook(api: OpenClawPluginApi) {
             },
             freshConfig,
           );
+          api.logger.info(
+            `[aight-utils] Push sent: session=${ctx.sessionKey} device=${device.deviceId} ok=${pushResult.ok}${pushResult.error ? ` error=${pushResult.error}` : ""}`,
+          );
+
+          // Auto-prune stale tokens — if the relay rejects the token, remove it
+          if (!pushResult.ok && pushResult.error) {
+            const err = pushResult.error.toLowerCase();
+            if (
+              err.includes("baddevicetoken") ||
+              err.includes("unregistered") ||
+              err.includes("devicetokennotfortopic") ||
+              err.includes("expired")
+            ) {
+              api.logger.info(`[aight-utils] Pruning stale device token: ${device.deviceId}`);
+              unregisterToken(device.deviceId);
+            }
+          }
         } catch (err) {
           api.logger.warn(
             `[aight-utils] Push failed: ${err instanceof Error ? err.message : String(err)}`,