niahere 0.2.79 → 0.2.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.79",
+  "version": "0.2.81",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/channels/slack.ts

@@ -53,6 +53,16 @@ class SlackChannel implements Channel {
     });
   }
 
+  async sendMediaToThread(channelId: string, data: Buffer, mimeType: string, filename?: string, threadTs?: string): Promise<void> {
+    if (!this.app) throw new Error("Slack not started");
+    await this.app.client.filesUploadV2({
+      channel_id: channelId,
+      file: data,
+      filename: filename || `file.${mimeType.split("/")[1] || "bin"}`,
+      ...(threadTs ? { thread_ts: threadTs } : {}),
+    } as any);
+  }
+
   async start(): Promise<void> {
     const config = getConfig();
     const botToken = config.channels.slack.bot_token!;
@@ -308,6 +318,11 @@ class SlackChannel implements Channel {
       return ext && /^[a-zA-Z0-9]{1,16}$/.test(ext) ? ext : "bin";
     }
 
+    function cacheExtension(filename: string | undefined, mime: string, attType: AttachmentType): string {
+      if (attType === "image" && mime !== "image/gif") return "jpg";
+      return safeExtension(filename);
+    }
+
     async function extractSlackAttachments(files: any[], scope: string): Promise<Attachment[]> {
       const attachments: Attachment[] = [];
       const scopedAttachDir = cacheDirForScope(scope);
@@ -327,7 +342,7 @@ class SlackChannel implements Channel {
 
         // Check disk (survives daemon restarts) — scoped by Slack room/thread.
         const hash = urlHash(file.url_private_download);
-        const ext = safeExtension(file.name);
+        const ext = cacheExtension(file.name, mime, attType);
         const diskPath = join(scopedAttachDir, `${hash}.${ext}`);
         const metaPath = join(scopedAttachDir, `${hash}.meta.json`);
         if (existsSync(diskPath) && existsSync(metaPath)) {

package/src/channels/telegram.ts

@@ -17,6 +17,11 @@ function safeExtension(filename?: string): string {
   return ext && /^[a-zA-Z0-9]{1,16}$/.test(ext) ? ext : "bin";
 }
 
+function cacheExtension(filename: string | undefined, mimeType: string): string {
+  if (mimeType === "image/jpeg") return "jpg";
+  return safeExtension(filename);
+}
+
 class TelegramChannel implements Channel {
   name = "telegram";
   private bot: Bot | null = null;
@@ -52,11 +57,11 @@ class TelegramChannel implements Channel {
     return Buffer.from(await resp.arrayBuffer());
   }
 
-  private cacheAttachment(chatId: number, roomIndex: number, data: Buffer, filename?: string): string {
+  private cacheAttachment(chatId: number, roomIndex: number, data: Buffer, mimeType: string, filename?: string): string {
     const scope = `telegram-${chatId}-${roomIndex}`;
     const dir = join(getNiaHome(), "tmp", "attachments", scope);
     mkdirSync(dir, { recursive: true });
-    const ext = safeExtension(filename);
+    const ext = cacheExtension(filename, mimeType);
     const hash = createHash("sha256").update(data).digest("hex").slice(0, 16);
     const path = join(dir, `${hash}.${ext}`);
     writeFileSync(path, data);
@@ -257,7 +262,7 @@ class TelegramChannel implements Channel {
             data = prepared.data;
             finalMime = prepared.mimeType;
           }
-          const sourcePath = self.cacheAttachment(ctx.chatId, state.roomIndex, data, doc.file_name);
+          const sourcePath = self.cacheAttachment(ctx.chatId, state.roomIndex, data, finalMime, doc.file_name);
           const attachment: Attachment = { type: attType, data, mimeType: finalMime, filename: doc.file_name, sourcePath };
           const caption = ctx.message.caption || (attType === "image" ? "What's in this image?" : "Here's a file.");
           await processMessage(ctx, state, caption, [attachment]);

package/src/chat/engine.ts

@@ -29,6 +29,8 @@ const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 const LONG_RUNNING_WARN = 30 * 60 * 1000; // 30 minutes
 const MAX_SEND_RETRIES = 2;
 const SEND_RETRY_DELAYS = [3_000, 8_000];
+const GENERIC_CHAT_ERROR =
+  "Claude/Anthropic returned an error without details. This is usually temporary; please try again shortly.";
 
 interface SDKUserMessage {
   type: "user";
@@ -93,6 +95,15 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
   return blocks as MessageParam["content"];
 }
 
+/** Convert SDK error text into a channel-safe chat response. */
+export function formatChatError(rawError: string | null | undefined): string {
+  const error = rawError?.trim();
+  if (!error || error.toLowerCase() === "unknown error") {
+    return GENERIC_CHAT_ERROR;
+  }
+  return `[error] ${error}`;
+}
+
 /**
  * Push-based async iterable for streaming user messages to the SDK.
  * Keeps the query subprocess alive between messages.
@@ -505,7 +516,18 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                 retryPending.onActivity?.("retrying after API error...");
                 stream!.push(retryPending.userMessage);
               } else {
-                const errorText = `[error] ${rawError}`;
+                const errorText = formatChatError(rawError);
+                log.error(
+                  {
+                    room,
+                    error: rawError,
+                    errors,
+                    subtype: msg.subtype,
+                    terminal_reason: msg.terminal_reason,
+                    session_id: msg.session_id,
+                  },
+                  "chat send failed with SDK result error",
+                );
                 await ActiveEngine.unregister(room);
                 clearLongRunningTimer();
                 pending.resolve({ result: errorText, costUsd: 0, turns: 0 });

package/src/core/daemon.ts

@@ -57,7 +57,10 @@ export function stopDaemon(opts: { force?: boolean } = {}): boolean {
 
   // Kill all daemon processes — pidfile PID plus any orphans.
   const killed = killAllDaemons(pidfilePid);
-  if (killed === 0 && pidfilePid === null) return false;
+  if (killed === 0 && pidfilePid === null) {
+    if (opts.force) clearForceShutdownRequest();
+    return false;
+  }
 
   // Wait for processes to finish (up to 5 min for active engines, then SIGKILL)
   waitForExit(opts.force ? 30_000 : 310_000);

package/src/mcp/tools.ts

@@ -296,7 +296,9 @@ export async function sendMessage(text: string, channelName?: string, mediaPath?
       const mimeType = guessMime(mediaPath);
       const filename = basename(mediaPath);
 
-      if (channel?.sendMedia) {
+      if (useThread && channel?.sendMediaToThread) {
+        await channel.sendMediaToThread(sourceCtx!.slackChannelId!, data, mimeType, filename, sourceCtx!.slackThreadTs);
+      } else if (channel?.sendMedia) {
         await channel.sendMedia(data, mimeType, filename);
       } else {
         await sendMediaDirect(channelTarget, data, mimeType, filename);

package/src/types/channel.ts

@@ -4,6 +4,8 @@ export interface Channel {
   stop(): Promise<void>;
   sendMessage?(text: string): Promise<void>;
   sendMedia?(data: Buffer, mimeType: string, filename?: string): Promise<void>;
+  /** Send media to a specific channel/thread when the channel supports it. */
+  sendMediaToThread?(channelId: string, data: Buffer, mimeType: string, filename?: string, threadTs?: string): Promise<void>;
   /** Send a message to a specific channel/thread (e.g. reply back to a Slack thread). */
   sendToThread?(channelId: string, text: string, threadTs?: string): Promise<void>;
 }