niahere 0.2.74 → 0.2.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.74",
+  "version": "0.2.76",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {
@@ -44,7 +44,7 @@
   "license": "MIT",
   "private": false,
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.97",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.119",
     "@anthropic-ai/sdk": "^0.88.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@slack/bolt": "^4.6.0",

package/src/channels/slack.ts

@@ -259,8 +259,8 @@ class SlackChannel implements Channel {
     });
 
     // Disk-backed file cache: download once, read from disk on subsequent requests
-    const attachDir = join(getNiaHome(), "tmp", "attachments");
-    mkdirSync(attachDir, { recursive: true });
+    const attachRoot = join(getNiaHome(), "tmp", "attachments");
+    mkdirSync(attachRoot, { recursive: true });
 
     interface CachedFile {
       path: string;
@@ -292,26 +292,39 @@ class SlackChannel implements Channel {
       return Buffer.from(await resp.arrayBuffer());
     }
 
-    async function extractSlackAttachments(files: any[]): Promise<Attachment[]> {
+    function cacheDirForScope(scope: string): string {
+      const safeScope = scope.replace(/[^a-zA-Z0-9._-]/g, "_");
+      const dir = join(attachRoot, safeScope);
+      mkdirSync(dir, { recursive: true });
+      return dir;
+    }
+
+    function cacheKey(scope: string, url: string): string {
+      return `${scope}:${url}`;
+    }
+
+    async function extractSlackAttachments(files: any[], scope: string): Promise<Attachment[]> {
       const attachments: Attachment[] = [];
-      for (const file of files.slice(0, 5)) {
+      const scopedAttachDir = cacheDirForScope(scope);
+      for (const file of files) {
         const mime = file.mimetype || "application/octet-stream";
         const attType = classifyMime(mime);
         if (!attType) continue;
         if (!file.url_private_download) continue;
 
         // Check in-memory index first
-        const cached = fileIndex.get(file.url_private_download);
+        const indexedKey = cacheKey(scope, file.url_private_download);
+        const cached = fileIndex.get(indexedKey);
         if (cached && existsSync(cached.path)) {
           attachments.push(loadCached(cached));
           continue;
         }
 
-        // Check disk (survives daemon restarts) — keyed by URL hash only (global dedup)
+        // Check disk (survives daemon restarts) — scoped by Slack room/thread.
         const hash = urlHash(file.url_private_download);
         const ext = file.name?.split(".").pop() || "bin";
-        const diskPath = join(attachDir, `${hash}.${ext}`);
-        const metaPath = join(attachDir, `${hash}.meta.json`);
+        const diskPath = join(scopedAttachDir, `${hash}.${ext}`);
+        const metaPath = join(scopedAttachDir, `${hash}.meta.json`);
         if (existsSync(diskPath) && existsSync(metaPath)) {
           try {
             const meta = JSON.parse(readFileSync(metaPath, "utf8"));
@@ -321,7 +334,7 @@ class SlackChannel implements Channel {
               mimeType: meta.mimeType || mime,
               filename: meta.filename || file.name,
             };
-            fileIndex.set(file.url_private_download, entry);
+            fileIndex.set(indexedKey, entry);
             attachments.push(loadCached(entry));
             continue;
           } catch {
@@ -348,7 +361,7 @@ class SlackChannel implements Channel {
           writeFileSync(diskPath, finalData);
           writeFileSync(metaPath, JSON.stringify({ type: attType, mimeType: finalMime, filename: file.name }));
           const entry: CachedFile = { path: diskPath, type: attType, mimeType: finalMime, filename: file.name };
-          fileIndex.set(file.url_private_download, entry);
+          fileIndex.set(indexedKey, entry);
 
           attachments.push({ type: attType, data: finalData, mimeType: finalMime, filename: file.name, sourcePath: diskPath });
         } catch (err) {
@@ -484,7 +497,7 @@ class SlackChannel implements Channel {
       // Download any file attachments
       let attachments: Attachment[] | undefined;
       if (hasFiles) {
-        attachments = await extractSlackAttachments(msg.files!);
+        attachments = await extractSlackAttachments(msg.files!, roomPrefix(key));
       }
 
       if (!text && (!attachments || attachments.length === 0)) return;
@@ -516,25 +529,20 @@ class SlackChannel implements Channel {
             text = `[Thread context]\n${threadMessages.join("\n")}\n\n[Current message]\n${text}`;
           }
 
-          // Download files from recent thread messages (last 5 messages, max 5 files total)
+          // Download files from fetched thread messages.
           if (!attachments) attachments = [];
-          const threadFileBudget = 5 - attachments.length;
-          if (threadFileBudget > 0) {
-            const messagesWithFiles = priorMessages.filter((m: any) => m.files?.length > 0).slice(-5);
-            let threadFilesAdded = 0;
-            for (const m of messagesWithFiles) {
-              if (threadFilesAdded >= threadFileBudget) break;
-              const extracted = await extractSlackAttachments(m.files || []);
-              for (const att of extracted) {
-                if (threadFilesAdded >= threadFileBudget) break;
-                attachments.push(att);
-                threadFilesAdded++;
-              }
-            }
-            if (threadFilesAdded > 0) {
-              log.info({ threadFiles: threadFilesAdded, channel: msg.channel }, "slack: downloaded thread attachments");
+          const messagesWithFiles = priorMessages.filter((m: any) => m.files?.length > 0);
+          let threadFilesAdded = 0;
+          for (const m of messagesWithFiles) {
+            const extracted = await extractSlackAttachments(m.files || [], roomPrefix(key));
+            for (const att of extracted) {
+              attachments.push(att);
+              threadFilesAdded++;
             }
           }
+          if (threadFilesAdded > 0) {
+            log.info({ threadFiles: threadFilesAdded, channel: msg.channel }, "slack: downloaded thread attachments");
+          }
         } catch (err) {
           log.warn({ err, channel: msg.channel, thread_ts: msg.thread_ts }, "failed to fetch thread context");
         }

package/src/chat/engine.ts

@@ -52,7 +52,7 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
     .map((att, idx) => {
       if (!att.sourcePath) return "";
       const label = att.filename || `${att.type}-${idx + 1}`;
-      return `- ${idx + 1}. ${label} -> ${att.sourcePath}`;
+      return `- ${idx + 1}. ${label} (${att.type}, ${att.mimeType}) -> ${att.sourcePath}`;
     })
     .filter(Boolean);
 
@@ -61,12 +61,14 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
       type: "text",
       text:
         "[Attachment local paths]\n" +
-        "If you need to resend/forward an attachment, call send_message with media_path set to one of these absolute paths.\n" +
+        "Use these absolute paths to inspect attachments. To resend/forward one, call send_message with media_path set to its path.\n" +
         pathHints.join("\n"),
     });
   }
 
   for (const att of attachments) {
+    if (att.sourcePath) continue;
+
     if (att.type === "image") {
       blocks.push({
         type: "image",

package/src/constants/attachment.ts

@@ -1,4 +1,4 @@
-export const MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024; // 10MB
+export const MAX_ATTACHMENT_SIZE = 25 * 1024 * 1024; // 25MB
 
 export const IMAGE_MIMES = new Set([
   "image/jpeg",

package/src/prompts/channel-slack.md

@@ -24,7 +24,7 @@
 ### Reply routing
 - Always reply in the same thread you received the message in. Don't DM someone unless the conversation is already in DMs.
 - `send_message` defaults to your current context (thread if in one, DM if in DM). For escalations, mention the owner in-thread rather than DMing — keeps context where the conversation is.
-- If the user wants a file/image sent, use `send_message` with `media_path`. When a Slack file was attached to the message, use the `[Attachment local paths]` block from context.
+- If the user wants you to inspect or send a file/image, use the absolute paths in the `[Attachment local paths]` block. Use `send_message` with `media_path` when forwarding one.
 
 ### Who's talking
 - Multiple users may message you. Slack messages are prefixed with [user:ID] so you know who's talking (in channels and DMs).

package/src/prompts/environment.md

@@ -43,7 +43,7 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
   - `auto` (default) — replies in the current Slack thread if you're in one, otherwise DMs the owner. This means watch sessions and thread chats reply in-thread by default.
   - `dm` — always DMs the owner, regardless of current context. Use sparingly — prefer @mentioning the owner in-thread to keep context visible.
   - `thread` — explicitly reply in the current thread (same as auto when in a thread, falls back to DM otherwise).
-  For inbound channel files, check the message context for an `[Attachment local paths]` block and reuse those absolute paths when forwarding.
+  For inbound channel files, check the message context for an `[Attachment local paths]` block and use those absolute paths for inspection or forwarding.
 - **list_messages** — read recent chat history
 - **list_sessions** — browse past conversation sessions with previews and message counts. Returns session IDs.
 - **search_messages** — keyword search across all past messages. Find when something was discussed.

package/src/utils/pid.ts

@@ -3,23 +3,50 @@ import { dirname } from "path";
 import { getPaths } from "./paths";
 import { log } from "./log";
 
+type PidEntry = { pid: number; lstart: string };
+
+function getLstart(pid: number): string {
+  try {
+    const result = Bun.spawnSync(["ps", "-o", "lstart=", "-p", String(pid)]);
+    return new TextDecoder().decode(result.stdout).trim();
+  } catch {
+    return "";
+  }
+}
+
 export function writePid(pid: number): void {
   const { pid: pidPath } = getPaths();
+  const lstart = getLstart(pid);
+  if (!lstart) {
+    log.warn({ pid }, "could not capture pid identity (ps returned nothing)");
+  }
   mkdirSync(dirname(pidPath), { recursive: true });
-  writeFileSync(pidPath, String(pid));
+  writeFileSync(pidPath, JSON.stringify({ pid, lstart }));
 }
 
-export function readPid(): number | null {
+function readEntry(): PidEntry | null {
   const { pid: pidPath } = getPaths();
   if (!existsSync(pidPath)) return null;
 
   try {
-    return parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+    const raw = readFileSync(pidPath, "utf8").trim();
+    if (/^\d+$/.test(raw)) {
+      return { pid: parseInt(raw, 10), lstart: "" };
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.pid === "number" && typeof parsed?.lstart === "string") {
+      return parsed as PidEntry;
+    }
+    return null;
   } catch {
     return null;
   }
 }
 
+export function readPid(): number | null {
+  return readEntry()?.pid ?? null;
+}
+
 export function removePid(): void {
   const { pid: pidPath } = getPaths();
   try {
@@ -30,15 +57,22 @@ export function removePid(): void {
 }
 
 export function isRunning(): boolean {
-  const pid = readPid();
-  if (pid === null) return false;
+  const entry = readEntry();
+  if (entry === null) return false;
 
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    log.warn({ stalePid: pid }, "removing stale pid file (process not running)");
+  const currentLstart = getLstart(entry.pid);
+  if (!currentLstart) {
+    log.warn({ stalePid: entry.pid }, "removing stale pid file (process not running)");
+    removePid();
+    return false;
+  }
+  if (entry.lstart && currentLstart !== entry.lstart) {
+    log.warn(
+      { stalePid: entry.pid, recorded: entry.lstart, current: currentLstart },
+      "removing stale pid file (process identity mismatch)",
+    );
     removePid();
     return false;
   }
+  return true;
 }