@pi-unipi/notify 0.1.7 → 0.1.9

package/commands.ts

@@ -13,6 +13,7 @@ import { TelegramSetupOverlay } from "./tui/telegram-setup.js";
 import { NtfySetupOverlay } from "./tui/ntfy-setup.js";
 import { RecapModelSelectorOverlay } from "./tui/recap-model-selector.js";
 import { loadConfig } from "./settings.js";
+import { loadNtfyConfig } from "./ntfy-config.js";
 import { sendNativeNotification } from "./platforms/native.js";
 import { sendGotifyNotification } from "./platforms/gotify.js";
 import { sendTelegramNotification } from "./platforms/telegram.js";
@@ -310,16 +311,17 @@ export function registerNotifyCommands(pi: ExtensionAPI): void {
           }
         }
 
-        // ntfy
-        if (config.ntfy.enabled && config.ntfy.serverUrl && config.ntfy.topic) {
+        // ntfy — resolved from project/global ntfy.json
+        const ntfyConfig = loadNtfyConfig(process.cwd());
+        if (ntfyConfig.enabled && ntfyConfig.serverUrl && ntfyConfig.topic) {
           try {
             await sendNtfyNotification(
-              config.ntfy.serverUrl,
-              config.ntfy.topic,
+              ntfyConfig.serverUrl,
+              ntfyConfig.topic,
               title,
               message,
-              config.ntfy.priority,
-              config.ntfy.token
+              ntfyConfig.priority,
+              ntfyConfig.token
             );
             results.push("✓ ntfy: sent");
           } catch (err) {

package/events.ts

@@ -8,6 +8,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { UNIPI_EVENTS, emitEvent } from "@pi-unipi/core";
 import type { NotifyConfig, NotifyPlatform, NotifyDispatchResult } from "./types.js";
+import { loadNtfyConfig } from "./ntfy-config.js";
 import { sendNativeNotification } from "./platforms/native.js";
 import { sendGotifyNotification } from "./platforms/gotify.js";
 import { sendTelegramNotification } from "./platforms/telegram.js";
@@ -47,7 +48,8 @@ export const BUILTIN_EVENTS: Record<
  */
 export function registerEventListeners(
   pi: ExtensionAPI,
-  config: NotifyConfig
+  config: NotifyConfig,
+  cwd: string
 ): void {
   // Register built-in events (except agent_end which has custom logic)
   for (const [eventKey, def] of Object.entries(BUILTIN_EVENTS)) {
@@ -56,10 +58,15 @@ export function registerEventListeners(
     const eventConfig = config.events[eventKey];
     if (!eventConfig?.enabled) continue;
 
-    const handler = async (payload: unknown) => {
+    const handler = (payload: unknown) => {
       const title = `Pi — ${def.label}`;
       const message = buildEventMessage(eventKey, payload);
-      await dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config);
+      // Fire-and-forget: don't block the event emitter
+      dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config, cwd).catch(
+        () => {
+          // Silently ignore — background notification failure is non-blocking.
+        }
+      );
     };
 
     (pi as any).on(def.hook, handler);
@@ -68,43 +75,48 @@ export function registerEventListeners(
   // agent_end — custom handler with session name and recap support
   const agentEndConfig = config.events["agent_end"];
   if (agentEndConfig?.enabled) {
-    const handler = async (payload: unknown) => {
+    const handler = (payload: unknown) => {
+      // Fire-and-forget: build message and dispatch in background,
+      // don't block agent_end from completing
       const sessionName = pi.getSessionName?.();
       const title = `Pi — ${BUILTIN_EVENTS.agent_end.label}`;
-      let message: string;
 
       if (config.recap.enabled) {
-        // Recap mode: summarize last assistant message
+        // Recap mode: summarize asynchronously, then dispatch
         const lastText = extractLastAssistantText(payload);
         if (lastText && sessionCtx?.modelRegistry) {
           const provider = extractProvider(config.recap.model);
           const modelId = extractModelId(config.recap.model);
           const model = sessionCtx.modelRegistry.find(provider, modelId);
           if (model) {
-            try {
-              const apiKeyResult = await sessionCtx.modelRegistry.getApiKeyAndHeaders(model);
-              const apiKey = apiKeyResult.ok ? (apiKeyResult as { apiKey?: string }).apiKey : undefined;
-              if (apiKey) {
-                const recap = await summarizeLastMessage(lastText, apiKey, model.baseUrl, model.api, modelId);
-                message = sessionName ? `${sessionName}: ${recap}` : recap;
-              } else {
-                message = buildAgentEndMessage(sessionName);
-              }
-            } catch {
-              message = buildAgentEndMessage(sessionName);
-            }
-          } else {
-            message = buildAgentEndMessage(sessionName);
+            sessionCtx.modelRegistry.getApiKeyAndHeaders(model)
+              .then((apiKeyResult) => {
+                const apiKey = apiKeyResult.ok ? (apiKeyResult as { apiKey?: string }).apiKey : undefined;
+                if (apiKey) {
+                  return summarizeLastMessage(lastText, apiKey, model.baseUrl, model.api, modelId)
+                    .then((recap) => sessionName ? `${sessionName}: ${recap}` : recap);
+                }
+                return buildAgentEndMessage(sessionName);
+              })
+              .catch(() => buildAgentEndMessage(sessionName))
+              .then((message) =>
+                dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config, cwd)
+              )
+              .catch(() => {
+                // Silently ignore — background agent_end notification failure is non-blocking.
+              });
+            return;
           }
-        } else {
-          message = buildAgentEndMessage(sessionName);
         }
-      } else {
-        // No recap: use session name based message
-        message = buildAgentEndMessage(sessionName);
       }
 
-      await dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config);
+      // No recap or recap unavailable: dispatch immediately in background
+      const message = buildAgentEndMessage(sessionName);
+      dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config, cwd).catch(
+        () => {
+          // Silently ignore — background agent_end notification failure is non-blocking.
+        }
+      );
     };
 
     (pi as any).on("agent_end", handler);
@@ -122,12 +134,12 @@ export function registerEventListeners(
 }
 
 /** Get all platforms that are currently enabled in config */
-function getEnabledPlatforms(config: NotifyConfig): NotifyPlatform[] {
+function getEnabledPlatforms(config: NotifyConfig, ntfyEnabled: boolean): NotifyPlatform[] {
   const enabled: NotifyPlatform[] = [];
   if (config.native.enabled) enabled.push("native");
   if (config.gotify.enabled) enabled.push("gotify");
   if (config.telegram.enabled) enabled.push("telegram");
-  if (config.ntfy.enabled) enabled.push("ntfy");
+  if (ntfyEnabled) enabled.push("ntfy");
   return enabled;
 }
 
@@ -144,34 +156,35 @@ export async function dispatchNotification(
   message: string,
   eventPlatforms: NotifyPlatform[],
   eventType: string,
-  config: NotifyConfig
+  config: NotifyConfig,
+  cwd: string
 ): Promise<NotifyDispatchResult> {
+  // Resolve ntfy config from project/global ntfy.json
+  const ntfyConfig = loadNtfyConfig(cwd);
+
   // Resolve platforms: event-specific → all enabled → global defaults
   const platforms =
     eventPlatforms.length > 0
       ? eventPlatforms
-      : getEnabledPlatforms(config).length > 0
-        ? getEnabledPlatforms(config)
+      : getEnabledPlatforms(config, ntfyConfig.enabled).length > 0
+        ? getEnabledPlatforms(config, ntfyConfig.enabled)
         : config.defaultPlatforms;
 
   const enabledPlatforms = platforms.filter((p) => {
     if (p === "native") return config.native.enabled;
     if (p === "gotify") return config.gotify.enabled;
     if (p === "telegram") return config.telegram.enabled;
-    if (p === "ntfy") return config.ntfy.enabled;
+    if (p === "ntfy") return ntfyConfig.enabled;
     return false;
   });
 
   const results = await Promise.all(
     enabledPlatforms.map(async (platform) => {
       try {
-        await sendToPlatform(platform, title, message, config);
+        await sendToPlatform(platform, title, message, config, cwd);
         return { platform, success: true };
       } catch (err) {
-        console.error(
-          `[notify] Failed to send via ${platform}:`,
-          err instanceof Error ? err.message : err
-        );
+        // Silently ignore — platform send failure is tracked in results.
         return {
           platform,
           success: false,
@@ -199,7 +212,8 @@ async function sendToPlatform(
   platform: NotifyPlatform,
   title: string,
   message: string,
-  config: NotifyConfig
+  config: NotifyConfig,
+  cwd: string
 ): Promise<void> {
   switch (platform) {
     case "native":
@@ -230,19 +244,22 @@ async function sendToPlatform(
         message
       );
       break;
-    case "ntfy":
-      if (!config.ntfy.serverUrl || !config.ntfy.topic) {
+    case "ntfy": {
+      const ntfyConfig = loadNtfyConfig(cwd);
+      if (!ntfyConfig.enabled) return;
+      if (!ntfyConfig.serverUrl || !ntfyConfig.topic) {
         throw new Error("ntfy: serverUrl and topic are required");
       }
       await sendNtfyNotification(
-        config.ntfy.serverUrl,
-        config.ntfy.topic,
+        ntfyConfig.serverUrl,
+        ntfyConfig.topic,
         title,
         message,
-        config.ntfy.priority,
-        config.ntfy.token
+        ntfyConfig.priority,
+        ntfyConfig.token
       );
       break;
+    }
   }
 }
 

package/index.ts

@@ -42,8 +42,9 @@ export default function (pi: ExtensionAPI) {
   // Session lifecycle — register events and announce module
   pi.on("session_start", async (_event, ctx) => {
     setSessionContext(ctx);
+    const cwd = process.cwd();
     const config = loadConfig();
-    registerEventListeners(pi, config);
+    registerEventListeners(pi, config, cwd);
 
     emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
       name: MODULES.NOTIFY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "license": "MIT",

package/skills/configure-notify/SKILL.md

@@ -16,9 +16,13 @@ Help users configure the `@pi-unipi/notify` notification system.
 - User wants to change which events trigger notifications
 - User asks about notification settings
 
-## Config location
+## Config locations
 
-`~/.unipi/config/notify/config.json`
+**Main config (platforms + events):** `~/.unipi/config/notify/config.json`
+
+**ntfy config (dedicated file):**
+- Global: `~/.unipi/config/notify/ntfy.json`
+- Project: `<project>/.unipi/config/notify/ntfy.json`
 
 ## Config structure
 
@@ -54,7 +58,8 @@ Help users configure the `@pi-unipi/notify` notification system.
     "topic": null,
     "token": null,
     "priority": 3
-  }
+  },
+  "NOTE": "ntfy section is legacy — migrated to ntfy.json on first run"
 }
 ```
 
@@ -92,9 +97,41 @@ Requires:
 - `priority` — 1-5 (default: 3)
 
 **Setup options:**
-1. **Interactive overlay:** Run `/unipi:notify-set-ntfy` for guided setup with connection test
-2. **Manual config:** Edit `config.json` directly with the fields above
-3. **Agent can write config:** Read the current config, merge changes, write back
+1. **Interactive overlay:** Run `/unipi:notify-set-ntfy` for guided setup with scope selection and connection test
+2. **Manual config:** Edit `ntfy.json` directly (see Project-Level ntfy Config below)
+3. **Agent can write config:** Read the current ntfy.json, merge changes, write back
+
+### Project-Level ntfy Config
+
+ntfy uses dedicated `ntfy.json` files at both global and project scope, with full override semantics.
+
+**File locations:**
+- Global: `~/.unipi/config/notify/ntfy.json` (all projects)
+- Project: `<project>/.unipi/config/notify/ntfy.json` (this project only)
+
+**Resolution order (at dispatch time):**
+1. Project `ntfy.json` exists → use it (full override)
+2. No project config → use global `ntfy.json`
+3. Neither exists → ntfy is effectively disabled
+
+**ntfy.json shape:**
+```json
+{
+  "enabled": true,
+  "serverUrl": "https://ntfy.sh",
+  "topic": "my-project-alerts",
+  "token": null,
+  "priority": 3
+}
+```
+
+**Scope selection in wizard:** When running `/unipi:notify-set-ntfy`, the wizard now asks where to save the config (Global or Project). Re-running the wizard pre-selects the current scope and pre-fills existing values.
+
+**Settings overlay:** The ntfy line in `/unipi:notify-settings` shows topic, priority, and scope label (`[project]`, `[global]`, or "Not configured").
+
+**Migration:** On first run, if `config.json` has ntfy settings and `ntfy.json` doesn't exist, settings are automatically migrated to `ntfy.json`. The legacy `config.json` ntfy section is left untouched for backward compatibility.
+
+**Manual config:** Edit the appropriate `ntfy.json` file directly with the fields above.
 
 ## Commands
 

package/tools.ts

@@ -9,7 +9,6 @@ import { Type } from "@sinclair/typebox";
 import { NOTIFY_TOOLS } from "@pi-unipi/core";
 import { loadConfig } from "./settings.js";
 import { dispatchNotification } from "./events.js";
-import type { NotifyDispatchResult } from "./types.js";
 
 /** Schema for notify_user tool parameters */
 const NotifyUserSchema = Type.Object({
@@ -43,7 +42,7 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
       "Send a notification to the user's configured platforms (native OS, Gotify, Telegram, ntfy). " +
       "Use for critical errors, completion of long-running tasks, or when the user explicitly asked to be notified.",
     parameters: NotifyUserSchema,
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx: ExtensionContext) {
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx: ExtensionContext) {
       const {
         message,
         title,
@@ -64,32 +63,28 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
       // Resolve platforms — use params.platforms or global defaults
       const notifPlatforms = platforms || config.defaultPlatforms;
 
-      // Dispatch notification
-      const result: NotifyDispatchResult = await dispatchNotification(
+      // Fire-and-forget: dispatch in background so the tool doesn't block the agent
+      const cwd = process.cwd();
+      dispatchNotification(
         pi,
         notifTitle,
         message,
         notifPlatforms,
         "agent_tool",
-        config
-      );
-
-      // Format result
-      const platformResults = result.results.map(
-        (r) => `${r.platform}: ${r.success ? "✓ sent" : `✗ ${r.error || "failed"}`}`
-      );
+        config,
+        cwd
+      ).catch(() => {
+        // Silently ignore — background dispatch failure is non-blocking.
+      });
 
       return {
         content: [
           {
             type: "text" as const,
-            text: `Notification sent to ${result.results.length} platform(s):\n${platformResults.join("\n")}`,
+            text: `Notification sending to ${notifPlatforms.length} platform(s): ${notifPlatforms.join(", ")}`,
           },
         ],
-        details: {
-          platforms: result.results.map((r) => r.platform),
-          allSuccess: result.allSuccess,
-        },
+        details: { platforms: notifPlatforms },
       };
     },
   });

package/tui/ntfy-setup.ts

@@ -10,10 +10,11 @@ import type { Component } from "@mariozechner/pi-tui";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { sendNtfyNotification } from "../platforms/ntfy.js";
-import { updateConfig, loadConfig } from "../settings.js";
+import { loadNtfyConfig, saveNtfyConfig, getNtfyConfigScope } from "../ntfy-config.js";
 
 type SetupPhase =
   | "instructions"
+  | "scope"
   | "server-url"
   | "topic"
   | "token"
@@ -28,6 +29,8 @@ type SetupPhase =
  */
 export class NtfySetupOverlay implements Component {
   private phase: SetupPhase = "instructions";
+  private scope: "global" | "project" = "global";
+  private scopeIndex = 0; // 0 = global, 1 = project
   private serverUrl = "";
   private topic = "";
   private token = "";
@@ -41,12 +44,18 @@ export class NtfySetupOverlay implements Component {
   private theme: Theme | null = null;
 
   constructor() {
-    // Pre-fill from existing config if available
-    const config = loadConfig();
-    if (config.ntfy.serverUrl) this.serverUrl = config.ntfy.serverUrl;
-    if (config.ntfy.topic) this.topic = config.ntfy.topic;
-    if (config.ntfy.token) this.token = config.ntfy.token;
-    if (config.ntfy.priority) this.priority = String(config.ntfy.priority);
+    // Determine current scope and pre-fill from resolved config
+    const cwd = process.cwd();
+    const existingScope = getNtfyConfigScope(cwd);
+    if (existingScope !== "none") {
+      this.scope = existingScope;
+      this.scopeIndex = existingScope === "project" ? 1 : 0;
+    }
+    const config = loadNtfyConfig(cwd);
+    if (config.serverUrl) this.serverUrl = config.serverUrl;
+    if (config.topic) this.topic = config.topic;
+    if (config.token) this.token = config.token;
+    if (config.priority) this.priority = String(config.priority);
   }
 
   setTheme(theme: Theme): void {
@@ -59,6 +68,21 @@ export class NtfySetupOverlay implements Component {
     switch (this.phase) {
       case "instructions":
         if (data === "\r" || data === " ") {
+          this.phase = "scope";
+        } else if (data === "\x1b") {
+          this.onClose?.();
+        }
+        break;
+
+      case "scope":
+        if (data === "\x1b[A" || data === "k") {
+          // Up
+          this.scopeIndex = Math.max(0, this.scopeIndex - 1);
+        } else if (data === "\x1b[B" || data === "j") {
+          // Down
+          this.scopeIndex = Math.min(1, this.scopeIndex + 1);
+        } else if (data === "\r" || data === " ") {
+          this.scope = this.scopeIndex === 1 ? "project" : "global";
           this.phase = this.serverUrl ? "topic" : "server-url";
         } else if (data === "\x1b") {
           this.onClose?.();
@@ -206,14 +230,13 @@ export class NtfySetupOverlay implements Component {
   }
 
   private saveConfig(): void {
-    updateConfig({
-      ntfy: {
-        enabled: true,
-        serverUrl: this.serverUrl.replace(/\/$/, ""),
-        topic: this.topic,
-        token: this.token || undefined,
-        priority: parseInt(this.priority, 10) || 3,
-      },
+    const cwd = process.cwd();
+    saveNtfyConfig(this.scope, cwd, {
+      enabled: true,
+      serverUrl: this.serverUrl.replace(/\/$/, ""),
+      topic: this.topic,
+      token: this.token || undefined,
+      priority: parseInt(this.priority, 10) || 3,
     });
   }
 
@@ -336,6 +359,36 @@ export class NtfySetupOverlay implements Component {
         );
         break;
 
+      case "scope": {
+        lines.push(
+          this.frameLine(
+            this.fg("dim", "Where should this config be saved?"),
+            innerWidth
+          )
+        );
+        lines.push(this.frameLine("", innerWidth));
+        const options = ["Global (all projects)", "Project (this project only)"];
+        for (let i = 0; i < options.length; i++) {
+          const isSelected = i === this.scopeIndex;
+          const label = isSelected ? this.bold(options[i]) : this.fg("dim", options[i]);
+          lines.push(
+            this.frameLine(
+              `  ${isSelected ? this.fg("accent", "▸") : " "} ${label}`,
+              innerWidth
+            )
+          );
+        }
+        lines.push(this.frameLine("", innerWidth));
+        lines.push(this.ruleLine(innerWidth));
+        lines.push(
+          this.frameLine(
+            this.fg("dim", "↑↓ select · Enter confirm · Esc cancel"),
+            innerWidth
+          )
+        );
+        break;
+      }
+
       case "server-url":
         lines.push(
           this.frameLine(

package/tui/settings-overlay.ts

@@ -13,7 +13,8 @@ import {
   saveConfig,
   validateConfig,
 } from "../settings.js";
-import type { NotifyConfig } from "../types.js";
+import { loadNtfyConfig, saveNtfyConfig, getNtfyConfigScope } from "../ntfy-config.js";
+import type { NotifyConfig, NtfyConfig } from "../types.js";
 
 /** Section types */
 type Section = "platforms" | "events" | "recap";
@@ -23,6 +24,8 @@ type Section = "platforms" | "events" | "recap";
  */
 export class NotifySettingsOverlay implements Component {
   private config: NotifyConfig;
+  private ntfyConfig: NtfyConfig;
+  private ntfyScope: "project" | "global" | "none";
   private section: Section = "platforms";
   private selectedIndex = 0;
   private error: string | null = null;
@@ -35,6 +38,9 @@ export class NotifySettingsOverlay implements Component {
 
   constructor() {
     this.config = loadConfig();
+    const cwd = process.cwd();
+    this.ntfyConfig = loadNtfyConfig(cwd);
+    this.ntfyScope = getNtfyConfigScope(cwd);
   }
 
   setTheme(theme: Theme): void {
@@ -93,7 +99,10 @@ export class NotifySettingsOverlay implements Component {
         "ntfy",
       ];
       const key = platforms[this.selectedIndex];
-      if (key) {
+      if (key === "ntfy") {
+        // ntfy toggle updates the resolved ntfy config
+        this.ntfyConfig.enabled = !this.ntfyConfig.enabled;
+      } else if (key) {
         this.config[key].enabled = !this.config[key].enabled;
       }
     } else if (this.section === "recap") {
@@ -115,6 +124,10 @@ export class NotifySettingsOverlay implements Component {
     }
     this.error = null;
     saveConfig(this.config);
+    // Save ntfy config to its own file if scope is known
+    if (this.ntfyScope !== "none") {
+      saveNtfyConfig(this.ntfyScope, process.cwd(), this.ntfyConfig);
+    }
     this.saved = true;
     setTimeout(() => this.onClose?.(), 500);
   }
@@ -237,9 +250,9 @@ export class NotifySettingsOverlay implements Component {
       {
         key: "ntfy",
         label: "ntfy",
-        detail: this.config.ntfy.serverUrl
-          ? `Server: ${this.config.ntfy.serverUrl}`
-          : "Self-hosted push service",
+        detail: this.ntfyScope !== "none"
+          ? `Topic: ${this.ntfyConfig.topic ?? "—"} · P${this.ntfyConfig.priority} · [${this.ntfyScope}]`
+          : "Not configured",
       },
     ];
 
@@ -248,7 +261,9 @@ export class NotifySettingsOverlay implements Component {
       const isSelected = i === this.selectedIndex;
       const toggleOn = this.fg("success", "●");
       const toggleOff = this.fg("dim", "○");
-      const toggle = this.config[p.key].enabled ? toggleOn : toggleOff;
+      // ntfy enabled state comes from resolved ntfy.json, not config.json
+      const isEnabled = p.key === "ntfy" ? this.ntfyConfig.enabled : this.config[p.key].enabled;
+      const toggle = isEnabled ? toggleOn : toggleOff;
       const label = isSelected ? this.bold(p.label) : this.fg("dim", p.label);
 
       lines.push(