niahere 0.2.10 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/skills/slack/SKILL.md

@@ -43,7 +43,18 @@ URL format: `https://<workspace>.slack.com/archives/<CHANNEL_ID>/p<THREAD_TS_NO_
 - **Channel ID:** the segment after `/archives/`
 - **Thread TS:** the `p` number with a `.` inserted before the last 6 digits
 
+## Beyond these primitives
+
+These commands cover common operations but the Slack API has 200+ methods. If you need something not listed here (e.g. managing bookmarks, setting channel topics, pinning messages, scheduling messages, managing user groups):
+
+1. **Check `slack.py --help`** for available subcommands first.
+2. **Use the Slack API directly** via `curl` with the bot token from `slack_helper.load_slack_config()["token"]`. The pattern is always: `curl -H "Authorization: Bearer $TOKEN" https://slack.com/api/<method>`.
+3. **Consult the [Slack API docs](https://api.slack.com/methods)** to find the right method and required scopes.
+4. **Compose primitives** to build workflows — "summarize channel" is just `history` + LLM reasoning. "Find discussions about X" is `search` + `thread`.
+
+The bot token and auth pattern are consistent across all Slack APIs. Don't limit yourself to what's explicitly in `slack.py` — treat it as a starting point, not a boundary.
+
 ## Design
 
 Each subcommand = one Slack API call. No bundled workflows.
-Features like "summarize channel" or "find discussions" are agent-level compositions of these primitives.
+Features are outcomes achieved by an agent composing these primitives in a loop.

package/src/cli/channels.ts

@@ -91,6 +91,28 @@ export async function slackCommand(): Promise<void> {
         console.log(`  Workspace: ${config.channels.slack.workspace} (${config.channels.slack.workspace_url})`);
         console.log(`  Bot: @${config.channels.slack.bot_name} (${config.channels.slack.bot_user_id})`);
       }
+      // Verify auth is working
+      try {
+        const resp = await fetch("https://slack.com/api/auth.test", {
+          headers: { Authorization: `Bearer ${config.channels.slack.bot_token}` },
+        });
+        const data = (await resp.json()) as Record<string, unknown>;
+        if (data.ok) {
+          console.log(`  Auth: \u2713 valid`);
+          // Backfill workspace info if missing
+          if (!config.channels.slack.workspace) {
+            const enriched = await enrichSlackConfig(config.channels.slack.bot_token);
+            if (Object.keys(enriched).length > 0) {
+              updateRawConfig({ channels: { slack: enriched } });
+              console.log("  (workspace info backfilled)");
+            }
+          }
+        } else {
+          console.log(`  Auth: \u2717 ${data.error}`);
+        }
+      } catch (err) {
+        console.log(`  Auth: \u2717 could not reach Slack API`);
+      }
     } else {
       console.log("Slack: not configured");
     }

package/src/cli/index.ts

@@ -219,7 +219,7 @@ switch (command) {
   }
 
   case "slack": {
-    slackCommand();
+    await slackCommand();
     break;
   }
 

package/src/cli/status.ts

@@ -7,6 +7,7 @@ import { Message, ActiveEngine, Job } from "../db/models";
 import type { ScheduleType, JobStateStatus, RoomStats } from "../types";
 import { withDb } from "../db/connection";
 import { errMsg } from "../utils/errors";
+import { checkForUpdate } from "../utils/update";
 
 type StatusOptions = {
   json: boolean;
@@ -306,4 +307,13 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
   } else {
     console.log("Tip: use --rooms N, --all, or --json for alternate views.");
   }
+
+  // Check for updates (non-blocking, cached 24h)
+  try {
+    const { version } = await import("../../package.json");
+    const update = await checkForUpdate(version);
+    if (update) {
+      console.log(`\n⚠ Update available: ${update.current} → ${update.latest} (run \`npm i -g niahere\` to update)`);
+    }
+  } catch {}
 }

package/src/core/daemon.ts

@@ -162,6 +162,17 @@ export async function runDaemon(): Promise<void> {
   writePid(process.pid);
   log.info({ pid: process.pid }, "daemon started");
 
+  // Check for updates (non-blocking, logged only)
+  try {
+    const { checkForUpdate } = await import("../utils/update");
+    const { version } = await import("../../package.json");
+    const update = await checkForUpdate(version);
+    if (update) {
+      log.warn({ current: update.current, latest: update.latest }, "update available — run `npm i -g niahere` to update");
+    }
+  } catch {}
+
+
   // Startup recovery
   try {
     await runMigrations();

package/src/utils/update.ts

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+import { getNiaHome } from "./paths";
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const PACKAGE_NAME = "niahere";
+
+type UpdateCache = {
+  latest: string;
+  checkedAt: number;
+};
+
+function cachePath(): string {
+  return resolve(getNiaHome(), "tmp/update-check.json");
+}
+
+function readCache(): UpdateCache | null {
+  const path = cachePath();
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    if (data.latest && data.checkedAt && Date.now() - data.checkedAt < CACHE_TTL_MS) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+
+function writeCache(latest: string): void {
+  const path = cachePath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify({ latest, checkedAt: Date.now() }));
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const resp = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json() as { version?: string };
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function isNewer(latest: string, current: string): boolean {
+  const [la, lb, lc] = latest.split(".").map(Number);
+  const [ca, cb, cc] = current.split(".").map(Number);
+  if (la !== ca) return la > ca;
+  if (lb !== cb) return lb > cb;
+  return lc > cc;
+}
+
+/** Check if a newer version is available. Returns update info or null. Non-blocking, cached 24h. */
+export async function checkForUpdate(currentVersion: string): Promise<{ current: string; latest: string } | null> {
+  const cached = readCache();
+  if (cached) {
+    return isNewer(cached.latest, currentVersion) ? { current: currentVersion, latest: cached.latest } : null;
+  }
+
+  const latest = await fetchLatestVersion();
+  if (!latest) return null;
+
+  writeCache(latest);
+  return isNewer(latest, currentVersion) ? { current: currentVersion, latest } : null;
+}