niahere 0.5.0 → 0.5.2

package/src/mcp/tools/send.ts

@@ -5,6 +5,7 @@ import { Message, Session } from "../../db/models";
 import { getConfig } from "../../utils/config";
 import { getChannel } from "../../channels/registry";
 import { log } from "../../utils/log";
+import { errMsg, ignore } from "../../utils/errors";
 import type { Recipient } from "../../types";
 import type { McpSourceContext } from "../index";
 
@@ -168,7 +169,7 @@ export async function sendMessage(
     let media: { data: Uint8Array; mimeType: string; filename: string } | undefined;
     if (mediaPath) {
       if (!existsSync(mediaPath)) {
-        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
         return `Failed to send: file not found: ${mediaPath}`;
       }
       const buf = readFileSync(mediaPath);
@@ -190,13 +191,13 @@ export async function sendMessage(
 
     // Mark as sent
     if (messageId) {
-      await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+      await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
     }
 
     return mediaPath ? "Message with media sent." : "Message sent.";
   } catch (err) {
-    if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
-    const errText = err instanceof Error ? err.message : String(err);
+    if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
+    const errText = errMsg(err);
     return `Failed to send: ${errText}`;
   }
 }

package/src/utils/errors.ts

@@ -1,4 +1,30 @@
+import { log } from "./log";
+
 /** Extract a human-readable message from an unknown error value. */
 export function errMsg(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }
+
+/** Normalize an unknown to an Error, keeping the original when it already is one
+ *  so its stack survives a rethrow. */
+export function asError(err: unknown): Error {
+  return err instanceof Error ? err : new Error(errMsg(err));
+}
+
+type Report = (context: string, err: string) => void;
+
+const report: Report = (context, err) => log.debug({ err }, `ignored failure: ${context}`);
+
+/**
+ * Await best-effort work whose failure must not stop the caller — cleanup,
+ * bookkeeping, teardown. Use instead of `.catch(() => {})`: the outcome is the
+ * same, but a failure leaves a trace rather than vanishing, so a persistent one
+ * is discoverable instead of silent.
+ */
+export async function ignore(work: Promise<unknown>, context: string, onError: Report = report): Promise<void> {
+  try {
+    await work;
+  } catch (err) {
+    onError(context, errMsg(err));
+  }
+}